lib/Target/X86/X86ISelLowering.cpp

   1 //===-- X86ISelLowering.cpp - X86 DAG Lowering Implementation -------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the interfaces that X86 uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "X86ISelLowering.h"
  16 #include "Utils/X86ShuffleDecode.h"
  17 #include "X86CallingConv.h"
  18 #include "X86FrameLowering.h"
  19 #include "X86InstrBuilder.h"
  20 #include "X86MachineFunctionInfo.h"
  21 #include "X86TargetMachine.h"
  22 #include "X86TargetObjectFile.h"
  23 #include "llvm/ADT/SmallBitVector.h"
  24 #include "llvm/ADT/SmallSet.h"
  25 #include "llvm/ADT/Statistic.h"
  26 #include "llvm/ADT/StringExtras.h"
  27 #include "llvm/ADT/StringSwitch.h"
  28 #include "llvm/ADT/VariadicFunction.h"
  29 #include "llvm/CodeGen/IntrinsicLowering.h"
  30 #include "llvm/CodeGen/MachineFrameInfo.h"
  31 #include "llvm/CodeGen/MachineFunction.h"
  32 #include "llvm/CodeGen/MachineInstrBuilder.h"
  33 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  34 #include "llvm/CodeGen/MachineModuleInfo.h"
  35 #include "llvm/CodeGen/MachineRegisterInfo.h"
  36 #include "llvm/IR/CallSite.h"
  37 #include "llvm/IR/CallingConv.h"
  38 #include "llvm/IR/Constants.h"
  39 #include "llvm/IR/DerivedTypes.h"
  40 #include "llvm/IR/Function.h"
  41 #include "llvm/IR/GlobalAlias.h"
  42 #include "llvm/IR/GlobalVariable.h"
  43 #include "llvm/IR/Instructions.h"
  44 #include "llvm/IR/Intrinsics.h"
  45 #include "llvm/MC/MCAsmInfo.h"
  46 #include "llvm/MC/MCContext.h"
  47 #include "llvm/MC/MCExpr.h"
  48 #include "llvm/MC/MCSymbol.h"
  49 #include "llvm/Support/CommandLine.h"
  50 #include "llvm/Support/Debug.h"
  51 #include "llvm/Support/ErrorHandling.h"
  52 #include "llvm/Support/MathExtras.h"
  53 #include "llvm/Target/TargetOptions.h"
  54 #include "X86IntrinsicsInfo.h"
  55 #include <bitset>
  56 #include <numeric>
  57 #include <cctype>
  58 using namespace llvm;
  59
  60 #define DEBUG_TYPE "x86-isel"
  61
  62 STATISTIC(NumTailCalls, "Number of tail calls");
  63
  64 static cl::opt<bool> ExperimentalVectorWideningLegalization(
  65     "x86-experimental-vector-widening-legalization", cl::init(false),
  66     cl::desc("Enable an experimental vector type legalization through widening "
  67              "rather than promotion."),
  68     cl::Hidden);
  69
  70 static cl::opt<bool> ExperimentalVectorShuffleLowering(
  71     "x86-experimental-vector-shuffle-lowering", cl::init(true),
  72     cl::desc("Enable an experimental vector shuffle lowering code path."),
  73     cl::Hidden);
  74
  75 static cl::opt<bool> ExperimentalVectorShuffleLegality(
  76     "x86-experimental-vector-shuffle-legality", cl::init(false),
  77     cl::desc("Enable experimental shuffle legality based on the experimental "
  78              "shuffle lowering. Should only be used with the experimental "
  79              "shuffle lowering."),
  80     cl::Hidden);
  81
  82 static cl::opt<int> ReciprocalEstimateRefinementSteps(
  83     "x86-recip-refinement-steps", cl::init(1),
  84     cl::desc("Specify the number of Newton-Raphson iterations applied to the "
  85              "result of the hardware reciprocal estimate instruction."),
  86     cl::NotHidden);
  87
  88 // Forward declarations.
  89 static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1,
  90                        SDValue V2);
  91
  92 static SDValue ExtractSubVector(SDValue Vec, unsigned IdxVal,
  93                                 SelectionDAG &DAG, SDLoc dl,
  94                                 unsigned vectorWidth) {
  95   assert((vectorWidth == 128 || vectorWidth == 256) &&
  96          "Unsupported vector width");
  97   EVT VT = Vec.getValueType();
  98   EVT ElVT = VT.getVectorElementType();
  99   unsigned Factor = VT.getSizeInBits()/vectorWidth;
 100   EVT ResultVT = EVT::getVectorVT(*DAG.getContext(), ElVT,
 101                                   VT.getVectorNumElements()/Factor);
 102
 103   // Extract from UNDEF is UNDEF.
 104   if (Vec.getOpcode() == ISD::UNDEF)
 105     return DAG.getUNDEF(ResultVT);
 106
 107   // Extract the relevant vectorWidth bits.  Generate an EXTRACT_SUBVECTOR
 108   unsigned ElemsPerChunk = vectorWidth / ElVT.getSizeInBits();
 109
 110   // This is the index of the first element of the vectorWidth-bit chunk
 111   // we want.
 112   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits()) / vectorWidth)
 113                                * ElemsPerChunk);
 114
 115   // If the input is a buildvector just emit a smaller one.
 116   if (Vec.getOpcode() == ISD::BUILD_VECTOR)
 117     return DAG.getNode(ISD::BUILD_VECTOR, dl, ResultVT,
 118                        makeArrayRef(Vec->op_begin() + NormalizedIdxVal,
 119                                     ElemsPerChunk));
 120
 121   SDValue VecIdx = DAG.getIntPtrConstant(NormalizedIdxVal);
 122   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec, VecIdx);
 123 }
 124
 125 /// Generate a DAG to grab 128-bits from a vector > 128 bits.  This
 126 /// sets things up to match to an AVX VEXTRACTF128 / VEXTRACTI128
 127 /// or AVX-512 VEXTRACTF32x4 / VEXTRACTI32x4
 128 /// instructions or a simple subregister reference. Idx is an index in the
 129 /// 128 bits we want.  It need not be aligned to a 128-bit boundary.  That makes
 130 /// lowering EXTRACT_VECTOR_ELT operations easier.
 131 static SDValue Extract128BitVector(SDValue Vec, unsigned IdxVal,
 132                                    SelectionDAG &DAG, SDLoc dl) {
 133   assert((Vec.getValueType().is256BitVector() ||
 134           Vec.getValueType().is512BitVector()) && "Unexpected vector size!");
 135   return ExtractSubVector(Vec, IdxVal, DAG, dl, 128);
 136 }
 137
 138 /// Generate a DAG to grab 256-bits from a 512-bit vector.
 139 static SDValue Extract256BitVector(SDValue Vec, unsigned IdxVal,
 140                                    SelectionDAG &DAG, SDLoc dl) {
 141   assert(Vec.getValueType().is512BitVector() && "Unexpected vector size!");
 142   return ExtractSubVector(Vec, IdxVal, DAG, dl, 256);
 143 }
 144
 145 static SDValue InsertSubVector(SDValue Result, SDValue Vec,
 146                                unsigned IdxVal, SelectionDAG &DAG,
 147                                SDLoc dl, unsigned vectorWidth) {
 148   assert((vectorWidth == 128 || vectorWidth == 256) &&
 149          "Unsupported vector width");
 150   // Inserting UNDEF is Result
 151   if (Vec.getOpcode() == ISD::UNDEF)
 152     return Result;
 153   EVT VT = Vec.getValueType();
 154   EVT ElVT = VT.getVectorElementType();
 155   EVT ResultVT = Result.getValueType();
 156
 157   // Insert the relevant vectorWidth bits.
 158   unsigned ElemsPerChunk = vectorWidth/ElVT.getSizeInBits();
 159
 160   // This is the index of the first element of the vectorWidth-bit chunk
 161   // we want.
 162   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits())/vectorWidth)
 163                                * ElemsPerChunk);
 164
 165   SDValue VecIdx = DAG.getIntPtrConstant(NormalizedIdxVal);
 166   return DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec, VecIdx);
 167 }
 168
 169 /// Generate a DAG to put 128-bits into a vector > 128 bits.  This
 170 /// sets things up to match to an AVX VINSERTF128/VINSERTI128 or
 171 /// AVX-512 VINSERTF32x4/VINSERTI32x4 instructions or a
 172 /// simple superregister reference.  Idx is an index in the 128 bits
 173 /// we want.  It need not be aligned to a 128-bit boundary.  That makes
 174 /// lowering INSERT_VECTOR_ELT operations easier.
 175 static SDValue Insert128BitVector(SDValue Result, SDValue Vec, unsigned IdxVal,
 176                                   SelectionDAG &DAG,SDLoc dl) {
 177   assert(Vec.getValueType().is128BitVector() && "Unexpected vector size!");
 178   return InsertSubVector(Result, Vec, IdxVal, DAG, dl, 128);
 179 }
 180
 181 static SDValue Insert256BitVector(SDValue Result, SDValue Vec, unsigned IdxVal,
 182                                   SelectionDAG &DAG, SDLoc dl) {
 183   assert(Vec.getValueType().is256BitVector() && "Unexpected vector size!");
 184   return InsertSubVector(Result, Vec, IdxVal, DAG, dl, 256);
 185 }
 186
 187 /// Concat two 128-bit vectors into a 256 bit vector using VINSERTF128
 188 /// instructions. This is used because creating CONCAT_VECTOR nodes of
 189 /// BUILD_VECTORS returns a larger BUILD_VECTOR while we're trying to lower
 190 /// large BUILD_VECTORS.
 191 static SDValue Concat128BitVectors(SDValue V1, SDValue V2, EVT VT,
 192                                    unsigned NumElems, SelectionDAG &DAG,
 193                                    SDLoc dl) {
 194   SDValue V = Insert128BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
 195   return Insert128BitVector(V, V2, NumElems/2, DAG, dl);
 196 }
 197
 198 static SDValue Concat256BitVectors(SDValue V1, SDValue V2, EVT VT,
 199                                    unsigned NumElems, SelectionDAG &DAG,
 200                                    SDLoc dl) {
 201   SDValue V = Insert256BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
 202   return Insert256BitVector(V, V2, NumElems/2, DAG, dl);
 203 }
 204
 205 X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM,
 206                                      const X86Subtarget &STI)
 207     : TargetLowering(TM), Subtarget(&STI) {
 208   X86ScalarSSEf64 = Subtarget->hasSSE2();
 209   X86ScalarSSEf32 = Subtarget->hasSSE1();
 210   TD = getDataLayout();
 211
 212   // Set up the TargetLowering object.
 213   static const MVT IntVTs[] = { MVT::i8, MVT::i16, MVT::i32, MVT::i64 };
 214
 215   // X86 is weird. It always uses i8 for shift amounts and setcc results.
 216   setBooleanContents(ZeroOrOneBooleanContent);
 217   // X86-SSE is even stranger. It uses -1 or 0 for vector masks.
 218   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
 219
 220   // For 64-bit, since we have so many registers, use the ILP scheduler.
 221   // For 32-bit, use the register pressure specific scheduling.
 222   // For Atom, always use ILP scheduling.
 223   if (Subtarget->isAtom())
 224     setSchedulingPreference(Sched::ILP);
 225   else if (Subtarget->is64Bit())
 226     setSchedulingPreference(Sched::ILP);
 227   else
 228     setSchedulingPreference(Sched::RegPressure);
 229   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
 230   setStackPointerRegisterToSaveRestore(RegInfo->getStackRegister());
 231
 232   // Bypass expensive divides on Atom when compiling with O2.
 233   if (TM.getOptLevel() >= CodeGenOpt::Default) {
 234     if (Subtarget->hasSlowDivide32())
 235       addBypassSlowDiv(32, 8);
 236     if (Subtarget->hasSlowDivide64() && Subtarget->is64Bit())
 237       addBypassSlowDiv(64, 16);
 238   }
 239
 240   if (Subtarget->isTargetKnownWindowsMSVC()) {
 241     // Setup Windows compiler runtime calls.
 242     setLibcallName(RTLIB::SDIV_I64, "_alldiv");
 243     setLibcallName(RTLIB::UDIV_I64, "_aulldiv");
 244     setLibcallName(RTLIB::SREM_I64, "_allrem");
 245     setLibcallName(RTLIB::UREM_I64, "_aullrem");
 246     setLibcallName(RTLIB::MUL_I64, "_allmul");
 247     setLibcallCallingConv(RTLIB::SDIV_I64, CallingConv::X86_StdCall);
 248     setLibcallCallingConv(RTLIB::UDIV_I64, CallingConv::X86_StdCall);
 249     setLibcallCallingConv(RTLIB::SREM_I64, CallingConv::X86_StdCall);
 250     setLibcallCallingConv(RTLIB::UREM_I64, CallingConv::X86_StdCall);
 251     setLibcallCallingConv(RTLIB::MUL_I64, CallingConv::X86_StdCall);
 252
 253     // The _ftol2 runtime function has an unusual calling conv, which
 254     // is modeled by a special pseudo-instruction.
 255     setLibcallName(RTLIB::FPTOUINT_F64_I64, nullptr);
 256     setLibcallName(RTLIB::FPTOUINT_F32_I64, nullptr);
 257     setLibcallName(RTLIB::FPTOUINT_F64_I32, nullptr);
 258     setLibcallName(RTLIB::FPTOUINT_F32_I32, nullptr);
 259   }
 260
 261   if (Subtarget->isTargetDarwin()) {
 262     // Darwin should use _setjmp/_longjmp instead of setjmp/longjmp.
 263     setUseUnderscoreSetJmp(false);
 264     setUseUnderscoreLongJmp(false);
 265   } else if (Subtarget->isTargetWindowsGNU()) {
 266     // MS runtime is weird: it exports _setjmp, but longjmp!
 267     setUseUnderscoreSetJmp(true);
 268     setUseUnderscoreLongJmp(false);
 269   } else {
 270     setUseUnderscoreSetJmp(true);
 271     setUseUnderscoreLongJmp(true);
 272   }
 273
 274   // Set up the register classes.
 275   addRegisterClass(MVT::i8, &X86::GR8RegClass);
 276   addRegisterClass(MVT::i16, &X86::GR16RegClass);
 277   addRegisterClass(MVT::i32, &X86::GR32RegClass);
 278   if (Subtarget->is64Bit())
 279     addRegisterClass(MVT::i64, &X86::GR64RegClass);
 280
 281   for (MVT VT : MVT::integer_valuetypes())
 282     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
 283
 284   // We don't accept any truncstore of integer registers.
 285   setTruncStoreAction(MVT::i64, MVT::i32, Expand);
 286   setTruncStoreAction(MVT::i64, MVT::i16, Expand);
 287   setTruncStoreAction(MVT::i64, MVT::i8 , Expand);
 288   setTruncStoreAction(MVT::i32, MVT::i16, Expand);
 289   setTruncStoreAction(MVT::i32, MVT::i8 , Expand);
 290   setTruncStoreAction(MVT::i16, MVT::i8,  Expand);
 291
 292   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
 293
 294   // SETOEQ and SETUNE require checking two conditions.
 295   setCondCodeAction(ISD::SETOEQ, MVT::f32, Expand);
 296   setCondCodeAction(ISD::SETOEQ, MVT::f64, Expand);
 297   setCondCodeAction(ISD::SETOEQ, MVT::f80, Expand);
 298   setCondCodeAction(ISD::SETUNE, MVT::f32, Expand);
 299   setCondCodeAction(ISD::SETUNE, MVT::f64, Expand);
 300   setCondCodeAction(ISD::SETUNE, MVT::f80, Expand);
 301
 302   // Promote all UINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have this
 303   // operation.
 304   setOperationAction(ISD::UINT_TO_FP       , MVT::i1   , Promote);
 305   setOperationAction(ISD::UINT_TO_FP       , MVT::i8   , Promote);
 306   setOperationAction(ISD::UINT_TO_FP       , MVT::i16  , Promote);
 307
 308   if (Subtarget->is64Bit()) {
 309     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Promote);
 310     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
 311   } else if (!TM.Options.UseSoftFloat) {
 312     // We have an algorithm for SSE2->double, and we turn this into a
 313     // 64-bit FILD followed by conditional FADD for other targets.
 314     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
 315     // We have an algorithm for SSE2, and we turn this into a 64-bit
 316     // FILD for other targets.
 317     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Custom);
 318   }
 319
 320   // Promote i1/i8 SINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have
 321   // this operation.
 322   setOperationAction(ISD::SINT_TO_FP       , MVT::i1   , Promote);
 323   setOperationAction(ISD::SINT_TO_FP       , MVT::i8   , Promote);
 324
 325   if (!TM.Options.UseSoftFloat) {
 326     // SSE has no i16 to fp conversion, only i32
 327     if (X86ScalarSSEf32) {
 328       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 329       // f32 and f64 cases are Legal, f80 case is not
 330       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 331     } else {
 332       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Custom);
 333       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 334     }
 335   } else {
 336     setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 337     setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Promote);
 338   }
 339
 340   // In 32-bit mode these are custom lowered.  In 64-bit mode F32 and F64
 341   // are Legal, f80 is custom lowered.
 342   setOperationAction(ISD::FP_TO_SINT     , MVT::i64  , Custom);
 343   setOperationAction(ISD::SINT_TO_FP     , MVT::i64  , Custom);
 344
 345   // Promote i1/i8 FP_TO_SINT to larger FP_TO_SINTS's, as X86 doesn't have
 346   // this operation.
 347   setOperationAction(ISD::FP_TO_SINT       , MVT::i1   , Promote);
 348   setOperationAction(ISD::FP_TO_SINT       , MVT::i8   , Promote);
 349
 350   if (X86ScalarSSEf32) {
 351     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Promote);
 352     // f32 and f64 cases are Legal, f80 case is not
 353     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 354   } else {
 355     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Custom);
 356     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 357   }
 358
 359   // Handle FP_TO_UINT by promoting the destination to a larger signed
 360   // conversion.
 361   setOperationAction(ISD::FP_TO_UINT       , MVT::i1   , Promote);
 362   setOperationAction(ISD::FP_TO_UINT       , MVT::i8   , Promote);
 363   setOperationAction(ISD::FP_TO_UINT       , MVT::i16  , Promote);
 364
 365   if (Subtarget->is64Bit()) {
 366     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Expand);
 367     setOperationAction(ISD::FP_TO_UINT     , MVT::i32  , Promote);
 368   } else if (!TM.Options.UseSoftFloat) {
 369     // Since AVX is a superset of SSE3, only check for SSE here.
 370     if (Subtarget->hasSSE1() && !Subtarget->hasSSE3())
 371       // Expand FP_TO_UINT into a select.
 372       // FIXME: We would like to use a Custom expander here eventually to do
 373       // the optimal thing for SSE vs. the default expansion in the legalizer.
 374       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Expand);
 375     else
 376       // With SSE3 we can use fisttpll to convert to a signed i64; without
 377       // SSE, we're stuck with a fistpll.
 378       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Custom);
 379   }
 380
 381   if (isTargetFTOL()) {
 382     // Use the _ftol2 runtime function, which has a pseudo-instruction
 383     // to handle its weird calling convention.
 384     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Custom);
 385   }
 386
 387   // TODO: when we have SSE, these could be more efficient, by using movd/movq.
 388   if (!X86ScalarSSEf64) {
 389     setOperationAction(ISD::BITCAST        , MVT::f32  , Expand);
 390     setOperationAction(ISD::BITCAST        , MVT::i32  , Expand);
 391     if (Subtarget->is64Bit()) {
 392       setOperationAction(ISD::BITCAST      , MVT::f64  , Expand);
 393       // Without SSE, i64->f64 goes through memory.
 394       setOperationAction(ISD::BITCAST      , MVT::i64  , Expand);
 395     }
 396   }
 397
 398   // Scalar integer divide and remainder are lowered to use operations that
 399   // produce two results, to match the available instructions. This exposes
 400   // the two-result form to trivial CSE, which is able to combine x/y and x%y
 401   // into a single instruction.
 402   //
 403   // Scalar integer multiply-high is also lowered to use two-result
 404   // operations, to match the available instructions. However, plain multiply
 405   // (low) operations are left as Legal, as there are single-result
 406   // instructions for this in x86. Using the two-result multiply instructions
 407   // when both high and low results are needed must be arranged by dagcombine.
 408   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
 409     MVT VT = IntVTs[i];
 410     setOperationAction(ISD::MULHS, VT, Expand);
 411     setOperationAction(ISD::MULHU, VT, Expand);
 412     setOperationAction(ISD::SDIV, VT, Expand);
 413     setOperationAction(ISD::UDIV, VT, Expand);
 414     setOperationAction(ISD::SREM, VT, Expand);
 415     setOperationAction(ISD::UREM, VT, Expand);
 416
 417     // Add/Sub overflow ops with MVT::Glues are lowered to EFLAGS dependences.
 418     setOperationAction(ISD::ADDC, VT, Custom);
 419     setOperationAction(ISD::ADDE, VT, Custom);
 420     setOperationAction(ISD::SUBC, VT, Custom);
 421     setOperationAction(ISD::SUBE, VT, Custom);
 422   }
 423
 424   setOperationAction(ISD::BR_JT            , MVT::Other, Expand);
 425   setOperationAction(ISD::BRCOND           , MVT::Other, Custom);
 426   setOperationAction(ISD::BR_CC            , MVT::f32,   Expand);
 427   setOperationAction(ISD::BR_CC            , MVT::f64,   Expand);
 428   setOperationAction(ISD::BR_CC            , MVT::f80,   Expand);
 429   setOperationAction(ISD::BR_CC            , MVT::i8,    Expand);
 430   setOperationAction(ISD::BR_CC            , MVT::i16,   Expand);
 431   setOperationAction(ISD::BR_CC            , MVT::i32,   Expand);
 432   setOperationAction(ISD::BR_CC            , MVT::i64,   Expand);
 433   setOperationAction(ISD::SELECT_CC        , MVT::f32,   Expand);
 434   setOperationAction(ISD::SELECT_CC        , MVT::f64,   Expand);
 435   setOperationAction(ISD::SELECT_CC        , MVT::f80,   Expand);
 436   setOperationAction(ISD::SELECT_CC        , MVT::i8,    Expand);
 437   setOperationAction(ISD::SELECT_CC        , MVT::i16,   Expand);
 438   setOperationAction(ISD::SELECT_CC        , MVT::i32,   Expand);
 439   setOperationAction(ISD::SELECT_CC        , MVT::i64,   Expand);
 440   if (Subtarget->is64Bit())
 441     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i32, Legal);
 442   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16  , Legal);
 443   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8   , Legal);
 444   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1   , Expand);
 445   setOperationAction(ISD::FP_ROUND_INREG   , MVT::f32  , Expand);
 446   setOperationAction(ISD::FREM             , MVT::f32  , Expand);
 447   setOperationAction(ISD::FREM             , MVT::f64  , Expand);
 448   setOperationAction(ISD::FREM             , MVT::f80  , Expand);
 449   setOperationAction(ISD::FLT_ROUNDS_      , MVT::i32  , Custom);
 450
 451   // Promote the i8 variants and force them on up to i32 which has a shorter
 452   // encoding.
 453   setOperationAction(ISD::CTTZ             , MVT::i8   , Promote);
 454   AddPromotedToType (ISD::CTTZ             , MVT::i8   , MVT::i32);
 455   setOperationAction(ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , Promote);
 456   AddPromotedToType (ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , MVT::i32);
 457   if (Subtarget->hasBMI()) {
 458     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i16  , Expand);
 459     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i32  , Expand);
 460     if (Subtarget->is64Bit())
 461       setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i64, Expand);
 462   } else {
 463     setOperationAction(ISD::CTTZ           , MVT::i16  , Custom);
 464     setOperationAction(ISD::CTTZ           , MVT::i32  , Custom);
 465     if (Subtarget->is64Bit())
 466       setOperationAction(ISD::CTTZ         , MVT::i64  , Custom);
 467   }
 468
 469   if (Subtarget->hasLZCNT()) {
 470     // When promoting the i8 variants, force them to i32 for a shorter
 471     // encoding.
 472     setOperationAction(ISD::CTLZ           , MVT::i8   , Promote);
 473     AddPromotedToType (ISD::CTLZ           , MVT::i8   , MVT::i32);
 474     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Promote);
 475     AddPromotedToType (ISD::CTLZ_ZERO_UNDEF, MVT::i8   , MVT::i32);
 476     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Expand);
 477     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Expand);
 478     if (Subtarget->is64Bit())
 479       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Expand);
 480   } else {
 481     setOperationAction(ISD::CTLZ           , MVT::i8   , Custom);
 482     setOperationAction(ISD::CTLZ           , MVT::i16  , Custom);
 483     setOperationAction(ISD::CTLZ           , MVT::i32  , Custom);
 484     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Custom);
 485     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Custom);
 486     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Custom);
 487     if (Subtarget->is64Bit()) {
 488       setOperationAction(ISD::CTLZ         , MVT::i64  , Custom);
 489       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Custom);
 490     }
 491   }
 492
 493   // Special handling for half-precision floating point conversions.
 494   // If we don't have F16C support, then lower half float conversions
 495   // into library calls.
 496   if (TM.Options.UseSoftFloat || !Subtarget->hasF16C()) {
 497     setOperationAction(ISD::FP16_TO_FP, MVT::f32, Expand);
 498     setOperationAction(ISD::FP_TO_FP16, MVT::f32, Expand);
 499   }
 500
 501   // There's never any support for operations beyond MVT::f32.
 502   setOperationAction(ISD::FP16_TO_FP, MVT::f64, Expand);
 503   setOperationAction(ISD::FP16_TO_FP, MVT::f80, Expand);
 504   setOperationAction(ISD::FP_TO_FP16, MVT::f64, Expand);
 505   setOperationAction(ISD::FP_TO_FP16, MVT::f80, Expand);
 506
 507   setLoadExtAction(ISD::EXTLOAD, MVT::f32, MVT::f16, Expand);
 508   setLoadExtAction(ISD::EXTLOAD, MVT::f64, MVT::f16, Expand);
 509   setLoadExtAction(ISD::EXTLOAD, MVT::f80, MVT::f16, Expand);
 510   setTruncStoreAction(MVT::f32, MVT::f16, Expand);
 511   setTruncStoreAction(MVT::f64, MVT::f16, Expand);
 512   setTruncStoreAction(MVT::f80, MVT::f16, Expand);
 513
 514   if (Subtarget->hasPOPCNT()) {
 515     setOperationAction(ISD::CTPOP          , MVT::i8   , Promote);
 516   } else {
 517     setOperationAction(ISD::CTPOP          , MVT::i8   , Expand);
 518     setOperationAction(ISD::CTPOP          , MVT::i16  , Expand);
 519     setOperationAction(ISD::CTPOP          , MVT::i32  , Expand);
 520     if (Subtarget->is64Bit())
 521       setOperationAction(ISD::CTPOP        , MVT::i64  , Expand);
 522   }
 523
 524   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
 525
 526   if (!Subtarget->hasMOVBE())
 527     setOperationAction(ISD::BSWAP          , MVT::i16  , Expand);
 528
 529   // These should be promoted to a larger select which is supported.
 530   setOperationAction(ISD::SELECT          , MVT::i1   , Promote);
 531   // X86 wants to expand cmov itself.
 532   setOperationAction(ISD::SELECT          , MVT::i8   , Custom);
 533   setOperationAction(ISD::SELECT          , MVT::i16  , Custom);
 534   setOperationAction(ISD::SELECT          , MVT::i32  , Custom);
 535   setOperationAction(ISD::SELECT          , MVT::f32  , Custom);
 536   setOperationAction(ISD::SELECT          , MVT::f64  , Custom);
 537   setOperationAction(ISD::SELECT          , MVT::f80  , Custom);
 538   setOperationAction(ISD::SETCC           , MVT::i8   , Custom);
 539   setOperationAction(ISD::SETCC           , MVT::i16  , Custom);
 540   setOperationAction(ISD::SETCC           , MVT::i32  , Custom);
 541   setOperationAction(ISD::SETCC           , MVT::f32  , Custom);
 542   setOperationAction(ISD::SETCC           , MVT::f64  , Custom);
 543   setOperationAction(ISD::SETCC           , MVT::f80  , Custom);
 544   if (Subtarget->is64Bit()) {
 545     setOperationAction(ISD::SELECT        , MVT::i64  , Custom);
 546     setOperationAction(ISD::SETCC         , MVT::i64  , Custom);
 547   }
 548   setOperationAction(ISD::EH_RETURN       , MVT::Other, Custom);
 549   // NOTE: EH_SJLJ_SETJMP/_LONGJMP supported here is NOT intended to support
 550   // SjLj exception handling but a light-weight setjmp/longjmp replacement to
 551   // support continuation, user-level threading, and etc.. As a result, no
 552   // other SjLj exception interfaces are implemented and please don't build
 553   // your own exception handling based on them.
 554   // LLVM/Clang supports zero-cost DWARF exception handling.
 555   setOperationAction(ISD::EH_SJLJ_SETJMP, MVT::i32, Custom);
 556   setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
 557
 558   // Darwin ABI issue.
 559   setOperationAction(ISD::ConstantPool    , MVT::i32  , Custom);
 560   setOperationAction(ISD::JumpTable       , MVT::i32  , Custom);
 561   setOperationAction(ISD::GlobalAddress   , MVT::i32  , Custom);
 562   setOperationAction(ISD::GlobalTLSAddress, MVT::i32  , Custom);
 563   if (Subtarget->is64Bit())
 564     setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
 565   setOperationAction(ISD::ExternalSymbol  , MVT::i32  , Custom);
 566   setOperationAction(ISD::BlockAddress    , MVT::i32  , Custom);
 567   if (Subtarget->is64Bit()) {
 568     setOperationAction(ISD::ConstantPool  , MVT::i64  , Custom);
 569     setOperationAction(ISD::JumpTable     , MVT::i64  , Custom);
 570     setOperationAction(ISD::GlobalAddress , MVT::i64  , Custom);
 571     setOperationAction(ISD::ExternalSymbol, MVT::i64  , Custom);
 572     setOperationAction(ISD::BlockAddress  , MVT::i64  , Custom);
 573   }
 574   // 64-bit addm sub, shl, sra, srl (iff 32-bit x86)
 575   setOperationAction(ISD::SHL_PARTS       , MVT::i32  , Custom);
 576   setOperationAction(ISD::SRA_PARTS       , MVT::i32  , Custom);
 577   setOperationAction(ISD::SRL_PARTS       , MVT::i32  , Custom);
 578   if (Subtarget->is64Bit()) {
 579     setOperationAction(ISD::SHL_PARTS     , MVT::i64  , Custom);
 580     setOperationAction(ISD::SRA_PARTS     , MVT::i64  , Custom);
 581     setOperationAction(ISD::SRL_PARTS     , MVT::i64  , Custom);
 582   }
 583
 584   if (Subtarget->hasSSE1())
 585     setOperationAction(ISD::PREFETCH      , MVT::Other, Legal);
 586
 587   setOperationAction(ISD::ATOMIC_FENCE  , MVT::Other, Custom);
 588
 589   // Expand certain atomics
 590   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
 591     MVT VT = IntVTs[i];
 592     setOperationAction(ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, VT, Custom);
 593     setOperationAction(ISD::ATOMIC_LOAD_SUB, VT, Custom);
 594     setOperationAction(ISD::ATOMIC_STORE, VT, Custom);
 595   }
 596
 597   if (Subtarget->hasCmpxchg16b()) {
 598     setOperationAction(ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, MVT::i128, Custom);
 599   }
 600
 601   // FIXME - use subtarget debug flags
 602   if (!Subtarget->isTargetDarwin() && !Subtarget->isTargetELF() &&
 603       !Subtarget->isTargetCygMing() && !Subtarget->isTargetWin64()) {
 604     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
 605   }
 606
 607   if (Subtarget->is64Bit()) {
 608     setExceptionPointerRegister(X86::RAX);
 609     setExceptionSelectorRegister(X86::RDX);
 610   } else {
 611     setExceptionPointerRegister(X86::EAX);
 612     setExceptionSelectorRegister(X86::EDX);
 613   }
 614   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i32, Custom);
 615   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i64, Custom);
 616
 617   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
 618   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
 619
 620   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 621   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Legal);
 622
 623   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
 624   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
 625   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
 626   if (Subtarget->is64Bit() && !Subtarget->isTargetWin64()) {
 627     // TargetInfo::X86_64ABIBuiltinVaList
 628     setOperationAction(ISD::VAARG           , MVT::Other, Custom);
 629     setOperationAction(ISD::VACOPY          , MVT::Other, Custom);
 630   } else {
 631     // TargetInfo::CharPtrBuiltinVaList
 632     setOperationAction(ISD::VAARG           , MVT::Other, Expand);
 633     setOperationAction(ISD::VACOPY          , MVT::Other, Expand);
 634   }
 635
 636   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
 637   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
 638
 639   setOperationAction(ISD::DYNAMIC_STACKALLOC, getPointerTy(), Custom);
 640
 641   if (!TM.Options.UseSoftFloat && X86ScalarSSEf64) {
 642     // f32 and f64 use SSE.
 643     // Set up the FP register classes.
 644     addRegisterClass(MVT::f32, &X86::FR32RegClass);
 645     addRegisterClass(MVT::f64, &X86::FR64RegClass);
 646
 647     // Use ANDPD to simulate FABS.
 648     setOperationAction(ISD::FABS , MVT::f64, Custom);
 649     setOperationAction(ISD::FABS , MVT::f32, Custom);
 650
 651     // Use XORP to simulate FNEG.
 652     setOperationAction(ISD::FNEG , MVT::f64, Custom);
 653     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 654
 655     // Use ANDPD and ORPD to simulate FCOPYSIGN.
 656     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
 657     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 658
 659     // Lower this to FGETSIGNx86 plus an AND.
 660     setOperationAction(ISD::FGETSIGN, MVT::i64, Custom);
 661     setOperationAction(ISD::FGETSIGN, MVT::i32, Custom);
 662
 663     // We don't support sin/cos/fmod
 664     setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 665     setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 666     setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 667     setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 668     setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 669     setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 670
 671     // Expand FP immediates into loads from the stack, except for the special
 672     // cases we handle.
 673     addLegalFPImmediate(APFloat(+0.0)); // xorpd
 674     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 675   } else if (!TM.Options.UseSoftFloat && X86ScalarSSEf32) {
 676     // Use SSE for f32, x87 for f64.
 677     // Set up the FP register classes.
 678     addRegisterClass(MVT::f32, &X86::FR32RegClass);
 679     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
 680
 681     // Use ANDPS to simulate FABS.
 682     setOperationAction(ISD::FABS , MVT::f32, Custom);
 683
 684     // Use XORP to simulate FNEG.
 685     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 686
 687     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 688
 689     // Use ANDPS and ORPS to simulate FCOPYSIGN.
 690     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 691     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 692
 693     // We don't support sin/cos/fmod
 694     setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 695     setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 696     setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 697
 698     // Special cases we handle for FP constants.
 699     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 700     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 701     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 702     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 703     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 704
 705     if (!TM.Options.UnsafeFPMath) {
 706       setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 707       setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 708       setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 709     }
 710   } else if (!TM.Options.UseSoftFloat) {
 711     // f32 and f64 in x87.
 712     // Set up the FP register classes.
 713     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
 714     addRegisterClass(MVT::f32, &X86::RFP32RegClass);
 715
 716     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 717     setOperationAction(ISD::UNDEF,     MVT::f32, Expand);
 718     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 719     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
 720
 721     if (!TM.Options.UnsafeFPMath) {
 722       setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 723       setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 724       setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 725       setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 726       setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 727       setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 728     }
 729     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 730     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 731     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 732     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 733     addLegalFPImmediate(APFloat(+0.0f)); // FLD0
 734     addLegalFPImmediate(APFloat(+1.0f)); // FLD1
 735     addLegalFPImmediate(APFloat(-0.0f)); // FLD0/FCHS
 736     addLegalFPImmediate(APFloat(-1.0f)); // FLD1/FCHS
 737   }
 738
 739   // We don't support FMA.
 740   setOperationAction(ISD::FMA, MVT::f64, Expand);
 741   setOperationAction(ISD::FMA, MVT::f32, Expand);
 742
 743   // Long double always uses X87.
 744   if (!TM.Options.UseSoftFloat) {
 745     addRegisterClass(MVT::f80, &X86::RFP80RegClass);
 746     setOperationAction(ISD::UNDEF,     MVT::f80, Expand);
 747     setOperationAction(ISD::FCOPYSIGN, MVT::f80, Expand);
 748     {
 749       APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended);
 750       addLegalFPImmediate(TmpFlt);  // FLD0
 751       TmpFlt.changeSign();
 752       addLegalFPImmediate(TmpFlt);  // FLD0/FCHS
 753
 754       bool ignored;
 755       APFloat TmpFlt2(+1.0);
 756       TmpFlt2.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
 757                       &ignored);
 758       addLegalFPImmediate(TmpFlt2);  // FLD1
 759       TmpFlt2.changeSign();
 760       addLegalFPImmediate(TmpFlt2);  // FLD1/FCHS
 761     }
 762
 763     if (!TM.Options.UnsafeFPMath) {
 764       setOperationAction(ISD::FSIN   , MVT::f80, Expand);
 765       setOperationAction(ISD::FCOS   , MVT::f80, Expand);
 766       setOperationAction(ISD::FSINCOS, MVT::f80, Expand);
 767     }
 768
 769     setOperationAction(ISD::FFLOOR, MVT::f80, Expand);
 770     setOperationAction(ISD::FCEIL,  MVT::f80, Expand);
 771     setOperationAction(ISD::FTRUNC, MVT::f80, Expand);
 772     setOperationAction(ISD::FRINT,  MVT::f80, Expand);
 773     setOperationAction(ISD::FNEARBYINT, MVT::f80, Expand);
 774     setOperationAction(ISD::FMA, MVT::f80, Expand);
 775   }
 776
 777   // Always use a library call for pow.
 778   setOperationAction(ISD::FPOW             , MVT::f32  , Expand);
 779   setOperationAction(ISD::FPOW             , MVT::f64  , Expand);
 780   setOperationAction(ISD::FPOW             , MVT::f80  , Expand);
 781
 782   setOperationAction(ISD::FLOG, MVT::f80, Expand);
 783   setOperationAction(ISD::FLOG2, MVT::f80, Expand);
 784   setOperationAction(ISD::FLOG10, MVT::f80, Expand);
 785   setOperationAction(ISD::FEXP, MVT::f80, Expand);
 786   setOperationAction(ISD::FEXP2, MVT::f80, Expand);
 787   setOperationAction(ISD::FMINNUM, MVT::f80, Expand);
 788   setOperationAction(ISD::FMAXNUM, MVT::f80, Expand);
 789
 790   // First set operation action for all vector types to either promote
 791   // (for widening) or expand (for scalarization). Then we will selectively
 792   // turn on ones that can be effectively codegen'd.
 793   for (MVT VT : MVT::vector_valuetypes()) {
 794     setOperationAction(ISD::ADD , VT, Expand);
 795     setOperationAction(ISD::SUB , VT, Expand);
 796     setOperationAction(ISD::FADD, VT, Expand);
 797     setOperationAction(ISD::FNEG, VT, Expand);
 798     setOperationAction(ISD::FSUB, VT, Expand);
 799     setOperationAction(ISD::MUL , VT, Expand);
 800     setOperationAction(ISD::FMUL, VT, Expand);
 801     setOperationAction(ISD::SDIV, VT, Expand);
 802     setOperationAction(ISD::UDIV, VT, Expand);
 803     setOperationAction(ISD::FDIV, VT, Expand);
 804     setOperationAction(ISD::SREM, VT, Expand);
 805     setOperationAction(ISD::UREM, VT, Expand);
 806     setOperationAction(ISD::LOAD, VT, Expand);
 807     setOperationAction(ISD::VECTOR_SHUFFLE, VT, Expand);
 808     setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT,Expand);
 809     setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Expand);
 810     setOperationAction(ISD::EXTRACT_SUBVECTOR, VT,Expand);
 811     setOperationAction(ISD::INSERT_SUBVECTOR, VT,Expand);
 812     setOperationAction(ISD::FABS, VT, Expand);
 813     setOperationAction(ISD::FSIN, VT, Expand);
 814     setOperationAction(ISD::FSINCOS, VT, Expand);
 815     setOperationAction(ISD::FCOS, VT, Expand);
 816     setOperationAction(ISD::FSINCOS, VT, Expand);
 817     setOperationAction(ISD::FREM, VT, Expand);
 818     setOperationAction(ISD::FMA,  VT, Expand);
 819     setOperationAction(ISD::FPOWI, VT, Expand);
 820     setOperationAction(ISD::FSQRT, VT, Expand);
 821     setOperationAction(ISD::FCOPYSIGN, VT, Expand);
 822     setOperationAction(ISD::FFLOOR, VT, Expand);
 823     setOperationAction(ISD::FCEIL, VT, Expand);
 824     setOperationAction(ISD::FTRUNC, VT, Expand);
 825     setOperationAction(ISD::FRINT, VT, Expand);
 826     setOperationAction(ISD::FNEARBYINT, VT, Expand);
 827     setOperationAction(ISD::SMUL_LOHI, VT, Expand);
 828     setOperationAction(ISD::MULHS, VT, Expand);
 829     setOperationAction(ISD::UMUL_LOHI, VT, Expand);
 830     setOperationAction(ISD::MULHU, VT, Expand);
 831     setOperationAction(ISD::SDIVREM, VT, Expand);
 832     setOperationAction(ISD::UDIVREM, VT, Expand);
 833     setOperationAction(ISD::FPOW, VT, Expand);
 834     setOperationAction(ISD::CTPOP, VT, Expand);
 835     setOperationAction(ISD::CTTZ, VT, Expand);
 836     setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Expand);
 837     setOperationAction(ISD::CTLZ, VT, Expand);
 838     setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Expand);
 839     setOperationAction(ISD::SHL, VT, Expand);
 840     setOperationAction(ISD::SRA, VT, Expand);
 841     setOperationAction(ISD::SRL, VT, Expand);
 842     setOperationAction(ISD::ROTL, VT, Expand);
 843     setOperationAction(ISD::ROTR, VT, Expand);
 844     setOperationAction(ISD::BSWAP, VT, Expand);
 845     setOperationAction(ISD::SETCC, VT, Expand);
 846     setOperationAction(ISD::FLOG, VT, Expand);
 847     setOperationAction(ISD::FLOG2, VT, Expand);
 848     setOperationAction(ISD::FLOG10, VT, Expand);
 849     setOperationAction(ISD::FEXP, VT, Expand);
 850     setOperationAction(ISD::FEXP2, VT, Expand);
 851     setOperationAction(ISD::FP_TO_UINT, VT, Expand);
 852     setOperationAction(ISD::FP_TO_SINT, VT, Expand);
 853     setOperationAction(ISD::UINT_TO_FP, VT, Expand);
 854     setOperationAction(ISD::SINT_TO_FP, VT, Expand);
 855     setOperationAction(ISD::SIGN_EXTEND_INREG, VT,Expand);
 856     setOperationAction(ISD::TRUNCATE, VT, Expand);
 857     setOperationAction(ISD::SIGN_EXTEND, VT, Expand);
 858     setOperationAction(ISD::ZERO_EXTEND, VT, Expand);
 859     setOperationAction(ISD::ANY_EXTEND, VT, Expand);
 860     setOperationAction(ISD::VSELECT, VT, Expand);
 861     setOperationAction(ISD::SELECT_CC, VT, Expand);
 862     for (MVT InnerVT : MVT::vector_valuetypes()) {
 863       setTruncStoreAction(InnerVT, VT, Expand);
 864
 865       setLoadExtAction(ISD::SEXTLOAD, InnerVT, VT, Expand);
 866       setLoadExtAction(ISD::ZEXTLOAD, InnerVT, VT, Expand);
 867
 868       // N.b. ISD::EXTLOAD legality is basically ignored except for i1-like
 869       // types, we have to deal with them whether we ask for Expansion or not.
 870       // Setting Expand causes its own optimisation problems though, so leave
 871       // them legal.
 872       if (VT.getVectorElementType() == MVT::i1)
 873         setLoadExtAction(ISD::EXTLOAD, InnerVT, VT, Expand);
 874     }
 875   }
 876
 877   // FIXME: In order to prevent SSE instructions being expanded to MMX ones
 878   // with -msoft-float, disable use of MMX as well.
 879   if (!TM.Options.UseSoftFloat && Subtarget->hasMMX()) {
 880     addRegisterClass(MVT::x86mmx, &X86::VR64RegClass);
 881     // No operations on x86mmx supported, everything uses intrinsics.
 882   }
 883
 884   // MMX-sized vectors (other than x86mmx) are expected to be expanded
 885   // into smaller operations.
 886   setOperationAction(ISD::MULHS,              MVT::v8i8,  Expand);
 887   setOperationAction(ISD::MULHS,              MVT::v4i16, Expand);
 888   setOperationAction(ISD::MULHS,              MVT::v2i32, Expand);
 889   setOperationAction(ISD::MULHS,              MVT::v1i64, Expand);
 890   setOperationAction(ISD::AND,                MVT::v8i8,  Expand);
 891   setOperationAction(ISD::AND,                MVT::v4i16, Expand);
 892   setOperationAction(ISD::AND,                MVT::v2i32, Expand);
 893   setOperationAction(ISD::AND,                MVT::v1i64, Expand);
 894   setOperationAction(ISD::OR,                 MVT::v8i8,  Expand);
 895   setOperationAction(ISD::OR,                 MVT::v4i16, Expand);
 896   setOperationAction(ISD::OR,                 MVT::v2i32, Expand);
 897   setOperationAction(ISD::OR,                 MVT::v1i64, Expand);
 898   setOperationAction(ISD::XOR,                MVT::v8i8,  Expand);
 899   setOperationAction(ISD::XOR,                MVT::v4i16, Expand);
 900   setOperationAction(ISD::XOR,                MVT::v2i32, Expand);
 901   setOperationAction(ISD::XOR,                MVT::v1i64, Expand);
 902   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i8,  Expand);
 903   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v4i16, Expand);
 904   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v2i32, Expand);
 905   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v1i64, Expand);
 906   setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v1i64, Expand);
 907   setOperationAction(ISD::SELECT,             MVT::v8i8,  Expand);
 908   setOperationAction(ISD::SELECT,             MVT::v4i16, Expand);
 909   setOperationAction(ISD::SELECT,             MVT::v2i32, Expand);
 910   setOperationAction(ISD::SELECT,             MVT::v1i64, Expand);
 911   setOperationAction(ISD::BITCAST,            MVT::v8i8,  Expand);
 912   setOperationAction(ISD::BITCAST,            MVT::v4i16, Expand);
 913   setOperationAction(ISD::BITCAST,            MVT::v2i32, Expand);
 914   setOperationAction(ISD::BITCAST,            MVT::v1i64, Expand);
 915
 916   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE1()) {
 917     addRegisterClass(MVT::v4f32, &X86::VR128RegClass);
 918
 919     setOperationAction(ISD::FADD,               MVT::v4f32, Legal);
 920     setOperationAction(ISD::FSUB,               MVT::v4f32, Legal);
 921     setOperationAction(ISD::FMUL,               MVT::v4f32, Legal);
 922     setOperationAction(ISD::FDIV,               MVT::v4f32, Legal);
 923     setOperationAction(ISD::FSQRT,              MVT::v4f32, Legal);
 924     setOperationAction(ISD::FNEG,               MVT::v4f32, Custom);
 925     setOperationAction(ISD::FABS,               MVT::v4f32, Custom);
 926     setOperationAction(ISD::LOAD,               MVT::v4f32, Legal);
 927     setOperationAction(ISD::BUILD_VECTOR,       MVT::v4f32, Custom);
 928     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v4f32, Custom);
 929     setOperationAction(ISD::VSELECT,            MVT::v4f32, Custom);
 930     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
 931     setOperationAction(ISD::SELECT,             MVT::v4f32, Custom);
 932     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i32, Custom);
 933   }
 934
 935   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE2()) {
 936     addRegisterClass(MVT::v2f64, &X86::VR128RegClass);
 937
 938     // FIXME: Unfortunately, -soft-float and -no-implicit-float mean XMM
 939     // registers cannot be used even for integer operations.
 940     addRegisterClass(MVT::v16i8, &X86::VR128RegClass);
 941     addRegisterClass(MVT::v8i16, &X86::VR128RegClass);
 942     addRegisterClass(MVT::v4i32, &X86::VR128RegClass);
 943     addRegisterClass(MVT::v2i64, &X86::VR128RegClass);
 944
 945     setOperationAction(ISD::ADD,                MVT::v16i8, Legal);
 946     setOperationAction(ISD::ADD,                MVT::v8i16, Legal);
 947     setOperationAction(ISD::ADD,                MVT::v4i32, Legal);
 948     setOperationAction(ISD::ADD,                MVT::v2i64, Legal);
 949     setOperationAction(ISD::MUL,                MVT::v4i32, Custom);
 950     setOperationAction(ISD::MUL,                MVT::v2i64, Custom);
 951     setOperationAction(ISD::UMUL_LOHI,          MVT::v4i32, Custom);
 952     setOperationAction(ISD::SMUL_LOHI,          MVT::v4i32, Custom);
 953     setOperationAction(ISD::MULHU,              MVT::v8i16, Legal);
 954     setOperationAction(ISD::MULHS,              MVT::v8i16, Legal);
 955     setOperationAction(ISD::SUB,                MVT::v16i8, Legal);
 956     setOperationAction(ISD::SUB,                MVT::v8i16, Legal);
 957     setOperationAction(ISD::SUB,                MVT::v4i32, Legal);
 958     setOperationAction(ISD::SUB,                MVT::v2i64, Legal);
 959     setOperationAction(ISD::MUL,                MVT::v8i16, Legal);
 960     setOperationAction(ISD::FADD,               MVT::v2f64, Legal);
 961     setOperationAction(ISD::FSUB,               MVT::v2f64, Legal);
 962     setOperationAction(ISD::FMUL,               MVT::v2f64, Legal);
 963     setOperationAction(ISD::FDIV,               MVT::v2f64, Legal);
 964     setOperationAction(ISD::FSQRT,              MVT::v2f64, Legal);
 965     setOperationAction(ISD::FNEG,               MVT::v2f64, Custom);
 966     setOperationAction(ISD::FABS,               MVT::v2f64, Custom);
 967
 968     setOperationAction(ISD::SETCC,              MVT::v2i64, Custom);
 969     setOperationAction(ISD::SETCC,              MVT::v16i8, Custom);
 970     setOperationAction(ISD::SETCC,              MVT::v8i16, Custom);
 971     setOperationAction(ISD::SETCC,              MVT::v4i32, Custom);
 972
 973     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v16i8, Custom);
 974     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i16, Custom);
 975     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
 976     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
 977     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
 978
 979     // Only provide customized ctpop vector bit twiddling for vector types we
 980     // know to perform better than using the popcnt instructions on each vector
 981     // element. If popcnt isn't supported, always provide the custom version.
 982     if (!Subtarget->hasPOPCNT()) {
 983       setOperationAction(ISD::CTPOP,            MVT::v4i32, Custom);
 984       setOperationAction(ISD::CTPOP,            MVT::v2i64, Custom);
 985     }
 986
 987     // Custom lower build_vector, vector_shuffle, and extract_vector_elt.
 988     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
 989       MVT VT = (MVT::SimpleValueType)i;
 990       // Do not attempt to custom lower non-power-of-2 vectors
 991       if (!isPowerOf2_32(VT.getVectorNumElements()))
 992         continue;
 993       // Do not attempt to custom lower non-128-bit vectors
 994       if (!VT.is128BitVector())
 995         continue;
 996       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
 997       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
 998       setOperationAction(ISD::VSELECT,            VT, Custom);
 999       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
1000     }
1001
1002     // We support custom legalizing of sext and anyext loads for specific
1003     // memory vector types which we can load as a scalar (or sequence of
1004     // scalars) and extend in-register to a legal 128-bit vector type. For sext
1005     // loads these must work with a single scalar load.
1006     for (MVT VT : MVT::integer_vector_valuetypes()) {
1007       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v4i8, Custom);
1008       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v4i16, Custom);
1009       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v8i8, Custom);
1010       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i8, Custom);
1011       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i16, Custom);
1012       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i32, Custom);
1013       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4i8, Custom);
1014       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4i16, Custom);
1015       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v8i8, Custom);
1016     }
1017
1018     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2f64, Custom);
1019     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2i64, Custom);
1020     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2f64, Custom);
1021     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2i64, Custom);
1022     setOperationAction(ISD::VSELECT,            MVT::v2f64, Custom);
1023     setOperationAction(ISD::VSELECT,            MVT::v2i64, Custom);
1024     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2f64, Custom);
1025     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Custom);
1026
1027     if (Subtarget->is64Bit()) {
1028       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
1029       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
1030     }
1031
1032     // Promote v16i8, v8i16, v4i32 load, select, and, or, xor to v2i64.
1033     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
1034       MVT VT = (MVT::SimpleValueType)i;
1035
1036       // Do not attempt to promote non-128-bit vectors
1037       if (!VT.is128BitVector())
1038         continue;
1039
1040       setOperationAction(ISD::AND,    VT, Promote);
1041       AddPromotedToType (ISD::AND,    VT, MVT::v2i64);
1042       setOperationAction(ISD::OR,     VT, Promote);
1043       AddPromotedToType (ISD::OR,     VT, MVT::v2i64);
1044       setOperationAction(ISD::XOR,    VT, Promote);
1045       AddPromotedToType (ISD::XOR,    VT, MVT::v2i64);
1046       setOperationAction(ISD::LOAD,   VT, Promote);
1047       AddPromotedToType (ISD::LOAD,   VT, MVT::v2i64);
1048       setOperationAction(ISD::SELECT, VT, Promote);
1049       AddPromotedToType (ISD::SELECT, VT, MVT::v2i64);
1050     }
1051
1052     // Custom lower v2i64 and v2f64 selects.
1053     setOperationAction(ISD::LOAD,               MVT::v2f64, Legal);
1054     setOperationAction(ISD::LOAD,               MVT::v2i64, Legal);
1055     setOperationAction(ISD::SELECT,             MVT::v2f64, Custom);
1056     setOperationAction(ISD::SELECT,             MVT::v2i64, Custom);
1057
1058     setOperationAction(ISD::FP_TO_SINT,         MVT::v4i32, Legal);
1059     setOperationAction(ISD::SINT_TO_FP,         MVT::v4i32, Legal);
1060
1061     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i8,  Custom);
1062     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i16, Custom);
1063     // As there is no 64-bit GPR available, we need build a special custom
1064     // sequence to convert from v2i32 to v2f32.
1065     if (!Subtarget->is64Bit())
1066       setOperationAction(ISD::UINT_TO_FP,       MVT::v2f32, Custom);
1067
1068     setOperationAction(ISD::FP_EXTEND,          MVT::v2f32, Custom);
1069     setOperationAction(ISD::FP_ROUND,           MVT::v2f32, Custom);
1070
1071     for (MVT VT : MVT::fp_vector_valuetypes())
1072       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2f32, Legal);
1073
1074     setOperationAction(ISD::BITCAST,            MVT::v2i32, Custom);
1075     setOperationAction(ISD::BITCAST,            MVT::v4i16, Custom);
1076     setOperationAction(ISD::BITCAST,            MVT::v8i8,  Custom);
1077   }
1078
1079   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE41()) {
1080     setOperationAction(ISD::FFLOOR,             MVT::f32,   Legal);
1081     setOperationAction(ISD::FCEIL,              MVT::f32,   Legal);
1082     setOperationAction(ISD::FTRUNC,             MVT::f32,   Legal);
1083     setOperationAction(ISD::FRINT,              MVT::f32,   Legal);
1084     setOperationAction(ISD::FNEARBYINT,         MVT::f32,   Legal);
1085     setOperationAction(ISD::FFLOOR,             MVT::f64,   Legal);
1086     setOperationAction(ISD::FCEIL,              MVT::f64,   Legal);
1087     setOperationAction(ISD::FTRUNC,             MVT::f64,   Legal);
1088     setOperationAction(ISD::FRINT,              MVT::f64,   Legal);
1089     setOperationAction(ISD::FNEARBYINT,         MVT::f64,   Legal);
1090
1091     setOperationAction(ISD::FFLOOR,             MVT::v4f32, Legal);
1092     setOperationAction(ISD::FCEIL,              MVT::v4f32, Legal);
1093     setOperationAction(ISD::FTRUNC,             MVT::v4f32, Legal);
1094     setOperationAction(ISD::FRINT,              MVT::v4f32, Legal);
1095     setOperationAction(ISD::FNEARBYINT,         MVT::v4f32, Legal);
1096     setOperationAction(ISD::FFLOOR,             MVT::v2f64, Legal);
1097     setOperationAction(ISD::FCEIL,              MVT::v2f64, Legal);
1098     setOperationAction(ISD::FTRUNC,             MVT::v2f64, Legal);
1099     setOperationAction(ISD::FRINT,              MVT::v2f64, Legal);
1100     setOperationAction(ISD::FNEARBYINT,         MVT::v2f64, Legal);
1101
1102     // FIXME: Do we need to handle scalar-to-vector here?
1103     setOperationAction(ISD::MUL,                MVT::v4i32, Legal);
1104
1105     // We directly match byte blends in the backend as they match the VSELECT
1106     // condition form.
1107     setOperationAction(ISD::VSELECT,            MVT::v16i8, Legal);
1108
1109     // SSE41 brings specific instructions for doing vector sign extend even in
1110     // cases where we don't have SRA.
1111     for (MVT VT : MVT::integer_vector_valuetypes()) {
1112       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i8, Custom);
1113       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i16, Custom);
1114       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i32, Custom);
1115     }
1116
1117     // SSE41 also has vector sign/zero extending loads, PMOV[SZ]X
1118     setLoadExtAction(ISD::SEXTLOAD, MVT::v8i16, MVT::v8i8,  Legal);
1119     setLoadExtAction(ISD::SEXTLOAD, MVT::v4i32, MVT::v4i8,  Legal);
1120     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i8,  Legal);
1121     setLoadExtAction(ISD::SEXTLOAD, MVT::v4i32, MVT::v4i16, Legal);
1122     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i16, Legal);
1123     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i32, Legal);
1124
1125     setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i16, MVT::v8i8,  Legal);
1126     setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i32, MVT::v4i8,  Legal);
1127     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i8,  Legal);
1128     setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i32, MVT::v4i16, Legal);
1129     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i16, Legal);
1130     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i32, Legal);
1131
1132     // i8 and i16 vectors are custom because the source register and source
1133     // source memory operand types are not the same width.  f32 vectors are
1134     // custom since the immediate controlling the insert encodes additional
1135     // information.
1136     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i8, Custom);
1137     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
1138     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
1139     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
1140
1141     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i8, Custom);
1142     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i16, Custom);
1143     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4i32, Custom);
1144     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
1145
1146     // FIXME: these should be Legal, but that's only for the case where
1147     // the index is constant.  For now custom expand to deal with that.
1148     if (Subtarget->is64Bit()) {
1149       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
1150       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
1151     }
1152   }
1153
1154   if (Subtarget->hasSSE2()) {
1155     setOperationAction(ISD::SRL,               MVT::v8i16, Custom);
1156     setOperationAction(ISD::SRL,               MVT::v16i8, Custom);
1157
1158     setOperationAction(ISD::SHL,               MVT::v8i16, Custom);
1159     setOperationAction(ISD::SHL,               MVT::v16i8, Custom);
1160
1161     setOperationAction(ISD::SRA,               MVT::v8i16, Custom);
1162     setOperationAction(ISD::SRA,               MVT::v16i8, Custom);
1163
1164     // In the customized shift lowering, the legal cases in AVX2 will be
1165     // recognized.
1166     setOperationAction(ISD::SRL,               MVT::v2i64, Custom);
1167     setOperationAction(ISD::SRL,               MVT::v4i32, Custom);
1168
1169     setOperationAction(ISD::SHL,               MVT::v2i64, Custom);
1170     setOperationAction(ISD::SHL,               MVT::v4i32, Custom);
1171
1172     setOperationAction(ISD::SRA,               MVT::v4i32, Custom);
1173   }
1174
1175   if (!TM.Options.UseSoftFloat && Subtarget->hasFp256()) {
1176     addRegisterClass(MVT::v32i8,  &X86::VR256RegClass);
1177     addRegisterClass(MVT::v16i16, &X86::VR256RegClass);
1178     addRegisterClass(MVT::v8i32,  &X86::VR256RegClass);
1179     addRegisterClass(MVT::v8f32,  &X86::VR256RegClass);
1180     addRegisterClass(MVT::v4i64,  &X86::VR256RegClass);
1181     addRegisterClass(MVT::v4f64,  &X86::VR256RegClass);
1182
1183     setOperationAction(ISD::LOAD,               MVT::v8f32, Legal);
1184     setOperationAction(ISD::LOAD,               MVT::v4f64, Legal);
1185     setOperationAction(ISD::LOAD,               MVT::v4i64, Legal);
1186
1187     setOperationAction(ISD::FADD,               MVT::v8f32, Legal);
1188     setOperationAction(ISD::FSUB,               MVT::v8f32, Legal);
1189     setOperationAction(ISD::FMUL,               MVT::v8f32, Legal);
1190     setOperationAction(ISD::FDIV,               MVT::v8f32, Legal);
1191     setOperationAction(ISD::FSQRT,              MVT::v8f32, Legal);
1192     setOperationAction(ISD::FFLOOR,             MVT::v8f32, Legal);
1193     setOperationAction(ISD::FCEIL,              MVT::v8f32, Legal);
1194     setOperationAction(ISD::FTRUNC,             MVT::v8f32, Legal);
1195     setOperationAction(ISD::FRINT,              MVT::v8f32, Legal);
1196     setOperationAction(ISD::FNEARBYINT,         MVT::v8f32, Legal);
1197     setOperationAction(ISD::FNEG,               MVT::v8f32, Custom);
1198     setOperationAction(ISD::FABS,               MVT::v8f32, Custom);
1199
1200     setOperationAction(ISD::FADD,               MVT::v4f64, Legal);
1201     setOperationAction(ISD::FSUB,               MVT::v4f64, Legal);
1202     setOperationAction(ISD::FMUL,               MVT::v4f64, Legal);
1203     setOperationAction(ISD::FDIV,               MVT::v4f64, Legal);
1204     setOperationAction(ISD::FSQRT,              MVT::v4f64, Legal);
1205     setOperationAction(ISD::FFLOOR,             MVT::v4f64, Legal);
1206     setOperationAction(ISD::FCEIL,              MVT::v4f64, Legal);
1207     setOperationAction(ISD::FTRUNC,             MVT::v4f64, Legal);
1208     setOperationAction(ISD::FRINT,              MVT::v4f64, Legal);
1209     setOperationAction(ISD::FNEARBYINT,         MVT::v4f64, Legal);
1210     setOperationAction(ISD::FNEG,               MVT::v4f64, Custom);
1211     setOperationAction(ISD::FABS,               MVT::v4f64, Custom);
1212
1213     // (fp_to_int:v8i16 (v8f32 ..)) requires the result type to be promoted
1214     // even though v8i16 is a legal type.
1215     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i16, Promote);
1216     setOperationAction(ISD::FP_TO_UINT,         MVT::v8i16, Promote);
1217     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i32, Legal);
1218
1219     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i16, Promote);
1220     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i32, Legal);
1221     setOperationAction(ISD::FP_ROUND,           MVT::v4f32, Legal);
1222
1223     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i8,  Custom);
1224     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i16, Custom);
1225
1226     for (MVT VT : MVT::fp_vector_valuetypes())
1227       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4f32, Legal);
1228
1229     setOperationAction(ISD::SRL,               MVT::v16i16, Custom);
1230     setOperationAction(ISD::SRL,               MVT::v32i8, Custom);
1231
1232     setOperationAction(ISD::SHL,               MVT::v16i16, Custom);
1233     setOperationAction(ISD::SHL,               MVT::v32i8, Custom);
1234
1235     setOperationAction(ISD::SRA,               MVT::v16i16, Custom);
1236     setOperationAction(ISD::SRA,               MVT::v32i8, Custom);
1237
1238     setOperationAction(ISD::SETCC,             MVT::v32i8, Custom);
1239     setOperationAction(ISD::SETCC,             MVT::v16i16, Custom);
1240     setOperationAction(ISD::SETCC,             MVT::v8i32, Custom);
1241     setOperationAction(ISD::SETCC,             MVT::v4i64, Custom);
1242
1243     setOperationAction(ISD::SELECT,            MVT::v4f64, Custom);
1244     setOperationAction(ISD::SELECT,            MVT::v4i64, Custom);
1245     setOperationAction(ISD::SELECT,            MVT::v8f32, Custom);
1246
1247     setOperationAction(ISD::SIGN_EXTEND,       MVT::v4i64, Custom);
1248     setOperationAction(ISD::SIGN_EXTEND,       MVT::v8i32, Custom);
1249     setOperationAction(ISD::SIGN_EXTEND,       MVT::v16i16, Custom);
1250     setOperationAction(ISD::ZERO_EXTEND,       MVT::v4i64, Custom);
1251     setOperationAction(ISD::ZERO_EXTEND,       MVT::v8i32, Custom);
1252     setOperationAction(ISD::ZERO_EXTEND,       MVT::v16i16, Custom);
1253     setOperationAction(ISD::ANY_EXTEND,        MVT::v4i64, Custom);
1254     setOperationAction(ISD::ANY_EXTEND,        MVT::v8i32, Custom);
1255     setOperationAction(ISD::ANY_EXTEND,        MVT::v16i16, Custom);
1256     setOperationAction(ISD::TRUNCATE,          MVT::v16i8, Custom);
1257     setOperationAction(ISD::TRUNCATE,          MVT::v8i16, Custom);
1258     setOperationAction(ISD::TRUNCATE,          MVT::v4i32, Custom);
1259
1260     if (Subtarget->hasFMA() || Subtarget->hasFMA4()) {
1261       setOperationAction(ISD::FMA,             MVT::v8f32, Legal);
1262       setOperationAction(ISD::FMA,             MVT::v4f64, Legal);
1263       setOperationAction(ISD::FMA,             MVT::v4f32, Legal);
1264       setOperationAction(ISD::FMA,             MVT::v2f64, Legal);
1265       setOperationAction(ISD::FMA,             MVT::f32, Legal);
1266       setOperationAction(ISD::FMA,             MVT::f64, Legal);
1267     }
1268
1269     if (Subtarget->hasInt256()) {
1270       setOperationAction(ISD::ADD,             MVT::v4i64, Legal);
1271       setOperationAction(ISD::ADD,             MVT::v8i32, Legal);
1272       setOperationAction(ISD::ADD,             MVT::v16i16, Legal);
1273       setOperationAction(ISD::ADD,             MVT::v32i8, Legal);
1274
1275       setOperationAction(ISD::SUB,             MVT::v4i64, Legal);
1276       setOperationAction(ISD::SUB,             MVT::v8i32, Legal);
1277       setOperationAction(ISD::SUB,             MVT::v16i16, Legal);
1278       setOperationAction(ISD::SUB,             MVT::v32i8, Legal);
1279
1280       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1281       setOperationAction(ISD::MUL,             MVT::v8i32, Legal);
1282       setOperationAction(ISD::MUL,             MVT::v16i16, Legal);
1283       // Don't lower v32i8 because there is no 128-bit byte mul
1284
1285       setOperationAction(ISD::UMUL_LOHI,       MVT::v8i32, Custom);
1286       setOperationAction(ISD::SMUL_LOHI,       MVT::v8i32, Custom);
1287       setOperationAction(ISD::MULHU,           MVT::v16i16, Legal);
1288       setOperationAction(ISD::MULHS,           MVT::v16i16, Legal);
1289
1290       // The custom lowering for UINT_TO_FP for v8i32 becomes interesting
1291       // when we have a 256bit-wide blend with immediate.
1292       setOperationAction(ISD::UINT_TO_FP, MVT::v8i32, Custom);
1293
1294       // Only provide customized ctpop vector bit twiddling for vector types we
1295       // know to perform better than using the popcnt instructions on each
1296       // vector element. If popcnt isn't supported, always provide the custom
1297       // version.
1298       if (!Subtarget->hasPOPCNT())
1299         setOperationAction(ISD::CTPOP,           MVT::v4i64, Custom);
1300
1301       // Custom CTPOP always performs better on natively supported v8i32
1302       setOperationAction(ISD::CTPOP,             MVT::v8i32, Custom);
1303
1304       // AVX2 also has wider vector sign/zero extending loads, VPMOV[SZ]X
1305       setLoadExtAction(ISD::SEXTLOAD, MVT::v16i16, MVT::v16i8, Legal);
1306       setLoadExtAction(ISD::SEXTLOAD, MVT::v8i32,  MVT::v8i8,  Legal);
1307       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i8,  Legal);
1308       setLoadExtAction(ISD::SEXTLOAD, MVT::v8i32,  MVT::v8i16, Legal);
1309       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i16, Legal);
1310       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i32, Legal);
1311
1312       setLoadExtAction(ISD::ZEXTLOAD, MVT::v16i16, MVT::v16i8, Legal);
1313       setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i32,  MVT::v8i8,  Legal);
1314       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i8,  Legal);
1315       setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i32,  MVT::v8i16, Legal);
1316       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i16, Legal);
1317       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i32, Legal);
1318     } else {
1319       setOperationAction(ISD::ADD,             MVT::v4i64, Custom);
1320       setOperationAction(ISD::ADD,             MVT::v8i32, Custom);
1321       setOperationAction(ISD::ADD,             MVT::v16i16, Custom);
1322       setOperationAction(ISD::ADD,             MVT::v32i8, Custom);
1323
1324       setOperationAction(ISD::SUB,             MVT::v4i64, Custom);
1325       setOperationAction(ISD::SUB,             MVT::v8i32, Custom);
1326       setOperationAction(ISD::SUB,             MVT::v16i16, Custom);
1327       setOperationAction(ISD::SUB,             MVT::v32i8, Custom);
1328
1329       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1330       setOperationAction(ISD::MUL,             MVT::v8i32, Custom);
1331       setOperationAction(ISD::MUL,             MVT::v16i16, Custom);
1332       // Don't lower v32i8 because there is no 128-bit byte mul
1333     }
1334
1335     // In the customized shift lowering, the legal cases in AVX2 will be
1336     // recognized.
1337     setOperationAction(ISD::SRL,               MVT::v4i64, Custom);
1338     setOperationAction(ISD::SRL,               MVT::v8i32, Custom);
1339
1340     setOperationAction(ISD::SHL,               MVT::v4i64, Custom);
1341     setOperationAction(ISD::SHL,               MVT::v8i32, Custom);
1342
1343     setOperationAction(ISD::SRA,               MVT::v8i32, Custom);
1344
1345     // Custom lower several nodes for 256-bit types.
1346     for (MVT VT : MVT::vector_valuetypes()) {
1347       if (VT.getScalarSizeInBits() >= 32) {
1348         setOperationAction(ISD::MLOAD,  VT, Legal);
1349         setOperationAction(ISD::MSTORE, VT, Legal);
1350       }
1351       // Extract subvector is special because the value type
1352       // (result) is 128-bit but the source is 256-bit wide.
1353       if (VT.is128BitVector()) {
1354         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Custom);
1355       }
1356       // Do not attempt to custom lower other non-256-bit vectors
1357       if (!VT.is256BitVector())
1358         continue;
1359
1360       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
1361       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
1362       setOperationAction(ISD::VSELECT,            VT, Custom);
1363       setOperationAction(ISD::INSERT_VECTOR_ELT,  VT, Custom);
1364       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
1365       setOperationAction(ISD::SCALAR_TO_VECTOR,   VT, Custom);
1366       setOperationAction(ISD::INSERT_SUBVECTOR,   VT, Custom);
1367       setOperationAction(ISD::CONCAT_VECTORS,     VT, Custom);
1368     }
1369
1370     if (Subtarget->hasInt256())
1371       setOperationAction(ISD::VSELECT,         MVT::v32i8, Legal);
1372
1373
1374     // Promote v32i8, v16i16, v8i32 select, and, or, xor to v4i64.
1375     for (int i = MVT::v32i8; i != MVT::v4i64; ++i) {
1376       MVT VT = (MVT::SimpleValueType)i;
1377
1378       // Do not attempt to promote non-256-bit vectors
1379       if (!VT.is256BitVector())
1380         continue;
1381
1382       setOperationAction(ISD::AND,    VT, Promote);
1383       AddPromotedToType (ISD::AND,    VT, MVT::v4i64);
1384       setOperationAction(ISD::OR,     VT, Promote);
1385       AddPromotedToType (ISD::OR,     VT, MVT::v4i64);
1386       setOperationAction(ISD::XOR,    VT, Promote);
1387       AddPromotedToType (ISD::XOR,    VT, MVT::v4i64);
1388       setOperationAction(ISD::LOAD,   VT, Promote);
1389       AddPromotedToType (ISD::LOAD,   VT, MVT::v4i64);
1390       setOperationAction(ISD::SELECT, VT, Promote);
1391       AddPromotedToType (ISD::SELECT, VT, MVT::v4i64);
1392     }
1393   }
1394
1395   if (!TM.Options.UseSoftFloat && Subtarget->hasAVX512()) {
1396     addRegisterClass(MVT::v16i32, &X86::VR512RegClass);
1397     addRegisterClass(MVT::v16f32, &X86::VR512RegClass);
1398     addRegisterClass(MVT::v8i64,  &X86::VR512RegClass);
1399     addRegisterClass(MVT::v8f64,  &X86::VR512RegClass);
1400
1401     addRegisterClass(MVT::i1,     &X86::VK1RegClass);
1402     addRegisterClass(MVT::v8i1,   &X86::VK8RegClass);
1403     addRegisterClass(MVT::v16i1,  &X86::VK16RegClass);
1404
1405     for (MVT VT : MVT::fp_vector_valuetypes())
1406       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v8f32, Legal);
1407
1408     setOperationAction(ISD::BR_CC,              MVT::i1,    Expand);
1409     setOperationAction(ISD::SETCC,              MVT::i1,    Custom);
1410     setOperationAction(ISD::XOR,                MVT::i1,    Legal);
1411     setOperationAction(ISD::OR,                 MVT::i1,    Legal);
1412     setOperationAction(ISD::AND,                MVT::i1,    Legal);
1413     setOperationAction(ISD::LOAD,               MVT::v16f32, Legal);
1414     setOperationAction(ISD::LOAD,               MVT::v8f64, Legal);
1415     setOperationAction(ISD::LOAD,               MVT::v8i64, Legal);
1416     setOperationAction(ISD::LOAD,               MVT::v16i32, Legal);
1417     setOperationAction(ISD::LOAD,               MVT::v16i1, Legal);
1418
1419     setOperationAction(ISD::FADD,               MVT::v16f32, Legal);
1420     setOperationAction(ISD::FSUB,               MVT::v16f32, Legal);
1421     setOperationAction(ISD::FMUL,               MVT::v16f32, Legal);
1422     setOperationAction(ISD::FDIV,               MVT::v16f32, Legal);
1423     setOperationAction(ISD::FSQRT,              MVT::v16f32, Legal);
1424     setOperationAction(ISD::FNEG,               MVT::v16f32, Custom);
1425
1426     setOperationAction(ISD::FADD,               MVT::v8f64, Legal);
1427     setOperationAction(ISD::FSUB,               MVT::v8f64, Legal);
1428     setOperationAction(ISD::FMUL,               MVT::v8f64, Legal);
1429     setOperationAction(ISD::FDIV,               MVT::v8f64, Legal);
1430     setOperationAction(ISD::FSQRT,              MVT::v8f64, Legal);
1431     setOperationAction(ISD::FNEG,               MVT::v8f64, Custom);
1432     setOperationAction(ISD::FMA,                MVT::v8f64, Legal);
1433     setOperationAction(ISD::FMA,                MVT::v16f32, Legal);
1434
1435     setOperationAction(ISD::FP_TO_SINT,         MVT::i32, Legal);
1436     setOperationAction(ISD::FP_TO_UINT,         MVT::i32, Legal);
1437     setOperationAction(ISD::SINT_TO_FP,         MVT::i32, Legal);
1438     setOperationAction(ISD::UINT_TO_FP,         MVT::i32, Legal);
1439     if (Subtarget->is64Bit()) {
1440       setOperationAction(ISD::FP_TO_UINT,       MVT::i64, Legal);
1441       setOperationAction(ISD::FP_TO_SINT,       MVT::i64, Legal);
1442       setOperationAction(ISD::SINT_TO_FP,       MVT::i64, Legal);
1443       setOperationAction(ISD::UINT_TO_FP,       MVT::i64, Legal);
1444     }
1445     setOperationAction(ISD::FP_TO_SINT,         MVT::v16i32, Legal);
1446     setOperationAction(ISD::FP_TO_UINT,         MVT::v16i32, Legal);
1447     setOperationAction(ISD::FP_TO_UINT,         MVT::v8i32, Legal);
1448     setOperationAction(ISD::FP_TO_UINT,         MVT::v4i32, Legal);
1449     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i32, Legal);
1450     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i1,   Custom);
1451     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i1,  Custom);
1452     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i8,  Promote);
1453     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i16, Promote);
1454     setOperationAction(ISD::UINT_TO_FP,         MVT::v16i32, Legal);
1455     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i32, Legal);
1456     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i32, Legal);
1457     setOperationAction(ISD::FP_ROUND,           MVT::v8f32, Legal);
1458     setOperationAction(ISD::FP_EXTEND,          MVT::v8f32, Legal);
1459
1460     setOperationAction(ISD::TRUNCATE,           MVT::i1, Custom);
1461     setOperationAction(ISD::TRUNCATE,           MVT::v16i8, Custom);
1462     setOperationAction(ISD::TRUNCATE,           MVT::v8i32, Custom);
1463     setOperationAction(ISD::TRUNCATE,           MVT::v8i1, Custom);
1464     setOperationAction(ISD::TRUNCATE,           MVT::v16i1, Custom);
1465     setOperationAction(ISD::TRUNCATE,           MVT::v16i16, Custom);
1466     setOperationAction(ISD::ZERO_EXTEND,        MVT::v16i32, Custom);
1467     setOperationAction(ISD::ZERO_EXTEND,        MVT::v8i64, Custom);
1468     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i32, Custom);
1469     setOperationAction(ISD::SIGN_EXTEND,        MVT::v8i64, Custom);
1470     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i8, Custom);
1471     setOperationAction(ISD::SIGN_EXTEND,        MVT::v8i16, Custom);
1472     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i16, Custom);
1473
1474     setOperationAction(ISD::FFLOOR,             MVT::v16f32, Legal);
1475     setOperationAction(ISD::FFLOOR,             MVT::v8f64, Legal);
1476     setOperationAction(ISD::FCEIL,              MVT::v16f32, Legal);
1477     setOperationAction(ISD::FCEIL,              MVT::v8f64, Legal);
1478     setOperationAction(ISD::FTRUNC,             MVT::v16f32, Legal);
1479     setOperationAction(ISD::FTRUNC,             MVT::v8f64, Legal);
1480     setOperationAction(ISD::FRINT,              MVT::v16f32, Legal);
1481     setOperationAction(ISD::FRINT,              MVT::v8f64, Legal);
1482     setOperationAction(ISD::FNEARBYINT,         MVT::v16f32, Legal);
1483     setOperationAction(ISD::FNEARBYINT,         MVT::v8f64, Legal);
1484
1485     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8f64,  Custom);
1486     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i64,  Custom);
1487     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16f32,  Custom);
1488     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i32,  Custom);
1489     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i1,    Custom);
1490     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i1, Legal);
1491
1492     setOperationAction(ISD::SETCC,              MVT::v16i1, Custom);
1493     setOperationAction(ISD::SETCC,              MVT::v8i1, Custom);
1494
1495     setOperationAction(ISD::MUL,              MVT::v8i64, Custom);
1496
1497     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i1,  Custom);
1498     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i1, Custom);
1499     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i1, Custom);
1500     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i1, Custom);
1501     setOperationAction(ISD::BUILD_VECTOR,       MVT::v8i1, Custom);
1502     setOperationAction(ISD::BUILD_VECTOR,       MVT::v16i1, Custom);
1503     setOperationAction(ISD::SELECT,             MVT::v8f64, Custom);
1504     setOperationAction(ISD::SELECT,             MVT::v8i64, Custom);
1505     setOperationAction(ISD::SELECT,             MVT::v16f32, Custom);
1506
1507     setOperationAction(ISD::ADD,                MVT::v8i64, Legal);
1508     setOperationAction(ISD::ADD,                MVT::v16i32, Legal);
1509
1510     setOperationAction(ISD::SUB,                MVT::v8i64, Legal);
1511     setOperationAction(ISD::SUB,                MVT::v16i32, Legal);
1512
1513     setOperationAction(ISD::MUL,                MVT::v16i32, Legal);
1514
1515     setOperationAction(ISD::SRL,                MVT::v8i64, Custom);
1516     setOperationAction(ISD::SRL,                MVT::v16i32, Custom);
1517
1518     setOperationAction(ISD::SHL,                MVT::v8i64, Custom);
1519     setOperationAction(ISD::SHL,                MVT::v16i32, Custom);
1520
1521     setOperationAction(ISD::SRA,                MVT::v8i64, Custom);
1522     setOperationAction(ISD::SRA,                MVT::v16i32, Custom);
1523
1524     setOperationAction(ISD::AND,                MVT::v8i64, Legal);
1525     setOperationAction(ISD::OR,                 MVT::v8i64, Legal);
1526     setOperationAction(ISD::XOR,                MVT::v8i64, Legal);
1527     setOperationAction(ISD::AND,                MVT::v16i32, Legal);
1528     setOperationAction(ISD::OR,                 MVT::v16i32, Legal);
1529     setOperationAction(ISD::XOR,                MVT::v16i32, Legal);
1530
1531     if (Subtarget->hasCDI()) {
1532       setOperationAction(ISD::CTLZ,             MVT::v8i64, Legal);
1533       setOperationAction(ISD::CTLZ,             MVT::v16i32, Legal);
1534     }
1535
1536     // Custom lower several nodes.
1537     for (MVT VT : MVT::vector_valuetypes()) {
1538       unsigned EltSize = VT.getVectorElementType().getSizeInBits();
1539       // Extract subvector is special because the value type
1540       // (result) is 256/128-bit but the source is 512-bit wide.
1541       if (VT.is128BitVector() || VT.is256BitVector()) {
1542         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Custom);
1543       }
1544       if (VT.getVectorElementType() == MVT::i1)
1545         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Legal);
1546
1547       // Do not attempt to custom lower other non-512-bit vectors
1548       if (!VT.is512BitVector())
1549         continue;
1550
1551       if ( EltSize >= 32) {
1552         setOperationAction(ISD::VECTOR_SHUFFLE,      VT, Custom);
1553         setOperationAction(ISD::INSERT_VECTOR_ELT,   VT, Custom);
1554         setOperationAction(ISD::BUILD_VECTOR,        VT, Custom);
1555         setOperationAction(ISD::VSELECT,             VT, Legal);
1556         setOperationAction(ISD::EXTRACT_VECTOR_ELT,  VT, Custom);
1557         setOperationAction(ISD::SCALAR_TO_VECTOR,    VT, Custom);
1558         setOperationAction(ISD::INSERT_SUBVECTOR,    VT, Custom);
1559         setOperationAction(ISD::MLOAD,               VT, Legal);
1560         setOperationAction(ISD::MSTORE,              VT, Legal);
1561       }
1562     }
1563     for (int i = MVT::v32i8; i != MVT::v8i64; ++i) {
1564       MVT VT = (MVT::SimpleValueType)i;
1565
1566       // Do not attempt to promote non-512-bit vectors.
1567       if (!VT.is512BitVector())
1568         continue;
1569
1570       setOperationAction(ISD::SELECT, VT, Promote);
1571       AddPromotedToType (ISD::SELECT, VT, MVT::v8i64);
1572     }
1573   }// has  AVX-512
1574
1575   if (!TM.Options.UseSoftFloat && Subtarget->hasBWI()) {
1576     addRegisterClass(MVT::v32i16, &X86::VR512RegClass);
1577     addRegisterClass(MVT::v64i8,  &X86::VR512RegClass);
1578
1579     addRegisterClass(MVT::v32i1,  &X86::VK32RegClass);
1580     addRegisterClass(MVT::v64i1,  &X86::VK64RegClass);
1581
1582     setOperationAction(ISD::LOAD,               MVT::v32i16, Legal);
1583     setOperationAction(ISD::LOAD,               MVT::v64i8, Legal);
1584     setOperationAction(ISD::SETCC,              MVT::v32i1, Custom);
1585     setOperationAction(ISD::SETCC,              MVT::v64i1, Custom);
1586     setOperationAction(ISD::ADD,                MVT::v32i16, Legal);
1587     setOperationAction(ISD::ADD,                MVT::v64i8, Legal);
1588     setOperationAction(ISD::SUB,                MVT::v32i16, Legal);
1589     setOperationAction(ISD::SUB,                MVT::v64i8, Legal);
1590     setOperationAction(ISD::MUL,                MVT::v32i16, Legal);
1591
1592     for (int i = MVT::v32i8; i != MVT::v8i64; ++i) {
1593       const MVT VT = (MVT::SimpleValueType)i;
1594
1595       const unsigned EltSize = VT.getVectorElementType().getSizeInBits();
1596
1597       // Do not attempt to promote non-512-bit vectors.
1598       if (!VT.is512BitVector())
1599         continue;
1600
1601       if (EltSize < 32) {
1602         setOperationAction(ISD::BUILD_VECTOR,        VT, Custom);
1603         setOperationAction(ISD::VSELECT,             VT, Legal);
1604       }
1605     }
1606   }
1607
1608   if (!TM.Options.UseSoftFloat && Subtarget->hasVLX()) {
1609     addRegisterClass(MVT::v4i1,   &X86::VK4RegClass);
1610     addRegisterClass(MVT::v2i1,   &X86::VK2RegClass);
1611
1612     setOperationAction(ISD::SETCC,              MVT::v4i1, Custom);
1613     setOperationAction(ISD::SETCC,              MVT::v2i1, Custom);
1614     setOperationAction(ISD::INSERT_SUBVECTOR,   MVT::v8i1, Legal);
1615
1616     setOperationAction(ISD::AND,                MVT::v8i32, Legal);
1617     setOperationAction(ISD::OR,                 MVT::v8i32, Legal);
1618     setOperationAction(ISD::XOR,                MVT::v8i32, Legal);
1619     setOperationAction(ISD::AND,                MVT::v4i32, Legal);
1620     setOperationAction(ISD::OR,                 MVT::v4i32, Legal);
1621     setOperationAction(ISD::XOR,                MVT::v4i32, Legal);
1622   }
1623
1624   // SIGN_EXTEND_INREGs are evaluated by the extend type. Handle the expansion
1625   // of this type with custom code.
1626   for (MVT VT : MVT::vector_valuetypes())
1627     setOperationAction(ISD::SIGN_EXTEND_INREG, VT, Custom);
1628
1629   // We want to custom lower some of our intrinsics.
1630   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
1631   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
1632   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
1633   if (!Subtarget->is64Bit())
1634     setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::i64, Custom);
1635
1636   // Only custom-lower 64-bit SADDO and friends on 64-bit because we don't
1637   // handle type legalization for these operations here.
1638   //
1639   // FIXME: We really should do custom legalization for addition and
1640   // subtraction on x86-32 once PR3203 is fixed.  We really can't do much better
1641   // than generic legalization for 64-bit multiplication-with-overflow, though.
1642   for (unsigned i = 0, e = 3+Subtarget->is64Bit(); i != e; ++i) {
1643     // Add/Sub/Mul with overflow operations are custom lowered.
1644     MVT VT = IntVTs[i];
1645     setOperationAction(ISD::SADDO, VT, Custom);
1646     setOperationAction(ISD::UADDO, VT, Custom);
1647     setOperationAction(ISD::SSUBO, VT, Custom);
1648     setOperationAction(ISD::USUBO, VT, Custom);
1649     setOperationAction(ISD::SMULO, VT, Custom);
1650     setOperationAction(ISD::UMULO, VT, Custom);
1651   }
1652
1653
1654   if (!Subtarget->is64Bit()) {
1655     // These libcalls are not available in 32-bit.
1656     setLibcallName(RTLIB::SHL_I128, nullptr);
1657     setLibcallName(RTLIB::SRL_I128, nullptr);
1658     setLibcallName(RTLIB::SRA_I128, nullptr);
1659   }
1660
1661   // Combine sin / cos into one node or libcall if possible.
1662   if (Subtarget->hasSinCos()) {
1663     setLibcallName(RTLIB::SINCOS_F32, "sincosf");
1664     setLibcallName(RTLIB::SINCOS_F64, "sincos");
1665     if (Subtarget->isTargetDarwin()) {
1666       // For MacOSX, we don't want the normal expansion of a libcall to sincos.
1667       // We want to issue a libcall to __sincos_stret to avoid memory traffic.
1668       setOperationAction(ISD::FSINCOS, MVT::f64, Custom);
1669       setOperationAction(ISD::FSINCOS, MVT::f32, Custom);
1670     }
1671   }
1672
1673   if (Subtarget->isTargetWin64()) {
1674     setOperationAction(ISD::SDIV, MVT::i128, Custom);
1675     setOperationAction(ISD::UDIV, MVT::i128, Custom);
1676     setOperationAction(ISD::SREM, MVT::i128, Custom);
1677     setOperationAction(ISD::UREM, MVT::i128, Custom);
1678     setOperationAction(ISD::SDIVREM, MVT::i128, Custom);
1679     setOperationAction(ISD::UDIVREM, MVT::i128, Custom);
1680   }
1681
1682   // We have target-specific dag combine patterns for the following nodes:
1683   setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
1684   setTargetDAGCombine(ISD::EXTRACT_VECTOR_ELT);
1685   setTargetDAGCombine(ISD::BITCAST);
1686   setTargetDAGCombine(ISD::VSELECT);
1687   setTargetDAGCombine(ISD::SELECT);
1688   setTargetDAGCombine(ISD::SHL);
1689   setTargetDAGCombine(ISD::SRA);
1690   setTargetDAGCombine(ISD::SRL);
1691   setTargetDAGCombine(ISD::OR);
1692   setTargetDAGCombine(ISD::AND);
1693   setTargetDAGCombine(ISD::ADD);
1694   setTargetDAGCombine(ISD::FADD);
1695   setTargetDAGCombine(ISD::FSUB);
1696   setTargetDAGCombine(ISD::FMA);
1697   setTargetDAGCombine(ISD::SUB);
1698   setTargetDAGCombine(ISD::LOAD);
1699   setTargetDAGCombine(ISD::MLOAD);
1700   setTargetDAGCombine(ISD::STORE);
1701   setTargetDAGCombine(ISD::MSTORE);
1702   setTargetDAGCombine(ISD::ZERO_EXTEND);
1703   setTargetDAGCombine(ISD::ANY_EXTEND);
1704   setTargetDAGCombine(ISD::SIGN_EXTEND);
1705   setTargetDAGCombine(ISD::SIGN_EXTEND_INREG);
1706   setTargetDAGCombine(ISD::TRUNCATE);
1707   setTargetDAGCombine(ISD::SINT_TO_FP);
1708   setTargetDAGCombine(ISD::SETCC);
1709   setTargetDAGCombine(ISD::INTRINSIC_WO_CHAIN);
1710   setTargetDAGCombine(ISD::BUILD_VECTOR);
1711   setTargetDAGCombine(ISD::MUL);
1712   setTargetDAGCombine(ISD::XOR);
1713
1714   computeRegisterProperties();
1715
1716   // On Darwin, -Os means optimize for size without hurting performance,
1717   // do not reduce the limit.
1718   MaxStoresPerMemset = 16; // For @llvm.memset -> sequence of stores
1719   MaxStoresPerMemsetOptSize = Subtarget->isTargetDarwin() ? 16 : 8;
1720   MaxStoresPerMemcpy = 8; // For @llvm.memcpy -> sequence of stores
1721   MaxStoresPerMemcpyOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1722   MaxStoresPerMemmove = 8; // For @llvm.memmove -> sequence of stores
1723   MaxStoresPerMemmoveOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1724   setPrefLoopAlignment(4); // 2^4 bytes.
1725
1726   // Predictable cmov don't hurt on atom because it's in-order.
1727   PredictableSelectIsExpensive = !Subtarget->isAtom();
1728   EnableExtLdPromotion = true;
1729   setPrefFunctionAlignment(4); // 2^4 bytes.
1730
1731   verifyIntrinsicTables();
1732 }
1733
1734 // This has so far only been implemented for 64-bit MachO.
1735 bool X86TargetLowering::useLoadStackGuardNode() const {
1736   return Subtarget->isTargetMachO() && Subtarget->is64Bit();
1737 }
1738
1739 TargetLoweringBase::LegalizeTypeAction
1740 X86TargetLowering::getPreferredVectorAction(EVT VT) const {
1741   if (ExperimentalVectorWideningLegalization &&
1742       VT.getVectorNumElements() != 1 &&
1743       VT.getVectorElementType().getSimpleVT() != MVT::i1)
1744     return TypeWidenVector;
1745
1746   return TargetLoweringBase::getPreferredVectorAction(VT);
1747 }
1748
1749 EVT X86TargetLowering::getSetCCResultType(LLVMContext &, EVT VT) const {
1750   if (!VT.isVector())
1751     return Subtarget->hasAVX512() ? MVT::i1: MVT::i8;
1752
1753   const unsigned NumElts = VT.getVectorNumElements();
1754   const EVT EltVT = VT.getVectorElementType();
1755   if (VT.is512BitVector()) {
1756     if (Subtarget->hasAVX512())
1757       if (EltVT == MVT::i32 || EltVT == MVT::i64 ||
1758           EltVT == MVT::f32 || EltVT == MVT::f64)
1759         switch(NumElts) {
1760         case  8: return MVT::v8i1;
1761         case 16: return MVT::v16i1;
1762       }
1763     if (Subtarget->hasBWI())
1764       if (EltVT == MVT::i8 || EltVT == MVT::i16)
1765         switch(NumElts) {
1766         case 32: return MVT::v32i1;
1767         case 64: return MVT::v64i1;
1768       }
1769   }
1770
1771   if (VT.is256BitVector() || VT.is128BitVector()) {
1772     if (Subtarget->hasVLX())
1773       if (EltVT == MVT::i32 || EltVT == MVT::i64 ||
1774           EltVT == MVT::f32 || EltVT == MVT::f64)
1775         switch(NumElts) {
1776         case 2: return MVT::v2i1;
1777         case 4: return MVT::v4i1;
1778         case 8: return MVT::v8i1;
1779       }
1780     if (Subtarget->hasBWI() && Subtarget->hasVLX())
1781       if (EltVT == MVT::i8 || EltVT == MVT::i16)
1782         switch(NumElts) {
1783         case  8: return MVT::v8i1;
1784         case 16: return MVT::v16i1;
1785         case 32: return MVT::v32i1;
1786       }
1787   }
1788
1789   return VT.changeVectorElementTypeToInteger();
1790 }
1791
1792 /// Helper for getByValTypeAlignment to determine
1793 /// the desired ByVal argument alignment.
1794 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign) {
1795   if (MaxAlign == 16)
1796     return;
1797   if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
1798     if (VTy->getBitWidth() == 128)
1799       MaxAlign = 16;
1800   } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
1801     unsigned EltAlign = 0;
1802     getMaxByValAlign(ATy->getElementType(), EltAlign);
1803     if (EltAlign > MaxAlign)
1804       MaxAlign = EltAlign;
1805   } else if (StructType *STy = dyn_cast<StructType>(Ty)) {
1806     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1807       unsigned EltAlign = 0;
1808       getMaxByValAlign(STy->getElementType(i), EltAlign);
1809       if (EltAlign > MaxAlign)
1810         MaxAlign = EltAlign;
1811       if (MaxAlign == 16)
1812         break;
1813     }
1814   }
1815 }
1816
1817 /// Return the desired alignment for ByVal aggregate
1818 /// function arguments in the caller parameter area. For X86, aggregates
1819 /// that contain SSE vectors are placed at 16-byte boundaries while the rest
1820 /// are at 4-byte boundaries.
1821 unsigned X86TargetLowering::getByValTypeAlignment(Type *Ty) const {
1822   if (Subtarget->is64Bit()) {
1823     // Max of 8 and alignment of type.
1824     unsigned TyAlign = TD->getABITypeAlignment(Ty);
1825     if (TyAlign > 8)
1826       return TyAlign;
1827     return 8;
1828   }
1829
1830   unsigned Align = 4;
1831   if (Subtarget->hasSSE1())
1832     getMaxByValAlign(Ty, Align);
1833   return Align;
1834 }
1835
1836 /// Returns the target specific optimal type for load
1837 /// and store operations as a result of memset, memcpy, and memmove
1838 /// lowering. If DstAlign is zero that means it's safe to destination
1839 /// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
1840 /// means there isn't a need to check it against alignment requirement,
1841 /// probably because the source does not need to be loaded. If 'IsMemset' is
1842 /// true, that means it's expanding a memset. If 'ZeroMemset' is true, that
1843 /// means it's a memset of zero. 'MemcpyStrSrc' indicates whether the memcpy
1844 /// source is constant so it does not need to be loaded.
1845 /// It returns EVT::Other if the type should be determined using generic
1846 /// target-independent logic.
1847 EVT
1848 X86TargetLowering::getOptimalMemOpType(uint64_t Size,
1849                                        unsigned DstAlign, unsigned SrcAlign,
1850                                        bool IsMemset, bool ZeroMemset,
1851                                        bool MemcpyStrSrc,
1852                                        MachineFunction &MF) const {
1853   const Function *F = MF.getFunction();
1854   if ((!IsMemset || ZeroMemset) &&
1855       !F->hasFnAttribute(Attribute::NoImplicitFloat)) {
1856     if (Size >= 16 &&
1857         (Subtarget->isUnalignedMemAccessFast() ||
1858          ((DstAlign == 0 || DstAlign >= 16) &&
1859           (SrcAlign == 0 || SrcAlign >= 16)))) {
1860       if (Size >= 32) {
1861         if (Subtarget->hasInt256())
1862           return MVT::v8i32;
1863         if (Subtarget->hasFp256())
1864           return MVT::v8f32;
1865       }
1866       if (Subtarget->hasSSE2())
1867         return MVT::v4i32;
1868       if (Subtarget->hasSSE1())
1869         return MVT::v4f32;
1870     } else if (!MemcpyStrSrc && Size >= 8 &&
1871                !Subtarget->is64Bit() &&
1872                Subtarget->hasSSE2()) {
1873       // Do not use f64 to lower memcpy if source is string constant. It's
1874       // better to use i32 to avoid the loads.
1875       return MVT::f64;
1876     }
1877   }
1878   if (Subtarget->is64Bit() && Size >= 8)
1879     return MVT::i64;
1880   return MVT::i32;
1881 }
1882
1883 bool X86TargetLowering::isSafeMemOpType(MVT VT) const {
1884   if (VT == MVT::f32)
1885     return X86ScalarSSEf32;
1886   else if (VT == MVT::f64)
1887     return X86ScalarSSEf64;
1888   return true;
1889 }
1890
1891 bool
1892 X86TargetLowering::allowsMisalignedMemoryAccesses(EVT VT,
1893                                                   unsigned,
1894                                                   unsigned,
1895                                                   bool *Fast) const {
1896   if (Fast)
1897     *Fast = Subtarget->isUnalignedMemAccessFast();
1898   return true;
1899 }
1900
1901 /// Return the entry encoding for a jump table in the
1902 /// current function.  The returned value is a member of the
1903 /// MachineJumpTableInfo::JTEntryKind enum.
1904 unsigned X86TargetLowering::getJumpTableEncoding() const {
1905   // In GOT pic mode, each entry in the jump table is emitted as a @GOTOFF
1906   // symbol.
1907   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1908       Subtarget->isPICStyleGOT())
1909     return MachineJumpTableInfo::EK_Custom32;
1910
1911   // Otherwise, use the normal jump table encoding heuristics.
1912   return TargetLowering::getJumpTableEncoding();
1913 }
1914
1915 const MCExpr *
1916 X86TargetLowering::LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
1917                                              const MachineBasicBlock *MBB,
1918                                              unsigned uid,MCContext &Ctx) const{
1919   assert(MBB->getParent()->getTarget().getRelocationModel() == Reloc::PIC_ &&
1920          Subtarget->isPICStyleGOT());
1921   // In 32-bit ELF systems, our jump table entries are formed with @GOTOFF
1922   // entries.
1923   return MCSymbolRefExpr::Create(MBB->getSymbol(),
1924                                  MCSymbolRefExpr::VK_GOTOFF, Ctx);
1925 }
1926
1927 /// Returns relocation base for the given PIC jumptable.
1928 SDValue X86TargetLowering::getPICJumpTableRelocBase(SDValue Table,
1929                                                     SelectionDAG &DAG) const {
1930   if (!Subtarget->is64Bit())
1931     // This doesn't have SDLoc associated with it, but is not really the
1932     // same as a Register.
1933     return DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy());
1934   return Table;
1935 }
1936
1937 /// This returns the relocation base for the given PIC jumptable,
1938 /// the same as getPICJumpTableRelocBase, but as an MCExpr.
1939 const MCExpr *X86TargetLowering::
1940 getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI,
1941                              MCContext &Ctx) const {
1942   // X86-64 uses RIP relative addressing based on the jump table label.
1943   if (Subtarget->isPICStyleRIPRel())
1944     return TargetLowering::getPICJumpTableRelocBaseExpr(MF, JTI, Ctx);
1945
1946   // Otherwise, the reference is relative to the PIC base.
1947   return MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx);
1948 }
1949
1950 // FIXME: Why this routine is here? Move to RegInfo!
1951 std::pair<const TargetRegisterClass*, uint8_t>
1952 X86TargetLowering::findRepresentativeClass(MVT VT) const{
1953   const TargetRegisterClass *RRC = nullptr;
1954   uint8_t Cost = 1;
1955   switch (VT.SimpleTy) {
1956   default:
1957     return TargetLowering::findRepresentativeClass(VT);
1958   case MVT::i8: case MVT::i16: case MVT::i32: case MVT::i64:
1959     RRC = Subtarget->is64Bit() ? &X86::GR64RegClass : &X86::GR32RegClass;
1960     break;
1961   case MVT::x86mmx:
1962     RRC = &X86::VR64RegClass;
1963     break;
1964   case MVT::f32: case MVT::f64:
1965   case MVT::v16i8: case MVT::v8i16: case MVT::v4i32: case MVT::v2i64:
1966   case MVT::v4f32: case MVT::v2f64:
1967   case MVT::v32i8: case MVT::v8i32: case MVT::v4i64: case MVT::v8f32:
1968   case MVT::v4f64:
1969     RRC = &X86::VR128RegClass;
1970     break;
1971   }
1972   return std::make_pair(RRC, Cost);
1973 }
1974
1975 bool X86TargetLowering::getStackCookieLocation(unsigned &AddressSpace,
1976                                                unsigned &Offset) const {
1977   if (!Subtarget->isTargetLinux())
1978     return false;
1979
1980   if (Subtarget->is64Bit()) {
1981     // %fs:0x28, unless we're using a Kernel code model, in which case it's %gs:
1982     Offset = 0x28;
1983     if (getTargetMachine().getCodeModel() == CodeModel::Kernel)
1984       AddressSpace = 256;
1985     else
1986       AddressSpace = 257;
1987   } else {
1988     // %gs:0x14 on i386
1989     Offset = 0x14;
1990     AddressSpace = 256;
1991   }
1992   return true;
1993 }
1994
1995 bool X86TargetLowering::isNoopAddrSpaceCast(unsigned SrcAS,
1996                                             unsigned DestAS) const {
1997   assert(SrcAS != DestAS && "Expected different address spaces!");
1998
1999   return SrcAS < 256 && DestAS < 256;
2000 }
2001
2002 //===----------------------------------------------------------------------===//
2003 //               Return Value Calling Convention Implementation
2004 //===----------------------------------------------------------------------===//
2005
2006 #include "X86GenCallingConv.inc"
2007
2008 bool
2009 X86TargetLowering::CanLowerReturn(CallingConv::ID CallConv,
2010                                   MachineFunction &MF, bool isVarArg,
2011                         const SmallVectorImpl<ISD::OutputArg> &Outs,
2012                         LLVMContext &Context) const {
2013   SmallVector<CCValAssign, 16> RVLocs;
2014   CCState CCInfo(CallConv, isVarArg, MF, RVLocs, Context);
2015   return CCInfo.CheckReturn(Outs, RetCC_X86);
2016 }
2017
2018 const MCPhysReg *X86TargetLowering::getScratchRegisters(CallingConv::ID) const {
2019   static const MCPhysReg ScratchRegs[] = { X86::R11, 0 };
2020   return ScratchRegs;
2021 }
2022
2023 SDValue
2024 X86TargetLowering::LowerReturn(SDValue Chain,
2025                                CallingConv::ID CallConv, bool isVarArg,
2026                                const SmallVectorImpl<ISD::OutputArg> &Outs,
2027                                const SmallVectorImpl<SDValue> &OutVals,
2028                                SDLoc dl, SelectionDAG &DAG) const {
2029   MachineFunction &MF = DAG.getMachineFunction();
2030   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2031
2032   SmallVector<CCValAssign, 16> RVLocs;
2033   CCState CCInfo(CallConv, isVarArg, MF, RVLocs, *DAG.getContext());
2034   CCInfo.AnalyzeReturn(Outs, RetCC_X86);
2035
2036   SDValue Flag;
2037   SmallVector<SDValue, 6> RetOps;
2038   RetOps.push_back(Chain); // Operand #0 = Chain (updated below)
2039   // Operand #1 = Bytes To Pop
2040   RetOps.push_back(DAG.getTargetConstant(FuncInfo->getBytesToPopOnReturn(),
2041                    MVT::i16));
2042
2043   // Copy the result values into the output registers.
2044   for (unsigned i = 0; i != RVLocs.size(); ++i) {
2045     CCValAssign &VA = RVLocs[i];
2046     assert(VA.isRegLoc() && "Can only return in registers!");
2047     SDValue ValToCopy = OutVals[i];
2048     EVT ValVT = ValToCopy.getValueType();
2049
2050     // Promote values to the appropriate types.
2051     if (VA.getLocInfo() == CCValAssign::SExt)
2052       ValToCopy = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), ValToCopy);
2053     else if (VA.getLocInfo() == CCValAssign::ZExt)
2054       ValToCopy = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), ValToCopy);
2055     else if (VA.getLocInfo() == CCValAssign::AExt)
2056       ValToCopy = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), ValToCopy);
2057     else if (VA.getLocInfo() == CCValAssign::BCvt)
2058       ValToCopy = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), ValToCopy);
2059
2060     assert(VA.getLocInfo() != CCValAssign::FPExt &&
2061            "Unexpected FP-extend for return value.");
2062
2063     // If this is x86-64, and we disabled SSE, we can't return FP values,
2064     // or SSE or MMX vectors.
2065     if ((ValVT == MVT::f32 || ValVT == MVT::f64 ||
2066          VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) &&
2067           (Subtarget->is64Bit() && !Subtarget->hasSSE1())) {
2068       report_fatal_error("SSE register return with SSE disabled");
2069     }
2070     // Likewise we can't return F64 values with SSE1 only.  gcc does so, but
2071     // llvm-gcc has never done it right and no one has noticed, so this
2072     // should be OK for now.
2073     if (ValVT == MVT::f64 &&
2074         (Subtarget->is64Bit() && !Subtarget->hasSSE2()))
2075       report_fatal_error("SSE2 register return with SSE2 disabled");
2076
2077     // Returns in ST0/ST1 are handled specially: these are pushed as operands to
2078     // the RET instruction and handled by the FP Stackifier.
2079     if (VA.getLocReg() == X86::FP0 ||
2080         VA.getLocReg() == X86::FP1) {
2081       // If this is a copy from an xmm register to ST(0), use an FPExtend to
2082       // change the value to the FP stack register class.
2083       if (isScalarFPTypeInSSEReg(VA.getValVT()))
2084         ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
2085       RetOps.push_back(ValToCopy);
2086       // Don't emit a copytoreg.
2087       continue;
2088     }
2089
2090     // 64-bit vector (MMX) values are returned in XMM0 / XMM1 except for v1i64
2091     // which is returned in RAX / RDX.
2092     if (Subtarget->is64Bit()) {
2093       if (ValVT == MVT::x86mmx) {
2094         if (VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) {
2095           ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ValToCopy);
2096           ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
2097                                   ValToCopy);
2098           // If we don't have SSE2 available, convert to v4f32 so the generated
2099           // register is legal.
2100           if (!Subtarget->hasSSE2())
2101             ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32,ValToCopy);
2102         }
2103       }
2104     }
2105
2106     Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), ValToCopy, Flag);
2107     Flag = Chain.getValue(1);
2108     RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2109   }
2110
2111   // The x86-64 ABIs require that for returning structs by value we copy
2112   // the sret argument into %rax/%eax (depending on ABI) for the return.
2113   // Win32 requires us to put the sret argument to %eax as well.
2114   // We saved the argument into a virtual register in the entry block,
2115   // so now we copy the value out and into %rax/%eax.
2116   //
2117   // Checking Function.hasStructRetAttr() here is insufficient because the IR
2118   // may not have an explicit sret argument. If FuncInfo.CanLowerReturn is
2119   // false, then an sret argument may be implicitly inserted in the SelDAG. In
2120   // either case FuncInfo->setSRetReturnReg() will have been called.
2121   if (unsigned SRetReg = FuncInfo->getSRetReturnReg()) {
2122     assert((Subtarget->is64Bit() || Subtarget->isTargetKnownWindowsMSVC()) &&
2123            "No need for an sret register");
2124     SDValue Val = DAG.getCopyFromReg(Chain, dl, SRetReg, getPointerTy());
2125
2126     unsigned RetValReg
2127         = (Subtarget->is64Bit() && !Subtarget->isTarget64BitILP32()) ?
2128           X86::RAX : X86::EAX;
2129     Chain = DAG.getCopyToReg(Chain, dl, RetValReg, Val, Flag);
2130     Flag = Chain.getValue(1);
2131
2132     // RAX/EAX now acts like a return value.
2133     RetOps.push_back(DAG.getRegister(RetValReg, getPointerTy()));
2134   }
2135
2136   RetOps[0] = Chain;  // Update chain.
2137
2138   // Add the flag if we have it.
2139   if (Flag.getNode())
2140     RetOps.push_back(Flag);
2141
2142   return DAG.getNode(X86ISD::RET_FLAG, dl, MVT::Other, RetOps);
2143 }
2144
2145 bool X86TargetLowering::isUsedByReturnOnly(SDNode *N, SDValue &Chain) const {
2146   if (N->getNumValues() != 1)
2147     return false;
2148   if (!N->hasNUsesOfValue(1, 0))
2149     return false;
2150
2151   SDValue TCChain = Chain;
2152   SDNode *Copy = *N->use_begin();
2153   if (Copy->getOpcode() == ISD::CopyToReg) {
2154     // If the copy has a glue operand, we conservatively assume it isn't safe to
2155     // perform a tail call.
2156     if (Copy->getOperand(Copy->getNumOperands()-1).getValueType() == MVT::Glue)
2157       return false;
2158     TCChain = Copy->getOperand(0);
2159   } else if (Copy->getOpcode() != ISD::FP_EXTEND)
2160     return false;
2161
2162   bool HasRet = false;
2163   for (SDNode::use_iterator UI = Copy->use_begin(), UE = Copy->use_end();
2164        UI != UE; ++UI) {
2165     if (UI->getOpcode() != X86ISD::RET_FLAG)
2166       return false;
2167     // If we are returning more than one value, we can definitely
2168     // not make a tail call see PR19530
2169     if (UI->getNumOperands() > 4)
2170       return false;
2171     if (UI->getNumOperands() == 4 &&
2172         UI->getOperand(UI->getNumOperands()-1).getValueType() != MVT::Glue)
2173       return false;
2174     HasRet = true;
2175   }
2176
2177   if (!HasRet)
2178     return false;
2179
2180   Chain = TCChain;
2181   return true;
2182 }
2183
2184 EVT
2185 X86TargetLowering::getTypeForExtArgOrReturn(LLVMContext &Context, EVT VT,
2186                                             ISD::NodeType ExtendKind) const {
2187   MVT ReturnMVT;
2188   // TODO: Is this also valid on 32-bit?
2189   if (Subtarget->is64Bit() && VT == MVT::i1 && ExtendKind == ISD::ZERO_EXTEND)
2190     ReturnMVT = MVT::i8;
2191   else
2192     ReturnMVT = MVT::i32;
2193
2194   EVT MinVT = getRegisterType(Context, ReturnMVT);
2195   return VT.bitsLT(MinVT) ? MinVT : VT;
2196 }
2197
2198 /// Lower the result values of a call into the
2199 /// appropriate copies out of appropriate physical registers.
2200 ///
2201 SDValue
2202 X86TargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
2203                                    CallingConv::ID CallConv, bool isVarArg,
2204                                    const SmallVectorImpl<ISD::InputArg> &Ins,
2205                                    SDLoc dl, SelectionDAG &DAG,
2206                                    SmallVectorImpl<SDValue> &InVals) const {
2207
2208   // Assign locations to each value returned by this call.
2209   SmallVector<CCValAssign, 16> RVLocs;
2210   bool Is64Bit = Subtarget->is64Bit();
2211   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
2212                  *DAG.getContext());
2213   CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
2214
2215   // Copy all of the result registers out of their specified physreg.
2216   for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
2217     CCValAssign &VA = RVLocs[i];
2218     EVT CopyVT = VA.getValVT();
2219
2220     // If this is x86-64, and we disabled SSE, we can't return FP values
2221     if ((CopyVT == MVT::f32 || CopyVT == MVT::f64) &&
2222         ((Is64Bit || Ins[i].Flags.isInReg()) && !Subtarget->hasSSE1())) {
2223       report_fatal_error("SSE register return with SSE disabled");
2224     }
2225
2226     // If we prefer to use the value in xmm registers, copy it out as f80 and
2227     // use a truncate to move it from fp stack reg to xmm reg.
2228     if ((VA.getLocReg() == X86::FP0 || VA.getLocReg() == X86::FP1) &&
2229         isScalarFPTypeInSSEReg(VA.getValVT()))
2230       CopyVT = MVT::f80;
2231
2232     Chain = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(),
2233                                CopyVT, InFlag).getValue(1);
2234     SDValue Val = Chain.getValue(0);
2235
2236     if (CopyVT != VA.getValVT())
2237       Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
2238                         // This truncation won't change the value.
2239                         DAG.getIntPtrConstant(1));
2240
2241     InFlag = Chain.getValue(2);
2242     InVals.push_back(Val);
2243   }
2244
2245   return Chain;
2246 }
2247
2248 //===----------------------------------------------------------------------===//
2249 //                C & StdCall & Fast Calling Convention implementation
2250 //===----------------------------------------------------------------------===//
2251 //  StdCall calling convention seems to be standard for many Windows' API
2252 //  routines and around. It differs from C calling convention just a little:
2253 //  callee should clean up the stack, not caller. Symbols should be also
2254 //  decorated in some fancy way :) It doesn't support any vector arguments.
2255 //  For info on fast calling convention see Fast Calling Convention (tail call)
2256 //  implementation LowerX86_32FastCCCallTo.
2257
2258 /// CallIsStructReturn - Determines whether a call uses struct return
2259 /// semantics.
2260 enum StructReturnType {
2261   NotStructReturn,
2262   RegStructReturn,
2263   StackStructReturn
2264 };
2265 static StructReturnType
2266 callIsStructReturn(const SmallVectorImpl<ISD::OutputArg> &Outs) {
2267   if (Outs.empty())
2268     return NotStructReturn;
2269
2270   const ISD::ArgFlagsTy &Flags = Outs[0].Flags;
2271   if (!Flags.isSRet())
2272     return NotStructReturn;
2273   if (Flags.isInReg())
2274     return RegStructReturn;
2275   return StackStructReturn;
2276 }
2277
2278 /// Determines whether a function uses struct return semantics.
2279 static StructReturnType
2280 argsAreStructReturn(const SmallVectorImpl<ISD::InputArg> &Ins) {
2281   if (Ins.empty())
2282     return NotStructReturn;
2283
2284   const ISD::ArgFlagsTy &Flags = Ins[0].Flags;
2285   if (!Flags.isSRet())
2286     return NotStructReturn;
2287   if (Flags.isInReg())
2288     return RegStructReturn;
2289   return StackStructReturn;
2290 }
2291
2292 /// Make a copy of an aggregate at address specified by "Src" to address
2293 /// "Dst" with size and alignment information specified by the specific
2294 /// parameter attribute. The copy will be passed as a byval function parameter.
2295 static SDValue
2296 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
2297                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
2298                           SDLoc dl) {
2299   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
2300
2301   return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
2302                        /*isVolatile*/false, /*AlwaysInline=*/true,
2303                        MachinePointerInfo(), MachinePointerInfo());
2304 }
2305
2306 /// Return true if the calling convention is one that
2307 /// supports tail call optimization.
2308 static bool IsTailCallConvention(CallingConv::ID CC) {
2309   return (CC == CallingConv::Fast || CC == CallingConv::GHC ||
2310           CC == CallingConv::HiPE);
2311 }
2312
2313 /// \brief Return true if the calling convention is a C calling convention.
2314 static bool IsCCallConvention(CallingConv::ID CC) {
2315   return (CC == CallingConv::C || CC == CallingConv::X86_64_Win64 ||
2316           CC == CallingConv::X86_64_SysV);
2317 }
2318
2319 bool X86TargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
2320   if (!CI->isTailCall() || getTargetMachine().Options.DisableTailCalls)
2321     return false;
2322
2323   CallSite CS(CI);
2324   CallingConv::ID CalleeCC = CS.getCallingConv();
2325   if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
2326     return false;
2327
2328   return true;
2329 }
2330
2331 /// Return true if the function is being made into
2332 /// a tailcall target by changing its ABI.
2333 static bool FuncIsMadeTailCallSafe(CallingConv::ID CC,
2334                                    bool GuaranteedTailCallOpt) {
2335   return GuaranteedTailCallOpt && IsTailCallConvention(CC);
2336 }
2337
2338 SDValue
2339 X86TargetLowering::LowerMemArgument(SDValue Chain,
2340                                     CallingConv::ID CallConv,
2341                                     const SmallVectorImpl<ISD::InputArg> &Ins,
2342                                     SDLoc dl, SelectionDAG &DAG,
2343                                     const CCValAssign &VA,
2344                                     MachineFrameInfo *MFI,
2345                                     unsigned i) const {
2346   // Create the nodes corresponding to a load from this parameter slot.
2347   ISD::ArgFlagsTy Flags = Ins[i].Flags;
2348   bool AlwaysUseMutable = FuncIsMadeTailCallSafe(
2349       CallConv, DAG.getTarget().Options.GuaranteedTailCallOpt);
2350   bool isImmutable = !AlwaysUseMutable && !Flags.isByVal();
2351   EVT ValVT;
2352
2353   // If value is passed by pointer we have address passed instead of the value
2354   // itself.
2355   if (VA.getLocInfo() == CCValAssign::Indirect)
2356     ValVT = VA.getLocVT();
2357   else
2358     ValVT = VA.getValVT();
2359
2360   // FIXME: For now, all byval parameter objects are marked mutable. This can be
2361   // changed with more analysis.
2362   // In case of tail call optimization mark all arguments mutable. Since they
2363   // could be overwritten by lowering of arguments in case of a tail call.
2364   if (Flags.isByVal()) {
2365     unsigned Bytes = Flags.getByValSize();
2366     if (Bytes == 0) Bytes = 1; // Don't create zero-sized stack objects.
2367     int FI = MFI->CreateFixedObject(Bytes, VA.getLocMemOffset(), isImmutable);
2368     return DAG.getFrameIndex(FI, getPointerTy());
2369   } else {
2370     int FI = MFI->CreateFixedObject(ValVT.getSizeInBits()/8,
2371                                     VA.getLocMemOffset(), isImmutable);
2372     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2373     return DAG.getLoad(ValVT, dl, Chain, FIN,
2374                        MachinePointerInfo::getFixedStack(FI),
2375                        false, false, false, 0);
2376   }
2377 }
2378
2379 // FIXME: Get this from tablegen.
2380 static ArrayRef<MCPhysReg> get64BitArgumentGPRs(CallingConv::ID CallConv,
2381                                                 const X86Subtarget *Subtarget) {
2382   assert(Subtarget->is64Bit());
2383
2384   if (Subtarget->isCallingConvWin64(CallConv)) {
2385     static const MCPhysReg GPR64ArgRegsWin64[] = {
2386       X86::RCX, X86::RDX, X86::R8,  X86::R9
2387     };
2388     return makeArrayRef(std::begin(GPR64ArgRegsWin64), std::end(GPR64ArgRegsWin64));
2389   }
2390
2391   static const MCPhysReg GPR64ArgRegs64Bit[] = {
2392     X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
2393   };
2394   return makeArrayRef(std::begin(GPR64ArgRegs64Bit), std::end(GPR64ArgRegs64Bit));
2395 }
2396
2397 // FIXME: Get this from tablegen.
2398 static ArrayRef<MCPhysReg> get64BitArgumentXMMs(MachineFunction &MF,
2399                                                 CallingConv::ID CallConv,
2400                                                 const X86Subtarget *Subtarget) {
2401   assert(Subtarget->is64Bit());
2402   if (Subtarget->isCallingConvWin64(CallConv)) {
2403     // The XMM registers which might contain var arg parameters are shadowed
2404     // in their paired GPR.  So we only need to save the GPR to their home
2405     // slots.
2406     // TODO: __vectorcall will change this.
2407     return None;
2408   }
2409
2410   const Function *Fn = MF.getFunction();
2411   bool NoImplicitFloatOps = Fn->hasFnAttribute(Attribute::NoImplicitFloat);
2412   assert(!(MF.getTarget().Options.UseSoftFloat && NoImplicitFloatOps) &&
2413          "SSE register cannot be used when SSE is disabled!");
2414   if (MF.getTarget().Options.UseSoftFloat || NoImplicitFloatOps ||
2415       !Subtarget->hasSSE1())
2416     // Kernel mode asks for SSE to be disabled, so there are no XMM argument
2417     // registers.
2418     return None;
2419
2420   static const MCPhysReg XMMArgRegs64Bit[] = {
2421     X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
2422     X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
2423   };
2424   return makeArrayRef(std::begin(XMMArgRegs64Bit), std::end(XMMArgRegs64Bit));
2425 }
2426
2427 SDValue
2428 X86TargetLowering::LowerFormalArguments(SDValue Chain,
2429                                         CallingConv::ID CallConv,
2430                                         bool isVarArg,
2431                                       const SmallVectorImpl<ISD::InputArg> &Ins,
2432                                         SDLoc dl,
2433                                         SelectionDAG &DAG,
2434                                         SmallVectorImpl<SDValue> &InVals)
2435                                           const {
2436   MachineFunction &MF = DAG.getMachineFunction();
2437   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2438
2439   const Function* Fn = MF.getFunction();
2440   if (Fn->hasExternalLinkage() &&
2441       Subtarget->isTargetCygMing() &&
2442       Fn->getName() == "main")
2443     FuncInfo->setForceFramePointer(true);
2444
2445   MachineFrameInfo *MFI = MF.getFrameInfo();
2446   bool Is64Bit = Subtarget->is64Bit();
2447   bool IsWin64 = Subtarget->isCallingConvWin64(CallConv);
2448
2449   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2450          "Var args not supported with calling convention fastcc, ghc or hipe");
2451
2452   // Assign locations to all of the incoming arguments.
2453   SmallVector<CCValAssign, 16> ArgLocs;
2454   CCState CCInfo(CallConv, isVarArg, MF, ArgLocs, *DAG.getContext());
2455
2456   // Allocate shadow area for Win64
2457   if (IsWin64)
2458     CCInfo.AllocateStack(32, 8);
2459
2460   CCInfo.AnalyzeFormalArguments(Ins, CC_X86);
2461
2462   unsigned LastVal = ~0U;
2463   SDValue ArgValue;
2464   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2465     CCValAssign &VA = ArgLocs[i];
2466     // TODO: If an arg is passed in two places (e.g. reg and stack), skip later
2467     // places.
2468     assert(VA.getValNo() != LastVal &&
2469            "Don't support value assigned to multiple locs yet");
2470     (void)LastVal;
2471     LastVal = VA.getValNo();
2472
2473     if (VA.isRegLoc()) {
2474       EVT RegVT = VA.getLocVT();
2475       const TargetRegisterClass *RC;
2476       if (RegVT == MVT::i32)
2477         RC = &X86::GR32RegClass;
2478       else if (Is64Bit && RegVT == MVT::i64)
2479         RC = &X86::GR64RegClass;
2480       else if (RegVT == MVT::f32)
2481         RC = &X86::FR32RegClass;
2482       else if (RegVT == MVT::f64)
2483         RC = &X86::FR64RegClass;
2484       else if (RegVT.is512BitVector())
2485         RC = &X86::VR512RegClass;
2486       else if (RegVT.is256BitVector())
2487         RC = &X86::VR256RegClass;
2488       else if (RegVT.is128BitVector())
2489         RC = &X86::VR128RegClass;
2490       else if (RegVT == MVT::x86mmx)
2491         RC = &X86::VR64RegClass;
2492       else if (RegVT == MVT::i1)
2493         RC = &X86::VK1RegClass;
2494       else if (RegVT == MVT::v8i1)
2495         RC = &X86::VK8RegClass;
2496       else if (RegVT == MVT::v16i1)
2497         RC = &X86::VK16RegClass;
2498       else if (RegVT == MVT::v32i1)
2499         RC = &X86::VK32RegClass;
2500       else if (RegVT == MVT::v64i1)
2501         RC = &X86::VK64RegClass;
2502       else
2503         llvm_unreachable("Unknown argument type!");
2504
2505       unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
2506       ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
2507
2508       // If this is an 8 or 16-bit value, it is really passed promoted to 32
2509       // bits.  Insert an assert[sz]ext to capture this, then truncate to the
2510       // right size.
2511       if (VA.getLocInfo() == CCValAssign::SExt)
2512         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
2513                                DAG.getValueType(VA.getValVT()));
2514       else if (VA.getLocInfo() == CCValAssign::ZExt)
2515         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
2516                                DAG.getValueType(VA.getValVT()));
2517       else if (VA.getLocInfo() == CCValAssign::BCvt)
2518         ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
2519
2520       if (VA.isExtInLoc()) {
2521         // Handle MMX values passed in XMM regs.
2522         if (RegVT.isVector())
2523           ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(), ArgValue);
2524         else
2525           ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
2526       }
2527     } else {
2528       assert(VA.isMemLoc());
2529       ArgValue = LowerMemArgument(Chain, CallConv, Ins, dl, DAG, VA, MFI, i);
2530     }
2531
2532     // If value is passed via pointer - do a load.
2533     if (VA.getLocInfo() == CCValAssign::Indirect)
2534       ArgValue = DAG.getLoad(VA.getValVT(), dl, Chain, ArgValue,
2535                              MachinePointerInfo(), false, false, false, 0);
2536
2537     InVals.push_back(ArgValue);
2538   }
2539
2540   if (Subtarget->is64Bit() || Subtarget->isTargetKnownWindowsMSVC()) {
2541     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2542       // The x86-64 ABIs require that for returning structs by value we copy
2543       // the sret argument into %rax/%eax (depending on ABI) for the return.
2544       // Win32 requires us to put the sret argument to %eax as well.
2545       // Save the argument into a virtual register so that we can access it
2546       // from the return points.
2547       if (Ins[i].Flags.isSRet()) {
2548         unsigned Reg = FuncInfo->getSRetReturnReg();
2549         if (!Reg) {
2550           MVT PtrTy = getPointerTy();
2551           Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(PtrTy));
2552           FuncInfo->setSRetReturnReg(Reg);
2553         }
2554         SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[i]);
2555         Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
2556         break;
2557       }
2558     }
2559   }
2560
2561   unsigned StackSize = CCInfo.getNextStackOffset();
2562   // Align stack specially for tail calls.
2563   if (FuncIsMadeTailCallSafe(CallConv,
2564                              MF.getTarget().Options.GuaranteedTailCallOpt))
2565     StackSize = GetAlignedArgumentStackSize(StackSize, DAG);
2566
2567   // If the function takes variable number of arguments, make a frame index for
2568   // the start of the first vararg value... for expansion of llvm.va_start. We
2569   // can skip this if there are no va_start calls.
2570   if (MFI->hasVAStart() &&
2571       (Is64Bit || (CallConv != CallingConv::X86_FastCall &&
2572                    CallConv != CallingConv::X86_ThisCall))) {
2573     FuncInfo->setVarArgsFrameIndex(
2574         MFI->CreateFixedObject(1, StackSize, true));
2575   }
2576
2577   // Figure out if XMM registers are in use.
2578   assert(!(MF.getTarget().Options.UseSoftFloat &&
2579            Fn->hasFnAttribute(Attribute::NoImplicitFloat)) &&
2580          "SSE register cannot be used when SSE is disabled!");
2581
2582   // 64-bit calling conventions support varargs and register parameters, so we
2583   // have to do extra work to spill them in the prologue.
2584   if (Is64Bit && isVarArg && MFI->hasVAStart()) {
2585     // Find the first unallocated argument registers.
2586     ArrayRef<MCPhysReg> ArgGPRs = get64BitArgumentGPRs(CallConv, Subtarget);
2587     ArrayRef<MCPhysReg> ArgXMMs = get64BitArgumentXMMs(MF, CallConv, Subtarget);
2588     unsigned NumIntRegs =
2589         CCInfo.getFirstUnallocated(ArgGPRs.data(), ArgGPRs.size());
2590     unsigned NumXMMRegs =
2591         CCInfo.getFirstUnallocated(ArgXMMs.data(), ArgXMMs.size());
2592     assert(!(NumXMMRegs && !Subtarget->hasSSE1()) &&
2593            "SSE register cannot be used when SSE is disabled!");
2594
2595     // Gather all the live in physical registers.
2596     SmallVector<SDValue, 6> LiveGPRs;
2597     SmallVector<SDValue, 8> LiveXMMRegs;
2598     SDValue ALVal;
2599     for (MCPhysReg Reg : ArgGPRs.slice(NumIntRegs)) {
2600       unsigned GPR = MF.addLiveIn(Reg, &X86::GR64RegClass);
2601       LiveGPRs.push_back(
2602           DAG.getCopyFromReg(Chain, dl, GPR, MVT::i64));
2603     }
2604     if (!ArgXMMs.empty()) {
2605       unsigned AL = MF.addLiveIn(X86::AL, &X86::GR8RegClass);
2606       ALVal = DAG.getCopyFromReg(Chain, dl, AL, MVT::i8);
2607       for (MCPhysReg Reg : ArgXMMs.slice(NumXMMRegs)) {
2608         unsigned XMMReg = MF.addLiveIn(Reg, &X86::VR128RegClass);
2609         LiveXMMRegs.push_back(
2610             DAG.getCopyFromReg(Chain, dl, XMMReg, MVT::v4f32));
2611       }
2612     }
2613
2614     if (IsWin64) {
2615       const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
2616       // Get to the caller-allocated home save location.  Add 8 to account
2617       // for the return address.
2618       int HomeOffset = TFI.getOffsetOfLocalArea() + 8;
2619       FuncInfo->setRegSaveFrameIndex(
2620           MFI->CreateFixedObject(1, NumIntRegs * 8 + HomeOffset, false));
2621       // Fixup to set vararg frame on shadow area (4 x i64).
2622       if (NumIntRegs < 4)
2623         FuncInfo->setVarArgsFrameIndex(FuncInfo->getRegSaveFrameIndex());
2624     } else {
2625       // For X86-64, if there are vararg parameters that are passed via
2626       // registers, then we must store them to their spots on the stack so
2627       // they may be loaded by deferencing the result of va_next.
2628       FuncInfo->setVarArgsGPOffset(NumIntRegs * 8);
2629       FuncInfo->setVarArgsFPOffset(ArgGPRs.size() * 8 + NumXMMRegs * 16);
2630       FuncInfo->setRegSaveFrameIndex(MFI->CreateStackObject(
2631           ArgGPRs.size() * 8 + ArgXMMs.size() * 16, 16, false));
2632     }
2633
2634     // Store the integer parameter registers.
2635     SmallVector<SDValue, 8> MemOps;
2636     SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
2637                                       getPointerTy());
2638     unsigned Offset = FuncInfo->getVarArgsGPOffset();
2639     for (SDValue Val : LiveGPRs) {
2640       SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), RSFIN,
2641                                 DAG.getIntPtrConstant(Offset));
2642       SDValue Store =
2643         DAG.getStore(Val.getValue(1), dl, Val, FIN,
2644                      MachinePointerInfo::getFixedStack(
2645                        FuncInfo->getRegSaveFrameIndex(), Offset),
2646                      false, false, 0);
2647       MemOps.push_back(Store);
2648       Offset += 8;
2649     }
2650
2651     if (!ArgXMMs.empty() && NumXMMRegs != ArgXMMs.size()) {
2652       // Now store the XMM (fp + vector) parameter registers.
2653       SmallVector<SDValue, 12> SaveXMMOps;
2654       SaveXMMOps.push_back(Chain);
2655       SaveXMMOps.push_back(ALVal);
2656       SaveXMMOps.push_back(DAG.getIntPtrConstant(
2657                              FuncInfo->getRegSaveFrameIndex()));
2658       SaveXMMOps.push_back(DAG.getIntPtrConstant(
2659                              FuncInfo->getVarArgsFPOffset()));
2660       SaveXMMOps.insert(SaveXMMOps.end(), LiveXMMRegs.begin(),
2661                         LiveXMMRegs.end());
2662       MemOps.push_back(DAG.getNode(X86ISD::VASTART_SAVE_XMM_REGS, dl,
2663                                    MVT::Other, SaveXMMOps));
2664     }
2665
2666     if (!MemOps.empty())
2667       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
2668   }
2669
2670   if (isVarArg && MFI->hasMustTailInVarArgFunc()) {
2671     // Find the largest legal vector type.
2672     MVT VecVT = MVT::Other;
2673     // FIXME: Only some x86_32 calling conventions support AVX512.
2674     if (Subtarget->hasAVX512() &&
2675         (Is64Bit || (CallConv == CallingConv::X86_VectorCall ||
2676                      CallConv == CallingConv::Intel_OCL_BI)))
2677       VecVT = MVT::v16f32;
2678     else if (Subtarget->hasAVX())
2679       VecVT = MVT::v8f32;
2680     else if (Subtarget->hasSSE2())
2681       VecVT = MVT::v4f32;
2682
2683     // We forward some GPRs and some vector types.
2684     SmallVector<MVT, 2> RegParmTypes;
2685     MVT IntVT = Is64Bit ? MVT::i64 : MVT::i32;
2686     RegParmTypes.push_back(IntVT);
2687     if (VecVT != MVT::Other)
2688       RegParmTypes.push_back(VecVT);
2689
2690     // Compute the set of forwarded registers. The rest are scratch.
2691     SmallVectorImpl<ForwardedRegister> &Forwards =
2692         FuncInfo->getForwardedMustTailRegParms();
2693     CCInfo.analyzeMustTailForwardedRegisters(Forwards, RegParmTypes, CC_X86);
2694
2695     // Conservatively forward AL on x86_64, since it might be used for varargs.
2696     if (Is64Bit && !CCInfo.isAllocated(X86::AL)) {
2697       unsigned ALVReg = MF.addLiveIn(X86::AL, &X86::GR8RegClass);
2698       Forwards.push_back(ForwardedRegister(ALVReg, X86::AL, MVT::i8));
2699     }
2700
2701     // Copy all forwards from physical to virtual registers.
2702     for (ForwardedRegister &F : Forwards) {
2703       // FIXME: Can we use a less constrained schedule?
2704       SDValue RegVal = DAG.getCopyFromReg(Chain, dl, F.VReg, F.VT);
2705       F.VReg = MF.getRegInfo().createVirtualRegister(getRegClassFor(F.VT));
2706       Chain = DAG.getCopyToReg(Chain, dl, F.VReg, RegVal);
2707     }
2708   }
2709
2710   // Some CCs need callee pop.
2711   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
2712                        MF.getTarget().Options.GuaranteedTailCallOpt)) {
2713     FuncInfo->setBytesToPopOnReturn(StackSize); // Callee pops everything.
2714   } else {
2715     FuncInfo->setBytesToPopOnReturn(0); // Callee pops nothing.
2716     // If this is an sret function, the return should pop the hidden pointer.
2717     if (!Is64Bit && !IsTailCallConvention(CallConv) &&
2718         !Subtarget->getTargetTriple().isOSMSVCRT() &&
2719         argsAreStructReturn(Ins) == StackStructReturn)
2720       FuncInfo->setBytesToPopOnReturn(4);
2721   }
2722
2723   if (!Is64Bit) {
2724     // RegSaveFrameIndex is X86-64 only.
2725     FuncInfo->setRegSaveFrameIndex(0xAAAAAAA);
2726     if (CallConv == CallingConv::X86_FastCall ||
2727         CallConv == CallingConv::X86_ThisCall)
2728       // fastcc functions can't have varargs.
2729       FuncInfo->setVarArgsFrameIndex(0xAAAAAAA);
2730   }
2731
2732   FuncInfo->setArgumentStackSize(StackSize);
2733
2734   return Chain;
2735 }
2736
2737 SDValue
2738 X86TargetLowering::LowerMemOpCallTo(SDValue Chain,
2739                                     SDValue StackPtr, SDValue Arg,
2740                                     SDLoc dl, SelectionDAG &DAG,
2741                                     const CCValAssign &VA,
2742                                     ISD::ArgFlagsTy Flags) const {
2743   unsigned LocMemOffset = VA.getLocMemOffset();
2744   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
2745   PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
2746   if (Flags.isByVal())
2747     return CreateCopyOfByValArgument(Arg, PtrOff, Chain, Flags, DAG, dl);
2748
2749   return DAG.getStore(Chain, dl, Arg, PtrOff,
2750                       MachinePointerInfo::getStack(LocMemOffset),
2751                       false, false, 0);
2752 }
2753
2754 /// Emit a load of return address if tail call
2755 /// optimization is performed and it is required.
2756 SDValue
2757 X86TargetLowering::EmitTailCallLoadRetAddr(SelectionDAG &DAG,
2758                                            SDValue &OutRetAddr, SDValue Chain,
2759                                            bool IsTailCall, bool Is64Bit,
2760                                            int FPDiff, SDLoc dl) const {
2761   // Adjust the Return address stack slot.
2762   EVT VT = getPointerTy();
2763   OutRetAddr = getReturnAddressFrameIndex(DAG);
2764
2765   // Load the "old" Return address.
2766   OutRetAddr = DAG.getLoad(VT, dl, Chain, OutRetAddr, MachinePointerInfo(),
2767                            false, false, false, 0);
2768   return SDValue(OutRetAddr.getNode(), 1);
2769 }
2770
2771 /// Emit a store of the return address if tail call
2772 /// optimization is performed and it is required (FPDiff!=0).
2773 static SDValue EmitTailCallStoreRetAddr(SelectionDAG &DAG, MachineFunction &MF,
2774                                         SDValue Chain, SDValue RetAddrFrIdx,
2775                                         EVT PtrVT, unsigned SlotSize,
2776                                         int FPDiff, SDLoc dl) {
2777   // Store the return address to the appropriate stack slot.
2778   if (!FPDiff) return Chain;
2779   // Calculate the new stack slot for the return address.
2780   int NewReturnAddrFI =
2781     MF.getFrameInfo()->CreateFixedObject(SlotSize, (int64_t)FPDiff - SlotSize,
2782                                          false);
2783   SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, PtrVT);
2784   Chain = DAG.getStore(Chain, dl, RetAddrFrIdx, NewRetAddrFrIdx,
2785                        MachinePointerInfo::getFixedStack(NewReturnAddrFI),
2786                        false, false, 0);
2787   return Chain;
2788 }
2789
2790 SDValue
2791 X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
2792                              SmallVectorImpl<SDValue> &InVals) const {
2793   SelectionDAG &DAG                     = CLI.DAG;
2794   SDLoc &dl                             = CLI.DL;
2795   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
2796   SmallVectorImpl<SDValue> &OutVals     = CLI.OutVals;
2797   SmallVectorImpl<ISD::InputArg> &Ins   = CLI.Ins;
2798   SDValue Chain                         = CLI.Chain;
2799   SDValue Callee                        = CLI.Callee;
2800   CallingConv::ID CallConv              = CLI.CallConv;
2801   bool &isTailCall                      = CLI.IsTailCall;
2802   bool isVarArg                         = CLI.IsVarArg;
2803
2804   MachineFunction &MF = DAG.getMachineFunction();
2805   bool Is64Bit        = Subtarget->is64Bit();
2806   bool IsWin64        = Subtarget->isCallingConvWin64(CallConv);
2807   StructReturnType SR = callIsStructReturn(Outs);
2808   bool IsSibcall      = false;
2809   X86MachineFunctionInfo *X86Info = MF.getInfo<X86MachineFunctionInfo>();
2810
2811   if (MF.getTarget().Options.DisableTailCalls)
2812     isTailCall = false;
2813
2814   bool IsMustTail = CLI.CS && CLI.CS->isMustTailCall();
2815   if (IsMustTail) {
2816     // Force this to be a tail call.  The verifier rules are enough to ensure
2817     // that we can lower this successfully without moving the return address
2818     // around.
2819     isTailCall = true;
2820   } else if (isTailCall) {
2821     // Check if it's really possible to do a tail call.
2822     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
2823                     isVarArg, SR != NotStructReturn,
2824                     MF.getFunction()->hasStructRetAttr(), CLI.RetTy,
2825                     Outs, OutVals, Ins, DAG);
2826
2827     // Sibcalls are automatically detected tailcalls which do not require
2828     // ABI changes.
2829     if (!MF.getTarget().Options.GuaranteedTailCallOpt && isTailCall)
2830       IsSibcall = true;
2831
2832     if (isTailCall)
2833       ++NumTailCalls;
2834   }
2835
2836   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2837          "Var args not supported with calling convention fastcc, ghc or hipe");
2838
2839   // Analyze operands of the call, assigning locations to each operand.
2840   SmallVector<CCValAssign, 16> ArgLocs;
2841   CCState CCInfo(CallConv, isVarArg, MF, ArgLocs, *DAG.getContext());
2842
2843   // Allocate shadow area for Win64
2844   if (IsWin64)
2845     CCInfo.AllocateStack(32, 8);
2846
2847   CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2848
2849   // Get a count of how many bytes are to be pushed on the stack.
2850   unsigned NumBytes = CCInfo.getNextStackOffset();
2851   if (IsSibcall)
2852     // This is a sibcall. The memory operands are available in caller's
2853     // own caller's stack.
2854     NumBytes = 0;
2855   else if (MF.getTarget().Options.GuaranteedTailCallOpt &&
2856            IsTailCallConvention(CallConv))
2857     NumBytes = GetAlignedArgumentStackSize(NumBytes, DAG);
2858
2859   int FPDiff = 0;
2860   if (isTailCall && !IsSibcall && !IsMustTail) {
2861     // Lower arguments at fp - stackoffset + fpdiff.
2862     unsigned NumBytesCallerPushed = X86Info->getBytesToPopOnReturn();
2863
2864     FPDiff = NumBytesCallerPushed - NumBytes;
2865
2866     // Set the delta of movement of the returnaddr stackslot.
2867     // But only set if delta is greater than previous delta.
2868     if (FPDiff < X86Info->getTCReturnAddrDelta())
2869       X86Info->setTCReturnAddrDelta(FPDiff);
2870   }
2871
2872   unsigned NumBytesToPush = NumBytes;
2873   unsigned NumBytesToPop = NumBytes;
2874
2875   // If we have an inalloca argument, all stack space has already been allocated
2876   // for us and be right at the top of the stack.  We don't support multiple
2877   // arguments passed in memory when using inalloca.
2878   if (!Outs.empty() && Outs.back().Flags.isInAlloca()) {
2879     NumBytesToPush = 0;
2880     if (!ArgLocs.back().isMemLoc())
2881       report_fatal_error("cannot use inalloca attribute on a register "
2882                          "parameter");
2883     if (ArgLocs.back().getLocMemOffset() != 0)
2884       report_fatal_error("any parameter with the inalloca attribute must be "
2885                          "the only memory argument");
2886   }
2887
2888   if (!IsSibcall)
2889     Chain = DAG.getCALLSEQ_START(
2890         Chain, DAG.getIntPtrConstant(NumBytesToPush, true), dl);
2891
2892   SDValue RetAddrFrIdx;
2893   // Load return address for tail calls.
2894   if (isTailCall && FPDiff)
2895     Chain = EmitTailCallLoadRetAddr(DAG, RetAddrFrIdx, Chain, isTailCall,
2896                                     Is64Bit, FPDiff, dl);
2897
2898   SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
2899   SmallVector<SDValue, 8> MemOpChains;
2900   SDValue StackPtr;
2901
2902   // Walk the register/memloc assignments, inserting copies/loads.  In the case
2903   // of tail call optimization arguments are handle later.
2904   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
2905   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2906     // Skip inalloca arguments, they have already been written.
2907     ISD::ArgFlagsTy Flags = Outs[i].Flags;
2908     if (Flags.isInAlloca())
2909       continue;
2910
2911     CCValAssign &VA = ArgLocs[i];
2912     EVT RegVT = VA.getLocVT();
2913     SDValue Arg = OutVals[i];
2914     bool isByVal = Flags.isByVal();
2915
2916     // Promote the value if needed.
2917     switch (VA.getLocInfo()) {
2918     default: llvm_unreachable("Unknown loc info!");
2919     case CCValAssign::Full: break;
2920     case CCValAssign::SExt:
2921       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
2922       break;
2923     case CCValAssign::ZExt:
2924       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
2925       break;
2926     case CCValAssign::AExt:
2927       if (RegVT.is128BitVector()) {
2928         // Special case: passing MMX values in XMM registers.
2929         Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
2930         Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
2931         Arg = getMOVL(DAG, dl, MVT::v2i64, DAG.getUNDEF(MVT::v2i64), Arg);
2932       } else
2933         Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
2934       break;
2935     case CCValAssign::BCvt:
2936       Arg = DAG.getNode(ISD::BITCAST, dl, RegVT, Arg);
2937       break;
2938     case CCValAssign::Indirect: {
2939       // Store the argument.
2940       SDValue SpillSlot = DAG.CreateStackTemporary(VA.getValVT());
2941       int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
2942       Chain = DAG.getStore(Chain, dl, Arg, SpillSlot,
2943                            MachinePointerInfo::getFixedStack(FI),
2944                            false, false, 0);
2945       Arg = SpillSlot;
2946       break;
2947     }
2948     }
2949
2950     if (VA.isRegLoc()) {
2951       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
2952       if (isVarArg && IsWin64) {
2953         // Win64 ABI requires argument XMM reg to be copied to the corresponding
2954         // shadow reg if callee is a varargs function.
2955         unsigned ShadowReg = 0;
2956         switch (VA.getLocReg()) {
2957         case X86::XMM0: ShadowReg = X86::RCX; break;
2958         case X86::XMM1: ShadowReg = X86::RDX; break;
2959         case X86::XMM2: ShadowReg = X86::R8; break;
2960         case X86::XMM3: ShadowReg = X86::R9; break;
2961         }
2962         if (ShadowReg)
2963           RegsToPass.push_back(std::make_pair(ShadowReg, Arg));
2964       }
2965     } else if (!IsSibcall && (!isTailCall || isByVal)) {
2966       assert(VA.isMemLoc());
2967       if (!StackPtr.getNode())
2968         StackPtr = DAG.getCopyFromReg(Chain, dl, RegInfo->getStackRegister(),
2969                                       getPointerTy());
2970       MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Arg,
2971                                              dl, DAG, VA, Flags));
2972     }
2973   }
2974
2975   if (!MemOpChains.empty())
2976     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
2977
2978   if (Subtarget->isPICStyleGOT()) {
2979     // ELF / PIC requires GOT in the EBX register before function calls via PLT
2980     // GOT pointer.
2981     if (!isTailCall) {
2982       RegsToPass.push_back(std::make_pair(unsigned(X86::EBX),
2983                DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy())));
2984     } else {
2985       // If we are tail calling and generating PIC/GOT style code load the
2986       // address of the callee into ECX. The value in ecx is used as target of
2987       // the tail jump. This is done to circumvent the ebx/callee-saved problem
2988       // for tail calls on PIC/GOT architectures. Normally we would just put the
2989       // address of GOT into ebx and then call target@PLT. But for tail calls
2990       // ebx would be restored (since ebx is callee saved) before jumping to the
2991       // target@PLT.
2992
2993       // Note: The actual moving to ECX is done further down.
2994       GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
2995       if (G && !G->getGlobal()->hasHiddenVisibility() &&
2996           !G->getGlobal()->hasProtectedVisibility())
2997         Callee = LowerGlobalAddress(Callee, DAG);
2998       else if (isa<ExternalSymbolSDNode>(Callee))
2999         Callee = LowerExternalSymbol(Callee, DAG);
3000     }
3001   }
3002
3003   if (Is64Bit && isVarArg && !IsWin64 && !IsMustTail) {
3004     // From AMD64 ABI document:
3005     // For calls that may call functions that use varargs or stdargs
3006     // (prototype-less calls or calls to functions containing ellipsis (...) in
3007     // the declaration) %al is used as hidden argument to specify the number
3008     // of SSE registers used. The contents of %al do not need to match exactly
3009     // the number of registers, but must be an ubound on the number of SSE
3010     // registers used and is in the range 0 - 8 inclusive.
3011
3012     // Count the number of XMM registers allocated.
3013     static const MCPhysReg XMMArgRegs[] = {
3014       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
3015       X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
3016     };
3017     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs, 8);
3018     assert((Subtarget->hasSSE1() || !NumXMMRegs)
3019            && "SSE registers cannot be used when SSE is disabled");
3020
3021     RegsToPass.push_back(std::make_pair(unsigned(X86::AL),
3022                                         DAG.getConstant(NumXMMRegs, MVT::i8)));
3023   }
3024
3025   if (isVarArg && IsMustTail) {
3026     const auto &Forwards = X86Info->getForwardedMustTailRegParms();
3027     for (const auto &F : Forwards) {
3028       SDValue Val = DAG.getCopyFromReg(Chain, dl, F.VReg, F.VT);
3029       RegsToPass.push_back(std::make_pair(unsigned(F.PReg), Val));
3030     }
3031   }
3032
3033   // For tail calls lower the arguments to the 'real' stack slots.  Sibcalls
3034   // don't need this because the eligibility check rejects calls that require
3035   // shuffling arguments passed in memory.
3036   if (!IsSibcall && isTailCall) {
3037     // Force all the incoming stack arguments to be loaded from the stack
3038     // before any new outgoing arguments are stored to the stack, because the
3039     // outgoing stack slots may alias the incoming argument stack slots, and
3040     // the alias isn't otherwise explicit. This is slightly more conservative
3041     // than necessary, because it means that each store effectively depends
3042     // on every argument instead of just those arguments it would clobber.
3043     SDValue ArgChain = DAG.getStackArgumentTokenFactor(Chain);
3044
3045     SmallVector<SDValue, 8> MemOpChains2;
3046     SDValue FIN;
3047     int FI = 0;
3048     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3049       CCValAssign &VA = ArgLocs[i];
3050       if (VA.isRegLoc())
3051         continue;
3052       assert(VA.isMemLoc());
3053       SDValue Arg = OutVals[i];
3054       ISD::ArgFlagsTy Flags = Outs[i].Flags;
3055       // Skip inalloca arguments.  They don't require any work.
3056       if (Flags.isInAlloca())
3057         continue;
3058       // Create frame index.
3059       int32_t Offset = VA.getLocMemOffset()+FPDiff;
3060       uint32_t OpSize = (VA.getLocVT().getSizeInBits()+7)/8;
3061       FI = MF.getFrameInfo()->CreateFixedObject(OpSize, Offset, true);
3062       FIN = DAG.getFrameIndex(FI, getPointerTy());
3063
3064       if (Flags.isByVal()) {
3065         // Copy relative to framepointer.
3066         SDValue Source = DAG.getIntPtrConstant(VA.getLocMemOffset());
3067         if (!StackPtr.getNode())
3068           StackPtr = DAG.getCopyFromReg(Chain, dl,
3069                                         RegInfo->getStackRegister(),
3070                                         getPointerTy());
3071         Source = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, Source);
3072
3073         MemOpChains2.push_back(CreateCopyOfByValArgument(Source, FIN,
3074                                                          ArgChain,
3075                                                          Flags, DAG, dl));
3076       } else {
3077         // Store relative to framepointer.
3078         MemOpChains2.push_back(
3079           DAG.getStore(ArgChain, dl, Arg, FIN,
3080                        MachinePointerInfo::getFixedStack(FI),
3081                        false, false, 0));
3082       }
3083     }
3084
3085     if (!MemOpChains2.empty())
3086       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains2);
3087
3088     // Store the return address to the appropriate stack slot.
3089     Chain = EmitTailCallStoreRetAddr(DAG, MF, Chain, RetAddrFrIdx,
3090                                      getPointerTy(), RegInfo->getSlotSize(),
3091                                      FPDiff, dl);
3092   }
3093
3094   // Build a sequence of copy-to-reg nodes chained together with token chain
3095   // and flag operands which copy the outgoing args into registers.
3096   SDValue InFlag;
3097   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
3098     Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
3099                              RegsToPass[i].second, InFlag);
3100     InFlag = Chain.getValue(1);
3101   }
3102
3103   if (DAG.getTarget().getCodeModel() == CodeModel::Large) {
3104     assert(Is64Bit && "Large code model is only legal in 64-bit mode.");
3105     // In the 64-bit large code model, we have to make all calls
3106     // through a register, since the call instruction's 32-bit
3107     // pc-relative offset may not be large enough to hold the whole
3108     // address.
3109   } else if (Callee->getOpcode() == ISD::GlobalAddress) {
3110     // If the callee is a GlobalAddress node (quite common, every direct call
3111     // is) turn it into a TargetGlobalAddress node so that legalize doesn't hack
3112     // it.
3113     GlobalAddressSDNode* G = cast<GlobalAddressSDNode>(Callee);
3114
3115     // We should use extra load for direct calls to dllimported functions in
3116     // non-JIT mode.
3117     const GlobalValue *GV = G->getGlobal();
3118     if (!GV->hasDLLImportStorageClass()) {
3119       unsigned char OpFlags = 0;
3120       bool ExtraLoad = false;
3121       unsigned WrapperKind = ISD::DELETED_NODE;
3122
3123       // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
3124       // external symbols most go through the PLT in PIC mode.  If the symbol
3125       // has hidden or protected visibility, or if it is static or local, then
3126       // we don't need to use the PLT - we can directly call it.
3127       if (Subtarget->isTargetELF() &&
3128           DAG.getTarget().getRelocationModel() == Reloc::PIC_ &&
3129           GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
3130         OpFlags = X86II::MO_PLT;
3131       } else if (Subtarget->isPICStyleStubAny() &&
3132                  (GV->isDeclaration() || GV->isWeakForLinker()) &&
3133                  (!Subtarget->getTargetTriple().isMacOSX() ||
3134                   Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
3135         // PC-relative references to external symbols should go through $stub,
3136         // unless we're building with the leopard linker or later, which
3137         // automatically synthesizes these stubs.
3138         OpFlags = X86II::MO_DARWIN_STUB;
3139       } else if (Subtarget->isPICStyleRIPRel() && isa<Function>(GV) &&
3140                  cast<Function>(GV)->hasFnAttribute(Attribute::NonLazyBind)) {
3141         // If the function is marked as non-lazy, generate an indirect call
3142         // which loads from the GOT directly. This avoids runtime overhead
3143         // at the cost of eager binding (and one extra byte of encoding).
3144         OpFlags = X86II::MO_GOTPCREL;
3145         WrapperKind = X86ISD::WrapperRIP;
3146         ExtraLoad = true;
3147       }
3148
3149       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(),
3150                                           G->getOffset(), OpFlags);
3151
3152       // Add a wrapper if needed.
3153       if (WrapperKind != ISD::DELETED_NODE)
3154         Callee = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Callee);
3155       // Add extra indirection if needed.
3156       if (ExtraLoad)
3157         Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Callee,
3158                              MachinePointerInfo::getGOT(),
3159                              false, false, false, 0);
3160     }
3161   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
3162     unsigned char OpFlags = 0;
3163
3164     // On ELF targets, in either X86-64 or X86-32 mode, direct calls to
3165     // external symbols should go through the PLT.
3166     if (Subtarget->isTargetELF() &&
3167         DAG.getTarget().getRelocationModel() == Reloc::PIC_) {
3168       OpFlags = X86II::MO_PLT;
3169     } else if (Subtarget->isPICStyleStubAny() &&
3170                (!Subtarget->getTargetTriple().isMacOSX() ||
3171                 Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
3172       // PC-relative references to external symbols should go through $stub,
3173       // unless we're building with the leopard linker or later, which
3174       // automatically synthesizes these stubs.
3175       OpFlags = X86II::MO_DARWIN_STUB;
3176     }
3177
3178     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy(),
3179                                          OpFlags);
3180   } else if (Subtarget->isTarget64BitILP32() &&
3181              Callee->getValueType(0) == MVT::i32) {
3182     // Zero-extend the 32-bit Callee address into a 64-bit according to x32 ABI
3183     Callee = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Callee);
3184   }
3185
3186   // Returns a chain & a flag for retval copy to use.
3187   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
3188   SmallVector<SDValue, 8> Ops;
3189
3190   if (!IsSibcall && isTailCall) {
3191     Chain = DAG.getCALLSEQ_END(Chain,
3192                                DAG.getIntPtrConstant(NumBytesToPop, true),
3193                                DAG.getIntPtrConstant(0, true), InFlag, dl);
3194     InFlag = Chain.getValue(1);
3195   }
3196
3197   Ops.push_back(Chain);
3198   Ops.push_back(Callee);
3199
3200   if (isTailCall)
3201     Ops.push_back(DAG.getConstant(FPDiff, MVT::i32));
3202
3203   // Add argument registers to the end of the list so that they are known live
3204   // into the call.
3205   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
3206     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
3207                                   RegsToPass[i].second.getValueType()));
3208
3209   // Add a register mask operand representing the call-preserved registers.
3210   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
3211   const uint32_t *Mask = TRI->getCallPreservedMask(CallConv);
3212   assert(Mask && "Missing call preserved mask for calling convention");
3213   Ops.push_back(DAG.getRegisterMask(Mask));
3214
3215   if (InFlag.getNode())
3216     Ops.push_back(InFlag);
3217
3218   if (isTailCall) {
3219     // We used to do:
3220     //// If this is the first return lowered for this function, add the regs
3221     //// to the liveout set for the function.
3222     // This isn't right, although it's probably harmless on x86; liveouts
3223     // should be computed from returns not tail calls.  Consider a void
3224     // function making a tail call to a function returning int.
3225     return DAG.getNode(X86ISD::TC_RETURN, dl, NodeTys, Ops);
3226   }
3227
3228   Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, Ops);
3229   InFlag = Chain.getValue(1);
3230
3231   // Create the CALLSEQ_END node.
3232   unsigned NumBytesForCalleeToPop;
3233   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
3234                        DAG.getTarget().Options.GuaranteedTailCallOpt))
3235     NumBytesForCalleeToPop = NumBytes;    // Callee pops everything
3236   else if (!Is64Bit && !IsTailCallConvention(CallConv) &&
3237            !Subtarget->getTargetTriple().isOSMSVCRT() &&
3238            SR == StackStructReturn)
3239     // If this is a call to a struct-return function, the callee
3240     // pops the hidden struct pointer, so we have to push it back.
3241     // This is common for Darwin/X86, Linux & Mingw32 targets.
3242     // For MSVC Win32 targets, the caller pops the hidden struct pointer.
3243     NumBytesForCalleeToPop = 4;
3244   else
3245     NumBytesForCalleeToPop = 0;  // Callee pops nothing.
3246
3247   // Returns a flag for retval copy to use.
3248   if (!IsSibcall) {
3249     Chain = DAG.getCALLSEQ_END(Chain,
3250                                DAG.getIntPtrConstant(NumBytesToPop, true),
3251                                DAG.getIntPtrConstant(NumBytesForCalleeToPop,
3252                                                      true),
3253                                InFlag, dl);
3254     InFlag = Chain.getValue(1);
3255   }
3256
3257   // Handle result values, copying them out of physregs into vregs that we
3258   // return.
3259   return LowerCallResult(Chain, InFlag, CallConv, isVarArg,
3260                          Ins, dl, DAG, InVals);
3261 }
3262
3263 //===----------------------------------------------------------------------===//
3264 //                Fast Calling Convention (tail call) implementation
3265 //===----------------------------------------------------------------------===//
3266
3267 //  Like std call, callee cleans arguments, convention except that ECX is
3268 //  reserved for storing the tail called function address. Only 2 registers are
3269 //  free for argument passing (inreg). Tail call optimization is performed
3270 //  provided:
3271 //                * tailcallopt is enabled
3272 //                * caller/callee are fastcc
3273 //  On X86_64 architecture with GOT-style position independent code only local
3274 //  (within module) calls are supported at the moment.
3275 //  To keep the stack aligned according to platform abi the function
3276 //  GetAlignedArgumentStackSize ensures that argument delta is always multiples
3277 //  of stack alignment. (Dynamic linkers need this - darwin's dyld for example)
3278 //  If a tail called function callee has more arguments than the caller the
3279 //  caller needs to make sure that there is room to move the RETADDR to. This is
3280 //  achieved by reserving an area the size of the argument delta right after the
3281 //  original RETADDR, but before the saved framepointer or the spilled registers
3282 //  e.g. caller(arg1, arg2) calls callee(arg1, arg2,arg3,arg4)
3283 //  stack layout:
3284 //    arg1
3285 //    arg2
3286 //    RETADDR
3287 //    [ new RETADDR
3288 //      move area ]
3289 //    (possible EBP)
3290 //    ESI
3291 //    EDI
3292 //    local1 ..
3293
3294 /// GetAlignedArgumentStackSize - Make the stack size align e.g 16n + 12 aligned
3295 /// for a 16 byte align requirement.
3296 unsigned
3297 X86TargetLowering::GetAlignedArgumentStackSize(unsigned StackSize,
3298                                                SelectionDAG& DAG) const {
3299   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
3300   const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
3301   unsigned StackAlignment = TFI.getStackAlignment();
3302   uint64_t AlignMask = StackAlignment - 1;
3303   int64_t Offset = StackSize;
3304   unsigned SlotSize = RegInfo->getSlotSize();
3305   if ( (Offset & AlignMask) <= (StackAlignment - SlotSize) ) {
3306     // Number smaller than 12 so just add the difference.
3307     Offset += ((StackAlignment - SlotSize) - (Offset & AlignMask));
3308   } else {
3309     // Mask out lower bits, add stackalignment once plus the 12 bytes.
3310     Offset = ((~AlignMask) & Offset) + StackAlignment +
3311       (StackAlignment-SlotSize);
3312   }
3313   return Offset;
3314 }
3315
3316 /// MatchingStackOffset - Return true if the given stack call argument is
3317 /// already available in the same position (relatively) of the caller's
3318 /// incoming argument stack.
3319 static
3320 bool MatchingStackOffset(SDValue Arg, unsigned Offset, ISD::ArgFlagsTy Flags,
3321                          MachineFrameInfo *MFI, const MachineRegisterInfo *MRI,
3322                          const X86InstrInfo *TII) {
3323   unsigned Bytes = Arg.getValueType().getSizeInBits() / 8;
3324   int FI = INT_MAX;
3325   if (Arg.getOpcode() == ISD::CopyFromReg) {
3326     unsigned VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
3327     if (!TargetRegisterInfo::isVirtualRegister(VR))
3328       return false;
3329     MachineInstr *Def = MRI->getVRegDef(VR);
3330     if (!Def)
3331       return false;
3332     if (!Flags.isByVal()) {
3333       if (!TII->isLoadFromStackSlot(Def, FI))
3334         return false;
3335     } else {
3336       unsigned Opcode = Def->getOpcode();
3337       if ((Opcode == X86::LEA32r || Opcode == X86::LEA64r ||
3338            Opcode == X86::LEA64_32r) &&
3339           Def->getOperand(1).isFI()) {
3340         FI = Def->getOperand(1).getIndex();
3341         Bytes = Flags.getByValSize();
3342       } else
3343         return false;
3344     }
3345   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
3346     if (Flags.isByVal())
3347       // ByVal argument is passed in as a pointer but it's now being
3348       // dereferenced. e.g.
3349       // define @foo(%struct.X* %A) {
3350       //   tail call @bar(%struct.X* byval %A)
3351       // }
3352       return false;
3353     SDValue Ptr = Ld->getBasePtr();
3354     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr);
3355     if (!FINode)
3356       return false;
3357     FI = FINode->getIndex();
3358   } else if (Arg.getOpcode() == ISD::FrameIndex && Flags.isByVal()) {
3359     FrameIndexSDNode *FINode = cast<FrameIndexSDNode>(Arg);
3360     FI = FINode->getIndex();
3361     Bytes = Flags.getByValSize();
3362   } else
3363     return false;
3364
3365   assert(FI != INT_MAX);
3366   if (!MFI->isFixedObjectIndex(FI))
3367     return false;
3368   return Offset == MFI->getObjectOffset(FI) && Bytes == MFI->getObjectSize(FI);
3369 }
3370
3371 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
3372 /// for tail call optimization. Targets which want to do tail call
3373 /// optimization should implement this function.
3374 bool
3375 X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
3376                                                      CallingConv::ID CalleeCC,
3377                                                      bool isVarArg,
3378                                                      bool isCalleeStructRet,
3379                                                      bool isCallerStructRet,
3380                                                      Type *RetTy,
3381                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
3382                                     const SmallVectorImpl<SDValue> &OutVals,
3383                                     const SmallVectorImpl<ISD::InputArg> &Ins,
3384                                                      SelectionDAG &DAG) const {
3385   if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
3386     return false;
3387
3388   // If -tailcallopt is specified, make fastcc functions tail-callable.
3389   const MachineFunction &MF = DAG.getMachineFunction();
3390   const Function *CallerF = MF.getFunction();
3391
3392   // If the function return type is x86_fp80 and the callee return type is not,
3393   // then the FP_EXTEND of the call result is not a nop. It's not safe to
3394   // perform a tailcall optimization here.
3395   if (CallerF->getReturnType()->isX86_FP80Ty() && !RetTy->isX86_FP80Ty())
3396     return false;
3397
3398   CallingConv::ID CallerCC = CallerF->getCallingConv();
3399   bool CCMatch = CallerCC == CalleeCC;
3400   bool IsCalleeWin64 = Subtarget->isCallingConvWin64(CalleeCC);
3401   bool IsCallerWin64 = Subtarget->isCallingConvWin64(CallerCC);
3402
3403   if (DAG.getTarget().Options.GuaranteedTailCallOpt) {
3404     if (IsTailCallConvention(CalleeCC) && CCMatch)
3405       return true;
3406     return false;
3407   }
3408
3409   // Look for obvious safe cases to perform tail call optimization that do not
3410   // require ABI changes. This is what gcc calls sibcall.
3411
3412   // Can't do sibcall if stack needs to be dynamically re-aligned. PEI needs to
3413   // emit a special epilogue.
3414   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
3415   if (RegInfo->needsStackRealignment(MF))
3416     return false;
3417
3418   // Also avoid sibcall optimization if either caller or callee uses struct
3419   // return semantics.
3420   if (isCalleeStructRet || isCallerStructRet)
3421     return false;
3422
3423   // An stdcall/thiscall caller is expected to clean up its arguments; the
3424   // callee isn't going to do that.
3425   // FIXME: this is more restrictive than needed. We could produce a tailcall
3426   // when the stack adjustment matches. For example, with a thiscall that takes
3427   // only one argument.
3428   if (!CCMatch && (CallerCC == CallingConv::X86_StdCall ||
3429                    CallerCC == CallingConv::X86_ThisCall))
3430     return false;
3431
3432   // Do not sibcall optimize vararg calls unless all arguments are passed via
3433   // registers.
3434   if (isVarArg && !Outs.empty()) {
3435
3436     // Optimizing for varargs on Win64 is unlikely to be safe without
3437     // additional testing.
3438     if (IsCalleeWin64 || IsCallerWin64)
3439       return false;
3440
3441     SmallVector<CCValAssign, 16> ArgLocs;
3442     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(), ArgLocs,
3443                    *DAG.getContext());
3444
3445     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
3446     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i)
3447       if (!ArgLocs[i].isRegLoc())
3448         return false;
3449   }
3450
3451   // If the call result is in ST0 / ST1, it needs to be popped off the x87
3452   // stack.  Therefore, if it's not used by the call it is not safe to optimize
3453   // this into a sibcall.
3454   bool Unused = false;
3455   for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
3456     if (!Ins[i].Used) {
3457       Unused = true;
3458       break;
3459     }
3460   }
3461   if (Unused) {
3462     SmallVector<CCValAssign, 16> RVLocs;
3463     CCState CCInfo(CalleeCC, false, DAG.getMachineFunction(), RVLocs,
3464                    *DAG.getContext());
3465     CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
3466     for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
3467       CCValAssign &VA = RVLocs[i];
3468       if (VA.getLocReg() == X86::FP0 || VA.getLocReg() == X86::FP1)
3469         return false;
3470     }
3471   }
3472
3473   // If the calling conventions do not match, then we'd better make sure the
3474   // results are returned in the same way as what the caller expects.
3475   if (!CCMatch) {
3476     SmallVector<CCValAssign, 16> RVLocs1;
3477     CCState CCInfo1(CalleeCC, false, DAG.getMachineFunction(), RVLocs1,
3478                     *DAG.getContext());
3479     CCInfo1.AnalyzeCallResult(Ins, RetCC_X86);
3480
3481     SmallVector<CCValAssign, 16> RVLocs2;
3482     CCState CCInfo2(CallerCC, false, DAG.getMachineFunction(), RVLocs2,
3483                     *DAG.getContext());
3484     CCInfo2.AnalyzeCallResult(Ins, RetCC_X86);
3485
3486     if (RVLocs1.size() != RVLocs2.size())
3487       return false;
3488     for (unsigned i = 0, e = RVLocs1.size(); i != e; ++i) {
3489       if (RVLocs1[i].isRegLoc() != RVLocs2[i].isRegLoc())
3490         return false;
3491       if (RVLocs1[i].getLocInfo() != RVLocs2[i].getLocInfo())
3492         return false;
3493       if (RVLocs1[i].isRegLoc()) {
3494         if (RVLocs1[i].getLocReg() != RVLocs2[i].getLocReg())
3495           return false;
3496       } else {
3497         if (RVLocs1[i].getLocMemOffset() != RVLocs2[i].getLocMemOffset())
3498           return false;
3499       }
3500     }
3501   }
3502
3503   // If the callee takes no arguments then go on to check the results of the
3504   // call.
3505   if (!Outs.empty()) {
3506     // Check if stack adjustment is needed. For now, do not do this if any
3507     // argument is passed on the stack.
3508     SmallVector<CCValAssign, 16> ArgLocs;
3509     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(), ArgLocs,
3510                    *DAG.getContext());
3511
3512     // Allocate shadow area for Win64
3513     if (IsCalleeWin64)
3514       CCInfo.AllocateStack(32, 8);
3515
3516     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
3517     if (CCInfo.getNextStackOffset()) {
3518       MachineFunction &MF = DAG.getMachineFunction();
3519       if (MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn())
3520         return false;
3521
3522       // Check if the arguments are already laid out in the right way as
3523       // the caller's fixed stack objects.
3524       MachineFrameInfo *MFI = MF.getFrameInfo();
3525       const MachineRegisterInfo *MRI = &MF.getRegInfo();
3526       const X86InstrInfo *TII = Subtarget->getInstrInfo();
3527       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3528         CCValAssign &VA = ArgLocs[i];
3529         SDValue Arg = OutVals[i];
3530         ISD::ArgFlagsTy Flags = Outs[i].Flags;
3531         if (VA.getLocInfo() == CCValAssign::Indirect)
3532           return false;
3533         if (!VA.isRegLoc()) {
3534           if (!MatchingStackOffset(Arg, VA.getLocMemOffset(), Flags,
3535                                    MFI, MRI, TII))
3536             return false;
3537         }
3538       }
3539     }
3540
3541     // If the tailcall address may be in a register, then make sure it's
3542     // possible to register allocate for it. In 32-bit, the call address can
3543     // only target EAX, EDX, or ECX since the tail call must be scheduled after
3544     // callee-saved registers are restored. These happen to be the same
3545     // registers used to pass 'inreg' arguments so watch out for those.
3546     if (!Subtarget->is64Bit() &&
3547         ((!isa<GlobalAddressSDNode>(Callee) &&
3548           !isa<ExternalSymbolSDNode>(Callee)) ||
3549          DAG.getTarget().getRelocationModel() == Reloc::PIC_)) {
3550       unsigned NumInRegs = 0;
3551       // In PIC we need an extra register to formulate the address computation
3552       // for the callee.
3553       unsigned MaxInRegs =
3554         (DAG.getTarget().getRelocationModel() == Reloc::PIC_) ? 2 : 3;
3555
3556       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3557         CCValAssign &VA = ArgLocs[i];
3558         if (!VA.isRegLoc())
3559           continue;
3560         unsigned Reg = VA.getLocReg();
3561         switch (Reg) {
3562         default: break;
3563         case X86::EAX: case X86::EDX: case X86::ECX:
3564           if (++NumInRegs == MaxInRegs)
3565             return false;
3566           break;
3567         }
3568       }
3569     }
3570   }
3571
3572   return true;
3573 }
3574
3575 FastISel *
3576 X86TargetLowering::createFastISel(FunctionLoweringInfo &funcInfo,
3577                                   const TargetLibraryInfo *libInfo) const {
3578   return X86::createFastISel(funcInfo, libInfo);
3579 }
3580
3581 //===----------------------------------------------------------------------===//
3582 //                           Other Lowering Hooks
3583 //===----------------------------------------------------------------------===//
3584
3585 static bool MayFoldLoad(SDValue Op) {
3586   return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
3587 }
3588
3589 static bool MayFoldIntoStore(SDValue Op) {
3590   return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
3591 }
3592
3593 static bool isTargetShuffle(unsigned Opcode) {
3594   switch(Opcode) {
3595   default: return false;
3596   case X86ISD::BLENDI:
3597   case X86ISD::PSHUFB:
3598   case X86ISD::PSHUFD:
3599   case X86ISD::PSHUFHW:
3600   case X86ISD::PSHUFLW:
3601   case X86ISD::SHUFP:
3602   case X86ISD::PALIGNR:
3603   case X86ISD::MOVLHPS:
3604   case X86ISD::MOVLHPD:
3605   case X86ISD::MOVHLPS:
3606   case X86ISD::MOVLPS:
3607   case X86ISD::MOVLPD:
3608   case X86ISD::MOVSHDUP:
3609   case X86ISD::MOVSLDUP:
3610   case X86ISD::MOVDDUP:
3611   case X86ISD::MOVSS:
3612   case X86ISD::MOVSD:
3613   case X86ISD::UNPCKL:
3614   case X86ISD::UNPCKH:
3615   case X86ISD::VPERMILPI:
3616   case X86ISD::VPERM2X128:
3617   case X86ISD::VPERMI:
3618     return true;
3619   }
3620 }
3621
3622 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3623                                     SDValue V1, SelectionDAG &DAG) {
3624   switch(Opc) {
3625   default: llvm_unreachable("Unknown x86 shuffle node");
3626   case X86ISD::MOVSHDUP:
3627   case X86ISD::MOVSLDUP:
3628   case X86ISD::MOVDDUP:
3629     return DAG.getNode(Opc, dl, VT, V1);
3630   }
3631 }
3632
3633 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3634                                     SDValue V1, unsigned TargetMask,
3635                                     SelectionDAG &DAG) {
3636   switch(Opc) {
3637   default: llvm_unreachable("Unknown x86 shuffle node");
3638   case X86ISD::PSHUFD:
3639   case X86ISD::PSHUFHW:
3640   case X86ISD::PSHUFLW:
3641   case X86ISD::VPERMILPI:
3642   case X86ISD::VPERMI:
3643     return DAG.getNode(Opc, dl, VT, V1, DAG.getConstant(TargetMask, MVT::i8));
3644   }
3645 }
3646
3647 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3648                                     SDValue V1, SDValue V2, unsigned TargetMask,
3649                                     SelectionDAG &DAG) {
3650   switch(Opc) {
3651   default: llvm_unreachable("Unknown x86 shuffle node");
3652   case X86ISD::PALIGNR:
3653   case X86ISD::VALIGN:
3654   case X86ISD::SHUFP:
3655   case X86ISD::VPERM2X128:
3656     return DAG.getNode(Opc, dl, VT, V1, V2,
3657                        DAG.getConstant(TargetMask, MVT::i8));
3658   }
3659 }
3660
3661 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3662                                     SDValue V1, SDValue V2, SelectionDAG &DAG) {
3663   switch(Opc) {
3664   default: llvm_unreachable("Unknown x86 shuffle node");
3665   case X86ISD::MOVLHPS:
3666   case X86ISD::MOVLHPD:
3667   case X86ISD::MOVHLPS:
3668   case X86ISD::MOVLPS:
3669   case X86ISD::MOVLPD:
3670   case X86ISD::MOVSS:
3671   case X86ISD::MOVSD:
3672   case X86ISD::UNPCKL:
3673   case X86ISD::UNPCKH:
3674     return DAG.getNode(Opc, dl, VT, V1, V2);
3675   }
3676 }
3677
3678 SDValue X86TargetLowering::getReturnAddressFrameIndex(SelectionDAG &DAG) const {
3679   MachineFunction &MF = DAG.getMachineFunction();
3680   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
3681   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
3682   int ReturnAddrIndex = FuncInfo->getRAIndex();
3683
3684   if (ReturnAddrIndex == 0) {
3685     // Set up a frame object for the return address.
3686     unsigned SlotSize = RegInfo->getSlotSize();
3687     ReturnAddrIndex = MF.getFrameInfo()->CreateFixedObject(SlotSize,
3688                                                            -(int64_t)SlotSize,
3689                                                            false);
3690     FuncInfo->setRAIndex(ReturnAddrIndex);
3691   }
3692
3693   return DAG.getFrameIndex(ReturnAddrIndex, getPointerTy());
3694 }
3695
3696 bool X86::isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
3697                                        bool hasSymbolicDisplacement) {
3698   // Offset should fit into 32 bit immediate field.
3699   if (!isInt<32>(Offset))
3700     return false;
3701
3702   // If we don't have a symbolic displacement - we don't have any extra
3703   // restrictions.
3704   if (!hasSymbolicDisplacement)
3705     return true;
3706
3707   // FIXME: Some tweaks might be needed for medium code model.
3708   if (M != CodeModel::Small && M != CodeModel::Kernel)
3709     return false;
3710
3711   // For small code model we assume that latest object is 16MB before end of 31
3712   // bits boundary. We may also accept pretty large negative constants knowing
3713   // that all objects are in the positive half of address space.
3714   if (M == CodeModel::Small && Offset < 16*1024*1024)
3715     return true;
3716
3717   // For kernel code model we know that all object resist in the negative half
3718   // of 32bits address space. We may not accept negative offsets, since they may
3719   // be just off and we may accept pretty large positive ones.
3720   if (M == CodeModel::Kernel && Offset >= 0)
3721     return true;
3722
3723   return false;
3724 }
3725
3726 /// isCalleePop - Determines whether the callee is required to pop its
3727 /// own arguments. Callee pop is necessary to support tail calls.
3728 bool X86::isCalleePop(CallingConv::ID CallingConv,
3729                       bool is64Bit, bool IsVarArg, bool TailCallOpt) {
3730   switch (CallingConv) {
3731   default:
3732     return false;
3733   case CallingConv::X86_StdCall:
3734   case CallingConv::X86_FastCall:
3735   case CallingConv::X86_ThisCall:
3736     return !is64Bit;
3737   case CallingConv::Fast:
3738   case CallingConv::GHC:
3739   case CallingConv::HiPE:
3740     if (IsVarArg)
3741       return false;
3742     return TailCallOpt;
3743   }
3744 }
3745
3746 /// \brief Return true if the condition is an unsigned comparison operation.
3747 static bool isX86CCUnsigned(unsigned X86CC) {
3748   switch (X86CC) {
3749   default: llvm_unreachable("Invalid integer condition!");
3750   case X86::COND_E:     return true;
3751   case X86::COND_G:     return false;
3752   case X86::COND_GE:    return false;
3753   case X86::COND_L:     return false;
3754   case X86::COND_LE:    return false;
3755   case X86::COND_NE:    return true;
3756   case X86::COND_B:     return true;
3757   case X86::COND_A:     return true;
3758   case X86::COND_BE:    return true;
3759   case X86::COND_AE:    return true;
3760   }
3761   llvm_unreachable("covered switch fell through?!");
3762 }
3763
3764 /// TranslateX86CC - do a one to one translation of a ISD::CondCode to the X86
3765 /// specific condition code, returning the condition code and the LHS/RHS of the
3766 /// comparison to make.
3767 static unsigned TranslateX86CC(ISD::CondCode SetCCOpcode, bool isFP,
3768                                SDValue &LHS, SDValue &RHS, SelectionDAG &DAG) {
3769   if (!isFP) {
3770     if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS)) {
3771       if (SetCCOpcode == ISD::SETGT && RHSC->isAllOnesValue()) {
3772         // X > -1   -> X == 0, jump !sign.
3773         RHS = DAG.getConstant(0, RHS.getValueType());
3774         return X86::COND_NS;
3775       }
3776       if (SetCCOpcode == ISD::SETLT && RHSC->isNullValue()) {
3777         // X < 0   -> X == 0, jump on sign.
3778         return X86::COND_S;
3779       }
3780       if (SetCCOpcode == ISD::SETLT && RHSC->getZExtValue() == 1) {
3781         // X < 1   -> X <= 0
3782         RHS = DAG.getConstant(0, RHS.getValueType());
3783         return X86::COND_LE;
3784       }
3785     }
3786
3787     switch (SetCCOpcode) {
3788     default: llvm_unreachable("Invalid integer condition!");
3789     case ISD::SETEQ:  return X86::COND_E;
3790     case ISD::SETGT:  return X86::COND_G;
3791     case ISD::SETGE:  return X86::COND_GE;
3792     case ISD::SETLT:  return X86::COND_L;
3793     case ISD::SETLE:  return X86::COND_LE;
3794     case ISD::SETNE:  return X86::COND_NE;
3795     case ISD::SETULT: return X86::COND_B;
3796     case ISD::SETUGT: return X86::COND_A;
3797     case ISD::SETULE: return X86::COND_BE;
3798     case ISD::SETUGE: return X86::COND_AE;
3799     }
3800   }
3801
3802   // First determine if it is required or is profitable to flip the operands.
3803
3804   // If LHS is a foldable load, but RHS is not, flip the condition.
3805   if (ISD::isNON_EXTLoad(LHS.getNode()) &&
3806       !ISD::isNON_EXTLoad(RHS.getNode())) {
3807     SetCCOpcode = getSetCCSwappedOperands(SetCCOpcode);
3808     std::swap(LHS, RHS);
3809   }
3810
3811   switch (SetCCOpcode) {
3812   default: break;
3813   case ISD::SETOLT:
3814   case ISD::SETOLE:
3815   case ISD::SETUGT:
3816   case ISD::SETUGE:
3817     std::swap(LHS, RHS);
3818     break;
3819   }
3820
3821   // On a floating point condition, the flags are set as follows:
3822   // ZF  PF  CF   op
3823   //  0 | 0 | 0 | X > Y
3824   //  0 | 0 | 1 | X < Y
3825   //  1 | 0 | 0 | X == Y
3826   //  1 | 1 | 1 | unordered
3827   switch (SetCCOpcode) {
3828   default: llvm_unreachable("Condcode should be pre-legalized away");
3829   case ISD::SETUEQ:
3830   case ISD::SETEQ:   return X86::COND_E;
3831   case ISD::SETOLT:              // flipped
3832   case ISD::SETOGT:
3833   case ISD::SETGT:   return X86::COND_A;
3834   case ISD::SETOLE:              // flipped
3835   case ISD::SETOGE:
3836   case ISD::SETGE:   return X86::COND_AE;
3837   case ISD::SETUGT:              // flipped
3838   case ISD::SETULT:
3839   case ISD::SETLT:   return X86::COND_B;
3840   case ISD::SETUGE:              // flipped
3841   case ISD::SETULE:
3842   case ISD::SETLE:   return X86::COND_BE;
3843   case ISD::SETONE:
3844   case ISD::SETNE:   return X86::COND_NE;
3845   case ISD::SETUO:   return X86::COND_P;
3846   case ISD::SETO:    return X86::COND_NP;
3847   case ISD::SETOEQ:
3848   case ISD::SETUNE:  return X86::COND_INVALID;
3849   }
3850 }
3851
3852 /// hasFPCMov - is there a floating point cmov for the specific X86 condition
3853 /// code. Current x86 isa includes the following FP cmov instructions:
3854 /// fcmovb, fcomvbe, fcomve, fcmovu, fcmovae, fcmova, fcmovne, fcmovnu.
3855 static bool hasFPCMov(unsigned X86CC) {
3856   switch (X86CC) {
3857   default:
3858     return false;
3859   case X86::COND_B:
3860   case X86::COND_BE:
3861   case X86::COND_E:
3862   case X86::COND_P:
3863   case X86::COND_A:
3864   case X86::COND_AE:
3865   case X86::COND_NE:
3866   case X86::COND_NP:
3867     return true;
3868   }
3869 }
3870
3871 /// isFPImmLegal - Returns true if the target can instruction select the
3872 /// specified FP immediate natively. If false, the legalizer will
3873 /// materialize the FP immediate as a load from a constant pool.
3874 bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
3875   for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) {
3876     if (Imm.bitwiseIsEqual(LegalFPImmediates[i]))
3877       return true;
3878   }
3879   return false;
3880 }
3881
3882 bool X86TargetLowering::shouldReduceLoadWidth(SDNode *Load,
3883                                               ISD::LoadExtType ExtTy,
3884                                               EVT NewVT) const {
3885   // "ELF Handling for Thread-Local Storage" specifies that R_X86_64_GOTTPOFF
3886   // relocation target a movq or addq instruction: don't let the load shrink.
3887   SDValue BasePtr = cast<LoadSDNode>(Load)->getBasePtr();
3888   if (BasePtr.getOpcode() == X86ISD::WrapperRIP)
3889     if (const auto *GA = dyn_cast<GlobalAddressSDNode>(BasePtr.getOperand(0)))
3890       return GA->getTargetFlags() != X86II::MO_GOTTPOFF;
3891   return true;
3892 }
3893
3894 /// \brief Returns true if it is beneficial to convert a load of a constant
3895 /// to just the constant itself.
3896 bool X86TargetLowering::shouldConvertConstantLoadToIntImm(const APInt &Imm,
3897                                                           Type *Ty) const {
3898   assert(Ty->isIntegerTy());
3899
3900   unsigned BitSize = Ty->getPrimitiveSizeInBits();
3901   if (BitSize == 0 || BitSize > 64)
3902     return false;
3903   return true;
3904 }
3905
3906 bool X86TargetLowering::isExtractSubvectorCheap(EVT ResVT,
3907                                                 unsigned Index) const {
3908   if (!isOperationLegalOrCustom(ISD::EXTRACT_SUBVECTOR, ResVT))
3909     return false;
3910
3911   return (Index == 0 || Index == ResVT.getVectorNumElements());
3912 }
3913
3914 bool X86TargetLowering::isCheapToSpeculateCttz() const {
3915   // Speculate cttz only if we can directly use TZCNT.
3916   return Subtarget->hasBMI();
3917 }
3918
3919 bool X86TargetLowering::isCheapToSpeculateCtlz() const {
3920   // Speculate ctlz only if we can directly use LZCNT.
3921   return Subtarget->hasLZCNT();
3922 }
3923
3924 /// isUndefOrInRange - Return true if Val is undef or if its value falls within
3925 /// the specified range (L, H].
3926 static bool isUndefOrInRange(int Val, int Low, int Hi) {
3927   return (Val < 0) || (Val >= Low && Val < Hi);
3928 }
3929
3930 /// isUndefOrEqual - Val is either less than zero (undef) or equal to the
3931 /// specified value.
3932 static bool isUndefOrEqual(int Val, int CmpVal) {
3933   return (Val < 0 || Val == CmpVal);
3934 }
3935
3936 /// isSequentialOrUndefInRange - Return true if every element in Mask, beginning
3937 /// from position Pos and ending in Pos+Size, falls within the specified
3938 /// sequential range (Low, Low+Size]. or is undef.
3939 static bool isSequentialOrUndefInRange(ArrayRef<int> Mask,
3940                                        unsigned Pos, unsigned Size, int Low) {
3941   for (unsigned i = Pos, e = Pos+Size; i != e; ++i, ++Low)
3942     if (!isUndefOrEqual(Mask[i], Low))
3943       return false;
3944   return true;
3945 }
3946
3947 /// isPSHUFDMask - Return true if the node specifies a shuffle of elements that
3948 /// is suitable for input to PSHUFD. That is, it doesn't reference the other
3949 /// operand - by default will match for first operand.
3950 static bool isPSHUFDMask(ArrayRef<int> Mask, MVT VT,
3951                          bool TestSecondOperand = false) {
3952   if (VT != MVT::v4f32 && VT != MVT::v4i32 &&
3953       VT != MVT::v2f64 && VT != MVT::v2i64)
3954     return false;
3955
3956   unsigned NumElems = VT.getVectorNumElements();
3957   unsigned Lo = TestSecondOperand ? NumElems : 0;
3958   unsigned Hi = Lo + NumElems;
3959
3960   for (unsigned i = 0; i < NumElems; ++i)
3961     if (!isUndefOrInRange(Mask[i], (int)Lo, (int)Hi))
3962       return false;
3963
3964   return true;
3965 }
3966
3967 /// isPSHUFHWMask - Return true if the node specifies a shuffle of elements that
3968 /// is suitable for input to PSHUFHW.
3969 static bool isPSHUFHWMask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
3970   if (VT != MVT::v8i16 && (!HasInt256 || VT != MVT::v16i16))
3971     return false;
3972
3973   // Lower quadword copied in order or undef.
3974   if (!isSequentialOrUndefInRange(Mask, 0, 4, 0))
3975     return false;
3976
3977   // Upper quadword shuffled.
3978   for (unsigned i = 4; i != 8; ++i)
3979     if (!isUndefOrInRange(Mask[i], 4, 8))
3980       return false;
3981
3982   if (VT == MVT::v16i16) {
3983     // Lower quadword copied in order or undef.
3984     if (!isSequentialOrUndefInRange(Mask, 8, 4, 8))
3985       return false;
3986
3987     // Upper quadword shuffled.
3988     for (unsigned i = 12; i != 16; ++i)
3989       if (!isUndefOrInRange(Mask[i], 12, 16))
3990         return false;
3991   }
3992
3993   return true;
3994 }
3995
3996 /// isPSHUFLWMask - Return true if the node specifies a shuffle of elements that
3997 /// is suitable for input to PSHUFLW.
3998 static bool isPSHUFLWMask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
3999   if (VT != MVT::v8i16 && (!HasInt256 || VT != MVT::v16i16))
4000     return false;
4001
4002   // Upper quadword copied in order.
4003   if (!isSequentialOrUndefInRange(Mask, 4, 4, 4))
4004     return false;
4005
4006   // Lower quadword shuffled.
4007   for (unsigned i = 0; i != 4; ++i)
4008     if (!isUndefOrInRange(Mask[i], 0, 4))
4009       return false;
4010
4011   if (VT == MVT::v16i16) {
4012     // Upper quadword copied in order.
4013     if (!isSequentialOrUndefInRange(Mask, 12, 4, 12))
4014       return false;
4015
4016     // Lower quadword shuffled.
4017     for (unsigned i = 8; i != 12; ++i)
4018       if (!isUndefOrInRange(Mask[i], 8, 12))
4019         return false;
4020   }
4021
4022   return true;
4023 }
4024
4025 /// \brief Return true if the mask specifies a shuffle of elements that is
4026 /// suitable for input to intralane (palignr) or interlane (valign) vector
4027 /// right-shift.
4028 static bool isAlignrMask(ArrayRef<int> Mask, MVT VT, bool InterLane) {
4029   unsigned NumElts = VT.getVectorNumElements();
4030   unsigned NumLanes = InterLane ? 1: VT.getSizeInBits()/128;
4031   unsigned NumLaneElts = NumElts/NumLanes;
4032
4033   // Do not handle 64-bit element shuffles with palignr.
4034   if (NumLaneElts == 2)
4035     return false;
4036
4037   for (unsigned l = 0; l != NumElts; l+=NumLaneElts) {
4038     unsigned i;
4039     for (i = 0; i != NumLaneElts; ++i) {
4040       if (Mask[i+l] >= 0)
4041         break;
4042     }
4043
4044     // Lane is all undef, go to next lane
4045     if (i == NumLaneElts)
4046       continue;
4047
4048     int Start = Mask[i+l];
4049
4050     // Make sure its in this lane in one of the sources
4051     if (!isUndefOrInRange(Start, l, l+NumLaneElts) &&
4052         !isUndefOrInRange(Start, l+NumElts, l+NumElts+NumLaneElts))
4053       return false;
4054
4055     // If not lane 0, then we must match lane 0
4056     if (l != 0 && Mask[i] >= 0 && !isUndefOrEqual(Start, Mask[i]+l))
4057       return false;
4058
4059     // Correct second source to be contiguous with first source
4060     if (Start >= (int)NumElts)
4061       Start -= NumElts - NumLaneElts;
4062
4063     // Make sure we're shifting in the right direction.
4064     if (Start <= (int)(i+l))
4065       return false;
4066
4067     Start -= i;
4068
4069     // Check the rest of the elements to see if they are consecutive.
4070     for (++i; i != NumLaneElts; ++i) {
4071       int Idx = Mask[i+l];
4072
4073       // Make sure its in this lane
4074       if (!isUndefOrInRange(Idx, l, l+NumLaneElts) &&
4075           !isUndefOrInRange(Idx, l+NumElts, l+NumElts+NumLaneElts))
4076         return false;
4077
4078       // If not lane 0, then we must match lane 0
4079       if (l != 0 && Mask[i] >= 0 && !isUndefOrEqual(Idx, Mask[i]+l))
4080         return false;
4081
4082       if (Idx >= (int)NumElts)
4083         Idx -= NumElts - NumLaneElts;
4084
4085       if (!isUndefOrEqual(Idx, Start+i))
4086         return false;
4087
4088     }
4089   }
4090
4091   return true;
4092 }
4093
4094 /// \brief Return true if the node specifies a shuffle of elements that is
4095 /// suitable for input to PALIGNR.
4096 static bool isPALIGNRMask(ArrayRef<int> Mask, MVT VT,
4097                           const X86Subtarget *Subtarget) {
4098   if ((VT.is128BitVector() && !Subtarget->hasSSSE3()) ||
4099       (VT.is256BitVector() && !Subtarget->hasInt256()) ||
4100       VT.is512BitVector())
4101     // FIXME: Add AVX512BW.
4102     return false;
4103
4104   return isAlignrMask(Mask, VT, false);
4105 }
4106
4107 /// \brief Return true if the node specifies a shuffle of elements that is
4108 /// suitable for input to VALIGN.
4109 static bool isVALIGNMask(ArrayRef<int> Mask, MVT VT,
4110                           const X86Subtarget *Subtarget) {
4111   // FIXME: Add AVX512VL.
4112   if (!VT.is512BitVector() || !Subtarget->hasAVX512())
4113     return false;
4114   return isAlignrMask(Mask, VT, true);
4115 }
4116
4117 /// CommuteVectorShuffleMask - Change values in a shuffle permute mask assuming
4118 /// the two vector operands have swapped position.
4119 static void CommuteVectorShuffleMask(SmallVectorImpl<int> &Mask,
4120                                      unsigned NumElems) {
4121   for (unsigned i = 0; i != NumElems; ++i) {
4122     int idx = Mask[i];
4123     if (idx < 0)
4124       continue;
4125     else if (idx < (int)NumElems)
4126       Mask[i] = idx + NumElems;
4127     else
4128       Mask[i] = idx - NumElems;
4129   }
4130 }
4131
4132 /// isSHUFPMask - Return true if the specified VECTOR_SHUFFLE operand
4133 /// specifies a shuffle of elements that is suitable for input to 128/256-bit
4134 /// SHUFPS and SHUFPD. If Commuted is true, then it checks for sources to be
4135 /// reverse of what x86 shuffles want.
4136 static bool isSHUFPMask(ArrayRef<int> Mask, MVT VT, bool Commuted = false) {
4137
4138   unsigned NumElems = VT.getVectorNumElements();
4139   unsigned NumLanes = VT.getSizeInBits()/128;
4140   unsigned NumLaneElems = NumElems/NumLanes;
4141
4142   if (NumLaneElems != 2 && NumLaneElems != 4)
4143     return false;
4144
4145   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
4146   bool symmetricMaskRequired =
4147     (VT.getSizeInBits() >= 256) && (EltSize == 32);
4148
4149   // VSHUFPSY divides the resulting vector into 4 chunks.
4150   // The sources are also splitted into 4 chunks, and each destination
4151   // chunk must come from a different source chunk.
4152   //
4153   //  SRC1 =>   X7    X6    X5    X4    X3    X2    X1    X0
4154   //  SRC2 =>   Y7    Y6    Y5    Y4    Y3    Y2    Y1    Y9
4155   //
4156   //  DST  =>  Y7..Y4,   Y7..Y4,   X7..X4,   X7..X4,
4157   //           Y3..Y0,   Y3..Y0,   X3..X0,   X3..X0
4158   //
4159   // VSHUFPDY divides the resulting vector into 4 chunks.
4160   // The sources are also splitted into 4 chunks, and each destination
4161   // chunk must come from a different source chunk.
4162   //
4163   //  SRC1 =>      X3       X2       X1       X0
4164   //  SRC2 =>      Y3       Y2       Y1       Y0
4165   //
4166   //  DST  =>  Y3..Y2,  X3..X2,  Y1..Y0,  X1..X0
4167   //
4168   SmallVector<int, 4> MaskVal(NumLaneElems, -1);
4169   unsigned HalfLaneElems = NumLaneElems/2;
4170   for (unsigned l = 0; l != NumElems; l += NumLaneElems) {
4171     for (unsigned i = 0; i != NumLaneElems; ++i) {
4172       int Idx = Mask[i+l];
4173       unsigned RngStart = l + ((Commuted == (i<HalfLaneElems)) ? NumElems : 0);
4174       if (!isUndefOrInRange(Idx, RngStart, RngStart+NumLaneElems))
4175         return false;
4176       // For VSHUFPSY, the mask of the second half must be the same as the
4177       // first but with the appropriate offsets. This works in the same way as
4178       // VPERMILPS works with masks.
4179       if (!symmetricMaskRequired || Idx < 0)
4180         continue;
4181       if (MaskVal[i] < 0) {
4182         MaskVal[i] = Idx - l;
4183         continue;
4184       }
4185       if ((signed)(Idx - l) != MaskVal[i])
4186         return false;
4187     }
4188   }
4189
4190   return true;
4191 }
4192
4193 /// isMOVHLPSMask - Return true if the specified VECTOR_SHUFFLE operand
4194 /// specifies a shuffle of elements that is suitable for input to MOVHLPS.
4195 static bool isMOVHLPSMask(ArrayRef<int> Mask, MVT VT) {
4196   if (!VT.is128BitVector())
4197     return false;
4198
4199   unsigned NumElems = VT.getVectorNumElements();
4200
4201   if (NumElems != 4)
4202     return false;
4203
4204   // Expect bit0 == 6, bit1 == 7, bit2 == 2, bit3 == 3
4205   return isUndefOrEqual(Mask[0], 6) &&
4206          isUndefOrEqual(Mask[1], 7) &&
4207          isUndefOrEqual(Mask[2], 2) &&
4208          isUndefOrEqual(Mask[3], 3);
4209 }
4210
4211 /// isMOVHLPS_v_undef_Mask - Special case of isMOVHLPSMask for canonical form
4212 /// of vector_shuffle v, v, <2, 3, 2, 3>, i.e. vector_shuffle v, undef,
4213 /// <2, 3, 2, 3>
4214 static bool isMOVHLPS_v_undef_Mask(ArrayRef<int> Mask, MVT VT) {
4215   if (!VT.is128BitVector())
4216     return false;
4217
4218   unsigned NumElems = VT.getVectorNumElements();
4219
4220   if (NumElems != 4)
4221     return false;
4222
4223   return isUndefOrEqual(Mask[0], 2) &&
4224          isUndefOrEqual(Mask[1], 3) &&
4225          isUndefOrEqual(Mask[2], 2) &&
4226          isUndefOrEqual(Mask[3], 3);
4227 }
4228
4229 /// isMOVLPMask - Return true if the specified VECTOR_SHUFFLE operand
4230 /// specifies a shuffle of elements that is suitable for input to MOVLP{S|D}.
4231 static bool isMOVLPMask(ArrayRef<int> Mask, MVT VT) {
4232   if (!VT.is128BitVector())
4233     return false;
4234
4235   unsigned NumElems = VT.getVectorNumElements();
4236
4237   if (NumElems != 2 && NumElems != 4)
4238     return false;
4239
4240   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4241     if (!isUndefOrEqual(Mask[i], i + NumElems))
4242       return false;
4243
4244   for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
4245     if (!isUndefOrEqual(Mask[i], i))
4246       return false;
4247
4248   return true;
4249 }
4250
4251 /// isMOVLHPSMask - Return true if the specified VECTOR_SHUFFLE operand
4252 /// specifies a shuffle of elements that is suitable for input to MOVLHPS.
4253 static bool isMOVLHPSMask(ArrayRef<int> Mask, MVT VT) {
4254   if (!VT.is128BitVector())
4255     return false;
4256
4257   unsigned NumElems = VT.getVectorNumElements();
4258
4259   if (NumElems != 2 && NumElems != 4)
4260     return false;
4261
4262   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4263     if (!isUndefOrEqual(Mask[i], i))
4264       return false;
4265
4266   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4267     if (!isUndefOrEqual(Mask[i + e], i + NumElems))
4268       return false;
4269
4270   return true;
4271 }
4272
4273 /// isINSERTPSMask - Return true if the specified VECTOR_SHUFFLE operand
4274 /// specifies a shuffle of elements that is suitable for input to INSERTPS.
4275 /// i. e: If all but one element come from the same vector.
4276 static bool isINSERTPSMask(ArrayRef<int> Mask, MVT VT) {
4277   // TODO: Deal with AVX's VINSERTPS
4278   if (!VT.is128BitVector() || (VT != MVT::v4f32 && VT != MVT::v4i32))
4279     return false;
4280
4281   unsigned CorrectPosV1 = 0;
4282   unsigned CorrectPosV2 = 0;
4283   for (int i = 0, e = (int)VT.getVectorNumElements(); i != e; ++i) {
4284     if (Mask[i] == -1) {
4285       ++CorrectPosV1;
4286       ++CorrectPosV2;
4287       continue;
4288     }
4289
4290     if (Mask[i] == i)
4291       ++CorrectPosV1;
4292     else if (Mask[i] == i + 4)
4293       ++CorrectPosV2;
4294   }
4295
4296   if (CorrectPosV1 == 3 || CorrectPosV2 == 3)
4297     // We have 3 elements (undefs count as elements from any vector) from one
4298     // vector, and one from another.
4299     return true;
4300
4301   return false;
4302 }
4303
4304 //
4305 // Some special combinations that can be optimized.
4306 //
4307 static
4308 SDValue Compact8x32ShuffleNode(ShuffleVectorSDNode *SVOp,
4309                                SelectionDAG &DAG) {
4310   MVT VT = SVOp->getSimpleValueType(0);
4311   SDLoc dl(SVOp);
4312
4313   if (VT != MVT::v8i32 && VT != MVT::v8f32)
4314     return SDValue();
4315
4316   ArrayRef<int> Mask = SVOp->getMask();
4317
4318   // These are the special masks that may be optimized.
4319   static const int MaskToOptimizeEven[] = {0, 8, 2, 10, 4, 12, 6, 14};
4320   static const int MaskToOptimizeOdd[]  = {1, 9, 3, 11, 5, 13, 7, 15};
4321   bool MatchEvenMask = true;
4322   bool MatchOddMask  = true;
4323   for (int i=0; i<8; ++i) {
4324     if (!isUndefOrEqual(Mask[i], MaskToOptimizeEven[i]))
4325       MatchEvenMask = false;
4326     if (!isUndefOrEqual(Mask[i], MaskToOptimizeOdd[i]))
4327       MatchOddMask = false;
4328   }
4329
4330   if (!MatchEvenMask && !MatchOddMask)
4331     return SDValue();
4332
4333   SDValue UndefNode = DAG.getNode(ISD::UNDEF, dl, VT);
4334
4335   SDValue Op0 = SVOp->getOperand(0);
4336   SDValue Op1 = SVOp->getOperand(1);
4337
4338   if (MatchEvenMask) {
4339     // Shift the second operand right to 32 bits.
4340     static const int ShiftRightMask[] = {-1, 0, -1, 2, -1, 4, -1, 6 };
4341     Op1 = DAG.getVectorShuffle(VT, dl, Op1, UndefNode, ShiftRightMask);
4342   } else {
4343     // Shift the first operand left to 32 bits.
4344     static const int ShiftLeftMask[] = {1, -1, 3, -1, 5, -1, 7, -1 };
4345     Op0 = DAG.getVectorShuffle(VT, dl, Op0, UndefNode, ShiftLeftMask);
4346   }
4347   static const int BlendMask[] = {0, 9, 2, 11, 4, 13, 6, 15};
4348   return DAG.getVectorShuffle(VT, dl, Op0, Op1, BlendMask);
4349 }
4350
4351 /// isUNPCKLMask - Return true if the specified VECTOR_SHUFFLE operand
4352 /// specifies a shuffle of elements that is suitable for input to UNPCKL.
4353 static bool isUNPCKLMask(ArrayRef<int> Mask, MVT VT,
4354                          bool HasInt256, bool V2IsSplat = false) {
4355
4356   assert(VT.getSizeInBits() >= 128 &&
4357          "Unsupported vector type for unpckl");
4358
4359   unsigned NumElts = VT.getVectorNumElements();
4360   if (VT.is256BitVector() && NumElts != 4 && NumElts != 8 &&
4361       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4362     return false;
4363
4364   assert((!VT.is512BitVector() || VT.getScalarType().getSizeInBits() >= 32) &&
4365          "Unsupported vector type for unpckh");
4366
4367   // AVX defines UNPCK* to operate independently on 128-bit lanes.
4368   unsigned NumLanes = VT.getSizeInBits()/128;
4369   unsigned NumLaneElts = NumElts/NumLanes;
4370
4371   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4372     for (unsigned i = 0, j = l; i != NumLaneElts; i += 2, ++j) {
4373       int BitI  = Mask[l+i];
4374       int BitI1 = Mask[l+i+1];
4375       if (!isUndefOrEqual(BitI, j))
4376         return false;
4377       if (V2IsSplat) {
4378         if (!isUndefOrEqual(BitI1, NumElts))
4379           return false;
4380       } else {
4381         if (!isUndefOrEqual(BitI1, j + NumElts))
4382           return false;
4383       }
4384     }
4385   }
4386
4387   return true;
4388 }
4389
4390 /// isUNPCKHMask - Return true if the specified VECTOR_SHUFFLE operand
4391 /// specifies a shuffle of elements that is suitable for input to UNPCKH.
4392 static bool isUNPCKHMask(ArrayRef<int> Mask, MVT VT,
4393                          bool HasInt256, bool V2IsSplat = false) {
4394   assert(VT.getSizeInBits() >= 128 &&
4395          "Unsupported vector type for unpckh");
4396
4397   unsigned NumElts = VT.getVectorNumElements();
4398   if (VT.is256BitVector() && NumElts != 4 && NumElts != 8 &&
4399       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4400     return false;
4401
4402   assert((!VT.is512BitVector() || VT.getScalarType().getSizeInBits() >= 32) &&
4403          "Unsupported vector type for unpckh");
4404
4405   // AVX defines UNPCK* to operate independently on 128-bit lanes.
4406   unsigned NumLanes = VT.getSizeInBits()/128;
4407   unsigned NumLaneElts = NumElts/NumLanes;
4408
4409   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4410     for (unsigned i = 0, j = l+NumLaneElts/2; i != NumLaneElts; i += 2, ++j) {
4411       int BitI  = Mask[l+i];
4412       int BitI1 = Mask[l+i+1];
4413       if (!isUndefOrEqual(BitI, j))
4414         return false;
4415       if (V2IsSplat) {
4416         if (isUndefOrEqual(BitI1, NumElts))
4417           return false;
4418       } else {
4419         if (!isUndefOrEqual(BitI1, j+NumElts))
4420           return false;
4421       }
4422     }
4423   }
4424   return true;
4425 }
4426
4427 /// isUNPCKL_v_undef_Mask - Special case of isUNPCKLMask for canonical form
4428 /// of vector_shuffle v, v, <0, 4, 1, 5>, i.e. vector_shuffle v, undef,
4429 /// <0, 0, 1, 1>
4430 static bool isUNPCKL_v_undef_Mask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
4431   unsigned NumElts = VT.getVectorNumElements();
4432   bool Is256BitVec = VT.is256BitVector();
4433
4434   if (VT.is512BitVector())
4435     return false;
4436   assert((VT.is128BitVector() || VT.is256BitVector()) &&
4437          "Unsupported vector type for unpckh");
4438
4439   if (Is256BitVec && NumElts != 4 && NumElts != 8 &&
4440       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4441     return false;
4442
4443   // For 256-bit i64/f64, use MOVDDUPY instead, so reject the matching pattern
4444   // FIXME: Need a better way to get rid of this, there's no latency difference
4445   // between UNPCKLPD and MOVDDUP, the later should always be checked first and
4446   // the former later. We should also remove the "_undef" special mask.
4447   if (NumElts == 4 && Is256BitVec)
4448     return false;
4449
4450   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
4451   // independently on 128-bit lanes.
4452   unsigned NumLanes = VT.getSizeInBits()/128;
4453   unsigned NumLaneElts = NumElts/NumLanes;
4454
4455   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4456     for (unsigned i = 0, j = l; i != NumLaneElts; i += 2, ++j) {
4457       int BitI  = Mask[l+i];
4458       int BitI1 = Mask[l+i+1];
4459
4460       if (!isUndefOrEqual(BitI, j))
4461         return false;
4462       if (!isUndefOrEqual(BitI1, j))
4463         return false;
4464     }
4465   }
4466
4467   return true;
4468 }
4469
4470 /// isUNPCKH_v_undef_Mask - Special case of isUNPCKHMask for canonical form
4471 /// of vector_shuffle v, v, <2, 6, 3, 7>, i.e. vector_shuffle v, undef,
4472 /// <2, 2, 3, 3>
4473 static bool isUNPCKH_v_undef_Mask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
4474   unsigned NumElts = VT.getVectorNumElements();
4475
4476   if (VT.is512BitVector())
4477     return false;
4478
4479   assert((VT.is128BitVector() || VT.is256BitVector()) &&
4480          "Unsupported vector type for unpckh");
4481
4482   if (VT.is256BitVector() && NumElts != 4 && NumElts != 8 &&
4483       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4484     return false;
4485
4486   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
4487   // independently on 128-bit lanes.
4488   unsigned NumLanes = VT.getSizeInBits()/128;
4489   unsigned NumLaneElts = NumElts/NumLanes;
4490
4491   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4492     for (unsigned i = 0, j = l+NumLaneElts/2; i != NumLaneElts; i += 2, ++j) {
4493       int BitI  = Mask[l+i];
4494       int BitI1 = Mask[l+i+1];
4495       if (!isUndefOrEqual(BitI, j))
4496         return false;
4497       if (!isUndefOrEqual(BitI1, j))
4498         return false;
4499     }
4500   }
4501   return true;
4502 }
4503
4504 // Match for INSERTI64x4 INSERTF64x4 instructions (src0[0], src1[0]) or
4505 // (src1[0], src0[1]), manipulation with 256-bit sub-vectors
4506 static bool isINSERT64x4Mask(ArrayRef<int> Mask, MVT VT, unsigned int *Imm) {
4507   if (!VT.is512BitVector())
4508     return false;
4509
4510   unsigned NumElts = VT.getVectorNumElements();
4511   unsigned HalfSize = NumElts/2;
4512   if (isSequentialOrUndefInRange(Mask, 0, HalfSize, 0)) {
4513     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, NumElts)) {
4514       *Imm = 1;
4515       return true;
4516     }
4517   }
4518   if (isSequentialOrUndefInRange(Mask, 0, HalfSize, NumElts)) {
4519     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, HalfSize)) {
4520       *Imm = 0;
4521       return true;
4522     }
4523   }
4524   return false;
4525 }
4526
4527 /// isMOVLMask - Return true if the specified VECTOR_SHUFFLE operand
4528 /// specifies a shuffle of elements that is suitable for input to MOVSS,
4529 /// MOVSD, and MOVD, i.e. setting the lowest element.
4530 static bool isMOVLMask(ArrayRef<int> Mask, EVT VT) {
4531   if (VT.getVectorElementType().getSizeInBits() < 32)
4532     return false;
4533   if (!VT.is128BitVector())
4534     return false;
4535
4536   unsigned NumElts = VT.getVectorNumElements();
4537
4538   if (!isUndefOrEqual(Mask[0], NumElts))
4539     return false;
4540
4541   for (unsigned i = 1; i != NumElts; ++i)
4542     if (!isUndefOrEqual(Mask[i], i))
4543       return false;
4544
4545   return true;
4546 }
4547
4548 /// isVPERM2X128Mask - Match 256-bit shuffles where the elements are considered
4549 /// as permutations between 128-bit chunks or halves. As an example: this
4550 /// shuffle bellow:
4551 ///   vector_shuffle <4, 5, 6, 7, 12, 13, 14, 15>
4552 /// The first half comes from the second half of V1 and the second half from the
4553 /// the second half of V2.
4554 static bool isVPERM2X128Mask(ArrayRef<int> Mask, MVT VT, bool HasFp256) {
4555   if (!HasFp256 || !VT.is256BitVector())
4556     return false;
4557
4558   // The shuffle result is divided into half A and half B. In total the two
4559   // sources have 4 halves, namely: C, D, E, F. The final values of A and
4560   // B must come from C, D, E or F.
4561   unsigned HalfSize = VT.getVectorNumElements()/2;
4562   bool MatchA = false, MatchB = false;
4563
4564   // Check if A comes from one of C, D, E, F.
4565   for (unsigned Half = 0; Half != 4; ++Half) {
4566     if (isSequentialOrUndefInRange(Mask, 0, HalfSize, Half*HalfSize)) {
4567       MatchA = true;
4568       break;
4569     }
4570   }
4571
4572   // Check if B comes from one of C, D, E, F.
4573   for (unsigned Half = 0; Half != 4; ++Half) {
4574     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, Half*HalfSize)) {
4575       MatchB = true;
4576       break;
4577     }
4578   }
4579
4580   return MatchA && MatchB;
4581 }
4582
4583 /// getShuffleVPERM2X128Immediate - Return the appropriate immediate to shuffle
4584 /// the specified VECTOR_MASK mask with VPERM2F128/VPERM2I128 instructions.
4585 static unsigned getShuffleVPERM2X128Immediate(ShuffleVectorSDNode *SVOp) {
4586   MVT VT = SVOp->getSimpleValueType(0);
4587
4588   unsigned HalfSize = VT.getVectorNumElements()/2;
4589
4590   unsigned FstHalf = 0, SndHalf = 0;
4591   for (unsigned i = 0; i < HalfSize; ++i) {
4592     if (SVOp->getMaskElt(i) > 0) {
4593       FstHalf = SVOp->getMaskElt(i)/HalfSize;
4594       break;
4595     }
4596   }
4597   for (unsigned i = HalfSize; i < HalfSize*2; ++i) {
4598     if (SVOp->getMaskElt(i) > 0) {
4599       SndHalf = SVOp->getMaskElt(i)/HalfSize;
4600       break;
4601     }
4602   }
4603
4604   return (FstHalf | (SndHalf << 4));
4605 }
4606
4607 // Symmetric in-lane mask. Each lane has 4 elements (for imm8)
4608 static bool isPermImmMask(ArrayRef<int> Mask, MVT VT, unsigned& Imm8) {
4609   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
4610   if (EltSize < 32)
4611     return false;
4612
4613   unsigned NumElts = VT.getVectorNumElements();
4614   Imm8 = 0;
4615   if (VT.is128BitVector() || (VT.is256BitVector() && EltSize == 64)) {
4616     for (unsigned i = 0; i != NumElts; ++i) {
4617       if (Mask[i] < 0)
4618         continue;
4619       Imm8 |= Mask[i] << (i*2);
4620     }
4621     return true;
4622   }
4623
4624   unsigned LaneSize = 4;
4625   SmallVector<int, 4> MaskVal(LaneSize, -1);
4626
4627   for (unsigned l = 0; l != NumElts; l += LaneSize) {
4628     for (unsigned i = 0; i != LaneSize; ++i) {
4629       if (!isUndefOrInRange(Mask[i+l], l, l+LaneSize))
4630         return false;
4631       if (Mask[i+l] < 0)
4632         continue;
4633       if (MaskVal[i] < 0) {
4634         MaskVal[i] = Mask[i+l] - l;
4635         Imm8 |= MaskVal[i] << (i*2);
4636         continue;
4637       }
4638       if (Mask[i+l] != (signed)(MaskVal[i]+l))
4639         return false;
4640     }
4641   }
4642   return true;
4643 }
4644
4645 /// isVPERMILPMask - Return true if the specified VECTOR_SHUFFLE operand
4646 /// specifies a shuffle of elements that is suitable for input to VPERMILPD*.
4647 /// Note that VPERMIL mask matching is different depending whether theunderlying
4648 /// type is 32 or 64. In the VPERMILPS the high half of the mask should point
4649 /// to the same elements of the low, but to the higher half of the source.
4650 /// In VPERMILPD the two lanes could be shuffled independently of each other
4651 /// with the same restriction that lanes can't be crossed. Also handles PSHUFDY.
4652 static bool isVPERMILPMask(ArrayRef<int> Mask, MVT VT) {
4653   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
4654   if (VT.getSizeInBits() < 256 || EltSize < 32)
4655     return false;
4656   bool symmetricMaskRequired = (EltSize == 32);
4657   unsigned NumElts = VT.getVectorNumElements();
4658
4659   unsigned NumLanes = VT.getSizeInBits()/128;
4660   unsigned LaneSize = NumElts/NumLanes;
4661   // 2 or 4 elements in one lane
4662
4663   SmallVector<int, 4> ExpectedMaskVal(LaneSize, -1);
4664   for (unsigned l = 0; l != NumElts; l += LaneSize) {
4665     for (unsigned i = 0; i != LaneSize; ++i) {
4666       if (!isUndefOrInRange(Mask[i+l], l, l+LaneSize))
4667         return false;
4668       if (symmetricMaskRequired) {
4669         if (ExpectedMaskVal[i] < 0 && Mask[i+l] >= 0) {
4670           ExpectedMaskVal[i] = Mask[i+l] - l;
4671           continue;
4672         }
4673         if (!isUndefOrEqual(Mask[i+l], ExpectedMaskVal[i]+l))
4674           return false;
4675       }
4676     }
4677   }
4678   return true;
4679 }
4680
4681 /// isCommutedMOVLMask - Returns true if the shuffle mask is except the reverse
4682 /// of what x86 movss want. X86 movs requires the lowest  element to be lowest
4683 /// element of vector 2 and the other elements to come from vector 1 in order.
4684 static bool isCommutedMOVLMask(ArrayRef<int> Mask, MVT VT,
4685                                bool V2IsSplat = false, bool V2IsUndef = false) {
4686   if (!VT.is128BitVector())
4687     return false;
4688
4689   unsigned NumOps = VT.getVectorNumElements();
4690   if (NumOps != 2 && NumOps != 4 && NumOps != 8 && NumOps != 16)
4691     return false;
4692
4693   if (!isUndefOrEqual(Mask[0], 0))
4694     return false;
4695
4696   for (unsigned i = 1; i != NumOps; ++i)
4697     if (!(isUndefOrEqual(Mask[i], i+NumOps) ||
4698           (V2IsUndef && isUndefOrInRange(Mask[i], NumOps, NumOps*2)) ||
4699           (V2IsSplat && isUndefOrEqual(Mask[i], NumOps))))
4700       return false;
4701
4702   return true;
4703 }
4704
4705 /// isMOVSHDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4706 /// specifies a shuffle of elements that is suitable for input to MOVSHDUP.
4707 /// Masks to match: <1, 1, 3, 3> or <1, 1, 3, 3, 5, 5, 7, 7>
4708 static bool isMOVSHDUPMask(ArrayRef<int> Mask, MVT VT,
4709                            const X86Subtarget *Subtarget) {
4710   if (!Subtarget->hasSSE3())
4711     return false;
4712
4713   unsigned NumElems = VT.getVectorNumElements();
4714
4715   if ((VT.is128BitVector() && NumElems != 4) ||
4716       (VT.is256BitVector() && NumElems != 8) ||
4717       (VT.is512BitVector() && NumElems != 16))
4718     return false;
4719
4720   // "i+1" is the value the indexed mask element must have
4721   for (unsigned i = 0; i != NumElems; i += 2)
4722     if (!isUndefOrEqual(Mask[i], i+1) ||
4723         !isUndefOrEqual(Mask[i+1], i+1))
4724       return false;
4725
4726   return true;
4727 }
4728
4729 /// isMOVSLDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4730 /// specifies a shuffle of elements that is suitable for input to MOVSLDUP.
4731 /// Masks to match: <0, 0, 2, 2> or <0, 0, 2, 2, 4, 4, 6, 6>
4732 static bool isMOVSLDUPMask(ArrayRef<int> Mask, MVT VT,
4733                            const X86Subtarget *Subtarget) {
4734   if (!Subtarget->hasSSE3())
4735     return false;
4736
4737   unsigned NumElems = VT.getVectorNumElements();
4738
4739   if ((VT.is128BitVector() && NumElems != 4) ||
4740       (VT.is256BitVector() && NumElems != 8) ||
4741       (VT.is512BitVector() && NumElems != 16))
4742     return false;
4743
4744   // "i" is the value the indexed mask element must have
4745   for (unsigned i = 0; i != NumElems; i += 2)
4746     if (!isUndefOrEqual(Mask[i], i) ||
4747         !isUndefOrEqual(Mask[i+1], i))
4748       return false;
4749
4750   return true;
4751 }
4752
4753 /// isMOVDDUPYMask - Return true if the specified VECTOR_SHUFFLE operand
4754 /// specifies a shuffle of elements that is suitable for input to 256-bit
4755 /// version of MOVDDUP.
4756 static bool isMOVDDUPYMask(ArrayRef<int> Mask, MVT VT, bool HasFp256) {
4757   if (!HasFp256 || !VT.is256BitVector())
4758     return false;
4759
4760   unsigned NumElts = VT.getVectorNumElements();
4761   if (NumElts != 4)
4762     return false;
4763
4764   for (unsigned i = 0; i != NumElts/2; ++i)
4765     if (!isUndefOrEqual(Mask[i], 0))
4766       return false;
4767   for (unsigned i = NumElts/2; i != NumElts; ++i)
4768     if (!isUndefOrEqual(Mask[i], NumElts/2))
4769       return false;
4770   return true;
4771 }
4772
4773 /// isMOVDDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4774 /// specifies a shuffle of elements that is suitable for input to 128-bit
4775 /// version of MOVDDUP.
4776 static bool isMOVDDUPMask(ArrayRef<int> Mask, MVT VT) {
4777   if (!VT.is128BitVector())
4778     return false;
4779
4780   unsigned e = VT.getVectorNumElements() / 2;
4781   for (unsigned i = 0; i != e; ++i)
4782     if (!isUndefOrEqual(Mask[i], i))
4783       return false;
4784   for (unsigned i = 0; i != e; ++i)
4785     if (!isUndefOrEqual(Mask[e+i], i))
4786       return false;
4787   return true;
4788 }
4789
4790 /// isVEXTRACTIndex - Return true if the specified
4791 /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
4792 /// suitable for instruction that extract 128 or 256 bit vectors
4793 static bool isVEXTRACTIndex(SDNode *N, unsigned vecWidth) {
4794   assert((vecWidth == 128 || vecWidth == 256) && "Unexpected vector width");
4795   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4796     return false;
4797
4798   // The index should be aligned on a vecWidth-bit boundary.
4799   uint64_t Index =
4800     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4801
4802   MVT VT = N->getSimpleValueType(0);
4803   unsigned ElSize = VT.getVectorElementType().getSizeInBits();
4804   bool Result = (Index * ElSize) % vecWidth == 0;
4805
4806   return Result;
4807 }
4808
4809 /// isVINSERTIndex - Return true if the specified INSERT_SUBVECTOR
4810 /// operand specifies a subvector insert that is suitable for input to
4811 /// insertion of 128 or 256-bit subvectors
4812 static bool isVINSERTIndex(SDNode *N, unsigned vecWidth) {
4813   assert((vecWidth == 128 || vecWidth == 256) && "Unexpected vector width");
4814   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4815     return false;
4816   // The index should be aligned on a vecWidth-bit boundary.
4817   uint64_t Index =
4818     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4819
4820   MVT VT = N->getSimpleValueType(0);
4821   unsigned ElSize = VT.getVectorElementType().getSizeInBits();
4822   bool Result = (Index * ElSize) % vecWidth == 0;
4823
4824   return Result;
4825 }
4826
4827 bool X86::isVINSERT128Index(SDNode *N) {
4828   return isVINSERTIndex(N, 128);
4829 }
4830
4831 bool X86::isVINSERT256Index(SDNode *N) {
4832   return isVINSERTIndex(N, 256);
4833 }
4834
4835 bool X86::isVEXTRACT128Index(SDNode *N) {
4836   return isVEXTRACTIndex(N, 128);
4837 }
4838
4839 bool X86::isVEXTRACT256Index(SDNode *N) {
4840   return isVEXTRACTIndex(N, 256);
4841 }
4842
4843 /// getShuffleSHUFImmediate - Return the appropriate immediate to shuffle
4844 /// the specified VECTOR_SHUFFLE mask with PSHUF* and SHUFP* instructions.
4845 /// Handles 128-bit and 256-bit.
4846 static unsigned getShuffleSHUFImmediate(ShuffleVectorSDNode *N) {
4847   MVT VT = N->getSimpleValueType(0);
4848
4849   assert((VT.getSizeInBits() >= 128) &&
4850          "Unsupported vector type for PSHUF/SHUFP");
4851
4852   // Handle 128 and 256-bit vector lengths. AVX defines PSHUF/SHUFP to operate
4853   // independently on 128-bit lanes.
4854   unsigned NumElts = VT.getVectorNumElements();
4855   unsigned NumLanes = VT.getSizeInBits()/128;
4856   unsigned NumLaneElts = NumElts/NumLanes;
4857
4858   assert((NumLaneElts == 2 || NumLaneElts == 4 || NumLaneElts == 8) &&
4859          "Only supports 2, 4 or 8 elements per lane");
4860
4861   unsigned Shift = (NumLaneElts >= 4) ? 1 : 0;
4862   unsigned Mask = 0;
4863   for (unsigned i = 0; i != NumElts; ++i) {
4864     int Elt = N->getMaskElt(i);
4865     if (Elt < 0) continue;
4866     Elt &= NumLaneElts - 1;
4867     unsigned ShAmt = (i << Shift) % 8;
4868     Mask |= Elt << ShAmt;
4869   }
4870
4871   return Mask;
4872 }
4873
4874 /// getShufflePSHUFHWImmediate - Return the appropriate immediate to shuffle
4875 /// the specified VECTOR_SHUFFLE mask with the PSHUFHW instruction.
4876 static unsigned getShufflePSHUFHWImmediate(ShuffleVectorSDNode *N) {
4877   MVT VT = N->getSimpleValueType(0);
4878
4879   assert((VT == MVT::v8i16 || VT == MVT::v16i16) &&
4880          "Unsupported vector type for PSHUFHW");
4881
4882   unsigned NumElts = VT.getVectorNumElements();
4883
4884   unsigned Mask = 0;
4885   for (unsigned l = 0; l != NumElts; l += 8) {
4886     // 8 nodes per lane, but we only care about the last 4.
4887     for (unsigned i = 0; i < 4; ++i) {
4888       int Elt = N->getMaskElt(l+i+4);
4889       if (Elt < 0) continue;
4890       Elt &= 0x3; // only 2-bits.
4891       Mask |= Elt << (i * 2);
4892     }
4893   }
4894
4895   return Mask;
4896 }
4897
4898 /// getShufflePSHUFLWImmediate - Return the appropriate immediate to shuffle
4899 /// the specified VECTOR_SHUFFLE mask with the PSHUFLW instruction.
4900 static unsigned getShufflePSHUFLWImmediate(ShuffleVectorSDNode *N) {
4901   MVT VT = N->getSimpleValueType(0);
4902
4903   assert((VT == MVT::v8i16 || VT == MVT::v16i16) &&
4904          "Unsupported vector type for PSHUFHW");
4905
4906   unsigned NumElts = VT.getVectorNumElements();
4907
4908   unsigned Mask = 0;
4909   for (unsigned l = 0; l != NumElts; l += 8) {
4910     // 8 nodes per lane, but we only care about the first 4.
4911     for (unsigned i = 0; i < 4; ++i) {
4912       int Elt = N->getMaskElt(l+i);
4913       if (Elt < 0) continue;
4914       Elt &= 0x3; // only 2-bits
4915       Mask |= Elt << (i * 2);
4916     }
4917   }
4918
4919   return Mask;
4920 }
4921
4922 /// \brief Return the appropriate immediate to shuffle the specified
4923 /// VECTOR_SHUFFLE mask with the PALIGNR (if InterLane is false) or with
4924 /// VALIGN (if Interlane is true) instructions.
4925 static unsigned getShuffleAlignrImmediate(ShuffleVectorSDNode *SVOp,
4926                                            bool InterLane) {
4927   MVT VT = SVOp->getSimpleValueType(0);
4928   unsigned EltSize = InterLane ? 1 :
4929     VT.getVectorElementType().getSizeInBits() >> 3;
4930
4931   unsigned NumElts = VT.getVectorNumElements();
4932   unsigned NumLanes = VT.is512BitVector() ? 1 : VT.getSizeInBits()/128;
4933   unsigned NumLaneElts = NumElts/NumLanes;
4934
4935   int Val = 0;
4936   unsigned i;
4937   for (i = 0; i != NumElts; ++i) {
4938     Val = SVOp->getMaskElt(i);
4939     if (Val >= 0)
4940       break;
4941   }
4942   if (Val >= (int)NumElts)
4943     Val -= NumElts - NumLaneElts;
4944
4945   assert(Val - i > 0 && "PALIGNR imm should be positive");
4946   return (Val - i) * EltSize;
4947 }
4948
4949 /// \brief Return the appropriate immediate to shuffle the specified
4950 /// VECTOR_SHUFFLE mask with the PALIGNR instruction.
4951 static unsigned getShufflePALIGNRImmediate(ShuffleVectorSDNode *SVOp) {
4952   return getShuffleAlignrImmediate(SVOp, false);
4953 }
4954
4955 /// \brief Return the appropriate immediate to shuffle the specified
4956 /// VECTOR_SHUFFLE mask with the VALIGN instruction.
4957 static unsigned getShuffleVALIGNImmediate(ShuffleVectorSDNode *SVOp) {
4958   return getShuffleAlignrImmediate(SVOp, true);
4959 }
4960
4961
4962 static unsigned getExtractVEXTRACTImmediate(SDNode *N, unsigned vecWidth) {
4963   assert((vecWidth == 128 || vecWidth == 256) && "Unsupported vector width");
4964   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4965     llvm_unreachable("Illegal extract subvector for VEXTRACT");
4966
4967   uint64_t Index =
4968     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4969
4970   MVT VecVT = N->getOperand(0).getSimpleValueType();
4971   MVT ElVT = VecVT.getVectorElementType();
4972
4973   unsigned NumElemsPerChunk = vecWidth / ElVT.getSizeInBits();
4974   return Index / NumElemsPerChunk;
4975 }
4976
4977 static unsigned getInsertVINSERTImmediate(SDNode *N, unsigned vecWidth) {
4978   assert((vecWidth == 128 || vecWidth == 256) && "Unsupported vector width");
4979   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4980     llvm_unreachable("Illegal insert subvector for VINSERT");
4981
4982   uint64_t Index =
4983     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4984
4985   MVT VecVT = N->getSimpleValueType(0);
4986   MVT ElVT = VecVT.getVectorElementType();
4987
4988   unsigned NumElemsPerChunk = vecWidth / ElVT.getSizeInBits();
4989   return Index / NumElemsPerChunk;
4990 }
4991
4992 /// getExtractVEXTRACT128Immediate - Return the appropriate immediate
4993 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF128
4994 /// and VINSERTI128 instructions.
4995 unsigned X86::getExtractVEXTRACT128Immediate(SDNode *N) {
4996   return getExtractVEXTRACTImmediate(N, 128);
4997 }
4998
4999 /// getExtractVEXTRACT256Immediate - Return the appropriate immediate
5000 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF64x4
5001 /// and VINSERTI64x4 instructions.
5002 unsigned X86::getExtractVEXTRACT256Immediate(SDNode *N) {
5003   return getExtractVEXTRACTImmediate(N, 256);
5004 }
5005
5006 /// getInsertVINSERT128Immediate - Return the appropriate immediate
5007 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF128
5008 /// and VINSERTI128 instructions.
5009 unsigned X86::getInsertVINSERT128Immediate(SDNode *N) {
5010   return getInsertVINSERTImmediate(N, 128);
5011 }
5012
5013 /// getInsertVINSERT256Immediate - Return the appropriate immediate
5014 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF46x4
5015 /// and VINSERTI64x4 instructions.
5016 unsigned X86::getInsertVINSERT256Immediate(SDNode *N) {
5017   return getInsertVINSERTImmediate(N, 256);
5018 }
5019
5020 /// isZero - Returns true if Elt is a constant integer zero
5021 static bool isZero(SDValue V) {
5022   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
5023   return C && C->isNullValue();
5024 }
5025
5026 /// isZeroNode - Returns true if Elt is a constant zero or a floating point
5027 /// constant +0.0.
5028 bool X86::isZeroNode(SDValue Elt) {
5029   if (isZero(Elt))
5030     return true;
5031   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Elt))
5032     return CFP->getValueAPF().isPosZero();
5033   return false;
5034 }
5035
5036 /// ShouldXformToMOVHLPS - Return true if the node should be transformed to
5037 /// match movhlps. The lower half elements should come from upper half of
5038 /// V1 (and in order), and the upper half elements should come from the upper
5039 /// half of V2 (and in order).
5040 static bool ShouldXformToMOVHLPS(ArrayRef<int> Mask, MVT VT) {
5041   if (!VT.is128BitVector())
5042     return false;
5043   if (VT.getVectorNumElements() != 4)
5044     return false;
5045   for (unsigned i = 0, e = 2; i != e; ++i)
5046     if (!isUndefOrEqual(Mask[i], i+2))
5047       return false;
5048   for (unsigned i = 2; i != 4; ++i)
5049     if (!isUndefOrEqual(Mask[i], i+4))
5050       return false;
5051   return true;
5052 }
5053
5054 /// isScalarLoadToVector - Returns true if the node is a scalar load that
5055 /// is promoted to a vector. It also returns the LoadSDNode by reference if
5056 /// required.
5057 static bool isScalarLoadToVector(SDNode *N, LoadSDNode **LD = nullptr) {
5058   if (N->getOpcode() != ISD::SCALAR_TO_VECTOR)
5059     return false;
5060   N = N->getOperand(0).getNode();
5061   if (!ISD::isNON_EXTLoad(N))
5062     return false;
5063   if (LD)
5064     *LD = cast<LoadSDNode>(N);
5065   return true;
5066 }
5067
5068 // Test whether the given value is a vector value which will be legalized
5069 // into a load.
5070 static bool WillBeConstantPoolLoad(SDNode *N) {
5071   if (N->getOpcode() != ISD::BUILD_VECTOR)
5072     return false;
5073
5074   // Check for any non-constant elements.
5075   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
5076     switch (N->getOperand(i).getNode()->getOpcode()) {
5077     case ISD::UNDEF:
5078     case ISD::ConstantFP:
5079     case ISD::Constant:
5080       break;
5081     default:
5082       return false;
5083     }
5084
5085   // Vectors of all-zeros and all-ones are materialized with special
5086   // instructions rather than being loaded.
5087   return !ISD::isBuildVectorAllZeros(N) &&
5088          !ISD::isBuildVectorAllOnes(N);
5089 }
5090
5091 /// ShouldXformToMOVLP{S|D} - Return true if the node should be transformed to
5092 /// match movlp{s|d}. The lower half elements should come from lower half of
5093 /// V1 (and in order), and the upper half elements should come from the upper
5094 /// half of V2 (and in order). And since V1 will become the source of the
5095 /// MOVLP, it must be either a vector load or a scalar load to vector.
5096 static bool ShouldXformToMOVLP(SDNode *V1, SDNode *V2,
5097                                ArrayRef<int> Mask, MVT VT) {
5098   if (!VT.is128BitVector())
5099     return false;
5100
5101   if (!ISD::isNON_EXTLoad(V1) && !isScalarLoadToVector(V1))
5102     return false;
5103   // Is V2 is a vector load, don't do this transformation. We will try to use
5104   // load folding shufps op.
5105   if (ISD::isNON_EXTLoad(V2) || WillBeConstantPoolLoad(V2))
5106     return false;
5107
5108   unsigned NumElems = VT.getVectorNumElements();
5109
5110   if (NumElems != 2 && NumElems != 4)
5111     return false;
5112   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
5113     if (!isUndefOrEqual(Mask[i], i))
5114       return false;
5115   for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
5116     if (!isUndefOrEqual(Mask[i], i+NumElems))
5117       return false;
5118   return true;
5119 }
5120
5121 /// isZeroShuffle - Returns true if N is a VECTOR_SHUFFLE that can be resolved
5122 /// to an zero vector.
5123 /// FIXME: move to dag combiner / method on ShuffleVectorSDNode
5124 static bool isZeroShuffle(ShuffleVectorSDNode *N) {
5125   SDValue V1 = N->getOperand(0);
5126   SDValue V2 = N->getOperand(1);
5127   unsigned NumElems = N->getValueType(0).getVectorNumElements();
5128   for (unsigned i = 0; i != NumElems; ++i) {
5129     int Idx = N->getMaskElt(i);
5130     if (Idx >= (int)NumElems) {
5131       unsigned Opc = V2.getOpcode();
5132       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V2.getNode()))
5133         continue;
5134       if (Opc != ISD::BUILD_VECTOR ||
5135           !X86::isZeroNode(V2.getOperand(Idx-NumElems)))
5136         return false;
5137     } else if (Idx >= 0) {
5138       unsigned Opc = V1.getOpcode();
5139       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V1.getNode()))
5140         continue;
5141       if (Opc != ISD::BUILD_VECTOR ||
5142           !X86::isZeroNode(V1.getOperand(Idx)))
5143         return false;
5144     }
5145   }
5146   return true;
5147 }
5148
5149 /// getZeroVector - Returns a vector of specified type with all zero elements.
5150 ///
5151 static SDValue getZeroVector(EVT VT, const X86Subtarget *Subtarget,
5152                              SelectionDAG &DAG, SDLoc dl) {
5153   assert(VT.isVector() && "Expected a vector type");
5154
5155   // Always build SSE zero vectors as <4 x i32> bitcasted
5156   // to their dest type. This ensures they get CSE'd.
5157   SDValue Vec;
5158   if (VT.is128BitVector()) {  // SSE
5159     if (Subtarget->hasSSE2()) {  // SSE2
5160       SDValue Cst = DAG.getConstant(0, MVT::i32);
5161       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
5162     } else { // SSE1
5163       SDValue Cst = DAG.getConstantFP(+0.0, MVT::f32);
5164       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4f32, Cst, Cst, Cst, Cst);
5165     }
5166   } else if (VT.is256BitVector()) { // AVX
5167     if (Subtarget->hasInt256()) { // AVX2
5168       SDValue Cst = DAG.getConstant(0, MVT::i32);
5169       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5170       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops);
5171     } else {
5172       // 256-bit logic and arithmetic instructions in AVX are all
5173       // floating-point, no support for integer ops. Emit fp zeroed vectors.
5174       SDValue Cst = DAG.getConstantFP(+0.0, MVT::f32);
5175       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5176       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8f32, Ops);
5177     }
5178   } else if (VT.is512BitVector()) { // AVX-512
5179       SDValue Cst = DAG.getConstant(0, MVT::i32);
5180       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst,
5181                         Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5182       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v16i32, Ops);
5183   } else if (VT.getScalarType() == MVT::i1) {
5184     assert(VT.getVectorNumElements() <= 16 && "Unexpected vector type");
5185     SDValue Cst = DAG.getConstant(0, MVT::i1);
5186     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Cst);
5187     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
5188   } else
5189     llvm_unreachable("Unexpected vector type");
5190
5191   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
5192 }
5193
5194 /// getOnesVector - Returns a vector of specified type with all bits set.
5195 /// Always build ones vectors as <4 x i32> or <8 x i32>. For 256-bit types with
5196 /// no AVX2 supprt, use two <4 x i32> inserted in a <8 x i32> appropriately.
5197 /// Then bitcast to their original type, ensuring they get CSE'd.
5198 static SDValue getOnesVector(MVT VT, bool HasInt256, SelectionDAG &DAG,
5199                              SDLoc dl) {
5200   assert(VT.isVector() && "Expected a vector type");
5201
5202   SDValue Cst = DAG.getConstant(~0U, MVT::i32);
5203   SDValue Vec;
5204   if (VT.is256BitVector()) {
5205     if (HasInt256) { // AVX2
5206       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5207       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops);
5208     } else { // AVX
5209       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
5210       Vec = Concat128BitVectors(Vec, Vec, MVT::v8i32, 8, DAG, dl);
5211     }
5212   } else if (VT.is128BitVector()) {
5213     Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
5214   } else
5215     llvm_unreachable("Unexpected vector type");
5216
5217   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
5218 }
5219
5220 /// NormalizeMask - V2 is a splat, modify the mask (if needed) so all elements
5221 /// that point to V2 points to its first element.
5222 static void NormalizeMask(SmallVectorImpl<int> &Mask, unsigned NumElems) {
5223   for (unsigned i = 0; i != NumElems; ++i) {
5224     if (Mask[i] > (int)NumElems) {
5225       Mask[i] = NumElems;
5226     }
5227   }
5228 }
5229
5230 /// getMOVLMask - Returns a vector_shuffle mask for an movs{s|d}, movd
5231 /// operation of specified width.
5232 static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1,
5233                        SDValue V2) {
5234   unsigned NumElems = VT.getVectorNumElements();
5235   SmallVector<int, 8> Mask;
5236   Mask.push_back(NumElems);
5237   for (unsigned i = 1; i != NumElems; ++i)
5238     Mask.push_back(i);
5239   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
5240 }
5241
5242 /// getUnpackl - Returns a vector_shuffle node for an unpackl operation.
5243 static SDValue getUnpackl(SelectionDAG &DAG, SDLoc dl, MVT VT, SDValue V1,
5244                           SDValue V2) {
5245   unsigned NumElems = VT.getVectorNumElements();
5246   SmallVector<int, 8> Mask;
5247   for (unsigned i = 0, e = NumElems/2; i != e; ++i) {
5248     Mask.push_back(i);
5249     Mask.push_back(i + NumElems);
5250   }
5251   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
5252 }
5253
5254 /// getUnpackh - Returns a vector_shuffle node for an unpackh operation.
5255 static SDValue getUnpackh(SelectionDAG &DAG, SDLoc dl, MVT VT, SDValue V1,
5256                           SDValue V2) {
5257   unsigned NumElems = VT.getVectorNumElements();
5258   SmallVector<int, 8> Mask;
5259   for (unsigned i = 0, Half = NumElems/2; i != Half; ++i) {
5260     Mask.push_back(i + Half);
5261     Mask.push_back(i + NumElems + Half);
5262   }
5263   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
5264 }
5265
5266 // PromoteSplati8i16 - All i16 and i8 vector types can't be used directly by
5267 // a generic shuffle instruction because the target has no such instructions.
5268 // Generate shuffles which repeat i16 and i8 several times until they can be
5269 // represented by v4f32 and then be manipulated by target suported shuffles.
5270 static SDValue PromoteSplati8i16(SDValue V, SelectionDAG &DAG, int &EltNo) {
5271   MVT VT = V.getSimpleValueType();
5272   int NumElems = VT.getVectorNumElements();
5273   SDLoc dl(V);
5274
5275   while (NumElems > 4) {
5276     if (EltNo < NumElems/2) {
5277       V = getUnpackl(DAG, dl, VT, V, V);
5278     } else {
5279       V = getUnpackh(DAG, dl, VT, V, V);
5280       EltNo -= NumElems/2;
5281     }
5282     NumElems >>= 1;
5283   }
5284   return V;
5285 }
5286
5287 /// getLegalSplat - Generate a legal splat with supported x86 shuffles
5288 static SDValue getLegalSplat(SelectionDAG &DAG, SDValue V, int EltNo) {
5289   MVT VT = V.getSimpleValueType();
5290   SDLoc dl(V);
5291
5292   if (VT.is128BitVector()) {
5293     V = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V);
5294     int SplatMask[4] = { EltNo, EltNo, EltNo, EltNo };
5295     V = DAG.getVectorShuffle(MVT::v4f32, dl, V, DAG.getUNDEF(MVT::v4f32),
5296                              &SplatMask[0]);
5297   } else if (VT.is256BitVector()) {
5298     // To use VPERMILPS to splat scalars, the second half of indicies must
5299     // refer to the higher part, which is a duplication of the lower one,
5300     // because VPERMILPS can only handle in-lane permutations.
5301     int SplatMask[8] = { EltNo, EltNo, EltNo, EltNo,
5302                          EltNo+4, EltNo+4, EltNo+4, EltNo+4 };
5303
5304     V = DAG.getNode(ISD::BITCAST, dl, MVT::v8f32, V);
5305     V = DAG.getVectorShuffle(MVT::v8f32, dl, V, DAG.getUNDEF(MVT::v8f32),
5306                              &SplatMask[0]);
5307   } else
5308     llvm_unreachable("Vector size not supported");
5309
5310   return DAG.getNode(ISD::BITCAST, dl, VT, V);
5311 }
5312
5313 /// PromoteSplat - Splat is promoted to target supported vector shuffles.
5314 static SDValue PromoteSplat(ShuffleVectorSDNode *SV, SelectionDAG &DAG) {
5315   MVT SrcVT = SV->getSimpleValueType(0);
5316   SDValue V1 = SV->getOperand(0);
5317   SDLoc dl(SV);
5318
5319   int EltNo = SV->getSplatIndex();
5320   int NumElems = SrcVT.getVectorNumElements();
5321   bool Is256BitVec = SrcVT.is256BitVector();
5322
5323   assert(((SrcVT.is128BitVector() && NumElems > 4) || Is256BitVec) &&
5324          "Unknown how to promote splat for type");
5325
5326   // Extract the 128-bit part containing the splat element and update
5327   // the splat element index when it refers to the higher register.
5328   if (Is256BitVec) {
5329     V1 = Extract128BitVector(V1, EltNo, DAG, dl);
5330     if (EltNo >= NumElems/2)
5331       EltNo -= NumElems/2;
5332   }
5333
5334   // All i16 and i8 vector types can't be used directly by a generic shuffle
5335   // instruction because the target has no such instruction. Generate shuffles
5336   // which repeat i16 and i8 several times until they fit in i32, and then can
5337   // be manipulated by target suported shuffles.
5338   MVT EltVT = SrcVT.getVectorElementType();
5339   if (EltVT == MVT::i8 || EltVT == MVT::i16)
5340     V1 = PromoteSplati8i16(V1, DAG, EltNo);
5341
5342   // Recreate the 256-bit vector and place the same 128-bit vector
5343   // into the low and high part. This is necessary because we want
5344   // to use VPERM* to shuffle the vectors
5345   if (Is256BitVec) {
5346     V1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, SrcVT, V1, V1);
5347   }
5348
5349   return getLegalSplat(DAG, V1, EltNo);
5350 }
5351
5352 /// getShuffleVectorZeroOrUndef - Return a vector_shuffle of the specified
5353 /// vector of zero or undef vector.  This produces a shuffle where the low
5354 /// element of V2 is swizzled into the zero/undef vector, landing at element
5355 /// Idx.  This produces a shuffle mask like 4,1,2,3 (idx=0) or  0,1,2,4 (idx=3).
5356 static SDValue getShuffleVectorZeroOrUndef(SDValue V2, unsigned Idx,
5357                                            bool IsZero,
5358                                            const X86Subtarget *Subtarget,
5359                                            SelectionDAG &DAG) {
5360   MVT VT = V2.getSimpleValueType();
5361   SDValue V1 = IsZero
5362     ? getZeroVector(VT, Subtarget, DAG, SDLoc(V2)) : DAG.getUNDEF(VT);
5363   unsigned NumElems = VT.getVectorNumElements();
5364   SmallVector<int, 16> MaskVec;
5365   for (unsigned i = 0; i != NumElems; ++i)
5366     // If this is the insertion idx, put the low elt of V2 here.
5367     MaskVec.push_back(i == Idx ? NumElems : i);
5368   return DAG.getVectorShuffle(VT, SDLoc(V2), V1, V2, &MaskVec[0]);
5369 }
5370
5371 /// getTargetShuffleMask - Calculates the shuffle mask corresponding to the
5372 /// target specific opcode. Returns true if the Mask could be calculated. Sets
5373 /// IsUnary to true if only uses one source. Note that this will set IsUnary for
5374 /// shuffles which use a single input multiple times, and in those cases it will
5375 /// adjust the mask to only have indices within that single input.
5376 static bool getTargetShuffleMask(SDNode *N, MVT VT,
5377                                  SmallVectorImpl<int> &Mask, bool &IsUnary) {
5378   unsigned NumElems = VT.getVectorNumElements();
5379   SDValue ImmN;
5380
5381   IsUnary = false;
5382   bool IsFakeUnary = false;
5383   switch(N->getOpcode()) {
5384   case X86ISD::BLENDI:
5385     ImmN = N->getOperand(N->getNumOperands()-1);
5386     DecodeBLENDMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5387     break;
5388   case X86ISD::SHUFP:
5389     ImmN = N->getOperand(N->getNumOperands()-1);
5390     DecodeSHUFPMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5391     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5392     break;
5393   case X86ISD::UNPCKH:
5394     DecodeUNPCKHMask(VT, Mask);
5395     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5396     break;
5397   case X86ISD::UNPCKL:
5398     DecodeUNPCKLMask(VT, Mask);
5399     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5400     break;
5401   case X86ISD::MOVHLPS:
5402     DecodeMOVHLPSMask(NumElems, Mask);
5403     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5404     break;
5405   case X86ISD::MOVLHPS:
5406     DecodeMOVLHPSMask(NumElems, Mask);
5407     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5408     break;
5409   case X86ISD::PALIGNR:
5410     ImmN = N->getOperand(N->getNumOperands()-1);
5411     DecodePALIGNRMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5412     break;
5413   case X86ISD::PSHUFD:
5414   case X86ISD::VPERMILPI:
5415     ImmN = N->getOperand(N->getNumOperands()-1);
5416     DecodePSHUFMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5417     IsUnary = true;
5418     break;
5419   case X86ISD::PSHUFHW:
5420     ImmN = N->getOperand(N->getNumOperands()-1);
5421     DecodePSHUFHWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5422     IsUnary = true;
5423     break;
5424   case X86ISD::PSHUFLW:
5425     ImmN = N->getOperand(N->getNumOperands()-1);
5426     DecodePSHUFLWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5427     IsUnary = true;
5428     break;
5429   case X86ISD::PSHUFB: {
5430     IsUnary = true;
5431     SDValue MaskNode = N->getOperand(1);
5432     while (MaskNode->getOpcode() == ISD::BITCAST)
5433       MaskNode = MaskNode->getOperand(0);
5434
5435     if (MaskNode->getOpcode() == ISD::BUILD_VECTOR) {
5436       // If we have a build-vector, then things are easy.
5437       EVT VT = MaskNode.getValueType();
5438       assert(VT.isVector() &&
5439              "Can't produce a non-vector with a build_vector!");
5440       if (!VT.isInteger())
5441         return false;
5442
5443       int NumBytesPerElement = VT.getVectorElementType().getSizeInBits() / 8;
5444
5445       SmallVector<uint64_t, 32> RawMask;
5446       for (int i = 0, e = MaskNode->getNumOperands(); i < e; ++i) {
5447         SDValue Op = MaskNode->getOperand(i);
5448         if (Op->getOpcode() == ISD::UNDEF) {
5449           RawMask.push_back((uint64_t)SM_SentinelUndef);
5450           continue;
5451         }
5452         auto *CN = dyn_cast<ConstantSDNode>(Op.getNode());
5453         if (!CN)
5454           return false;
5455         APInt MaskElement = CN->getAPIntValue();
5456
5457         // We now have to decode the element which could be any integer size and
5458         // extract each byte of it.
5459         for (int j = 0; j < NumBytesPerElement; ++j) {
5460           // Note that this is x86 and so always little endian: the low byte is
5461           // the first byte of the mask.
5462           RawMask.push_back(MaskElement.getLoBits(8).getZExtValue());
5463           MaskElement = MaskElement.lshr(8);
5464         }
5465       }
5466       DecodePSHUFBMask(RawMask, Mask);
5467       break;
5468     }
5469
5470     auto *MaskLoad = dyn_cast<LoadSDNode>(MaskNode);
5471     if (!MaskLoad)
5472       return false;
5473
5474     SDValue Ptr = MaskLoad->getBasePtr();
5475     if (Ptr->getOpcode() == X86ISD::Wrapper)
5476       Ptr = Ptr->getOperand(0);
5477
5478     auto *MaskCP = dyn_cast<ConstantPoolSDNode>(Ptr);
5479     if (!MaskCP || MaskCP->isMachineConstantPoolEntry())
5480       return false;
5481
5482     if (auto *C = dyn_cast<Constant>(MaskCP->getConstVal())) {
5483       DecodePSHUFBMask(C, Mask);
5484       if (Mask.empty())
5485         return false;
5486       break;
5487     }
5488
5489     return false;
5490   }
5491   case X86ISD::VPERMI:
5492     ImmN = N->getOperand(N->getNumOperands()-1);
5493     DecodeVPERMMask(cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5494     IsUnary = true;
5495     break;
5496   case X86ISD::MOVSS:
5497   case X86ISD::MOVSD:
5498     DecodeScalarMoveMask(VT, /* IsLoad */ false, Mask);
5499     break;
5500   case X86ISD::VPERM2X128:
5501     ImmN = N->getOperand(N->getNumOperands()-1);
5502     DecodeVPERM2X128Mask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5503     if (Mask.empty()) return false;
5504     break;
5505   case X86ISD::MOVSLDUP:
5506     DecodeMOVSLDUPMask(VT, Mask);
5507     IsUnary = true;
5508     break;
5509   case X86ISD::MOVSHDUP:
5510     DecodeMOVSHDUPMask(VT, Mask);
5511     IsUnary = true;
5512     break;
5513   case X86ISD::MOVDDUP:
5514     DecodeMOVDDUPMask(VT, Mask);
5515     IsUnary = true;
5516     break;
5517   case X86ISD::MOVLHPD:
5518   case X86ISD::MOVLPD:
5519   case X86ISD::MOVLPS:
5520     // Not yet implemented
5521     return false;
5522   default: llvm_unreachable("unknown target shuffle node");
5523   }
5524
5525   // If we have a fake unary shuffle, the shuffle mask is spread across two
5526   // inputs that are actually the same node. Re-map the mask to always point
5527   // into the first input.
5528   if (IsFakeUnary)
5529     for (int &M : Mask)
5530       if (M >= (int)Mask.size())
5531         M -= Mask.size();
5532
5533   return true;
5534 }
5535
5536 /// getShuffleScalarElt - Returns the scalar element that will make up the ith
5537 /// element of the result of the vector shuffle.
5538 static SDValue getShuffleScalarElt(SDNode *N, unsigned Index, SelectionDAG &DAG,
5539                                    unsigned Depth) {
5540   if (Depth == 6)
5541     return SDValue();  // Limit search depth.
5542
5543   SDValue V = SDValue(N, 0);
5544   EVT VT = V.getValueType();
5545   unsigned Opcode = V.getOpcode();
5546
5547   // Recurse into ISD::VECTOR_SHUFFLE node to find scalars.
5548   if (const ShuffleVectorSDNode *SV = dyn_cast<ShuffleVectorSDNode>(N)) {
5549     int Elt = SV->getMaskElt(Index);
5550
5551     if (Elt < 0)
5552       return DAG.getUNDEF(VT.getVectorElementType());
5553
5554     unsigned NumElems = VT.getVectorNumElements();
5555     SDValue NewV = (Elt < (int)NumElems) ? SV->getOperand(0)
5556                                          : SV->getOperand(1);
5557     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
5558   }
5559
5560   // Recurse into target specific vector shuffles to find scalars.
5561   if (isTargetShuffle(Opcode)) {
5562     MVT ShufVT = V.getSimpleValueType();
5563     unsigned NumElems = ShufVT.getVectorNumElements();
5564     SmallVector<int, 16> ShuffleMask;
5565     bool IsUnary;
5566
5567     if (!getTargetShuffleMask(N, ShufVT, ShuffleMask, IsUnary))
5568       return SDValue();
5569
5570     int Elt = ShuffleMask[Index];
5571     if (Elt < 0)
5572       return DAG.getUNDEF(ShufVT.getVectorElementType());
5573
5574     SDValue NewV = (Elt < (int)NumElems) ? N->getOperand(0)
5575                                          : N->getOperand(1);
5576     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
5577                                Depth+1);
5578   }
5579
5580   // Actual nodes that may contain scalar elements
5581   if (Opcode == ISD::BITCAST) {
5582     V = V.getOperand(0);
5583     EVT SrcVT = V.getValueType();
5584     unsigned NumElems = VT.getVectorNumElements();
5585
5586     if (!SrcVT.isVector() || SrcVT.getVectorNumElements() != NumElems)
5587       return SDValue();
5588   }
5589
5590   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR)
5591     return (Index == 0) ? V.getOperand(0)
5592                         : DAG.getUNDEF(VT.getVectorElementType());
5593
5594   if (V.getOpcode() == ISD::BUILD_VECTOR)
5595     return V.getOperand(Index);
5596
5597   return SDValue();
5598 }
5599
5600 /// getNumOfConsecutiveZeros - Return the number of elements of a vector
5601 /// shuffle operation which come from a consecutively from a zero. The
5602 /// search can start in two different directions, from left or right.
5603 /// We count undefs as zeros until PreferredNum is reached.
5604 static unsigned getNumOfConsecutiveZeros(ShuffleVectorSDNode *SVOp,
5605                                          unsigned NumElems, bool ZerosFromLeft,
5606                                          SelectionDAG &DAG,
5607                                          unsigned PreferredNum = -1U) {
5608   unsigned NumZeros = 0;
5609   for (unsigned i = 0; i != NumElems; ++i) {
5610     unsigned Index = ZerosFromLeft ? i : NumElems - i - 1;
5611     SDValue Elt = getShuffleScalarElt(SVOp, Index, DAG, 0);
5612     if (!Elt.getNode())
5613       break;
5614
5615     if (X86::isZeroNode(Elt))
5616       ++NumZeros;
5617     else if (Elt.getOpcode() == ISD::UNDEF) // Undef as zero up to PreferredNum.
5618       NumZeros = std::min(NumZeros + 1, PreferredNum);
5619     else
5620       break;
5621   }
5622
5623   return NumZeros;
5624 }
5625
5626 /// isShuffleMaskConsecutive - Check if the shuffle mask indicies [MaskI, MaskE)
5627 /// correspond consecutively to elements from one of the vector operands,
5628 /// starting from its index OpIdx. Also tell OpNum which source vector operand.
5629 static
5630 bool isShuffleMaskConsecutive(ShuffleVectorSDNode *SVOp,
5631                               unsigned MaskI, unsigned MaskE, unsigned OpIdx,
5632                               unsigned NumElems, unsigned &OpNum) {
5633   bool SeenV1 = false;
5634   bool SeenV2 = false;
5635
5636   for (unsigned i = MaskI; i != MaskE; ++i, ++OpIdx) {
5637     int Idx = SVOp->getMaskElt(i);
5638     // Ignore undef indicies
5639     if (Idx < 0)
5640       continue;
5641
5642     if (Idx < (int)NumElems)
5643       SeenV1 = true;
5644     else
5645       SeenV2 = true;
5646
5647     // Only accept consecutive elements from the same vector
5648     if ((Idx % NumElems != OpIdx) || (SeenV1 && SeenV2))
5649       return false;
5650   }
5651
5652   OpNum = SeenV1 ? 0 : 1;
5653   return true;
5654 }
5655
5656 /// isVectorShiftRight - Returns true if the shuffle can be implemented as a
5657 /// logical left shift of a vector.
5658 static bool isVectorShiftRight(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5659                                bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5660   unsigned NumElems =
5661     SVOp->getSimpleValueType(0).getVectorNumElements();
5662   unsigned NumZeros = getNumOfConsecutiveZeros(
5663       SVOp, NumElems, false /* check zeros from right */, DAG,
5664       SVOp->getMaskElt(0));
5665   unsigned OpSrc;
5666
5667   if (!NumZeros)
5668     return false;
5669
5670   // Considering the elements in the mask that are not consecutive zeros,
5671   // check if they consecutively come from only one of the source vectors.
5672   //
5673   //               V1 = {X, A, B, C}     0
5674   //                         \  \  \    /
5675   //   vector_shuffle V1, V2 <1, 2, 3, X>
5676   //
5677   if (!isShuffleMaskConsecutive(SVOp,
5678             0,                   // Mask Start Index
5679             NumElems-NumZeros,   // Mask End Index(exclusive)
5680             NumZeros,            // Where to start looking in the src vector
5681             NumElems,            // Number of elements in vector
5682             OpSrc))              // Which source operand ?
5683     return false;
5684
5685   isLeft = false;
5686   ShAmt = NumZeros;
5687   ShVal = SVOp->getOperand(OpSrc);
5688   return true;
5689 }
5690
5691 /// isVectorShiftLeft - Returns true if the shuffle can be implemented as a
5692 /// logical left shift of a vector.
5693 static bool isVectorShiftLeft(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5694                               bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5695   unsigned NumElems =
5696     SVOp->getSimpleValueType(0).getVectorNumElements();
5697   unsigned NumZeros = getNumOfConsecutiveZeros(
5698       SVOp, NumElems, true /* check zeros from left */, DAG,
5699       NumElems - SVOp->getMaskElt(NumElems - 1) - 1);
5700   unsigned OpSrc;
5701
5702   if (!NumZeros)
5703     return false;
5704
5705   // Considering the elements in the mask that are not consecutive zeros,
5706   // check if they consecutively come from only one of the source vectors.
5707   //
5708   //                           0    { A, B, X, X } = V2
5709   //                          / \    /  /
5710   //   vector_shuffle V1, V2 <X, X, 4, 5>
5711   //
5712   if (!isShuffleMaskConsecutive(SVOp,
5713             NumZeros,     // Mask Start Index
5714             NumElems,     // Mask End Index(exclusive)
5715             0,            // Where to start looking in the src vector
5716             NumElems,     // Number of elements in vector
5717             OpSrc))       // Which source operand ?
5718     return false;
5719
5720   isLeft = true;
5721   ShAmt = NumZeros;
5722   ShVal = SVOp->getOperand(OpSrc);
5723   return true;
5724 }
5725
5726 /// isVectorShift - Returns true if the shuffle can be implemented as a
5727 /// logical left or right shift of a vector.
5728 static bool isVectorShift(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5729                           bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5730   // Although the logic below support any bitwidth size, there are no
5731   // shift instructions which handle more than 128-bit vectors.
5732   if (!SVOp->getSimpleValueType(0).is128BitVector())
5733     return false;
5734
5735   if (isVectorShiftLeft(SVOp, DAG, isLeft, ShVal, ShAmt) ||
5736       isVectorShiftRight(SVOp, DAG, isLeft, ShVal, ShAmt))
5737     return true;
5738
5739   return false;
5740 }
5741
5742 /// LowerBuildVectorv16i8 - Custom lower build_vector of v16i8.
5743 ///
5744 static SDValue LowerBuildVectorv16i8(SDValue Op, unsigned NonZeros,
5745                                        unsigned NumNonZero, unsigned NumZero,
5746                                        SelectionDAG &DAG,
5747                                        const X86Subtarget* Subtarget,
5748                                        const TargetLowering &TLI) {
5749   if (NumNonZero > 8)
5750     return SDValue();
5751
5752   SDLoc dl(Op);
5753   SDValue V;
5754   bool First = true;
5755   for (unsigned i = 0; i < 16; ++i) {
5756     bool ThisIsNonZero = (NonZeros & (1 << i)) != 0;
5757     if (ThisIsNonZero && First) {
5758       if (NumZero)
5759         V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
5760       else
5761         V = DAG.getUNDEF(MVT::v8i16);
5762       First = false;
5763     }
5764
5765     if ((i & 1) != 0) {
5766       SDValue ThisElt, LastElt;
5767       bool LastIsNonZero = (NonZeros & (1 << (i-1))) != 0;
5768       if (LastIsNonZero) {
5769         LastElt = DAG.getNode(ISD::ZERO_EXTEND, dl,
5770                               MVT::i16, Op.getOperand(i-1));
5771       }
5772       if (ThisIsNonZero) {
5773         ThisElt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Op.getOperand(i));
5774         ThisElt = DAG.getNode(ISD::SHL, dl, MVT::i16,
5775                               ThisElt, DAG.getConstant(8, MVT::i8));
5776         if (LastIsNonZero)
5777           ThisElt = DAG.getNode(ISD::OR, dl, MVT::i16, ThisElt, LastElt);
5778       } else
5779         ThisElt = LastElt;
5780
5781       if (ThisElt.getNode())
5782         V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, V, ThisElt,
5783                         DAG.getIntPtrConstant(i/2));
5784     }
5785   }
5786
5787   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V);
5788 }
5789
5790 /// LowerBuildVectorv8i16 - Custom lower build_vector of v8i16.
5791 ///
5792 static SDValue LowerBuildVectorv8i16(SDValue Op, unsigned NonZeros,
5793                                      unsigned NumNonZero, unsigned NumZero,
5794                                      SelectionDAG &DAG,
5795                                      const X86Subtarget* Subtarget,
5796                                      const TargetLowering &TLI) {
5797   if (NumNonZero > 4)
5798     return SDValue();
5799
5800   SDLoc dl(Op);
5801   SDValue V;
5802   bool First = true;
5803   for (unsigned i = 0; i < 8; ++i) {
5804     bool isNonZero = (NonZeros & (1 << i)) != 0;
5805     if (isNonZero) {
5806       if (First) {
5807         if (NumZero)
5808           V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
5809         else
5810           V = DAG.getUNDEF(MVT::v8i16);
5811         First = false;
5812       }
5813       V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
5814                       MVT::v8i16, V, Op.getOperand(i),
5815                       DAG.getIntPtrConstant(i));
5816     }
5817   }
5818
5819   return V;
5820 }
5821
5822 /// LowerBuildVectorv4x32 - Custom lower build_vector of v4i32 or v4f32.
5823 static SDValue LowerBuildVectorv4x32(SDValue Op, SelectionDAG &DAG,
5824                                      const X86Subtarget *Subtarget,
5825                                      const TargetLowering &TLI) {
5826   // Find all zeroable elements.
5827   std::bitset<4> Zeroable;
5828   for (int i=0; i < 4; ++i) {
5829     SDValue Elt = Op->getOperand(i);
5830     Zeroable[i] = (Elt.getOpcode() == ISD::UNDEF || X86::isZeroNode(Elt));
5831   }
5832   assert(Zeroable.size() - Zeroable.count() > 1 &&
5833          "We expect at least two non-zero elements!");
5834
5835   // We only know how to deal with build_vector nodes where elements are either
5836   // zeroable or extract_vector_elt with constant index.
5837   SDValue FirstNonZero;
5838   unsigned FirstNonZeroIdx;
5839   for (unsigned i=0; i < 4; ++i) {
5840     if (Zeroable[i])
5841       continue;
5842     SDValue Elt = Op->getOperand(i);
5843     if (Elt.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
5844         !isa<ConstantSDNode>(Elt.getOperand(1)))
5845       return SDValue();
5846     // Make sure that this node is extracting from a 128-bit vector.
5847     MVT VT = Elt.getOperand(0).getSimpleValueType();
5848     if (!VT.is128BitVector())
5849       return SDValue();
5850     if (!FirstNonZero.getNode()) {
5851       FirstNonZero = Elt;
5852       FirstNonZeroIdx = i;
5853     }
5854   }
5855
5856   assert(FirstNonZero.getNode() && "Unexpected build vector of all zeros!");
5857   SDValue V1 = FirstNonZero.getOperand(0);
5858   MVT VT = V1.getSimpleValueType();
5859
5860   // See if this build_vector can be lowered as a blend with zero.
5861   SDValue Elt;
5862   unsigned EltMaskIdx, EltIdx;
5863   int Mask[4];
5864   for (EltIdx = 0; EltIdx < 4; ++EltIdx) {
5865     if (Zeroable[EltIdx]) {
5866       // The zero vector will be on the right hand side.
5867       Mask[EltIdx] = EltIdx+4;
5868       continue;
5869     }
5870
5871     Elt = Op->getOperand(EltIdx);
5872     // By construction, Elt is a EXTRACT_VECTOR_ELT with constant index.
5873     EltMaskIdx = cast<ConstantSDNode>(Elt.getOperand(1))->getZExtValue();
5874     if (Elt.getOperand(0) != V1 || EltMaskIdx != EltIdx)
5875       break;
5876     Mask[EltIdx] = EltIdx;
5877   }
5878
5879   if (EltIdx == 4) {
5880     // Let the shuffle legalizer deal with blend operations.
5881     SDValue VZero = getZeroVector(VT, Subtarget, DAG, SDLoc(Op));
5882     if (V1.getSimpleValueType() != VT)
5883       V1 = DAG.getNode(ISD::BITCAST, SDLoc(V1), VT, V1);
5884     return DAG.getVectorShuffle(VT, SDLoc(V1), V1, VZero, &Mask[0]);
5885   }
5886
5887   // See if we can lower this build_vector to a INSERTPS.
5888   if (!Subtarget->hasSSE41())
5889     return SDValue();
5890
5891   SDValue V2 = Elt.getOperand(0);
5892   if (Elt == FirstNonZero && EltIdx == FirstNonZeroIdx)
5893     V1 = SDValue();
5894
5895   bool CanFold = true;
5896   for (unsigned i = EltIdx + 1; i < 4 && CanFold; ++i) {
5897     if (Zeroable[i])
5898       continue;
5899
5900     SDValue Current = Op->getOperand(i);
5901     SDValue SrcVector = Current->getOperand(0);
5902     if (!V1.getNode())
5903       V1 = SrcVector;
5904     CanFold = SrcVector == V1 &&
5905       cast<ConstantSDNode>(Current.getOperand(1))->getZExtValue() == i;
5906   }
5907
5908   if (!CanFold)
5909     return SDValue();
5910
5911   assert(V1.getNode() && "Expected at least two non-zero elements!");
5912   if (V1.getSimpleValueType() != MVT::v4f32)
5913     V1 = DAG.getNode(ISD::BITCAST, SDLoc(V1), MVT::v4f32, V1);
5914   if (V2.getSimpleValueType() != MVT::v4f32)
5915     V2 = DAG.getNode(ISD::BITCAST, SDLoc(V2), MVT::v4f32, V2);
5916
5917   // Ok, we can emit an INSERTPS instruction.
5918   unsigned ZMask = Zeroable.to_ulong();
5919
5920   unsigned InsertPSMask = EltMaskIdx << 6 | EltIdx << 4 | ZMask;
5921   assert((InsertPSMask & ~0xFFu) == 0 && "Invalid mask!");
5922   SDValue Result = DAG.getNode(X86ISD::INSERTPS, SDLoc(Op), MVT::v4f32, V1, V2,
5923                                DAG.getIntPtrConstant(InsertPSMask));
5924   return DAG.getNode(ISD::BITCAST, SDLoc(Op), VT, Result);
5925 }
5926
5927 /// Return a vector logical shift node.
5928 static SDValue getVShift(bool isLeft, EVT VT, SDValue SrcOp,
5929                          unsigned NumBits, SelectionDAG &DAG,
5930                          const TargetLowering &TLI, SDLoc dl) {
5931   assert(VT.is128BitVector() && "Unknown type for VShift");
5932   MVT ShVT = MVT::v2i64;
5933   unsigned Opc = isLeft ? X86ISD::VSHLDQ : X86ISD::VSRLDQ;
5934   SrcOp = DAG.getNode(ISD::BITCAST, dl, ShVT, SrcOp);
5935   MVT ScalarShiftTy = TLI.getScalarShiftAmountTy(SrcOp.getValueType());
5936   assert(NumBits % 8 == 0 && "Only support byte sized shifts");
5937   SDValue ShiftVal = DAG.getConstant(NumBits/8, ScalarShiftTy);
5938   return DAG.getNode(ISD::BITCAST, dl, VT,
5939                      DAG.getNode(Opc, dl, ShVT, SrcOp, ShiftVal));
5940 }
5941
5942 static SDValue
5943 LowerAsSplatVectorLoad(SDValue SrcOp, MVT VT, SDLoc dl, SelectionDAG &DAG) {
5944
5945   // Check if the scalar load can be widened into a vector load. And if
5946   // the address is "base + cst" see if the cst can be "absorbed" into
5947   // the shuffle mask.
5948   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(SrcOp)) {
5949     SDValue Ptr = LD->getBasePtr();
5950     if (!ISD::isNormalLoad(LD) || LD->isVolatile())
5951       return SDValue();
5952     EVT PVT = LD->getValueType(0);
5953     if (PVT != MVT::i32 && PVT != MVT::f32)
5954       return SDValue();
5955
5956     int FI = -1;
5957     int64_t Offset = 0;
5958     if (FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr)) {
5959       FI = FINode->getIndex();
5960       Offset = 0;
5961     } else if (DAG.isBaseWithConstantOffset(Ptr) &&
5962                isa<FrameIndexSDNode>(Ptr.getOperand(0))) {
5963       FI = cast<FrameIndexSDNode>(Ptr.getOperand(0))->getIndex();
5964       Offset = Ptr.getConstantOperandVal(1);
5965       Ptr = Ptr.getOperand(0);
5966     } else {
5967       return SDValue();
5968     }
5969
5970     // FIXME: 256-bit vector instructions don't require a strict alignment,
5971     // improve this code to support it better.
5972     unsigned RequiredAlign = VT.getSizeInBits()/8;
5973     SDValue Chain = LD->getChain();
5974     // Make sure the stack object alignment is at least 16 or 32.
5975     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
5976     if (DAG.InferPtrAlignment(Ptr) < RequiredAlign) {
5977       if (MFI->isFixedObjectIndex(FI)) {
5978         // Can't change the alignment. FIXME: It's possible to compute
5979         // the exact stack offset and reference FI + adjust offset instead.
5980         // If someone *really* cares about this. That's the way to implement it.
5981         return SDValue();
5982       } else {
5983         MFI->setObjectAlignment(FI, RequiredAlign);
5984       }
5985     }
5986
5987     // (Offset % 16 or 32) must be multiple of 4. Then address is then
5988     // Ptr + (Offset & ~15).
5989     if (Offset < 0)
5990       return SDValue();
5991     if ((Offset % RequiredAlign) & 3)
5992       return SDValue();
5993     int64_t StartOffset = Offset & ~(RequiredAlign-1);
5994     if (StartOffset)
5995       Ptr = DAG.getNode(ISD::ADD, SDLoc(Ptr), Ptr.getValueType(),
5996                         Ptr,DAG.getConstant(StartOffset, Ptr.getValueType()));
5997
5998     int EltNo = (Offset - StartOffset) >> 2;
5999     unsigned NumElems = VT.getVectorNumElements();
6000
6001     EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
6002     SDValue V1 = DAG.getLoad(NVT, dl, Chain, Ptr,
6003                              LD->getPointerInfo().getWithOffset(StartOffset),
6004                              false, false, false, 0);
6005
6006     SmallVector<int, 8> Mask(NumElems, EltNo);
6007
6008     return DAG.getVectorShuffle(NVT, dl, V1, DAG.getUNDEF(NVT), &Mask[0]);
6009   }
6010
6011   return SDValue();
6012 }
6013
6014 /// Given the initializing elements 'Elts' of a vector of type 'VT', see if the
6015 /// elements can be replaced by a single large load which has the same value as
6016 /// a build_vector or insert_subvector whose loaded operands are 'Elts'.
6017 ///
6018 /// Example: <load i32 *a, load i32 *a+4, undef, undef> -> zextload a
6019 ///
6020 /// FIXME: we'd also like to handle the case where the last elements are zero
6021 /// rather than undef via VZEXT_LOAD, but we do not detect that case today.
6022 /// There's even a handy isZeroNode for that purpose.
6023 static SDValue EltsFromConsecutiveLoads(EVT VT, ArrayRef<SDValue> Elts,
6024                                         SDLoc &DL, SelectionDAG &DAG,
6025                                         bool isAfterLegalize) {
6026   unsigned NumElems = Elts.size();
6027
6028   LoadSDNode *LDBase = nullptr;
6029   unsigned LastLoadedElt = -1U;
6030
6031   // For each element in the initializer, see if we've found a load or an undef.
6032   // If we don't find an initial load element, or later load elements are
6033   // non-consecutive, bail out.
6034   for (unsigned i = 0; i < NumElems; ++i) {
6035     SDValue Elt = Elts[i];
6036     // Look through a bitcast.
6037     if (Elt.getNode() && Elt.getOpcode() == ISD::BITCAST)
6038       Elt = Elt.getOperand(0);
6039     if (!Elt.getNode() ||
6040         (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
6041       return SDValue();
6042     if (!LDBase) {
6043       if (Elt.getNode()->getOpcode() == ISD::UNDEF)
6044         return SDValue();
6045       LDBase = cast<LoadSDNode>(Elt.getNode());
6046       LastLoadedElt = i;
6047       continue;
6048     }
6049     if (Elt.getOpcode() == ISD::UNDEF)
6050       continue;
6051
6052     LoadSDNode *LD = cast<LoadSDNode>(Elt);
6053     EVT LdVT = Elt.getValueType();
6054     // Each loaded element must be the correct fractional portion of the
6055     // requested vector load.
6056     if (LdVT.getSizeInBits() != VT.getSizeInBits() / NumElems)
6057       return SDValue();
6058     if (!DAG.isConsecutiveLoad(LD, LDBase, LdVT.getSizeInBits() / 8, i))
6059       return SDValue();
6060     LastLoadedElt = i;
6061   }
6062
6063   // If we have found an entire vector of loads and undefs, then return a large
6064   // load of the entire vector width starting at the base pointer.  If we found
6065   // consecutive loads for the low half, generate a vzext_load node.
6066   if (LastLoadedElt == NumElems - 1) {
6067     assert(LDBase && "Did not find base load for merging consecutive loads");
6068     EVT EltVT = LDBase->getValueType(0);
6069     // Ensure that the input vector size for the merged loads matches the
6070     // cumulative size of the input elements.
6071     if (VT.getSizeInBits() != EltVT.getSizeInBits() * NumElems)
6072       return SDValue();
6073
6074     if (isAfterLegalize &&
6075         !DAG.getTargetLoweringInfo().isOperationLegal(ISD::LOAD, VT))
6076       return SDValue();
6077
6078     SDValue NewLd = SDValue();
6079
6080     NewLd = DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
6081                         LDBase->getPointerInfo(), LDBase->isVolatile(),
6082                         LDBase->isNonTemporal(), LDBase->isInvariant(),
6083                         LDBase->getAlignment());
6084
6085     if (LDBase->hasAnyUseOfValue(1)) {
6086       SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
6087                                      SDValue(LDBase, 1),
6088                                      SDValue(NewLd.getNode(), 1));
6089       DAG.ReplaceAllUsesOfValueWith(SDValue(LDBase, 1), NewChain);
6090       DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
6091                              SDValue(NewLd.getNode(), 1));
6092     }
6093
6094     return NewLd;
6095   }
6096
6097   //TODO: The code below fires only for for loading the low v2i32 / v2f32
6098   //of a v4i32 / v4f32. It's probably worth generalizing.
6099   EVT EltVT = VT.getVectorElementType();
6100   if (NumElems == 4 && LastLoadedElt == 1 && (EltVT.getSizeInBits() == 32) &&
6101       DAG.getTargetLoweringInfo().isTypeLegal(MVT::v2i64)) {
6102     SDVTList Tys = DAG.getVTList(MVT::v2i64, MVT::Other);
6103     SDValue Ops[] = { LDBase->getChain(), LDBase->getBasePtr() };
6104     SDValue ResNode =
6105         DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, DL, Tys, Ops, MVT::i64,
6106                                 LDBase->getPointerInfo(),
6107                                 LDBase->getAlignment(),
6108                                 false/*isVolatile*/, true/*ReadMem*/,
6109                                 false/*WriteMem*/);
6110
6111     // Make sure the newly-created LOAD is in the same position as LDBase in
6112     // terms of dependency. We create a TokenFactor for LDBase and ResNode, and
6113     // update uses of LDBase's output chain to use the TokenFactor.
6114     if (LDBase->hasAnyUseOfValue(1)) {
6115       SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
6116                              SDValue(LDBase, 1), SDValue(ResNode.getNode(), 1));
6117       DAG.ReplaceAllUsesOfValueWith(SDValue(LDBase, 1), NewChain);
6118       DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
6119                              SDValue(ResNode.getNode(), 1));
6120     }
6121
6122     return DAG.getNode(ISD::BITCAST, DL, VT, ResNode);
6123   }
6124   return SDValue();
6125 }
6126
6127 /// LowerVectorBroadcast - Attempt to use the vbroadcast instruction
6128 /// to generate a splat value for the following cases:
6129 /// 1. A splat BUILD_VECTOR which uses a single scalar load, or a constant.
6130 /// 2. A splat shuffle which uses a scalar_to_vector node which comes from
6131 /// a scalar load, or a constant.
6132 /// The VBROADCAST node is returned when a pattern is found,
6133 /// or SDValue() otherwise.
6134 static SDValue LowerVectorBroadcast(SDValue Op, const X86Subtarget* Subtarget,
6135                                     SelectionDAG &DAG) {
6136   // VBROADCAST requires AVX.
6137   // TODO: Splats could be generated for non-AVX CPUs using SSE
6138   // instructions, but there's less potential gain for only 128-bit vectors.
6139   if (!Subtarget->hasAVX())
6140     return SDValue();
6141
6142   MVT VT = Op.getSimpleValueType();
6143   SDLoc dl(Op);
6144
6145   assert((VT.is128BitVector() || VT.is256BitVector() || VT.is512BitVector()) &&
6146          "Unsupported vector type for broadcast.");
6147
6148   SDValue Ld;
6149   bool ConstSplatVal;
6150
6151   switch (Op.getOpcode()) {
6152     default:
6153       // Unknown pattern found.
6154       return SDValue();
6155
6156     case ISD::BUILD_VECTOR: {
6157       auto *BVOp = cast<BuildVectorSDNode>(Op.getNode());
6158       BitVector UndefElements;
6159       SDValue Splat = BVOp->getSplatValue(&UndefElements);
6160
6161       // We need a splat of a single value to use broadcast, and it doesn't
6162       // make any sense if the value is only in one element of the vector.
6163       if (!Splat || (VT.getVectorNumElements() - UndefElements.count()) <= 1)
6164         return SDValue();
6165
6166       Ld = Splat;
6167       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
6168                        Ld.getOpcode() == ISD::ConstantFP);
6169
6170       // Make sure that all of the users of a non-constant load are from the
6171       // BUILD_VECTOR node.
6172       if (!ConstSplatVal && !BVOp->isOnlyUserOf(Ld.getNode()))
6173         return SDValue();
6174       break;
6175     }
6176
6177     case ISD::VECTOR_SHUFFLE: {
6178       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6179
6180       // Shuffles must have a splat mask where the first element is
6181       // broadcasted.
6182       if ((!SVOp->isSplat()) || SVOp->getMaskElt(0) != 0)
6183         return SDValue();
6184
6185       SDValue Sc = Op.getOperand(0);
6186       if (Sc.getOpcode() != ISD::SCALAR_TO_VECTOR &&
6187           Sc.getOpcode() != ISD::BUILD_VECTOR) {
6188
6189         if (!Subtarget->hasInt256())
6190           return SDValue();
6191
6192         // Use the register form of the broadcast instruction available on AVX2.
6193         if (VT.getSizeInBits() >= 256)
6194           Sc = Extract128BitVector(Sc, 0, DAG, dl);
6195         return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Sc);
6196       }
6197
6198       Ld = Sc.getOperand(0);
6199       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
6200                        Ld.getOpcode() == ISD::ConstantFP);
6201
6202       // The scalar_to_vector node and the suspected
6203       // load node must have exactly one user.
6204       // Constants may have multiple users.
6205
6206       // AVX-512 has register version of the broadcast
6207       bool hasRegVer = Subtarget->hasAVX512() && VT.is512BitVector() &&
6208         Ld.getValueType().getSizeInBits() >= 32;
6209       if (!ConstSplatVal && ((!Sc.hasOneUse() || !Ld.hasOneUse()) &&
6210           !hasRegVer))
6211         return SDValue();
6212       break;
6213     }
6214   }
6215
6216   unsigned ScalarSize = Ld.getValueType().getSizeInBits();
6217   bool IsGE256 = (VT.getSizeInBits() >= 256);
6218
6219   // When optimizing for size, generate up to 5 extra bytes for a broadcast
6220   // instruction to save 8 or more bytes of constant pool data.
6221   // TODO: If multiple splats are generated to load the same constant,
6222   // it may be detrimental to overall size. There needs to be a way to detect
6223   // that condition to know if this is truly a size win.
6224   const Function *F = DAG.getMachineFunction().getFunction();
6225   bool OptForSize = F->hasFnAttribute(Attribute::OptimizeForSize);
6226
6227   // Handle broadcasting a single constant scalar from the constant pool
6228   // into a vector.
6229   // On Sandybridge (no AVX2), it is still better to load a constant vector
6230   // from the constant pool and not to broadcast it from a scalar.
6231   // But override that restriction when optimizing for size.
6232   // TODO: Check if splatting is recommended for other AVX-capable CPUs.
6233   if (ConstSplatVal && (Subtarget->hasAVX2() || OptForSize)) {
6234     EVT CVT = Ld.getValueType();
6235     assert(!CVT.isVector() && "Must not broadcast a vector type");
6236
6237     // Splat f32, i32, v4f64, v4i64 in all cases with AVX2.
6238     // For size optimization, also splat v2f64 and v2i64, and for size opt
6239     // with AVX2, also splat i8 and i16.
6240     // With pattern matching, the VBROADCAST node may become a VMOVDDUP.
6241     if (ScalarSize == 32 || (IsGE256 && ScalarSize == 64) ||
6242         (OptForSize && (ScalarSize == 64 || Subtarget->hasAVX2()))) {
6243       const Constant *C = nullptr;
6244       if (ConstantSDNode *CI = dyn_cast<ConstantSDNode>(Ld))
6245         C = CI->getConstantIntValue();
6246       else if (ConstantFPSDNode *CF = dyn_cast<ConstantFPSDNode>(Ld))
6247         C = CF->getConstantFPValue();
6248
6249       assert(C && "Invalid constant type");
6250
6251       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
6252       SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
6253       unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
6254       Ld = DAG.getLoad(CVT, dl, DAG.getEntryNode(), CP,
6255                        MachinePointerInfo::getConstantPool(),
6256                        false, false, false, Alignment);
6257
6258       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
6259     }
6260   }
6261
6262   bool IsLoad = ISD::isNormalLoad(Ld.getNode());
6263
6264   // Handle AVX2 in-register broadcasts.
6265   if (!IsLoad && Subtarget->hasInt256() &&
6266       (ScalarSize == 32 || (IsGE256 && ScalarSize == 64)))
6267     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
6268
6269   // The scalar source must be a normal load.
6270   if (!IsLoad)
6271     return SDValue();
6272
6273   if (ScalarSize == 32 || (IsGE256 && ScalarSize == 64) ||
6274       (Subtarget->hasVLX() && ScalarSize == 64))
6275     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
6276
6277   // The integer check is needed for the 64-bit into 128-bit so it doesn't match
6278   // double since there is no vbroadcastsd xmm
6279   if (Subtarget->hasInt256() && Ld.getValueType().isInteger()) {
6280     if (ScalarSize == 8 || ScalarSize == 16 || ScalarSize == 64)
6281       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
6282   }
6283
6284   // Unsupported broadcast.
6285   return SDValue();
6286 }
6287
6288 /// \brief For an EXTRACT_VECTOR_ELT with a constant index return the real
6289 /// underlying vector and index.
6290 ///
6291 /// Modifies \p ExtractedFromVec to the real vector and returns the real
6292 /// index.
6293 static int getUnderlyingExtractedFromVec(SDValue &ExtractedFromVec,
6294                                          SDValue ExtIdx) {
6295   int Idx = cast<ConstantSDNode>(ExtIdx)->getZExtValue();
6296   if (!isa<ShuffleVectorSDNode>(ExtractedFromVec))
6297     return Idx;
6298
6299   // For 256-bit vectors, LowerEXTRACT_VECTOR_ELT_SSE4 may have already
6300   // lowered this:
6301   //   (extract_vector_elt (v8f32 %vreg1), Constant<6>)
6302   // to:
6303   //   (extract_vector_elt (vector_shuffle<2,u,u,u>
6304   //                           (extract_subvector (v8f32 %vreg0), Constant<4>),
6305   //                           undef)
6306   //                       Constant<0>)
6307   // In this case the vector is the extract_subvector expression and the index
6308   // is 2, as specified by the shuffle.
6309   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(ExtractedFromVec);
6310   SDValue ShuffleVec = SVOp->getOperand(0);
6311   MVT ShuffleVecVT = ShuffleVec.getSimpleValueType();
6312   assert(ShuffleVecVT.getVectorElementType() ==
6313          ExtractedFromVec.getSimpleValueType().getVectorElementType());
6314
6315   int ShuffleIdx = SVOp->getMaskElt(Idx);
6316   if (isUndefOrInRange(ShuffleIdx, 0, ShuffleVecVT.getVectorNumElements())) {
6317     ExtractedFromVec = ShuffleVec;
6318     return ShuffleIdx;
6319   }
6320   return Idx;
6321 }
6322
6323 static SDValue buildFromShuffleMostly(SDValue Op, SelectionDAG &DAG) {
6324   MVT VT = Op.getSimpleValueType();
6325
6326   // Skip if insert_vec_elt is not supported.
6327   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
6328   if (!TLI.isOperationLegalOrCustom(ISD::INSERT_VECTOR_ELT, VT))
6329     return SDValue();
6330
6331   SDLoc DL(Op);
6332   unsigned NumElems = Op.getNumOperands();
6333
6334   SDValue VecIn1;
6335   SDValue VecIn2;
6336   SmallVector<unsigned, 4> InsertIndices;
6337   SmallVector<int, 8> Mask(NumElems, -1);
6338
6339   for (unsigned i = 0; i != NumElems; ++i) {
6340     unsigned Opc = Op.getOperand(i).getOpcode();
6341
6342     if (Opc == ISD::UNDEF)
6343       continue;
6344
6345     if (Opc != ISD::EXTRACT_VECTOR_ELT) {
6346       // Quit if more than 1 elements need inserting.
6347       if (InsertIndices.size() > 1)
6348         return SDValue();
6349
6350       InsertIndices.push_back(i);
6351       continue;
6352     }
6353
6354     SDValue ExtractedFromVec = Op.getOperand(i).getOperand(0);
6355     SDValue ExtIdx = Op.getOperand(i).getOperand(1);
6356     // Quit if non-constant index.
6357     if (!isa<ConstantSDNode>(ExtIdx))
6358       return SDValue();
6359     int Idx = getUnderlyingExtractedFromVec(ExtractedFromVec, ExtIdx);
6360
6361     // Quit if extracted from vector of different type.
6362     if (ExtractedFromVec.getValueType() != VT)
6363       return SDValue();
6364
6365     if (!VecIn1.getNode())
6366       VecIn1 = ExtractedFromVec;
6367     else if (VecIn1 != ExtractedFromVec) {
6368       if (!VecIn2.getNode())
6369         VecIn2 = ExtractedFromVec;
6370       else if (VecIn2 != ExtractedFromVec)
6371         // Quit if more than 2 vectors to shuffle
6372         return SDValue();
6373     }
6374
6375     if (ExtractedFromVec == VecIn1)
6376       Mask[i] = Idx;
6377     else if (ExtractedFromVec == VecIn2)
6378       Mask[i] = Idx + NumElems;
6379   }
6380
6381   if (!VecIn1.getNode())
6382     return SDValue();
6383
6384   VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
6385   SDValue NV = DAG.getVectorShuffle(VT, DL, VecIn1, VecIn2, &Mask[0]);
6386   for (unsigned i = 0, e = InsertIndices.size(); i != e; ++i) {
6387     unsigned Idx = InsertIndices[i];
6388     NV = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, NV, Op.getOperand(Idx),
6389                      DAG.getIntPtrConstant(Idx));
6390   }
6391
6392   return NV;
6393 }
6394
6395 // Lower BUILD_VECTOR operation for v8i1 and v16i1 types.
6396 SDValue
6397 X86TargetLowering::LowerBUILD_VECTORvXi1(SDValue Op, SelectionDAG &DAG) const {
6398
6399   MVT VT = Op.getSimpleValueType();
6400   assert((VT.getVectorElementType() == MVT::i1) && (VT.getSizeInBits() <= 16) &&
6401          "Unexpected type in LowerBUILD_VECTORvXi1!");
6402
6403   SDLoc dl(Op);
6404   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
6405     SDValue Cst = DAG.getTargetConstant(0, MVT::i1);
6406     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Cst);
6407     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
6408   }
6409
6410   if (ISD::isBuildVectorAllOnes(Op.getNode())) {
6411     SDValue Cst = DAG.getTargetConstant(1, MVT::i1);
6412     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Cst);
6413     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
6414   }
6415
6416   bool AllContants = true;
6417   uint64_t Immediate = 0;
6418   int NonConstIdx = -1;
6419   bool IsSplat = true;
6420   unsigned NumNonConsts = 0;
6421   unsigned NumConsts = 0;
6422   for (unsigned idx = 0, e = Op.getNumOperands(); idx < e; ++idx) {
6423     SDValue In = Op.getOperand(idx);
6424     if (In.getOpcode() == ISD::UNDEF)
6425       continue;
6426     if (!isa<ConstantSDNode>(In)) {
6427       AllContants = false;
6428       NonConstIdx = idx;
6429       NumNonConsts++;
6430     } else {
6431       NumConsts++;
6432       if (cast<ConstantSDNode>(In)->getZExtValue())
6433       Immediate |= (1ULL << idx);
6434     }
6435     if (In != Op.getOperand(0))
6436       IsSplat = false;
6437   }
6438
6439   if (AllContants) {
6440     SDValue FullMask = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1,
6441       DAG.getConstant(Immediate, MVT::i16));
6442     return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, FullMask,
6443                        DAG.getIntPtrConstant(0));
6444   }
6445
6446   if (NumNonConsts == 1 && NonConstIdx != 0) {
6447     SDValue DstVec;
6448     if (NumConsts) {
6449       SDValue VecAsImm = DAG.getConstant(Immediate,
6450                                          MVT::getIntegerVT(VT.getSizeInBits()));
6451       DstVec = DAG.getNode(ISD::BITCAST, dl, VT, VecAsImm);
6452     }
6453     else
6454       DstVec = DAG.getUNDEF(VT);
6455     return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, DstVec,
6456                        Op.getOperand(NonConstIdx),
6457                        DAG.getIntPtrConstant(NonConstIdx));
6458   }
6459   if (!IsSplat && (NonConstIdx != 0))
6460     llvm_unreachable("Unsupported BUILD_VECTOR operation");
6461   MVT SelectVT = (VT == MVT::v16i1)? MVT::i16 : MVT::i8;
6462   SDValue Select;
6463   if (IsSplat)
6464     Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
6465                           DAG.getConstant(-1, SelectVT),
6466                           DAG.getConstant(0, SelectVT));
6467   else
6468     Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
6469                          DAG.getConstant((Immediate | 1), SelectVT),
6470                          DAG.getConstant(Immediate, SelectVT));
6471   return DAG.getNode(ISD::BITCAST, dl, VT, Select);
6472 }
6473
6474 /// \brief Return true if \p N implements a horizontal binop and return the
6475 /// operands for the horizontal binop into V0 and V1.
6476 ///
6477 /// This is a helper function of PerformBUILD_VECTORCombine.
6478 /// This function checks that the build_vector \p N in input implements a
6479 /// horizontal operation. Parameter \p Opcode defines the kind of horizontal
6480 /// operation to match.
6481 /// For example, if \p Opcode is equal to ISD::ADD, then this function
6482 /// checks if \p N implements a horizontal arithmetic add; if instead \p Opcode
6483 /// is equal to ISD::SUB, then this function checks if this is a horizontal
6484 /// arithmetic sub.
6485 ///
6486 /// This function only analyzes elements of \p N whose indices are
6487 /// in range [BaseIdx, LastIdx).
6488 static bool isHorizontalBinOp(const BuildVectorSDNode *N, unsigned Opcode,
6489                               SelectionDAG &DAG,
6490                               unsigned BaseIdx, unsigned LastIdx,
6491                               SDValue &V0, SDValue &V1) {
6492   EVT VT = N->getValueType(0);
6493
6494   assert(BaseIdx * 2 <= LastIdx && "Invalid Indices in input!");
6495   assert(VT.isVector() && VT.getVectorNumElements() >= LastIdx &&
6496          "Invalid Vector in input!");
6497
6498   bool IsCommutable = (Opcode == ISD::ADD || Opcode == ISD::FADD);
6499   bool CanFold = true;
6500   unsigned ExpectedVExtractIdx = BaseIdx;
6501   unsigned NumElts = LastIdx - BaseIdx;
6502   V0 = DAG.getUNDEF(VT);
6503   V1 = DAG.getUNDEF(VT);
6504
6505   // Check if N implements a horizontal binop.
6506   for (unsigned i = 0, e = NumElts; i != e && CanFold; ++i) {
6507     SDValue Op = N->getOperand(i + BaseIdx);
6508
6509     // Skip UNDEFs.
6510     if (Op->getOpcode() == ISD::UNDEF) {
6511       // Update the expected vector extract index.
6512       if (i * 2 == NumElts)
6513         ExpectedVExtractIdx = BaseIdx;
6514       ExpectedVExtractIdx += 2;
6515       continue;
6516     }
6517
6518     CanFold = Op->getOpcode() == Opcode && Op->hasOneUse();
6519
6520     if (!CanFold)
6521       break;
6522
6523     SDValue Op0 = Op.getOperand(0);
6524     SDValue Op1 = Op.getOperand(1);
6525
6526     // Try to match the following pattern:
6527     // (BINOP (extract_vector_elt A, I), (extract_vector_elt A, I+1))
6528     CanFold = (Op0.getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
6529         Op1.getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
6530         Op0.getOperand(0) == Op1.getOperand(0) &&
6531         isa<ConstantSDNode>(Op0.getOperand(1)) &&
6532         isa<ConstantSDNode>(Op1.getOperand(1)));
6533     if (!CanFold)
6534       break;
6535
6536     unsigned I0 = cast<ConstantSDNode>(Op0.getOperand(1))->getZExtValue();
6537     unsigned I1 = cast<ConstantSDNode>(Op1.getOperand(1))->getZExtValue();
6538
6539     if (i * 2 < NumElts) {
6540       if (V0.getOpcode() == ISD::UNDEF)
6541         V0 = Op0.getOperand(0);
6542     } else {
6543       if (V1.getOpcode() == ISD::UNDEF)
6544         V1 = Op0.getOperand(0);
6545       if (i * 2 == NumElts)
6546         ExpectedVExtractIdx = BaseIdx;
6547     }
6548
6549     SDValue Expected = (i * 2 < NumElts) ? V0 : V1;
6550     if (I0 == ExpectedVExtractIdx)
6551       CanFold = I1 == I0 + 1 && Op0.getOperand(0) == Expected;
6552     else if (IsCommutable && I1 == ExpectedVExtractIdx) {
6553       // Try to match the following dag sequence:
6554       // (BINOP (extract_vector_elt A, I+1), (extract_vector_elt A, I))
6555       CanFold = I0 == I1 + 1 && Op1.getOperand(0) == Expected;
6556     } else
6557       CanFold = false;
6558
6559     ExpectedVExtractIdx += 2;
6560   }
6561
6562   return CanFold;
6563 }
6564
6565 /// \brief Emit a sequence of two 128-bit horizontal add/sub followed by
6566 /// a concat_vector.
6567 ///
6568 /// This is a helper function of PerformBUILD_VECTORCombine.
6569 /// This function expects two 256-bit vectors called V0 and V1.
6570 /// At first, each vector is split into two separate 128-bit vectors.
6571 /// Then, the resulting 128-bit vectors are used to implement two
6572 /// horizontal binary operations.
6573 ///
6574 /// The kind of horizontal binary operation is defined by \p X86Opcode.
6575 ///
6576 /// \p Mode specifies how the 128-bit parts of V0 and V1 are passed in input to
6577 /// the two new horizontal binop.
6578 /// When Mode is set, the first horizontal binop dag node would take as input
6579 /// the lower 128-bit of V0 and the upper 128-bit of V0. The second
6580 /// horizontal binop dag node would take as input the lower 128-bit of V1
6581 /// and the upper 128-bit of V1.
6582 ///   Example:
6583 ///     HADD V0_LO, V0_HI
6584 ///     HADD V1_LO, V1_HI
6585 ///
6586 /// Otherwise, the first horizontal binop dag node takes as input the lower
6587 /// 128-bit of V0 and the lower 128-bit of V1, and the second horizontal binop
6588 /// dag node takes the the upper 128-bit of V0 and the upper 128-bit of V1.
6589 ///   Example:
6590 ///     HADD V0_LO, V1_LO
6591 ///     HADD V0_HI, V1_HI
6592 ///
6593 /// If \p isUndefLO is set, then the algorithm propagates UNDEF to the lower
6594 /// 128-bits of the result. If \p isUndefHI is set, then UNDEF is propagated to
6595 /// the upper 128-bits of the result.
6596 static SDValue ExpandHorizontalBinOp(const SDValue &V0, const SDValue &V1,
6597                                      SDLoc DL, SelectionDAG &DAG,
6598                                      unsigned X86Opcode, bool Mode,
6599                                      bool isUndefLO, bool isUndefHI) {
6600   EVT VT = V0.getValueType();
6601   assert(VT.is256BitVector() && VT == V1.getValueType() &&
6602          "Invalid nodes in input!");
6603
6604   unsigned NumElts = VT.getVectorNumElements();
6605   SDValue V0_LO = Extract128BitVector(V0, 0, DAG, DL);
6606   SDValue V0_HI = Extract128BitVector(V0, NumElts/2, DAG, DL);
6607   SDValue V1_LO = Extract128BitVector(V1, 0, DAG, DL);
6608   SDValue V1_HI = Extract128BitVector(V1, NumElts/2, DAG, DL);
6609   EVT NewVT = V0_LO.getValueType();
6610
6611   SDValue LO = DAG.getUNDEF(NewVT);
6612   SDValue HI = DAG.getUNDEF(NewVT);
6613
6614   if (Mode) {
6615     // Don't emit a horizontal binop if the result is expected to be UNDEF.
6616     if (!isUndefLO && V0->getOpcode() != ISD::UNDEF)
6617       LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V0_HI);
6618     if (!isUndefHI && V1->getOpcode() != ISD::UNDEF)
6619       HI = DAG.getNode(X86Opcode, DL, NewVT, V1_LO, V1_HI);
6620   } else {
6621     // Don't emit a horizontal binop if the result is expected to be UNDEF.
6622     if (!isUndefLO && (V0_LO->getOpcode() != ISD::UNDEF ||
6623                        V1_LO->getOpcode() != ISD::UNDEF))
6624       LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V1_LO);
6625
6626     if (!isUndefHI && (V0_HI->getOpcode() != ISD::UNDEF ||
6627                        V1_HI->getOpcode() != ISD::UNDEF))
6628       HI = DAG.getNode(X86Opcode, DL, NewVT, V0_HI, V1_HI);
6629   }
6630
6631   return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LO, HI);
6632 }
6633
6634 /// \brief Try to fold a build_vector that performs an 'addsub' into the
6635 /// sequence of 'vadd + vsub + blendi'.
6636 static SDValue matchAddSub(const BuildVectorSDNode *BV, SelectionDAG &DAG,
6637                            const X86Subtarget *Subtarget) {
6638   SDLoc DL(BV);
6639   EVT VT = BV->getValueType(0);
6640   unsigned NumElts = VT.getVectorNumElements();
6641   SDValue InVec0 = DAG.getUNDEF(VT);
6642   SDValue InVec1 = DAG.getUNDEF(VT);
6643
6644   assert((VT == MVT::v8f32 || VT == MVT::v4f64 || VT == MVT::v4f32 ||
6645           VT == MVT::v2f64) && "build_vector with an invalid type found!");
6646
6647   // Odd-numbered elements in the input build vector are obtained from
6648   // adding two integer/float elements.
6649   // Even-numbered elements in the input build vector are obtained from
6650   // subtracting two integer/float elements.
6651   unsigned ExpectedOpcode = ISD::FSUB;
6652   unsigned NextExpectedOpcode = ISD::FADD;
6653   bool AddFound = false;
6654   bool SubFound = false;
6655
6656   for (unsigned i = 0, e = NumElts; i != e; ++i) {
6657     SDValue Op = BV->getOperand(i);
6658
6659     // Skip 'undef' values.
6660     unsigned Opcode = Op.getOpcode();
6661     if (Opcode == ISD::UNDEF) {
6662       std::swap(ExpectedOpcode, NextExpectedOpcode);
6663       continue;
6664     }
6665
6666     // Early exit if we found an unexpected opcode.
6667     if (Opcode != ExpectedOpcode)
6668       return SDValue();
6669
6670     SDValue Op0 = Op.getOperand(0);
6671     SDValue Op1 = Op.getOperand(1);
6672
6673     // Try to match the following pattern:
6674     // (BINOP (extract_vector_elt A, i), (extract_vector_elt B, i))
6675     // Early exit if we cannot match that sequence.
6676     if (Op0.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
6677         Op1.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
6678         !isa<ConstantSDNode>(Op0.getOperand(1)) ||
6679         !isa<ConstantSDNode>(Op1.getOperand(1)) ||
6680         Op0.getOperand(1) != Op1.getOperand(1))
6681       return SDValue();
6682
6683     unsigned I0 = cast<ConstantSDNode>(Op0.getOperand(1))->getZExtValue();
6684     if (I0 != i)
6685       return SDValue();
6686
6687     // We found a valid add/sub node. Update the information accordingly.
6688     if (i & 1)
6689       AddFound = true;
6690     else
6691       SubFound = true;
6692
6693     // Update InVec0 and InVec1.
6694     if (InVec0.getOpcode() == ISD::UNDEF)
6695       InVec0 = Op0.getOperand(0);
6696     if (InVec1.getOpcode() == ISD::UNDEF)
6697       InVec1 = Op1.getOperand(0);
6698
6699     // Make sure that operands in input to each add/sub node always
6700     // come from a same pair of vectors.
6701     if (InVec0 != Op0.getOperand(0)) {
6702       if (ExpectedOpcode == ISD::FSUB)
6703         return SDValue();
6704
6705       // FADD is commutable. Try to commute the operands
6706       // and then test again.
6707       std::swap(Op0, Op1);
6708       if (InVec0 != Op0.getOperand(0))
6709         return SDValue();
6710     }
6711
6712     if (InVec1 != Op1.getOperand(0))
6713       return SDValue();
6714
6715     // Update the pair of expected opcodes.
6716     std::swap(ExpectedOpcode, NextExpectedOpcode);
6717   }
6718
6719   // Don't try to fold this build_vector into an ADDSUB if the inputs are undef.
6720   if (AddFound && SubFound && InVec0.getOpcode() != ISD::UNDEF &&
6721       InVec1.getOpcode() != ISD::UNDEF)
6722     return DAG.getNode(X86ISD::ADDSUB, DL, VT, InVec0, InVec1);
6723
6724   return SDValue();
6725 }
6726
6727 static SDValue PerformBUILD_VECTORCombine(SDNode *N, SelectionDAG &DAG,
6728                                           const X86Subtarget *Subtarget) {
6729   SDLoc DL(N);
6730   EVT VT = N->getValueType(0);
6731   unsigned NumElts = VT.getVectorNumElements();
6732   BuildVectorSDNode *BV = cast<BuildVectorSDNode>(N);
6733   SDValue InVec0, InVec1;
6734
6735   // Try to match an ADDSUB.
6736   if ((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
6737       (Subtarget->hasAVX() && (VT == MVT::v8f32 || VT == MVT::v4f64))) {
6738     SDValue Value = matchAddSub(BV, DAG, Subtarget);
6739     if (Value.getNode())
6740       return Value;
6741   }
6742
6743   // Try to match horizontal ADD/SUB.
6744   unsigned NumUndefsLO = 0;
6745   unsigned NumUndefsHI = 0;
6746   unsigned Half = NumElts/2;
6747
6748   // Count the number of UNDEF operands in the build_vector in input.
6749   for (unsigned i = 0, e = Half; i != e; ++i)
6750     if (BV->getOperand(i)->getOpcode() == ISD::UNDEF)
6751       NumUndefsLO++;
6752
6753   for (unsigned i = Half, e = NumElts; i != e; ++i)
6754     if (BV->getOperand(i)->getOpcode() == ISD::UNDEF)
6755       NumUndefsHI++;
6756
6757   // Early exit if this is either a build_vector of all UNDEFs or all the
6758   // operands but one are UNDEF.
6759   if (NumUndefsLO + NumUndefsHI + 1 >= NumElts)
6760     return SDValue();
6761
6762   if ((VT == MVT::v4f32 || VT == MVT::v2f64) && Subtarget->hasSSE3()) {
6763     // Try to match an SSE3 float HADD/HSUB.
6764     if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, NumElts, InVec0, InVec1))
6765       return DAG.getNode(X86ISD::FHADD, DL, VT, InVec0, InVec1);
6766
6767     if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, NumElts, InVec0, InVec1))
6768       return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
6769   } else if ((VT == MVT::v4i32 || VT == MVT::v8i16) && Subtarget->hasSSSE3()) {
6770     // Try to match an SSSE3 integer HADD/HSUB.
6771     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, NumElts, InVec0, InVec1))
6772       return DAG.getNode(X86ISD::HADD, DL, VT, InVec0, InVec1);
6773
6774     if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, NumElts, InVec0, InVec1))
6775       return DAG.getNode(X86ISD::HSUB, DL, VT, InVec0, InVec1);
6776   }
6777
6778   if (!Subtarget->hasAVX())
6779     return SDValue();
6780
6781   if ((VT == MVT::v8f32 || VT == MVT::v4f64)) {
6782     // Try to match an AVX horizontal add/sub of packed single/double
6783     // precision floating point values from 256-bit vectors.
6784     SDValue InVec2, InVec3;
6785     if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, Half, InVec0, InVec1) &&
6786         isHorizontalBinOp(BV, ISD::FADD, DAG, Half, NumElts, InVec2, InVec3) &&
6787         ((InVec0.getOpcode() == ISD::UNDEF ||
6788           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
6789         ((InVec1.getOpcode() == ISD::UNDEF ||
6790           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
6791       return DAG.getNode(X86ISD::FHADD, DL, VT, InVec0, InVec1);
6792
6793     if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, Half, InVec0, InVec1) &&
6794         isHorizontalBinOp(BV, ISD::FSUB, DAG, Half, NumElts, InVec2, InVec3) &&
6795         ((InVec0.getOpcode() == ISD::UNDEF ||
6796           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
6797         ((InVec1.getOpcode() == ISD::UNDEF ||
6798           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
6799       return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
6800   } else if (VT == MVT::v8i32 || VT == MVT::v16i16) {
6801     // Try to match an AVX2 horizontal add/sub of signed integers.
6802     SDValue InVec2, InVec3;
6803     unsigned X86Opcode;
6804     bool CanFold = true;
6805
6806     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, Half, InVec0, InVec1) &&
6807         isHorizontalBinOp(BV, ISD::ADD, DAG, Half, NumElts, InVec2, InVec3) &&
6808         ((InVec0.getOpcode() == ISD::UNDEF ||
6809           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
6810         ((InVec1.getOpcode() == ISD::UNDEF ||
6811           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
6812       X86Opcode = X86ISD::HADD;
6813     else if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, Half, InVec0, InVec1) &&
6814         isHorizontalBinOp(BV, ISD::SUB, DAG, Half, NumElts, InVec2, InVec3) &&
6815         ((InVec0.getOpcode() == ISD::UNDEF ||
6816           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
6817         ((InVec1.getOpcode() == ISD::UNDEF ||
6818           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
6819       X86Opcode = X86ISD::HSUB;
6820     else
6821       CanFold = false;
6822
6823     if (CanFold) {
6824       // Fold this build_vector into a single horizontal add/sub.
6825       // Do this only if the target has AVX2.
6826       if (Subtarget->hasAVX2())
6827         return DAG.getNode(X86Opcode, DL, VT, InVec0, InVec1);
6828
6829       // Do not try to expand this build_vector into a pair of horizontal
6830       // add/sub if we can emit a pair of scalar add/sub.
6831       if (NumUndefsLO + 1 == Half || NumUndefsHI + 1 == Half)
6832         return SDValue();
6833
6834       // Convert this build_vector into a pair of horizontal binop followed by
6835       // a concat vector.
6836       bool isUndefLO = NumUndefsLO == Half;
6837       bool isUndefHI = NumUndefsHI == Half;
6838       return ExpandHorizontalBinOp(InVec0, InVec1, DL, DAG, X86Opcode, false,
6839                                    isUndefLO, isUndefHI);
6840     }
6841   }
6842
6843   if ((VT == MVT::v8f32 || VT == MVT::v4f64 || VT == MVT::v8i32 ||
6844        VT == MVT::v16i16) && Subtarget->hasAVX()) {
6845     unsigned X86Opcode;
6846     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, NumElts, InVec0, InVec1))
6847       X86Opcode = X86ISD::HADD;
6848     else if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, NumElts, InVec0, InVec1))
6849       X86Opcode = X86ISD::HSUB;
6850     else if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, NumElts, InVec0, InVec1))
6851       X86Opcode = X86ISD::FHADD;
6852     else if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, NumElts, InVec0, InVec1))
6853       X86Opcode = X86ISD::FHSUB;
6854     else
6855       return SDValue();
6856
6857     // Don't try to expand this build_vector into a pair of horizontal add/sub
6858     // if we can simply emit a pair of scalar add/sub.
6859     if (NumUndefsLO + 1 == Half || NumUndefsHI + 1 == Half)
6860       return SDValue();
6861
6862     // Convert this build_vector into two horizontal add/sub followed by
6863     // a concat vector.
6864     bool isUndefLO = NumUndefsLO == Half;
6865     bool isUndefHI = NumUndefsHI == Half;
6866     return ExpandHorizontalBinOp(InVec0, InVec1, DL, DAG, X86Opcode, true,
6867                                  isUndefLO, isUndefHI);
6868   }
6869
6870   return SDValue();
6871 }
6872
6873 SDValue
6874 X86TargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const {
6875   SDLoc dl(Op);
6876
6877   MVT VT = Op.getSimpleValueType();
6878   MVT ExtVT = VT.getVectorElementType();
6879   unsigned NumElems = Op.getNumOperands();
6880
6881   // Generate vectors for predicate vectors.
6882   if (VT.getScalarType() == MVT::i1 && Subtarget->hasAVX512())
6883     return LowerBUILD_VECTORvXi1(Op, DAG);
6884
6885   // Vectors containing all zeros can be matched by pxor and xorps later
6886   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
6887     // Canonicalize this to <4 x i32> to 1) ensure the zero vectors are CSE'd
6888     // and 2) ensure that i64 scalars are eliminated on x86-32 hosts.
6889     if (VT == MVT::v4i32 || VT == MVT::v8i32 || VT == MVT::v16i32)
6890       return Op;
6891
6892     return getZeroVector(VT, Subtarget, DAG, dl);
6893   }
6894
6895   // Vectors containing all ones can be matched by pcmpeqd on 128-bit width
6896   // vectors or broken into v4i32 operations on 256-bit vectors. AVX2 can use
6897   // vpcmpeqd on 256-bit vectors.
6898   if (Subtarget->hasSSE2() && ISD::isBuildVectorAllOnes(Op.getNode())) {
6899     if (VT == MVT::v4i32 || (VT == MVT::v8i32 && Subtarget->hasInt256()))
6900       return Op;
6901
6902     if (!VT.is512BitVector())
6903       return getOnesVector(VT, Subtarget->hasInt256(), DAG, dl);
6904   }
6905
6906   SDValue Broadcast = LowerVectorBroadcast(Op, Subtarget, DAG);
6907   if (Broadcast.getNode())
6908     return Broadcast;
6909
6910   unsigned EVTBits = ExtVT.getSizeInBits();
6911
6912   unsigned NumZero  = 0;
6913   unsigned NumNonZero = 0;
6914   unsigned NonZeros = 0;
6915   bool IsAllConstants = true;
6916   SmallSet<SDValue, 8> Values;
6917   for (unsigned i = 0; i < NumElems; ++i) {
6918     SDValue Elt = Op.getOperand(i);
6919     if (Elt.getOpcode() == ISD::UNDEF)
6920       continue;
6921     Values.insert(Elt);
6922     if (Elt.getOpcode() != ISD::Constant &&
6923         Elt.getOpcode() != ISD::ConstantFP)
6924       IsAllConstants = false;
6925     if (X86::isZeroNode(Elt))
6926       NumZero++;
6927     else {
6928       NonZeros |= (1 << i);
6929       NumNonZero++;
6930     }
6931   }
6932
6933   // All undef vector. Return an UNDEF.  All zero vectors were handled above.
6934   if (NumNonZero == 0)
6935     return DAG.getUNDEF(VT);
6936
6937   // Special case for single non-zero, non-undef, element.
6938   if (NumNonZero == 1) {
6939     unsigned Idx = countTrailingZeros(NonZeros);
6940     SDValue Item = Op.getOperand(Idx);
6941
6942     // If this is an insertion of an i64 value on x86-32, and if the top bits of
6943     // the value are obviously zero, truncate the value to i32 and do the
6944     // insertion that way.  Only do this if the value is non-constant or if the
6945     // value is a constant being inserted into element 0.  It is cheaper to do
6946     // a constant pool load than it is to do a movd + shuffle.
6947     if (ExtVT == MVT::i64 && !Subtarget->is64Bit() &&
6948         (!IsAllConstants || Idx == 0)) {
6949       if (DAG.MaskedValueIsZero(Item, APInt::getBitsSet(64, 32, 64))) {
6950         // Handle SSE only.
6951         assert(VT == MVT::v2i64 && "Expected an SSE value type!");
6952         EVT VecVT = MVT::v4i32;
6953         unsigned VecElts = 4;
6954
6955         // Truncate the value (which may itself be a constant) to i32, and
6956         // convert it to a vector with movd (S2V+shuffle to zero extend).
6957         Item = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Item);
6958         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Item);
6959
6960         // If using the new shuffle lowering, just directly insert this.
6961         if (ExperimentalVectorShuffleLowering)
6962           return DAG.getNode(
6963               ISD::BITCAST, dl, VT,
6964               getShuffleVectorZeroOrUndef(Item, Idx * 2, true, Subtarget, DAG));
6965
6966         Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
6967
6968         // Now we have our 32-bit value zero extended in the low element of
6969         // a vector.  If Idx != 0, swizzle it into place.
6970         if (Idx != 0) {
6971           SmallVector<int, 4> Mask;
6972           Mask.push_back(Idx);
6973           for (unsigned i = 1; i != VecElts; ++i)
6974             Mask.push_back(i);
6975           Item = DAG.getVectorShuffle(VecVT, dl, Item, DAG.getUNDEF(VecVT),
6976                                       &Mask[0]);
6977         }
6978         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
6979       }
6980     }
6981
6982     // If we have a constant or non-constant insertion into the low element of
6983     // a vector, we can do this with SCALAR_TO_VECTOR + shuffle of zero into
6984     // the rest of the elements.  This will be matched as movd/movq/movss/movsd
6985     // depending on what the source datatype is.
6986     if (Idx == 0) {
6987       if (NumZero == 0)
6988         return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
6989
6990       if (ExtVT == MVT::i32 || ExtVT == MVT::f32 || ExtVT == MVT::f64 ||
6991           (ExtVT == MVT::i64 && Subtarget->is64Bit())) {
6992         if (VT.is256BitVector() || VT.is512BitVector()) {
6993           SDValue ZeroVec = getZeroVector(VT, Subtarget, DAG, dl);
6994           return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, ZeroVec,
6995                              Item, DAG.getIntPtrConstant(0));
6996         }
6997         assert(VT.is128BitVector() && "Expected an SSE value type!");
6998         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
6999         // Turn it into a MOVL (i.e. movss, movsd, or movd) to a zero vector.
7000         return getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
7001       }
7002
7003       if (ExtVT == MVT::i16 || ExtVT == MVT::i8) {
7004         Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
7005         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Item);
7006         if (VT.is256BitVector()) {
7007           SDValue ZeroVec = getZeroVector(MVT::v8i32, Subtarget, DAG, dl);
7008           Item = Insert128BitVector(ZeroVec, Item, 0, DAG, dl);
7009         } else {
7010           assert(VT.is128BitVector() && "Expected an SSE value type!");
7011           Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
7012         }
7013         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
7014       }
7015     }
7016
7017     // Is it a vector logical left shift?
7018     if (NumElems == 2 && Idx == 1 &&
7019         X86::isZeroNode(Op.getOperand(0)) &&
7020         !X86::isZeroNode(Op.getOperand(1))) {
7021       unsigned NumBits = VT.getSizeInBits();
7022       return getVShift(true, VT,
7023                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
7024                                    VT, Op.getOperand(1)),
7025                        NumBits/2, DAG, *this, dl);
7026     }
7027
7028     if (IsAllConstants) // Otherwise, it's better to do a constpool load.
7029       return SDValue();
7030
7031     // Otherwise, if this is a vector with i32 or f32 elements, and the element
7032     // is a non-constant being inserted into an element other than the low one,
7033     // we can't use a constant pool load.  Instead, use SCALAR_TO_VECTOR (aka
7034     // movd/movss) to move this into the low element, then shuffle it into
7035     // place.
7036     if (EVTBits == 32) {
7037       Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
7038
7039       // If using the new shuffle lowering, just directly insert this.
7040       if (ExperimentalVectorShuffleLowering)
7041         return getShuffleVectorZeroOrUndef(Item, Idx, NumZero > 0, Subtarget, DAG);
7042
7043       // Turn it into a shuffle of zero and zero-extended scalar to vector.
7044       Item = getShuffleVectorZeroOrUndef(Item, 0, NumZero > 0, Subtarget, DAG);
7045       SmallVector<int, 8> MaskVec;
7046       for (unsigned i = 0; i != NumElems; ++i)
7047         MaskVec.push_back(i == Idx ? 0 : 1);
7048       return DAG.getVectorShuffle(VT, dl, Item, DAG.getUNDEF(VT), &MaskVec[0]);
7049     }
7050   }
7051
7052   // Splat is obviously ok. Let legalizer expand it to a shuffle.
7053   if (Values.size() == 1) {
7054     if (EVTBits == 32) {
7055       // Instead of a shuffle like this:
7056       // shuffle (scalar_to_vector (load (ptr + 4))), undef, <0, 0, 0, 0>
7057       // Check if it's possible to issue this instead.
7058       // shuffle (vload ptr)), undef, <1, 1, 1, 1>
7059       unsigned Idx = countTrailingZeros(NonZeros);
7060       SDValue Item = Op.getOperand(Idx);
7061       if (Op.getNode()->isOnlyUserOf(Item.getNode()))
7062         return LowerAsSplatVectorLoad(Item, VT, dl, DAG);
7063     }
7064     return SDValue();
7065   }
7066
7067   // A vector full of immediates; various special cases are already
7068   // handled, so this is best done with a single constant-pool load.
7069   if (IsAllConstants)
7070     return SDValue();
7071
7072   // For AVX-length vectors, see if we can use a vector load to get all of the
7073   // elements, otherwise build the individual 128-bit pieces and use
7074   // shuffles to put them in place.
7075   if (VT.is256BitVector() || VT.is512BitVector()) {
7076     SmallVector<SDValue, 64> V(Op->op_begin(), Op->op_begin() + NumElems);
7077
7078     // Check for a build vector of consecutive loads.
7079     if (SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG, false))
7080       return LD;
7081
7082     EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElems/2);
7083
7084     // Build both the lower and upper subvector.
7085     SDValue Lower = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT,
7086                                 makeArrayRef(&V[0], NumElems/2));
7087     SDValue Upper = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT,
7088                                 makeArrayRef(&V[NumElems / 2], NumElems/2));
7089
7090     // Recreate the wider vector with the lower and upper part.
7091     if (VT.is256BitVector())
7092       return Concat128BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
7093     return Concat256BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
7094   }
7095
7096   // Let legalizer expand 2-wide build_vectors.
7097   if (EVTBits == 64) {
7098     if (NumNonZero == 1) {
7099       // One half is zero or undef.
7100       unsigned Idx = countTrailingZeros(NonZeros);
7101       SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
7102                                  Op.getOperand(Idx));
7103       return getShuffleVectorZeroOrUndef(V2, Idx, true, Subtarget, DAG);
7104     }
7105     return SDValue();
7106   }
7107
7108   // If element VT is < 32 bits, convert it to inserts into a zero vector.
7109   if (EVTBits == 8 && NumElems == 16) {
7110     SDValue V = LowerBuildVectorv16i8(Op, NonZeros,NumNonZero,NumZero, DAG,
7111                                         Subtarget, *this);
7112     if (V.getNode()) return V;
7113   }
7114
7115   if (EVTBits == 16 && NumElems == 8) {
7116     SDValue V = LowerBuildVectorv8i16(Op, NonZeros,NumNonZero,NumZero, DAG,
7117                                       Subtarget, *this);
7118     if (V.getNode()) return V;
7119   }
7120
7121   // If element VT is == 32 bits and has 4 elems, try to generate an INSERTPS
7122   if (EVTBits == 32 && NumElems == 4) {
7123     SDValue V = LowerBuildVectorv4x32(Op, DAG, Subtarget, *this);
7124     if (V.getNode())
7125       return V;
7126   }
7127
7128   // If element VT is == 32 bits, turn it into a number of shuffles.
7129   SmallVector<SDValue, 8> V(NumElems);
7130   if (NumElems == 4 && NumZero > 0) {
7131     for (unsigned i = 0; i < 4; ++i) {
7132       bool isZero = !(NonZeros & (1 << i));
7133       if (isZero)
7134         V[i] = getZeroVector(VT, Subtarget, DAG, dl);
7135       else
7136         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
7137     }
7138
7139     for (unsigned i = 0; i < 2; ++i) {
7140       switch ((NonZeros & (0x3 << i*2)) >> (i*2)) {
7141         default: break;
7142         case 0:
7143           V[i] = V[i*2];  // Must be a zero vector.
7144           break;
7145         case 1:
7146           V[i] = getMOVL(DAG, dl, VT, V[i*2+1], V[i*2]);
7147           break;
7148         case 2:
7149           V[i] = getMOVL(DAG, dl, VT, V[i*2], V[i*2+1]);
7150           break;
7151         case 3:
7152           V[i] = getUnpackl(DAG, dl, VT, V[i*2], V[i*2+1]);
7153           break;
7154       }
7155     }
7156
7157     bool Reverse1 = (NonZeros & 0x3) == 2;
7158     bool Reverse2 = ((NonZeros & (0x3 << 2)) >> 2) == 2;
7159     int MaskVec[] = {
7160       Reverse1 ? 1 : 0,
7161       Reverse1 ? 0 : 1,
7162       static_cast<int>(Reverse2 ? NumElems+1 : NumElems),
7163       static_cast<int>(Reverse2 ? NumElems   : NumElems+1)
7164     };
7165     return DAG.getVectorShuffle(VT, dl, V[0], V[1], &MaskVec[0]);
7166   }
7167
7168   if (Values.size() > 1 && VT.is128BitVector()) {
7169     // Check for a build vector of consecutive loads.
7170     for (unsigned i = 0; i < NumElems; ++i)
7171       V[i] = Op.getOperand(i);
7172
7173     // Check for elements which are consecutive loads.
7174     SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG, false);
7175     if (LD.getNode())
7176       return LD;
7177
7178     // Check for a build vector from mostly shuffle plus few inserting.
7179     SDValue Sh = buildFromShuffleMostly(Op, DAG);
7180     if (Sh.getNode())
7181       return Sh;
7182
7183     // For SSE 4.1, use insertps to put the high elements into the low element.
7184     if (Subtarget->hasSSE41()) {
7185       SDValue Result;
7186       if (Op.getOperand(0).getOpcode() != ISD::UNDEF)
7187         Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
7188       else
7189         Result = DAG.getUNDEF(VT);
7190
7191       for (unsigned i = 1; i < NumElems; ++i) {
7192         if (Op.getOperand(i).getOpcode() == ISD::UNDEF) continue;
7193         Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
7194                              Op.getOperand(i), DAG.getIntPtrConstant(i));
7195       }
7196       return Result;
7197     }
7198
7199     // Otherwise, expand into a number of unpckl*, start by extending each of
7200     // our (non-undef) elements to the full vector width with the element in the
7201     // bottom slot of the vector (which generates no code for SSE).
7202     for (unsigned i = 0; i < NumElems; ++i) {
7203       if (Op.getOperand(i).getOpcode() != ISD::UNDEF)
7204         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
7205       else
7206         V[i] = DAG.getUNDEF(VT);
7207     }
7208
7209     // Next, we iteratively mix elements, e.g. for v4f32:
7210     //   Step 1: unpcklps 0, 2 ==> X: <?, ?, 2, 0>
7211     //         : unpcklps 1, 3 ==> Y: <?, ?, 3, 1>
7212     //   Step 2: unpcklps X, Y ==>    <3, 2, 1, 0>
7213     unsigned EltStride = NumElems >> 1;
7214     while (EltStride != 0) {
7215       for (unsigned i = 0; i < EltStride; ++i) {
7216         // If V[i+EltStride] is undef and this is the first round of mixing,
7217         // then it is safe to just drop this shuffle: V[i] is already in the
7218         // right place, the one element (since it's the first round) being
7219         // inserted as undef can be dropped.  This isn't safe for successive
7220         // rounds because they will permute elements within both vectors.
7221         if (V[i+EltStride].getOpcode() == ISD::UNDEF &&
7222             EltStride == NumElems/2)
7223           continue;
7224
7225         V[i] = getUnpackl(DAG, dl, VT, V[i], V[i + EltStride]);
7226       }
7227       EltStride >>= 1;
7228     }
7229     return V[0];
7230   }
7231   return SDValue();
7232 }
7233
7234 // LowerAVXCONCAT_VECTORS - 256-bit AVX can use the vinsertf128 instruction
7235 // to create 256-bit vectors from two other 128-bit ones.
7236 static SDValue LowerAVXCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
7237   SDLoc dl(Op);
7238   MVT ResVT = Op.getSimpleValueType();
7239
7240   assert((ResVT.is256BitVector() ||
7241           ResVT.is512BitVector()) && "Value type must be 256-/512-bit wide");
7242
7243   SDValue V1 = Op.getOperand(0);
7244   SDValue V2 = Op.getOperand(1);
7245   unsigned NumElems = ResVT.getVectorNumElements();
7246   if(ResVT.is256BitVector())
7247     return Concat128BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
7248
7249   if (Op.getNumOperands() == 4) {
7250     MVT HalfVT = MVT::getVectorVT(ResVT.getScalarType(),
7251                                 ResVT.getVectorNumElements()/2);
7252     SDValue V3 = Op.getOperand(2);
7253     SDValue V4 = Op.getOperand(3);
7254     return Concat256BitVectors(Concat128BitVectors(V1, V2, HalfVT, NumElems/2, DAG, dl),
7255       Concat128BitVectors(V3, V4, HalfVT, NumElems/2, DAG, dl), ResVT, NumElems, DAG, dl);
7256   }
7257   return Concat256BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
7258 }
7259
7260 static SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
7261   MVT LLVM_ATTRIBUTE_UNUSED VT = Op.getSimpleValueType();
7262   assert((VT.is256BitVector() && Op.getNumOperands() == 2) ||
7263          (VT.is512BitVector() && (Op.getNumOperands() == 2 ||
7264           Op.getNumOperands() == 4)));
7265
7266   // AVX can use the vinsertf128 instruction to create 256-bit vectors
7267   // from two other 128-bit ones.
7268
7269   // 512-bit vector may contain 2 256-bit vectors or 4 128-bit vectors
7270   return LowerAVXCONCAT_VECTORS(Op, DAG);
7271 }
7272
7273
7274 //===----------------------------------------------------------------------===//
7275 // Vector shuffle lowering
7276 //
7277 // This is an experimental code path for lowering vector shuffles on x86. It is
7278 // designed to handle arbitrary vector shuffles and blends, gracefully
7279 // degrading performance as necessary. It works hard to recognize idiomatic
7280 // shuffles and lower them to optimal instruction patterns without leaving
7281 // a framework that allows reasonably efficient handling of all vector shuffle
7282 // patterns.
7283 //===----------------------------------------------------------------------===//
7284
7285 /// \brief Tiny helper function to identify a no-op mask.
7286 ///
7287 /// This is a somewhat boring predicate function. It checks whether the mask
7288 /// array input, which is assumed to be a single-input shuffle mask of the kind
7289 /// used by the X86 shuffle instructions (not a fully general
7290 /// ShuffleVectorSDNode mask) requires any shuffles to occur. Both undef and an
7291 /// in-place shuffle are 'no-op's.
7292 static bool isNoopShuffleMask(ArrayRef<int> Mask) {
7293   for (int i = 0, Size = Mask.size(); i < Size; ++i)
7294     if (Mask[i] != -1 && Mask[i] != i)
7295       return false;
7296   return true;
7297 }
7298
7299 /// \brief Helper function to classify a mask as a single-input mask.
7300 ///
7301 /// This isn't a generic single-input test because in the vector shuffle
7302 /// lowering we canonicalize single inputs to be the first input operand. This
7303 /// means we can more quickly test for a single input by only checking whether
7304 /// an input from the second operand exists. We also assume that the size of
7305 /// mask corresponds to the size of the input vectors which isn't true in the
7306 /// fully general case.
7307 static bool isSingleInputShuffleMask(ArrayRef<int> Mask) {
7308   for (int M : Mask)
7309     if (M >= (int)Mask.size())
7310       return false;
7311   return true;
7312 }
7313
7314 /// \brief Test whether there are elements crossing 128-bit lanes in this
7315 /// shuffle mask.
7316 ///
7317 /// X86 divides up its shuffles into in-lane and cross-lane shuffle operations
7318 /// and we routinely test for these.
7319 static bool is128BitLaneCrossingShuffleMask(MVT VT, ArrayRef<int> Mask) {
7320   int LaneSize = 128 / VT.getScalarSizeInBits();
7321   int Size = Mask.size();
7322   for (int i = 0; i < Size; ++i)
7323     if (Mask[i] >= 0 && (Mask[i] % Size) / LaneSize != i / LaneSize)
7324       return true;
7325   return false;
7326 }
7327
7328 /// \brief Test whether a shuffle mask is equivalent within each 128-bit lane.
7329 ///
7330 /// This checks a shuffle mask to see if it is performing the same
7331 /// 128-bit lane-relative shuffle in each 128-bit lane. This trivially implies
7332 /// that it is also not lane-crossing. It may however involve a blend from the
7333 /// same lane of a second vector.
7334 ///
7335 /// The specific repeated shuffle mask is populated in \p RepeatedMask, as it is
7336 /// non-trivial to compute in the face of undef lanes. The representation is
7337 /// *not* suitable for use with existing 128-bit shuffles as it will contain
7338 /// entries from both V1 and V2 inputs to the wider mask.
7339 static bool
7340 is128BitLaneRepeatedShuffleMask(MVT VT, ArrayRef<int> Mask,
7341                                 SmallVectorImpl<int> &RepeatedMask) {
7342   int LaneSize = 128 / VT.getScalarSizeInBits();
7343   RepeatedMask.resize(LaneSize, -1);
7344   int Size = Mask.size();
7345   for (int i = 0; i < Size; ++i) {
7346     if (Mask[i] < 0)
7347       continue;
7348     if ((Mask[i] % Size) / LaneSize != i / LaneSize)
7349       // This entry crosses lanes, so there is no way to model this shuffle.
7350       return false;
7351
7352     // Ok, handle the in-lane shuffles by detecting if and when they repeat.
7353     if (RepeatedMask[i % LaneSize] == -1)
7354       // This is the first non-undef entry in this slot of a 128-bit lane.
7355       RepeatedMask[i % LaneSize] =
7356           Mask[i] < Size ? Mask[i] % LaneSize : Mask[i] % LaneSize + Size;
7357     else if (RepeatedMask[i % LaneSize] + (i / LaneSize) * LaneSize != Mask[i])
7358       // Found a mismatch with the repeated mask.
7359       return false;
7360   }
7361   return true;
7362 }
7363
7364 /// \brief Base case helper for testing a single mask element.
7365 static bool isShuffleEquivalentImpl(SDValue V1, SDValue V2,
7366                                     BuildVectorSDNode *BV1,
7367                                     BuildVectorSDNode *BV2, ArrayRef<int> Mask,
7368                                     int i, int Arg) {
7369   int Size = Mask.size();
7370   if (Mask[i] != -1 && Mask[i] != Arg) {
7371     auto *MaskBV = Mask[i] < Size ? BV1 : BV2;
7372     auto *ArgsBV = Arg < Size ? BV1 : BV2;
7373     if (!MaskBV || !ArgsBV ||
7374         MaskBV->getOperand(Mask[i] % Size) != ArgsBV->getOperand(Arg % Size))
7375       return false;
7376   }
7377   return true;
7378 }
7379
7380 /// \brief Recursive helper to peel off and test each mask element.
7381 template <typename... Ts>
7382 static bool isShuffleEquivalentImpl(SDValue V1, SDValue V2,
7383                                     BuildVectorSDNode *BV1,
7384                                     BuildVectorSDNode *BV2, ArrayRef<int> Mask,
7385                                     int i, int Arg, Ts... Args) {
7386   if (!isShuffleEquivalentImpl(V1, V2, BV1, BV2, Mask, i, Arg))
7387     return false;
7388
7389   return isShuffleEquivalentImpl(V1, V2, BV1, BV2, Mask, i + 1, Args...);
7390 }
7391
7392 /// \brief Checks whether a shuffle mask is equivalent to an explicit list of
7393 /// arguments.
7394 ///
7395 /// This is a fast way to test a shuffle mask against a fixed pattern:
7396 ///
7397 ///   if (isShuffleEquivalent(Mask, 3, 2, 1, 0)) { ... }
7398 ///
7399 /// It returns true if the mask is exactly as wide as the argument list, and
7400 /// each element of the mask is either -1 (signifying undef) or the value given
7401 /// in the argument.
7402 template <typename... Ts>
7403 static bool isShuffleEquivalent(SDValue V1, SDValue V2, ArrayRef<int> Mask,
7404                                 Ts... Args) {
7405   if (Mask.size() != sizeof...(Args))
7406     return false;
7407
7408   // If the values are build vectors, we can look through them to find
7409   // equivalent inputs that make the shuffles equivalent.
7410   auto *BV1 = dyn_cast<BuildVectorSDNode>(V1);
7411   auto *BV2 = dyn_cast<BuildVectorSDNode>(V2);
7412
7413   // Recursively peel off arguments and test them against the mask.
7414   return isShuffleEquivalentImpl(V1, V2, BV1, BV2, Mask, 0, Args...);
7415 }
7416
7417 /// \brief Get a 4-lane 8-bit shuffle immediate for a mask.
7418 ///
7419 /// This helper function produces an 8-bit shuffle immediate corresponding to
7420 /// the ubiquitous shuffle encoding scheme used in x86 instructions for
7421 /// shuffling 4 lanes. It can be used with most of the PSHUF instructions for
7422 /// example.
7423 ///
7424 /// NB: We rely heavily on "undef" masks preserving the input lane.
7425 static SDValue getV4X86ShuffleImm8ForMask(ArrayRef<int> Mask,
7426                                           SelectionDAG &DAG) {
7427   assert(Mask.size() == 4 && "Only 4-lane shuffle masks");
7428   assert(Mask[0] >= -1 && Mask[0] < 4 && "Out of bound mask element!");
7429   assert(Mask[1] >= -1 && Mask[1] < 4 && "Out of bound mask element!");
7430   assert(Mask[2] >= -1 && Mask[2] < 4 && "Out of bound mask element!");
7431   assert(Mask[3] >= -1 && Mask[3] < 4 && "Out of bound mask element!");
7432
7433   unsigned Imm = 0;
7434   Imm |= (Mask[0] == -1 ? 0 : Mask[0]) << 0;
7435   Imm |= (Mask[1] == -1 ? 1 : Mask[1]) << 2;
7436   Imm |= (Mask[2] == -1 ? 2 : Mask[2]) << 4;
7437   Imm |= (Mask[3] == -1 ? 3 : Mask[3]) << 6;
7438   return DAG.getConstant(Imm, MVT::i8);
7439 }
7440
7441 /// \brief Try to emit a blend instruction for a shuffle using bit math.
7442 ///
7443 /// This is used as a fallback approach when first class blend instructions are
7444 /// unavailable. Currently it is only suitable for integer vectors, but could
7445 /// be generalized for floating point vectors if desirable.
7446 static SDValue lowerVectorShuffleAsBitBlend(SDLoc DL, MVT VT, SDValue V1,
7447                                             SDValue V2, ArrayRef<int> Mask,
7448                                             SelectionDAG &DAG) {
7449   assert(VT.isInteger() && "Only supports integer vector types!");
7450   MVT EltVT = VT.getScalarType();
7451   int NumEltBits = EltVT.getSizeInBits();
7452   SDValue Zero = DAG.getConstant(0, EltVT);
7453   SDValue AllOnes = DAG.getConstant(APInt::getAllOnesValue(NumEltBits), EltVT);
7454   SmallVector<SDValue, 16> MaskOps;
7455   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
7456     if (Mask[i] != -1 && Mask[i] != i && Mask[i] != i + Size)
7457       return SDValue(); // Shuffled input!
7458     MaskOps.push_back(Mask[i] < Size ? AllOnes : Zero);
7459   }
7460
7461   SDValue V1Mask = DAG.getNode(ISD::BUILD_VECTOR, DL, VT, MaskOps);
7462   V1 = DAG.getNode(ISD::AND, DL, VT, V1, V1Mask);
7463   // We have to cast V2 around.
7464   MVT MaskVT = MVT::getVectorVT(MVT::i64, VT.getSizeInBits() / 64);
7465   V2 = DAG.getNode(ISD::BITCAST, DL, VT,
7466                    DAG.getNode(X86ISD::ANDNP, DL, MaskVT,
7467                                DAG.getNode(ISD::BITCAST, DL, MaskVT, V1Mask),
7468                                DAG.getNode(ISD::BITCAST, DL, MaskVT, V2)));
7469   return DAG.getNode(ISD::OR, DL, VT, V1, V2);
7470 }
7471
7472 /// \brief Try to emit a blend instruction for a shuffle.
7473 ///
7474 /// This doesn't do any checks for the availability of instructions for blending
7475 /// these values. It relies on the availability of the X86ISD::BLENDI pattern to
7476 /// be matched in the backend with the type given. What it does check for is
7477 /// that the shuffle mask is in fact a blend.
7478 static SDValue lowerVectorShuffleAsBlend(SDLoc DL, MVT VT, SDValue V1,
7479                                          SDValue V2, ArrayRef<int> Mask,
7480                                          const X86Subtarget *Subtarget,
7481                                          SelectionDAG &DAG) {
7482   unsigned BlendMask = 0;
7483   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
7484     if (Mask[i] >= Size) {
7485       if (Mask[i] != i + Size)
7486         return SDValue(); // Shuffled V2 input!
7487       BlendMask |= 1u << i;
7488       continue;
7489     }
7490     if (Mask[i] >= 0 && Mask[i] != i)
7491       return SDValue(); // Shuffled V1 input!
7492   }
7493   switch (VT.SimpleTy) {
7494   case MVT::v2f64:
7495   case MVT::v4f32:
7496   case MVT::v4f64:
7497   case MVT::v8f32:
7498     return DAG.getNode(X86ISD::BLENDI, DL, VT, V1, V2,
7499                        DAG.getConstant(BlendMask, MVT::i8));
7500
7501   case MVT::v4i64:
7502   case MVT::v8i32:
7503     assert(Subtarget->hasAVX2() && "256-bit integer blends require AVX2!");
7504     // FALLTHROUGH
7505   case MVT::v2i64:
7506   case MVT::v4i32:
7507     // If we have AVX2 it is faster to use VPBLENDD when the shuffle fits into
7508     // that instruction.
7509     if (Subtarget->hasAVX2()) {
7510       // Scale the blend by the number of 32-bit dwords per element.
7511       int Scale =  VT.getScalarSizeInBits() / 32;
7512       BlendMask = 0;
7513       for (int i = 0, Size = Mask.size(); i < Size; ++i)
7514         if (Mask[i] >= Size)
7515           for (int j = 0; j < Scale; ++j)
7516             BlendMask |= 1u << (i * Scale + j);
7517
7518       MVT BlendVT = VT.getSizeInBits() > 128 ? MVT::v8i32 : MVT::v4i32;
7519       V1 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V1);
7520       V2 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V2);
7521       return DAG.getNode(ISD::BITCAST, DL, VT,
7522                          DAG.getNode(X86ISD::BLENDI, DL, BlendVT, V1, V2,
7523                                      DAG.getConstant(BlendMask, MVT::i8)));
7524     }
7525     // FALLTHROUGH
7526   case MVT::v8i16: {
7527     // For integer shuffles we need to expand the mask and cast the inputs to
7528     // v8i16s prior to blending.
7529     int Scale = 8 / VT.getVectorNumElements();
7530     BlendMask = 0;
7531     for (int i = 0, Size = Mask.size(); i < Size; ++i)
7532       if (Mask[i] >= Size)
7533         for (int j = 0; j < Scale; ++j)
7534           BlendMask |= 1u << (i * Scale + j);
7535
7536     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1);
7537     V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V2);
7538     return DAG.getNode(ISD::BITCAST, DL, VT,
7539                        DAG.getNode(X86ISD::BLENDI, DL, MVT::v8i16, V1, V2,
7540                                    DAG.getConstant(BlendMask, MVT::i8)));
7541   }
7542
7543   case MVT::v16i16: {
7544     assert(Subtarget->hasAVX2() && "256-bit integer blends require AVX2!");
7545     SmallVector<int, 8> RepeatedMask;
7546     if (is128BitLaneRepeatedShuffleMask(MVT::v16i16, Mask, RepeatedMask)) {
7547       // We can lower these with PBLENDW which is mirrored across 128-bit lanes.
7548       assert(RepeatedMask.size() == 8 && "Repeated mask size doesn't match!");
7549       BlendMask = 0;
7550       for (int i = 0; i < 8; ++i)
7551         if (RepeatedMask[i] >= 16)
7552           BlendMask |= 1u << i;
7553       return DAG.getNode(X86ISD::BLENDI, DL, MVT::v16i16, V1, V2,
7554                          DAG.getConstant(BlendMask, MVT::i8));
7555     }
7556   }
7557     // FALLTHROUGH
7558   case MVT::v16i8:
7559   case MVT::v32i8: {
7560     // Scale the blend by the number of bytes per element.
7561     int Scale = VT.getScalarSizeInBits() / 8;
7562
7563     // This form of blend is always done on bytes. Compute the byte vector
7564     // type.
7565     MVT BlendVT = MVT::getVectorVT(MVT::i8, VT.getSizeInBits() / 8);
7566
7567     // Compute the VSELECT mask. Note that VSELECT is really confusing in the
7568     // mix of LLVM's code generator and the x86 backend. We tell the code
7569     // generator that boolean values in the elements of an x86 vector register
7570     // are -1 for true and 0 for false. We then use the LLVM semantics of 'true'
7571     // mapping a select to operand #1, and 'false' mapping to operand #2. The
7572     // reality in x86 is that vector masks (pre-AVX-512) use only the high bit
7573     // of the element (the remaining are ignored) and 0 in that high bit would
7574     // mean operand #1 while 1 in the high bit would mean operand #2. So while
7575     // the LLVM model for boolean values in vector elements gets the relevant
7576     // bit set, it is set backwards and over constrained relative to x86's
7577     // actual model.
7578     SmallVector<SDValue, 32> VSELECTMask;
7579     for (int i = 0, Size = Mask.size(); i < Size; ++i)
7580       for (int j = 0; j < Scale; ++j)
7581         VSELECTMask.push_back(
7582             Mask[i] < 0 ? DAG.getUNDEF(MVT::i8)
7583                         : DAG.getConstant(Mask[i] < Size ? -1 : 0, MVT::i8));
7584
7585     V1 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V1);
7586     V2 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V2);
7587     return DAG.getNode(
7588         ISD::BITCAST, DL, VT,
7589         DAG.getNode(ISD::VSELECT, DL, BlendVT,
7590                     DAG.getNode(ISD::BUILD_VECTOR, DL, BlendVT, VSELECTMask),
7591                     V1, V2));
7592   }
7593
7594   default:
7595     llvm_unreachable("Not a supported integer vector type!");
7596   }
7597 }
7598
7599 /// \brief Try to lower as a blend of elements from two inputs followed by
7600 /// a single-input permutation.
7601 ///
7602 /// This matches the pattern where we can blend elements from two inputs and
7603 /// then reduce the shuffle to a single-input permutation.
7604 static SDValue lowerVectorShuffleAsBlendAndPermute(SDLoc DL, MVT VT, SDValue V1,
7605                                                    SDValue V2,
7606                                                    ArrayRef<int> Mask,
7607                                                    SelectionDAG &DAG) {
7608   // We build up the blend mask while checking whether a blend is a viable way
7609   // to reduce the shuffle.
7610   SmallVector<int, 32> BlendMask(Mask.size(), -1);
7611   SmallVector<int, 32> PermuteMask(Mask.size(), -1);
7612
7613   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
7614     if (Mask[i] < 0)
7615       continue;
7616
7617     assert(Mask[i] < Size * 2 && "Shuffle input is out of bounds.");
7618
7619     if (BlendMask[Mask[i] % Size] == -1)
7620       BlendMask[Mask[i] % Size] = Mask[i];
7621     else if (BlendMask[Mask[i] % Size] != Mask[i])
7622       return SDValue(); // Can't blend in the needed input!
7623
7624     PermuteMask[i] = Mask[i] % Size;
7625   }
7626
7627   SDValue V = DAG.getVectorShuffle(VT, DL, V1, V2, BlendMask);
7628   return DAG.getVectorShuffle(VT, DL, V, DAG.getUNDEF(VT), PermuteMask);
7629 }
7630
7631 /// \brief Generic routine to decompose a shuffle and blend into indepndent
7632 /// blends and permutes.
7633 ///
7634 /// This matches the extremely common pattern for handling combined
7635 /// shuffle+blend operations on newer X86 ISAs where we have very fast blend
7636 /// operations. It will try to pick the best arrangement of shuffles and
7637 /// blends.
7638 static SDValue lowerVectorShuffleAsDecomposedShuffleBlend(SDLoc DL, MVT VT,
7639                                                           SDValue V1,
7640                                                           SDValue V2,
7641                                                           ArrayRef<int> Mask,
7642                                                           SelectionDAG &DAG) {
7643   // Shuffle the input elements into the desired positions in V1 and V2 and
7644   // blend them together.
7645   SmallVector<int, 32> V1Mask(Mask.size(), -1);
7646   SmallVector<int, 32> V2Mask(Mask.size(), -1);
7647   SmallVector<int, 32> BlendMask(Mask.size(), -1);
7648   for (int i = 0, Size = Mask.size(); i < Size; ++i)
7649     if (Mask[i] >= 0 && Mask[i] < Size) {
7650       V1Mask[i] = Mask[i];
7651       BlendMask[i] = i;
7652     } else if (Mask[i] >= Size) {
7653       V2Mask[i] = Mask[i] - Size;
7654       BlendMask[i] = i + Size;
7655     }
7656
7657   // Try to lower with the simpler initial blend strategy unless one of the
7658   // input shuffles would be a no-op. We prefer to shuffle inputs as the
7659   // shuffle may be able to fold with a load or other benefit. However, when
7660   // we'll have to do 2x as many shuffles in order to achieve this, blending
7661   // first is a better strategy.
7662   if (!isNoopShuffleMask(V1Mask) && !isNoopShuffleMask(V2Mask))
7663     if (SDValue BlendPerm =
7664             lowerVectorShuffleAsBlendAndPermute(DL, VT, V1, V2, Mask, DAG))
7665       return BlendPerm;
7666
7667   V1 = DAG.getVectorShuffle(VT, DL, V1, DAG.getUNDEF(VT), V1Mask);
7668   V2 = DAG.getVectorShuffle(VT, DL, V2, DAG.getUNDEF(VT), V2Mask);
7669   return DAG.getVectorShuffle(VT, DL, V1, V2, BlendMask);
7670 }
7671
7672 /// \brief Try to lower a vector shuffle as a byte rotation.
7673 ///
7674 /// SSSE3 has a generic PALIGNR instruction in x86 that will do an arbitrary
7675 /// byte-rotation of the concatenation of two vectors; pre-SSSE3 can use
7676 /// a PSRLDQ/PSLLDQ/POR pattern to get a similar effect. This routine will
7677 /// try to generically lower a vector shuffle through such an pattern. It
7678 /// does not check for the profitability of lowering either as PALIGNR or
7679 /// PSRLDQ/PSLLDQ/POR, only whether the mask is valid to lower in that form.
7680 /// This matches shuffle vectors that look like:
7681 ///
7682 ///   v8i16 [11, 12, 13, 14, 15, 0, 1, 2]
7683 ///
7684 /// Essentially it concatenates V1 and V2, shifts right by some number of
7685 /// elements, and takes the low elements as the result. Note that while this is
7686 /// specified as a *right shift* because x86 is little-endian, it is a *left
7687 /// rotate* of the vector lanes.
7688 static SDValue lowerVectorShuffleAsByteRotate(SDLoc DL, MVT VT, SDValue V1,
7689                                               SDValue V2,
7690                                               ArrayRef<int> Mask,
7691                                               const X86Subtarget *Subtarget,
7692                                               SelectionDAG &DAG) {
7693   assert(!isNoopShuffleMask(Mask) && "We shouldn't lower no-op shuffles!");
7694
7695   int NumElts = Mask.size();
7696   int NumLanes = VT.getSizeInBits() / 128;
7697   int NumLaneElts = NumElts / NumLanes;
7698
7699   // We need to detect various ways of spelling a rotation:
7700   //   [11, 12, 13, 14, 15,  0,  1,  2]
7701   //   [-1, 12, 13, 14, -1, -1,  1, -1]
7702   //   [-1, -1, -1, -1, -1, -1,  1,  2]
7703   //   [ 3,  4,  5,  6,  7,  8,  9, 10]
7704   //   [-1,  4,  5,  6, -1, -1,  9, -1]
7705   //   [-1,  4,  5,  6, -1, -1, -1, -1]
7706   int Rotation = 0;
7707   SDValue Lo, Hi;
7708   for (int l = 0; l < NumElts; l += NumLaneElts) {
7709     for (int i = 0; i < NumLaneElts; ++i) {
7710       if (Mask[l + i] == -1)
7711         continue;
7712       assert(Mask[l + i] >= 0 && "Only -1 is a valid negative mask element!");
7713
7714       // Get the mod-Size index and lane correct it.
7715       int LaneIdx = (Mask[l + i] % NumElts) - l;
7716       // Make sure it was in this lane.
7717       if (LaneIdx < 0 || LaneIdx >= NumLaneElts)
7718         return SDValue();
7719
7720       // Determine where a rotated vector would have started.
7721       int StartIdx = i - LaneIdx;
7722       if (StartIdx == 0)
7723         // The identity rotation isn't interesting, stop.
7724         return SDValue();
7725
7726       // If we found the tail of a vector the rotation must be the missing
7727       // front. If we found the head of a vector, it must be how much of the
7728       // head.
7729       int CandidateRotation = StartIdx < 0 ? -StartIdx : NumLaneElts - StartIdx;
7730
7731       if (Rotation == 0)
7732         Rotation = CandidateRotation;
7733       else if (Rotation != CandidateRotation)
7734         // The rotations don't match, so we can't match this mask.
7735         return SDValue();
7736
7737       // Compute which value this mask is pointing at.
7738       SDValue MaskV = Mask[l + i] < NumElts ? V1 : V2;
7739
7740       // Compute which of the two target values this index should be assigned
7741       // to. This reflects whether the high elements are remaining or the low
7742       // elements are remaining.
7743       SDValue &TargetV = StartIdx < 0 ? Hi : Lo;
7744
7745       // Either set up this value if we've not encountered it before, or check
7746       // that it remains consistent.
7747       if (!TargetV)
7748         TargetV = MaskV;
7749       else if (TargetV != MaskV)
7750         // This may be a rotation, but it pulls from the inputs in some
7751         // unsupported interleaving.
7752         return SDValue();
7753     }
7754   }
7755
7756   // Check that we successfully analyzed the mask, and normalize the results.
7757   assert(Rotation != 0 && "Failed to locate a viable rotation!");
7758   assert((Lo || Hi) && "Failed to find a rotated input vector!");
7759   if (!Lo)
7760     Lo = Hi;
7761   else if (!Hi)
7762     Hi = Lo;
7763
7764   // The actual rotate instruction rotates bytes, so we need to scale the
7765   // rotation based on how many bytes are in the vector lane.
7766   int Scale = 16 / NumLaneElts;
7767
7768   // SSSE3 targets can use the palignr instruction.
7769   if (Subtarget->hasSSSE3()) {
7770     // Cast the inputs to i8 vector of correct length to match PALIGNR.
7771     MVT AlignVT = MVT::getVectorVT(MVT::i8, 16 * NumLanes);
7772     Lo = DAG.getNode(ISD::BITCAST, DL, AlignVT, Lo);
7773     Hi = DAG.getNode(ISD::BITCAST, DL, AlignVT, Hi);
7774
7775     return DAG.getNode(ISD::BITCAST, DL, VT,
7776                        DAG.getNode(X86ISD::PALIGNR, DL, AlignVT, Hi, Lo,
7777                                    DAG.getConstant(Rotation * Scale, MVT::i8)));
7778   }
7779
7780   assert(VT.getSizeInBits() == 128 &&
7781          "Rotate-based lowering only supports 128-bit lowering!");
7782   assert(Mask.size() <= 16 &&
7783          "Can shuffle at most 16 bytes in a 128-bit vector!");
7784
7785   // Default SSE2 implementation
7786   int LoByteShift = 16 - Rotation * Scale;
7787   int HiByteShift = Rotation * Scale;
7788
7789   // Cast the inputs to v2i64 to match PSLLDQ/PSRLDQ.
7790   Lo = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Lo);
7791   Hi = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Hi);
7792
7793   SDValue LoShift = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v2i64, Lo,
7794                                 DAG.getConstant(LoByteShift, MVT::i8));
7795   SDValue HiShift = DAG.getNode(X86ISD::VSRLDQ, DL, MVT::v2i64, Hi,
7796                                 DAG.getConstant(HiByteShift, MVT::i8));
7797   return DAG.getNode(ISD::BITCAST, DL, VT,
7798                      DAG.getNode(ISD::OR, DL, MVT::v2i64, LoShift, HiShift));
7799 }
7800
7801 /// \brief Compute whether each element of a shuffle is zeroable.
7802 ///
7803 /// A "zeroable" vector shuffle element is one which can be lowered to zero.
7804 /// Either it is an undef element in the shuffle mask, the element of the input
7805 /// referenced is undef, or the element of the input referenced is known to be
7806 /// zero. Many x86 shuffles can zero lanes cheaply and we often want to handle
7807 /// as many lanes with this technique as possible to simplify the remaining
7808 /// shuffle.
7809 static SmallBitVector computeZeroableShuffleElements(ArrayRef<int> Mask,
7810                                                      SDValue V1, SDValue V2) {
7811   SmallBitVector Zeroable(Mask.size(), false);
7812
7813   while (V1.getOpcode() == ISD::BITCAST)
7814     V1 = V1->getOperand(0);
7815   while (V2.getOpcode() == ISD::BITCAST)
7816     V2 = V2->getOperand(0);
7817
7818   bool V1IsZero = ISD::isBuildVectorAllZeros(V1.getNode());
7819   bool V2IsZero = ISD::isBuildVectorAllZeros(V2.getNode());
7820
7821   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
7822     int M = Mask[i];
7823     // Handle the easy cases.
7824     if (M < 0 || (M >= 0 && M < Size && V1IsZero) || (M >= Size && V2IsZero)) {
7825       Zeroable[i] = true;
7826       continue;
7827     }
7828
7829     // If this is an index into a build_vector node (which has the same number
7830     // of elements), dig out the input value and use it.
7831     SDValue V = M < Size ? V1 : V2;
7832     if (V.getOpcode() != ISD::BUILD_VECTOR || Size != (int)V.getNumOperands())
7833       continue;
7834
7835     SDValue Input = V.getOperand(M % Size);
7836     // The UNDEF opcode check really should be dead code here, but not quite
7837     // worth asserting on (it isn't invalid, just unexpected).
7838     if (Input.getOpcode() == ISD::UNDEF || X86::isZeroNode(Input))
7839       Zeroable[i] = true;
7840   }
7841
7842   return Zeroable;
7843 }
7844
7845 /// \brief Try to emit a bitmask instruction for a shuffle.
7846 ///
7847 /// This handles cases where we can model a blend exactly as a bitmask due to
7848 /// one of the inputs being zeroable.
7849 static SDValue lowerVectorShuffleAsBitMask(SDLoc DL, MVT VT, SDValue V1,
7850                                            SDValue V2, ArrayRef<int> Mask,
7851                                            SelectionDAG &DAG) {
7852   MVT EltVT = VT.getScalarType();
7853   int NumEltBits = EltVT.getSizeInBits();
7854   MVT IntEltVT = MVT::getIntegerVT(NumEltBits);
7855   SDValue Zero = DAG.getConstant(0, IntEltVT);
7856   SDValue AllOnes = DAG.getConstant(APInt::getAllOnesValue(NumEltBits), IntEltVT);
7857   if (EltVT.isFloatingPoint()) {
7858     Zero = DAG.getNode(ISD::BITCAST, DL, EltVT, Zero);
7859     AllOnes = DAG.getNode(ISD::BITCAST, DL, EltVT, AllOnes);
7860   }
7861   SmallVector<SDValue, 16> VMaskOps(Mask.size(), Zero);
7862   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
7863   SDValue V;
7864   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
7865     if (Zeroable[i])
7866       continue;
7867     if (Mask[i] % Size != i)
7868       return SDValue(); // Not a blend.
7869     if (!V)
7870       V = Mask[i] < Size ? V1 : V2;
7871     else if (V != (Mask[i] < Size ? V1 : V2))
7872       return SDValue(); // Can only let one input through the mask.
7873
7874     VMaskOps[i] = AllOnes;
7875   }
7876   if (!V)
7877     return SDValue(); // No non-zeroable elements!
7878
7879   SDValue VMask = DAG.getNode(ISD::BUILD_VECTOR, DL, VT, VMaskOps);
7880   V = DAG.getNode(VT.isFloatingPoint()
7881                   ? (unsigned) X86ISD::FAND : (unsigned) ISD::AND,
7882                   DL, VT, V, VMask);
7883   return V;
7884 }
7885
7886 /// \brief Try to lower a vector shuffle as a bit shift (shifts in zeros).
7887 ///
7888 /// Attempts to match a shuffle mask against the PSLL(W/D/Q/DQ) and
7889 /// PSRL(W/D/Q/DQ) SSE2 and AVX2 logical bit-shift instructions. The function
7890 /// matches elements from one of the input vectors shuffled to the left or
7891 /// right with zeroable elements 'shifted in'. It handles both the strictly
7892 /// bit-wise element shifts and the byte shift across an entire 128-bit double
7893 /// quad word lane.
7894 ///
7895 /// PSHL : (little-endian) left bit shift.
7896 /// [ zz, 0, zz,  2 ]
7897 /// [ -1, 4, zz, -1 ]
7898 /// PSRL : (little-endian) right bit shift.
7899 /// [  1, zz,  3, zz]
7900 /// [ -1, -1,  7, zz]
7901 /// PSLLDQ : (little-endian) left byte shift
7902 /// [ zz,  0,  1,  2,  3,  4,  5,  6]
7903 /// [ zz, zz, -1, -1,  2,  3,  4, -1]
7904 /// [ zz, zz, zz, zz, zz, zz, -1,  1]
7905 /// PSRLDQ : (little-endian) right byte shift
7906 /// [  5, 6,  7, zz, zz, zz, zz, zz]
7907 /// [ -1, 5,  6,  7, zz, zz, zz, zz]
7908 /// [  1, 2, -1, -1, -1, -1, zz, zz]
7909 static SDValue lowerVectorShuffleAsShift(SDLoc DL, MVT VT, SDValue V1,
7910                                          SDValue V2, ArrayRef<int> Mask,
7911                                          SelectionDAG &DAG) {
7912   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
7913
7914   int Size = Mask.size();
7915   assert(Size == (int)VT.getVectorNumElements() && "Unexpected mask size");
7916
7917   auto CheckZeros = [&](int Shift, int Scale, bool Left) {
7918     for (int i = 0; i < Size; i += Scale)
7919       for (int j = 0; j < Shift; ++j)
7920         if (!Zeroable[i + j + (Left ? 0 : (Scale - Shift))])
7921           return false;
7922
7923     return true;
7924   };
7925
7926   auto MatchShift = [&](int Shift, int Scale, bool Left, SDValue V) {
7927     for (int i = 0; i != Size; i += Scale) {
7928       unsigned Pos = Left ? i + Shift : i;
7929       unsigned Low = Left ? i : i + Shift;
7930       unsigned Len = Scale - Shift;
7931       if (!isSequentialOrUndefInRange(Mask, Pos, Len,
7932                                       Low + (V == V1 ? 0 : Size)))
7933         return SDValue();
7934     }
7935
7936     int ShiftEltBits = VT.getScalarSizeInBits() * Scale;
7937     bool ByteShift = ShiftEltBits > 64;
7938     unsigned OpCode = Left ? (ByteShift ? X86ISD::VSHLDQ : X86ISD::VSHLI)
7939                            : (ByteShift ? X86ISD::VSRLDQ : X86ISD::VSRLI);
7940     int ShiftAmt = Shift * VT.getScalarSizeInBits() / (ByteShift ? 8 : 1);
7941
7942     // Normalize the scale for byte shifts to still produce an i64 element
7943     // type.
7944     Scale = ByteShift ? Scale / 2 : Scale;
7945
7946     // We need to round trip through the appropriate type for the shift.
7947     MVT ShiftSVT = MVT::getIntegerVT(VT.getScalarSizeInBits() * Scale);
7948     MVT ShiftVT = MVT::getVectorVT(ShiftSVT, Size / Scale);
7949     assert(DAG.getTargetLoweringInfo().isTypeLegal(ShiftVT) &&
7950            "Illegal integer vector type");
7951     V = DAG.getNode(ISD::BITCAST, DL, ShiftVT, V);
7952
7953     V = DAG.getNode(OpCode, DL, ShiftVT, V, DAG.getConstant(ShiftAmt, MVT::i8));
7954     return DAG.getNode(ISD::BITCAST, DL, VT, V);
7955   };
7956
7957   // SSE/AVX supports logical shifts up to 64-bit integers - so we can just
7958   // keep doubling the size of the integer elements up to that. We can
7959   // then shift the elements of the integer vector by whole multiples of
7960   // their width within the elements of the larger integer vector. Test each
7961   // multiple to see if we can find a match with the moved element indices
7962   // and that the shifted in elements are all zeroable.
7963   for (int Scale = 2; Scale * VT.getScalarSizeInBits() <= 128; Scale *= 2)
7964     for (int Shift = 1; Shift != Scale; ++Shift)
7965       for (bool Left : {true, false})
7966         if (CheckZeros(Shift, Scale, Left))
7967           for (SDValue V : {V1, V2})
7968             if (SDValue Match = MatchShift(Shift, Scale, Left, V))
7969               return Match;
7970
7971   // no match
7972   return SDValue();
7973 }
7974
7975 /// \brief Lower a vector shuffle as a zero or any extension.
7976 ///
7977 /// Given a specific number of elements, element bit width, and extension
7978 /// stride, produce either a zero or any extension based on the available
7979 /// features of the subtarget.
7980 static SDValue lowerVectorShuffleAsSpecificZeroOrAnyExtend(
7981     SDLoc DL, MVT VT, int Scale, bool AnyExt, SDValue InputV,
7982     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
7983   assert(Scale > 1 && "Need a scale to extend.");
7984   int NumElements = VT.getVectorNumElements();
7985   int EltBits = VT.getScalarSizeInBits();
7986   assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
7987          "Only 8, 16, and 32 bit elements can be extended.");
7988   assert(Scale * EltBits <= 64 && "Cannot zero extend past 64 bits.");
7989
7990   // Found a valid zext mask! Try various lowering strategies based on the
7991   // input type and available ISA extensions.
7992   if (Subtarget->hasSSE41()) {
7993     MVT ExtVT = MVT::getVectorVT(MVT::getIntegerVT(EltBits * Scale),
7994                                  NumElements / Scale);
7995     return DAG.getNode(ISD::BITCAST, DL, VT,
7996                        DAG.getNode(X86ISD::VZEXT, DL, ExtVT, InputV));
7997   }
7998
7999   // For any extends we can cheat for larger element sizes and use shuffle
8000   // instructions that can fold with a load and/or copy.
8001   if (AnyExt && EltBits == 32) {
8002     int PSHUFDMask[4] = {0, -1, 1, -1};
8003     return DAG.getNode(
8004         ISD::BITCAST, DL, VT,
8005         DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
8006                     DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, InputV),
8007                     getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
8008   }
8009   if (AnyExt && EltBits == 16 && Scale > 2) {
8010     int PSHUFDMask[4] = {0, -1, 0, -1};
8011     InputV = DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
8012                          DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, InputV),
8013                          getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG));
8014     int PSHUFHWMask[4] = {1, -1, -1, -1};
8015     return DAG.getNode(
8016         ISD::BITCAST, DL, VT,
8017         DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16,
8018                     DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, InputV),
8019                     getV4X86ShuffleImm8ForMask(PSHUFHWMask, DAG)));
8020   }
8021
8022   // If this would require more than 2 unpack instructions to expand, use
8023   // pshufb when available. We can only use more than 2 unpack instructions
8024   // when zero extending i8 elements which also makes it easier to use pshufb.
8025   if (Scale > 4 && EltBits == 8 && Subtarget->hasSSSE3()) {
8026     assert(NumElements == 16 && "Unexpected byte vector width!");
8027     SDValue PSHUFBMask[16];
8028     for (int i = 0; i < 16; ++i)
8029       PSHUFBMask[i] =
8030           DAG.getConstant((i % Scale == 0) ? i / Scale : 0x80, MVT::i8);
8031     InputV = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, InputV);
8032     return DAG.getNode(ISD::BITCAST, DL, VT,
8033                        DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, InputV,
8034                                    DAG.getNode(ISD::BUILD_VECTOR, DL,
8035                                                MVT::v16i8, PSHUFBMask)));
8036   }
8037
8038   // Otherwise emit a sequence of unpacks.
8039   do {
8040     MVT InputVT = MVT::getVectorVT(MVT::getIntegerVT(EltBits), NumElements);
8041     SDValue Ext = AnyExt ? DAG.getUNDEF(InputVT)
8042                          : getZeroVector(InputVT, Subtarget, DAG, DL);
8043     InputV = DAG.getNode(ISD::BITCAST, DL, InputVT, InputV);
8044     InputV = DAG.getNode(X86ISD::UNPCKL, DL, InputVT, InputV, Ext);
8045     Scale /= 2;
8046     EltBits *= 2;
8047     NumElements /= 2;
8048   } while (Scale > 1);
8049   return DAG.getNode(ISD::BITCAST, DL, VT, InputV);
8050 }
8051
8052 /// \brief Try to lower a vector shuffle as a zero extension on any microarch.
8053 ///
8054 /// This routine will try to do everything in its power to cleverly lower
8055 /// a shuffle which happens to match the pattern of a zero extend. It doesn't
8056 /// check for the profitability of this lowering,  it tries to aggressively
8057 /// match this pattern. It will use all of the micro-architectural details it
8058 /// can to emit an efficient lowering. It handles both blends with all-zero
8059 /// inputs to explicitly zero-extend and undef-lanes (sometimes undef due to
8060 /// masking out later).
8061 ///
8062 /// The reason we have dedicated lowering for zext-style shuffles is that they
8063 /// are both incredibly common and often quite performance sensitive.
8064 static SDValue lowerVectorShuffleAsZeroOrAnyExtend(
8065     SDLoc DL, MVT VT, SDValue V1, SDValue V2, ArrayRef<int> Mask,
8066     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
8067   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
8068
8069   int Bits = VT.getSizeInBits();
8070   int NumElements = VT.getVectorNumElements();
8071   assert(VT.getScalarSizeInBits() <= 32 &&
8072          "Exceeds 32-bit integer zero extension limit");
8073   assert((int)Mask.size() == NumElements && "Unexpected shuffle mask size");
8074
8075   // Define a helper function to check a particular ext-scale and lower to it if
8076   // valid.
8077   auto Lower = [&](int Scale) -> SDValue {
8078     SDValue InputV;
8079     bool AnyExt = true;
8080     for (int i = 0; i < NumElements; ++i) {
8081       if (Mask[i] == -1)
8082         continue; // Valid anywhere but doesn't tell us anything.
8083       if (i % Scale != 0) {
8084         // Each of the extended elements need to be zeroable.
8085         if (!Zeroable[i])
8086           return SDValue();
8087
8088         // We no longer are in the anyext case.
8089         AnyExt = false;
8090         continue;
8091       }
8092
8093       // Each of the base elements needs to be consecutive indices into the
8094       // same input vector.
8095       SDValue V = Mask[i] < NumElements ? V1 : V2;
8096       if (!InputV)
8097         InputV = V;
8098       else if (InputV != V)
8099         return SDValue(); // Flip-flopping inputs.
8100
8101       if (Mask[i] % NumElements != i / Scale)
8102         return SDValue(); // Non-consecutive strided elements.
8103     }
8104
8105     // If we fail to find an input, we have a zero-shuffle which should always
8106     // have already been handled.
8107     // FIXME: Maybe handle this here in case during blending we end up with one?
8108     if (!InputV)
8109       return SDValue();
8110
8111     return lowerVectorShuffleAsSpecificZeroOrAnyExtend(
8112         DL, VT, Scale, AnyExt, InputV, Subtarget, DAG);
8113   };
8114
8115   // The widest scale possible for extending is to a 64-bit integer.
8116   assert(Bits % 64 == 0 &&
8117          "The number of bits in a vector must be divisible by 64 on x86!");
8118   int NumExtElements = Bits / 64;
8119
8120   // Each iteration, try extending the elements half as much, but into twice as
8121   // many elements.
8122   for (; NumExtElements < NumElements; NumExtElements *= 2) {
8123     assert(NumElements % NumExtElements == 0 &&
8124            "The input vector size must be divisible by the extended size.");
8125     if (SDValue V = Lower(NumElements / NumExtElements))
8126       return V;
8127   }
8128
8129   // General extends failed, but 128-bit vectors may be able to use MOVQ.
8130   if (Bits != 128)
8131     return SDValue();
8132
8133   // Returns one of the source operands if the shuffle can be reduced to a
8134   // MOVQ, copying the lower 64-bits and zero-extending to the upper 64-bits.
8135   auto CanZExtLowHalf = [&]() {
8136     for (int i = NumElements / 2; i != NumElements; ++i)
8137       if (!Zeroable[i])
8138         return SDValue();
8139     if (isSequentialOrUndefInRange(Mask, 0, NumElements / 2, 0))
8140       return V1;
8141     if (isSequentialOrUndefInRange(Mask, 0, NumElements / 2, NumElements))
8142       return V2;
8143     return SDValue();
8144   };
8145
8146   if (SDValue V = CanZExtLowHalf()) {
8147     V = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, V);
8148     V = DAG.getNode(X86ISD::VZEXT_MOVL, DL, MVT::v2i64, V);
8149     return DAG.getNode(ISD::BITCAST, DL, VT, V);
8150   }
8151
8152   // No viable ext lowering found.
8153   return SDValue();
8154 }
8155
8156 /// \brief Try to get a scalar value for a specific element of a vector.
8157 ///
8158 /// Looks through BUILD_VECTOR and SCALAR_TO_VECTOR nodes to find a scalar.
8159 static SDValue getScalarValueForVectorElement(SDValue V, int Idx,
8160                                               SelectionDAG &DAG) {
8161   MVT VT = V.getSimpleValueType();
8162   MVT EltVT = VT.getVectorElementType();
8163   while (V.getOpcode() == ISD::BITCAST)
8164     V = V.getOperand(0);
8165   // If the bitcasts shift the element size, we can't extract an equivalent
8166   // element from it.
8167   MVT NewVT = V.getSimpleValueType();
8168   if (!NewVT.isVector() || NewVT.getScalarSizeInBits() != VT.getScalarSizeInBits())
8169     return SDValue();
8170
8171   if (V.getOpcode() == ISD::BUILD_VECTOR ||
8172       (Idx == 0 && V.getOpcode() == ISD::SCALAR_TO_VECTOR))
8173     return DAG.getNode(ISD::BITCAST, SDLoc(V), EltVT, V.getOperand(Idx));
8174
8175   return SDValue();
8176 }
8177
8178 /// \brief Helper to test for a load that can be folded with x86 shuffles.
8179 ///
8180 /// This is particularly important because the set of instructions varies
8181 /// significantly based on whether the operand is a load or not.
8182 static bool isShuffleFoldableLoad(SDValue V) {
8183   while (V.getOpcode() == ISD::BITCAST)
8184     V = V.getOperand(0);
8185
8186   return ISD::isNON_EXTLoad(V.getNode());
8187 }
8188
8189 /// \brief Try to lower insertion of a single element into a zero vector.
8190 ///
8191 /// This is a common pattern that we have especially efficient patterns to lower
8192 /// across all subtarget feature sets.
8193 static SDValue lowerVectorShuffleAsElementInsertion(
8194     MVT VT, SDLoc DL, SDValue V1, SDValue V2, ArrayRef<int> Mask,
8195     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
8196   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
8197   MVT ExtVT = VT;
8198   MVT EltVT = VT.getVectorElementType();
8199
8200   int V2Index = std::find_if(Mask.begin(), Mask.end(),
8201                              [&Mask](int M) { return M >= (int)Mask.size(); }) -
8202                 Mask.begin();
8203   bool IsV1Zeroable = true;
8204   for (int i = 0, Size = Mask.size(); i < Size; ++i)
8205     if (i != V2Index && !Zeroable[i]) {
8206       IsV1Zeroable = false;
8207       break;
8208     }
8209
8210   // Check for a single input from a SCALAR_TO_VECTOR node.
8211   // FIXME: All of this should be canonicalized into INSERT_VECTOR_ELT and
8212   // all the smarts here sunk into that routine. However, the current
8213   // lowering of BUILD_VECTOR makes that nearly impossible until the old
8214   // vector shuffle lowering is dead.
8215   if (SDValue V2S = getScalarValueForVectorElement(
8216           V2, Mask[V2Index] - Mask.size(), DAG)) {
8217     // We need to zext the scalar if it is smaller than an i32.
8218     V2S = DAG.getNode(ISD::BITCAST, DL, EltVT, V2S);
8219     if (EltVT == MVT::i8 || EltVT == MVT::i16) {
8220       // Using zext to expand a narrow element won't work for non-zero
8221       // insertions.
8222       if (!IsV1Zeroable)
8223         return SDValue();
8224
8225       // Zero-extend directly to i32.
8226       ExtVT = MVT::v4i32;
8227       V2S = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, V2S);
8228     }
8229     V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, ExtVT, V2S);
8230   } else if (Mask[V2Index] != (int)Mask.size() || EltVT == MVT::i8 ||
8231              EltVT == MVT::i16) {
8232     // Either not inserting from the low element of the input or the input
8233     // element size is too small to use VZEXT_MOVL to clear the high bits.
8234     return SDValue();
8235   }
8236
8237   if (!IsV1Zeroable) {
8238     // If V1 can't be treated as a zero vector we have fewer options to lower
8239     // this. We can't support integer vectors or non-zero targets cheaply, and
8240     // the V1 elements can't be permuted in any way.
8241     assert(VT == ExtVT && "Cannot change extended type when non-zeroable!");
8242     if (!VT.isFloatingPoint() || V2Index != 0)
8243       return SDValue();
8244     SmallVector<int, 8> V1Mask(Mask.begin(), Mask.end());
8245     V1Mask[V2Index] = -1;
8246     if (!isNoopShuffleMask(V1Mask))
8247       return SDValue();
8248     // This is essentially a special case blend operation, but if we have
8249     // general purpose blend operations, they are always faster. Bail and let
8250     // the rest of the lowering handle these as blends.
8251     if (Subtarget->hasSSE41())
8252       return SDValue();
8253
8254     // Otherwise, use MOVSD or MOVSS.
8255     assert((EltVT == MVT::f32 || EltVT == MVT::f64) &&
8256            "Only two types of floating point element types to handle!");
8257     return DAG.getNode(EltVT == MVT::f32 ? X86ISD::MOVSS : X86ISD::MOVSD, DL,
8258                        ExtVT, V1, V2);
8259   }
8260
8261   // This lowering only works for the low element with floating point vectors.
8262   if (VT.isFloatingPoint() && V2Index != 0)
8263     return SDValue();
8264
8265   V2 = DAG.getNode(X86ISD::VZEXT_MOVL, DL, ExtVT, V2);
8266   if (ExtVT != VT)
8267     V2 = DAG.getNode(ISD::BITCAST, DL, VT, V2);
8268
8269   if (V2Index != 0) {
8270     // If we have 4 or fewer lanes we can cheaply shuffle the element into
8271     // the desired position. Otherwise it is more efficient to do a vector
8272     // shift left. We know that we can do a vector shift left because all
8273     // the inputs are zero.
8274     if (VT.isFloatingPoint() || VT.getVectorNumElements() <= 4) {
8275       SmallVector<int, 4> V2Shuffle(Mask.size(), 1);
8276       V2Shuffle[V2Index] = 0;
8277       V2 = DAG.getVectorShuffle(VT, DL, V2, DAG.getUNDEF(VT), V2Shuffle);
8278     } else {
8279       V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, V2);
8280       V2 = DAG.getNode(
8281           X86ISD::VSHLDQ, DL, MVT::v2i64, V2,
8282           DAG.getConstant(
8283               V2Index * EltVT.getSizeInBits()/8,
8284               DAG.getTargetLoweringInfo().getScalarShiftAmountTy(MVT::v2i64)));
8285       V2 = DAG.getNode(ISD::BITCAST, DL, VT, V2);
8286     }
8287   }
8288   return V2;
8289 }
8290
8291 /// \brief Try to lower broadcast of a single element.
8292 ///
8293 /// For convenience, this code also bundles all of the subtarget feature set
8294 /// filtering. While a little annoying to re-dispatch on type here, there isn't
8295 /// a convenient way to factor it out.
8296 static SDValue lowerVectorShuffleAsBroadcast(MVT VT, SDLoc DL, SDValue V,
8297                                              ArrayRef<int> Mask,
8298                                              const X86Subtarget *Subtarget,
8299                                              SelectionDAG &DAG) {
8300   if (!Subtarget->hasAVX())
8301     return SDValue();
8302   if (VT.isInteger() && !Subtarget->hasAVX2())
8303     return SDValue();
8304
8305   // Check that the mask is a broadcast.
8306   int BroadcastIdx = -1;
8307   for (int M : Mask)
8308     if (M >= 0 && BroadcastIdx == -1)
8309       BroadcastIdx = M;
8310     else if (M >= 0 && M != BroadcastIdx)
8311       return SDValue();
8312
8313   assert(BroadcastIdx < (int)Mask.size() && "We only expect to be called with "
8314                                             "a sorted mask where the broadcast "
8315                                             "comes from V1.");
8316
8317   // Go up the chain of (vector) values to try and find a scalar load that
8318   // we can combine with the broadcast.
8319   for (;;) {
8320     switch (V.getOpcode()) {
8321     case ISD::CONCAT_VECTORS: {
8322       int OperandSize = Mask.size() / V.getNumOperands();
8323       V = V.getOperand(BroadcastIdx / OperandSize);
8324       BroadcastIdx %= OperandSize;
8325       continue;
8326     }
8327
8328     case ISD::INSERT_SUBVECTOR: {
8329       SDValue VOuter = V.getOperand(0), VInner = V.getOperand(1);
8330       auto ConstantIdx = dyn_cast<ConstantSDNode>(V.getOperand(2));
8331       if (!ConstantIdx)
8332         break;
8333
8334       int BeginIdx = (int)ConstantIdx->getZExtValue();
8335       int EndIdx =
8336           BeginIdx + (int)VInner.getValueType().getVectorNumElements();
8337       if (BroadcastIdx >= BeginIdx && BroadcastIdx < EndIdx) {
8338         BroadcastIdx -= BeginIdx;
8339         V = VInner;
8340       } else {
8341         V = VOuter;
8342       }
8343       continue;
8344     }
8345     }
8346     break;
8347   }
8348
8349   // Check if this is a broadcast of a scalar. We special case lowering
8350   // for scalars so that we can more effectively fold with loads.
8351   if (V.getOpcode() == ISD::BUILD_VECTOR ||
8352       (V.getOpcode() == ISD::SCALAR_TO_VECTOR && BroadcastIdx == 0)) {
8353     V = V.getOperand(BroadcastIdx);
8354
8355     // If the scalar isn't a load we can't broadcast from it in AVX1, only with
8356     // AVX2.
8357     if (!Subtarget->hasAVX2() && !isShuffleFoldableLoad(V))
8358       return SDValue();
8359   } else if (BroadcastIdx != 0 || !Subtarget->hasAVX2()) {
8360     // We can't broadcast from a vector register w/o AVX2, and we can only
8361     // broadcast from the zero-element of a vector register.
8362     return SDValue();
8363   }
8364
8365   return DAG.getNode(X86ISD::VBROADCAST, DL, VT, V);
8366 }
8367
8368 // Check for whether we can use INSERTPS to perform the shuffle. We only use
8369 // INSERTPS when the V1 elements are already in the correct locations
8370 // because otherwise we can just always use two SHUFPS instructions which
8371 // are much smaller to encode than a SHUFPS and an INSERTPS. We can also
8372 // perform INSERTPS if a single V1 element is out of place and all V2
8373 // elements are zeroable.
8374 static SDValue lowerVectorShuffleAsInsertPS(SDValue Op, SDValue V1, SDValue V2,
8375                                             ArrayRef<int> Mask,
8376                                             SelectionDAG &DAG) {
8377   assert(Op.getSimpleValueType() == MVT::v4f32 && "Bad shuffle type!");
8378   assert(V1.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
8379   assert(V2.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
8380   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
8381
8382   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
8383
8384   unsigned ZMask = 0;
8385   int V1DstIndex = -1;
8386   int V2DstIndex = -1;
8387   bool V1UsedInPlace = false;
8388
8389   for (int i = 0; i < 4; ++i) {
8390     // Synthesize a zero mask from the zeroable elements (includes undefs).
8391     if (Zeroable[i]) {
8392       ZMask |= 1 << i;
8393       continue;
8394     }
8395
8396     // Flag if we use any V1 inputs in place.
8397     if (i == Mask[i]) {
8398       V1UsedInPlace = true;
8399       continue;
8400     }
8401
8402     // We can only insert a single non-zeroable element.
8403     if (V1DstIndex != -1 || V2DstIndex != -1)
8404       return SDValue();
8405
8406     if (Mask[i] < 4) {
8407       // V1 input out of place for insertion.
8408       V1DstIndex = i;
8409     } else {
8410       // V2 input for insertion.
8411       V2DstIndex = i;
8412     }
8413   }
8414
8415   // Don't bother if we have no (non-zeroable) element for insertion.
8416   if (V1DstIndex == -1 && V2DstIndex == -1)
8417     return SDValue();
8418
8419   // Determine element insertion src/dst indices. The src index is from the
8420   // start of the inserted vector, not the start of the concatenated vector.
8421   unsigned V2SrcIndex = 0;
8422   if (V1DstIndex != -1) {
8423     // If we have a V1 input out of place, we use V1 as the V2 element insertion
8424     // and don't use the original V2 at all.
8425     V2SrcIndex = Mask[V1DstIndex];
8426     V2DstIndex = V1DstIndex;
8427     V2 = V1;
8428   } else {
8429     V2SrcIndex = Mask[V2DstIndex] - 4;
8430   }
8431
8432   // If no V1 inputs are used in place, then the result is created only from
8433   // the zero mask and the V2 insertion - so remove V1 dependency.
8434   if (!V1UsedInPlace)
8435     V1 = DAG.getUNDEF(MVT::v4f32);
8436
8437   unsigned InsertPSMask = V2SrcIndex << 6 | V2DstIndex << 4 | ZMask;
8438   assert((InsertPSMask & ~0xFFu) == 0 && "Invalid mask!");
8439
8440   // Insert the V2 element into the desired position.
8441   SDLoc DL(Op);
8442   return DAG.getNode(X86ISD::INSERTPS, DL, MVT::v4f32, V1, V2,
8443                      DAG.getConstant(InsertPSMask, MVT::i8));
8444 }
8445
8446 /// \brief Try to lower a shuffle as a permute of the inputs followed by an
8447 /// UNPCK instruction.
8448 ///
8449 /// This specifically targets cases where we end up with alternating between
8450 /// the two inputs, and so can permute them into something that feeds a single
8451 /// UNPCK instruction. Note that this routine only targets integer vectors
8452 /// because for floating point vectors we have a generalized SHUFPS lowering
8453 /// strategy that handles everything that doesn't *exactly* match an unpack,
8454 /// making this clever lowering unnecessary.
8455 static SDValue lowerVectorShuffleAsUnpack(MVT VT, SDLoc DL, SDValue V1,
8456                                           SDValue V2, ArrayRef<int> Mask,
8457                                           SelectionDAG &DAG) {
8458   assert(!VT.isFloatingPoint() &&
8459          "This routine only supports integer vectors.");
8460   assert(!isSingleInputShuffleMask(Mask) &&
8461          "This routine should only be used when blending two inputs.");
8462   assert(Mask.size() >= 2 && "Single element masks are invalid.");
8463
8464   int Size = Mask.size();
8465
8466   int NumLoInputs = std::count_if(Mask.begin(), Mask.end(), [Size](int M) {
8467     return M >= 0 && M % Size < Size / 2;
8468   });
8469   int NumHiInputs = std::count_if(
8470       Mask.begin(), Mask.end(), [Size](int M) { return M % Size > Size / 2; });
8471
8472   bool UnpackLo = NumLoInputs >= NumHiInputs;
8473
8474   auto TryUnpack = [&](MVT UnpackVT, int Scale) {
8475     SmallVector<int, 32> V1Mask(Mask.size(), -1);
8476     SmallVector<int, 32> V2Mask(Mask.size(), -1);
8477
8478     for (int i = 0; i < Size; ++i) {
8479       if (Mask[i] < 0)
8480         continue;
8481
8482       // Each element of the unpack contains Scale elements from this mask.
8483       int UnpackIdx = i / Scale;
8484
8485       // We only handle the case where V1 feeds the first slots of the unpack.
8486       // We rely on canonicalization to ensure this is the case.
8487       if ((UnpackIdx % 2 == 0) != (Mask[i] < Size))
8488         return SDValue();
8489
8490       // Setup the mask for this input. The indexing is tricky as we have to
8491       // handle the unpack stride.
8492       SmallVectorImpl<int> &VMask = (UnpackIdx % 2 == 0) ? V1Mask : V2Mask;
8493       VMask[(UnpackIdx / 2) * Scale + i % Scale + (UnpackLo ? 0 : Size / 2)] =
8494           Mask[i] % Size;
8495     }
8496
8497     // Shuffle the inputs into place.
8498     V1 = DAG.getVectorShuffle(VT, DL, V1, DAG.getUNDEF(VT), V1Mask);
8499     V2 = DAG.getVectorShuffle(VT, DL, V2, DAG.getUNDEF(VT), V2Mask);
8500
8501     // Cast the inputs to the type we will use to unpack them.
8502     V1 = DAG.getNode(ISD::BITCAST, DL, UnpackVT, V1);
8503     V2 = DAG.getNode(ISD::BITCAST, DL, UnpackVT, V2);
8504
8505     // Unpack the inputs and cast the result back to the desired type.
8506     return DAG.getNode(ISD::BITCAST, DL, VT,
8507                        DAG.getNode(UnpackLo ? X86ISD::UNPCKL : X86ISD::UNPCKH,
8508                                    DL, UnpackVT, V1, V2));
8509   };
8510
8511   // We try each unpack from the largest to the smallest to try and find one
8512   // that fits this mask.
8513   int OrigNumElements = VT.getVectorNumElements();
8514   int OrigScalarSize = VT.getScalarSizeInBits();
8515   for (int ScalarSize = 64; ScalarSize >= OrigScalarSize; ScalarSize /= 2) {
8516     int Scale = ScalarSize / OrigScalarSize;
8517     int NumElements = OrigNumElements / Scale;
8518     MVT UnpackVT = MVT::getVectorVT(MVT::getIntegerVT(ScalarSize), NumElements);
8519     if (SDValue Unpack = TryUnpack(UnpackVT, Scale))
8520       return Unpack;
8521   }
8522
8523   return SDValue();
8524 }
8525
8526 /// \brief Handle lowering of 2-lane 64-bit floating point shuffles.
8527 ///
8528 /// This is the basis function for the 2-lane 64-bit shuffles as we have full
8529 /// support for floating point shuffles but not integer shuffles. These
8530 /// instructions will incur a domain crossing penalty on some chips though so
8531 /// it is better to avoid lowering through this for integer vectors where
8532 /// possible.
8533 static SDValue lowerV2F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8534                                        const X86Subtarget *Subtarget,
8535                                        SelectionDAG &DAG) {
8536   SDLoc DL(Op);
8537   assert(Op.getSimpleValueType() == MVT::v2f64 && "Bad shuffle type!");
8538   assert(V1.getSimpleValueType() == MVT::v2f64 && "Bad operand type!");
8539   assert(V2.getSimpleValueType() == MVT::v2f64 && "Bad operand type!");
8540   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8541   ArrayRef<int> Mask = SVOp->getMask();
8542   assert(Mask.size() == 2 && "Unexpected mask size for v2 shuffle!");
8543
8544   if (isSingleInputShuffleMask(Mask)) {
8545     // Use low duplicate instructions for masks that match their pattern.
8546     if (Subtarget->hasSSE3())
8547       if (isShuffleEquivalent(V1, V2, Mask, 0, 0))
8548         return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v2f64, V1);
8549
8550     // Straight shuffle of a single input vector. Simulate this by using the
8551     // single input as both of the "inputs" to this instruction..
8552     unsigned SHUFPDMask = (Mask[0] == 1) | ((Mask[1] == 1) << 1);
8553
8554     if (Subtarget->hasAVX()) {
8555       // If we have AVX, we can use VPERMILPS which will allow folding a load
8556       // into the shuffle.
8557       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v2f64, V1,
8558                          DAG.getConstant(SHUFPDMask, MVT::i8));
8559     }
8560
8561     return DAG.getNode(X86ISD::SHUFP, SDLoc(Op), MVT::v2f64, V1, V1,
8562                        DAG.getConstant(SHUFPDMask, MVT::i8));
8563   }
8564   assert(Mask[0] >= 0 && Mask[0] < 2 && "Non-canonicalized blend!");
8565   assert(Mask[1] >= 2 && "Non-canonicalized blend!");
8566
8567   // If we have a single input, insert that into V1 if we can do so cheaply.
8568   if ((Mask[0] >= 2) + (Mask[1] >= 2) == 1) {
8569     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
8570             MVT::v2f64, DL, V1, V2, Mask, Subtarget, DAG))
8571       return Insertion;
8572     // Try inverting the insertion since for v2 masks it is easy to do and we
8573     // can't reliably sort the mask one way or the other.
8574     int InverseMask[2] = {Mask[0] < 0 ? -1 : (Mask[0] ^ 2),
8575                           Mask[1] < 0 ? -1 : (Mask[1] ^ 2)};
8576     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
8577             MVT::v2f64, DL, V2, V1, InverseMask, Subtarget, DAG))
8578       return Insertion;
8579   }
8580
8581   // Try to use one of the special instruction patterns to handle two common
8582   // blend patterns if a zero-blend above didn't work.
8583   if (isShuffleEquivalent(V1, V2, Mask, 0, 3) || isShuffleEquivalent(V1, V2, Mask, 1, 3))
8584     if (SDValue V1S = getScalarValueForVectorElement(V1, Mask[0], DAG))
8585       // We can either use a special instruction to load over the low double or
8586       // to move just the low double.
8587       return DAG.getNode(
8588           isShuffleFoldableLoad(V1S) ? X86ISD::MOVLPD : X86ISD::MOVSD,
8589           DL, MVT::v2f64, V2,
8590           DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64, V1S));
8591
8592   if (Subtarget->hasSSE41())
8593     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v2f64, V1, V2, Mask,
8594                                                   Subtarget, DAG))
8595       return Blend;
8596
8597   // Use dedicated unpack instructions for masks that match their pattern.
8598   if (isShuffleEquivalent(V1, V2, Mask, 0, 2))
8599     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2f64, V1, V2);
8600   if (isShuffleEquivalent(V1, V2, Mask, 1, 3))
8601     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v2f64, V1, V2);
8602
8603   unsigned SHUFPDMask = (Mask[0] == 1) | (((Mask[1] - 2) == 1) << 1);
8604   return DAG.getNode(X86ISD::SHUFP, SDLoc(Op), MVT::v2f64, V1, V2,
8605                      DAG.getConstant(SHUFPDMask, MVT::i8));
8606 }
8607
8608 /// \brief Handle lowering of 2-lane 64-bit integer shuffles.
8609 ///
8610 /// Tries to lower a 2-lane 64-bit shuffle using shuffle operations provided by
8611 /// the integer unit to minimize domain crossing penalties. However, for blends
8612 /// it falls back to the floating point shuffle operation with appropriate bit
8613 /// casting.
8614 static SDValue lowerV2I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8615                                        const X86Subtarget *Subtarget,
8616                                        SelectionDAG &DAG) {
8617   SDLoc DL(Op);
8618   assert(Op.getSimpleValueType() == MVT::v2i64 && "Bad shuffle type!");
8619   assert(V1.getSimpleValueType() == MVT::v2i64 && "Bad operand type!");
8620   assert(V2.getSimpleValueType() == MVT::v2i64 && "Bad operand type!");
8621   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8622   ArrayRef<int> Mask = SVOp->getMask();
8623   assert(Mask.size() == 2 && "Unexpected mask size for v2 shuffle!");
8624
8625   if (isSingleInputShuffleMask(Mask)) {
8626     // Check for being able to broadcast a single element.
8627     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v2i64, DL, V1,
8628                                                           Mask, Subtarget, DAG))
8629       return Broadcast;
8630
8631     // Straight shuffle of a single input vector. For everything from SSE2
8632     // onward this has a single fast instruction with no scary immediates.
8633     // We have to map the mask as it is actually a v4i32 shuffle instruction.
8634     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V1);
8635     int WidenedMask[4] = {
8636         std::max(Mask[0], 0) * 2, std::max(Mask[0], 0) * 2 + 1,
8637         std::max(Mask[1], 0) * 2, std::max(Mask[1], 0) * 2 + 1};
8638     return DAG.getNode(
8639         ISD::BITCAST, DL, MVT::v2i64,
8640         DAG.getNode(X86ISD::PSHUFD, SDLoc(Op), MVT::v4i32, V1,
8641                     getV4X86ShuffleImm8ForMask(WidenedMask, DAG)));
8642   }
8643   assert(Mask[0] != -1 && "No undef lanes in multi-input v2 shuffles!");
8644   assert(Mask[1] != -1 && "No undef lanes in multi-input v2 shuffles!");
8645   assert(Mask[0] < 2 && "We sort V1 to be the first input.");
8646   assert(Mask[1] >= 2 && "We sort V2 to be the second input.");
8647
8648   // If we have a blend of two PACKUS operations an the blend aligns with the
8649   // low and half halves, we can just merge the PACKUS operations. This is
8650   // particularly important as it lets us merge shuffles that this routine itself
8651   // creates.
8652   auto GetPackNode = [](SDValue V) {
8653     while (V.getOpcode() == ISD::BITCAST)
8654       V = V.getOperand(0);
8655
8656     return V.getOpcode() == X86ISD::PACKUS ? V : SDValue();
8657   };
8658   if (SDValue V1Pack = GetPackNode(V1))
8659     if (SDValue V2Pack = GetPackNode(V2))
8660       return DAG.getNode(ISD::BITCAST, DL, MVT::v2i64,
8661                          DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8,
8662                                      Mask[0] == 0 ? V1Pack.getOperand(0)
8663                                                   : V1Pack.getOperand(1),
8664                                      Mask[1] == 2 ? V2Pack.getOperand(0)
8665                                                   : V2Pack.getOperand(1)));
8666
8667   // Try to use shift instructions.
8668   if (SDValue Shift =
8669           lowerVectorShuffleAsShift(DL, MVT::v2i64, V1, V2, Mask, DAG))
8670     return Shift;
8671
8672   // When loading a scalar and then shuffling it into a vector we can often do
8673   // the insertion cheaply.
8674   if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
8675           MVT::v2i64, DL, V1, V2, Mask, Subtarget, DAG))
8676     return Insertion;
8677   // Try inverting the insertion since for v2 masks it is easy to do and we
8678   // can't reliably sort the mask one way or the other.
8679   int InverseMask[2] = {Mask[0] ^ 2, Mask[1] ^ 2};
8680   if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
8681           MVT::v2i64, DL, V2, V1, InverseMask, Subtarget, DAG))
8682     return Insertion;
8683
8684   // We have different paths for blend lowering, but they all must use the
8685   // *exact* same predicate.
8686   bool IsBlendSupported = Subtarget->hasSSE41();
8687   if (IsBlendSupported)
8688     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v2i64, V1, V2, Mask,
8689                                                   Subtarget, DAG))
8690       return Blend;
8691
8692   // Use dedicated unpack instructions for masks that match their pattern.
8693   if (isShuffleEquivalent(V1, V2, Mask, 0, 2))
8694     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2i64, V1, V2);
8695   if (isShuffleEquivalent(V1, V2, Mask, 1, 3))
8696     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v2i64, V1, V2);
8697
8698   // Try to use byte rotation instructions.
8699   // Its more profitable for pre-SSSE3 to use shuffles/unpacks.
8700   if (Subtarget->hasSSSE3())
8701     if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
8702             DL, MVT::v2i64, V1, V2, Mask, Subtarget, DAG))
8703       return Rotate;
8704
8705   // If we have direct support for blends, we should lower by decomposing into
8706   // a permute. That will be faster than the domain cross.
8707   if (IsBlendSupported)
8708     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v2i64, V1, V2,
8709                                                       Mask, DAG);
8710
8711   // We implement this with SHUFPD which is pretty lame because it will likely
8712   // incur 2 cycles of stall for integer vectors on Nehalem and older chips.
8713   // However, all the alternatives are still more cycles and newer chips don't
8714   // have this problem. It would be really nice if x86 had better shuffles here.
8715   V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, V1);
8716   V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, V2);
8717   return DAG.getNode(ISD::BITCAST, DL, MVT::v2i64,
8718                      DAG.getVectorShuffle(MVT::v2f64, DL, V1, V2, Mask));
8719 }
8720
8721 /// \brief Test whether this can be lowered with a single SHUFPS instruction.
8722 ///
8723 /// This is used to disable more specialized lowerings when the shufps lowering
8724 /// will happen to be efficient.
8725 static bool isSingleSHUFPSMask(ArrayRef<int> Mask) {
8726   // This routine only handles 128-bit shufps.
8727   assert(Mask.size() == 4 && "Unsupported mask size!");
8728
8729   // To lower with a single SHUFPS we need to have the low half and high half
8730   // each requiring a single input.
8731   if (Mask[0] != -1 && Mask[1] != -1 && (Mask[0] < 4) != (Mask[1] < 4))
8732     return false;
8733   if (Mask[2] != -1 && Mask[3] != -1 && (Mask[2] < 4) != (Mask[3] < 4))
8734     return false;
8735
8736   return true;
8737 }
8738
8739 /// \brief Lower a vector shuffle using the SHUFPS instruction.
8740 ///
8741 /// This is a helper routine dedicated to lowering vector shuffles using SHUFPS.
8742 /// It makes no assumptions about whether this is the *best* lowering, it simply
8743 /// uses it.
8744 static SDValue lowerVectorShuffleWithSHUFPS(SDLoc DL, MVT VT,
8745                                             ArrayRef<int> Mask, SDValue V1,
8746                                             SDValue V2, SelectionDAG &DAG) {
8747   SDValue LowV = V1, HighV = V2;
8748   int NewMask[4] = {Mask[0], Mask[1], Mask[2], Mask[3]};
8749
8750   int NumV2Elements =
8751       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
8752
8753   if (NumV2Elements == 1) {
8754     int V2Index =
8755         std::find_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; }) -
8756         Mask.begin();
8757
8758     // Compute the index adjacent to V2Index and in the same half by toggling
8759     // the low bit.
8760     int V2AdjIndex = V2Index ^ 1;
8761
8762     if (Mask[V2AdjIndex] == -1) {
8763       // Handles all the cases where we have a single V2 element and an undef.
8764       // This will only ever happen in the high lanes because we commute the
8765       // vector otherwise.
8766       if (V2Index < 2)
8767         std::swap(LowV, HighV);
8768       NewMask[V2Index] -= 4;
8769     } else {
8770       // Handle the case where the V2 element ends up adjacent to a V1 element.
8771       // To make this work, blend them together as the first step.
8772       int V1Index = V2AdjIndex;
8773       int BlendMask[4] = {Mask[V2Index] - 4, 0, Mask[V1Index], 0};
8774       V2 = DAG.getNode(X86ISD::SHUFP, DL, VT, V2, V1,
8775                        getV4X86ShuffleImm8ForMask(BlendMask, DAG));
8776
8777       // Now proceed to reconstruct the final blend as we have the necessary
8778       // high or low half formed.
8779       if (V2Index < 2) {
8780         LowV = V2;
8781         HighV = V1;
8782       } else {
8783         HighV = V2;
8784       }
8785       NewMask[V1Index] = 2; // We put the V1 element in V2[2].
8786       NewMask[V2Index] = 0; // We shifted the V2 element into V2[0].
8787     }
8788   } else if (NumV2Elements == 2) {
8789     if (Mask[0] < 4 && Mask[1] < 4) {
8790       // Handle the easy case where we have V1 in the low lanes and V2 in the
8791       // high lanes.
8792       NewMask[2] -= 4;
8793       NewMask[3] -= 4;
8794     } else if (Mask[2] < 4 && Mask[3] < 4) {
8795       // We also handle the reversed case because this utility may get called
8796       // when we detect a SHUFPS pattern but can't easily commute the shuffle to
8797       // arrange things in the right direction.
8798       NewMask[0] -= 4;
8799       NewMask[1] -= 4;
8800       HighV = V1;
8801       LowV = V2;
8802     } else {
8803       // We have a mixture of V1 and V2 in both low and high lanes. Rather than
8804       // trying to place elements directly, just blend them and set up the final
8805       // shuffle to place them.
8806
8807       // The first two blend mask elements are for V1, the second two are for
8808       // V2.
8809       int BlendMask[4] = {Mask[0] < 4 ? Mask[0] : Mask[1],
8810                           Mask[2] < 4 ? Mask[2] : Mask[3],
8811                           (Mask[0] >= 4 ? Mask[0] : Mask[1]) - 4,
8812                           (Mask[2] >= 4 ? Mask[2] : Mask[3]) - 4};
8813       V1 = DAG.getNode(X86ISD::SHUFP, DL, VT, V1, V2,
8814                        getV4X86ShuffleImm8ForMask(BlendMask, DAG));
8815
8816       // Now we do a normal shuffle of V1 by giving V1 as both operands to
8817       // a blend.
8818       LowV = HighV = V1;
8819       NewMask[0] = Mask[0] < 4 ? 0 : 2;
8820       NewMask[1] = Mask[0] < 4 ? 2 : 0;
8821       NewMask[2] = Mask[2] < 4 ? 1 : 3;
8822       NewMask[3] = Mask[2] < 4 ? 3 : 1;
8823     }
8824   }
8825   return DAG.getNode(X86ISD::SHUFP, DL, VT, LowV, HighV,
8826                      getV4X86ShuffleImm8ForMask(NewMask, DAG));
8827 }
8828
8829 /// \brief Lower 4-lane 32-bit floating point shuffles.
8830 ///
8831 /// Uses instructions exclusively from the floating point unit to minimize
8832 /// domain crossing penalties, as these are sufficient to implement all v4f32
8833 /// shuffles.
8834 static SDValue lowerV4F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8835                                        const X86Subtarget *Subtarget,
8836                                        SelectionDAG &DAG) {
8837   SDLoc DL(Op);
8838   assert(Op.getSimpleValueType() == MVT::v4f32 && "Bad shuffle type!");
8839   assert(V1.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
8840   assert(V2.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
8841   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8842   ArrayRef<int> Mask = SVOp->getMask();
8843   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
8844
8845   int NumV2Elements =
8846       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
8847
8848   if (NumV2Elements == 0) {
8849     // Check for being able to broadcast a single element.
8850     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4f32, DL, V1,
8851                                                           Mask, Subtarget, DAG))
8852       return Broadcast;
8853
8854     // Use even/odd duplicate instructions for masks that match their pattern.
8855     if (Subtarget->hasSSE3()) {
8856       if (isShuffleEquivalent(V1, V2, Mask, 0, 0, 2, 2))
8857         return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v4f32, V1);
8858       if (isShuffleEquivalent(V1, V2, Mask, 1, 1, 3, 3))
8859         return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v4f32, V1);
8860     }
8861
8862     if (Subtarget->hasAVX()) {
8863       // If we have AVX, we can use VPERMILPS which will allow folding a load
8864       // into the shuffle.
8865       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f32, V1,
8866                          getV4X86ShuffleImm8ForMask(Mask, DAG));
8867     }
8868
8869     // Otherwise, use a straight shuffle of a single input vector. We pass the
8870     // input vector to both operands to simulate this with a SHUFPS.
8871     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f32, V1, V1,
8872                        getV4X86ShuffleImm8ForMask(Mask, DAG));
8873   }
8874
8875   // There are special ways we can lower some single-element blends. However, we
8876   // have custom ways we can lower more complex single-element blends below that
8877   // we defer to if both this and BLENDPS fail to match, so restrict this to
8878   // when the V2 input is targeting element 0 of the mask -- that is the fast
8879   // case here.
8880   if (NumV2Elements == 1 && Mask[0] >= 4)
8881     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v4f32, DL, V1, V2,
8882                                                          Mask, Subtarget, DAG))
8883       return V;
8884
8885   if (Subtarget->hasSSE41()) {
8886     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4f32, V1, V2, Mask,
8887                                                   Subtarget, DAG))
8888       return Blend;
8889
8890     // Use INSERTPS if we can complete the shuffle efficiently.
8891     if (SDValue V = lowerVectorShuffleAsInsertPS(Op, V1, V2, Mask, DAG))
8892       return V;
8893
8894     if (!isSingleSHUFPSMask(Mask))
8895       if (SDValue BlendPerm = lowerVectorShuffleAsBlendAndPermute(
8896               DL, MVT::v4f32, V1, V2, Mask, DAG))
8897         return BlendPerm;
8898   }
8899
8900   // Use dedicated unpack instructions for masks that match their pattern.
8901   if (isShuffleEquivalent(V1, V2, Mask, 0, 4, 1, 5))
8902     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f32, V1, V2);
8903   if (isShuffleEquivalent(V1, V2, Mask, 2, 6, 3, 7))
8904     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f32, V1, V2);
8905   if (isShuffleEquivalent(V1, V2, Mask, 4, 0, 5, 1))
8906     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f32, V2, V1);
8907   if (isShuffleEquivalent(V1, V2, Mask, 6, 2, 7, 3))
8908     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f32, V2, V1);
8909
8910   // Otherwise fall back to a SHUFPS lowering strategy.
8911   return lowerVectorShuffleWithSHUFPS(DL, MVT::v4f32, Mask, V1, V2, DAG);
8912 }
8913
8914 /// \brief Lower 4-lane i32 vector shuffles.
8915 ///
8916 /// We try to handle these with integer-domain shuffles where we can, but for
8917 /// blends we use the floating point domain blend instructions.
8918 static SDValue lowerV4I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8919                                        const X86Subtarget *Subtarget,
8920                                        SelectionDAG &DAG) {
8921   SDLoc DL(Op);
8922   assert(Op.getSimpleValueType() == MVT::v4i32 && "Bad shuffle type!");
8923   assert(V1.getSimpleValueType() == MVT::v4i32 && "Bad operand type!");
8924   assert(V2.getSimpleValueType() == MVT::v4i32 && "Bad operand type!");
8925   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8926   ArrayRef<int> Mask = SVOp->getMask();
8927   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
8928
8929   // Whenever we can lower this as a zext, that instruction is strictly faster
8930   // than any alternative. It also allows us to fold memory operands into the
8931   // shuffle in many cases.
8932   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v4i32, V1, V2,
8933                                                          Mask, Subtarget, DAG))
8934     return ZExt;
8935
8936   int NumV2Elements =
8937       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
8938
8939   if (NumV2Elements == 0) {
8940     // Check for being able to broadcast a single element.
8941     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4i32, DL, V1,
8942                                                           Mask, Subtarget, DAG))
8943       return Broadcast;
8944
8945     // Straight shuffle of a single input vector. For everything from SSE2
8946     // onward this has a single fast instruction with no scary immediates.
8947     // We coerce the shuffle pattern to be compatible with UNPCK instructions
8948     // but we aren't actually going to use the UNPCK instruction because doing
8949     // so prevents folding a load into this instruction or making a copy.
8950     const int UnpackLoMask[] = {0, 0, 1, 1};
8951     const int UnpackHiMask[] = {2, 2, 3, 3};
8952     if (isShuffleEquivalent(V1, V2, Mask, 0, 0, 1, 1))
8953       Mask = UnpackLoMask;
8954     else if (isShuffleEquivalent(V1, V2, Mask, 2, 2, 3, 3))
8955       Mask = UnpackHiMask;
8956
8957     return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V1,
8958                        getV4X86ShuffleImm8ForMask(Mask, DAG));
8959   }
8960
8961   // Try to use shift instructions.
8962   if (SDValue Shift =
8963           lowerVectorShuffleAsShift(DL, MVT::v4i32, V1, V2, Mask, DAG))
8964     return Shift;
8965
8966   // There are special ways we can lower some single-element blends.
8967   if (NumV2Elements == 1)
8968     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v4i32, DL, V1, V2,
8969                                                          Mask, Subtarget, DAG))
8970       return V;
8971
8972   // We have different paths for blend lowering, but they all must use the
8973   // *exact* same predicate.
8974   bool IsBlendSupported = Subtarget->hasSSE41();
8975   if (IsBlendSupported)
8976     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4i32, V1, V2, Mask,
8977                                                   Subtarget, DAG))
8978       return Blend;
8979
8980   if (SDValue Masked =
8981           lowerVectorShuffleAsBitMask(DL, MVT::v4i32, V1, V2, Mask, DAG))
8982     return Masked;
8983
8984   // Use dedicated unpack instructions for masks that match their pattern.
8985   if (isShuffleEquivalent(V1, V2, Mask, 0, 4, 1, 5))
8986     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i32, V1, V2);
8987   if (isShuffleEquivalent(V1, V2, Mask, 2, 6, 3, 7))
8988     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i32, V1, V2);
8989   if (isShuffleEquivalent(V1, V2, Mask, 4, 0, 5, 1))
8990     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i32, V2, V1);
8991   if (isShuffleEquivalent(V1, V2, Mask, 6, 2, 7, 3))
8992     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i32, V2, V1);
8993
8994   // Try to use byte rotation instructions.
8995   // Its more profitable for pre-SSSE3 to use shuffles/unpacks.
8996   if (Subtarget->hasSSSE3())
8997     if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
8998             DL, MVT::v4i32, V1, V2, Mask, Subtarget, DAG))
8999       return Rotate;
9000
9001   // If we have direct support for blends, we should lower by decomposing into
9002   // a permute. That will be faster than the domain cross.
9003   if (IsBlendSupported)
9004     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4i32, V1, V2,
9005                                                       Mask, DAG);
9006
9007   // Try to lower by permuting the inputs into an unpack instruction.
9008   if (SDValue Unpack =
9009           lowerVectorShuffleAsUnpack(MVT::v4i32, DL, V1, V2, Mask, DAG))
9010     return Unpack;
9011
9012   // We implement this with SHUFPS because it can blend from two vectors.
9013   // Because we're going to eventually use SHUFPS, we use SHUFPS even to build
9014   // up the inputs, bypassing domain shift penalties that we would encur if we
9015   // directly used PSHUFD on Nehalem and older. For newer chips, this isn't
9016   // relevant.
9017   return DAG.getNode(ISD::BITCAST, DL, MVT::v4i32,
9018                      DAG.getVectorShuffle(
9019                          MVT::v4f32, DL,
9020                          DAG.getNode(ISD::BITCAST, DL, MVT::v4f32, V1),
9021                          DAG.getNode(ISD::BITCAST, DL, MVT::v4f32, V2), Mask));
9022 }
9023
9024 /// \brief Lowering of single-input v8i16 shuffles is the cornerstone of SSE2
9025 /// shuffle lowering, and the most complex part.
9026 ///
9027 /// The lowering strategy is to try to form pairs of input lanes which are
9028 /// targeted at the same half of the final vector, and then use a dword shuffle
9029 /// to place them onto the right half, and finally unpack the paired lanes into
9030 /// their final position.
9031 ///
9032 /// The exact breakdown of how to form these dword pairs and align them on the
9033 /// correct sides is really tricky. See the comments within the function for
9034 /// more of the details.
9035 static SDValue lowerV8I16SingleInputVectorShuffle(
9036     SDLoc DL, SDValue V, MutableArrayRef<int> Mask,
9037     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
9038   assert(V.getSimpleValueType() == MVT::v8i16 && "Bad input type!");
9039   MutableArrayRef<int> LoMask = Mask.slice(0, 4);
9040   MutableArrayRef<int> HiMask = Mask.slice(4, 4);
9041
9042   SmallVector<int, 4> LoInputs;
9043   std::copy_if(LoMask.begin(), LoMask.end(), std::back_inserter(LoInputs),
9044                [](int M) { return M >= 0; });
9045   std::sort(LoInputs.begin(), LoInputs.end());
9046   LoInputs.erase(std::unique(LoInputs.begin(), LoInputs.end()), LoInputs.end());
9047   SmallVector<int, 4> HiInputs;
9048   std::copy_if(HiMask.begin(), HiMask.end(), std::back_inserter(HiInputs),
9049                [](int M) { return M >= 0; });
9050   std::sort(HiInputs.begin(), HiInputs.end());
9051   HiInputs.erase(std::unique(HiInputs.begin(), HiInputs.end()), HiInputs.end());
9052   int NumLToL =
9053       std::lower_bound(LoInputs.begin(), LoInputs.end(), 4) - LoInputs.begin();
9054   int NumHToL = LoInputs.size() - NumLToL;
9055   int NumLToH =
9056       std::lower_bound(HiInputs.begin(), HiInputs.end(), 4) - HiInputs.begin();
9057   int NumHToH = HiInputs.size() - NumLToH;
9058   MutableArrayRef<int> LToLInputs(LoInputs.data(), NumLToL);
9059   MutableArrayRef<int> LToHInputs(HiInputs.data(), NumLToH);
9060   MutableArrayRef<int> HToLInputs(LoInputs.data() + NumLToL, NumHToL);
9061   MutableArrayRef<int> HToHInputs(HiInputs.data() + NumLToH, NumHToH);
9062
9063   // Check for being able to broadcast a single element.
9064   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v8i16, DL, V,
9065                                                         Mask, Subtarget, DAG))
9066     return Broadcast;
9067
9068   // Try to use shift instructions.
9069   if (SDValue Shift =
9070           lowerVectorShuffleAsShift(DL, MVT::v8i16, V, V, Mask, DAG))
9071     return Shift;
9072
9073   // Use dedicated unpack instructions for masks that match their pattern.
9074   if (isShuffleEquivalent(V, V, Mask, 0, 0, 1, 1, 2, 2, 3, 3))
9075     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, V, V);
9076   if (isShuffleEquivalent(V, V, Mask, 4, 4, 5, 5, 6, 6, 7, 7))
9077     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i16, V, V);
9078
9079   // Try to use byte rotation instructions.
9080   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9081           DL, MVT::v8i16, V, V, Mask, Subtarget, DAG))
9082     return Rotate;
9083
9084   // Simplify the 1-into-3 and 3-into-1 cases with a single pshufd. For all
9085   // such inputs we can swap two of the dwords across the half mark and end up
9086   // with <=2 inputs to each half in each half. Once there, we can fall through
9087   // to the generic code below. For example:
9088   //
9089   // Input: [a, b, c, d, e, f, g, h] -PSHUFD[0,2,1,3]-> [a, b, e, f, c, d, g, h]
9090   // Mask:  [0, 1, 2, 7, 4, 5, 6, 3] -----------------> [0, 1, 4, 7, 2, 3, 6, 5]
9091   //
9092   // However in some very rare cases we have a 1-into-3 or 3-into-1 on one half
9093   // and an existing 2-into-2 on the other half. In this case we may have to
9094   // pre-shuffle the 2-into-2 half to avoid turning it into a 3-into-1 or
9095   // 1-into-3 which could cause us to cycle endlessly fixing each side in turn.
9096   // Fortunately, we don't have to handle anything but a 2-into-2 pattern
9097   // because any other situation (including a 3-into-1 or 1-into-3 in the other
9098   // half than the one we target for fixing) will be fixed when we re-enter this
9099   // path. We will also combine away any sequence of PSHUFD instructions that
9100   // result into a single instruction. Here is an example of the tricky case:
9101   //
9102   // Input: [a, b, c, d, e, f, g, h] -PSHUFD[0,2,1,3]-> [a, b, e, f, c, d, g, h]
9103   // Mask:  [3, 7, 1, 0, 2, 7, 3, 5] -THIS-IS-BAD!!!!-> [5, 7, 1, 0, 4, 7, 5, 3]
9104   //
9105   // This now has a 1-into-3 in the high half! Instead, we do two shuffles:
9106   //
9107   // Input: [a, b, c, d, e, f, g, h] PSHUFHW[0,2,1,3]-> [a, b, c, d, e, g, f, h]
9108   // Mask:  [3, 7, 1, 0, 2, 7, 3, 5] -----------------> [3, 7, 1, 0, 2, 7, 3, 6]
9109   //
9110   // Input: [a, b, c, d, e, g, f, h] -PSHUFD[0,2,1,3]-> [a, b, e, g, c, d, f, h]
9111   // Mask:  [3, 7, 1, 0, 2, 7, 3, 6] -----------------> [5, 7, 1, 0, 4, 7, 5, 6]
9112   //
9113   // The result is fine to be handled by the generic logic.
9114   auto balanceSides = [&](ArrayRef<int> AToAInputs, ArrayRef<int> BToAInputs,
9115                           ArrayRef<int> BToBInputs, ArrayRef<int> AToBInputs,
9116                           int AOffset, int BOffset) {
9117     assert((AToAInputs.size() == 3 || AToAInputs.size() == 1) &&
9118            "Must call this with A having 3 or 1 inputs from the A half.");
9119     assert((BToAInputs.size() == 1 || BToAInputs.size() == 3) &&
9120            "Must call this with B having 1 or 3 inputs from the B half.");
9121     assert(AToAInputs.size() + BToAInputs.size() == 4 &&
9122            "Must call this with either 3:1 or 1:3 inputs (summing to 4).");
9123
9124     // Compute the index of dword with only one word among the three inputs in
9125     // a half by taking the sum of the half with three inputs and subtracting
9126     // the sum of the actual three inputs. The difference is the remaining
9127     // slot.
9128     int ADWord, BDWord;
9129     int &TripleDWord = AToAInputs.size() == 3 ? ADWord : BDWord;
9130     int &OneInputDWord = AToAInputs.size() == 3 ? BDWord : ADWord;
9131     int TripleInputOffset = AToAInputs.size() == 3 ? AOffset : BOffset;
9132     ArrayRef<int> TripleInputs = AToAInputs.size() == 3 ? AToAInputs : BToAInputs;
9133     int OneInput = AToAInputs.size() == 3 ? BToAInputs[0] : AToAInputs[0];
9134     int TripleInputSum = 0 + 1 + 2 + 3 + (4 * TripleInputOffset);
9135     int TripleNonInputIdx =
9136         TripleInputSum - std::accumulate(TripleInputs.begin(), TripleInputs.end(), 0);
9137     TripleDWord = TripleNonInputIdx / 2;
9138
9139     // We use xor with one to compute the adjacent DWord to whichever one the
9140     // OneInput is in.
9141     OneInputDWord = (OneInput / 2) ^ 1;
9142
9143     // Check for one tricky case: We're fixing a 3<-1 or a 1<-3 shuffle for AToA
9144     // and BToA inputs. If there is also such a problem with the BToB and AToB
9145     // inputs, we don't try to fix it necessarily -- we'll recurse and see it in
9146     // the next pass. However, if we have a 2<-2 in the BToB and AToB inputs, it
9147     // is essential that we don't *create* a 3<-1 as then we might oscillate.
9148     if (BToBInputs.size() == 2 && AToBInputs.size() == 2) {
9149       // Compute how many inputs will be flipped by swapping these DWords. We
9150       // need
9151       // to balance this to ensure we don't form a 3-1 shuffle in the other
9152       // half.
9153       int NumFlippedAToBInputs =
9154           std::count(AToBInputs.begin(), AToBInputs.end(), 2 * ADWord) +
9155           std::count(AToBInputs.begin(), AToBInputs.end(), 2 * ADWord + 1);
9156       int NumFlippedBToBInputs =
9157           std::count(BToBInputs.begin(), BToBInputs.end(), 2 * BDWord) +
9158           std::count(BToBInputs.begin(), BToBInputs.end(), 2 * BDWord + 1);
9159       if ((NumFlippedAToBInputs == 1 &&
9160            (NumFlippedBToBInputs == 0 || NumFlippedBToBInputs == 2)) ||
9161           (NumFlippedBToBInputs == 1 &&
9162            (NumFlippedAToBInputs == 0 || NumFlippedAToBInputs == 2))) {
9163         // We choose whether to fix the A half or B half based on whether that
9164         // half has zero flipped inputs. At zero, we may not be able to fix it
9165         // with that half. We also bias towards fixing the B half because that
9166         // will more commonly be the high half, and we have to bias one way.
9167         auto FixFlippedInputs = [&V, &DL, &Mask, &DAG](int PinnedIdx, int DWord,
9168                                                        ArrayRef<int> Inputs) {
9169           int FixIdx = PinnedIdx ^ 1; // The adjacent slot to the pinned slot.
9170           bool IsFixIdxInput = std::find(Inputs.begin(), Inputs.end(),
9171                                          PinnedIdx ^ 1) != Inputs.end();
9172           // Determine whether the free index is in the flipped dword or the
9173           // unflipped dword based on where the pinned index is. We use this bit
9174           // in an xor to conditionally select the adjacent dword.
9175           int FixFreeIdx = 2 * (DWord ^ (PinnedIdx / 2 == DWord));
9176           bool IsFixFreeIdxInput = std::find(Inputs.begin(), Inputs.end(),
9177                                              FixFreeIdx) != Inputs.end();
9178           if (IsFixIdxInput == IsFixFreeIdxInput)
9179             FixFreeIdx += 1;
9180           IsFixFreeIdxInput = std::find(Inputs.begin(), Inputs.end(),
9181                                         FixFreeIdx) != Inputs.end();
9182           assert(IsFixIdxInput != IsFixFreeIdxInput &&
9183                  "We need to be changing the number of flipped inputs!");
9184           int PSHUFHalfMask[] = {0, 1, 2, 3};
9185           std::swap(PSHUFHalfMask[FixFreeIdx % 4], PSHUFHalfMask[FixIdx % 4]);
9186           V = DAG.getNode(FixIdx < 4 ? X86ISD::PSHUFLW : X86ISD::PSHUFHW, DL,
9187                           MVT::v8i16, V,
9188                           getV4X86ShuffleImm8ForMask(PSHUFHalfMask, DAG));
9189
9190           for (int &M : Mask)
9191             if (M != -1 && M == FixIdx)
9192               M = FixFreeIdx;
9193             else if (M != -1 && M == FixFreeIdx)
9194               M = FixIdx;
9195         };
9196         if (NumFlippedBToBInputs != 0) {
9197           int BPinnedIdx =
9198               BToAInputs.size() == 3 ? TripleNonInputIdx : OneInput;
9199           FixFlippedInputs(BPinnedIdx, BDWord, BToBInputs);
9200         } else {
9201           assert(NumFlippedAToBInputs != 0 && "Impossible given predicates!");
9202           int APinnedIdx =
9203               AToAInputs.size() == 3 ? TripleNonInputIdx : OneInput;
9204           FixFlippedInputs(APinnedIdx, ADWord, AToBInputs);
9205         }
9206       }
9207     }
9208
9209     int PSHUFDMask[] = {0, 1, 2, 3};
9210     PSHUFDMask[ADWord] = BDWord;
9211     PSHUFDMask[BDWord] = ADWord;
9212     V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
9213                     DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
9214                                 DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V),
9215                                 getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
9216
9217     // Adjust the mask to match the new locations of A and B.
9218     for (int &M : Mask)
9219       if (M != -1 && M/2 == ADWord)
9220         M = 2 * BDWord + M % 2;
9221       else if (M != -1 && M/2 == BDWord)
9222         M = 2 * ADWord + M % 2;
9223
9224     // Recurse back into this routine to re-compute state now that this isn't
9225     // a 3 and 1 problem.
9226     return DAG.getVectorShuffle(MVT::v8i16, DL, V, DAG.getUNDEF(MVT::v8i16),
9227                                 Mask);
9228   };
9229   if ((NumLToL == 3 && NumHToL == 1) || (NumLToL == 1 && NumHToL == 3))
9230     return balanceSides(LToLInputs, HToLInputs, HToHInputs, LToHInputs, 0, 4);
9231   else if ((NumHToH == 3 && NumLToH == 1) || (NumHToH == 1 && NumLToH == 3))
9232     return balanceSides(HToHInputs, LToHInputs, LToLInputs, HToLInputs, 4, 0);
9233
9234   // At this point there are at most two inputs to the low and high halves from
9235   // each half. That means the inputs can always be grouped into dwords and
9236   // those dwords can then be moved to the correct half with a dword shuffle.
9237   // We use at most one low and one high word shuffle to collect these paired
9238   // inputs into dwords, and finally a dword shuffle to place them.
9239   int PSHUFLMask[4] = {-1, -1, -1, -1};
9240   int PSHUFHMask[4] = {-1, -1, -1, -1};
9241   int PSHUFDMask[4] = {-1, -1, -1, -1};
9242
9243   // First fix the masks for all the inputs that are staying in their
9244   // original halves. This will then dictate the targets of the cross-half
9245   // shuffles.
9246   auto fixInPlaceInputs =
9247       [&PSHUFDMask](ArrayRef<int> InPlaceInputs, ArrayRef<int> IncomingInputs,
9248                     MutableArrayRef<int> SourceHalfMask,
9249                     MutableArrayRef<int> HalfMask, int HalfOffset) {
9250     if (InPlaceInputs.empty())
9251       return;
9252     if (InPlaceInputs.size() == 1) {
9253       SourceHalfMask[InPlaceInputs[0] - HalfOffset] =
9254           InPlaceInputs[0] - HalfOffset;
9255       PSHUFDMask[InPlaceInputs[0] / 2] = InPlaceInputs[0] / 2;
9256       return;
9257     }
9258     if (IncomingInputs.empty()) {
9259       // Just fix all of the in place inputs.
9260       for (int Input : InPlaceInputs) {
9261         SourceHalfMask[Input - HalfOffset] = Input - HalfOffset;
9262         PSHUFDMask[Input / 2] = Input / 2;
9263       }
9264       return;
9265     }
9266
9267     assert(InPlaceInputs.size() == 2 && "Cannot handle 3 or 4 inputs!");
9268     SourceHalfMask[InPlaceInputs[0] - HalfOffset] =
9269         InPlaceInputs[0] - HalfOffset;
9270     // Put the second input next to the first so that they are packed into
9271     // a dword. We find the adjacent index by toggling the low bit.
9272     int AdjIndex = InPlaceInputs[0] ^ 1;
9273     SourceHalfMask[AdjIndex - HalfOffset] = InPlaceInputs[1] - HalfOffset;
9274     std::replace(HalfMask.begin(), HalfMask.end(), InPlaceInputs[1], AdjIndex);
9275     PSHUFDMask[AdjIndex / 2] = AdjIndex / 2;
9276   };
9277   fixInPlaceInputs(LToLInputs, HToLInputs, PSHUFLMask, LoMask, 0);
9278   fixInPlaceInputs(HToHInputs, LToHInputs, PSHUFHMask, HiMask, 4);
9279
9280   // Now gather the cross-half inputs and place them into a free dword of
9281   // their target half.
9282   // FIXME: This operation could almost certainly be simplified dramatically to
9283   // look more like the 3-1 fixing operation.
9284   auto moveInputsToRightHalf = [&PSHUFDMask](
9285       MutableArrayRef<int> IncomingInputs, ArrayRef<int> ExistingInputs,
9286       MutableArrayRef<int> SourceHalfMask, MutableArrayRef<int> HalfMask,
9287       MutableArrayRef<int> FinalSourceHalfMask, int SourceOffset,
9288       int DestOffset) {
9289     auto isWordClobbered = [](ArrayRef<int> SourceHalfMask, int Word) {
9290       return SourceHalfMask[Word] != -1 && SourceHalfMask[Word] != Word;
9291     };
9292     auto isDWordClobbered = [&isWordClobbered](ArrayRef<int> SourceHalfMask,
9293                                                int Word) {
9294       int LowWord = Word & ~1;
9295       int HighWord = Word | 1;
9296       return isWordClobbered(SourceHalfMask, LowWord) ||
9297              isWordClobbered(SourceHalfMask, HighWord);
9298     };
9299
9300     if (IncomingInputs.empty())
9301       return;
9302
9303     if (ExistingInputs.empty()) {
9304       // Map any dwords with inputs from them into the right half.
9305       for (int Input : IncomingInputs) {
9306         // If the source half mask maps over the inputs, turn those into
9307         // swaps and use the swapped lane.
9308         if (isWordClobbered(SourceHalfMask, Input - SourceOffset)) {
9309           if (SourceHalfMask[SourceHalfMask[Input - SourceOffset]] == -1) {
9310             SourceHalfMask[SourceHalfMask[Input - SourceOffset]] =
9311                 Input - SourceOffset;
9312             // We have to swap the uses in our half mask in one sweep.
9313             for (int &M : HalfMask)
9314               if (M == SourceHalfMask[Input - SourceOffset] + SourceOffset)
9315                 M = Input;
9316               else if (M == Input)
9317                 M = SourceHalfMask[Input - SourceOffset] + SourceOffset;
9318           } else {
9319             assert(SourceHalfMask[SourceHalfMask[Input - SourceOffset]] ==
9320                        Input - SourceOffset &&
9321                    "Previous placement doesn't match!");
9322           }
9323           // Note that this correctly re-maps both when we do a swap and when
9324           // we observe the other side of the swap above. We rely on that to
9325           // avoid swapping the members of the input list directly.
9326           Input = SourceHalfMask[Input - SourceOffset] + SourceOffset;
9327         }
9328
9329         // Map the input's dword into the correct half.
9330         if (PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] == -1)
9331           PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] = Input / 2;
9332         else
9333           assert(PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] ==
9334                      Input / 2 &&
9335                  "Previous placement doesn't match!");
9336       }
9337
9338       // And just directly shift any other-half mask elements to be same-half
9339       // as we will have mirrored the dword containing the element into the
9340       // same position within that half.
9341       for (int &M : HalfMask)
9342         if (M >= SourceOffset && M < SourceOffset + 4) {
9343           M = M - SourceOffset + DestOffset;
9344           assert(M >= 0 && "This should never wrap below zero!");
9345         }
9346       return;
9347     }
9348
9349     // Ensure we have the input in a viable dword of its current half. This
9350     // is particularly tricky because the original position may be clobbered
9351     // by inputs being moved and *staying* in that half.
9352     if (IncomingInputs.size() == 1) {
9353       if (isWordClobbered(SourceHalfMask, IncomingInputs[0] - SourceOffset)) {
9354         int InputFixed = std::find(std::begin(SourceHalfMask),
9355                                    std::end(SourceHalfMask), -1) -
9356                          std::begin(SourceHalfMask) + SourceOffset;
9357         SourceHalfMask[InputFixed - SourceOffset] =
9358             IncomingInputs[0] - SourceOffset;
9359         std::replace(HalfMask.begin(), HalfMask.end(), IncomingInputs[0],
9360                      InputFixed);
9361         IncomingInputs[0] = InputFixed;
9362       }
9363     } else if (IncomingInputs.size() == 2) {
9364       if (IncomingInputs[0] / 2 != IncomingInputs[1] / 2 ||
9365           isDWordClobbered(SourceHalfMask, IncomingInputs[0] - SourceOffset)) {
9366         // We have two non-adjacent or clobbered inputs we need to extract from
9367         // the source half. To do this, we need to map them into some adjacent
9368         // dword slot in the source mask.
9369         int InputsFixed[2] = {IncomingInputs[0] - SourceOffset,
9370                               IncomingInputs[1] - SourceOffset};
9371
9372         // If there is a free slot in the source half mask adjacent to one of
9373         // the inputs, place the other input in it. We use (Index XOR 1) to
9374         // compute an adjacent index.
9375         if (!isWordClobbered(SourceHalfMask, InputsFixed[0]) &&
9376             SourceHalfMask[InputsFixed[0] ^ 1] == -1) {
9377           SourceHalfMask[InputsFixed[0]] = InputsFixed[0];
9378           SourceHalfMask[InputsFixed[0] ^ 1] = InputsFixed[1];
9379           InputsFixed[1] = InputsFixed[0] ^ 1;
9380         } else if (!isWordClobbered(SourceHalfMask, InputsFixed[1]) &&
9381                    SourceHalfMask[InputsFixed[1] ^ 1] == -1) {
9382           SourceHalfMask[InputsFixed[1]] = InputsFixed[1];
9383           SourceHalfMask[InputsFixed[1] ^ 1] = InputsFixed[0];
9384           InputsFixed[0] = InputsFixed[1] ^ 1;
9385         } else if (SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1)] == -1 &&
9386                    SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1) + 1] == -1) {
9387           // The two inputs are in the same DWord but it is clobbered and the
9388           // adjacent DWord isn't used at all. Move both inputs to the free
9389           // slot.
9390           SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1)] = InputsFixed[0];
9391           SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1) + 1] = InputsFixed[1];
9392           InputsFixed[0] = 2 * ((InputsFixed[0] / 2) ^ 1);
9393           InputsFixed[1] = 2 * ((InputsFixed[0] / 2) ^ 1) + 1;
9394         } else {
9395           // The only way we hit this point is if there is no clobbering
9396           // (because there are no off-half inputs to this half) and there is no
9397           // free slot adjacent to one of the inputs. In this case, we have to
9398           // swap an input with a non-input.
9399           for (int i = 0; i < 4; ++i)
9400             assert((SourceHalfMask[i] == -1 || SourceHalfMask[i] == i) &&
9401                    "We can't handle any clobbers here!");
9402           assert(InputsFixed[1] != (InputsFixed[0] ^ 1) &&
9403                  "Cannot have adjacent inputs here!");
9404
9405           SourceHalfMask[InputsFixed[0] ^ 1] = InputsFixed[1];
9406           SourceHalfMask[InputsFixed[1]] = InputsFixed[0] ^ 1;
9407
9408           // We also have to update the final source mask in this case because
9409           // it may need to undo the above swap.
9410           for (int &M : FinalSourceHalfMask)
9411             if (M == (InputsFixed[0] ^ 1) + SourceOffset)
9412               M = InputsFixed[1] + SourceOffset;
9413             else if (M == InputsFixed[1] + SourceOffset)
9414               M = (InputsFixed[0] ^ 1) + SourceOffset;
9415
9416           InputsFixed[1] = InputsFixed[0] ^ 1;
9417         }
9418
9419         // Point everything at the fixed inputs.
9420         for (int &M : HalfMask)
9421           if (M == IncomingInputs[0])
9422             M = InputsFixed[0] + SourceOffset;
9423           else if (M == IncomingInputs[1])
9424             M = InputsFixed[1] + SourceOffset;
9425
9426         IncomingInputs[0] = InputsFixed[0] + SourceOffset;
9427         IncomingInputs[1] = InputsFixed[1] + SourceOffset;
9428       }
9429     } else {
9430       llvm_unreachable("Unhandled input size!");
9431     }
9432
9433     // Now hoist the DWord down to the right half.
9434     int FreeDWord = (PSHUFDMask[DestOffset / 2] == -1 ? 0 : 1) + DestOffset / 2;
9435     assert(PSHUFDMask[FreeDWord] == -1 && "DWord not free");
9436     PSHUFDMask[FreeDWord] = IncomingInputs[0] / 2;
9437     for (int &M : HalfMask)
9438       for (int Input : IncomingInputs)
9439         if (M == Input)
9440           M = FreeDWord * 2 + Input % 2;
9441   };
9442   moveInputsToRightHalf(HToLInputs, LToLInputs, PSHUFHMask, LoMask, HiMask,
9443                         /*SourceOffset*/ 4, /*DestOffset*/ 0);
9444   moveInputsToRightHalf(LToHInputs, HToHInputs, PSHUFLMask, HiMask, LoMask,
9445                         /*SourceOffset*/ 0, /*DestOffset*/ 4);
9446
9447   // Now enact all the shuffles we've computed to move the inputs into their
9448   // target half.
9449   if (!isNoopShuffleMask(PSHUFLMask))
9450     V = DAG.getNode(X86ISD::PSHUFLW, DL, MVT::v8i16, V,
9451                     getV4X86ShuffleImm8ForMask(PSHUFLMask, DAG));
9452   if (!isNoopShuffleMask(PSHUFHMask))
9453     V = DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16, V,
9454                     getV4X86ShuffleImm8ForMask(PSHUFHMask, DAG));
9455   if (!isNoopShuffleMask(PSHUFDMask))
9456     V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
9457                     DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
9458                                 DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V),
9459                                 getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
9460
9461   // At this point, each half should contain all its inputs, and we can then
9462   // just shuffle them into their final position.
9463   assert(std::count_if(LoMask.begin(), LoMask.end(),
9464                        [](int M) { return M >= 4; }) == 0 &&
9465          "Failed to lift all the high half inputs to the low mask!");
9466   assert(std::count_if(HiMask.begin(), HiMask.end(),
9467                        [](int M) { return M >= 0 && M < 4; }) == 0 &&
9468          "Failed to lift all the low half inputs to the high mask!");
9469
9470   // Do a half shuffle for the low mask.
9471   if (!isNoopShuffleMask(LoMask))
9472     V = DAG.getNode(X86ISD::PSHUFLW, DL, MVT::v8i16, V,
9473                     getV4X86ShuffleImm8ForMask(LoMask, DAG));
9474
9475   // Do a half shuffle with the high mask after shifting its values down.
9476   for (int &M : HiMask)
9477     if (M >= 0)
9478       M -= 4;
9479   if (!isNoopShuffleMask(HiMask))
9480     V = DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16, V,
9481                     getV4X86ShuffleImm8ForMask(HiMask, DAG));
9482
9483   return V;
9484 }
9485
9486 /// \brief Detect whether the mask pattern should be lowered through
9487 /// interleaving.
9488 ///
9489 /// This essentially tests whether viewing the mask as an interleaving of two
9490 /// sub-sequences reduces the cross-input traffic of a blend operation. If so,
9491 /// lowering it through interleaving is a significantly better strategy.
9492 static bool shouldLowerAsInterleaving(ArrayRef<int> Mask) {
9493   int NumEvenInputs[2] = {0, 0};
9494   int NumOddInputs[2] = {0, 0};
9495   int NumLoInputs[2] = {0, 0};
9496   int NumHiInputs[2] = {0, 0};
9497   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
9498     if (Mask[i] < 0)
9499       continue;
9500
9501     int InputIdx = Mask[i] >= Size;
9502
9503     if (i < Size / 2)
9504       ++NumLoInputs[InputIdx];
9505     else
9506       ++NumHiInputs[InputIdx];
9507
9508     if ((i % 2) == 0)
9509       ++NumEvenInputs[InputIdx];
9510     else
9511       ++NumOddInputs[InputIdx];
9512   }
9513
9514   // The minimum number of cross-input results for both the interleaved and
9515   // split cases. If interleaving results in fewer cross-input results, return
9516   // true.
9517   int InterleavedCrosses = std::min(NumEvenInputs[1] + NumOddInputs[0],
9518                                     NumEvenInputs[0] + NumOddInputs[1]);
9519   int SplitCrosses = std::min(NumLoInputs[1] + NumHiInputs[0],
9520                               NumLoInputs[0] + NumHiInputs[1]);
9521   return InterleavedCrosses < SplitCrosses;
9522 }
9523
9524 /// \brief Blend two v8i16 vectors using a naive unpack strategy.
9525 ///
9526 /// This strategy only works when the inputs from each vector fit into a single
9527 /// half of that vector, and generally there are not so many inputs as to leave
9528 /// the in-place shuffles required highly constrained (and thus expensive). It
9529 /// shifts all the inputs into a single side of both input vectors and then
9530 /// uses an unpack to interleave these inputs in a single vector. At that
9531 /// point, we will fall back on the generic single input shuffle lowering.
9532 static SDValue lowerV8I16BasicBlendVectorShuffle(SDLoc DL, SDValue V1,
9533                                                  SDValue V2,
9534                                                  MutableArrayRef<int> Mask,
9535                                                  const X86Subtarget *Subtarget,
9536                                                  SelectionDAG &DAG) {
9537   assert(V1.getSimpleValueType() == MVT::v8i16 && "Bad input type!");
9538   assert(V2.getSimpleValueType() == MVT::v8i16 && "Bad input type!");
9539   SmallVector<int, 3> LoV1Inputs, HiV1Inputs, LoV2Inputs, HiV2Inputs;
9540   for (int i = 0; i < 8; ++i)
9541     if (Mask[i] >= 0 && Mask[i] < 4)
9542       LoV1Inputs.push_back(i);
9543     else if (Mask[i] >= 4 && Mask[i] < 8)
9544       HiV1Inputs.push_back(i);
9545     else if (Mask[i] >= 8 && Mask[i] < 12)
9546       LoV2Inputs.push_back(i);
9547     else if (Mask[i] >= 12)
9548       HiV2Inputs.push_back(i);
9549
9550   int NumV1Inputs = LoV1Inputs.size() + HiV1Inputs.size();
9551   int NumV2Inputs = LoV2Inputs.size() + HiV2Inputs.size();
9552   (void)NumV1Inputs;
9553   (void)NumV2Inputs;
9554   assert(NumV1Inputs > 0 && NumV1Inputs <= 3 && "At most 3 inputs supported");
9555   assert(NumV2Inputs > 0 && NumV2Inputs <= 3 && "At most 3 inputs supported");
9556   assert(NumV1Inputs + NumV2Inputs <= 4 && "At most 4 combined inputs");
9557
9558   bool MergeFromLo = LoV1Inputs.size() + LoV2Inputs.size() >=
9559                      HiV1Inputs.size() + HiV2Inputs.size();
9560
9561   auto moveInputsToHalf = [&](SDValue V, ArrayRef<int> LoInputs,
9562                               ArrayRef<int> HiInputs, bool MoveToLo,
9563                               int MaskOffset) {
9564     ArrayRef<int> GoodInputs = MoveToLo ? LoInputs : HiInputs;
9565     ArrayRef<int> BadInputs = MoveToLo ? HiInputs : LoInputs;
9566     if (BadInputs.empty())
9567       return V;
9568
9569     int MoveMask[] = {-1, -1, -1, -1, -1, -1, -1, -1};
9570     int MoveOffset = MoveToLo ? 0 : 4;
9571
9572     if (GoodInputs.empty()) {
9573       for (int BadInput : BadInputs) {
9574         MoveMask[Mask[BadInput] % 4 + MoveOffset] = Mask[BadInput] - MaskOffset;
9575         Mask[BadInput] = Mask[BadInput] % 4 + MoveOffset + MaskOffset;
9576       }
9577     } else {
9578       if (GoodInputs.size() == 2) {
9579         // If the low inputs are spread across two dwords, pack them into
9580         // a single dword.
9581         MoveMask[MoveOffset] = Mask[GoodInputs[0]] - MaskOffset;
9582         MoveMask[MoveOffset + 1] = Mask[GoodInputs[1]] - MaskOffset;
9583         Mask[GoodInputs[0]] = MoveOffset + MaskOffset;
9584         Mask[GoodInputs[1]] = MoveOffset + 1 + MaskOffset;
9585       } else {
9586         // Otherwise pin the good inputs.
9587         for (int GoodInput : GoodInputs)
9588           MoveMask[Mask[GoodInput] - MaskOffset] = Mask[GoodInput] - MaskOffset;
9589       }
9590
9591       if (BadInputs.size() == 2) {
9592         // If we have two bad inputs then there may be either one or two good
9593         // inputs fixed in place. Find a fixed input, and then find the *other*
9594         // two adjacent indices by using modular arithmetic.
9595         int GoodMaskIdx =
9596             std::find_if(std::begin(MoveMask) + MoveOffset, std::end(MoveMask),
9597                          [](int M) { return M >= 0; }) -
9598             std::begin(MoveMask);
9599         int MoveMaskIdx =
9600             ((((GoodMaskIdx - MoveOffset) & ~1) + 2) % 4) + MoveOffset;
9601         assert(MoveMask[MoveMaskIdx] == -1 && "Expected empty slot");
9602         assert(MoveMask[MoveMaskIdx + 1] == -1 && "Expected empty slot");
9603         MoveMask[MoveMaskIdx] = Mask[BadInputs[0]] - MaskOffset;
9604         MoveMask[MoveMaskIdx + 1] = Mask[BadInputs[1]] - MaskOffset;
9605         Mask[BadInputs[0]] = MoveMaskIdx + MaskOffset;
9606         Mask[BadInputs[1]] = MoveMaskIdx + 1 + MaskOffset;
9607       } else {
9608         assert(BadInputs.size() == 1 && "All sizes handled");
9609         int MoveMaskIdx = std::find(std::begin(MoveMask) + MoveOffset,
9610                                     std::end(MoveMask), -1) -
9611                           std::begin(MoveMask);
9612         MoveMask[MoveMaskIdx] = Mask[BadInputs[0]] - MaskOffset;
9613         Mask[BadInputs[0]] = MoveMaskIdx + MaskOffset;
9614       }
9615     }
9616
9617     return DAG.getVectorShuffle(MVT::v8i16, DL, V, DAG.getUNDEF(MVT::v8i16),
9618                                 MoveMask);
9619   };
9620   V1 = moveInputsToHalf(V1, LoV1Inputs, HiV1Inputs, MergeFromLo,
9621                         /*MaskOffset*/ 0);
9622   V2 = moveInputsToHalf(V2, LoV2Inputs, HiV2Inputs, MergeFromLo,
9623                         /*MaskOffset*/ 8);
9624
9625   // FIXME: Select an interleaving of the merge of V1 and V2 that minimizes
9626   // cross-half traffic in the final shuffle.
9627
9628   // Munge the mask to be a single-input mask after the unpack merges the
9629   // results.
9630   for (int &M : Mask)
9631     if (M != -1)
9632       M = 2 * (M % 4) + (M / 8);
9633
9634   return DAG.getVectorShuffle(
9635       MVT::v8i16, DL, DAG.getNode(MergeFromLo ? X86ISD::UNPCKL : X86ISD::UNPCKH,
9636                                   DL, MVT::v8i16, V1, V2),
9637       DAG.getUNDEF(MVT::v8i16), Mask);
9638 }
9639
9640 /// \brief Helper to form a PSHUFB-based shuffle+blend.
9641 static SDValue lowerVectorShuffleAsPSHUFB(SDLoc DL, MVT VT, SDValue V1,
9642                                           SDValue V2, ArrayRef<int> Mask,
9643                                           SelectionDAG &DAG, bool &V1InUse,
9644                                           bool &V2InUse) {
9645   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
9646   SDValue V1Mask[16];
9647   SDValue V2Mask[16];
9648   V1InUse = false;
9649   V2InUse = false;
9650
9651   int Size = Mask.size();
9652   int Scale = 16 / Size;
9653   for (int i = 0; i < 16; ++i) {
9654     if (Mask[i / Scale] == -1) {
9655       V1Mask[i] = V2Mask[i] = DAG.getUNDEF(MVT::i8);
9656     } else {
9657       const int ZeroMask = 0x80;
9658       int V1Idx = Mask[i / Scale] < Size ? Mask[i / Scale] * Scale + i % Scale
9659                                           : ZeroMask;
9660       int V2Idx = Mask[i / Scale] < Size
9661                       ? ZeroMask
9662                       : (Mask[i / Scale] - Size) * Scale + i % Scale;
9663       if (Zeroable[i / Scale])
9664         V1Idx = V2Idx = ZeroMask;
9665       V1Mask[i] = DAG.getConstant(V1Idx, MVT::i8);
9666       V2Mask[i] = DAG.getConstant(V2Idx, MVT::i8);
9667       V1InUse |= (ZeroMask != V1Idx);
9668       V2InUse |= (ZeroMask != V2Idx);
9669     }
9670   }
9671
9672   if (V1InUse)
9673     V1 = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8,
9674                      DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, V1),
9675                      DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, V1Mask));
9676   if (V2InUse)
9677     V2 = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8,
9678                      DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, V2),
9679                      DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, V2Mask));
9680
9681   // If we need shuffled inputs from both, blend the two.
9682   SDValue V;
9683   if (V1InUse && V2InUse)
9684     V = DAG.getNode(ISD::OR, DL, MVT::v16i8, V1, V2);
9685   else
9686     V = V1InUse ? V1 : V2;
9687
9688   // Cast the result back to the correct type.
9689   return DAG.getNode(ISD::BITCAST, DL, VT, V);
9690 }
9691
9692 /// \brief Generic lowering of 8-lane i16 shuffles.
9693 ///
9694 /// This handles both single-input shuffles and combined shuffle/blends with
9695 /// two inputs. The single input shuffles are immediately delegated to
9696 /// a dedicated lowering routine.
9697 ///
9698 /// The blends are lowered in one of three fundamental ways. If there are few
9699 /// enough inputs, it delegates to a basic UNPCK-based strategy. If the shuffle
9700 /// of the input is significantly cheaper when lowered as an interleaving of
9701 /// the two inputs, try to interleave them. Otherwise, blend the low and high
9702 /// halves of the inputs separately (making them have relatively few inputs)
9703 /// and then concatenate them.
9704 static SDValue lowerV8I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9705                                        const X86Subtarget *Subtarget,
9706                                        SelectionDAG &DAG) {
9707   SDLoc DL(Op);
9708   assert(Op.getSimpleValueType() == MVT::v8i16 && "Bad shuffle type!");
9709   assert(V1.getSimpleValueType() == MVT::v8i16 && "Bad operand type!");
9710   assert(V2.getSimpleValueType() == MVT::v8i16 && "Bad operand type!");
9711   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9712   ArrayRef<int> OrigMask = SVOp->getMask();
9713   int MaskStorage[8] = {OrigMask[0], OrigMask[1], OrigMask[2], OrigMask[3],
9714                         OrigMask[4], OrigMask[5], OrigMask[6], OrigMask[7]};
9715   MutableArrayRef<int> Mask(MaskStorage);
9716
9717   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
9718
9719   // Whenever we can lower this as a zext, that instruction is strictly faster
9720   // than any alternative.
9721   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(
9722           DL, MVT::v8i16, V1, V2, OrigMask, Subtarget, DAG))
9723     return ZExt;
9724
9725   auto isV1 = [](int M) { return M >= 0 && M < 8; };
9726   auto isV2 = [](int M) { return M >= 8; };
9727
9728   int NumV1Inputs = std::count_if(Mask.begin(), Mask.end(), isV1);
9729   int NumV2Inputs = std::count_if(Mask.begin(), Mask.end(), isV2);
9730
9731   if (NumV2Inputs == 0)
9732     return lowerV8I16SingleInputVectorShuffle(DL, V1, Mask, Subtarget, DAG);
9733
9734   assert(NumV1Inputs > 0 && "All single-input shuffles should be canonicalized "
9735                             "to be V1-input shuffles.");
9736
9737   // Try to use shift instructions.
9738   if (SDValue Shift =
9739           lowerVectorShuffleAsShift(DL, MVT::v8i16, V1, V2, Mask, DAG))
9740     return Shift;
9741
9742   // There are special ways we can lower some single-element blends.
9743   if (NumV2Inputs == 1)
9744     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v8i16, DL, V1, V2,
9745                                                          Mask, Subtarget, DAG))
9746       return V;
9747
9748   // We have different paths for blend lowering, but they all must use the
9749   // *exact* same predicate.
9750   bool IsBlendSupported = Subtarget->hasSSE41();
9751   if (IsBlendSupported)
9752     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8i16, V1, V2, Mask,
9753                                                   Subtarget, DAG))
9754       return Blend;
9755
9756   if (SDValue Masked =
9757           lowerVectorShuffleAsBitMask(DL, MVT::v8i16, V1, V2, Mask, DAG))
9758     return Masked;
9759
9760   // Use dedicated unpack instructions for masks that match their pattern.
9761   if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 1, 9, 2, 10, 3, 11))
9762     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, V1, V2);
9763   if (isShuffleEquivalent(V1, V2, Mask, 4, 12, 5, 13, 6, 14, 7, 15))
9764     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i16, V1, V2);
9765
9766   // Try to use byte rotation instructions.
9767   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9768           DL, MVT::v8i16, V1, V2, Mask, Subtarget, DAG))
9769     return Rotate;
9770
9771   if (SDValue BitBlend =
9772           lowerVectorShuffleAsBitBlend(DL, MVT::v8i16, V1, V2, Mask, DAG))
9773     return BitBlend;
9774
9775   if (NumV1Inputs + NumV2Inputs <= 4)
9776     return lowerV8I16BasicBlendVectorShuffle(DL, V1, V2, Mask, Subtarget, DAG);
9777
9778   // Check whether an interleaving lowering is likely to be more efficient.
9779   // This isn't perfect but it is a strong heuristic that tends to work well on
9780   // the kinds of shuffles that show up in practice.
9781   //
9782   // FIXME: Handle 1x, 2x, and 4x interleaving.
9783   if (shouldLowerAsInterleaving(Mask)) {
9784     // FIXME: Figure out whether we should pack these into the low or high
9785     // halves.
9786
9787     int EMask[8], OMask[8];
9788     for (int i = 0; i < 4; ++i) {
9789       EMask[i] = Mask[2*i];
9790       OMask[i] = Mask[2*i + 1];
9791       EMask[i + 4] = -1;
9792       OMask[i + 4] = -1;
9793     }
9794
9795     SDValue Evens = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, EMask);
9796     SDValue Odds = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, OMask);
9797
9798     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, Evens, Odds);
9799   }
9800
9801   // Try to lower by permuting the inputs into an unpack instruction unless we
9802   // have direct support for blending.
9803   if (!IsBlendSupported) {
9804     if (SDValue Unpack =
9805             lowerVectorShuffleAsUnpack(MVT::v8i16, DL, V1, V2, Mask, DAG))
9806       return Unpack;
9807
9808     // If we can use PSHUFB, that will be better as it can both shuffle and set
9809     // up an efficient blend.
9810     if (Subtarget->hasSSSE3()) {
9811       bool V1InUse, V2InUse;
9812       return lowerVectorShuffleAsPSHUFB(DL, MVT::v8i16, V1, V2, Mask, DAG,
9813                                         V1InUse, V2InUse);
9814     }
9815   }
9816
9817   // We can always bit-blend if we have to so the fallback strategy is to
9818   // decompose into single-input permutes and blends.
9819   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8i16, V1, V2,
9820                                                       Mask, DAG);
9821 }
9822
9823 /// \brief Check whether a compaction lowering can be done by dropping even
9824 /// elements and compute how many times even elements must be dropped.
9825 ///
9826 /// This handles shuffles which take every Nth element where N is a power of
9827 /// two. Example shuffle masks:
9828 ///
9829 ///  N = 1:  0,  2,  4,  6,  8, 10, 12, 14,  0,  2,  4,  6,  8, 10, 12, 14
9830 ///  N = 1:  0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30
9831 ///  N = 2:  0,  4,  8, 12,  0,  4,  8, 12,  0,  4,  8, 12,  0,  4,  8, 12
9832 ///  N = 2:  0,  4,  8, 12, 16, 20, 24, 28,  0,  4,  8, 12, 16, 20, 24, 28
9833 ///  N = 3:  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8
9834 ///  N = 3:  0,  8, 16, 24,  0,  8, 16, 24,  0,  8, 16, 24,  0,  8, 16, 24
9835 ///
9836 /// Any of these lanes can of course be undef.
9837 ///
9838 /// This routine only supports N <= 3.
9839 /// FIXME: Evaluate whether either AVX or AVX-512 have any opportunities here
9840 /// for larger N.
9841 ///
9842 /// \returns N above, or the number of times even elements must be dropped if
9843 /// there is such a number. Otherwise returns zero.
9844 static int canLowerByDroppingEvenElements(ArrayRef<int> Mask) {
9845   // Figure out whether we're looping over two inputs or just one.
9846   bool IsSingleInput = isSingleInputShuffleMask(Mask);
9847
9848   // The modulus for the shuffle vector entries is based on whether this is
9849   // a single input or not.
9850   int ShuffleModulus = Mask.size() * (IsSingleInput ? 1 : 2);
9851   assert(isPowerOf2_32((uint32_t)ShuffleModulus) &&
9852          "We should only be called with masks with a power-of-2 size!");
9853
9854   uint64_t ModMask = (uint64_t)ShuffleModulus - 1;
9855
9856   // We track whether the input is viable for all power-of-2 strides 2^1, 2^2,
9857   // and 2^3 simultaneously. This is because we may have ambiguity with
9858   // partially undef inputs.
9859   bool ViableForN[3] = {true, true, true};
9860
9861   for (int i = 0, e = Mask.size(); i < e; ++i) {
9862     // Ignore undef lanes, we'll optimistically collapse them to the pattern we
9863     // want.
9864     if (Mask[i] == -1)
9865       continue;
9866
9867     bool IsAnyViable = false;
9868     for (unsigned j = 0; j != array_lengthof(ViableForN); ++j)
9869       if (ViableForN[j]) {
9870         uint64_t N = j + 1;
9871
9872         // The shuffle mask must be equal to (i * 2^N) % M.
9873         if ((uint64_t)Mask[i] == (((uint64_t)i << N) & ModMask))
9874           IsAnyViable = true;
9875         else
9876           ViableForN[j] = false;
9877       }
9878     // Early exit if we exhaust the possible powers of two.
9879     if (!IsAnyViable)
9880       break;
9881   }
9882
9883   for (unsigned j = 0; j != array_lengthof(ViableForN); ++j)
9884     if (ViableForN[j])
9885       return j + 1;
9886
9887   // Return 0 as there is no viable power of two.
9888   return 0;
9889 }
9890
9891 /// \brief Generic lowering of v16i8 shuffles.
9892 ///
9893 /// This is a hybrid strategy to lower v16i8 vectors. It first attempts to
9894 /// detect any complexity reducing interleaving. If that doesn't help, it uses
9895 /// UNPCK to spread the i8 elements across two i16-element vectors, and uses
9896 /// the existing lowering for v8i16 blends on each half, finally PACK-ing them
9897 /// back together.
9898 static SDValue lowerV16I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9899                                        const X86Subtarget *Subtarget,
9900                                        SelectionDAG &DAG) {
9901   SDLoc DL(Op);
9902   assert(Op.getSimpleValueType() == MVT::v16i8 && "Bad shuffle type!");
9903   assert(V1.getSimpleValueType() == MVT::v16i8 && "Bad operand type!");
9904   assert(V2.getSimpleValueType() == MVT::v16i8 && "Bad operand type!");
9905   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9906   ArrayRef<int> Mask = SVOp->getMask();
9907   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
9908
9909   // Try to use shift instructions.
9910   if (SDValue Shift =
9911           lowerVectorShuffleAsShift(DL, MVT::v16i8, V1, V2, Mask, DAG))
9912     return Shift;
9913
9914   // Try to use byte rotation instructions.
9915   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9916           DL, MVT::v16i8, V1, V2, Mask, Subtarget, DAG))
9917     return Rotate;
9918
9919   // Try to use a zext lowering.
9920   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(
9921           DL, MVT::v16i8, V1, V2, Mask, Subtarget, DAG))
9922     return ZExt;
9923
9924   int NumV2Elements =
9925       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 16; });
9926
9927   // For single-input shuffles, there are some nicer lowering tricks we can use.
9928   if (NumV2Elements == 0) {
9929     // Check for being able to broadcast a single element.
9930     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v16i8, DL, V1,
9931                                                           Mask, Subtarget, DAG))
9932       return Broadcast;
9933
9934     // Check whether we can widen this to an i16 shuffle by duplicating bytes.
9935     // Notably, this handles splat and partial-splat shuffles more efficiently.
9936     // However, it only makes sense if the pre-duplication shuffle simplifies
9937     // things significantly. Currently, this means we need to be able to
9938     // express the pre-duplication shuffle as an i16 shuffle.
9939     //
9940     // FIXME: We should check for other patterns which can be widened into an
9941     // i16 shuffle as well.
9942     auto canWidenViaDuplication = [](ArrayRef<int> Mask) {
9943       for (int i = 0; i < 16; i += 2)
9944         if (Mask[i] != -1 && Mask[i + 1] != -1 && Mask[i] != Mask[i + 1])
9945           return false;
9946
9947       return true;
9948     };
9949     auto tryToWidenViaDuplication = [&]() -> SDValue {
9950       if (!canWidenViaDuplication(Mask))
9951         return SDValue();
9952       SmallVector<int, 4> LoInputs;
9953       std::copy_if(Mask.begin(), Mask.end(), std::back_inserter(LoInputs),
9954                    [](int M) { return M >= 0 && M < 8; });
9955       std::sort(LoInputs.begin(), LoInputs.end());
9956       LoInputs.erase(std::unique(LoInputs.begin(), LoInputs.end()),
9957                      LoInputs.end());
9958       SmallVector<int, 4> HiInputs;
9959       std::copy_if(Mask.begin(), Mask.end(), std::back_inserter(HiInputs),
9960                    [](int M) { return M >= 8; });
9961       std::sort(HiInputs.begin(), HiInputs.end());
9962       HiInputs.erase(std::unique(HiInputs.begin(), HiInputs.end()),
9963                      HiInputs.end());
9964
9965       bool TargetLo = LoInputs.size() >= HiInputs.size();
9966       ArrayRef<int> InPlaceInputs = TargetLo ? LoInputs : HiInputs;
9967       ArrayRef<int> MovingInputs = TargetLo ? HiInputs : LoInputs;
9968
9969       int PreDupI16Shuffle[] = {-1, -1, -1, -1, -1, -1, -1, -1};
9970       SmallDenseMap<int, int, 8> LaneMap;
9971       for (int I : InPlaceInputs) {
9972         PreDupI16Shuffle[I/2] = I/2;
9973         LaneMap[I] = I;
9974       }
9975       int j = TargetLo ? 0 : 4, je = j + 4;
9976       for (int i = 0, ie = MovingInputs.size(); i < ie; ++i) {
9977         // Check if j is already a shuffle of this input. This happens when
9978         // there are two adjacent bytes after we move the low one.
9979         if (PreDupI16Shuffle[j] != MovingInputs[i] / 2) {
9980           // If we haven't yet mapped the input, search for a slot into which
9981           // we can map it.
9982           while (j < je && PreDupI16Shuffle[j] != -1)
9983             ++j;
9984
9985           if (j == je)
9986             // We can't place the inputs into a single half with a simple i16 shuffle, so bail.
9987             return SDValue();
9988
9989           // Map this input with the i16 shuffle.
9990           PreDupI16Shuffle[j] = MovingInputs[i] / 2;
9991         }
9992
9993         // Update the lane map based on the mapping we ended up with.
9994         LaneMap[MovingInputs[i]] = 2 * j + MovingInputs[i] % 2;
9995       }
9996       V1 = DAG.getNode(
9997           ISD::BITCAST, DL, MVT::v16i8,
9998           DAG.getVectorShuffle(MVT::v8i16, DL,
9999                                DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
10000                                DAG.getUNDEF(MVT::v8i16), PreDupI16Shuffle));
10001
10002       // Unpack the bytes to form the i16s that will be shuffled into place.
10003       V1 = DAG.getNode(TargetLo ? X86ISD::UNPCKL : X86ISD::UNPCKH, DL,
10004                        MVT::v16i8, V1, V1);
10005
10006       int PostDupI16Shuffle[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
10007       for (int i = 0; i < 16; ++i)
10008         if (Mask[i] != -1) {
10009           int MappedMask = LaneMap[Mask[i]] - (TargetLo ? 0 : 8);
10010           assert(MappedMask < 8 && "Invalid v8 shuffle mask!");
10011           if (PostDupI16Shuffle[i / 2] == -1)
10012             PostDupI16Shuffle[i / 2] = MappedMask;
10013           else
10014             assert(PostDupI16Shuffle[i / 2] == MappedMask &&
10015                    "Conflicting entrties in the original shuffle!");
10016         }
10017       return DAG.getNode(
10018           ISD::BITCAST, DL, MVT::v16i8,
10019           DAG.getVectorShuffle(MVT::v8i16, DL,
10020                                DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
10021                                DAG.getUNDEF(MVT::v8i16), PostDupI16Shuffle));
10022     };
10023     if (SDValue V = tryToWidenViaDuplication())
10024       return V;
10025   }
10026
10027   // Use dedicated unpack instructions for masks that match their pattern.
10028   if (isShuffleEquivalent(V1, V2, Mask,
10029                           0,  16,  1, 17,  2, 18,  3, 19,
10030                           4,  20,  5, 21,  6, 22,  7, 23))
10031     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V1, V2);
10032   if (isShuffleEquivalent(V1, V2, Mask,
10033                           8,  24,  9, 25, 10, 26, 11, 27,
10034                           12, 28, 13, 29, 14, 30, 15, 31))
10035     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V1, V2);
10036
10037   // Check for SSSE3 which lets us lower all v16i8 shuffles much more directly
10038   // with PSHUFB. It is important to do this before we attempt to generate any
10039   // blends but after all of the single-input lowerings. If the single input
10040   // lowerings can find an instruction sequence that is faster than a PSHUFB, we
10041   // want to preserve that and we can DAG combine any longer sequences into
10042   // a PSHUFB in the end. But once we start blending from multiple inputs,
10043   // the complexity of DAG combining bad patterns back into PSHUFB is too high,
10044   // and there are *very* few patterns that would actually be faster than the
10045   // PSHUFB approach because of its ability to zero lanes.
10046   //
10047   // FIXME: The only exceptions to the above are blends which are exact
10048   // interleavings with direct instructions supporting them. We currently don't
10049   // handle those well here.
10050   if (Subtarget->hasSSSE3()) {
10051     bool V1InUse = false;
10052     bool V2InUse = false;
10053
10054     SDValue PSHUFB = lowerVectorShuffleAsPSHUFB(DL, MVT::v16i8, V1, V2, Mask,
10055                                                 DAG, V1InUse, V2InUse);
10056
10057     // If both V1 and V2 are in use and we can use a direct blend or an unpack,
10058     // do so. This avoids using them to handle blends-with-zero which is
10059     // important as a single pshufb is significantly faster for that.
10060     if (V1InUse && V2InUse) {
10061       if (Subtarget->hasSSE41())
10062         if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v16i8, V1, V2,
10063                                                       Mask, Subtarget, DAG))
10064           return Blend;
10065
10066       // We can use an unpack to do the blending rather than an or in some
10067       // cases. Even though the or may be (very minorly) more efficient, we
10068       // preference this lowering because there are common cases where part of
10069       // the complexity of the shuffles goes away when we do the final blend as
10070       // an unpack.
10071       // FIXME: It might be worth trying to detect if the unpack-feeding
10072       // shuffles will both be pshufb, in which case we shouldn't bother with
10073       // this.
10074       if (SDValue Unpack =
10075               lowerVectorShuffleAsUnpack(MVT::v16i8, DL, V1, V2, Mask, DAG))
10076         return Unpack;
10077     }
10078
10079     return PSHUFB;
10080   }
10081
10082   // There are special ways we can lower some single-element blends.
10083   if (NumV2Elements == 1)
10084     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v16i8, DL, V1, V2,
10085                                                          Mask, Subtarget, DAG))
10086       return V;
10087
10088   if (SDValue BitBlend =
10089           lowerVectorShuffleAsBitBlend(DL, MVT::v16i8, V1, V2, Mask, DAG))
10090     return BitBlend;
10091
10092   // Check whether a compaction lowering can be done. This handles shuffles
10093   // which take every Nth element for some even N. See the helper function for
10094   // details.
10095   //
10096   // We special case these as they can be particularly efficiently handled with
10097   // the PACKUSB instruction on x86 and they show up in common patterns of
10098   // rearranging bytes to truncate wide elements.
10099   if (int NumEvenDrops = canLowerByDroppingEvenElements(Mask)) {
10100     // NumEvenDrops is the power of two stride of the elements. Another way of
10101     // thinking about it is that we need to drop the even elements this many
10102     // times to get the original input.
10103     bool IsSingleInput = isSingleInputShuffleMask(Mask);
10104
10105     // First we need to zero all the dropped bytes.
10106     assert(NumEvenDrops <= 3 &&
10107            "No support for dropping even elements more than 3 times.");
10108     // We use the mask type to pick which bytes are preserved based on how many
10109     // elements are dropped.
10110     MVT MaskVTs[] = { MVT::v8i16, MVT::v4i32, MVT::v2i64 };
10111     SDValue ByteClearMask =
10112         DAG.getNode(ISD::BITCAST, DL, MVT::v16i8,
10113                     DAG.getConstant(0xFF, MaskVTs[NumEvenDrops - 1]));
10114     V1 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V1, ByteClearMask);
10115     if (!IsSingleInput)
10116       V2 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V2, ByteClearMask);
10117
10118     // Now pack things back together.
10119     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1);
10120     V2 = IsSingleInput ? V1 : DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V2);
10121     SDValue Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, V1, V2);
10122     for (int i = 1; i < NumEvenDrops; ++i) {
10123       Result = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, Result);
10124       Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, Result, Result);
10125     }
10126
10127     return Result;
10128   }
10129
10130   // Handle multi-input cases by blending single-input shuffles.
10131   if (NumV2Elements > 0)
10132     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v16i8, V1, V2,
10133                                                       Mask, DAG);
10134
10135   // The fallback path for single-input shuffles widens this into two v8i16
10136   // vectors with unpacks, shuffles those, and then pulls them back together
10137   // with a pack.
10138   SDValue V = V1;
10139
10140   int LoBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
10141   int HiBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
10142   for (int i = 0; i < 16; ++i)
10143     if (Mask[i] >= 0)
10144       (i < 8 ? LoBlendMask[i] : HiBlendMask[i % 8]) = Mask[i];
10145
10146   SDValue Zero = getZeroVector(MVT::v8i16, Subtarget, DAG, DL);
10147
10148   SDValue VLoHalf, VHiHalf;
10149   // Check if any of the odd lanes in the v16i8 are used. If not, we can mask
10150   // them out and avoid using UNPCK{L,H} to extract the elements of V as
10151   // i16s.
10152   if (std::none_of(std::begin(LoBlendMask), std::end(LoBlendMask),
10153                    [](int M) { return M >= 0 && M % 2 == 1; }) &&
10154       std::none_of(std::begin(HiBlendMask), std::end(HiBlendMask),
10155                    [](int M) { return M >= 0 && M % 2 == 1; })) {
10156     // Use a mask to drop the high bytes.
10157     VLoHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
10158     VLoHalf = DAG.getNode(ISD::AND, DL, MVT::v8i16, VLoHalf,
10159                      DAG.getConstant(0x00FF, MVT::v8i16));
10160
10161     // This will be a single vector shuffle instead of a blend so nuke VHiHalf.
10162     VHiHalf = DAG.getUNDEF(MVT::v8i16);
10163
10164     // Squash the masks to point directly into VLoHalf.
10165     for (int &M : LoBlendMask)
10166       if (M >= 0)
10167         M /= 2;
10168     for (int &M : HiBlendMask)
10169       if (M >= 0)
10170         M /= 2;
10171   } else {
10172     // Otherwise just unpack the low half of V into VLoHalf and the high half into
10173     // VHiHalf so that we can blend them as i16s.
10174     VLoHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
10175                      DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V, Zero));
10176     VHiHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
10177                      DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V, Zero));
10178   }
10179
10180   SDValue LoV = DAG.getVectorShuffle(MVT::v8i16, DL, VLoHalf, VHiHalf, LoBlendMask);
10181   SDValue HiV = DAG.getVectorShuffle(MVT::v8i16, DL, VLoHalf, VHiHalf, HiBlendMask);
10182
10183   return DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, LoV, HiV);
10184 }
10185
10186 /// \brief Dispatching routine to lower various 128-bit x86 vector shuffles.
10187 ///
10188 /// This routine breaks down the specific type of 128-bit shuffle and
10189 /// dispatches to the lowering routines accordingly.
10190 static SDValue lower128BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10191                                         MVT VT, const X86Subtarget *Subtarget,
10192                                         SelectionDAG &DAG) {
10193   switch (VT.SimpleTy) {
10194   case MVT::v2i64:
10195     return lowerV2I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10196   case MVT::v2f64:
10197     return lowerV2F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10198   case MVT::v4i32:
10199     return lowerV4I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10200   case MVT::v4f32:
10201     return lowerV4F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10202   case MVT::v8i16:
10203     return lowerV8I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
10204   case MVT::v16i8:
10205     return lowerV16I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
10206
10207   default:
10208     llvm_unreachable("Unimplemented!");
10209   }
10210 }
10211
10212 /// \brief Helper function to test whether a shuffle mask could be
10213 /// simplified by widening the elements being shuffled.
10214 ///
10215 /// Appends the mask for wider elements in WidenedMask if valid. Otherwise
10216 /// leaves it in an unspecified state.
10217 ///
10218 /// NOTE: This must handle normal vector shuffle masks and *target* vector
10219 /// shuffle masks. The latter have the special property of a '-2' representing
10220 /// a zero-ed lane of a vector.
10221 static bool canWidenShuffleElements(ArrayRef<int> Mask,
10222                                     SmallVectorImpl<int> &WidenedMask) {
10223   for (int i = 0, Size = Mask.size(); i < Size; i += 2) {
10224     // If both elements are undef, its trivial.
10225     if (Mask[i] == SM_SentinelUndef && Mask[i + 1] == SM_SentinelUndef) {
10226       WidenedMask.push_back(SM_SentinelUndef);
10227       continue;
10228     }
10229
10230     // Check for an undef mask and a mask value properly aligned to fit with
10231     // a pair of values. If we find such a case, use the non-undef mask's value.
10232     if (Mask[i] == SM_SentinelUndef && Mask[i + 1] >= 0 && Mask[i + 1] % 2 == 1) {
10233       WidenedMask.push_back(Mask[i + 1] / 2);
10234       continue;
10235     }
10236     if (Mask[i + 1] == SM_SentinelUndef && Mask[i] >= 0 && Mask[i] % 2 == 0) {
10237       WidenedMask.push_back(Mask[i] / 2);
10238       continue;
10239     }
10240
10241     // When zeroing, we need to spread the zeroing across both lanes to widen.
10242     if (Mask[i] == SM_SentinelZero || Mask[i + 1] == SM_SentinelZero) {
10243       if ((Mask[i] == SM_SentinelZero || Mask[i] == SM_SentinelUndef) &&
10244           (Mask[i + 1] == SM_SentinelZero || Mask[i + 1] == SM_SentinelUndef)) {
10245         WidenedMask.push_back(SM_SentinelZero);
10246         continue;
10247       }
10248       return false;
10249     }
10250
10251     // Finally check if the two mask values are adjacent and aligned with
10252     // a pair.
10253     if (Mask[i] != SM_SentinelUndef && Mask[i] % 2 == 0 && Mask[i] + 1 == Mask[i + 1]) {
10254       WidenedMask.push_back(Mask[i] / 2);
10255       continue;
10256     }
10257
10258     // Otherwise we can't safely widen the elements used in this shuffle.
10259     return false;
10260   }
10261   assert(WidenedMask.size() == Mask.size() / 2 &&
10262          "Incorrect size of mask after widening the elements!");
10263
10264   return true;
10265 }
10266
10267 /// \brief Generic routine to split vector shuffle into half-sized shuffles.
10268 ///
10269 /// This routine just extracts two subvectors, shuffles them independently, and
10270 /// then concatenates them back together. This should work effectively with all
10271 /// AVX vector shuffle types.
10272 static SDValue splitAndLowerVectorShuffle(SDLoc DL, MVT VT, SDValue V1,
10273                                           SDValue V2, ArrayRef<int> Mask,
10274                                           SelectionDAG &DAG) {
10275   assert(VT.getSizeInBits() >= 256 &&
10276          "Only for 256-bit or wider vector shuffles!");
10277   assert(V1.getSimpleValueType() == VT && "Bad operand type!");
10278   assert(V2.getSimpleValueType() == VT && "Bad operand type!");
10279
10280   ArrayRef<int> LoMask = Mask.slice(0, Mask.size() / 2);
10281   ArrayRef<int> HiMask = Mask.slice(Mask.size() / 2);
10282
10283   int NumElements = VT.getVectorNumElements();
10284   int SplitNumElements = NumElements / 2;
10285   MVT ScalarVT = VT.getScalarType();
10286   MVT SplitVT = MVT::getVectorVT(ScalarVT, NumElements / 2);
10287
10288   // Rather than splitting build-vectors, just build two narrower build
10289   // vectors. This helps shuffling with splats and zeros.
10290   auto SplitVector = [&](SDValue V) {
10291     while (V.getOpcode() == ISD::BITCAST)
10292       V = V->getOperand(0);
10293
10294     MVT OrigVT = V.getSimpleValueType();
10295     int OrigNumElements = OrigVT.getVectorNumElements();
10296     int OrigSplitNumElements = OrigNumElements / 2;
10297     MVT OrigScalarVT = OrigVT.getScalarType();
10298     MVT OrigSplitVT = MVT::getVectorVT(OrigScalarVT, OrigNumElements / 2);
10299
10300     SDValue LoV, HiV;
10301
10302     auto *BV = dyn_cast<BuildVectorSDNode>(V);
10303     if (!BV) {
10304       LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigSplitVT, V,
10305                         DAG.getIntPtrConstant(0));
10306       HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigSplitVT, V,
10307                         DAG.getIntPtrConstant(OrigSplitNumElements));
10308     } else {
10309
10310       SmallVector<SDValue, 16> LoOps, HiOps;
10311       for (int i = 0; i < OrigSplitNumElements; ++i) {
10312         LoOps.push_back(BV->getOperand(i));
10313         HiOps.push_back(BV->getOperand(i + OrigSplitNumElements));
10314       }
10315       LoV = DAG.getNode(ISD::BUILD_VECTOR, DL, OrigSplitVT, LoOps);
10316       HiV = DAG.getNode(ISD::BUILD_VECTOR, DL, OrigSplitVT, HiOps);
10317     }
10318     return std::make_pair(DAG.getNode(ISD::BITCAST, DL, SplitVT, LoV),
10319                           DAG.getNode(ISD::BITCAST, DL, SplitVT, HiV));
10320   };
10321
10322   SDValue LoV1, HiV1, LoV2, HiV2;
10323   std::tie(LoV1, HiV1) = SplitVector(V1);
10324   std::tie(LoV2, HiV2) = SplitVector(V2);
10325
10326   // Now create two 4-way blends of these half-width vectors.
10327   auto HalfBlend = [&](ArrayRef<int> HalfMask) {
10328     bool UseLoV1 = false, UseHiV1 = false, UseLoV2 = false, UseHiV2 = false;
10329     SmallVector<int, 32> V1BlendMask, V2BlendMask, BlendMask;
10330     for (int i = 0; i < SplitNumElements; ++i) {
10331       int M = HalfMask[i];
10332       if (M >= NumElements) {
10333         if (M >= NumElements + SplitNumElements)
10334           UseHiV2 = true;
10335         else
10336           UseLoV2 = true;
10337         V2BlendMask.push_back(M - NumElements);
10338         V1BlendMask.push_back(-1);
10339         BlendMask.push_back(SplitNumElements + i);
10340       } else if (M >= 0) {
10341         if (M >= SplitNumElements)
10342           UseHiV1 = true;
10343         else
10344           UseLoV1 = true;
10345         V2BlendMask.push_back(-1);
10346         V1BlendMask.push_back(M);
10347         BlendMask.push_back(i);
10348       } else {
10349         V2BlendMask.push_back(-1);
10350         V1BlendMask.push_back(-1);
10351         BlendMask.push_back(-1);
10352       }
10353     }
10354
10355     // Because the lowering happens after all combining takes place, we need to
10356     // manually combine these blend masks as much as possible so that we create
10357     // a minimal number of high-level vector shuffle nodes.
10358
10359     // First try just blending the halves of V1 or V2.
10360     if (!UseLoV1 && !UseHiV1 && !UseLoV2 && !UseHiV2)
10361       return DAG.getUNDEF(SplitVT);
10362     if (!UseLoV2 && !UseHiV2)
10363       return DAG.getVectorShuffle(SplitVT, DL, LoV1, HiV1, V1BlendMask);
10364     if (!UseLoV1 && !UseHiV1)
10365       return DAG.getVectorShuffle(SplitVT, DL, LoV2, HiV2, V2BlendMask);
10366
10367     SDValue V1Blend, V2Blend;
10368     if (UseLoV1 && UseHiV1) {
10369       V1Blend =
10370         DAG.getVectorShuffle(SplitVT, DL, LoV1, HiV1, V1BlendMask);
10371     } else {
10372       // We only use half of V1 so map the usage down into the final blend mask.
10373       V1Blend = UseLoV1 ? LoV1 : HiV1;
10374       for (int i = 0; i < SplitNumElements; ++i)
10375         if (BlendMask[i] >= 0 && BlendMask[i] < SplitNumElements)
10376           BlendMask[i] = V1BlendMask[i] - (UseLoV1 ? 0 : SplitNumElements);
10377     }
10378     if (UseLoV2 && UseHiV2) {
10379       V2Blend =
10380         DAG.getVectorShuffle(SplitVT, DL, LoV2, HiV2, V2BlendMask);
10381     } else {
10382       // We only use half of V2 so map the usage down into the final blend mask.
10383       V2Blend = UseLoV2 ? LoV2 : HiV2;
10384       for (int i = 0; i < SplitNumElements; ++i)
10385         if (BlendMask[i] >= SplitNumElements)
10386           BlendMask[i] = V2BlendMask[i] + (UseLoV2 ? SplitNumElements : 0);
10387     }
10388     return DAG.getVectorShuffle(SplitVT, DL, V1Blend, V2Blend, BlendMask);
10389   };
10390   SDValue Lo = HalfBlend(LoMask);
10391   SDValue Hi = HalfBlend(HiMask);
10392   return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
10393 }
10394
10395 /// \brief Either split a vector in halves or decompose the shuffles and the
10396 /// blend.
10397 ///
10398 /// This is provided as a good fallback for many lowerings of non-single-input
10399 /// shuffles with more than one 128-bit lane. In those cases, we want to select
10400 /// between splitting the shuffle into 128-bit components and stitching those
10401 /// back together vs. extracting the single-input shuffles and blending those
10402 /// results.
10403 static SDValue lowerVectorShuffleAsSplitOrBlend(SDLoc DL, MVT VT, SDValue V1,
10404                                                 SDValue V2, ArrayRef<int> Mask,
10405                                                 SelectionDAG &DAG) {
10406   assert(!isSingleInputShuffleMask(Mask) && "This routine must not be used to "
10407                                             "lower single-input shuffles as it "
10408                                             "could then recurse on itself.");
10409   int Size = Mask.size();
10410
10411   // If this can be modeled as a broadcast of two elements followed by a blend,
10412   // prefer that lowering. This is especially important because broadcasts can
10413   // often fold with memory operands.
10414   auto DoBothBroadcast = [&] {
10415     int V1BroadcastIdx = -1, V2BroadcastIdx = -1;
10416     for (int M : Mask)
10417       if (M >= Size) {
10418         if (V2BroadcastIdx == -1)
10419           V2BroadcastIdx = M - Size;
10420         else if (M - Size != V2BroadcastIdx)
10421           return false;
10422       } else if (M >= 0) {
10423         if (V1BroadcastIdx == -1)
10424           V1BroadcastIdx = M;
10425         else if (M != V1BroadcastIdx)
10426           return false;
10427       }
10428     return true;
10429   };
10430   if (DoBothBroadcast())
10431     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask,
10432                                                       DAG);
10433
10434   // If the inputs all stem from a single 128-bit lane of each input, then we
10435   // split them rather than blending because the split will decompose to
10436   // unusually few instructions.
10437   int LaneCount = VT.getSizeInBits() / 128;
10438   int LaneSize = Size / LaneCount;
10439   SmallBitVector LaneInputs[2];
10440   LaneInputs[0].resize(LaneCount, false);
10441   LaneInputs[1].resize(LaneCount, false);
10442   for (int i = 0; i < Size; ++i)
10443     if (Mask[i] >= 0)
10444       LaneInputs[Mask[i] / Size][(Mask[i] % Size) / LaneSize] = true;
10445   if (LaneInputs[0].count() <= 1 && LaneInputs[1].count() <= 1)
10446     return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10447
10448   // Otherwise, just fall back to decomposed shuffles and a blend. This requires
10449   // that the decomposed single-input shuffles don't end up here.
10450   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask, DAG);
10451 }
10452
10453 /// \brief Lower a vector shuffle crossing multiple 128-bit lanes as
10454 /// a permutation and blend of those lanes.
10455 ///
10456 /// This essentially blends the out-of-lane inputs to each lane into the lane
10457 /// from a permuted copy of the vector. This lowering strategy results in four
10458 /// instructions in the worst case for a single-input cross lane shuffle which
10459 /// is lower than any other fully general cross-lane shuffle strategy I'm aware
10460 /// of. Special cases for each particular shuffle pattern should be handled
10461 /// prior to trying this lowering.
10462 static SDValue lowerVectorShuffleAsLanePermuteAndBlend(SDLoc DL, MVT VT,
10463                                                        SDValue V1, SDValue V2,
10464                                                        ArrayRef<int> Mask,
10465                                                        SelectionDAG &DAG) {
10466   // FIXME: This should probably be generalized for 512-bit vectors as well.
10467   assert(VT.getSizeInBits() == 256 && "Only for 256-bit vector shuffles!");
10468   int LaneSize = Mask.size() / 2;
10469
10470   // If there are only inputs from one 128-bit lane, splitting will in fact be
10471   // less expensive. The flags track wether the given lane contains an element
10472   // that crosses to another lane.
10473   bool LaneCrossing[2] = {false, false};
10474   for (int i = 0, Size = Mask.size(); i < Size; ++i)
10475     if (Mask[i] >= 0 && (Mask[i] % Size) / LaneSize != i / LaneSize)
10476       LaneCrossing[(Mask[i] % Size) / LaneSize] = true;
10477   if (!LaneCrossing[0] || !LaneCrossing[1])
10478     return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10479
10480   if (isSingleInputShuffleMask(Mask)) {
10481     SmallVector<int, 32> FlippedBlendMask;
10482     for (int i = 0, Size = Mask.size(); i < Size; ++i)
10483       FlippedBlendMask.push_back(
10484           Mask[i] < 0 ? -1 : (((Mask[i] % Size) / LaneSize == i / LaneSize)
10485                                   ? Mask[i]
10486                                   : Mask[i] % LaneSize +
10487                                         (i / LaneSize) * LaneSize + Size));
10488
10489     // Flip the vector, and blend the results which should now be in-lane. The
10490     // VPERM2X128 mask uses the low 2 bits for the low source and bits 4 and
10491     // 5 for the high source. The value 3 selects the high half of source 2 and
10492     // the value 2 selects the low half of source 2. We only use source 2 to
10493     // allow folding it into a memory operand.
10494     unsigned PERMMask = 3 | 2 << 4;
10495     SDValue Flipped = DAG.getNode(X86ISD::VPERM2X128, DL, VT, DAG.getUNDEF(VT),
10496                                   V1, DAG.getConstant(PERMMask, MVT::i8));
10497     return DAG.getVectorShuffle(VT, DL, V1, Flipped, FlippedBlendMask);
10498   }
10499
10500   // This now reduces to two single-input shuffles of V1 and V2 which at worst
10501   // will be handled by the above logic and a blend of the results, much like
10502   // other patterns in AVX.
10503   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask, DAG);
10504 }
10505
10506 /// \brief Handle lowering 2-lane 128-bit shuffles.
10507 static SDValue lowerV2X128VectorShuffle(SDLoc DL, MVT VT, SDValue V1,
10508                                         SDValue V2, ArrayRef<int> Mask,
10509                                         const X86Subtarget *Subtarget,
10510                                         SelectionDAG &DAG) {
10511   // Blends are faster and handle all the non-lane-crossing cases.
10512   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, VT, V1, V2, Mask,
10513                                                 Subtarget, DAG))
10514     return Blend;
10515
10516   MVT SubVT = MVT::getVectorVT(VT.getVectorElementType(),
10517                                VT.getVectorNumElements() / 2);
10518   // Check for patterns which can be matched with a single insert of a 128-bit
10519   // subvector.
10520   if (isShuffleEquivalent(V1, V2, Mask, 0, 1, 0, 1) ||
10521       isShuffleEquivalent(V1, V2, Mask, 0, 1, 4, 5)) {
10522     SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
10523                               DAG.getIntPtrConstant(0));
10524     SDValue HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT,
10525                               Mask[2] < 4 ? V1 : V2, DAG.getIntPtrConstant(0));
10526     return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LoV, HiV);
10527   }
10528   if (isShuffleEquivalent(V1, V2, Mask, 0, 1, 6, 7)) {
10529     SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
10530                               DAG.getIntPtrConstant(0));
10531     SDValue HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V2,
10532                               DAG.getIntPtrConstant(2));
10533     return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LoV, HiV);
10534   }
10535
10536   // Otherwise form a 128-bit permutation.
10537   // FIXME: Detect zero-vector inputs and use the VPERM2X128 to zero that half.
10538   unsigned PermMask = Mask[0] / 2 | (Mask[2] / 2) << 4;
10539   return DAG.getNode(X86ISD::VPERM2X128, DL, VT, V1, V2,
10540                      DAG.getConstant(PermMask, MVT::i8));
10541 }
10542
10543 /// \brief Lower a vector shuffle by first fixing the 128-bit lanes and then
10544 /// shuffling each lane.
10545 ///
10546 /// This will only succeed when the result of fixing the 128-bit lanes results
10547 /// in a single-input non-lane-crossing shuffle with a repeating shuffle mask in
10548 /// each 128-bit lanes. This handles many cases where we can quickly blend away
10549 /// the lane crosses early and then use simpler shuffles within each lane.
10550 ///
10551 /// FIXME: It might be worthwhile at some point to support this without
10552 /// requiring the 128-bit lane-relative shuffles to be repeating, but currently
10553 /// in x86 only floating point has interesting non-repeating shuffles, and even
10554 /// those are still *marginally* more expensive.
10555 static SDValue lowerVectorShuffleByMerging128BitLanes(
10556     SDLoc DL, MVT VT, SDValue V1, SDValue V2, ArrayRef<int> Mask,
10557     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
10558   assert(!isSingleInputShuffleMask(Mask) &&
10559          "This is only useful with multiple inputs.");
10560
10561   int Size = Mask.size();
10562   int LaneSize = 128 / VT.getScalarSizeInBits();
10563   int NumLanes = Size / LaneSize;
10564   assert(NumLanes > 1 && "Only handles 256-bit and wider shuffles.");
10565
10566   // See if we can build a hypothetical 128-bit lane-fixing shuffle mask. Also
10567   // check whether the in-128-bit lane shuffles share a repeating pattern.
10568   SmallVector<int, 4> Lanes;
10569   Lanes.resize(NumLanes, -1);
10570   SmallVector<int, 4> InLaneMask;
10571   InLaneMask.resize(LaneSize, -1);
10572   for (int i = 0; i < Size; ++i) {
10573     if (Mask[i] < 0)
10574       continue;
10575
10576     int j = i / LaneSize;
10577
10578     if (Lanes[j] < 0) {
10579       // First entry we've seen for this lane.
10580       Lanes[j] = Mask[i] / LaneSize;
10581     } else if (Lanes[j] != Mask[i] / LaneSize) {
10582       // This doesn't match the lane selected previously!
10583       return SDValue();
10584     }
10585
10586     // Check that within each lane we have a consistent shuffle mask.
10587     int k = i % LaneSize;
10588     if (InLaneMask[k] < 0) {
10589       InLaneMask[k] = Mask[i] % LaneSize;
10590     } else if (InLaneMask[k] != Mask[i] % LaneSize) {
10591       // This doesn't fit a repeating in-lane mask.
10592       return SDValue();
10593     }
10594   }
10595
10596   // First shuffle the lanes into place.
10597   MVT LaneVT = MVT::getVectorVT(VT.isFloatingPoint() ? MVT::f64 : MVT::i64,
10598                                 VT.getSizeInBits() / 64);
10599   SmallVector<int, 8> LaneMask;
10600   LaneMask.resize(NumLanes * 2, -1);
10601   for (int i = 0; i < NumLanes; ++i)
10602     if (Lanes[i] >= 0) {
10603       LaneMask[2 * i + 0] = 2*Lanes[i] + 0;
10604       LaneMask[2 * i + 1] = 2*Lanes[i] + 1;
10605     }
10606
10607   V1 = DAG.getNode(ISD::BITCAST, DL, LaneVT, V1);
10608   V2 = DAG.getNode(ISD::BITCAST, DL, LaneVT, V2);
10609   SDValue LaneShuffle = DAG.getVectorShuffle(LaneVT, DL, V1, V2, LaneMask);
10610
10611   // Cast it back to the type we actually want.
10612   LaneShuffle = DAG.getNode(ISD::BITCAST, DL, VT, LaneShuffle);
10613
10614   // Now do a simple shuffle that isn't lane crossing.
10615   SmallVector<int, 8> NewMask;
10616   NewMask.resize(Size, -1);
10617   for (int i = 0; i < Size; ++i)
10618     if (Mask[i] >= 0)
10619       NewMask[i] = (i / LaneSize) * LaneSize + Mask[i] % LaneSize;
10620   assert(!is128BitLaneCrossingShuffleMask(VT, NewMask) &&
10621          "Must not introduce lane crosses at this point!");
10622
10623   return DAG.getVectorShuffle(VT, DL, LaneShuffle, DAG.getUNDEF(VT), NewMask);
10624 }
10625
10626 /// \brief Test whether the specified input (0 or 1) is in-place blended by the
10627 /// given mask.
10628 ///
10629 /// This returns true if the elements from a particular input are already in the
10630 /// slot required by the given mask and require no permutation.
10631 static bool isShuffleMaskInputInPlace(int Input, ArrayRef<int> Mask) {
10632   assert((Input == 0 || Input == 1) && "Only two inputs to shuffles.");
10633   int Size = Mask.size();
10634   for (int i = 0; i < Size; ++i)
10635     if (Mask[i] >= 0 && Mask[i] / Size == Input && Mask[i] % Size != i)
10636       return false;
10637
10638   return true;
10639 }
10640
10641 /// \brief Handle lowering of 4-lane 64-bit floating point shuffles.
10642 ///
10643 /// Also ends up handling lowering of 4-lane 64-bit integer shuffles when AVX2
10644 /// isn't available.
10645 static SDValue lowerV4F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10646                                        const X86Subtarget *Subtarget,
10647                                        SelectionDAG &DAG) {
10648   SDLoc DL(Op);
10649   assert(V1.getSimpleValueType() == MVT::v4f64 && "Bad operand type!");
10650   assert(V2.getSimpleValueType() == MVT::v4f64 && "Bad operand type!");
10651   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10652   ArrayRef<int> Mask = SVOp->getMask();
10653   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
10654
10655   SmallVector<int, 4> WidenedMask;
10656   if (canWidenShuffleElements(Mask, WidenedMask))
10657     return lowerV2X128VectorShuffle(DL, MVT::v4f64, V1, V2, Mask, Subtarget,
10658                                     DAG);
10659
10660   if (isSingleInputShuffleMask(Mask)) {
10661     // Check for being able to broadcast a single element.
10662     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4f64, DL, V1,
10663                                                           Mask, Subtarget, DAG))
10664       return Broadcast;
10665
10666     // Use low duplicate instructions for masks that match their pattern.
10667     if (isShuffleEquivalent(V1, V2, Mask, 0, 0, 2, 2))
10668       return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v4f64, V1);
10669
10670     if (!is128BitLaneCrossingShuffleMask(MVT::v4f64, Mask)) {
10671       // Non-half-crossing single input shuffles can be lowerid with an
10672       // interleaved permutation.
10673       unsigned VPERMILPMask = (Mask[0] == 1) | ((Mask[1] == 1) << 1) |
10674                               ((Mask[2] == 3) << 2) | ((Mask[3] == 3) << 3);
10675       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f64, V1,
10676                          DAG.getConstant(VPERMILPMask, MVT::i8));
10677     }
10678
10679     // With AVX2 we have direct support for this permutation.
10680     if (Subtarget->hasAVX2())
10681       return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4f64, V1,
10682                          getV4X86ShuffleImm8ForMask(Mask, DAG));
10683
10684     // Otherwise, fall back.
10685     return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v4f64, V1, V2, Mask,
10686                                                    DAG);
10687   }
10688
10689   // X86 has dedicated unpack instructions that can handle specific blend
10690   // operations: UNPCKH and UNPCKL.
10691   if (isShuffleEquivalent(V1, V2, Mask, 0, 4, 2, 6))
10692     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f64, V1, V2);
10693   if (isShuffleEquivalent(V1, V2, Mask, 1, 5, 3, 7))
10694     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f64, V1, V2);
10695   if (isShuffleEquivalent(V1, V2, Mask, 4, 0, 6, 2))
10696     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f64, V2, V1);
10697   if (isShuffleEquivalent(V1, V2, Mask, 5, 1, 7, 3))
10698     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f64, V2, V1);
10699
10700   // If we have a single input to the zero element, insert that into V1 if we
10701   // can do so cheaply.
10702   int NumV2Elements =
10703       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
10704   if (NumV2Elements == 1 && Mask[0] >= 4)
10705     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
10706             MVT::v4f64, DL, V1, V2, Mask, Subtarget, DAG))
10707       return Insertion;
10708
10709   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4f64, V1, V2, Mask,
10710                                                 Subtarget, DAG))
10711     return Blend;
10712
10713   // Check if the blend happens to exactly fit that of SHUFPD.
10714   if ((Mask[0] == -1 || Mask[0] < 2) &&
10715       (Mask[1] == -1 || (Mask[1] >= 4 && Mask[1] < 6)) &&
10716       (Mask[2] == -1 || (Mask[2] >= 2 && Mask[2] < 4)) &&
10717       (Mask[3] == -1 || Mask[3] >= 6)) {
10718     unsigned SHUFPDMask = (Mask[0] == 1) | ((Mask[1] == 5) << 1) |
10719                           ((Mask[2] == 3) << 2) | ((Mask[3] == 7) << 3);
10720     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f64, V1, V2,
10721                        DAG.getConstant(SHUFPDMask, MVT::i8));
10722   }
10723   if ((Mask[0] == -1 || (Mask[0] >= 4 && Mask[0] < 6)) &&
10724       (Mask[1] == -1 || Mask[1] < 2) &&
10725       (Mask[2] == -1 || Mask[2] >= 6) &&
10726       (Mask[3] == -1 || (Mask[3] >= 2 && Mask[3] < 4))) {
10727     unsigned SHUFPDMask = (Mask[0] == 5) | ((Mask[1] == 1) << 1) |
10728                           ((Mask[2] == 7) << 2) | ((Mask[3] == 3) << 3);
10729     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f64, V2, V1,
10730                        DAG.getConstant(SHUFPDMask, MVT::i8));
10731   }
10732
10733   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10734   // shuffle. However, if we have AVX2 and either inputs are already in place,
10735   // we will be able to shuffle even across lanes the other input in a single
10736   // instruction so skip this pattern.
10737   if (!(Subtarget->hasAVX2() && (isShuffleMaskInputInPlace(0, Mask) ||
10738                                  isShuffleMaskInputInPlace(1, Mask))))
10739     if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10740             DL, MVT::v4f64, V1, V2, Mask, Subtarget, DAG))
10741       return Result;
10742
10743   // If we have AVX2 then we always want to lower with a blend because an v4 we
10744   // can fully permute the elements.
10745   if (Subtarget->hasAVX2())
10746     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4f64, V1, V2,
10747                                                       Mask, DAG);
10748
10749   // Otherwise fall back on generic lowering.
10750   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v4f64, V1, V2, Mask, DAG);
10751 }
10752
10753 /// \brief Handle lowering of 4-lane 64-bit integer shuffles.
10754 ///
10755 /// This routine is only called when we have AVX2 and thus a reasonable
10756 /// instruction set for v4i64 shuffling..
10757 static SDValue lowerV4I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10758                                        const X86Subtarget *Subtarget,
10759                                        SelectionDAG &DAG) {
10760   SDLoc DL(Op);
10761   assert(V1.getSimpleValueType() == MVT::v4i64 && "Bad operand type!");
10762   assert(V2.getSimpleValueType() == MVT::v4i64 && "Bad operand type!");
10763   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10764   ArrayRef<int> Mask = SVOp->getMask();
10765   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
10766   assert(Subtarget->hasAVX2() && "We can only lower v4i64 with AVX2!");
10767
10768   SmallVector<int, 4> WidenedMask;
10769   if (canWidenShuffleElements(Mask, WidenedMask))
10770     return lowerV2X128VectorShuffle(DL, MVT::v4i64, V1, V2, Mask, Subtarget,
10771                                     DAG);
10772
10773   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4i64, V1, V2, Mask,
10774                                                 Subtarget, DAG))
10775     return Blend;
10776
10777   // Check for being able to broadcast a single element.
10778   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4i64, DL, V1,
10779                                                         Mask, Subtarget, DAG))
10780     return Broadcast;
10781
10782   // When the shuffle is mirrored between the 128-bit lanes of the unit, we can
10783   // use lower latency instructions that will operate on both 128-bit lanes.
10784   SmallVector<int, 2> RepeatedMask;
10785   if (is128BitLaneRepeatedShuffleMask(MVT::v4i64, Mask, RepeatedMask)) {
10786     if (isSingleInputShuffleMask(Mask)) {
10787       int PSHUFDMask[] = {-1, -1, -1, -1};
10788       for (int i = 0; i < 2; ++i)
10789         if (RepeatedMask[i] >= 0) {
10790           PSHUFDMask[2 * i] = 2 * RepeatedMask[i];
10791           PSHUFDMask[2 * i + 1] = 2 * RepeatedMask[i] + 1;
10792         }
10793       return DAG.getNode(
10794           ISD::BITCAST, DL, MVT::v4i64,
10795           DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32,
10796                       DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, V1),
10797                       getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
10798     }
10799   }
10800
10801   // AVX2 provides a direct instruction for permuting a single input across
10802   // lanes.
10803   if (isSingleInputShuffleMask(Mask))
10804     return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4i64, V1,
10805                        getV4X86ShuffleImm8ForMask(Mask, DAG));
10806
10807   // Try to use shift instructions.
10808   if (SDValue Shift =
10809           lowerVectorShuffleAsShift(DL, MVT::v4i64, V1, V2, Mask, DAG))
10810     return Shift;
10811
10812   // Use dedicated unpack instructions for masks that match their pattern.
10813   if (isShuffleEquivalent(V1, V2, Mask, 0, 4, 2, 6))
10814     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i64, V1, V2);
10815   if (isShuffleEquivalent(V1, V2, Mask, 1, 5, 3, 7))
10816     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i64, V1, V2);
10817   if (isShuffleEquivalent(V1, V2, Mask, 4, 0, 6, 2))
10818     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i64, V2, V1);
10819   if (isShuffleEquivalent(V1, V2, Mask, 5, 1, 7, 3))
10820     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i64, V2, V1);
10821
10822   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10823   // shuffle. However, if we have AVX2 and either inputs are already in place,
10824   // we will be able to shuffle even across lanes the other input in a single
10825   // instruction so skip this pattern.
10826   if (!(Subtarget->hasAVX2() && (isShuffleMaskInputInPlace(0, Mask) ||
10827                                  isShuffleMaskInputInPlace(1, Mask))))
10828     if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10829             DL, MVT::v4i64, V1, V2, Mask, Subtarget, DAG))
10830       return Result;
10831
10832   // Otherwise fall back on generic blend lowering.
10833   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4i64, V1, V2,
10834                                                     Mask, DAG);
10835 }
10836
10837 /// \brief Handle lowering of 8-lane 32-bit floating point shuffles.
10838 ///
10839 /// Also ends up handling lowering of 8-lane 32-bit integer shuffles when AVX2
10840 /// isn't available.
10841 static SDValue lowerV8F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10842                                        const X86Subtarget *Subtarget,
10843                                        SelectionDAG &DAG) {
10844   SDLoc DL(Op);
10845   assert(V1.getSimpleValueType() == MVT::v8f32 && "Bad operand type!");
10846   assert(V2.getSimpleValueType() == MVT::v8f32 && "Bad operand type!");
10847   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10848   ArrayRef<int> Mask = SVOp->getMask();
10849   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
10850
10851   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8f32, V1, V2, Mask,
10852                                                 Subtarget, DAG))
10853     return Blend;
10854
10855   // Check for being able to broadcast a single element.
10856   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v8f32, DL, V1,
10857                                                         Mask, Subtarget, DAG))
10858     return Broadcast;
10859
10860   // If the shuffle mask is repeated in each 128-bit lane, we have many more
10861   // options to efficiently lower the shuffle.
10862   SmallVector<int, 4> RepeatedMask;
10863   if (is128BitLaneRepeatedShuffleMask(MVT::v8f32, Mask, RepeatedMask)) {
10864     assert(RepeatedMask.size() == 4 &&
10865            "Repeated masks must be half the mask width!");
10866
10867     // Use even/odd duplicate instructions for masks that match their pattern.
10868     if (isShuffleEquivalent(V1, V2, Mask, 0, 0, 2, 2, 4, 4, 6, 6))
10869       return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v8f32, V1);
10870     if (isShuffleEquivalent(V1, V2, Mask, 1, 1, 3, 3, 5, 5, 7, 7))
10871       return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v8f32, V1);
10872
10873     if (isSingleInputShuffleMask(Mask))
10874       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v8f32, V1,
10875                          getV4X86ShuffleImm8ForMask(RepeatedMask, DAG));
10876
10877     // Use dedicated unpack instructions for masks that match their pattern.
10878     if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 1, 9, 4, 12, 5, 13))
10879       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f32, V1, V2);
10880     if (isShuffleEquivalent(V1, V2, Mask, 2, 10, 3, 11, 6, 14, 7, 15))
10881       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f32, V1, V2);
10882     if (isShuffleEquivalent(V1, V2, Mask, 8, 0, 9, 1, 12, 4, 13, 5))
10883       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f32, V2, V1);
10884     if (isShuffleEquivalent(V1, V2, Mask, 10, 2, 11, 3, 14, 6, 15, 7))
10885       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f32, V2, V1);
10886
10887     // Otherwise, fall back to a SHUFPS sequence. Here it is important that we
10888     // have already handled any direct blends. We also need to squash the
10889     // repeated mask into a simulated v4f32 mask.
10890     for (int i = 0; i < 4; ++i)
10891       if (RepeatedMask[i] >= 8)
10892         RepeatedMask[i] -= 4;
10893     return lowerVectorShuffleWithSHUFPS(DL, MVT::v8f32, RepeatedMask, V1, V2, DAG);
10894   }
10895
10896   // If we have a single input shuffle with different shuffle patterns in the
10897   // two 128-bit lanes use the variable mask to VPERMILPS.
10898   if (isSingleInputShuffleMask(Mask)) {
10899     SDValue VPermMask[8];
10900     for (int i = 0; i < 8; ++i)
10901       VPermMask[i] = Mask[i] < 0 ? DAG.getUNDEF(MVT::i32)
10902                                  : DAG.getConstant(Mask[i], MVT::i32);
10903     if (!is128BitLaneCrossingShuffleMask(MVT::v8f32, Mask))
10904       return DAG.getNode(
10905           X86ISD::VPERMILPV, DL, MVT::v8f32, V1,
10906           DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v8i32, VPermMask));
10907
10908     if (Subtarget->hasAVX2())
10909       return DAG.getNode(X86ISD::VPERMV, DL, MVT::v8f32,
10910                          DAG.getNode(ISD::BITCAST, DL, MVT::v8f32,
10911                                      DAG.getNode(ISD::BUILD_VECTOR, DL,
10912                                                  MVT::v8i32, VPermMask)),
10913                          V1);
10914
10915     // Otherwise, fall back.
10916     return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v8f32, V1, V2, Mask,
10917                                                    DAG);
10918   }
10919
10920   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10921   // shuffle.
10922   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10923           DL, MVT::v8f32, V1, V2, Mask, Subtarget, DAG))
10924     return Result;
10925
10926   // If we have AVX2 then we always want to lower with a blend because at v8 we
10927   // can fully permute the elements.
10928   if (Subtarget->hasAVX2())
10929     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8f32, V1, V2,
10930                                                       Mask, DAG);
10931
10932   // Otherwise fall back on generic lowering.
10933   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v8f32, V1, V2, Mask, DAG);
10934 }
10935
10936 /// \brief Handle lowering of 8-lane 32-bit integer shuffles.
10937 ///
10938 /// This routine is only called when we have AVX2 and thus a reasonable
10939 /// instruction set for v8i32 shuffling..
10940 static SDValue lowerV8I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10941                                        const X86Subtarget *Subtarget,
10942                                        SelectionDAG &DAG) {
10943   SDLoc DL(Op);
10944   assert(V1.getSimpleValueType() == MVT::v8i32 && "Bad operand type!");
10945   assert(V2.getSimpleValueType() == MVT::v8i32 && "Bad operand type!");
10946   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10947   ArrayRef<int> Mask = SVOp->getMask();
10948   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
10949   assert(Subtarget->hasAVX2() && "We can only lower v8i32 with AVX2!");
10950
10951   // Whenever we can lower this as a zext, that instruction is strictly faster
10952   // than any alternative. It also allows us to fold memory operands into the
10953   // shuffle in many cases.
10954   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v8i32, V1, V2,
10955                                                          Mask, Subtarget, DAG))
10956     return ZExt;
10957
10958   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8i32, V1, V2, Mask,
10959                                                 Subtarget, DAG))
10960     return Blend;
10961
10962   // Check for being able to broadcast a single element.
10963   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v8i32, DL, V1,
10964                                                         Mask, Subtarget, DAG))
10965     return Broadcast;
10966
10967   // If the shuffle mask is repeated in each 128-bit lane we can use more
10968   // efficient instructions that mirror the shuffles across the two 128-bit
10969   // lanes.
10970   SmallVector<int, 4> RepeatedMask;
10971   if (is128BitLaneRepeatedShuffleMask(MVT::v8i32, Mask, RepeatedMask)) {
10972     assert(RepeatedMask.size() == 4 && "Unexpected repeated mask size!");
10973     if (isSingleInputShuffleMask(Mask))
10974       return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32, V1,
10975                          getV4X86ShuffleImm8ForMask(RepeatedMask, DAG));
10976
10977     // Use dedicated unpack instructions for masks that match their pattern.
10978     if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 1, 9, 4, 12, 5, 13))
10979       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i32, V1, V2);
10980     if (isShuffleEquivalent(V1, V2, Mask, 2, 10, 3, 11, 6, 14, 7, 15))
10981       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i32, V1, V2);
10982     if (isShuffleEquivalent(V1, V2, Mask, 8, 0, 9, 1, 12, 4, 13, 5))
10983       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i32, V2, V1);
10984     if (isShuffleEquivalent(V1, V2, Mask, 10, 2, 11, 3, 14, 6, 15, 7))
10985       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i32, V2, V1);
10986   }
10987
10988   // Try to use shift instructions.
10989   if (SDValue Shift =
10990           lowerVectorShuffleAsShift(DL, MVT::v8i32, V1, V2, Mask, DAG))
10991     return Shift;
10992
10993   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
10994           DL, MVT::v8i32, V1, V2, Mask, Subtarget, DAG))
10995     return Rotate;
10996
10997   // If the shuffle patterns aren't repeated but it is a single input, directly
10998   // generate a cross-lane VPERMD instruction.
10999   if (isSingleInputShuffleMask(Mask)) {
11000     SDValue VPermMask[8];
11001     for (int i = 0; i < 8; ++i)
11002       VPermMask[i] = Mask[i] < 0 ? DAG.getUNDEF(MVT::i32)
11003                                  : DAG.getConstant(Mask[i], MVT::i32);
11004     return DAG.getNode(
11005         X86ISD::VPERMV, DL, MVT::v8i32,
11006         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v8i32, VPermMask), V1);
11007   }
11008
11009   // Try to simplify this by merging 128-bit lanes to enable a lane-based
11010   // shuffle.
11011   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
11012           DL, MVT::v8i32, V1, V2, Mask, Subtarget, DAG))
11013     return Result;
11014
11015   // Otherwise fall back on generic blend lowering.
11016   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8i32, V1, V2,
11017                                                     Mask, DAG);
11018 }
11019
11020 /// \brief Handle lowering of 16-lane 16-bit integer shuffles.
11021 ///
11022 /// This routine is only called when we have AVX2 and thus a reasonable
11023 /// instruction set for v16i16 shuffling..
11024 static SDValue lowerV16I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11025                                         const X86Subtarget *Subtarget,
11026                                         SelectionDAG &DAG) {
11027   SDLoc DL(Op);
11028   assert(V1.getSimpleValueType() == MVT::v16i16 && "Bad operand type!");
11029   assert(V2.getSimpleValueType() == MVT::v16i16 && "Bad operand type!");
11030   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11031   ArrayRef<int> Mask = SVOp->getMask();
11032   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
11033   assert(Subtarget->hasAVX2() && "We can only lower v16i16 with AVX2!");
11034
11035   // Whenever we can lower this as a zext, that instruction is strictly faster
11036   // than any alternative. It also allows us to fold memory operands into the
11037   // shuffle in many cases.
11038   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v16i16, V1, V2,
11039                                                          Mask, Subtarget, DAG))
11040     return ZExt;
11041
11042   // Check for being able to broadcast a single element.
11043   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v16i16, DL, V1,
11044                                                         Mask, Subtarget, DAG))
11045     return Broadcast;
11046
11047   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v16i16, V1, V2, Mask,
11048                                                 Subtarget, DAG))
11049     return Blend;
11050
11051   // Use dedicated unpack instructions for masks that match their pattern.
11052   if (isShuffleEquivalent(V1, V2, Mask,
11053                           // First 128-bit lane:
11054                           0, 16, 1, 17, 2, 18, 3, 19,
11055                           // Second 128-bit lane:
11056                           8, 24, 9, 25, 10, 26, 11, 27))
11057     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i16, V1, V2);
11058   if (isShuffleEquivalent(V1, V2, Mask,
11059                           // First 128-bit lane:
11060                           4, 20, 5, 21, 6, 22, 7, 23,
11061                           // Second 128-bit lane:
11062                           12, 28, 13, 29, 14, 30, 15, 31))
11063     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i16, V1, V2);
11064
11065   // Try to use shift instructions.
11066   if (SDValue Shift =
11067           lowerVectorShuffleAsShift(DL, MVT::v16i16, V1, V2, Mask, DAG))
11068     return Shift;
11069
11070   // Try to use byte rotation instructions.
11071   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
11072           DL, MVT::v16i16, V1, V2, Mask, Subtarget, DAG))
11073     return Rotate;
11074
11075   if (isSingleInputShuffleMask(Mask)) {
11076     // There are no generalized cross-lane shuffle operations available on i16
11077     // element types.
11078     if (is128BitLaneCrossingShuffleMask(MVT::v16i16, Mask))
11079       return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v16i16, V1, V2,
11080                                                      Mask, DAG);
11081
11082     SDValue PSHUFBMask[32];
11083     for (int i = 0; i < 16; ++i) {
11084       if (Mask[i] == -1) {
11085         PSHUFBMask[2 * i] = PSHUFBMask[2 * i + 1] = DAG.getUNDEF(MVT::i8);
11086         continue;
11087       }
11088
11089       int M = i < 8 ? Mask[i] : Mask[i] - 8;
11090       assert(M >= 0 && M < 8 && "Invalid single-input mask!");
11091       PSHUFBMask[2 * i] = DAG.getConstant(2 * M, MVT::i8);
11092       PSHUFBMask[2 * i + 1] = DAG.getConstant(2 * M + 1, MVT::i8);
11093     }
11094     return DAG.getNode(
11095         ISD::BITCAST, DL, MVT::v16i16,
11096         DAG.getNode(
11097             X86ISD::PSHUFB, DL, MVT::v32i8,
11098             DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, V1),
11099             DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, PSHUFBMask)));
11100   }
11101
11102   // Try to simplify this by merging 128-bit lanes to enable a lane-based
11103   // shuffle.
11104   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
11105           DL, MVT::v16i16, V1, V2, Mask, Subtarget, DAG))
11106     return Result;
11107
11108   // Otherwise fall back on generic lowering.
11109   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v16i16, V1, V2, Mask, DAG);
11110 }
11111
11112 /// \brief Handle lowering of 32-lane 8-bit integer shuffles.
11113 ///
11114 /// This routine is only called when we have AVX2 and thus a reasonable
11115 /// instruction set for v32i8 shuffling..
11116 static SDValue lowerV32I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11117                                        const X86Subtarget *Subtarget,
11118                                        SelectionDAG &DAG) {
11119   SDLoc DL(Op);
11120   assert(V1.getSimpleValueType() == MVT::v32i8 && "Bad operand type!");
11121   assert(V2.getSimpleValueType() == MVT::v32i8 && "Bad operand type!");
11122   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11123   ArrayRef<int> Mask = SVOp->getMask();
11124   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
11125   assert(Subtarget->hasAVX2() && "We can only lower v32i8 with AVX2!");
11126
11127   // Whenever we can lower this as a zext, that instruction is strictly faster
11128   // than any alternative. It also allows us to fold memory operands into the
11129   // shuffle in many cases.
11130   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v32i8, V1, V2,
11131                                                          Mask, Subtarget, DAG))
11132     return ZExt;
11133
11134   // Check for being able to broadcast a single element.
11135   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v32i8, DL, V1,
11136                                                         Mask, Subtarget, DAG))
11137     return Broadcast;
11138
11139   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v32i8, V1, V2, Mask,
11140                                                 Subtarget, DAG))
11141     return Blend;
11142
11143   // Use dedicated unpack instructions for masks that match their pattern.
11144   // Note that these are repeated 128-bit lane unpacks, not unpacks across all
11145   // 256-bit lanes.
11146   if (isShuffleEquivalent(
11147           V1, V2, Mask,
11148           // First 128-bit lane:
11149           0, 32, 1, 33, 2, 34, 3, 35, 4, 36, 5, 37, 6, 38, 7, 39,
11150           // Second 128-bit lane:
11151           16, 48, 17, 49, 18, 50, 19, 51, 20, 52, 21, 53, 22, 54, 23, 55))
11152     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v32i8, V1, V2);
11153   if (isShuffleEquivalent(
11154           V1, V2, Mask,
11155           // First 128-bit lane:
11156           8, 40, 9, 41, 10, 42, 11, 43, 12, 44, 13, 45, 14, 46, 15, 47,
11157           // Second 128-bit lane:
11158           24, 56, 25, 57, 26, 58, 27, 59, 28, 60, 29, 61, 30, 62, 31, 63))
11159     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v32i8, V1, V2);
11160
11161   // Try to use shift instructions.
11162   if (SDValue Shift =
11163           lowerVectorShuffleAsShift(DL, MVT::v32i8, V1, V2, Mask, DAG))
11164     return Shift;
11165
11166   // Try to use byte rotation instructions.
11167   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
11168           DL, MVT::v32i8, V1, V2, Mask, Subtarget, DAG))
11169     return Rotate;
11170
11171   if (isSingleInputShuffleMask(Mask)) {
11172     // There are no generalized cross-lane shuffle operations available on i8
11173     // element types.
11174     if (is128BitLaneCrossingShuffleMask(MVT::v32i8, Mask))
11175       return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v32i8, V1, V2,
11176                                                      Mask, DAG);
11177
11178     SDValue PSHUFBMask[32];
11179     for (int i = 0; i < 32; ++i)
11180       PSHUFBMask[i] =
11181           Mask[i] < 0
11182               ? DAG.getUNDEF(MVT::i8)
11183               : DAG.getConstant(Mask[i] < 16 ? Mask[i] : Mask[i] - 16, MVT::i8);
11184
11185     return DAG.getNode(
11186         X86ISD::PSHUFB, DL, MVT::v32i8, V1,
11187         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, PSHUFBMask));
11188   }
11189
11190   // Try to simplify this by merging 128-bit lanes to enable a lane-based
11191   // shuffle.
11192   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
11193           DL, MVT::v32i8, V1, V2, Mask, Subtarget, DAG))
11194     return Result;
11195
11196   // Otherwise fall back on generic lowering.
11197   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v32i8, V1, V2, Mask, DAG);
11198 }
11199
11200 /// \brief High-level routine to lower various 256-bit x86 vector shuffles.
11201 ///
11202 /// This routine either breaks down the specific type of a 256-bit x86 vector
11203 /// shuffle or splits it into two 128-bit shuffles and fuses the results back
11204 /// together based on the available instructions.
11205 static SDValue lower256BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11206                                         MVT VT, const X86Subtarget *Subtarget,
11207                                         SelectionDAG &DAG) {
11208   SDLoc DL(Op);
11209   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11210   ArrayRef<int> Mask = SVOp->getMask();
11211
11212   // There is a really nice hard cut-over between AVX1 and AVX2 that means we can
11213   // check for those subtargets here and avoid much of the subtarget querying in
11214   // the per-vector-type lowering routines. With AVX1 we have essentially *zero*
11215   // ability to manipulate a 256-bit vector with integer types. Since we'll use
11216   // floating point types there eventually, just immediately cast everything to
11217   // a float and operate entirely in that domain.
11218   if (VT.isInteger() && !Subtarget->hasAVX2()) {
11219     int ElementBits = VT.getScalarSizeInBits();
11220     if (ElementBits < 32)
11221       // No floating point type available, decompose into 128-bit vectors.
11222       return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
11223
11224     MVT FpVT = MVT::getVectorVT(MVT::getFloatingPointVT(ElementBits),
11225                                 VT.getVectorNumElements());
11226     V1 = DAG.getNode(ISD::BITCAST, DL, FpVT, V1);
11227     V2 = DAG.getNode(ISD::BITCAST, DL, FpVT, V2);
11228     return DAG.getNode(ISD::BITCAST, DL, VT,
11229                        DAG.getVectorShuffle(FpVT, DL, V1, V2, Mask));
11230   }
11231
11232   switch (VT.SimpleTy) {
11233   case MVT::v4f64:
11234     return lowerV4F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
11235   case MVT::v4i64:
11236     return lowerV4I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
11237   case MVT::v8f32:
11238     return lowerV8F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
11239   case MVT::v8i32:
11240     return lowerV8I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
11241   case MVT::v16i16:
11242     return lowerV16I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
11243   case MVT::v32i8:
11244     return lowerV32I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
11245
11246   default:
11247     llvm_unreachable("Not a valid 256-bit x86 vector type!");
11248   }
11249 }
11250
11251 /// \brief Handle lowering of 8-lane 64-bit floating point shuffles.
11252 static SDValue lowerV8F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11253                                        const X86Subtarget *Subtarget,
11254                                        SelectionDAG &DAG) {
11255   SDLoc DL(Op);
11256   assert(V1.getSimpleValueType() == MVT::v8f64 && "Bad operand type!");
11257   assert(V2.getSimpleValueType() == MVT::v8f64 && "Bad operand type!");
11258   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11259   ArrayRef<int> Mask = SVOp->getMask();
11260   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
11261
11262   // X86 has dedicated unpack instructions that can handle specific blend
11263   // operations: UNPCKH and UNPCKL.
11264   if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 2, 10, 4, 12, 6, 14))
11265     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f64, V1, V2);
11266   if (isShuffleEquivalent(V1, V2, Mask, 1, 9, 3, 11, 5, 13, 7, 15))
11267     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f64, V1, V2);
11268
11269   // FIXME: Implement direct support for this type!
11270   return splitAndLowerVectorShuffle(DL, MVT::v8f64, V1, V2, Mask, DAG);
11271 }
11272
11273 /// \brief Handle lowering of 16-lane 32-bit floating point shuffles.
11274 static SDValue lowerV16F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11275                                        const X86Subtarget *Subtarget,
11276                                        SelectionDAG &DAG) {
11277   SDLoc DL(Op);
11278   assert(V1.getSimpleValueType() == MVT::v16f32 && "Bad operand type!");
11279   assert(V2.getSimpleValueType() == MVT::v16f32 && "Bad operand type!");
11280   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11281   ArrayRef<int> Mask = SVOp->getMask();
11282   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
11283
11284   // Use dedicated unpack instructions for masks that match their pattern.
11285   if (isShuffleEquivalent(V1, V2, Mask,
11286                           0, 16, 1, 17, 4, 20, 5, 21,
11287                           8, 24, 9, 25, 12, 28, 13, 29))
11288     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16f32, V1, V2);
11289   if (isShuffleEquivalent(V1, V2, Mask,
11290                           2, 18, 3, 19, 6, 22, 7, 23,
11291                           10, 26, 11, 27, 14, 30, 15, 31))
11292     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16f32, V1, V2);
11293
11294   // FIXME: Implement direct support for this type!
11295   return splitAndLowerVectorShuffle(DL, MVT::v16f32, V1, V2, Mask, DAG);
11296 }
11297
11298 /// \brief Handle lowering of 8-lane 64-bit integer shuffles.
11299 static SDValue lowerV8I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11300                                        const X86Subtarget *Subtarget,
11301                                        SelectionDAG &DAG) {
11302   SDLoc DL(Op);
11303   assert(V1.getSimpleValueType() == MVT::v8i64 && "Bad operand type!");
11304   assert(V2.getSimpleValueType() == MVT::v8i64 && "Bad operand type!");
11305   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11306   ArrayRef<int> Mask = SVOp->getMask();
11307   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
11308
11309   // X86 has dedicated unpack instructions that can handle specific blend
11310   // operations: UNPCKH and UNPCKL.
11311   if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 2, 10, 4, 12, 6, 14))
11312     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i64, V1, V2);
11313   if (isShuffleEquivalent(V1, V2, Mask, 1, 9, 3, 11, 5, 13, 7, 15))
11314     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i64, V1, V2);
11315
11316   // FIXME: Implement direct support for this type!
11317   return splitAndLowerVectorShuffle(DL, MVT::v8i64, V1, V2, Mask, DAG);
11318 }
11319
11320 /// \brief Handle lowering of 16-lane 32-bit integer shuffles.
11321 static SDValue lowerV16I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11322                                        const X86Subtarget *Subtarget,
11323                                        SelectionDAG &DAG) {
11324   SDLoc DL(Op);
11325   assert(V1.getSimpleValueType() == MVT::v16i32 && "Bad operand type!");
11326   assert(V2.getSimpleValueType() == MVT::v16i32 && "Bad operand type!");
11327   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11328   ArrayRef<int> Mask = SVOp->getMask();
11329   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
11330
11331   // Use dedicated unpack instructions for masks that match their pattern.
11332   if (isShuffleEquivalent(V1, V2, Mask,
11333                           0, 16, 1, 17, 4, 20, 5, 21,
11334                           8, 24, 9, 25, 12, 28, 13, 29))
11335     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i32, V1, V2);
11336   if (isShuffleEquivalent(V1, V2, Mask,
11337                           2, 18, 3, 19, 6, 22, 7, 23,
11338                           10, 26, 11, 27, 14, 30, 15, 31))
11339     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i32, V1, V2);
11340
11341   // FIXME: Implement direct support for this type!
11342   return splitAndLowerVectorShuffle(DL, MVT::v16i32, V1, V2, Mask, DAG);
11343 }
11344
11345 /// \brief Handle lowering of 32-lane 16-bit integer shuffles.
11346 static SDValue lowerV32I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11347                                         const X86Subtarget *Subtarget,
11348                                         SelectionDAG &DAG) {
11349   SDLoc DL(Op);
11350   assert(V1.getSimpleValueType() == MVT::v32i16 && "Bad operand type!");
11351   assert(V2.getSimpleValueType() == MVT::v32i16 && "Bad operand type!");
11352   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11353   ArrayRef<int> Mask = SVOp->getMask();
11354   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
11355   assert(Subtarget->hasBWI() && "We can only lower v32i16 with AVX-512-BWI!");
11356
11357   // FIXME: Implement direct support for this type!
11358   return splitAndLowerVectorShuffle(DL, MVT::v32i16, V1, V2, Mask, DAG);
11359 }
11360
11361 /// \brief Handle lowering of 64-lane 8-bit integer shuffles.
11362 static SDValue lowerV64I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11363                                        const X86Subtarget *Subtarget,
11364                                        SelectionDAG &DAG) {
11365   SDLoc DL(Op);
11366   assert(V1.getSimpleValueType() == MVT::v64i8 && "Bad operand type!");
11367   assert(V2.getSimpleValueType() == MVT::v64i8 && "Bad operand type!");
11368   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11369   ArrayRef<int> Mask = SVOp->getMask();
11370   assert(Mask.size() == 64 && "Unexpected mask size for v64 shuffle!");
11371   assert(Subtarget->hasBWI() && "We can only lower v64i8 with AVX-512-BWI!");
11372
11373   // FIXME: Implement direct support for this type!
11374   return splitAndLowerVectorShuffle(DL, MVT::v64i8, V1, V2, Mask, DAG);
11375 }
11376
11377 /// \brief High-level routine to lower various 512-bit x86 vector shuffles.
11378 ///
11379 /// This routine either breaks down the specific type of a 512-bit x86 vector
11380 /// shuffle or splits it into two 256-bit shuffles and fuses the results back
11381 /// together based on the available instructions.
11382 static SDValue lower512BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11383                                         MVT VT, const X86Subtarget *Subtarget,
11384                                         SelectionDAG &DAG) {
11385   SDLoc DL(Op);
11386   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11387   ArrayRef<int> Mask = SVOp->getMask();
11388   assert(Subtarget->hasAVX512() &&
11389          "Cannot lower 512-bit vectors w/ basic ISA!");
11390
11391   // Check for being able to broadcast a single element.
11392   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(VT.SimpleTy, DL, V1,
11393                                                         Mask, Subtarget, DAG))
11394     return Broadcast;
11395
11396   // Dispatch to each element type for lowering. If we don't have supprot for
11397   // specific element type shuffles at 512 bits, immediately split them and
11398   // lower them. Each lowering routine of a given type is allowed to assume that
11399   // the requisite ISA extensions for that element type are available.
11400   switch (VT.SimpleTy) {
11401   case MVT::v8f64:
11402     return lowerV8F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
11403   case MVT::v16f32:
11404     return lowerV16F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
11405   case MVT::v8i64:
11406     return lowerV8I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
11407   case MVT::v16i32:
11408     return lowerV16I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
11409   case MVT::v32i16:
11410     if (Subtarget->hasBWI())
11411       return lowerV32I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
11412     break;
11413   case MVT::v64i8:
11414     if (Subtarget->hasBWI())
11415       return lowerV64I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
11416     break;
11417
11418   default:
11419     llvm_unreachable("Not a valid 512-bit x86 vector type!");
11420   }
11421
11422   // Otherwise fall back on splitting.
11423   return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
11424 }
11425
11426 /// \brief Top-level lowering for x86 vector shuffles.
11427 ///
11428 /// This handles decomposition, canonicalization, and lowering of all x86
11429 /// vector shuffles. Most of the specific lowering strategies are encapsulated
11430 /// above in helper routines. The canonicalization attempts to widen shuffles
11431 /// to involve fewer lanes of wider elements, consolidate symmetric patterns
11432 /// s.t. only one of the two inputs needs to be tested, etc.
11433 static SDValue lowerVectorShuffle(SDValue Op, const X86Subtarget *Subtarget,
11434                                   SelectionDAG &DAG) {
11435   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11436   ArrayRef<int> Mask = SVOp->getMask();
11437   SDValue V1 = Op.getOperand(0);
11438   SDValue V2 = Op.getOperand(1);
11439   MVT VT = Op.getSimpleValueType();
11440   int NumElements = VT.getVectorNumElements();
11441   SDLoc dl(Op);
11442
11443   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
11444
11445   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
11446   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
11447   if (V1IsUndef && V2IsUndef)
11448     return DAG.getUNDEF(VT);
11449
11450   // When we create a shuffle node we put the UNDEF node to second operand,
11451   // but in some cases the first operand may be transformed to UNDEF.
11452   // In this case we should just commute the node.
11453   if (V1IsUndef)
11454     return DAG.getCommutedVectorShuffle(*SVOp);
11455
11456   // Check for non-undef masks pointing at an undef vector and make the masks
11457   // undef as well. This makes it easier to match the shuffle based solely on
11458   // the mask.
11459   if (V2IsUndef)
11460     for (int M : Mask)
11461       if (M >= NumElements) {
11462         SmallVector<int, 8> NewMask(Mask.begin(), Mask.end());
11463         for (int &M : NewMask)
11464           if (M >= NumElements)
11465             M = -1;
11466         return DAG.getVectorShuffle(VT, dl, V1, V2, NewMask);
11467       }
11468
11469   // We actually see shuffles that are entirely re-arrangements of a set of
11470   // zero inputs. This mostly happens while decomposing complex shuffles into
11471   // simple ones. Directly lower these as a buildvector of zeros.
11472   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
11473   if (Zeroable.all())
11474     return getZeroVector(VT, Subtarget, DAG, dl);
11475
11476   // Try to collapse shuffles into using a vector type with fewer elements but
11477   // wider element types. We cap this to not form integers or floating point
11478   // elements wider than 64 bits, but it might be interesting to form i128
11479   // integers to handle flipping the low and high halves of AVX 256-bit vectors.
11480   SmallVector<int, 16> WidenedMask;
11481   if (VT.getScalarSizeInBits() < 64 &&
11482       canWidenShuffleElements(Mask, WidenedMask)) {
11483     MVT NewEltVT = VT.isFloatingPoint()
11484                        ? MVT::getFloatingPointVT(VT.getScalarSizeInBits() * 2)
11485                        : MVT::getIntegerVT(VT.getScalarSizeInBits() * 2);
11486     MVT NewVT = MVT::getVectorVT(NewEltVT, VT.getVectorNumElements() / 2);
11487     // Make sure that the new vector type is legal. For example, v2f64 isn't
11488     // legal on SSE1.
11489     if (DAG.getTargetLoweringInfo().isTypeLegal(NewVT)) {
11490       V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, V1);
11491       V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, V2);
11492       return DAG.getNode(ISD::BITCAST, dl, VT,
11493                          DAG.getVectorShuffle(NewVT, dl, V1, V2, WidenedMask));
11494     }
11495   }
11496
11497   int NumV1Elements = 0, NumUndefElements = 0, NumV2Elements = 0;
11498   for (int M : SVOp->getMask())
11499     if (M < 0)
11500       ++NumUndefElements;
11501     else if (M < NumElements)
11502       ++NumV1Elements;
11503     else
11504       ++NumV2Elements;
11505
11506   // Commute the shuffle as needed such that more elements come from V1 than
11507   // V2. This allows us to match the shuffle pattern strictly on how many
11508   // elements come from V1 without handling the symmetric cases.
11509   if (NumV2Elements > NumV1Elements)
11510     return DAG.getCommutedVectorShuffle(*SVOp);
11511
11512   // When the number of V1 and V2 elements are the same, try to minimize the
11513   // number of uses of V2 in the low half of the vector. When that is tied,
11514   // ensure that the sum of indices for V1 is equal to or lower than the sum
11515   // indices for V2. When those are equal, try to ensure that the number of odd
11516   // indices for V1 is lower than the number of odd indices for V2.
11517   if (NumV1Elements == NumV2Elements) {
11518     int LowV1Elements = 0, LowV2Elements = 0;
11519     for (int M : SVOp->getMask().slice(0, NumElements / 2))
11520       if (M >= NumElements)
11521         ++LowV2Elements;
11522       else if (M >= 0)
11523         ++LowV1Elements;
11524     if (LowV2Elements > LowV1Elements) {
11525       return DAG.getCommutedVectorShuffle(*SVOp);
11526     } else if (LowV2Elements == LowV1Elements) {
11527       int SumV1Indices = 0, SumV2Indices = 0;
11528       for (int i = 0, Size = SVOp->getMask().size(); i < Size; ++i)
11529         if (SVOp->getMask()[i] >= NumElements)
11530           SumV2Indices += i;
11531         else if (SVOp->getMask()[i] >= 0)
11532           SumV1Indices += i;
11533       if (SumV2Indices < SumV1Indices) {
11534         return DAG.getCommutedVectorShuffle(*SVOp);
11535       } else if (SumV2Indices == SumV1Indices) {
11536         int NumV1OddIndices = 0, NumV2OddIndices = 0;
11537         for (int i = 0, Size = SVOp->getMask().size(); i < Size; ++i)
11538           if (SVOp->getMask()[i] >= NumElements)
11539             NumV2OddIndices += i % 2;
11540           else if (SVOp->getMask()[i] >= 0)
11541             NumV1OddIndices += i % 2;
11542         if (NumV2OddIndices < NumV1OddIndices)
11543           return DAG.getCommutedVectorShuffle(*SVOp);
11544       }
11545     }
11546   }
11547
11548   // For each vector width, delegate to a specialized lowering routine.
11549   if (VT.getSizeInBits() == 128)
11550     return lower128BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11551
11552   if (VT.getSizeInBits() == 256)
11553     return lower256BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11554
11555   // Force AVX-512 vectors to be scalarized for now.
11556   // FIXME: Implement AVX-512 support!
11557   if (VT.getSizeInBits() == 512)
11558     return lower512BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11559
11560   llvm_unreachable("Unimplemented!");
11561 }
11562
11563
11564 //===----------------------------------------------------------------------===//
11565 // Legacy vector shuffle lowering
11566 //
11567 // This code is the legacy code handling vector shuffles until the above
11568 // replaces its functionality and performance.
11569 //===----------------------------------------------------------------------===//
11570
11571 static bool isBlendMask(ArrayRef<int> MaskVals, MVT VT, bool hasSSE41,
11572                         bool hasInt256, unsigned *MaskOut = nullptr) {
11573   MVT EltVT = VT.getVectorElementType();
11574
11575   // There is no blend with immediate in AVX-512.
11576   if (VT.is512BitVector())
11577     return false;
11578
11579   if (!hasSSE41 || EltVT == MVT::i8)
11580     return false;
11581   if (!hasInt256 && VT == MVT::v16i16)
11582     return false;
11583
11584   unsigned MaskValue = 0;
11585   unsigned NumElems = VT.getVectorNumElements();
11586   // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
11587   unsigned NumLanes = (NumElems - 1) / 8 + 1;
11588   unsigned NumElemsInLane = NumElems / NumLanes;
11589
11590   // Blend for v16i16 should be symmetric for both lanes.
11591   for (unsigned i = 0; i < NumElemsInLane; ++i) {
11592
11593     int SndLaneEltIdx = (NumLanes == 2) ? MaskVals[i + NumElemsInLane] : -1;
11594     int EltIdx = MaskVals[i];
11595
11596     if ((EltIdx < 0 || EltIdx == (int)i) &&
11597         (SndLaneEltIdx < 0 || SndLaneEltIdx == (int)(i + NumElemsInLane)))
11598       continue;
11599
11600     if (((unsigned)EltIdx == (i + NumElems)) &&
11601         (SndLaneEltIdx < 0 ||
11602          (unsigned)SndLaneEltIdx == i + NumElems + NumElemsInLane))
11603       MaskValue |= (1 << i);
11604     else
11605       return false;
11606   }
11607
11608   if (MaskOut)
11609     *MaskOut = MaskValue;
11610   return true;
11611 }
11612
11613 // Try to lower a shuffle node into a simple blend instruction.
11614 // This function assumes isBlendMask returns true for this
11615 // SuffleVectorSDNode
11616 static SDValue LowerVECTOR_SHUFFLEtoBlend(ShuffleVectorSDNode *SVOp,
11617                                           unsigned MaskValue,
11618                                           const X86Subtarget *Subtarget,
11619                                           SelectionDAG &DAG) {
11620   MVT VT = SVOp->getSimpleValueType(0);
11621   MVT EltVT = VT.getVectorElementType();
11622   assert(isBlendMask(SVOp->getMask(), VT, Subtarget->hasSSE41(),
11623                      Subtarget->hasInt256() && "Trying to lower a "
11624                                                "VECTOR_SHUFFLE to a Blend but "
11625                                                "with the wrong mask"));
11626   SDValue V1 = SVOp->getOperand(0);
11627   SDValue V2 = SVOp->getOperand(1);
11628   SDLoc dl(SVOp);
11629   unsigned NumElems = VT.getVectorNumElements();
11630
11631   // Convert i32 vectors to floating point if it is not AVX2.
11632   // AVX2 introduced VPBLENDD instruction for 128 and 256-bit vectors.
11633   MVT BlendVT = VT;
11634   if (EltVT == MVT::i64 || (EltVT == MVT::i32 && !Subtarget->hasInt256())) {
11635     BlendVT = MVT::getVectorVT(MVT::getFloatingPointVT(EltVT.getSizeInBits()),
11636                                NumElems);
11637     V1 = DAG.getNode(ISD::BITCAST, dl, VT, V1);
11638     V2 = DAG.getNode(ISD::BITCAST, dl, VT, V2);
11639   }
11640
11641   SDValue Ret = DAG.getNode(X86ISD::BLENDI, dl, BlendVT, V1, V2,
11642                             DAG.getConstant(MaskValue, MVT::i32));
11643   return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
11644 }
11645
11646 /// In vector type \p VT, return true if the element at index \p InputIdx
11647 /// falls on a different 128-bit lane than \p OutputIdx.
11648 static bool ShuffleCrosses128bitLane(MVT VT, unsigned InputIdx,
11649                                      unsigned OutputIdx) {
11650   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
11651   return InputIdx * EltSize / 128 != OutputIdx * EltSize / 128;
11652 }
11653
11654 /// Generate a PSHUFB if possible.  Selects elements from \p V1 according to
11655 /// \p MaskVals.  MaskVals[OutputIdx] = InputIdx specifies that we want to
11656 /// shuffle the element at InputIdx in V1 to OutputIdx in the result.  If \p
11657 /// MaskVals refers to elements outside of \p V1 or is undef (-1), insert a
11658 /// zero.
11659 static SDValue getPSHUFB(ArrayRef<int> MaskVals, SDValue V1, SDLoc &dl,
11660                          SelectionDAG &DAG) {
11661   MVT VT = V1.getSimpleValueType();
11662   assert(VT.is128BitVector() || VT.is256BitVector());
11663
11664   MVT EltVT = VT.getVectorElementType();
11665   unsigned EltSizeInBytes = EltVT.getSizeInBits() / 8;
11666   unsigned NumElts = VT.getVectorNumElements();
11667
11668   SmallVector<SDValue, 32> PshufbMask;
11669   for (unsigned OutputIdx = 0; OutputIdx < NumElts; ++OutputIdx) {
11670     int InputIdx = MaskVals[OutputIdx];
11671     unsigned InputByteIdx;
11672
11673     if (InputIdx < 0 || NumElts <= (unsigned)InputIdx)
11674       InputByteIdx = 0x80;
11675     else {
11676       // Cross lane is not allowed.
11677       if (ShuffleCrosses128bitLane(VT, InputIdx, OutputIdx))
11678         return SDValue();
11679       InputByteIdx = InputIdx * EltSizeInBytes;
11680       // Index is an byte offset within the 128-bit lane.
11681       InputByteIdx &= 0xf;
11682     }
11683
11684     for (unsigned j = 0; j < EltSizeInBytes; ++j) {
11685       PshufbMask.push_back(DAG.getConstant(InputByteIdx, MVT::i8));
11686       if (InputByteIdx != 0x80)
11687         ++InputByteIdx;
11688     }
11689   }
11690
11691   MVT ShufVT = MVT::getVectorVT(MVT::i8, PshufbMask.size());
11692   if (ShufVT != VT)
11693     V1 = DAG.getNode(ISD::BITCAST, dl, ShufVT, V1);
11694   return DAG.getNode(X86ISD::PSHUFB, dl, ShufVT, V1,
11695                      DAG.getNode(ISD::BUILD_VECTOR, dl, ShufVT, PshufbMask));
11696 }
11697
11698 // v8i16 shuffles - Prefer shuffles in the following order:
11699 // 1. [all]   pshuflw, pshufhw, optional move
11700 // 2. [ssse3] 1 x pshufb
11701 // 3. [ssse3] 2 x pshufb + 1 x por
11702 // 4. [all]   mov + pshuflw + pshufhw + N x (pextrw + pinsrw)
11703 static SDValue
11704 LowerVECTOR_SHUFFLEv8i16(SDValue Op, const X86Subtarget *Subtarget,
11705                          SelectionDAG &DAG) {
11706   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11707   SDValue V1 = SVOp->getOperand(0);
11708   SDValue V2 = SVOp->getOperand(1);
11709   SDLoc dl(SVOp);
11710   SmallVector<int, 8> MaskVals;
11711
11712   // Determine if more than 1 of the words in each of the low and high quadwords
11713   // of the result come from the same quadword of one of the two inputs.  Undef
11714   // mask values count as coming from any quadword, for better codegen.
11715   //
11716   // Lo/HiQuad[i] = j indicates how many words from the ith quad of the input
11717   // feeds this quad.  For i, 0 and 1 refer to V1, 2 and 3 refer to V2.
11718   unsigned LoQuad[] = { 0, 0, 0, 0 };
11719   unsigned HiQuad[] = { 0, 0, 0, 0 };
11720   // Indices of quads used.
11721   std::bitset<4> InputQuads;
11722   for (unsigned i = 0; i < 8; ++i) {
11723     unsigned *Quad = i < 4 ? LoQuad : HiQuad;
11724     int EltIdx = SVOp->getMaskElt(i);
11725     MaskVals.push_back(EltIdx);
11726     if (EltIdx < 0) {
11727       ++Quad[0];
11728       ++Quad[1];
11729       ++Quad[2];
11730       ++Quad[3];
11731       continue;
11732     }
11733     ++Quad[EltIdx / 4];
11734     InputQuads.set(EltIdx / 4);
11735   }
11736
11737   int BestLoQuad = -1;
11738   unsigned MaxQuad = 1;
11739   for (unsigned i = 0; i < 4; ++i) {
11740     if (LoQuad[i] > MaxQuad) {
11741       BestLoQuad = i;
11742       MaxQuad = LoQuad[i];
11743     }
11744   }
11745
11746   int BestHiQuad = -1;
11747   MaxQuad = 1;
11748   for (unsigned i = 0; i < 4; ++i) {
11749     if (HiQuad[i] > MaxQuad) {
11750       BestHiQuad = i;
11751       MaxQuad = HiQuad[i];
11752     }
11753   }
11754
11755   // For SSSE3, If all 8 words of the result come from only 1 quadword of each
11756   // of the two input vectors, shuffle them into one input vector so only a
11757   // single pshufb instruction is necessary. If there are more than 2 input
11758   // quads, disable the next transformation since it does not help SSSE3.
11759   bool V1Used = InputQuads[0] || InputQuads[1];
11760   bool V2Used = InputQuads[2] || InputQuads[3];
11761   if (Subtarget->hasSSSE3()) {
11762     if (InputQuads.count() == 2 && V1Used && V2Used) {
11763       BestLoQuad = InputQuads[0] ? 0 : 1;
11764       BestHiQuad = InputQuads[2] ? 2 : 3;
11765     }
11766     if (InputQuads.count() > 2) {
11767       BestLoQuad = -1;
11768       BestHiQuad = -1;
11769     }
11770   }
11771
11772   // If BestLoQuad or BestHiQuad are set, shuffle the quads together and update
11773   // the shuffle mask.  If a quad is scored as -1, that means that it contains
11774   // words from all 4 input quadwords.
11775   SDValue NewV;
11776   if (BestLoQuad >= 0 || BestHiQuad >= 0) {
11777     int MaskV[] = {
11778       BestLoQuad < 0 ? 0 : BestLoQuad,
11779       BestHiQuad < 0 ? 1 : BestHiQuad
11780     };
11781     NewV = DAG.getVectorShuffle(MVT::v2i64, dl,
11782                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1),
11783                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2), &MaskV[0]);
11784     NewV = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, NewV);
11785
11786     // Rewrite the MaskVals and assign NewV to V1 if NewV now contains all the
11787     // source words for the shuffle, to aid later transformations.
11788     bool AllWordsInNewV = true;
11789     bool InOrder[2] = { true, true };
11790     for (unsigned i = 0; i != 8; ++i) {
11791       int idx = MaskVals[i];
11792       if (idx != (int)i)
11793         InOrder[i/4] = false;
11794       if (idx < 0 || (idx/4) == BestLoQuad || (idx/4) == BestHiQuad)
11795         continue;
11796       AllWordsInNewV = false;
11797       break;
11798     }
11799
11800     bool pshuflw = AllWordsInNewV, pshufhw = AllWordsInNewV;
11801     if (AllWordsInNewV) {
11802       for (int i = 0; i != 8; ++i) {
11803         int idx = MaskVals[i];
11804         if (idx < 0)
11805           continue;
11806         idx = MaskVals[i] = (idx / 4) == BestLoQuad ? (idx & 3) : (idx & 3) + 4;
11807         if ((idx != i) && idx < 4)
11808           pshufhw = false;
11809         if ((idx != i) && idx > 3)
11810           pshuflw = false;
11811       }
11812       V1 = NewV;
11813       V2Used = false;
11814       BestLoQuad = 0;
11815       BestHiQuad = 1;
11816     }
11817
11818     // If we've eliminated the use of V2, and the new mask is a pshuflw or
11819     // pshufhw, that's as cheap as it gets.  Return the new shuffle.
11820     if ((pshufhw && InOrder[0]) || (pshuflw && InOrder[1])) {
11821       unsigned Opc = pshufhw ? X86ISD::PSHUFHW : X86ISD::PSHUFLW;
11822       unsigned TargetMask = 0;
11823       NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV,
11824                                   DAG.getUNDEF(MVT::v8i16), &MaskVals[0]);
11825       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11826       TargetMask = pshufhw ? getShufflePSHUFHWImmediate(SVOp):
11827                              getShufflePSHUFLWImmediate(SVOp);
11828       V1 = NewV.getOperand(0);
11829       return getTargetShuffleNode(Opc, dl, MVT::v8i16, V1, TargetMask, DAG);
11830     }
11831   }
11832
11833   // Promote splats to a larger type which usually leads to more efficient code.
11834   // FIXME: Is this true if pshufb is available?
11835   if (SVOp->isSplat())
11836     return PromoteSplat(SVOp, DAG);
11837
11838   // If we have SSSE3, and all words of the result are from 1 input vector,
11839   // case 2 is generated, otherwise case 3 is generated.  If no SSSE3
11840   // is present, fall back to case 4.
11841   if (Subtarget->hasSSSE3()) {
11842     SmallVector<SDValue,16> pshufbMask;
11843
11844     // If we have elements from both input vectors, set the high bit of the
11845     // shuffle mask element to zero out elements that come from V2 in the V1
11846     // mask, and elements that come from V1 in the V2 mask, so that the two
11847     // results can be OR'd together.
11848     bool TwoInputs = V1Used && V2Used;
11849     V1 = getPSHUFB(MaskVals, V1, dl, DAG);
11850     if (!TwoInputs)
11851       return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
11852
11853     // Calculate the shuffle mask for the second input, shuffle it, and
11854     // OR it with the first shuffled input.
11855     CommuteVectorShuffleMask(MaskVals, 8);
11856     V2 = getPSHUFB(MaskVals, V2, dl, DAG);
11857     V1 = DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
11858     return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
11859   }
11860
11861   // If BestLoQuad >= 0, generate a pshuflw to put the low elements in order,
11862   // and update MaskVals with new element order.
11863   std::bitset<8> InOrder;
11864   if (BestLoQuad >= 0) {
11865     int MaskV[] = { -1, -1, -1, -1, 4, 5, 6, 7 };
11866     for (int i = 0; i != 4; ++i) {
11867       int idx = MaskVals[i];
11868       if (idx < 0) {
11869         InOrder.set(i);
11870       } else if ((idx / 4) == BestLoQuad) {
11871         MaskV[i] = idx & 3;
11872         InOrder.set(i);
11873       }
11874     }
11875     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
11876                                 &MaskV[0]);
11877
11878     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSE2()) {
11879       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11880       NewV = getTargetShuffleNode(X86ISD::PSHUFLW, dl, MVT::v8i16,
11881                                   NewV.getOperand(0),
11882                                   getShufflePSHUFLWImmediate(SVOp), DAG);
11883     }
11884   }
11885
11886   // If BestHi >= 0, generate a pshufhw to put the high elements in order,
11887   // and update MaskVals with the new element order.
11888   if (BestHiQuad >= 0) {
11889     int MaskV[] = { 0, 1, 2, 3, -1, -1, -1, -1 };
11890     for (unsigned i = 4; i != 8; ++i) {
11891       int idx = MaskVals[i];
11892       if (idx < 0) {
11893         InOrder.set(i);
11894       } else if ((idx / 4) == BestHiQuad) {
11895         MaskV[i] = (idx & 3) + 4;
11896         InOrder.set(i);
11897       }
11898     }
11899     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
11900                                 &MaskV[0]);
11901
11902     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSE2()) {
11903       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11904       NewV = getTargetShuffleNode(X86ISD::PSHUFHW, dl, MVT::v8i16,
11905                                   NewV.getOperand(0),
11906                                   getShufflePSHUFHWImmediate(SVOp), DAG);
11907     }
11908   }
11909
11910   // In case BestHi & BestLo were both -1, which means each quadword has a word
11911   // from each of the four input quadwords, calculate the InOrder bitvector now
11912   // before falling through to the insert/extract cleanup.
11913   if (BestLoQuad == -1 && BestHiQuad == -1) {
11914     NewV = V1;
11915     for (int i = 0; i != 8; ++i)
11916       if (MaskVals[i] < 0 || MaskVals[i] == i)
11917         InOrder.set(i);
11918   }
11919
11920   // The other elements are put in the right place using pextrw and pinsrw.
11921   for (unsigned i = 0; i != 8; ++i) {
11922     if (InOrder[i])
11923       continue;
11924     int EltIdx = MaskVals[i];
11925     if (EltIdx < 0)
11926       continue;
11927     SDValue ExtOp = (EltIdx < 8) ?
11928       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V1,
11929                   DAG.getIntPtrConstant(EltIdx)) :
11930       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V2,
11931                   DAG.getIntPtrConstant(EltIdx - 8));
11932     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, ExtOp,
11933                        DAG.getIntPtrConstant(i));
11934   }
11935   return NewV;
11936 }
11937
11938 /// \brief v16i16 shuffles
11939 ///
11940 /// FIXME: We only support generation of a single pshufb currently.  We can
11941 /// generalize the other applicable cases from LowerVECTOR_SHUFFLEv8i16 as
11942 /// well (e.g 2 x pshufb + 1 x por).
11943 static SDValue
11944 LowerVECTOR_SHUFFLEv16i16(SDValue Op, SelectionDAG &DAG) {
11945   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11946   SDValue V1 = SVOp->getOperand(0);
11947   SDValue V2 = SVOp->getOperand(1);
11948   SDLoc dl(SVOp);
11949
11950   if (V2.getOpcode() != ISD::UNDEF)
11951     return SDValue();
11952
11953   SmallVector<int, 16> MaskVals(SVOp->getMask().begin(), SVOp->getMask().end());
11954   return getPSHUFB(MaskVals, V1, dl, DAG);
11955 }
11956
11957 // v16i8 shuffles - Prefer shuffles in the following order:
11958 // 1. [ssse3] 1 x pshufb
11959 // 2. [ssse3] 2 x pshufb + 1 x por
11960 // 3. [all]   v8i16 shuffle + N x pextrw + rotate + pinsrw
11961 static SDValue LowerVECTOR_SHUFFLEv16i8(ShuffleVectorSDNode *SVOp,
11962                                         const X86Subtarget* Subtarget,
11963                                         SelectionDAG &DAG) {
11964   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
11965   SDValue V1 = SVOp->getOperand(0);
11966   SDValue V2 = SVOp->getOperand(1);
11967   SDLoc dl(SVOp);
11968   ArrayRef<int> MaskVals = SVOp->getMask();
11969
11970   // Promote splats to a larger type which usually leads to more efficient code.
11971   // FIXME: Is this true if pshufb is available?
11972   if (SVOp->isSplat())
11973     return PromoteSplat(SVOp, DAG);
11974
11975   // If we have SSSE3, case 1 is generated when all result bytes come from
11976   // one of  the inputs.  Otherwise, case 2 is generated.  If no SSSE3 is
11977   // present, fall back to case 3.
11978
11979   // If SSSE3, use 1 pshufb instruction per vector with elements in the result.
11980   if (Subtarget->hasSSSE3()) {
11981     SmallVector<SDValue,16> pshufbMask;
11982
11983     // If all result elements are from one input vector, then only translate
11984     // undef mask values to 0x80 (zero out result) in the pshufb mask.
11985     //
11986     // Otherwise, we have elements from both input vectors, and must zero out
11987     // elements that come from V2 in the first mask, and V1 in the second mask
11988     // so that we can OR them together.
11989     for (unsigned i = 0; i != 16; ++i) {
11990       int EltIdx = MaskVals[i];
11991       if (EltIdx < 0 || EltIdx >= 16)
11992         EltIdx = 0x80;
11993       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
11994     }
11995     V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
11996                      DAG.getNode(ISD::BUILD_VECTOR, dl,
11997                                  MVT::v16i8, pshufbMask));
11998
11999     // As PSHUFB will zero elements with negative indices, it's safe to ignore
12000     // the 2nd operand if it's undefined or zero.
12001     if (V2.getOpcode() == ISD::UNDEF ||
12002         ISD::isBuildVectorAllZeros(V2.getNode()))
12003       return V1;
12004
12005     // Calculate the shuffle mask for the second input, shuffle it, and
12006     // OR it with the first shuffled input.
12007     pshufbMask.clear();
12008     for (unsigned i = 0; i != 16; ++i) {
12009       int EltIdx = MaskVals[i];
12010       EltIdx = (EltIdx < 16) ? 0x80 : EltIdx - 16;
12011       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
12012     }
12013     V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
12014                      DAG.getNode(ISD::BUILD_VECTOR, dl,
12015                                  MVT::v16i8, pshufbMask));
12016     return DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
12017   }
12018
12019   // No SSSE3 - Calculate in place words and then fix all out of place words
12020   // With 0-16 extracts & inserts.  Worst case is 16 bytes out of order from
12021   // the 16 different words that comprise the two doublequadword input vectors.
12022   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
12023   V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
12024   SDValue NewV = V1;
12025   for (int i = 0; i != 8; ++i) {
12026     int Elt0 = MaskVals[i*2];
12027     int Elt1 = MaskVals[i*2+1];
12028
12029     // This word of the result is all undef, skip it.
12030     if (Elt0 < 0 && Elt1 < 0)
12031       continue;
12032
12033     // This word of the result is already in the correct place, skip it.
12034     if ((Elt0 == i*2) && (Elt1 == i*2+1))
12035       continue;
12036
12037     SDValue Elt0Src = Elt0 < 16 ? V1 : V2;
12038     SDValue Elt1Src = Elt1 < 16 ? V1 : V2;
12039     SDValue InsElt;
12040
12041     // If Elt0 and Elt1 are defined, are consecutive, and can be load
12042     // using a single extract together, load it and store it.
12043     if ((Elt0 >= 0) && ((Elt0 + 1) == Elt1) && ((Elt0 & 1) == 0)) {
12044       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
12045                            DAG.getIntPtrConstant(Elt1 / 2));
12046       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
12047                         DAG.getIntPtrConstant(i));
12048       continue;
12049     }
12050
12051     // If Elt1 is defined, extract it from the appropriate source.  If the
12052     // source byte is not also odd, shift the extracted word left 8 bits
12053     // otherwise clear the bottom 8 bits if we need to do an or.
12054     if (Elt1 >= 0) {
12055       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
12056                            DAG.getIntPtrConstant(Elt1 / 2));
12057       if ((Elt1 & 1) == 0)
12058         InsElt = DAG.getNode(ISD::SHL, dl, MVT::i16, InsElt,
12059                              DAG.getConstant(8,
12060                                   TLI.getShiftAmountTy(InsElt.getValueType())));
12061       else if (Elt0 >= 0)
12062         InsElt = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt,
12063                              DAG.getConstant(0xFF00, MVT::i16));
12064     }
12065     // If Elt0 is defined, extract it from the appropriate source.  If the
12066     // source byte is not also even, shift the extracted word right 8 bits. If
12067     // Elt1 was also defined, OR the extracted values together before
12068     // inserting them in the result.
12069     if (Elt0 >= 0) {
12070       SDValue InsElt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
12071                                     Elt0Src, DAG.getIntPtrConstant(Elt0 / 2));
12072       if ((Elt0 & 1) != 0)
12073         InsElt0 = DAG.getNode(ISD::SRL, dl, MVT::i16, InsElt0,
12074                               DAG.getConstant(8,
12075                                  TLI.getShiftAmountTy(InsElt0.getValueType())));
12076       else if (Elt1 >= 0)
12077         InsElt0 = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt0,
12078                              DAG.getConstant(0x00FF, MVT::i16));
12079       InsElt = Elt1 >= 0 ? DAG.getNode(ISD::OR, dl, MVT::i16, InsElt, InsElt0)
12080                          : InsElt0;
12081     }
12082     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
12083                        DAG.getIntPtrConstant(i));
12084   }
12085   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, NewV);
12086 }
12087
12088 // v32i8 shuffles - Translate to VPSHUFB if possible.
12089 static
12090 SDValue LowerVECTOR_SHUFFLEv32i8(ShuffleVectorSDNode *SVOp,
12091                                  const X86Subtarget *Subtarget,
12092                                  SelectionDAG &DAG) {
12093   MVT VT = SVOp->getSimpleValueType(0);
12094   SDValue V1 = SVOp->getOperand(0);
12095   SDValue V2 = SVOp->getOperand(1);
12096   SDLoc dl(SVOp);
12097   SmallVector<int, 32> MaskVals(SVOp->getMask().begin(), SVOp->getMask().end());
12098
12099   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
12100   bool V1IsAllZero = ISD::isBuildVectorAllZeros(V1.getNode());
12101   bool V2IsAllZero = ISD::isBuildVectorAllZeros(V2.getNode());
12102
12103   // VPSHUFB may be generated if
12104   // (1) one of input vector is undefined or zeroinitializer.
12105   // The mask value 0x80 puts 0 in the corresponding slot of the vector.
12106   // And (2) the mask indexes don't cross the 128-bit lane.
12107   if (VT != MVT::v32i8 || !Subtarget->hasInt256() ||
12108       (!V2IsUndef && !V2IsAllZero && !V1IsAllZero))
12109     return SDValue();
12110
12111   if (V1IsAllZero && !V2IsAllZero) {
12112     CommuteVectorShuffleMask(MaskVals, 32);
12113     V1 = V2;
12114   }
12115   return getPSHUFB(MaskVals, V1, dl, DAG);
12116 }
12117
12118 /// RewriteAsNarrowerShuffle - Try rewriting v8i16 and v16i8 shuffles as 4 wide
12119 /// ones, or rewriting v4i32 / v4f32 as 2 wide ones if possible. This can be
12120 /// done when every pair / quad of shuffle mask elements point to elements in
12121 /// the right sequence. e.g.
12122 /// vector_shuffle X, Y, <2, 3, | 10, 11, | 0, 1, | 14, 15>
12123 static
12124 SDValue RewriteAsNarrowerShuffle(ShuffleVectorSDNode *SVOp,
12125                                  SelectionDAG &DAG) {
12126   MVT VT = SVOp->getSimpleValueType(0);
12127   SDLoc dl(SVOp);
12128   unsigned NumElems = VT.getVectorNumElements();
12129   MVT NewVT;
12130   unsigned Scale;
12131   switch (VT.SimpleTy) {
12132   default: llvm_unreachable("Unexpected!");
12133   case MVT::v2i64:
12134   case MVT::v2f64:
12135            return SDValue(SVOp, 0);
12136   case MVT::v4f32:  NewVT = MVT::v2f64; Scale = 2; break;
12137   case MVT::v4i32:  NewVT = MVT::v2i64; Scale = 2; break;
12138   case MVT::v8i16:  NewVT = MVT::v4i32; Scale = 2; break;
12139   case MVT::v16i8:  NewVT = MVT::v4i32; Scale = 4; break;
12140   case MVT::v16i16: NewVT = MVT::v8i32; Scale = 2; break;
12141   case MVT::v32i8:  NewVT = MVT::v8i32; Scale = 4; break;
12142   }
12143
12144   SmallVector<int, 8> MaskVec;
12145   for (unsigned i = 0; i != NumElems; i += Scale) {
12146     int StartIdx = -1;
12147     for (unsigned j = 0; j != Scale; ++j) {
12148       int EltIdx = SVOp->getMaskElt(i+j);
12149       if (EltIdx < 0)
12150         continue;
12151       if (StartIdx < 0)
12152         StartIdx = (EltIdx / Scale);
12153       if (EltIdx != (int)(StartIdx*Scale + j))
12154         return SDValue();
12155     }
12156     MaskVec.push_back(StartIdx);
12157   }
12158
12159   SDValue V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(0));
12160   SDValue V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(1));
12161   return DAG.getVectorShuffle(NewVT, dl, V1, V2, &MaskVec[0]);
12162 }
12163
12164 /// getVZextMovL - Return a zero-extending vector move low node.
12165 ///
12166 static SDValue getVZextMovL(MVT VT, MVT OpVT,
12167                             SDValue SrcOp, SelectionDAG &DAG,
12168                             const X86Subtarget *Subtarget, SDLoc dl) {
12169   if (VT == MVT::v2f64 || VT == MVT::v4f32) {
12170     LoadSDNode *LD = nullptr;
12171     if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
12172       LD = dyn_cast<LoadSDNode>(SrcOp);
12173     if (!LD) {
12174       // movssrr and movsdrr do not clear top bits. Try to use movd, movq
12175       // instead.
12176       MVT ExtVT = (OpVT == MVT::v2f64) ? MVT::i64 : MVT::i32;
12177       if ((ExtVT != MVT::i64 || Subtarget->is64Bit()) &&
12178           SrcOp.getOpcode() == ISD::SCALAR_TO_VECTOR &&
12179           SrcOp.getOperand(0).getOpcode() == ISD::BITCAST &&
12180           SrcOp.getOperand(0).getOperand(0).getValueType() == ExtVT) {
12181         // PR2108
12182         OpVT = (OpVT == MVT::v2f64) ? MVT::v2i64 : MVT::v4i32;
12183         return DAG.getNode(ISD::BITCAST, dl, VT,
12184                            DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
12185                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
12186                                                    OpVT,
12187                                                    SrcOp.getOperand(0)
12188                                                           .getOperand(0))));
12189       }
12190     }
12191   }
12192
12193   return DAG.getNode(ISD::BITCAST, dl, VT,
12194                      DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
12195                                  DAG.getNode(ISD::BITCAST, dl,
12196                                              OpVT, SrcOp)));
12197 }
12198
12199 /// LowerVECTOR_SHUFFLE_256 - Handle all 256-bit wide vectors shuffles
12200 /// which could not be matched by any known target speficic shuffle
12201 static SDValue
12202 LowerVECTOR_SHUFFLE_256(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
12203
12204   SDValue NewOp = Compact8x32ShuffleNode(SVOp, DAG);
12205   if (NewOp.getNode())
12206     return NewOp;
12207
12208   MVT VT = SVOp->getSimpleValueType(0);
12209
12210   unsigned NumElems = VT.getVectorNumElements();
12211   unsigned NumLaneElems = NumElems / 2;
12212
12213   SDLoc dl(SVOp);
12214   MVT EltVT = VT.getVectorElementType();
12215   MVT NVT = MVT::getVectorVT(EltVT, NumLaneElems);
12216   SDValue Output[2];
12217
12218   SmallVector<int, 16> Mask;
12219   for (unsigned l = 0; l < 2; ++l) {
12220     // Build a shuffle mask for the output, discovering on the fly which
12221     // input vectors to use as shuffle operands (recorded in InputUsed).
12222     // If building a suitable shuffle vector proves too hard, then bail
12223     // out with UseBuildVector set.
12224     bool UseBuildVector = false;
12225     int InputUsed[2] = { -1, -1 }; // Not yet discovered.
12226     unsigned LaneStart = l * NumLaneElems;
12227     for (unsigned i = 0; i != NumLaneElems; ++i) {
12228       // The mask element.  This indexes into the input.
12229       int Idx = SVOp->getMaskElt(i+LaneStart);
12230       if (Idx < 0) {
12231         // the mask element does not index into any input vector.
12232         Mask.push_back(-1);
12233         continue;
12234       }
12235
12236       // The input vector this mask element indexes into.
12237       int Input = Idx / NumLaneElems;
12238
12239       // Turn the index into an offset from the start of the input vector.
12240       Idx -= Input * NumLaneElems;
12241
12242       // Find or create a shuffle vector operand to hold this input.
12243       unsigned OpNo;
12244       for (OpNo = 0; OpNo < array_lengthof(InputUsed); ++OpNo) {
12245         if (InputUsed[OpNo] == Input)
12246           // This input vector is already an operand.
12247           break;
12248         if (InputUsed[OpNo] < 0) {
12249           // Create a new operand for this input vector.
12250           InputUsed[OpNo] = Input;
12251           break;
12252         }
12253       }
12254
12255       if (OpNo >= array_lengthof(InputUsed)) {
12256         // More than two input vectors used!  Give up on trying to create a
12257         // shuffle vector.  Insert all elements into a BUILD_VECTOR instead.
12258         UseBuildVector = true;
12259         break;
12260       }
12261
12262       // Add the mask index for the new shuffle vector.
12263       Mask.push_back(Idx + OpNo * NumLaneElems);
12264     }
12265
12266     if (UseBuildVector) {
12267       SmallVector<SDValue, 16> SVOps;
12268       for (unsigned i = 0; i != NumLaneElems; ++i) {
12269         // The mask element.  This indexes into the input.
12270         int Idx = SVOp->getMaskElt(i+LaneStart);
12271         if (Idx < 0) {
12272           SVOps.push_back(DAG.getUNDEF(EltVT));
12273           continue;
12274         }
12275
12276         // The input vector this mask element indexes into.
12277         int Input = Idx / NumElems;
12278
12279         // Turn the index into an offset from the start of the input vector.
12280         Idx -= Input * NumElems;
12281
12282         // Extract the vector element by hand.
12283         SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
12284                                     SVOp->getOperand(Input),
12285                                     DAG.getIntPtrConstant(Idx)));
12286       }
12287
12288       // Construct the output using a BUILD_VECTOR.
12289       Output[l] = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, SVOps);
12290     } else if (InputUsed[0] < 0) {
12291       // No input vectors were used! The result is undefined.
12292       Output[l] = DAG.getUNDEF(NVT);
12293     } else {
12294       SDValue Op0 = Extract128BitVector(SVOp->getOperand(InputUsed[0] / 2),
12295                                         (InputUsed[0] % 2) * NumLaneElems,
12296                                         DAG, dl);
12297       // If only one input was used, use an undefined vector for the other.
12298       SDValue Op1 = (InputUsed[1] < 0) ? DAG.getUNDEF(NVT) :
12299         Extract128BitVector(SVOp->getOperand(InputUsed[1] / 2),
12300                             (InputUsed[1] % 2) * NumLaneElems, DAG, dl);
12301       // At least one input vector was used. Create a new shuffle vector.
12302       Output[l] = DAG.getVectorShuffle(NVT, dl, Op0, Op1, &Mask[0]);
12303     }
12304
12305     Mask.clear();
12306   }
12307
12308   // Concatenate the result back
12309   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Output[0], Output[1]);
12310 }
12311
12312 /// LowerVECTOR_SHUFFLE_128v4 - Handle all 128-bit wide vectors with
12313 /// 4 elements, and match them with several different shuffle types.
12314 static SDValue
12315 LowerVECTOR_SHUFFLE_128v4(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
12316   SDValue V1 = SVOp->getOperand(0);
12317   SDValue V2 = SVOp->getOperand(1);
12318   SDLoc dl(SVOp);
12319   MVT VT = SVOp->getSimpleValueType(0);
12320
12321   assert(VT.is128BitVector() && "Unsupported vector size");
12322
12323   std::pair<int, int> Locs[4];
12324   int Mask1[] = { -1, -1, -1, -1 };
12325   SmallVector<int, 8> PermMask(SVOp->getMask().begin(), SVOp->getMask().end());
12326
12327   unsigned NumHi = 0;
12328   unsigned NumLo = 0;
12329   for (unsigned i = 0; i != 4; ++i) {
12330     int Idx = PermMask[i];
12331     if (Idx < 0) {
12332       Locs[i] = std::make_pair(-1, -1);
12333     } else {
12334       assert(Idx < 8 && "Invalid VECTOR_SHUFFLE index!");
12335       if (Idx < 4) {
12336         Locs[i] = std::make_pair(0, NumLo);
12337         Mask1[NumLo] = Idx;
12338         NumLo++;
12339       } else {
12340         Locs[i] = std::make_pair(1, NumHi);
12341         if (2+NumHi < 4)
12342           Mask1[2+NumHi] = Idx;
12343         NumHi++;
12344       }
12345     }
12346   }
12347
12348   if (NumLo <= 2 && NumHi <= 2) {
12349     // If no more than two elements come from either vector. This can be
12350     // implemented with two shuffles. First shuffle gather the elements.
12351     // The second shuffle, which takes the first shuffle as both of its
12352     // vector operands, put the elements into the right order.
12353     V1 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
12354
12355     int Mask2[] = { -1, -1, -1, -1 };
12356
12357     for (unsigned i = 0; i != 4; ++i)
12358       if (Locs[i].first != -1) {
12359         unsigned Idx = (i < 2) ? 0 : 4;
12360         Idx += Locs[i].first * 2 + Locs[i].second;
12361         Mask2[i] = Idx;
12362       }
12363
12364     return DAG.getVectorShuffle(VT, dl, V1, V1, &Mask2[0]);
12365   }
12366
12367   if (NumLo == 3 || NumHi == 3) {
12368     // Otherwise, we must have three elements from one vector, call it X, and
12369     // one element from the other, call it Y.  First, use a shufps to build an
12370     // intermediate vector with the one element from Y and the element from X
12371     // that will be in the same half in the final destination (the indexes don't
12372     // matter). Then, use a shufps to build the final vector, taking the half
12373     // containing the element from Y from the intermediate, and the other half
12374     // from X.
12375     if (NumHi == 3) {
12376       // Normalize it so the 3 elements come from V1.
12377       CommuteVectorShuffleMask(PermMask, 4);
12378       std::swap(V1, V2);
12379     }
12380
12381     // Find the element from V2.
12382     unsigned HiIndex;
12383     for (HiIndex = 0; HiIndex < 3; ++HiIndex) {
12384       int Val = PermMask[HiIndex];
12385       if (Val < 0)
12386         continue;
12387       if (Val >= 4)
12388         break;
12389     }
12390
12391     Mask1[0] = PermMask[HiIndex];
12392     Mask1[1] = -1;
12393     Mask1[2] = PermMask[HiIndex^1];
12394     Mask1[3] = -1;
12395     V2 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
12396
12397     if (HiIndex >= 2) {
12398       Mask1[0] = PermMask[0];
12399       Mask1[1] = PermMask[1];
12400       Mask1[2] = HiIndex & 1 ? 6 : 4;
12401       Mask1[3] = HiIndex & 1 ? 4 : 6;
12402       return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
12403     }
12404
12405     Mask1[0] = HiIndex & 1 ? 2 : 0;
12406     Mask1[1] = HiIndex & 1 ? 0 : 2;
12407     Mask1[2] = PermMask[2];
12408     Mask1[3] = PermMask[3];
12409     if (Mask1[2] >= 0)
12410       Mask1[2] += 4;
12411     if (Mask1[3] >= 0)
12412       Mask1[3] += 4;
12413     return DAG.getVectorShuffle(VT, dl, V2, V1, &Mask1[0]);
12414   }
12415
12416   // Break it into (shuffle shuffle_hi, shuffle_lo).
12417   int LoMask[] = { -1, -1, -1, -1 };
12418   int HiMask[] = { -1, -1, -1, -1 };
12419
12420   int *MaskPtr = LoMask;
12421   unsigned MaskIdx = 0;
12422   unsigned LoIdx = 0;
12423   unsigned HiIdx = 2;
12424   for (unsigned i = 0; i != 4; ++i) {
12425     if (i == 2) {
12426       MaskPtr = HiMask;
12427       MaskIdx = 1;
12428       LoIdx = 0;
12429       HiIdx = 2;
12430     }
12431     int Idx = PermMask[i];
12432     if (Idx < 0) {
12433       Locs[i] = std::make_pair(-1, -1);
12434     } else if (Idx < 4) {
12435       Locs[i] = std::make_pair(MaskIdx, LoIdx);
12436       MaskPtr[LoIdx] = Idx;
12437       LoIdx++;
12438     } else {
12439       Locs[i] = std::make_pair(MaskIdx, HiIdx);
12440       MaskPtr[HiIdx] = Idx;
12441       HiIdx++;
12442     }
12443   }
12444
12445   SDValue LoShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &LoMask[0]);
12446   SDValue HiShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &HiMask[0]);
12447   int MaskOps[] = { -1, -1, -1, -1 };
12448   for (unsigned i = 0; i != 4; ++i)
12449     if (Locs[i].first != -1)
12450       MaskOps[i] = Locs[i].first * 4 + Locs[i].second;
12451   return DAG.getVectorShuffle(VT, dl, LoShuffle, HiShuffle, &MaskOps[0]);
12452 }
12453
12454 static bool MayFoldVectorLoad(SDValue V) {
12455   while (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
12456     V = V.getOperand(0);
12457
12458   if (V.hasOneUse() && V.getOpcode() == ISD::SCALAR_TO_VECTOR)
12459     V = V.getOperand(0);
12460   if (V.hasOneUse() && V.getOpcode() == ISD::BUILD_VECTOR &&
12461       V.getNumOperands() == 2 && V.getOperand(1).getOpcode() == ISD::UNDEF)
12462     // BUILD_VECTOR (load), undef
12463     V = V.getOperand(0);
12464
12465   return MayFoldLoad(V);
12466 }
12467
12468 static
12469 SDValue getMOVDDup(SDValue &Op, SDLoc &dl, SDValue V1, SelectionDAG &DAG) {
12470   MVT VT = Op.getSimpleValueType();
12471
12472   // Canonicalize to v2f64.
12473   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
12474   return DAG.getNode(ISD::BITCAST, dl, VT,
12475                      getTargetShuffleNode(X86ISD::MOVDDUP, dl, MVT::v2f64,
12476                                           V1, DAG));
12477 }
12478
12479 static
12480 SDValue getMOVLowToHigh(SDValue &Op, SDLoc &dl, SelectionDAG &DAG,
12481                         bool HasSSE2) {
12482   SDValue V1 = Op.getOperand(0);
12483   SDValue V2 = Op.getOperand(1);
12484   MVT VT = Op.getSimpleValueType();
12485
12486   assert(VT != MVT::v2i64 && "unsupported shuffle type");
12487
12488   if (HasSSE2 && VT == MVT::v2f64)
12489     return getTargetShuffleNode(X86ISD::MOVLHPD, dl, VT, V1, V2, DAG);
12490
12491   // v4f32 or v4i32: canonicalize to v4f32 (which is legal for SSE1)
12492   return DAG.getNode(ISD::BITCAST, dl, VT,
12493                      getTargetShuffleNode(X86ISD::MOVLHPS, dl, MVT::v4f32,
12494                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V1),
12495                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V2), DAG));
12496 }
12497
12498 static
12499 SDValue getMOVHighToLow(SDValue &Op, SDLoc &dl, SelectionDAG &DAG) {
12500   SDValue V1 = Op.getOperand(0);
12501   SDValue V2 = Op.getOperand(1);
12502   MVT VT = Op.getSimpleValueType();
12503
12504   assert((VT == MVT::v4i32 || VT == MVT::v4f32) &&
12505          "unsupported shuffle type");
12506
12507   if (V2.getOpcode() == ISD::UNDEF)
12508     V2 = V1;
12509
12510   // v4i32 or v4f32
12511   return getTargetShuffleNode(X86ISD::MOVHLPS, dl, VT, V1, V2, DAG);
12512 }
12513
12514 static
12515 SDValue getMOVLP(SDValue &Op, SDLoc &dl, SelectionDAG &DAG, bool HasSSE2) {
12516   SDValue V1 = Op.getOperand(0);
12517   SDValue V2 = Op.getOperand(1);
12518   MVT VT = Op.getSimpleValueType();
12519   unsigned NumElems = VT.getVectorNumElements();
12520
12521   // Use MOVLPS and MOVLPD in case V1 or V2 are loads. During isel, the second
12522   // operand of these instructions is only memory, so check if there's a
12523   // potencial load folding here, otherwise use SHUFPS or MOVSD to match the
12524   // same masks.
12525   bool CanFoldLoad = false;
12526
12527   // Trivial case, when V2 comes from a load.
12528   if (MayFoldVectorLoad(V2))
12529     CanFoldLoad = true;
12530
12531   // When V1 is a load, it can be folded later into a store in isel, example:
12532   //  (store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)), addr:$src1)
12533   //    turns into:
12534   //  (MOVLPSmr addr:$src1, VR128:$src2)
12535   // So, recognize this potential and also use MOVLPS or MOVLPD
12536   else if (MayFoldVectorLoad(V1) && MayFoldIntoStore(Op))
12537     CanFoldLoad = true;
12538
12539   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12540   if (CanFoldLoad) {
12541     if (HasSSE2 && NumElems == 2)
12542       return getTargetShuffleNode(X86ISD::MOVLPD, dl, VT, V1, V2, DAG);
12543
12544     if (NumElems == 4)
12545       // If we don't care about the second element, proceed to use movss.
12546       if (SVOp->getMaskElt(1) != -1)
12547         return getTargetShuffleNode(X86ISD::MOVLPS, dl, VT, V1, V2, DAG);
12548   }
12549
12550   // movl and movlp will both match v2i64, but v2i64 is never matched by
12551   // movl earlier because we make it strict to avoid messing with the movlp load
12552   // folding logic (see the code above getMOVLP call). Match it here then,
12553   // this is horrible, but will stay like this until we move all shuffle
12554   // matching to x86 specific nodes. Note that for the 1st condition all
12555   // types are matched with movsd.
12556   if (HasSSE2) {
12557     // FIXME: isMOVLMask should be checked and matched before getMOVLP,
12558     // as to remove this logic from here, as much as possible
12559     if (NumElems == 2 || !isMOVLMask(SVOp->getMask(), VT))
12560       return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
12561     return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
12562   }
12563
12564   assert(VT != MVT::v4i32 && "unsupported shuffle type");
12565
12566   // Invert the operand order and use SHUFPS to match it.
12567   return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V2, V1,
12568                               getShuffleSHUFImmediate(SVOp), DAG);
12569 }
12570
12571 static SDValue NarrowVectorLoadToElement(LoadSDNode *Load, unsigned Index,
12572                                          SelectionDAG &DAG) {
12573   SDLoc dl(Load);
12574   MVT VT = Load->getSimpleValueType(0);
12575   MVT EVT = VT.getVectorElementType();
12576   SDValue Addr = Load->getOperand(1);
12577   SDValue NewAddr = DAG.getNode(
12578       ISD::ADD, dl, Addr.getSimpleValueType(), Addr,
12579       DAG.getConstant(Index * EVT.getStoreSize(), Addr.getSimpleValueType()));
12580
12581   SDValue NewLoad =
12582       DAG.getLoad(EVT, dl, Load->getChain(), NewAddr,
12583                   DAG.getMachineFunction().getMachineMemOperand(
12584                       Load->getMemOperand(), 0, EVT.getStoreSize()));
12585   return NewLoad;
12586 }
12587
12588 // It is only safe to call this function if isINSERTPSMask is true for
12589 // this shufflevector mask.
12590 static SDValue getINSERTPS(ShuffleVectorSDNode *SVOp, SDLoc &dl,
12591                            SelectionDAG &DAG) {
12592   // Generate an insertps instruction when inserting an f32 from memory onto a
12593   // v4f32 or when copying a member from one v4f32 to another.
12594   // We also use it for transferring i32 from one register to another,
12595   // since it simply copies the same bits.
12596   // If we're transferring an i32 from memory to a specific element in a
12597   // register, we output a generic DAG that will match the PINSRD
12598   // instruction.
12599   MVT VT = SVOp->getSimpleValueType(0);
12600   MVT EVT = VT.getVectorElementType();
12601   SDValue V1 = SVOp->getOperand(0);
12602   SDValue V2 = SVOp->getOperand(1);
12603   auto Mask = SVOp->getMask();
12604   assert((VT == MVT::v4f32 || VT == MVT::v4i32) &&
12605          "unsupported vector type for insertps/pinsrd");
12606
12607   auto FromV1Predicate = [](const int &i) { return i < 4 && i > -1; };
12608   auto FromV2Predicate = [](const int &i) { return i >= 4; };
12609   int FromV1 = std::count_if(Mask.begin(), Mask.end(), FromV1Predicate);
12610
12611   SDValue From;
12612   SDValue To;
12613   unsigned DestIndex;
12614   if (FromV1 == 1) {
12615     From = V1;
12616     To = V2;
12617     DestIndex = std::find_if(Mask.begin(), Mask.end(), FromV1Predicate) -
12618                 Mask.begin();
12619
12620     // If we have 1 element from each vector, we have to check if we're
12621     // changing V1's element's place. If so, we're done. Otherwise, we
12622     // should assume we're changing V2's element's place and behave
12623     // accordingly.
12624     int FromV2 = std::count_if(Mask.begin(), Mask.end(), FromV2Predicate);
12625     assert(DestIndex <= INT32_MAX && "truncated destination index");
12626     if (FromV1 == FromV2 &&
12627         static_cast<int>(DestIndex) == Mask[DestIndex] % 4) {
12628       From = V2;
12629       To = V1;
12630       DestIndex =
12631           std::find_if(Mask.begin(), Mask.end(), FromV2Predicate) - Mask.begin();
12632     }
12633   } else {
12634     assert(std::count_if(Mask.begin(), Mask.end(), FromV2Predicate) == 1 &&
12635            "More than one element from V1 and from V2, or no elements from one "
12636            "of the vectors. This case should not have returned true from "
12637            "isINSERTPSMask");
12638     From = V2;
12639     To = V1;
12640     DestIndex =
12641         std::find_if(Mask.begin(), Mask.end(), FromV2Predicate) - Mask.begin();
12642   }
12643
12644   // Get an index into the source vector in the range [0,4) (the mask is
12645   // in the range [0,8) because it can address V1 and V2)
12646   unsigned SrcIndex = Mask[DestIndex] % 4;
12647   if (MayFoldLoad(From)) {
12648     // Trivial case, when From comes from a load and is only used by the
12649     // shuffle. Make it use insertps from the vector that we need from that
12650     // load.
12651     SDValue NewLoad =
12652         NarrowVectorLoadToElement(cast<LoadSDNode>(From), SrcIndex, DAG);
12653     if (!NewLoad.getNode())
12654       return SDValue();
12655
12656     if (EVT == MVT::f32) {
12657       // Create this as a scalar to vector to match the instruction pattern.
12658       SDValue LoadScalarToVector =
12659           DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, NewLoad);
12660       SDValue InsertpsMask = DAG.getIntPtrConstant(DestIndex << 4);
12661       return DAG.getNode(X86ISD::INSERTPS, dl, VT, To, LoadScalarToVector,
12662                          InsertpsMask);
12663     } else { // EVT == MVT::i32
12664       // If we're getting an i32 from memory, use an INSERT_VECTOR_ELT
12665       // instruction, to match the PINSRD instruction, which loads an i32 to a
12666       // certain vector element.
12667       return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, To, NewLoad,
12668                          DAG.getConstant(DestIndex, MVT::i32));
12669     }
12670   }
12671
12672   // Vector-element-to-vector
12673   SDValue InsertpsMask = DAG.getIntPtrConstant(DestIndex << 4 | SrcIndex << 6);
12674   return DAG.getNode(X86ISD::INSERTPS, dl, VT, To, From, InsertpsMask);
12675 }
12676
12677 // Reduce a vector shuffle to zext.
12678 static SDValue LowerVectorIntExtend(SDValue Op, const X86Subtarget *Subtarget,
12679                                     SelectionDAG &DAG) {
12680   // PMOVZX is only available from SSE41.
12681   if (!Subtarget->hasSSE41())
12682     return SDValue();
12683
12684   MVT VT = Op.getSimpleValueType();
12685
12686   // Only AVX2 support 256-bit vector integer extending.
12687   if (!Subtarget->hasInt256() && VT.is256BitVector())
12688     return SDValue();
12689
12690   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12691   SDLoc DL(Op);
12692   SDValue V1 = Op.getOperand(0);
12693   SDValue V2 = Op.getOperand(1);
12694   unsigned NumElems = VT.getVectorNumElements();
12695
12696   // Extending is an unary operation and the element type of the source vector
12697   // won't be equal to or larger than i64.
12698   if (V2.getOpcode() != ISD::UNDEF || !VT.isInteger() ||
12699       VT.getVectorElementType() == MVT::i64)
12700     return SDValue();
12701
12702   // Find the expansion ratio, e.g. expanding from i8 to i32 has a ratio of 4.
12703   unsigned Shift = 1; // Start from 2, i.e. 1 << 1.
12704   while ((1U << Shift) < NumElems) {
12705     if (SVOp->getMaskElt(1U << Shift) == 1)
12706       break;
12707     Shift += 1;
12708     // The maximal ratio is 8, i.e. from i8 to i64.
12709     if (Shift > 3)
12710       return SDValue();
12711   }
12712
12713   // Check the shuffle mask.
12714   unsigned Mask = (1U << Shift) - 1;
12715   for (unsigned i = 0; i != NumElems; ++i) {
12716     int EltIdx = SVOp->getMaskElt(i);
12717     if ((i & Mask) != 0 && EltIdx != -1)
12718       return SDValue();
12719     if ((i & Mask) == 0 && (unsigned)EltIdx != (i >> Shift))
12720       return SDValue();
12721   }
12722
12723   unsigned NBits = VT.getVectorElementType().getSizeInBits() << Shift;
12724   MVT NeVT = MVT::getIntegerVT(NBits);
12725   MVT NVT = MVT::getVectorVT(NeVT, NumElems >> Shift);
12726
12727   if (!DAG.getTargetLoweringInfo().isTypeLegal(NVT))
12728     return SDValue();
12729
12730   return DAG.getNode(ISD::BITCAST, DL, VT,
12731                      DAG.getNode(X86ISD::VZEXT, DL, NVT, V1));
12732 }
12733
12734 static SDValue NormalizeVectorShuffle(SDValue Op, const X86Subtarget *Subtarget,
12735                                       SelectionDAG &DAG) {
12736   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12737   MVT VT = Op.getSimpleValueType();
12738   SDLoc dl(Op);
12739   SDValue V1 = Op.getOperand(0);
12740   SDValue V2 = Op.getOperand(1);
12741
12742   if (isZeroShuffle(SVOp))
12743     return getZeroVector(VT, Subtarget, DAG, dl);
12744
12745   // Handle splat operations
12746   if (SVOp->isSplat()) {
12747     // Use vbroadcast whenever the splat comes from a foldable load
12748     SDValue Broadcast = LowerVectorBroadcast(Op, Subtarget, DAG);
12749     if (Broadcast.getNode())
12750       return Broadcast;
12751   }
12752
12753   // Check integer expanding shuffles.
12754   SDValue NewOp = LowerVectorIntExtend(Op, Subtarget, DAG);
12755   if (NewOp.getNode())
12756     return NewOp;
12757
12758   // If the shuffle can be profitably rewritten as a narrower shuffle, then
12759   // do it!
12760   if (VT == MVT::v8i16 || VT == MVT::v16i8 || VT == MVT::v16i16 ||
12761       VT == MVT::v32i8) {
12762     SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12763     if (NewOp.getNode())
12764       return DAG.getNode(ISD::BITCAST, dl, VT, NewOp);
12765   } else if (VT.is128BitVector() && Subtarget->hasSSE2()) {
12766     // FIXME: Figure out a cleaner way to do this.
12767     if (ISD::isBuildVectorAllZeros(V2.getNode())) {
12768       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12769       if (NewOp.getNode()) {
12770         MVT NewVT = NewOp.getSimpleValueType();
12771         if (isCommutedMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(),
12772                                NewVT, true, false))
12773           return getVZextMovL(VT, NewVT, NewOp.getOperand(0), DAG, Subtarget,
12774                               dl);
12775       }
12776     } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
12777       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12778       if (NewOp.getNode()) {
12779         MVT NewVT = NewOp.getSimpleValueType();
12780         if (isMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(), NewVT))
12781           return getVZextMovL(VT, NewVT, NewOp.getOperand(1), DAG, Subtarget,
12782                               dl);
12783       }
12784     }
12785   }
12786   return SDValue();
12787 }
12788
12789 SDValue
12790 X86TargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const {
12791   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12792   SDValue V1 = Op.getOperand(0);
12793   SDValue V2 = Op.getOperand(1);
12794   MVT VT = Op.getSimpleValueType();
12795   SDLoc dl(Op);
12796   unsigned NumElems = VT.getVectorNumElements();
12797   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
12798   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
12799   bool V1IsSplat = false;
12800   bool V2IsSplat = false;
12801   bool HasSSE2 = Subtarget->hasSSE2();
12802   bool HasFp256    = Subtarget->hasFp256();
12803   bool HasInt256   = Subtarget->hasInt256();
12804   MachineFunction &MF = DAG.getMachineFunction();
12805   bool OptForSize =
12806       MF.getFunction()->hasFnAttribute(Attribute::OptimizeForSize);
12807
12808   // Check if we should use the experimental vector shuffle lowering. If so,
12809   // delegate completely to that code path.
12810   if (ExperimentalVectorShuffleLowering)
12811     return lowerVectorShuffle(Op, Subtarget, DAG);
12812
12813   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
12814
12815   if (V1IsUndef && V2IsUndef)
12816     return DAG.getUNDEF(VT);
12817
12818   // When we create a shuffle node we put the UNDEF node to second operand,
12819   // but in some cases the first operand may be transformed to UNDEF.
12820   // In this case we should just commute the node.
12821   if (V1IsUndef)
12822     return DAG.getCommutedVectorShuffle(*SVOp);
12823
12824   // Vector shuffle lowering takes 3 steps:
12825   //
12826   // 1) Normalize the input vectors. Here splats, zeroed vectors, profitable
12827   //    narrowing and commutation of operands should be handled.
12828   // 2) Matching of shuffles with known shuffle masks to x86 target specific
12829   //    shuffle nodes.
12830   // 3) Rewriting of unmatched masks into new generic shuffle operations,
12831   //    so the shuffle can be broken into other shuffles and the legalizer can
12832   //    try the lowering again.
12833   //
12834   // The general idea is that no vector_shuffle operation should be left to
12835   // be matched during isel, all of them must be converted to a target specific
12836   // node here.
12837
12838   // Normalize the input vectors. Here splats, zeroed vectors, profitable
12839   // narrowing and commutation of operands should be handled. The actual code
12840   // doesn't include all of those, work in progress...
12841   SDValue NewOp = NormalizeVectorShuffle(Op, Subtarget, DAG);
12842   if (NewOp.getNode())
12843     return NewOp;
12844
12845   SmallVector<int, 8> M(SVOp->getMask().begin(), SVOp->getMask().end());
12846
12847   // NOTE: isPSHUFDMask can also match both masks below (unpckl_undef and
12848   // unpckh_undef). Only use pshufd if speed is more important than size.
12849   if (OptForSize && isUNPCKL_v_undef_Mask(M, VT, HasInt256))
12850     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
12851   if (OptForSize && isUNPCKH_v_undef_Mask(M, VT, HasInt256))
12852     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
12853
12854   if (isMOVDDUPMask(M, VT) && Subtarget->hasSSE3() &&
12855       V2IsUndef && MayFoldVectorLoad(V1))
12856     return getMOVDDup(Op, dl, V1, DAG);
12857
12858   if (isMOVHLPS_v_undef_Mask(M, VT))
12859     return getMOVHighToLow(Op, dl, DAG);
12860
12861   // Use to match splats
12862   if (HasSSE2 && isUNPCKHMask(M, VT, HasInt256) && V2IsUndef &&
12863       (VT == MVT::v2f64 || VT == MVT::v2i64))
12864     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
12865
12866   if (isPSHUFDMask(M, VT)) {
12867     // The actual implementation will match the mask in the if above and then
12868     // during isel it can match several different instructions, not only pshufd
12869     // as its name says, sad but true, emulate the behavior for now...
12870     if (isMOVDDUPMask(M, VT) && ((VT == MVT::v4f32 || VT == MVT::v2i64)))
12871       return getTargetShuffleNode(X86ISD::MOVLHPS, dl, VT, V1, V1, DAG);
12872
12873     unsigned TargetMask = getShuffleSHUFImmediate(SVOp);
12874
12875     if (HasSSE2 && (VT == MVT::v4f32 || VT == MVT::v4i32))
12876       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1, TargetMask, DAG);
12877
12878     if (HasFp256 && (VT == MVT::v4f32 || VT == MVT::v2f64))
12879       return getTargetShuffleNode(X86ISD::VPERMILPI, dl, VT, V1, TargetMask,
12880                                   DAG);
12881
12882     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V1,
12883                                 TargetMask, DAG);
12884   }
12885
12886   if (isPALIGNRMask(M, VT, Subtarget))
12887     return getTargetShuffleNode(X86ISD::PALIGNR, dl, VT, V1, V2,
12888                                 getShufflePALIGNRImmediate(SVOp),
12889                                 DAG);
12890
12891   if (isVALIGNMask(M, VT, Subtarget))
12892     return getTargetShuffleNode(X86ISD::VALIGN, dl, VT, V1, V2,
12893                                 getShuffleVALIGNImmediate(SVOp),
12894                                 DAG);
12895
12896   // Check if this can be converted into a logical shift.
12897   bool isLeft = false;
12898   unsigned ShAmt = 0;
12899   SDValue ShVal;
12900   bool isShift = HasSSE2 && isVectorShift(SVOp, DAG, isLeft, ShVal, ShAmt);
12901   if (isShift && ShVal.hasOneUse()) {
12902     // If the shifted value has multiple uses, it may be cheaper to use
12903     // v_set0 + movlhps or movhlps, etc.
12904     MVT EltVT = VT.getVectorElementType();
12905     ShAmt *= EltVT.getSizeInBits();
12906     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
12907   }
12908
12909   if (isMOVLMask(M, VT)) {
12910     if (ISD::isBuildVectorAllZeros(V1.getNode()))
12911       return getVZextMovL(VT, VT, V2, DAG, Subtarget, dl);
12912     if (!isMOVLPMask(M, VT)) {
12913       if (HasSSE2 && (VT == MVT::v2i64 || VT == MVT::v2f64))
12914         return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
12915
12916       if (VT == MVT::v4i32 || VT == MVT::v4f32)
12917         return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
12918     }
12919   }
12920
12921   // FIXME: fold these into legal mask.
12922   if (isMOVLHPSMask(M, VT) && !isUNPCKLMask(M, VT, HasInt256))
12923     return getMOVLowToHigh(Op, dl, DAG, HasSSE2);
12924
12925   if (isMOVHLPSMask(M, VT))
12926     return getMOVHighToLow(Op, dl, DAG);
12927
12928   if (V2IsUndef && isMOVSHDUPMask(M, VT, Subtarget))
12929     return getTargetShuffleNode(X86ISD::MOVSHDUP, dl, VT, V1, DAG);
12930
12931   if (V2IsUndef && isMOVSLDUPMask(M, VT, Subtarget))
12932     return getTargetShuffleNode(X86ISD::MOVSLDUP, dl, VT, V1, DAG);
12933
12934   if (isMOVLPMask(M, VT))
12935     return getMOVLP(Op, dl, DAG, HasSSE2);
12936
12937   if (ShouldXformToMOVHLPS(M, VT) ||
12938       ShouldXformToMOVLP(V1.getNode(), V2.getNode(), M, VT))
12939     return DAG.getCommutedVectorShuffle(*SVOp);
12940
12941   if (isShift) {
12942     // No better options. Use a vshldq / vsrldq.
12943     MVT EltVT = VT.getVectorElementType();
12944     ShAmt *= EltVT.getSizeInBits();
12945     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
12946   }
12947
12948   bool Commuted = false;
12949   // FIXME: This should also accept a bitcast of a splat?  Be careful, not
12950   // 1,1,1,1 -> v8i16 though.
12951   BitVector UndefElements;
12952   if (auto *BVOp = dyn_cast<BuildVectorSDNode>(V1.getNode()))
12953     if (BVOp->getConstantSplatNode(&UndefElements) && UndefElements.none())
12954       V1IsSplat = true;
12955   if (auto *BVOp = dyn_cast<BuildVectorSDNode>(V2.getNode()))
12956     if (BVOp->getConstantSplatNode(&UndefElements) && UndefElements.none())
12957       V2IsSplat = true;
12958
12959   // Canonicalize the splat or undef, if present, to be on the RHS.
12960   if (!V2IsUndef && V1IsSplat && !V2IsSplat) {
12961     CommuteVectorShuffleMask(M, NumElems);
12962     std::swap(V1, V2);
12963     std::swap(V1IsSplat, V2IsSplat);
12964     Commuted = true;
12965   }
12966
12967   if (isCommutedMOVLMask(M, VT, V2IsSplat, V2IsUndef)) {
12968     // Shuffling low element of v1 into undef, just return v1.
12969     if (V2IsUndef)
12970       return V1;
12971     // If V2 is a splat, the mask may be malformed such as <4,3,3,3>, which
12972     // the instruction selector will not match, so get a canonical MOVL with
12973     // swapped operands to undo the commute.
12974     return getMOVL(DAG, dl, VT, V2, V1);
12975   }
12976
12977   if (isUNPCKLMask(M, VT, HasInt256))
12978     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
12979
12980   if (isUNPCKHMask(M, VT, HasInt256))
12981     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
12982
12983   if (V2IsSplat) {
12984     // Normalize mask so all entries that point to V2 points to its first
12985     // element then try to match unpck{h|l} again. If match, return a
12986     // new vector_shuffle with the corrected mask.p
12987     SmallVector<int, 8> NewMask(M.begin(), M.end());
12988     NormalizeMask(NewMask, NumElems);
12989     if (isUNPCKLMask(NewMask, VT, HasInt256, true))
12990       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
12991     if (isUNPCKHMask(NewMask, VT, HasInt256, true))
12992       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
12993   }
12994
12995   if (Commuted) {
12996     // Commute is back and try unpck* again.
12997     // FIXME: this seems wrong.
12998     CommuteVectorShuffleMask(M, NumElems);
12999     std::swap(V1, V2);
13000     std::swap(V1IsSplat, V2IsSplat);
13001
13002     if (isUNPCKLMask(M, VT, HasInt256))
13003       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
13004
13005     if (isUNPCKHMask(M, VT, HasInt256))
13006       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
13007   }
13008
13009   // Normalize the node to match x86 shuffle ops if needed
13010   if (!V2IsUndef && (isSHUFPMask(M, VT, /* Commuted */ true)))
13011     return DAG.getCommutedVectorShuffle(*SVOp);
13012
13013   // The checks below are all present in isShuffleMaskLegal, but they are
13014   // inlined here right now to enable us to directly emit target specific
13015   // nodes, and remove one by one until they don't return Op anymore.
13016
13017   if (ShuffleVectorSDNode::isSplatMask(&M[0], VT) &&
13018       SVOp->getSplatIndex() == 0 && V2IsUndef) {
13019     if (VT == MVT::v2f64 || VT == MVT::v2i64)
13020       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
13021   }
13022
13023   if (isPSHUFHWMask(M, VT, HasInt256))
13024     return getTargetShuffleNode(X86ISD::PSHUFHW, dl, VT, V1,
13025                                 getShufflePSHUFHWImmediate(SVOp),
13026                                 DAG);
13027
13028   if (isPSHUFLWMask(M, VT, HasInt256))
13029     return getTargetShuffleNode(X86ISD::PSHUFLW, dl, VT, V1,
13030                                 getShufflePSHUFLWImmediate(SVOp),
13031                                 DAG);
13032
13033   unsigned MaskValue;
13034   if (isBlendMask(M, VT, Subtarget->hasSSE41(), HasInt256, &MaskValue))
13035     return LowerVECTOR_SHUFFLEtoBlend(SVOp, MaskValue, Subtarget, DAG);
13036
13037   if (isSHUFPMask(M, VT))
13038     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V2,
13039                                 getShuffleSHUFImmediate(SVOp), DAG);
13040
13041   if (isUNPCKL_v_undef_Mask(M, VT, HasInt256))
13042     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
13043   if (isUNPCKH_v_undef_Mask(M, VT, HasInt256))
13044     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
13045
13046   //===--------------------------------------------------------------------===//
13047   // Generate target specific nodes for 128 or 256-bit shuffles only
13048   // supported in the AVX instruction set.
13049   //
13050
13051   // Handle VMOVDDUPY permutations
13052   if (V2IsUndef && isMOVDDUPYMask(M, VT, HasFp256))
13053     return getTargetShuffleNode(X86ISD::MOVDDUP, dl, VT, V1, DAG);
13054
13055   // Handle VPERMILPS/D* permutations
13056   if (isVPERMILPMask(M, VT)) {
13057     if ((HasInt256 && VT == MVT::v8i32) || VT == MVT::v16i32)
13058       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1,
13059                                   getShuffleSHUFImmediate(SVOp), DAG);
13060     return getTargetShuffleNode(X86ISD::VPERMILPI, dl, VT, V1,
13061                                 getShuffleSHUFImmediate(SVOp), DAG);
13062   }
13063
13064   unsigned Idx;
13065   if (VT.is512BitVector() && isINSERT64x4Mask(M, VT, &Idx))
13066     return Insert256BitVector(V1, Extract256BitVector(V2, 0, DAG, dl),
13067                               Idx*(NumElems/2), DAG, dl);
13068
13069   // Handle VPERM2F128/VPERM2I128 permutations
13070   if (isVPERM2X128Mask(M, VT, HasFp256))
13071     return getTargetShuffleNode(X86ISD::VPERM2X128, dl, VT, V1,
13072                                 V2, getShuffleVPERM2X128Immediate(SVOp), DAG);
13073
13074   if (Subtarget->hasSSE41() && isINSERTPSMask(M, VT))
13075     return getINSERTPS(SVOp, dl, DAG);
13076
13077   unsigned Imm8;
13078   if (V2IsUndef && HasInt256 && isPermImmMask(M, VT, Imm8))
13079     return getTargetShuffleNode(X86ISD::VPERMI, dl, VT, V1, Imm8, DAG);
13080
13081   if ((V2IsUndef && HasInt256 && VT.is256BitVector() && NumElems == 8) ||
13082       VT.is512BitVector()) {
13083     MVT MaskEltVT = MVT::getIntegerVT(VT.getVectorElementType().getSizeInBits());
13084     MVT MaskVectorVT = MVT::getVectorVT(MaskEltVT, NumElems);
13085     SmallVector<SDValue, 16> permclMask;
13086     for (unsigned i = 0; i != NumElems; ++i) {
13087       permclMask.push_back(DAG.getConstant((M[i]>=0) ? M[i] : 0, MaskEltVT));
13088     }
13089
13090     SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, MaskVectorVT, permclMask);
13091     if (V2IsUndef)
13092       // Bitcast is for VPERMPS since mask is v8i32 but node takes v8f32
13093       return DAG.getNode(X86ISD::VPERMV, dl, VT,
13094                           DAG.getNode(ISD::BITCAST, dl, VT, Mask), V1);
13095     return DAG.getNode(X86ISD::VPERMV3, dl, VT, V1,
13096                        DAG.getNode(ISD::BITCAST, dl, VT, Mask), V2);
13097   }
13098
13099   //===--------------------------------------------------------------------===//
13100   // Since no target specific shuffle was selected for this generic one,
13101   // lower it into other known shuffles. FIXME: this isn't true yet, but
13102   // this is the plan.
13103   //
13104
13105   // Handle v8i16 specifically since SSE can do byte extraction and insertion.
13106   if (VT == MVT::v8i16) {
13107     SDValue NewOp = LowerVECTOR_SHUFFLEv8i16(Op, Subtarget, DAG);
13108     if (NewOp.getNode())
13109       return NewOp;
13110   }
13111
13112   if (VT == MVT::v16i16 && HasInt256) {
13113     SDValue NewOp = LowerVECTOR_SHUFFLEv16i16(Op, DAG);
13114     if (NewOp.getNode())
13115       return NewOp;
13116   }
13117
13118   if (VT == MVT::v16i8) {
13119     SDValue NewOp = LowerVECTOR_SHUFFLEv16i8(SVOp, Subtarget, DAG);
13120     if (NewOp.getNode())
13121       return NewOp;
13122   }
13123
13124   if (VT == MVT::v32i8) {
13125     SDValue NewOp = LowerVECTOR_SHUFFLEv32i8(SVOp, Subtarget, DAG);
13126     if (NewOp.getNode())
13127       return NewOp;
13128   }
13129
13130   // Handle all 128-bit wide vectors with 4 elements, and match them with
13131   // several different shuffle types.
13132   if (NumElems == 4 && VT.is128BitVector())
13133     return LowerVECTOR_SHUFFLE_128v4(SVOp, DAG);
13134
13135   // Handle general 256-bit shuffles
13136   if (VT.is256BitVector())
13137     return LowerVECTOR_SHUFFLE_256(SVOp, DAG);
13138
13139   return SDValue();
13140 }
13141
13142 // This function assumes its argument is a BUILD_VECTOR of constants or
13143 // undef SDNodes. i.e: ISD::isBuildVectorOfConstantSDNodes(BuildVector) is
13144 // true.
13145 static bool BUILD_VECTORtoBlendMask(BuildVectorSDNode *BuildVector,
13146                                     unsigned &MaskValue) {
13147   MaskValue = 0;
13148   unsigned NumElems = BuildVector->getNumOperands();
13149   // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
13150   unsigned NumLanes = (NumElems - 1) / 8 + 1;
13151   unsigned NumElemsInLane = NumElems / NumLanes;
13152
13153   // Blend for v16i16 should be symetric for the both lanes.
13154   for (unsigned i = 0; i < NumElemsInLane; ++i) {
13155     SDValue EltCond = BuildVector->getOperand(i);
13156     SDValue SndLaneEltCond =
13157         (NumLanes == 2) ? BuildVector->getOperand(i + NumElemsInLane) : EltCond;
13158
13159     int Lane1Cond = -1, Lane2Cond = -1;
13160     if (isa<ConstantSDNode>(EltCond))
13161       Lane1Cond = !isZero(EltCond);
13162     if (isa<ConstantSDNode>(SndLaneEltCond))
13163       Lane2Cond = !isZero(SndLaneEltCond);
13164
13165     if (Lane1Cond == Lane2Cond || Lane2Cond < 0)
13166       // Lane1Cond != 0, means we want the first argument.
13167       // Lane1Cond == 0, means we want the second argument.
13168       // The encoding of this argument is 0 for the first argument, 1
13169       // for the second. Therefore, invert the condition.
13170       MaskValue |= !Lane1Cond << i;
13171     else if (Lane1Cond < 0)
13172       MaskValue |= !Lane2Cond << i;
13173     else
13174       return false;
13175   }
13176   return true;
13177 }
13178
13179 /// \brief Try to lower a VSELECT instruction to a vector shuffle.
13180 static SDValue lowerVSELECTtoVectorShuffle(SDValue Op,
13181                                            const X86Subtarget *Subtarget,
13182                                            SelectionDAG &DAG) {
13183   SDValue Cond = Op.getOperand(0);
13184   SDValue LHS = Op.getOperand(1);
13185   SDValue RHS = Op.getOperand(2);
13186   SDLoc dl(Op);
13187   MVT VT = Op.getSimpleValueType();
13188
13189   if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
13190     return SDValue();
13191   auto *CondBV = cast<BuildVectorSDNode>(Cond);
13192
13193   // Only non-legal VSELECTs reach this lowering, convert those into generic
13194   // shuffles and re-use the shuffle lowering path for blends.
13195   SmallVector<int, 32> Mask;
13196   for (int i = 0, Size = VT.getVectorNumElements(); i < Size; ++i) {
13197     SDValue CondElt = CondBV->getOperand(i);
13198     Mask.push_back(
13199         isa<ConstantSDNode>(CondElt) ? i + (isZero(CondElt) ? Size : 0) : -1);
13200   }
13201   return DAG.getVectorShuffle(VT, dl, LHS, RHS, Mask);
13202 }
13203
13204 SDValue X86TargetLowering::LowerVSELECT(SDValue Op, SelectionDAG &DAG) const {
13205   // A vselect where all conditions and data are constants can be optimized into
13206   // a single vector load by SelectionDAGLegalize::ExpandBUILD_VECTOR().
13207   if (ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(0).getNode()) &&
13208       ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(1).getNode()) &&
13209       ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(2).getNode()))
13210     return SDValue();
13211
13212   // Try to lower this to a blend-style vector shuffle. This can handle all
13213   // constant condition cases.
13214   SDValue BlendOp = lowerVSELECTtoVectorShuffle(Op, Subtarget, DAG);
13215   if (BlendOp.getNode())
13216     return BlendOp;
13217
13218   // Variable blends are only legal from SSE4.1 onward.
13219   if (!Subtarget->hasSSE41())
13220     return SDValue();
13221
13222   // Some types for vselect were previously set to Expand, not Legal or
13223   // Custom. Return an empty SDValue so we fall-through to Expand, after
13224   // the Custom lowering phase.
13225   MVT VT = Op.getSimpleValueType();
13226   switch (VT.SimpleTy) {
13227   default:
13228     break;
13229   case MVT::v8i16:
13230   case MVT::v16i16:
13231     if (Subtarget->hasBWI() && Subtarget->hasVLX())
13232       break;
13233     return SDValue();
13234   }
13235
13236   // We couldn't create a "Blend with immediate" node.
13237   // This node should still be legal, but we'll have to emit a blendv*
13238   // instruction.
13239   return Op;
13240 }
13241
13242 static SDValue LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG) {
13243   MVT VT = Op.getSimpleValueType();
13244   SDLoc dl(Op);
13245
13246   if (!Op.getOperand(0).getSimpleValueType().is128BitVector())
13247     return SDValue();
13248
13249   if (VT.getSizeInBits() == 8) {
13250     SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
13251                                   Op.getOperand(0), Op.getOperand(1));
13252     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
13253                                   DAG.getValueType(VT));
13254     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
13255   }
13256
13257   if (VT.getSizeInBits() == 16) {
13258     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
13259     // If Idx is 0, it's cheaper to do a move instead of a pextrw.
13260     if (Idx == 0)
13261       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
13262                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
13263                                      DAG.getNode(ISD::BITCAST, dl,
13264                                                  MVT::v4i32,
13265                                                  Op.getOperand(0)),
13266                                      Op.getOperand(1)));
13267     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
13268                                   Op.getOperand(0), Op.getOperand(1));
13269     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
13270                                   DAG.getValueType(VT));
13271     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
13272   }
13273
13274   if (VT == MVT::f32) {
13275     // EXTRACTPS outputs to a GPR32 register which will require a movd to copy
13276     // the result back to FR32 register. It's only worth matching if the
13277     // result has a single use which is a store or a bitcast to i32.  And in
13278     // the case of a store, it's not worth it if the index is a constant 0,
13279     // because a MOVSSmr can be used instead, which is smaller and faster.
13280     if (!Op.hasOneUse())
13281       return SDValue();
13282     SDNode *User = *Op.getNode()->use_begin();
13283     if ((User->getOpcode() != ISD::STORE ||
13284          (isa<ConstantSDNode>(Op.getOperand(1)) &&
13285           cast<ConstantSDNode>(Op.getOperand(1))->isNullValue())) &&
13286         (User->getOpcode() != ISD::BITCAST ||
13287          User->getValueType(0) != MVT::i32))
13288       return SDValue();
13289     SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
13290                                   DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
13291                                               Op.getOperand(0)),
13292                                               Op.getOperand(1));
13293     return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
13294   }
13295
13296   if (VT == MVT::i32 || VT == MVT::i64) {
13297     // ExtractPS/pextrq works with constant index.
13298     if (isa<ConstantSDNode>(Op.getOperand(1)))
13299       return Op;
13300   }
13301   return SDValue();
13302 }
13303
13304 /// Extract one bit from mask vector, like v16i1 or v8i1.
13305 /// AVX-512 feature.
13306 SDValue
13307 X86TargetLowering::ExtractBitFromMaskVector(SDValue Op, SelectionDAG &DAG) const {
13308   SDValue Vec = Op.getOperand(0);
13309   SDLoc dl(Vec);
13310   MVT VecVT = Vec.getSimpleValueType();
13311   SDValue Idx = Op.getOperand(1);
13312   MVT EltVT = Op.getSimpleValueType();
13313
13314   assert((EltVT == MVT::i1) && "Unexpected operands in ExtractBitFromMaskVector");
13315   assert((VecVT.getVectorNumElements() <= 16 || Subtarget->hasBWI()) &&
13316          "Unexpected vector type in ExtractBitFromMaskVector");
13317
13318   // variable index can't be handled in mask registers,
13319   // extend vector to VR512
13320   if (!isa<ConstantSDNode>(Idx)) {
13321     MVT ExtVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
13322     SDValue Ext = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, Vec);
13323     SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
13324                               ExtVT.getVectorElementType(), Ext, Idx);
13325     return DAG.getNode(ISD::TRUNCATE, dl, EltVT, Elt);
13326   }
13327
13328   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13329   const TargetRegisterClass* rc = getRegClassFor(VecVT);
13330   if (!Subtarget->hasDQI() && (VecVT.getVectorNumElements() <= 8))
13331     rc = getRegClassFor(MVT::v16i1);
13332   unsigned MaxSift = rc->getSize()*8 - 1;
13333   Vec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, Vec,
13334                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
13335   Vec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, Vec,
13336                     DAG.getConstant(MaxSift, MVT::i8));
13337   return DAG.getNode(X86ISD::VEXTRACT, dl, MVT::i1, Vec,
13338                        DAG.getIntPtrConstant(0));
13339 }
13340
13341 SDValue
13342 X86TargetLowering::LowerEXTRACT_VECTOR_ELT(SDValue Op,
13343                                            SelectionDAG &DAG) const {
13344   SDLoc dl(Op);
13345   SDValue Vec = Op.getOperand(0);
13346   MVT VecVT = Vec.getSimpleValueType();
13347   SDValue Idx = Op.getOperand(1);
13348
13349   if (Op.getSimpleValueType() == MVT::i1)
13350     return ExtractBitFromMaskVector(Op, DAG);
13351
13352   if (!isa<ConstantSDNode>(Idx)) {
13353     if (VecVT.is512BitVector() ||
13354         (VecVT.is256BitVector() && Subtarget->hasInt256() &&
13355          VecVT.getVectorElementType().getSizeInBits() == 32)) {
13356
13357       MVT MaskEltVT =
13358         MVT::getIntegerVT(VecVT.getVectorElementType().getSizeInBits());
13359       MVT MaskVT = MVT::getVectorVT(MaskEltVT, VecVT.getSizeInBits() /
13360                                     MaskEltVT.getSizeInBits());
13361
13362       Idx = DAG.getZExtOrTrunc(Idx, dl, MaskEltVT);
13363       SDValue Mask = DAG.getNode(X86ISD::VINSERT, dl, MaskVT,
13364                                 getZeroVector(MaskVT, Subtarget, DAG, dl),
13365                                 Idx, DAG.getConstant(0, getPointerTy()));
13366       SDValue Perm = DAG.getNode(X86ISD::VPERMV, dl, VecVT, Mask, Vec);
13367       return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(),
13368                         Perm, DAG.getConstant(0, getPointerTy()));
13369     }
13370     return SDValue();
13371   }
13372
13373   // If this is a 256-bit vector result, first extract the 128-bit vector and
13374   // then extract the element from the 128-bit vector.
13375   if (VecVT.is256BitVector() || VecVT.is512BitVector()) {
13376
13377     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13378     // Get the 128-bit vector.
13379     Vec = Extract128BitVector(Vec, IdxVal, DAG, dl);
13380     MVT EltVT = VecVT.getVectorElementType();
13381
13382     unsigned ElemsPerChunk = 128 / EltVT.getSizeInBits();
13383
13384     //if (IdxVal >= NumElems/2)
13385     //  IdxVal -= NumElems/2;
13386     IdxVal -= (IdxVal/ElemsPerChunk)*ElemsPerChunk;
13387     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
13388                        DAG.getConstant(IdxVal, MVT::i32));
13389   }
13390
13391   assert(VecVT.is128BitVector() && "Unexpected vector length");
13392
13393   if (Subtarget->hasSSE41()) {
13394     SDValue Res = LowerEXTRACT_VECTOR_ELT_SSE4(Op, DAG);
13395     if (Res.getNode())
13396       return Res;
13397   }
13398
13399   MVT VT = Op.getSimpleValueType();
13400   // TODO: handle v16i8.
13401   if (VT.getSizeInBits() == 16) {
13402     SDValue Vec = Op.getOperand(0);
13403     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
13404     if (Idx == 0)
13405       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
13406                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
13407                                      DAG.getNode(ISD::BITCAST, dl,
13408                                                  MVT::v4i32, Vec),
13409                                      Op.getOperand(1)));
13410     // Transform it so it match pextrw which produces a 32-bit result.
13411     MVT EltVT = MVT::i32;
13412     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
13413                                   Op.getOperand(0), Op.getOperand(1));
13414     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
13415                                   DAG.getValueType(VT));
13416     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
13417   }
13418
13419   if (VT.getSizeInBits() == 32) {
13420     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
13421     if (Idx == 0)
13422       return Op;
13423
13424     // SHUFPS the element to the lowest double word, then movss.
13425     int Mask[4] = { static_cast<int>(Idx), -1, -1, -1 };
13426     MVT VVT = Op.getOperand(0).getSimpleValueType();
13427     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
13428                                        DAG.getUNDEF(VVT), Mask);
13429     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
13430                        DAG.getIntPtrConstant(0));
13431   }
13432
13433   if (VT.getSizeInBits() == 64) {
13434     // FIXME: .td only matches this for <2 x f64>, not <2 x i64> on 32b
13435     // FIXME: seems like this should be unnecessary if mov{h,l}pd were taught
13436     //        to match extract_elt for f64.
13437     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
13438     if (Idx == 0)
13439       return Op;
13440
13441     // UNPCKHPD the element to the lowest double word, then movsd.
13442     // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
13443     // to a f64mem, the whole operation is folded into a single MOVHPDmr.
13444     int Mask[2] = { 1, -1 };
13445     MVT VVT = Op.getOperand(0).getSimpleValueType();
13446     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
13447                                        DAG.getUNDEF(VVT), Mask);
13448     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
13449                        DAG.getIntPtrConstant(0));
13450   }
13451
13452   return SDValue();
13453 }
13454
13455 /// Insert one bit to mask vector, like v16i1 or v8i1.
13456 /// AVX-512 feature.
13457 SDValue
13458 X86TargetLowering::InsertBitToMaskVector(SDValue Op, SelectionDAG &DAG) const {
13459   SDLoc dl(Op);
13460   SDValue Vec = Op.getOperand(0);
13461   SDValue Elt = Op.getOperand(1);
13462   SDValue Idx = Op.getOperand(2);
13463   MVT VecVT = Vec.getSimpleValueType();
13464
13465   if (!isa<ConstantSDNode>(Idx)) {
13466     // Non constant index. Extend source and destination,
13467     // insert element and then truncate the result.
13468     MVT ExtVecVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
13469     MVT ExtEltVT = (VecVT == MVT::v8i1 ?  MVT::i64 : MVT::i32);
13470     SDValue ExtOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, ExtVecVT,
13471       DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVecVT, Vec),
13472       DAG.getNode(ISD::ZERO_EXTEND, dl, ExtEltVT, Elt), Idx);
13473     return DAG.getNode(ISD::TRUNCATE, dl, VecVT, ExtOp);
13474   }
13475
13476   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13477   SDValue EltInVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Elt);
13478   if (Vec.getOpcode() == ISD::UNDEF)
13479     return DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
13480                        DAG.getConstant(IdxVal, MVT::i8));
13481   const TargetRegisterClass* rc = getRegClassFor(VecVT);
13482   unsigned MaxSift = rc->getSize()*8 - 1;
13483   EltInVec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
13484                     DAG.getConstant(MaxSift, MVT::i8));
13485   EltInVec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, EltInVec,
13486                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
13487   return DAG.getNode(ISD::OR, dl, VecVT, Vec, EltInVec);
13488 }
13489
13490 SDValue X86TargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op,
13491                                                   SelectionDAG &DAG) const {
13492   MVT VT = Op.getSimpleValueType();
13493   MVT EltVT = VT.getVectorElementType();
13494
13495   if (EltVT == MVT::i1)
13496     return InsertBitToMaskVector(Op, DAG);
13497
13498   SDLoc dl(Op);
13499   SDValue N0 = Op.getOperand(0);
13500   SDValue N1 = Op.getOperand(1);
13501   SDValue N2 = Op.getOperand(2);
13502   if (!isa<ConstantSDNode>(N2))
13503     return SDValue();
13504   auto *N2C = cast<ConstantSDNode>(N2);
13505   unsigned IdxVal = N2C->getZExtValue();
13506
13507   // If the vector is wider than 128 bits, extract the 128-bit subvector, insert
13508   // into that, and then insert the subvector back into the result.
13509   if (VT.is256BitVector() || VT.is512BitVector()) {
13510     // Get the desired 128-bit vector half.
13511     SDValue V = Extract128BitVector(N0, IdxVal, DAG, dl);
13512
13513     // Insert the element into the desired half.
13514     unsigned NumEltsIn128 = 128 / EltVT.getSizeInBits();
13515     unsigned IdxIn128 = IdxVal - (IdxVal / NumEltsIn128) * NumEltsIn128;
13516
13517     V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V, N1,
13518                     DAG.getConstant(IdxIn128, MVT::i32));
13519
13520     // Insert the changed part back to the 256-bit vector
13521     return Insert128BitVector(N0, V, IdxVal, DAG, dl);
13522   }
13523   assert(VT.is128BitVector() && "Only 128-bit vector types should be left!");
13524
13525   if (Subtarget->hasSSE41()) {
13526     if (EltVT.getSizeInBits() == 8 || EltVT.getSizeInBits() == 16) {
13527       unsigned Opc;
13528       if (VT == MVT::v8i16) {
13529         Opc = X86ISD::PINSRW;
13530       } else {
13531         assert(VT == MVT::v16i8);
13532         Opc = X86ISD::PINSRB;
13533       }
13534
13535       // Transform it so it match pinsr{b,w} which expects a GR32 as its second
13536       // argument.
13537       if (N1.getValueType() != MVT::i32)
13538         N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
13539       if (N2.getValueType() != MVT::i32)
13540         N2 = DAG.getIntPtrConstant(IdxVal);
13541       return DAG.getNode(Opc, dl, VT, N0, N1, N2);
13542     }
13543
13544     if (EltVT == MVT::f32) {
13545       // Bits [7:6] of the constant are the source select.  This will always be
13546       //  zero here.  The DAG Combiner may combine an extract_elt index into
13547       //  these
13548       //  bits.  For example (insert (extract, 3), 2) could be matched by
13549       //  putting
13550       //  the '3' into bits [7:6] of X86ISD::INSERTPS.
13551       // Bits [5:4] of the constant are the destination select.  This is the
13552       //  value of the incoming immediate.
13553       // Bits [3:0] of the constant are the zero mask.  The DAG Combiner may
13554       //   combine either bitwise AND or insert of float 0.0 to set these bits.
13555       N2 = DAG.getIntPtrConstant(IdxVal << 4);
13556       // Create this as a scalar to vector..
13557       N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
13558       return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
13559     }
13560
13561     if (EltVT == MVT::i32 || EltVT == MVT::i64) {
13562       // PINSR* works with constant index.
13563       return Op;
13564     }
13565   }
13566
13567   if (EltVT == MVT::i8)
13568     return SDValue();
13569
13570   if (EltVT.getSizeInBits() == 16) {
13571     // Transform it so it match pinsrw which expects a 16-bit value in a GR32
13572     // as its second argument.
13573     if (N1.getValueType() != MVT::i32)
13574       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
13575     if (N2.getValueType() != MVT::i32)
13576       N2 = DAG.getIntPtrConstant(IdxVal);
13577     return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
13578   }
13579   return SDValue();
13580 }
13581
13582 static SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) {
13583   SDLoc dl(Op);
13584   MVT OpVT = Op.getSimpleValueType();
13585
13586   // If this is a 256-bit vector result, first insert into a 128-bit
13587   // vector and then insert into the 256-bit vector.
13588   if (!OpVT.is128BitVector()) {
13589     // Insert into a 128-bit vector.
13590     unsigned SizeFactor = OpVT.getSizeInBits()/128;
13591     MVT VT128 = MVT::getVectorVT(OpVT.getVectorElementType(),
13592                                  OpVT.getVectorNumElements() / SizeFactor);
13593
13594     Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
13595
13596     // Insert the 128-bit vector.
13597     return Insert128BitVector(DAG.getUNDEF(OpVT), Op, 0, DAG, dl);
13598   }
13599
13600   if (OpVT == MVT::v1i64 &&
13601       Op.getOperand(0).getValueType() == MVT::i64)
13602     return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
13603
13604   SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
13605   assert(OpVT.is128BitVector() && "Expected an SSE type!");
13606   return DAG.getNode(ISD::BITCAST, dl, OpVT,
13607                      DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
13608 }
13609
13610 // Lower a node with an EXTRACT_SUBVECTOR opcode.  This may result in
13611 // a simple subregister reference or explicit instructions to grab
13612 // upper bits of a vector.
13613 static SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
13614                                       SelectionDAG &DAG) {
13615   SDLoc dl(Op);
13616   SDValue In =  Op.getOperand(0);
13617   SDValue Idx = Op.getOperand(1);
13618   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13619   MVT ResVT   = Op.getSimpleValueType();
13620   MVT InVT    = In.getSimpleValueType();
13621
13622   if (Subtarget->hasFp256()) {
13623     if (ResVT.is128BitVector() &&
13624         (InVT.is256BitVector() || InVT.is512BitVector()) &&
13625         isa<ConstantSDNode>(Idx)) {
13626       return Extract128BitVector(In, IdxVal, DAG, dl);
13627     }
13628     if (ResVT.is256BitVector() && InVT.is512BitVector() &&
13629         isa<ConstantSDNode>(Idx)) {
13630       return Extract256BitVector(In, IdxVal, DAG, dl);
13631     }
13632   }
13633   return SDValue();
13634 }
13635
13636 // Lower a node with an INSERT_SUBVECTOR opcode.  This may result in a
13637 // simple superregister reference or explicit instructions to insert
13638 // the upper bits of a vector.
13639 static SDValue LowerINSERT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
13640                                      SelectionDAG &DAG) {
13641   if (!Subtarget->hasAVX())
13642     return SDValue();
13643
13644   SDLoc dl(Op);
13645   SDValue Vec = Op.getOperand(0);
13646   SDValue SubVec = Op.getOperand(1);
13647   SDValue Idx = Op.getOperand(2);
13648
13649   if (!isa<ConstantSDNode>(Idx))
13650     return SDValue();
13651
13652   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13653   MVT OpVT = Op.getSimpleValueType();
13654   MVT SubVecVT = SubVec.getSimpleValueType();
13655
13656   // Fold two 16-byte subvector loads into one 32-byte load:
13657   // (insert_subvector (insert_subvector undef, (load addr), 0),
13658   //                   (load addr + 16), Elts/2)
13659   // --> load32 addr
13660   if ((IdxVal == OpVT.getVectorNumElements() / 2) &&
13661       Vec.getOpcode() == ISD::INSERT_SUBVECTOR &&
13662       OpVT.is256BitVector() && SubVecVT.is128BitVector() &&
13663       !Subtarget->isUnalignedMem32Slow()) {
13664     SDValue SubVec2 = Vec.getOperand(1);
13665     if (auto *Idx2 = dyn_cast<ConstantSDNode>(Vec.getOperand(2))) {
13666       if (Idx2->getZExtValue() == 0) {
13667         SDValue Ops[] = { SubVec2, SubVec };
13668         SDValue LD = EltsFromConsecutiveLoads(OpVT, Ops, dl, DAG, false);
13669         if (LD.getNode())
13670           return LD;
13671       }
13672     }
13673   }
13674
13675   if ((OpVT.is256BitVector() || OpVT.is512BitVector()) &&
13676       SubVecVT.is128BitVector())
13677     return Insert128BitVector(Vec, SubVec, IdxVal, DAG, dl);
13678
13679   if (OpVT.is512BitVector() && SubVecVT.is256BitVector())
13680     return Insert256BitVector(Vec, SubVec, IdxVal, DAG, dl);
13681
13682   return SDValue();
13683 }
13684
13685 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
13686 // their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is
13687 // one of the above mentioned nodes. It has to be wrapped because otherwise
13688 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
13689 // be used to form addressing mode. These wrapped nodes will be selected
13690 // into MOV32ri.
13691 SDValue
13692 X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
13693   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
13694
13695   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13696   // global base reg.
13697   unsigned char OpFlag = 0;
13698   unsigned WrapperKind = X86ISD::Wrapper;
13699   CodeModel::Model M = DAG.getTarget().getCodeModel();
13700
13701   if (Subtarget->isPICStyleRIPRel() &&
13702       (M == CodeModel::Small || M == CodeModel::Kernel))
13703     WrapperKind = X86ISD::WrapperRIP;
13704   else if (Subtarget->isPICStyleGOT())
13705     OpFlag = X86II::MO_GOTOFF;
13706   else if (Subtarget->isPICStyleStubPIC())
13707     OpFlag = X86II::MO_PIC_BASE_OFFSET;
13708
13709   SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(), getPointerTy(),
13710                                              CP->getAlignment(),
13711                                              CP->getOffset(), OpFlag);
13712   SDLoc DL(CP);
13713   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13714   // With PIC, the address is actually $g + Offset.
13715   if (OpFlag) {
13716     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13717                          DAG.getNode(X86ISD::GlobalBaseReg,
13718                                      SDLoc(), getPointerTy()),
13719                          Result);
13720   }
13721
13722   return Result;
13723 }
13724
13725 SDValue X86TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
13726   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
13727
13728   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13729   // global base reg.
13730   unsigned char OpFlag = 0;
13731   unsigned WrapperKind = X86ISD::Wrapper;
13732   CodeModel::Model M = DAG.getTarget().getCodeModel();
13733
13734   if (Subtarget->isPICStyleRIPRel() &&
13735       (M == CodeModel::Small || M == CodeModel::Kernel))
13736     WrapperKind = X86ISD::WrapperRIP;
13737   else if (Subtarget->isPICStyleGOT())
13738     OpFlag = X86II::MO_GOTOFF;
13739   else if (Subtarget->isPICStyleStubPIC())
13740     OpFlag = X86II::MO_PIC_BASE_OFFSET;
13741
13742   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy(),
13743                                           OpFlag);
13744   SDLoc DL(JT);
13745   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13746
13747   // With PIC, the address is actually $g + Offset.
13748   if (OpFlag)
13749     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13750                          DAG.getNode(X86ISD::GlobalBaseReg,
13751                                      SDLoc(), getPointerTy()),
13752                          Result);
13753
13754   return Result;
13755 }
13756
13757 SDValue
13758 X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const {
13759   const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
13760
13761   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13762   // global base reg.
13763   unsigned char OpFlag = 0;
13764   unsigned WrapperKind = X86ISD::Wrapper;
13765   CodeModel::Model M = DAG.getTarget().getCodeModel();
13766
13767   if (Subtarget->isPICStyleRIPRel() &&
13768       (M == CodeModel::Small || M == CodeModel::Kernel)) {
13769     if (Subtarget->isTargetDarwin() || Subtarget->isTargetELF())
13770       OpFlag = X86II::MO_GOTPCREL;
13771     WrapperKind = X86ISD::WrapperRIP;
13772   } else if (Subtarget->isPICStyleGOT()) {
13773     OpFlag = X86II::MO_GOT;
13774   } else if (Subtarget->isPICStyleStubPIC()) {
13775     OpFlag = X86II::MO_DARWIN_NONLAZY_PIC_BASE;
13776   } else if (Subtarget->isPICStyleStubNoDynamic()) {
13777     OpFlag = X86II::MO_DARWIN_NONLAZY;
13778   }
13779
13780   SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlag);
13781
13782   SDLoc DL(Op);
13783   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13784
13785   // With PIC, the address is actually $g + Offset.
13786   if (DAG.getTarget().getRelocationModel() == Reloc::PIC_ &&
13787       !Subtarget->is64Bit()) {
13788     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13789                          DAG.getNode(X86ISD::GlobalBaseReg,
13790                                      SDLoc(), getPointerTy()),
13791                          Result);
13792   }
13793
13794   // For symbols that require a load from a stub to get the address, emit the
13795   // load.
13796   if (isGlobalStubReference(OpFlag))
13797     Result = DAG.getLoad(getPointerTy(), DL, DAG.getEntryNode(), Result,
13798                          MachinePointerInfo::getGOT(), false, false, false, 0);
13799
13800   return Result;
13801 }
13802
13803 SDValue
13804 X86TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
13805   // Create the TargetBlockAddressAddress node.
13806   unsigned char OpFlags =
13807     Subtarget->ClassifyBlockAddressReference();
13808   CodeModel::Model M = DAG.getTarget().getCodeModel();
13809   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
13810   int64_t Offset = cast<BlockAddressSDNode>(Op)->getOffset();
13811   SDLoc dl(Op);
13812   SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy(), Offset,
13813                                              OpFlags);
13814
13815   if (Subtarget->isPICStyleRIPRel() &&
13816       (M == CodeModel::Small || M == CodeModel::Kernel))
13817     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
13818   else
13819     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
13820
13821   // With PIC, the address is actually $g + Offset.
13822   if (isGlobalRelativeToPICBase(OpFlags)) {
13823     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
13824                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
13825                          Result);
13826   }
13827
13828   return Result;
13829 }
13830
13831 SDValue
13832 X86TargetLowering::LowerGlobalAddress(const GlobalValue *GV, SDLoc dl,
13833                                       int64_t Offset, SelectionDAG &DAG) const {
13834   // Create the TargetGlobalAddress node, folding in the constant
13835   // offset if it is legal.
13836   unsigned char OpFlags =
13837       Subtarget->ClassifyGlobalReference(GV, DAG.getTarget());
13838   CodeModel::Model M = DAG.getTarget().getCodeModel();
13839   SDValue Result;
13840   if (OpFlags == X86II::MO_NO_FLAG &&
13841       X86::isOffsetSuitableForCodeModel(Offset, M)) {
13842     // A direct static reference to a global.
13843     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
13844     Offset = 0;
13845   } else {
13846     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
13847   }
13848
13849   if (Subtarget->isPICStyleRIPRel() &&
13850       (M == CodeModel::Small || M == CodeModel::Kernel))
13851     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
13852   else
13853     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
13854
13855   // With PIC, the address is actually $g + Offset.
13856   if (isGlobalRelativeToPICBase(OpFlags)) {
13857     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
13858                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
13859                          Result);
13860   }
13861
13862   // For globals that require a load from a stub to get the address, emit the
13863   // load.
13864   if (isGlobalStubReference(OpFlags))
13865     Result = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Result,
13866                          MachinePointerInfo::getGOT(), false, false, false, 0);
13867
13868   // If there was a non-zero offset that we didn't fold, create an explicit
13869   // addition for it.
13870   if (Offset != 0)
13871     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
13872                          DAG.getConstant(Offset, getPointerTy()));
13873
13874   return Result;
13875 }
13876
13877 SDValue
13878 X86TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
13879   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
13880   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
13881   return LowerGlobalAddress(GV, SDLoc(Op), Offset, DAG);
13882 }
13883
13884 static SDValue
13885 GetTLSADDR(SelectionDAG &DAG, SDValue Chain, GlobalAddressSDNode *GA,
13886            SDValue *InFlag, const EVT PtrVT, unsigned ReturnReg,
13887            unsigned char OperandFlags, bool LocalDynamic = false) {
13888   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
13889   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
13890   SDLoc dl(GA);
13891   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
13892                                            GA->getValueType(0),
13893                                            GA->getOffset(),
13894                                            OperandFlags);
13895
13896   X86ISD::NodeType CallType = LocalDynamic ? X86ISD::TLSBASEADDR
13897                                            : X86ISD::TLSADDR;
13898
13899   if (InFlag) {
13900     SDValue Ops[] = { Chain,  TGA, *InFlag };
13901     Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
13902   } else {
13903     SDValue Ops[]  = { Chain, TGA };
13904     Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
13905   }
13906
13907   // TLSADDR will be codegen'ed as call. Inform MFI that function has calls.
13908   MFI->setAdjustsStack(true);
13909   MFI->setHasCalls(true);
13910
13911   SDValue Flag = Chain.getValue(1);
13912   return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Flag);
13913 }
13914
13915 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 32 bit
13916 static SDValue
13917 LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13918                                 const EVT PtrVT) {
13919   SDValue InFlag;
13920   SDLoc dl(GA);  // ? function entry point might be better
13921   SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
13922                                    DAG.getNode(X86ISD::GlobalBaseReg,
13923                                                SDLoc(), PtrVT), InFlag);
13924   InFlag = Chain.getValue(1);
13925
13926   return GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX, X86II::MO_TLSGD);
13927 }
13928
13929 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 64 bit
13930 static SDValue
13931 LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13932                                 const EVT PtrVT) {
13933   return GetTLSADDR(DAG, DAG.getEntryNode(), GA, nullptr, PtrVT,
13934                     X86::RAX, X86II::MO_TLSGD);
13935 }
13936
13937 static SDValue LowerToTLSLocalDynamicModel(GlobalAddressSDNode *GA,
13938                                            SelectionDAG &DAG,
13939                                            const EVT PtrVT,
13940                                            bool is64Bit) {
13941   SDLoc dl(GA);
13942
13943   // Get the start address of the TLS block for this module.
13944   X86MachineFunctionInfo* MFI = DAG.getMachineFunction()
13945       .getInfo<X86MachineFunctionInfo>();
13946   MFI->incNumLocalDynamicTLSAccesses();
13947
13948   SDValue Base;
13949   if (is64Bit) {
13950     Base = GetTLSADDR(DAG, DAG.getEntryNode(), GA, nullptr, PtrVT, X86::RAX,
13951                       X86II::MO_TLSLD, /*LocalDynamic=*/true);
13952   } else {
13953     SDValue InFlag;
13954     SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
13955         DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT), InFlag);
13956     InFlag = Chain.getValue(1);
13957     Base = GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX,
13958                       X86II::MO_TLSLDM, /*LocalDynamic=*/true);
13959   }
13960
13961   // Note: the CleanupLocalDynamicTLSPass will remove redundant computations
13962   // of Base.
13963
13964   // Build x@dtpoff.
13965   unsigned char OperandFlags = X86II::MO_DTPOFF;
13966   unsigned WrapperKind = X86ISD::Wrapper;
13967   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
13968                                            GA->getValueType(0),
13969                                            GA->getOffset(), OperandFlags);
13970   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
13971
13972   // Add x@dtpoff with the base.
13973   return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
13974 }
13975
13976 // Lower ISD::GlobalTLSAddress using the "initial exec" or "local exec" model.
13977 static SDValue LowerToTLSExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13978                                    const EVT PtrVT, TLSModel::Model model,
13979                                    bool is64Bit, bool isPIC) {
13980   SDLoc dl(GA);
13981
13982   // Get the Thread Pointer, which is %gs:0 (32-bit) or %fs:0 (64-bit).
13983   Value *Ptr = Constant::getNullValue(Type::getInt8PtrTy(*DAG.getContext(),
13984                                                          is64Bit ? 257 : 256));
13985
13986   SDValue ThreadPointer =
13987       DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), DAG.getIntPtrConstant(0),
13988                   MachinePointerInfo(Ptr), false, false, false, 0);
13989
13990   unsigned char OperandFlags = 0;
13991   // Most TLS accesses are not RIP relative, even on x86-64.  One exception is
13992   // initialexec.
13993   unsigned WrapperKind = X86ISD::Wrapper;
13994   if (model == TLSModel::LocalExec) {
13995     OperandFlags = is64Bit ? X86II::MO_TPOFF : X86II::MO_NTPOFF;
13996   } else if (model == TLSModel::InitialExec) {
13997     if (is64Bit) {
13998       OperandFlags = X86II::MO_GOTTPOFF;
13999       WrapperKind = X86ISD::WrapperRIP;
14000     } else {
14001       OperandFlags = isPIC ? X86II::MO_GOTNTPOFF : X86II::MO_INDNTPOFF;
14002     }
14003   } else {
14004     llvm_unreachable("Unexpected model");
14005   }
14006
14007   // emit "addl x@ntpoff,%eax" (local exec)
14008   // or "addl x@indntpoff,%eax" (initial exec)
14009   // or "addl x@gotntpoff(%ebx) ,%eax" (initial exec, 32-bit pic)
14010   SDValue TGA =
14011       DAG.getTargetGlobalAddress(GA->getGlobal(), dl, GA->getValueType(0),
14012                                  GA->getOffset(), OperandFlags);
14013   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
14014
14015   if (model == TLSModel::InitialExec) {
14016     if (isPIC && !is64Bit) {
14017       Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
14018                            DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT),
14019                            Offset);
14020     }
14021
14022     Offset = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Offset,
14023                          MachinePointerInfo::getGOT(), false, false, false, 0);
14024   }
14025
14026   // The address of the thread local variable is the add of the thread
14027   // pointer with the offset of the variable.
14028   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
14029 }
14030
14031 SDValue
14032 X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
14033
14034   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
14035   const GlobalValue *GV = GA->getGlobal();
14036
14037   if (Subtarget->isTargetELF()) {
14038     TLSModel::Model model = DAG.getTarget().getTLSModel(GV);
14039
14040     switch (model) {
14041       case TLSModel::GeneralDynamic:
14042         if (Subtarget->is64Bit())
14043           return LowerToTLSGeneralDynamicModel64(GA, DAG, getPointerTy());
14044         return LowerToTLSGeneralDynamicModel32(GA, DAG, getPointerTy());
14045       case TLSModel::LocalDynamic:
14046         return LowerToTLSLocalDynamicModel(GA, DAG, getPointerTy(),
14047                                            Subtarget->is64Bit());
14048       case TLSModel::InitialExec:
14049       case TLSModel::LocalExec:
14050         return LowerToTLSExecModel(
14051             GA, DAG, getPointerTy(), model, Subtarget->is64Bit(),
14052             DAG.getTarget().getRelocationModel() == Reloc::PIC_);
14053     }
14054     llvm_unreachable("Unknown TLS model.");
14055   }
14056
14057   if (Subtarget->isTargetDarwin()) {
14058     // Darwin only has one model of TLS.  Lower to that.
14059     unsigned char OpFlag = 0;
14060     unsigned WrapperKind = Subtarget->isPICStyleRIPRel() ?
14061                            X86ISD::WrapperRIP : X86ISD::Wrapper;
14062
14063     // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
14064     // global base reg.
14065     bool PIC32 = (DAG.getTarget().getRelocationModel() == Reloc::PIC_) &&
14066                  !Subtarget->is64Bit();
14067     if (PIC32)
14068       OpFlag = X86II::MO_TLVP_PIC_BASE;
14069     else
14070       OpFlag = X86II::MO_TLVP;
14071     SDLoc DL(Op);
14072     SDValue Result = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
14073                                                 GA->getValueType(0),
14074                                                 GA->getOffset(), OpFlag);
14075     SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
14076
14077     // With PIC32, the address is actually $g + Offset.
14078     if (PIC32)
14079       Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
14080                            DAG.getNode(X86ISD::GlobalBaseReg,
14081                                        SDLoc(), getPointerTy()),
14082                            Offset);
14083
14084     // Lowering the machine isd will make sure everything is in the right
14085     // location.
14086     SDValue Chain = DAG.getEntryNode();
14087     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
14088     SDValue Args[] = { Chain, Offset };
14089     Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args);
14090
14091     // TLSCALL will be codegen'ed as call. Inform MFI that function has calls.
14092     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
14093     MFI->setAdjustsStack(true);
14094
14095     // And our return value (tls address) is in the standard call return value
14096     // location.
14097     unsigned Reg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
14098     return DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy(),
14099                               Chain.getValue(1));
14100   }
14101
14102   if (Subtarget->isTargetKnownWindowsMSVC() ||
14103       Subtarget->isTargetWindowsGNU()) {
14104     // Just use the implicit TLS architecture
14105     // Need to generate someting similar to:
14106     //   mov     rdx, qword [gs:abs 58H]; Load pointer to ThreadLocalStorage
14107     //                                  ; from TEB
14108     //   mov     ecx, dword [rel _tls_index]: Load index (from C runtime)
14109     //   mov     rcx, qword [rdx+rcx*8]
14110     //   mov     eax, .tls$:tlsvar
14111     //   [rax+rcx] contains the address
14112     // Windows 64bit: gs:0x58
14113     // Windows 32bit: fs:__tls_array
14114
14115     SDLoc dl(GA);
14116     SDValue Chain = DAG.getEntryNode();
14117
14118     // Get the Thread Pointer, which is %fs:__tls_array (32-bit) or
14119     // %gs:0x58 (64-bit). On MinGW, __tls_array is not available, so directly
14120     // use its literal value of 0x2C.
14121     Value *Ptr = Constant::getNullValue(Subtarget->is64Bit()
14122                                         ? Type::getInt8PtrTy(*DAG.getContext(),
14123                                                              256)
14124                                         : Type::getInt32PtrTy(*DAG.getContext(),
14125                                                               257));
14126
14127     SDValue TlsArray =
14128         Subtarget->is64Bit()
14129             ? DAG.getIntPtrConstant(0x58)
14130             : (Subtarget->isTargetWindowsGNU()
14131                    ? DAG.getIntPtrConstant(0x2C)
14132                    : DAG.getExternalSymbol("_tls_array", getPointerTy()));
14133
14134     SDValue ThreadPointer =
14135         DAG.getLoad(getPointerTy(), dl, Chain, TlsArray,
14136                     MachinePointerInfo(Ptr), false, false, false, 0);
14137
14138     // Load the _tls_index variable
14139     SDValue IDX = DAG.getExternalSymbol("_tls_index", getPointerTy());
14140     if (Subtarget->is64Bit())
14141       IDX = DAG.getExtLoad(ISD::ZEXTLOAD, dl, getPointerTy(), Chain,
14142                            IDX, MachinePointerInfo(), MVT::i32,
14143                            false, false, false, 0);
14144     else
14145       IDX = DAG.getLoad(getPointerTy(), dl, Chain, IDX, MachinePointerInfo(),
14146                         false, false, false, 0);
14147
14148     SDValue Scale = DAG.getConstant(Log2_64_Ceil(TD->getPointerSize()),
14149                                     getPointerTy());
14150     IDX = DAG.getNode(ISD::SHL, dl, getPointerTy(), IDX, Scale);
14151
14152     SDValue res = DAG.getNode(ISD::ADD, dl, getPointerTy(), ThreadPointer, IDX);
14153     res = DAG.getLoad(getPointerTy(), dl, Chain, res, MachinePointerInfo(),
14154                       false, false, false, 0);
14155
14156     // Get the offset of start of .tls section
14157     SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
14158                                              GA->getValueType(0),
14159                                              GA->getOffset(), X86II::MO_SECREL);
14160     SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), TGA);
14161
14162     // The address of the thread local variable is the add of the thread
14163     // pointer with the offset of the variable.
14164     return DAG.getNode(ISD::ADD, dl, getPointerTy(), res, Offset);
14165   }
14166
14167   llvm_unreachable("TLS not implemented for this target.");
14168 }
14169
14170 /// LowerShiftParts - Lower SRA_PARTS and friends, which return two i32 values
14171 /// and take a 2 x i32 value to shift plus a shift amount.
14172 static SDValue LowerShiftParts(SDValue Op, SelectionDAG &DAG) {
14173   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
14174   MVT VT = Op.getSimpleValueType();
14175   unsigned VTBits = VT.getSizeInBits();
14176   SDLoc dl(Op);
14177   bool isSRA = Op.getOpcode() == ISD::SRA_PARTS;
14178   SDValue ShOpLo = Op.getOperand(0);
14179   SDValue ShOpHi = Op.getOperand(1);
14180   SDValue ShAmt  = Op.getOperand(2);
14181   // X86ISD::SHLD and X86ISD::SHRD have defined overflow behavior but the
14182   // generic ISD nodes haven't. Insert an AND to be safe, it's optimized away
14183   // during isel.
14184   SDValue SafeShAmt = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
14185                                   DAG.getConstant(VTBits - 1, MVT::i8));
14186   SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
14187                                      DAG.getConstant(VTBits - 1, MVT::i8))
14188                        : DAG.getConstant(0, VT);
14189
14190   SDValue Tmp2, Tmp3;
14191   if (Op.getOpcode() == ISD::SHL_PARTS) {
14192     Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
14193     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, SafeShAmt);
14194   } else {
14195     Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
14196     Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, SafeShAmt);
14197   }
14198
14199   // If the shift amount is larger or equal than the width of a part we can't
14200   // rely on the results of shld/shrd. Insert a test and select the appropriate
14201   // values for large shift amounts.
14202   SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
14203                                 DAG.getConstant(VTBits, MVT::i8));
14204   SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
14205                              AndNode, DAG.getConstant(0, MVT::i8));
14206
14207   SDValue Hi, Lo;
14208   SDValue CC = DAG.getConstant(X86::COND_NE, MVT::i8);
14209   SDValue Ops0[4] = { Tmp2, Tmp3, CC, Cond };
14210   SDValue Ops1[4] = { Tmp3, Tmp1, CC, Cond };
14211
14212   if (Op.getOpcode() == ISD::SHL_PARTS) {
14213     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
14214     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
14215   } else {
14216     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
14217     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
14218   }
14219
14220   SDValue Ops[2] = { Lo, Hi };
14221   return DAG.getMergeValues(Ops, dl);
14222 }
14223
14224 SDValue X86TargetLowering::LowerSINT_TO_FP(SDValue Op,
14225                                            SelectionDAG &DAG) const {
14226   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
14227   SDLoc dl(Op);
14228
14229   if (SrcVT.isVector()) {
14230     if (SrcVT.getVectorElementType() == MVT::i1) {
14231       MVT IntegerVT = MVT::getVectorVT(MVT::i32, SrcVT.getVectorNumElements());
14232       return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
14233                          DAG.getNode(ISD::SIGN_EXTEND, dl, IntegerVT,
14234                                      Op.getOperand(0)));
14235     }
14236     return SDValue();
14237   }
14238
14239   assert(SrcVT <= MVT::i64 && SrcVT >= MVT::i16 &&
14240          "Unknown SINT_TO_FP to lower!");
14241
14242   // These are really Legal; return the operand so the caller accepts it as
14243   // Legal.
14244   if (SrcVT == MVT::i32 && isScalarFPTypeInSSEReg(Op.getValueType()))
14245     return Op;
14246   if (SrcVT == MVT::i64 && isScalarFPTypeInSSEReg(Op.getValueType()) &&
14247       Subtarget->is64Bit()) {
14248     return Op;
14249   }
14250
14251   unsigned Size = SrcVT.getSizeInBits()/8;
14252   MachineFunction &MF = DAG.getMachineFunction();
14253   int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size, false);
14254   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14255   SDValue Chain = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
14256                                StackSlot,
14257                                MachinePointerInfo::getFixedStack(SSFI),
14258                                false, false, 0);
14259   return BuildFILD(Op, SrcVT, Chain, StackSlot, DAG);
14260 }
14261
14262 SDValue X86TargetLowering::BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain,
14263                                      SDValue StackSlot,
14264                                      SelectionDAG &DAG) const {
14265   // Build the FILD
14266   SDLoc DL(Op);
14267   SDVTList Tys;
14268   bool useSSE = isScalarFPTypeInSSEReg(Op.getValueType());
14269   if (useSSE)
14270     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Glue);
14271   else
14272     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
14273
14274   unsigned ByteSize = SrcVT.getSizeInBits()/8;
14275
14276   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(StackSlot);
14277   MachineMemOperand *MMO;
14278   if (FI) {
14279     int SSFI = FI->getIndex();
14280     MMO =
14281       DAG.getMachineFunction()
14282       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14283                             MachineMemOperand::MOLoad, ByteSize, ByteSize);
14284   } else {
14285     MMO = cast<LoadSDNode>(StackSlot)->getMemOperand();
14286     StackSlot = StackSlot.getOperand(1);
14287   }
14288   SDValue Ops[] = { Chain, StackSlot, DAG.getValueType(SrcVT) };
14289   SDValue Result = DAG.getMemIntrinsicNode(useSSE ? X86ISD::FILD_FLAG :
14290                                            X86ISD::FILD, DL,
14291                                            Tys, Ops, SrcVT, MMO);
14292
14293   if (useSSE) {
14294     Chain = Result.getValue(1);
14295     SDValue InFlag = Result.getValue(2);
14296
14297     // FIXME: Currently the FST is flagged to the FILD_FLAG. This
14298     // shouldn't be necessary except that RFP cannot be live across
14299     // multiple blocks. When stackifier is fixed, they can be uncoupled.
14300     MachineFunction &MF = DAG.getMachineFunction();
14301     unsigned SSFISize = Op.getValueType().getSizeInBits()/8;
14302     int SSFI = MF.getFrameInfo()->CreateStackObject(SSFISize, SSFISize, false);
14303     SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14304     Tys = DAG.getVTList(MVT::Other);
14305     SDValue Ops[] = {
14306       Chain, Result, StackSlot, DAG.getValueType(Op.getValueType()), InFlag
14307     };
14308     MachineMemOperand *MMO =
14309       DAG.getMachineFunction()
14310       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14311                             MachineMemOperand::MOStore, SSFISize, SSFISize);
14312
14313     Chain = DAG.getMemIntrinsicNode(X86ISD::FST, DL, Tys,
14314                                     Ops, Op.getValueType(), MMO);
14315     Result = DAG.getLoad(Op.getValueType(), DL, Chain, StackSlot,
14316                          MachinePointerInfo::getFixedStack(SSFI),
14317                          false, false, false, 0);
14318   }
14319
14320   return Result;
14321 }
14322
14323 // LowerUINT_TO_FP_i64 - 64-bit unsigned integer to double expansion.
14324 SDValue X86TargetLowering::LowerUINT_TO_FP_i64(SDValue Op,
14325                                                SelectionDAG &DAG) const {
14326   // This algorithm is not obvious. Here it is what we're trying to output:
14327   /*
14328      movq       %rax,  %xmm0
14329      punpckldq  (c0),  %xmm0  // c0: (uint4){ 0x43300000U, 0x45300000U, 0U, 0U }
14330      subpd      (c1),  %xmm0  // c1: (double2){ 0x1.0p52, 0x1.0p52 * 0x1.0p32 }
14331      #ifdef __SSE3__
14332        haddpd   %xmm0, %xmm0
14333      #else
14334        pshufd   $0x4e, %xmm0, %xmm1
14335        addpd    %xmm1, %xmm0
14336      #endif
14337   */
14338
14339   SDLoc dl(Op);
14340   LLVMContext *Context = DAG.getContext();
14341
14342   // Build some magic constants.
14343   static const uint32_t CV0[] = { 0x43300000, 0x45300000, 0, 0 };
14344   Constant *C0 = ConstantDataVector::get(*Context, CV0);
14345   SDValue CPIdx0 = DAG.getConstantPool(C0, getPointerTy(), 16);
14346
14347   SmallVector<Constant*,2> CV1;
14348   CV1.push_back(
14349     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
14350                                       APInt(64, 0x4330000000000000ULL))));
14351   CV1.push_back(
14352     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
14353                                       APInt(64, 0x4530000000000000ULL))));
14354   Constant *C1 = ConstantVector::get(CV1);
14355   SDValue CPIdx1 = DAG.getConstantPool(C1, getPointerTy(), 16);
14356
14357   // Load the 64-bit value into an XMM register.
14358   SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
14359                             Op.getOperand(0));
14360   SDValue CLod0 = DAG.getLoad(MVT::v4i32, dl, DAG.getEntryNode(), CPIdx0,
14361                               MachinePointerInfo::getConstantPool(),
14362                               false, false, false, 16);
14363   SDValue Unpck1 = getUnpackl(DAG, dl, MVT::v4i32,
14364                               DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, XR1),
14365                               CLod0);
14366
14367   SDValue CLod1 = DAG.getLoad(MVT::v2f64, dl, CLod0.getValue(1), CPIdx1,
14368                               MachinePointerInfo::getConstantPool(),
14369                               false, false, false, 16);
14370   SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck1);
14371   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
14372   SDValue Result;
14373
14374   if (Subtarget->hasSSE3()) {
14375     // FIXME: The 'haddpd' instruction may be slower than 'movhlps + addsd'.
14376     Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
14377   } else {
14378     SDValue S2F = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Sub);
14379     SDValue Shuffle = getTargetShuffleNode(X86ISD::PSHUFD, dl, MVT::v4i32,
14380                                            S2F, 0x4E, DAG);
14381     Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64,
14382                          DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Shuffle),
14383                          Sub);
14384   }
14385
14386   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
14387                      DAG.getIntPtrConstant(0));
14388 }
14389
14390 // LowerUINT_TO_FP_i32 - 32-bit unsigned integer to float expansion.
14391 SDValue X86TargetLowering::LowerUINT_TO_FP_i32(SDValue Op,
14392                                                SelectionDAG &DAG) const {
14393   SDLoc dl(Op);
14394   // FP constant to bias correct the final result.
14395   SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
14396                                    MVT::f64);
14397
14398   // Load the 32-bit value into an XMM register.
14399   SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
14400                              Op.getOperand(0));
14401
14402   // Zero out the upper parts of the register.
14403   Load = getShuffleVectorZeroOrUndef(Load, 0, true, Subtarget, DAG);
14404
14405   Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
14406                      DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
14407                      DAG.getIntPtrConstant(0));
14408
14409   // Or the load with the bias.
14410   SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
14411                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
14412                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
14413                                                    MVT::v2f64, Load)),
14414                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
14415                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
14416                                                    MVT::v2f64, Bias)));
14417   Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
14418                    DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
14419                    DAG.getIntPtrConstant(0));
14420
14421   // Subtract the bias.
14422   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
14423
14424   // Handle final rounding.
14425   EVT DestVT = Op.getValueType();
14426
14427   if (DestVT.bitsLT(MVT::f64))
14428     return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
14429                        DAG.getIntPtrConstant(0));
14430   if (DestVT.bitsGT(MVT::f64))
14431     return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
14432
14433   // Handle final rounding.
14434   return Sub;
14435 }
14436
14437 static SDValue lowerUINT_TO_FP_vXi32(SDValue Op, SelectionDAG &DAG,
14438                                      const X86Subtarget &Subtarget) {
14439   // The algorithm is the following:
14440   // #ifdef __SSE4_1__
14441   //     uint4 lo = _mm_blend_epi16( v, (uint4) 0x4b000000, 0xaa);
14442   //     uint4 hi = _mm_blend_epi16( _mm_srli_epi32(v,16),
14443   //                                 (uint4) 0x53000000, 0xaa);
14444   // #else
14445   //     uint4 lo = (v & (uint4) 0xffff) | (uint4) 0x4b000000;
14446   //     uint4 hi = (v >> 16) | (uint4) 0x53000000;
14447   // #endif
14448   //     float4 fhi = (float4) hi - (0x1.0p39f + 0x1.0p23f);
14449   //     return (float4) lo + fhi;
14450
14451   SDLoc DL(Op);
14452   SDValue V = Op->getOperand(0);
14453   EVT VecIntVT = V.getValueType();
14454   bool Is128 = VecIntVT == MVT::v4i32;
14455   EVT VecFloatVT = Is128 ? MVT::v4f32 : MVT::v8f32;
14456   // If we convert to something else than the supported type, e.g., to v4f64,
14457   // abort early.
14458   if (VecFloatVT != Op->getValueType(0))
14459     return SDValue();
14460
14461   unsigned NumElts = VecIntVT.getVectorNumElements();
14462   assert((VecIntVT == MVT::v4i32 || VecIntVT == MVT::v8i32) &&
14463          "Unsupported custom type");
14464   assert(NumElts <= 8 && "The size of the constant array must be fixed");
14465
14466   // In the #idef/#else code, we have in common:
14467   // - The vector of constants:
14468   // -- 0x4b000000
14469   // -- 0x53000000
14470   // - A shift:
14471   // -- v >> 16
14472
14473   // Create the splat vector for 0x4b000000.
14474   SDValue CstLow = DAG.getConstant(0x4b000000, MVT::i32);
14475   SDValue CstLowArray[] = {CstLow, CstLow, CstLow, CstLow,
14476                            CstLow, CstLow, CstLow, CstLow};
14477   SDValue VecCstLow = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14478                                   makeArrayRef(&CstLowArray[0], NumElts));
14479   // Create the splat vector for 0x53000000.
14480   SDValue CstHigh = DAG.getConstant(0x53000000, MVT::i32);
14481   SDValue CstHighArray[] = {CstHigh, CstHigh, CstHigh, CstHigh,
14482                             CstHigh, CstHigh, CstHigh, CstHigh};
14483   SDValue VecCstHigh = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14484                                    makeArrayRef(&CstHighArray[0], NumElts));
14485
14486   // Create the right shift.
14487   SDValue CstShift = DAG.getConstant(16, MVT::i32);
14488   SDValue CstShiftArray[] = {CstShift, CstShift, CstShift, CstShift,
14489                              CstShift, CstShift, CstShift, CstShift};
14490   SDValue VecCstShift = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14491                                     makeArrayRef(&CstShiftArray[0], NumElts));
14492   SDValue HighShift = DAG.getNode(ISD::SRL, DL, VecIntVT, V, VecCstShift);
14493
14494   SDValue Low, High;
14495   if (Subtarget.hasSSE41()) {
14496     EVT VecI16VT = Is128 ? MVT::v8i16 : MVT::v16i16;
14497     //     uint4 lo = _mm_blend_epi16( v, (uint4) 0x4b000000, 0xaa);
14498     SDValue VecCstLowBitcast =
14499         DAG.getNode(ISD::BITCAST, DL, VecI16VT, VecCstLow);
14500     SDValue VecBitcast = DAG.getNode(ISD::BITCAST, DL, VecI16VT, V);
14501     // Low will be bitcasted right away, so do not bother bitcasting back to its
14502     // original type.
14503     Low = DAG.getNode(X86ISD::BLENDI, DL, VecI16VT, VecBitcast,
14504                       VecCstLowBitcast, DAG.getConstant(0xaa, MVT::i32));
14505     //     uint4 hi = _mm_blend_epi16( _mm_srli_epi32(v,16),
14506     //                                 (uint4) 0x53000000, 0xaa);
14507     SDValue VecCstHighBitcast =
14508         DAG.getNode(ISD::BITCAST, DL, VecI16VT, VecCstHigh);
14509     SDValue VecShiftBitcast =
14510         DAG.getNode(ISD::BITCAST, DL, VecI16VT, HighShift);
14511     // High will be bitcasted right away, so do not bother bitcasting back to
14512     // its original type.
14513     High = DAG.getNode(X86ISD::BLENDI, DL, VecI16VT, VecShiftBitcast,
14514                        VecCstHighBitcast, DAG.getConstant(0xaa, MVT::i32));
14515   } else {
14516     SDValue CstMask = DAG.getConstant(0xffff, MVT::i32);
14517     SDValue VecCstMask = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT, CstMask,
14518                                      CstMask, CstMask, CstMask);
14519     //     uint4 lo = (v & (uint4) 0xffff) | (uint4) 0x4b000000;
14520     SDValue LowAnd = DAG.getNode(ISD::AND, DL, VecIntVT, V, VecCstMask);
14521     Low = DAG.getNode(ISD::OR, DL, VecIntVT, LowAnd, VecCstLow);
14522
14523     //     uint4 hi = (v >> 16) | (uint4) 0x53000000;
14524     High = DAG.getNode(ISD::OR, DL, VecIntVT, HighShift, VecCstHigh);
14525   }
14526
14527   // Create the vector constant for -(0x1.0p39f + 0x1.0p23f).
14528   SDValue CstFAdd = DAG.getConstantFP(
14529       APFloat(APFloat::IEEEsingle, APInt(32, 0xD3000080)), MVT::f32);
14530   SDValue CstFAddArray[] = {CstFAdd, CstFAdd, CstFAdd, CstFAdd,
14531                             CstFAdd, CstFAdd, CstFAdd, CstFAdd};
14532   SDValue VecCstFAdd = DAG.getNode(ISD::BUILD_VECTOR, DL, VecFloatVT,
14533                                    makeArrayRef(&CstFAddArray[0], NumElts));
14534
14535   //     float4 fhi = (float4) hi - (0x1.0p39f + 0x1.0p23f);
14536   SDValue HighBitcast = DAG.getNode(ISD::BITCAST, DL, VecFloatVT, High);
14537   SDValue FHigh =
14538       DAG.getNode(ISD::FADD, DL, VecFloatVT, HighBitcast, VecCstFAdd);
14539   //     return (float4) lo + fhi;
14540   SDValue LowBitcast = DAG.getNode(ISD::BITCAST, DL, VecFloatVT, Low);
14541   return DAG.getNode(ISD::FADD, DL, VecFloatVT, LowBitcast, FHigh);
14542 }
14543
14544 SDValue X86TargetLowering::lowerUINT_TO_FP_vec(SDValue Op,
14545                                                SelectionDAG &DAG) const {
14546   SDValue N0 = Op.getOperand(0);
14547   MVT SVT = N0.getSimpleValueType();
14548   SDLoc dl(Op);
14549
14550   switch (SVT.SimpleTy) {
14551   default:
14552     llvm_unreachable("Custom UINT_TO_FP is not supported!");
14553   case MVT::v4i8:
14554   case MVT::v4i16:
14555   case MVT::v8i8:
14556   case MVT::v8i16: {
14557     MVT NVT = MVT::getVectorVT(MVT::i32, SVT.getVectorNumElements());
14558     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
14559                        DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N0));
14560   }
14561   case MVT::v4i32:
14562   case MVT::v8i32:
14563     return lowerUINT_TO_FP_vXi32(Op, DAG, *Subtarget);
14564   }
14565   llvm_unreachable(nullptr);
14566 }
14567
14568 SDValue X86TargetLowering::LowerUINT_TO_FP(SDValue Op,
14569                                            SelectionDAG &DAG) const {
14570   SDValue N0 = Op.getOperand(0);
14571   SDLoc dl(Op);
14572
14573   if (Op.getValueType().isVector())
14574     return lowerUINT_TO_FP_vec(Op, DAG);
14575
14576   // Since UINT_TO_FP is legal (it's marked custom), dag combiner won't
14577   // optimize it to a SINT_TO_FP when the sign bit is known zero. Perform
14578   // the optimization here.
14579   if (DAG.SignBitIsZero(N0))
14580     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
14581
14582   MVT SrcVT = N0.getSimpleValueType();
14583   MVT DstVT = Op.getSimpleValueType();
14584   if (SrcVT == MVT::i64 && DstVT == MVT::f64 && X86ScalarSSEf64)
14585     return LowerUINT_TO_FP_i64(Op, DAG);
14586   if (SrcVT == MVT::i32 && X86ScalarSSEf64)
14587     return LowerUINT_TO_FP_i32(Op, DAG);
14588   if (Subtarget->is64Bit() && SrcVT == MVT::i64 && DstVT == MVT::f32)
14589     return SDValue();
14590
14591   // Make a 64-bit buffer, and use it to build an FILD.
14592   SDValue StackSlot = DAG.CreateStackTemporary(MVT::i64);
14593   if (SrcVT == MVT::i32) {
14594     SDValue WordOff = DAG.getConstant(4, getPointerTy());
14595     SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
14596                                      getPointerTy(), StackSlot, WordOff);
14597     SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
14598                                   StackSlot, MachinePointerInfo(),
14599                                   false, false, 0);
14600     SDValue Store2 = DAG.getStore(Store1, dl, DAG.getConstant(0, MVT::i32),
14601                                   OffsetSlot, MachinePointerInfo(),
14602                                   false, false, 0);
14603     SDValue Fild = BuildFILD(Op, MVT::i64, Store2, StackSlot, DAG);
14604     return Fild;
14605   }
14606
14607   assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
14608   SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
14609                                StackSlot, MachinePointerInfo(),
14610                                false, false, 0);
14611   // For i64 source, we need to add the appropriate power of 2 if the input
14612   // was negative.  This is the same as the optimization in
14613   // DAGTypeLegalizer::ExpandIntOp_UNIT_TO_FP, and for it to be safe here,
14614   // we must be careful to do the computation in x87 extended precision, not
14615   // in SSE. (The generic code can't know it's OK to do this, or how to.)
14616   int SSFI = cast<FrameIndexSDNode>(StackSlot)->getIndex();
14617   MachineMemOperand *MMO =
14618     DAG.getMachineFunction()
14619     .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14620                           MachineMemOperand::MOLoad, 8, 8);
14621
14622   SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other);
14623   SDValue Ops[] = { Store, StackSlot, DAG.getValueType(MVT::i64) };
14624   SDValue Fild = DAG.getMemIntrinsicNode(X86ISD::FILD, dl, Tys, Ops,
14625                                          MVT::i64, MMO);
14626
14627   APInt FF(32, 0x5F800000ULL);
14628
14629   // Check whether the sign bit is set.
14630   SDValue SignSet = DAG.getSetCC(dl,
14631                                  getSetCCResultType(*DAG.getContext(), MVT::i64),
14632                                  Op.getOperand(0), DAG.getConstant(0, MVT::i64),
14633                                  ISD::SETLT);
14634
14635   // Build a 64 bit pair (0, FF) in the constant pool, with FF in the lo bits.
14636   SDValue FudgePtr = DAG.getConstantPool(
14637                              ConstantInt::get(*DAG.getContext(), FF.zext(64)),
14638                                          getPointerTy());
14639
14640   // Get a pointer to FF if the sign bit was set, or to 0 otherwise.
14641   SDValue Zero = DAG.getIntPtrConstant(0);
14642   SDValue Four = DAG.getIntPtrConstant(4);
14643   SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
14644                                Zero, Four);
14645   FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
14646
14647   // Load the value out, extending it from f32 to f80.
14648   // FIXME: Avoid the extend by constructing the right constant pool?
14649   SDValue Fudge = DAG.getExtLoad(ISD::EXTLOAD, dl, MVT::f80, DAG.getEntryNode(),
14650                                  FudgePtr, MachinePointerInfo::getConstantPool(),
14651                                  MVT::f32, false, false, false, 4);
14652   // Extend everything to 80 bits to force it to be done on x87.
14653   SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
14654   return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
14655 }
14656
14657 std::pair<SDValue,SDValue>
14658 X86TargetLowering:: FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG,
14659                                     bool IsSigned, bool IsReplace) const {
14660   SDLoc DL(Op);
14661
14662   EVT DstTy = Op.getValueType();
14663
14664   if (!IsSigned && !isIntegerTypeFTOL(DstTy)) {
14665     assert(DstTy == MVT::i32 && "Unexpected FP_TO_UINT");
14666     DstTy = MVT::i64;
14667   }
14668
14669   assert(DstTy.getSimpleVT() <= MVT::i64 &&
14670          DstTy.getSimpleVT() >= MVT::i16 &&
14671          "Unknown FP_TO_INT to lower!");
14672
14673   // These are really Legal.
14674   if (DstTy == MVT::i32 &&
14675       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
14676     return std::make_pair(SDValue(), SDValue());
14677   if (Subtarget->is64Bit() &&
14678       DstTy == MVT::i64 &&
14679       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
14680     return std::make_pair(SDValue(), SDValue());
14681
14682   // We lower FP->int64 either into FISTP64 followed by a load from a temporary
14683   // stack slot, or into the FTOL runtime function.
14684   MachineFunction &MF = DAG.getMachineFunction();
14685   unsigned MemSize = DstTy.getSizeInBits()/8;
14686   int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
14687   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14688
14689   unsigned Opc;
14690   if (!IsSigned && isIntegerTypeFTOL(DstTy))
14691     Opc = X86ISD::WIN_FTOL;
14692   else
14693     switch (DstTy.getSimpleVT().SimpleTy) {
14694     default: llvm_unreachable("Invalid FP_TO_SINT to lower!");
14695     case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
14696     case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
14697     case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
14698     }
14699
14700   SDValue Chain = DAG.getEntryNode();
14701   SDValue Value = Op.getOperand(0);
14702   EVT TheVT = Op.getOperand(0).getValueType();
14703   // FIXME This causes a redundant load/store if the SSE-class value is already
14704   // in memory, such as if it is on the callstack.
14705   if (isScalarFPTypeInSSEReg(TheVT)) {
14706     assert(DstTy == MVT::i64 && "Invalid FP_TO_SINT to lower!");
14707     Chain = DAG.getStore(Chain, DL, Value, StackSlot,
14708                          MachinePointerInfo::getFixedStack(SSFI),
14709                          false, false, 0);
14710     SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other);
14711     SDValue Ops[] = {
14712       Chain, StackSlot, DAG.getValueType(TheVT)
14713     };
14714
14715     MachineMemOperand *MMO =
14716       MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14717                               MachineMemOperand::MOLoad, MemSize, MemSize);
14718     Value = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops, DstTy, MMO);
14719     Chain = Value.getValue(1);
14720     SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
14721     StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14722   }
14723
14724   MachineMemOperand *MMO =
14725     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14726                             MachineMemOperand::MOStore, MemSize, MemSize);
14727
14728   if (Opc != X86ISD::WIN_FTOL) {
14729     // Build the FP_TO_INT*_IN_MEM
14730     SDValue Ops[] = { Chain, Value, StackSlot };
14731     SDValue FIST = DAG.getMemIntrinsicNode(Opc, DL, DAG.getVTList(MVT::Other),
14732                                            Ops, DstTy, MMO);
14733     return std::make_pair(FIST, StackSlot);
14734   } else {
14735     SDValue ftol = DAG.getNode(X86ISD::WIN_FTOL, DL,
14736       DAG.getVTList(MVT::Other, MVT::Glue),
14737       Chain, Value);
14738     SDValue eax = DAG.getCopyFromReg(ftol, DL, X86::EAX,
14739       MVT::i32, ftol.getValue(1));
14740     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), DL, X86::EDX,
14741       MVT::i32, eax.getValue(2));
14742     SDValue Ops[] = { eax, edx };
14743     SDValue pair = IsReplace
14744       ? DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops)
14745       : DAG.getMergeValues(Ops, DL);
14746     return std::make_pair(pair, SDValue());
14747   }
14748 }
14749
14750 static SDValue LowerAVXExtend(SDValue Op, SelectionDAG &DAG,
14751                               const X86Subtarget *Subtarget) {
14752   MVT VT = Op->getSimpleValueType(0);
14753   SDValue In = Op->getOperand(0);
14754   MVT InVT = In.getSimpleValueType();
14755   SDLoc dl(Op);
14756
14757   // Optimize vectors in AVX mode:
14758   //
14759   //   v8i16 -> v8i32
14760   //   Use vpunpcklwd for 4 lower elements  v8i16 -> v4i32.
14761   //   Use vpunpckhwd for 4 upper elements  v8i16 -> v4i32.
14762   //   Concat upper and lower parts.
14763   //
14764   //   v4i32 -> v4i64
14765   //   Use vpunpckldq for 4 lower elements  v4i32 -> v2i64.
14766   //   Use vpunpckhdq for 4 upper elements  v4i32 -> v2i64.
14767   //   Concat upper and lower parts.
14768   //
14769
14770   if (((VT != MVT::v16i16) || (InVT != MVT::v16i8)) &&
14771       ((VT != MVT::v8i32) || (InVT != MVT::v8i16)) &&
14772       ((VT != MVT::v4i64) || (InVT != MVT::v4i32)))
14773     return SDValue();
14774
14775   if (Subtarget->hasInt256())
14776     return DAG.getNode(X86ISD::VZEXT, dl, VT, In);
14777
14778   SDValue ZeroVec = getZeroVector(InVT, Subtarget, DAG, dl);
14779   SDValue Undef = DAG.getUNDEF(InVT);
14780   bool NeedZero = Op.getOpcode() == ISD::ZERO_EXTEND;
14781   SDValue OpLo = getUnpackl(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
14782   SDValue OpHi = getUnpackh(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
14783
14784   MVT HVT = MVT::getVectorVT(VT.getVectorElementType(),
14785                              VT.getVectorNumElements()/2);
14786
14787   OpLo = DAG.getNode(ISD::BITCAST, dl, HVT, OpLo);
14788   OpHi = DAG.getNode(ISD::BITCAST, dl, HVT, OpHi);
14789
14790   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
14791 }
14792
14793 static  SDValue LowerZERO_EXTEND_AVX512(SDValue Op,
14794                                         SelectionDAG &DAG) {
14795   MVT VT = Op->getSimpleValueType(0);
14796   SDValue In = Op->getOperand(0);
14797   MVT InVT = In.getSimpleValueType();
14798   SDLoc DL(Op);
14799   unsigned int NumElts = VT.getVectorNumElements();
14800   if (NumElts != 8 && NumElts != 16)
14801     return SDValue();
14802
14803   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1)
14804     return DAG.getNode(X86ISD::VZEXT, DL, VT, In);
14805
14806   EVT ExtVT = (NumElts == 8)? MVT::v8i64 : MVT::v16i32;
14807   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14808   // Now we have only mask extension
14809   assert(InVT.getVectorElementType() == MVT::i1);
14810   SDValue Cst = DAG.getTargetConstant(1, ExtVT.getScalarType());
14811   const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
14812   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
14813   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
14814   SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
14815                            MachinePointerInfo::getConstantPool(),
14816                            false, false, false, Alignment);
14817
14818   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, DL, ExtVT, In, Ld);
14819   if (VT.is512BitVector())
14820     return Brcst;
14821   return DAG.getNode(X86ISD::VTRUNC, DL, VT, Brcst);
14822 }
14823
14824 static SDValue LowerANY_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
14825                                SelectionDAG &DAG) {
14826   if (Subtarget->hasFp256()) {
14827     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
14828     if (Res.getNode())
14829       return Res;
14830   }
14831
14832   return SDValue();
14833 }
14834
14835 static SDValue LowerZERO_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
14836                                 SelectionDAG &DAG) {
14837   SDLoc DL(Op);
14838   MVT VT = Op.getSimpleValueType();
14839   SDValue In = Op.getOperand(0);
14840   MVT SVT = In.getSimpleValueType();
14841
14842   if (VT.is512BitVector() || SVT.getVectorElementType() == MVT::i1)
14843     return LowerZERO_EXTEND_AVX512(Op, DAG);
14844
14845   if (Subtarget->hasFp256()) {
14846     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
14847     if (Res.getNode())
14848       return Res;
14849   }
14850
14851   assert(!VT.is256BitVector() || !SVT.is128BitVector() ||
14852          VT.getVectorNumElements() != SVT.getVectorNumElements());
14853   return SDValue();
14854 }
14855
14856 SDValue X86TargetLowering::LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const {
14857   SDLoc DL(Op);
14858   MVT VT = Op.getSimpleValueType();
14859   SDValue In = Op.getOperand(0);
14860   MVT InVT = In.getSimpleValueType();
14861
14862   if (VT == MVT::i1) {
14863     assert((InVT.isInteger() && (InVT.getSizeInBits() <= 64)) &&
14864            "Invalid scalar TRUNCATE operation");
14865     if (InVT.getSizeInBits() >= 32)
14866       return SDValue();
14867     In = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, In);
14868     return DAG.getNode(ISD::TRUNCATE, DL, VT, In);
14869   }
14870   assert(VT.getVectorNumElements() == InVT.getVectorNumElements() &&
14871          "Invalid TRUNCATE operation");
14872
14873   if (InVT.is512BitVector() || VT.getVectorElementType() == MVT::i1) {
14874     if (VT.getVectorElementType().getSizeInBits() >=8)
14875       return DAG.getNode(X86ISD::VTRUNC, DL, VT, In);
14876
14877     assert(VT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
14878     unsigned NumElts = InVT.getVectorNumElements();
14879     assert ((NumElts == 8 || NumElts == 16) && "Unexpected vector type");
14880     if (InVT.getSizeInBits() < 512) {
14881       MVT ExtVT = (NumElts == 16)? MVT::v16i32 : MVT::v8i64;
14882       In = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, In);
14883       InVT = ExtVT;
14884     }
14885
14886     SDValue Cst = DAG.getTargetConstant(1, InVT.getVectorElementType());
14887     const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
14888     SDValue CP = DAG.getConstantPool(C, getPointerTy());
14889     unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
14890     SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
14891                            MachinePointerInfo::getConstantPool(),
14892                            false, false, false, Alignment);
14893     SDValue OneV = DAG.getNode(X86ISD::VBROADCAST, DL, InVT, Ld);
14894     SDValue And = DAG.getNode(ISD::AND, DL, InVT, OneV, In);
14895     return DAG.getNode(X86ISD::TESTM, DL, VT, And, And);
14896   }
14897
14898   if ((VT == MVT::v4i32) && (InVT == MVT::v4i64)) {
14899     // On AVX2, v4i64 -> v4i32 becomes VPERMD.
14900     if (Subtarget->hasInt256()) {
14901       static const int ShufMask[] = {0, 2, 4, 6, -1, -1, -1, -1};
14902       In = DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, In);
14903       In = DAG.getVectorShuffle(MVT::v8i32, DL, In, DAG.getUNDEF(MVT::v8i32),
14904                                 ShufMask);
14905       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, In,
14906                          DAG.getIntPtrConstant(0));
14907     }
14908
14909     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14910                                DAG.getIntPtrConstant(0));
14911     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14912                                DAG.getIntPtrConstant(2));
14913     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
14914     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
14915     static const int ShufMask[] = {0, 2, 4, 6};
14916     return DAG.getVectorShuffle(VT, DL, OpLo, OpHi, ShufMask);
14917   }
14918
14919   if ((VT == MVT::v8i16) && (InVT == MVT::v8i32)) {
14920     // On AVX2, v8i32 -> v8i16 becomed PSHUFB.
14921     if (Subtarget->hasInt256()) {
14922       In = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, In);
14923
14924       SmallVector<SDValue,32> pshufbMask;
14925       for (unsigned i = 0; i < 2; ++i) {
14926         pshufbMask.push_back(DAG.getConstant(0x0, MVT::i8));
14927         pshufbMask.push_back(DAG.getConstant(0x1, MVT::i8));
14928         pshufbMask.push_back(DAG.getConstant(0x4, MVT::i8));
14929         pshufbMask.push_back(DAG.getConstant(0x5, MVT::i8));
14930         pshufbMask.push_back(DAG.getConstant(0x8, MVT::i8));
14931         pshufbMask.push_back(DAG.getConstant(0x9, MVT::i8));
14932         pshufbMask.push_back(DAG.getConstant(0xc, MVT::i8));
14933         pshufbMask.push_back(DAG.getConstant(0xd, MVT::i8));
14934         for (unsigned j = 0; j < 8; ++j)
14935           pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
14936       }
14937       SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, pshufbMask);
14938       In = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v32i8, In, BV);
14939       In = DAG.getNode(ISD::BITCAST, DL, MVT::v4i64, In);
14940
14941       static const int ShufMask[] = {0,  2,  -1,  -1};
14942       In = DAG.getVectorShuffle(MVT::v4i64, DL,  In, DAG.getUNDEF(MVT::v4i64),
14943                                 &ShufMask[0]);
14944       In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14945                        DAG.getIntPtrConstant(0));
14946       return DAG.getNode(ISD::BITCAST, DL, VT, In);
14947     }
14948
14949     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
14950                                DAG.getIntPtrConstant(0));
14951
14952     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
14953                                DAG.getIntPtrConstant(4));
14954
14955     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpLo);
14956     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpHi);
14957
14958     // The PSHUFB mask:
14959     static const int ShufMask1[] = {0,  1,  4,  5,  8,  9, 12, 13,
14960                                    -1, -1, -1, -1, -1, -1, -1, -1};
14961
14962     SDValue Undef = DAG.getUNDEF(MVT::v16i8);
14963     OpLo = DAG.getVectorShuffle(MVT::v16i8, DL, OpLo, Undef, ShufMask1);
14964     OpHi = DAG.getVectorShuffle(MVT::v16i8, DL, OpHi, Undef, ShufMask1);
14965
14966     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
14967     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
14968
14969     // The MOVLHPS Mask:
14970     static const int ShufMask2[] = {0, 1, 4, 5};
14971     SDValue res = DAG.getVectorShuffle(MVT::v4i32, DL, OpLo, OpHi, ShufMask2);
14972     return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, res);
14973   }
14974
14975   // Handle truncation of V256 to V128 using shuffles.
14976   if (!VT.is128BitVector() || !InVT.is256BitVector())
14977     return SDValue();
14978
14979   assert(Subtarget->hasFp256() && "256-bit vector without AVX!");
14980
14981   unsigned NumElems = VT.getVectorNumElements();
14982   MVT NVT = MVT::getVectorVT(VT.getVectorElementType(), NumElems * 2);
14983
14984   SmallVector<int, 16> MaskVec(NumElems * 2, -1);
14985   // Prepare truncation shuffle mask
14986   for (unsigned i = 0; i != NumElems; ++i)
14987     MaskVec[i] = i * 2;
14988   SDValue V = DAG.getVectorShuffle(NVT, DL,
14989                                    DAG.getNode(ISD::BITCAST, DL, NVT, In),
14990                                    DAG.getUNDEF(NVT), &MaskVec[0]);
14991   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, V,
14992                      DAG.getIntPtrConstant(0));
14993 }
14994
14995 SDValue X86TargetLowering::LowerFP_TO_SINT(SDValue Op,
14996                                            SelectionDAG &DAG) const {
14997   assert(!Op.getSimpleValueType().isVector());
14998
14999   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
15000     /*IsSigned=*/ true, /*IsReplace=*/ false);
15001   SDValue FIST = Vals.first, StackSlot = Vals.second;
15002   // If FP_TO_INTHelper failed, the node is actually supposed to be Legal.
15003   if (!FIST.getNode()) return Op;
15004
15005   if (StackSlot.getNode())
15006     // Load the result.
15007     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
15008                        FIST, StackSlot, MachinePointerInfo(),
15009                        false, false, false, 0);
15010
15011   // The node is the result.
15012   return FIST;
15013 }
15014
15015 SDValue X86TargetLowering::LowerFP_TO_UINT(SDValue Op,
15016                                            SelectionDAG &DAG) const {
15017   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
15018     /*IsSigned=*/ false, /*IsReplace=*/ false);
15019   SDValue FIST = Vals.first, StackSlot = Vals.second;
15020   assert(FIST.getNode() && "Unexpected failure");
15021
15022   if (StackSlot.getNode())
15023     // Load the result.
15024     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
15025                        FIST, StackSlot, MachinePointerInfo(),
15026                        false, false, false, 0);
15027
15028   // The node is the result.
15029   return FIST;
15030 }
15031
15032 static SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) {
15033   SDLoc DL(Op);
15034   MVT VT = Op.getSimpleValueType();
15035   SDValue In = Op.getOperand(0);
15036   MVT SVT = In.getSimpleValueType();
15037
15038   assert(SVT == MVT::v2f32 && "Only customize MVT::v2f32 type legalization!");
15039
15040   return DAG.getNode(X86ISD::VFPEXT, DL, VT,
15041                      DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4f32,
15042                                  In, DAG.getUNDEF(SVT)));
15043 }
15044
15045 /// The only differences between FABS and FNEG are the mask and the logic op.
15046 /// FNEG also has a folding opportunity for FNEG(FABS(x)).
15047 static SDValue LowerFABSorFNEG(SDValue Op, SelectionDAG &DAG) {
15048   assert((Op.getOpcode() == ISD::FABS || Op.getOpcode() == ISD::FNEG) &&
15049          "Wrong opcode for lowering FABS or FNEG.");
15050
15051   bool IsFABS = (Op.getOpcode() == ISD::FABS);
15052
15053   // If this is a FABS and it has an FNEG user, bail out to fold the combination
15054   // into an FNABS. We'll lower the FABS after that if it is still in use.
15055   if (IsFABS)
15056     for (SDNode *User : Op->uses())
15057       if (User->getOpcode() == ISD::FNEG)
15058         return Op;
15059
15060   SDValue Op0 = Op.getOperand(0);
15061   bool IsFNABS = !IsFABS && (Op0.getOpcode() == ISD::FABS);
15062
15063   SDLoc dl(Op);
15064   MVT VT = Op.getSimpleValueType();
15065   // Assume scalar op for initialization; update for vector if needed.
15066   // Note that there are no scalar bitwise logical SSE/AVX instructions, so we
15067   // generate a 16-byte vector constant and logic op even for the scalar case.
15068   // Using a 16-byte mask allows folding the load of the mask with
15069   // the logic op, so it can save (~4 bytes) on code size.
15070   MVT EltVT = VT;
15071   unsigned NumElts = VT == MVT::f64 ? 2 : 4;
15072   // FIXME: Use function attribute "OptimizeForSize" and/or CodeGenOpt::Level to
15073   // decide if we should generate a 16-byte constant mask when we only need 4 or
15074   // 8 bytes for the scalar case.
15075   if (VT.isVector()) {
15076     EltVT = VT.getVectorElementType();
15077     NumElts = VT.getVectorNumElements();
15078   }
15079
15080   unsigned EltBits = EltVT.getSizeInBits();
15081   LLVMContext *Context = DAG.getContext();
15082   // For FABS, mask is 0x7f...; for FNEG, mask is 0x80...
15083   APInt MaskElt =
15084     IsFABS ? APInt::getSignedMaxValue(EltBits) : APInt::getSignBit(EltBits);
15085   Constant *C = ConstantInt::get(*Context, MaskElt);
15086   C = ConstantVector::getSplat(NumElts, C);
15087   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
15088   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy());
15089   unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment();
15090   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
15091                              MachinePointerInfo::getConstantPool(),
15092                              false, false, false, Alignment);
15093
15094   if (VT.isVector()) {
15095     // For a vector, cast operands to a vector type, perform the logic op,
15096     // and cast the result back to the original value type.
15097     MVT VecVT = MVT::getVectorVT(MVT::i64, VT.getSizeInBits() / 64);
15098     SDValue MaskCasted = DAG.getNode(ISD::BITCAST, dl, VecVT, Mask);
15099     SDValue Operand = IsFNABS ?
15100       DAG.getNode(ISD::BITCAST, dl, VecVT, Op0.getOperand(0)) :
15101       DAG.getNode(ISD::BITCAST, dl, VecVT, Op0);
15102     unsigned BitOp = IsFABS ? ISD::AND : IsFNABS ? ISD::OR : ISD::XOR;
15103     return DAG.getNode(ISD::BITCAST, dl, VT,
15104                        DAG.getNode(BitOp, dl, VecVT, Operand, MaskCasted));
15105   }
15106
15107   // If not vector, then scalar.
15108   unsigned BitOp = IsFABS ? X86ISD::FAND : IsFNABS ? X86ISD::FOR : X86ISD::FXOR;
15109   SDValue Operand = IsFNABS ? Op0.getOperand(0) : Op0;
15110   return DAG.getNode(BitOp, dl, VT, Operand, Mask);
15111 }
15112
15113 static SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) {
15114   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
15115   LLVMContext *Context = DAG.getContext();
15116   SDValue Op0 = Op.getOperand(0);
15117   SDValue Op1 = Op.getOperand(1);
15118   SDLoc dl(Op);
15119   MVT VT = Op.getSimpleValueType();
15120   MVT SrcVT = Op1.getSimpleValueType();
15121
15122   // If second operand is smaller, extend it first.
15123   if (SrcVT.bitsLT(VT)) {
15124     Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
15125     SrcVT = VT;
15126   }
15127   // And if it is bigger, shrink it first.
15128   if (SrcVT.bitsGT(VT)) {
15129     Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
15130     SrcVT = VT;
15131   }
15132
15133   // At this point the operands and the result should have the same
15134   // type, and that won't be f80 since that is not custom lowered.
15135
15136   const fltSemantics &Sem =
15137       VT == MVT::f64 ? APFloat::IEEEdouble : APFloat::IEEEsingle;
15138   const unsigned SizeInBits = VT.getSizeInBits();
15139
15140   SmallVector<Constant *, 4> CV(
15141       VT == MVT::f64 ? 2 : 4,
15142       ConstantFP::get(*Context, APFloat(Sem, APInt(SizeInBits, 0))));
15143
15144   // First, clear all bits but the sign bit from the second operand (sign).
15145   CV[0] = ConstantFP::get(*Context,
15146                           APFloat(Sem, APInt::getHighBitsSet(SizeInBits, 1)));
15147   Constant *C = ConstantVector::get(CV);
15148   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
15149   SDValue Mask1 = DAG.getLoad(SrcVT, dl, DAG.getEntryNode(), CPIdx,
15150                               MachinePointerInfo::getConstantPool(),
15151                               false, false, false, 16);
15152   SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
15153
15154   // Next, clear the sign bit from the first operand (magnitude).
15155   // If it's a constant, we can clear it here.
15156   if (ConstantFPSDNode *Op0CN = dyn_cast<ConstantFPSDNode>(Op0)) {
15157     APFloat APF = Op0CN->getValueAPF();
15158     // If the magnitude is a positive zero, the sign bit alone is enough.
15159     if (APF.isPosZero())
15160       return SignBit;
15161     APF.clearSign();
15162     CV[0] = ConstantFP::get(*Context, APF);
15163   } else {
15164     CV[0] = ConstantFP::get(
15165         *Context,
15166         APFloat(Sem, APInt::getLowBitsSet(SizeInBits, SizeInBits - 1)));
15167   }
15168   C = ConstantVector::get(CV);
15169   CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
15170   SDValue Val = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
15171                             MachinePointerInfo::getConstantPool(),
15172                             false, false, false, 16);
15173   // If the magnitude operand wasn't a constant, we need to AND out the sign.
15174   if (!isa<ConstantFPSDNode>(Op0))
15175     Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Val);
15176
15177   // OR the magnitude value with the sign bit.
15178   return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
15179 }
15180
15181 static SDValue LowerFGETSIGN(SDValue Op, SelectionDAG &DAG) {
15182   SDValue N0 = Op.getOperand(0);
15183   SDLoc dl(Op);
15184   MVT VT = Op.getSimpleValueType();
15185
15186   // Lower ISD::FGETSIGN to (AND (X86ISD::FGETSIGNx86 ...) 1).
15187   SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
15188                                   DAG.getConstant(1, VT));
15189   return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
15190 }
15191
15192 // Check whether an OR'd tree is PTEST-able.
15193 static SDValue LowerVectorAllZeroTest(SDValue Op, const X86Subtarget *Subtarget,
15194                                       SelectionDAG &DAG) {
15195   assert(Op.getOpcode() == ISD::OR && "Only check OR'd tree.");
15196
15197   if (!Subtarget->hasSSE41())
15198     return SDValue();
15199
15200   if (!Op->hasOneUse())
15201     return SDValue();
15202
15203   SDNode *N = Op.getNode();
15204   SDLoc DL(N);
15205
15206   SmallVector<SDValue, 8> Opnds;
15207   DenseMap<SDValue, unsigned> VecInMap;
15208   SmallVector<SDValue, 8> VecIns;
15209   EVT VT = MVT::Other;
15210
15211   // Recognize a special case where a vector is casted into wide integer to
15212   // test all 0s.
15213   Opnds.push_back(N->getOperand(0));
15214   Opnds.push_back(N->getOperand(1));
15215
15216   for (unsigned Slot = 0, e = Opnds.size(); Slot < e; ++Slot) {
15217     SmallVectorImpl<SDValue>::const_iterator I = Opnds.begin() + Slot;
15218     // BFS traverse all OR'd operands.
15219     if (I->getOpcode() == ISD::OR) {
15220       Opnds.push_back(I->getOperand(0));
15221       Opnds.push_back(I->getOperand(1));
15222       // Re-evaluate the number of nodes to be traversed.
15223       e += 2; // 2 more nodes (LHS and RHS) are pushed.
15224       continue;
15225     }
15226
15227     // Quit if a non-EXTRACT_VECTOR_ELT
15228     if (I->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
15229       return SDValue();
15230
15231     // Quit if without a constant index.
15232     SDValue Idx = I->getOperand(1);
15233     if (!isa<ConstantSDNode>(Idx))
15234       return SDValue();
15235
15236     SDValue ExtractedFromVec = I->getOperand(0);
15237     DenseMap<SDValue, unsigned>::iterator M = VecInMap.find(ExtractedFromVec);
15238     if (M == VecInMap.end()) {
15239       VT = ExtractedFromVec.getValueType();
15240       // Quit if not 128/256-bit vector.
15241       if (!VT.is128BitVector() && !VT.is256BitVector())
15242         return SDValue();
15243       // Quit if not the same type.
15244       if (VecInMap.begin() != VecInMap.end() &&
15245           VT != VecInMap.begin()->first.getValueType())
15246         return SDValue();
15247       M = VecInMap.insert(std::make_pair(ExtractedFromVec, 0)).first;
15248       VecIns.push_back(ExtractedFromVec);
15249     }
15250     M->second |= 1U << cast<ConstantSDNode>(Idx)->getZExtValue();
15251   }
15252
15253   assert((VT.is128BitVector() || VT.is256BitVector()) &&
15254          "Not extracted from 128-/256-bit vector.");
15255
15256   unsigned FullMask = (1U << VT.getVectorNumElements()) - 1U;
15257
15258   for (DenseMap<SDValue, unsigned>::const_iterator
15259         I = VecInMap.begin(), E = VecInMap.end(); I != E; ++I) {
15260     // Quit if not all elements are used.
15261     if (I->second != FullMask)
15262       return SDValue();
15263   }
15264
15265   EVT TestVT = VT.is128BitVector() ? MVT::v2i64 : MVT::v4i64;
15266
15267   // Cast all vectors into TestVT for PTEST.
15268   for (unsigned i = 0, e = VecIns.size(); i < e; ++i)
15269     VecIns[i] = DAG.getNode(ISD::BITCAST, DL, TestVT, VecIns[i]);
15270
15271   // If more than one full vectors are evaluated, OR them first before PTEST.
15272   for (unsigned Slot = 0, e = VecIns.size(); e - Slot > 1; Slot += 2, e += 1) {
15273     // Each iteration will OR 2 nodes and append the result until there is only
15274     // 1 node left, i.e. the final OR'd value of all vectors.
15275     SDValue LHS = VecIns[Slot];
15276     SDValue RHS = VecIns[Slot + 1];
15277     VecIns.push_back(DAG.getNode(ISD::OR, DL, TestVT, LHS, RHS));
15278   }
15279
15280   return DAG.getNode(X86ISD::PTEST, DL, MVT::i32,
15281                      VecIns.back(), VecIns.back());
15282 }
15283
15284 /// \brief return true if \c Op has a use that doesn't just read flags.
15285 static bool hasNonFlagsUse(SDValue Op) {
15286   for (SDNode::use_iterator UI = Op->use_begin(), UE = Op->use_end(); UI != UE;
15287        ++UI) {
15288     SDNode *User = *UI;
15289     unsigned UOpNo = UI.getOperandNo();
15290     if (User->getOpcode() == ISD::TRUNCATE && User->hasOneUse()) {
15291       // Look pass truncate.
15292       UOpNo = User->use_begin().getOperandNo();
15293       User = *User->use_begin();
15294     }
15295
15296     if (User->getOpcode() != ISD::BRCOND && User->getOpcode() != ISD::SETCC &&
15297         !(User->getOpcode() == ISD::SELECT && UOpNo == 0))
15298       return true;
15299   }
15300   return false;
15301 }
15302
15303 /// Emit nodes that will be selected as "test Op0,Op0", or something
15304 /// equivalent.
15305 SDValue X86TargetLowering::EmitTest(SDValue Op, unsigned X86CC, SDLoc dl,
15306                                     SelectionDAG &DAG) const {
15307   if (Op.getValueType() == MVT::i1) {
15308     SDValue ExtOp = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i8, Op);
15309     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, ExtOp,
15310                        DAG.getConstant(0, MVT::i8));
15311   }
15312   // CF and OF aren't always set the way we want. Determine which
15313   // of these we need.
15314   bool NeedCF = false;
15315   bool NeedOF = false;
15316   switch (X86CC) {
15317   default: break;
15318   case X86::COND_A: case X86::COND_AE:
15319   case X86::COND_B: case X86::COND_BE:
15320     NeedCF = true;
15321     break;
15322   case X86::COND_G: case X86::COND_GE:
15323   case X86::COND_L: case X86::COND_LE:
15324   case X86::COND_O: case X86::COND_NO: {
15325     // Check if we really need to set the
15326     // Overflow flag. If NoSignedWrap is present
15327     // that is not actually needed.
15328     switch (Op->getOpcode()) {
15329     case ISD::ADD:
15330     case ISD::SUB:
15331     case ISD::MUL:
15332     case ISD::SHL: {
15333       const BinaryWithFlagsSDNode *BinNode =
15334           cast<BinaryWithFlagsSDNode>(Op.getNode());
15335       if (BinNode->hasNoSignedWrap())
15336         break;
15337     }
15338     default:
15339       NeedOF = true;
15340       break;
15341     }
15342     break;
15343   }
15344   }
15345   // See if we can use the EFLAGS value from the operand instead of
15346   // doing a separate TEST. TEST always sets OF and CF to 0, so unless
15347   // we prove that the arithmetic won't overflow, we can't use OF or CF.
15348   if (Op.getResNo() != 0 || NeedOF || NeedCF) {
15349     // Emit a CMP with 0, which is the TEST pattern.
15350     //if (Op.getValueType() == MVT::i1)
15351     //  return DAG.getNode(X86ISD::CMP, dl, MVT::i1, Op,
15352     //                     DAG.getConstant(0, MVT::i1));
15353     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
15354                        DAG.getConstant(0, Op.getValueType()));
15355   }
15356   unsigned Opcode = 0;
15357   unsigned NumOperands = 0;
15358
15359   // Truncate operations may prevent the merge of the SETCC instruction
15360   // and the arithmetic instruction before it. Attempt to truncate the operands
15361   // of the arithmetic instruction and use a reduced bit-width instruction.
15362   bool NeedTruncation = false;
15363   SDValue ArithOp = Op;
15364   if (Op->getOpcode() == ISD::TRUNCATE && Op->hasOneUse()) {
15365     SDValue Arith = Op->getOperand(0);
15366     // Both the trunc and the arithmetic op need to have one user each.
15367     if (Arith->hasOneUse())
15368       switch (Arith.getOpcode()) {
15369         default: break;
15370         case ISD::ADD:
15371         case ISD::SUB:
15372         case ISD::AND:
15373         case ISD::OR:
15374         case ISD::XOR: {
15375           NeedTruncation = true;
15376           ArithOp = Arith;
15377         }
15378       }
15379   }
15380
15381   // NOTICE: In the code below we use ArithOp to hold the arithmetic operation
15382   // which may be the result of a CAST.  We use the variable 'Op', which is the
15383   // non-casted variable when we check for possible users.
15384   switch (ArithOp.getOpcode()) {
15385   case ISD::ADD:
15386     // Due to an isel shortcoming, be conservative if this add is likely to be
15387     // selected as part of a load-modify-store instruction. When the root node
15388     // in a match is a store, isel doesn't know how to remap non-chain non-flag
15389     // uses of other nodes in the match, such as the ADD in this case. This
15390     // leads to the ADD being left around and reselected, with the result being
15391     // two adds in the output.  Alas, even if none our users are stores, that
15392     // doesn't prove we're O.K.  Ergo, if we have any parents that aren't
15393     // CopyToReg or SETCC, eschew INC/DEC.  A better fix seems to require
15394     // climbing the DAG back to the root, and it doesn't seem to be worth the
15395     // effort.
15396     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
15397          UE = Op.getNode()->use_end(); UI != UE; ++UI)
15398       if (UI->getOpcode() != ISD::CopyToReg &&
15399           UI->getOpcode() != ISD::SETCC &&
15400           UI->getOpcode() != ISD::STORE)
15401         goto default_case;
15402
15403     if (ConstantSDNode *C =
15404         dyn_cast<ConstantSDNode>(ArithOp.getNode()->getOperand(1))) {
15405       // An add of one will be selected as an INC.
15406       if (C->getAPIntValue() == 1 && !Subtarget->slowIncDec()) {
15407         Opcode = X86ISD::INC;
15408         NumOperands = 1;
15409         break;
15410       }
15411
15412       // An add of negative one (subtract of one) will be selected as a DEC.
15413       if (C->getAPIntValue().isAllOnesValue() && !Subtarget->slowIncDec()) {
15414         Opcode = X86ISD::DEC;
15415         NumOperands = 1;
15416         break;
15417       }
15418     }
15419
15420     // Otherwise use a regular EFLAGS-setting add.
15421     Opcode = X86ISD::ADD;
15422     NumOperands = 2;
15423     break;
15424   case ISD::SHL:
15425   case ISD::SRL:
15426     // If we have a constant logical shift that's only used in a comparison
15427     // against zero turn it into an equivalent AND. This allows turning it into
15428     // a TEST instruction later.
15429     if ((X86CC == X86::COND_E || X86CC == X86::COND_NE) && Op->hasOneUse() &&
15430         isa<ConstantSDNode>(Op->getOperand(1)) && !hasNonFlagsUse(Op)) {
15431       EVT VT = Op.getValueType();
15432       unsigned BitWidth = VT.getSizeInBits();
15433       unsigned ShAmt = Op->getConstantOperandVal(1);
15434       if (ShAmt >= BitWidth) // Avoid undefined shifts.
15435         break;
15436       APInt Mask = ArithOp.getOpcode() == ISD::SRL
15437                        ? APInt::getHighBitsSet(BitWidth, BitWidth - ShAmt)
15438                        : APInt::getLowBitsSet(BitWidth, BitWidth - ShAmt);
15439       if (!Mask.isSignedIntN(32)) // Avoid large immediates.
15440         break;
15441       SDValue New = DAG.getNode(ISD::AND, dl, VT, Op->getOperand(0),
15442                                 DAG.getConstant(Mask, VT));
15443       DAG.ReplaceAllUsesWith(Op, New);
15444       Op = New;
15445     }
15446     break;
15447
15448   case ISD::AND:
15449     // If the primary and result isn't used, don't bother using X86ISD::AND,
15450     // because a TEST instruction will be better.
15451     if (!hasNonFlagsUse(Op))
15452       break;
15453     // FALL THROUGH
15454   case ISD::SUB:
15455   case ISD::OR:
15456   case ISD::XOR:
15457     // Due to the ISEL shortcoming noted above, be conservative if this op is
15458     // likely to be selected as part of a load-modify-store instruction.
15459     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
15460            UE = Op.getNode()->use_end(); UI != UE; ++UI)
15461       if (UI->getOpcode() == ISD::STORE)
15462         goto default_case;
15463
15464     // Otherwise use a regular EFLAGS-setting instruction.
15465     switch (ArithOp.getOpcode()) {
15466     default: llvm_unreachable("unexpected operator!");
15467     case ISD::SUB: Opcode = X86ISD::SUB; break;
15468     case ISD::XOR: Opcode = X86ISD::XOR; break;
15469     case ISD::AND: Opcode = X86ISD::AND; break;
15470     case ISD::OR: {
15471       if (!NeedTruncation && (X86CC == X86::COND_E || X86CC == X86::COND_NE)) {
15472         SDValue EFLAGS = LowerVectorAllZeroTest(Op, Subtarget, DAG);
15473         if (EFLAGS.getNode())
15474           return EFLAGS;
15475       }
15476       Opcode = X86ISD::OR;
15477       break;
15478     }
15479     }
15480
15481     NumOperands = 2;
15482     break;
15483   case X86ISD::ADD:
15484   case X86ISD::SUB:
15485   case X86ISD::INC:
15486   case X86ISD::DEC:
15487   case X86ISD::OR:
15488   case X86ISD::XOR:
15489   case X86ISD::AND:
15490     return SDValue(Op.getNode(), 1);
15491   default:
15492   default_case:
15493     break;
15494   }
15495
15496   // If we found that truncation is beneficial, perform the truncation and
15497   // update 'Op'.
15498   if (NeedTruncation) {
15499     EVT VT = Op.getValueType();
15500     SDValue WideVal = Op->getOperand(0);
15501     EVT WideVT = WideVal.getValueType();
15502     unsigned ConvertedOp = 0;
15503     // Use a target machine opcode to prevent further DAGCombine
15504     // optimizations that may separate the arithmetic operations
15505     // from the setcc node.
15506     switch (WideVal.getOpcode()) {
15507       default: break;
15508       case ISD::ADD: ConvertedOp = X86ISD::ADD; break;
15509       case ISD::SUB: ConvertedOp = X86ISD::SUB; break;
15510       case ISD::AND: ConvertedOp = X86ISD::AND; break;
15511       case ISD::OR:  ConvertedOp = X86ISD::OR;  break;
15512       case ISD::XOR: ConvertedOp = X86ISD::XOR; break;
15513     }
15514
15515     if (ConvertedOp) {
15516       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
15517       if (TLI.isOperationLegal(WideVal.getOpcode(), WideVT)) {
15518         SDValue V0 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(0));
15519         SDValue V1 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(1));
15520         Op = DAG.getNode(ConvertedOp, dl, VT, V0, V1);
15521       }
15522     }
15523   }
15524
15525   if (Opcode == 0)
15526     // Emit a CMP with 0, which is the TEST pattern.
15527     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
15528                        DAG.getConstant(0, Op.getValueType()));
15529
15530   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
15531   SmallVector<SDValue, 4> Ops(Op->op_begin(), Op->op_begin() + NumOperands);
15532
15533   SDValue New = DAG.getNode(Opcode, dl, VTs, Ops);
15534   DAG.ReplaceAllUsesWith(Op, New);
15535   return SDValue(New.getNode(), 1);
15536 }
15537
15538 /// Emit nodes that will be selected as "cmp Op0,Op1", or something
15539 /// equivalent.
15540 SDValue X86TargetLowering::EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC,
15541                                    SDLoc dl, SelectionDAG &DAG) const {
15542   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op1)) {
15543     if (C->getAPIntValue() == 0)
15544       return EmitTest(Op0, X86CC, dl, DAG);
15545
15546      if (Op0.getValueType() == MVT::i1)
15547        llvm_unreachable("Unexpected comparison operation for MVT::i1 operands");
15548   }
15549
15550   if ((Op0.getValueType() == MVT::i8 || Op0.getValueType() == MVT::i16 ||
15551        Op0.getValueType() == MVT::i32 || Op0.getValueType() == MVT::i64)) {
15552     // Do the comparison at i32 if it's smaller, besides the Atom case.
15553     // This avoids subregister aliasing issues. Keep the smaller reference
15554     // if we're optimizing for size, however, as that'll allow better folding
15555     // of memory operations.
15556     if (Op0.getValueType() != MVT::i32 && Op0.getValueType() != MVT::i64 &&
15557         !DAG.getMachineFunction().getFunction()->hasFnAttribute(
15558             Attribute::MinSize) &&
15559         !Subtarget->isAtom()) {
15560       unsigned ExtendOp =
15561           isX86CCUnsigned(X86CC) ? ISD::ZERO_EXTEND : ISD::SIGN_EXTEND;
15562       Op0 = DAG.getNode(ExtendOp, dl, MVT::i32, Op0);
15563       Op1 = DAG.getNode(ExtendOp, dl, MVT::i32, Op1);
15564     }
15565     // Use SUB instead of CMP to enable CSE between SUB and CMP.
15566     SDVTList VTs = DAG.getVTList(Op0.getValueType(), MVT::i32);
15567     SDValue Sub = DAG.getNode(X86ISD::SUB, dl, VTs,
15568                               Op0, Op1);
15569     return SDValue(Sub.getNode(), 1);
15570   }
15571   return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
15572 }
15573
15574 /// Convert a comparison if required by the subtarget.
15575 SDValue X86TargetLowering::ConvertCmpIfNecessary(SDValue Cmp,
15576                                                  SelectionDAG &DAG) const {
15577   // If the subtarget does not support the FUCOMI instruction, floating-point
15578   // comparisons have to be converted.
15579   if (Subtarget->hasCMov() ||
15580       Cmp.getOpcode() != X86ISD::CMP ||
15581       !Cmp.getOperand(0).getValueType().isFloatingPoint() ||
15582       !Cmp.getOperand(1).getValueType().isFloatingPoint())
15583     return Cmp;
15584
15585   // The instruction selector will select an FUCOM instruction instead of
15586   // FUCOMI, which writes the comparison result to FPSW instead of EFLAGS. Hence
15587   // build an SDNode sequence that transfers the result from FPSW into EFLAGS:
15588   // (X86sahf (trunc (srl (X86fp_stsw (trunc (X86cmp ...)), 8))))
15589   SDLoc dl(Cmp);
15590   SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
15591   SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
15592   SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
15593                             DAG.getConstant(8, MVT::i8));
15594   SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
15595   return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
15596 }
15597
15598 /// The minimum architected relative accuracy is 2^-12. We need one
15599 /// Newton-Raphson step to have a good float result (24 bits of precision).
15600 SDValue X86TargetLowering::getRsqrtEstimate(SDValue Op,
15601                                             DAGCombinerInfo &DCI,
15602                                             unsigned &RefinementSteps,
15603                                             bool &UseOneConstNR) const {
15604   // FIXME: We should use instruction latency models to calculate the cost of
15605   // each potential sequence, but this is very hard to do reliably because
15606   // at least Intel's Core* chips have variable timing based on the number of
15607   // significant digits in the divisor and/or sqrt operand.
15608   if (!Subtarget->useSqrtEst())
15609     return SDValue();
15610
15611   EVT VT = Op.getValueType();
15612
15613   // SSE1 has rsqrtss and rsqrtps.
15614   // TODO: Add support for AVX512 (v16f32).
15615   // It is likely not profitable to do this for f64 because a double-precision
15616   // rsqrt estimate with refinement on x86 prior to FMA requires at least 16
15617   // instructions: convert to single, rsqrtss, convert back to double, refine
15618   // (3 steps = at least 13 insts). If an 'rsqrtsd' variant was added to the ISA
15619   // along with FMA, this could be a throughput win.
15620   if ((Subtarget->hasSSE1() && (VT == MVT::f32 || VT == MVT::v4f32)) ||
15621       (Subtarget->hasAVX() && VT == MVT::v8f32)) {
15622     RefinementSteps = 1;
15623     UseOneConstNR = false;
15624     return DCI.DAG.getNode(X86ISD::FRSQRT, SDLoc(Op), VT, Op);
15625   }
15626   return SDValue();
15627 }
15628
15629 /// The minimum architected relative accuracy is 2^-12. We need one
15630 /// Newton-Raphson step to have a good float result (24 bits of precision).
15631 SDValue X86TargetLowering::getRecipEstimate(SDValue Op,
15632                                             DAGCombinerInfo &DCI,
15633                                             unsigned &RefinementSteps) const {
15634   // FIXME: We should use instruction latency models to calculate the cost of
15635   // each potential sequence, but this is very hard to do reliably because
15636   // at least Intel's Core* chips have variable timing based on the number of
15637   // significant digits in the divisor.
15638   if (!Subtarget->useReciprocalEst())
15639     return SDValue();
15640
15641   EVT VT = Op.getValueType();
15642
15643   // SSE1 has rcpss and rcpps. AVX adds a 256-bit variant for rcpps.
15644   // TODO: Add support for AVX512 (v16f32).
15645   // It is likely not profitable to do this for f64 because a double-precision
15646   // reciprocal estimate with refinement on x86 prior to FMA requires
15647   // 15 instructions: convert to single, rcpss, convert back to double, refine
15648   // (3 steps = 12 insts). If an 'rcpsd' variant was added to the ISA
15649   // along with FMA, this could be a throughput win.
15650   if ((Subtarget->hasSSE1() && (VT == MVT::f32 || VT == MVT::v4f32)) ||
15651       (Subtarget->hasAVX() && VT == MVT::v8f32)) {
15652     RefinementSteps = ReciprocalEstimateRefinementSteps;
15653     return DCI.DAG.getNode(X86ISD::FRCP, SDLoc(Op), VT, Op);
15654   }
15655   return SDValue();
15656 }
15657
15658 static bool isAllOnes(SDValue V) {
15659   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
15660   return C && C->isAllOnesValue();
15661 }
15662
15663 /// LowerToBT - Result of 'and' is compared against zero. Turn it into a BT node
15664 /// if it's possible.
15665 SDValue X86TargetLowering::LowerToBT(SDValue And, ISD::CondCode CC,
15666                                      SDLoc dl, SelectionDAG &DAG) const {
15667   SDValue Op0 = And.getOperand(0);
15668   SDValue Op1 = And.getOperand(1);
15669   if (Op0.getOpcode() == ISD::TRUNCATE)
15670     Op0 = Op0.getOperand(0);
15671   if (Op1.getOpcode() == ISD::TRUNCATE)
15672     Op1 = Op1.getOperand(0);
15673
15674   SDValue LHS, RHS;
15675   if (Op1.getOpcode() == ISD::SHL)
15676     std::swap(Op0, Op1);
15677   if (Op0.getOpcode() == ISD::SHL) {
15678     if (ConstantSDNode *And00C = dyn_cast<ConstantSDNode>(Op0.getOperand(0)))
15679       if (And00C->getZExtValue() == 1) {
15680         // If we looked past a truncate, check that it's only truncating away
15681         // known zeros.
15682         unsigned BitWidth = Op0.getValueSizeInBits();
15683         unsigned AndBitWidth = And.getValueSizeInBits();
15684         if (BitWidth > AndBitWidth) {
15685           APInt Zeros, Ones;
15686           DAG.computeKnownBits(Op0, Zeros, Ones);
15687           if (Zeros.countLeadingOnes() < BitWidth - AndBitWidth)
15688             return SDValue();
15689         }
15690         LHS = Op1;
15691         RHS = Op0.getOperand(1);
15692       }
15693   } else if (Op1.getOpcode() == ISD::Constant) {
15694     ConstantSDNode *AndRHS = cast<ConstantSDNode>(Op1);
15695     uint64_t AndRHSVal = AndRHS->getZExtValue();
15696     SDValue AndLHS = Op0;
15697
15698     if (AndRHSVal == 1 && AndLHS.getOpcode() == ISD::SRL) {
15699       LHS = AndLHS.getOperand(0);
15700       RHS = AndLHS.getOperand(1);
15701     }
15702
15703     // Use BT if the immediate can't be encoded in a TEST instruction.
15704     if (!isUInt<32>(AndRHSVal) && isPowerOf2_64(AndRHSVal)) {
15705       LHS = AndLHS;
15706       RHS = DAG.getConstant(Log2_64_Ceil(AndRHSVal), LHS.getValueType());
15707     }
15708   }
15709
15710   if (LHS.getNode()) {
15711     // If LHS is i8, promote it to i32 with any_extend.  There is no i8 BT
15712     // instruction.  Since the shift amount is in-range-or-undefined, we know
15713     // that doing a bittest on the i32 value is ok.  We extend to i32 because
15714     // the encoding for the i16 version is larger than the i32 version.
15715     // Also promote i16 to i32 for performance / code size reason.
15716     if (LHS.getValueType() == MVT::i8 ||
15717         LHS.getValueType() == MVT::i16)
15718       LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
15719
15720     // If the operand types disagree, extend the shift amount to match.  Since
15721     // BT ignores high bits (like shifts) we can use anyextend.
15722     if (LHS.getValueType() != RHS.getValueType())
15723       RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
15724
15725     SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
15726     X86::CondCode Cond = CC == ISD::SETEQ ? X86::COND_AE : X86::COND_B;
15727     return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
15728                        DAG.getConstant(Cond, MVT::i8), BT);
15729   }
15730
15731   return SDValue();
15732 }
15733
15734 /// \brief - Turns an ISD::CondCode into a value suitable for SSE floating point
15735 /// mask CMPs.
15736 static int translateX86FSETCC(ISD::CondCode SetCCOpcode, SDValue &Op0,
15737                               SDValue &Op1) {
15738   unsigned SSECC;
15739   bool Swap = false;
15740
15741   // SSE Condition code mapping:
15742   //  0 - EQ
15743   //  1 - LT
15744   //  2 - LE
15745   //  3 - UNORD
15746   //  4 - NEQ
15747   //  5 - NLT
15748   //  6 - NLE
15749   //  7 - ORD
15750   switch (SetCCOpcode) {
15751   default: llvm_unreachable("Unexpected SETCC condition");
15752   case ISD::SETOEQ:
15753   case ISD::SETEQ:  SSECC = 0; break;
15754   case ISD::SETOGT:
15755   case ISD::SETGT:  Swap = true; // Fallthrough
15756   case ISD::SETLT:
15757   case ISD::SETOLT: SSECC = 1; break;
15758   case ISD::SETOGE:
15759   case ISD::SETGE:  Swap = true; // Fallthrough
15760   case ISD::SETLE:
15761   case ISD::SETOLE: SSECC = 2; break;
15762   case ISD::SETUO:  SSECC = 3; break;
15763   case ISD::SETUNE:
15764   case ISD::SETNE:  SSECC = 4; break;
15765   case ISD::SETULE: Swap = true; // Fallthrough
15766   case ISD::SETUGE: SSECC = 5; break;
15767   case ISD::SETULT: Swap = true; // Fallthrough
15768   case ISD::SETUGT: SSECC = 6; break;
15769   case ISD::SETO:   SSECC = 7; break;
15770   case ISD::SETUEQ:
15771   case ISD::SETONE: SSECC = 8; break;
15772   }
15773   if (Swap)
15774     std::swap(Op0, Op1);
15775
15776   return SSECC;
15777 }
15778
15779 // Lower256IntVSETCC - Break a VSETCC 256-bit integer VSETCC into two new 128
15780 // ones, and then concatenate the result back.
15781 static SDValue Lower256IntVSETCC(SDValue Op, SelectionDAG &DAG) {
15782   MVT VT = Op.getSimpleValueType();
15783
15784   assert(VT.is256BitVector() && Op.getOpcode() == ISD::SETCC &&
15785          "Unsupported value type for operation");
15786
15787   unsigned NumElems = VT.getVectorNumElements();
15788   SDLoc dl(Op);
15789   SDValue CC = Op.getOperand(2);
15790
15791   // Extract the LHS vectors
15792   SDValue LHS = Op.getOperand(0);
15793   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
15794   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
15795
15796   // Extract the RHS vectors
15797   SDValue RHS = Op.getOperand(1);
15798   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
15799   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
15800
15801   // Issue the operation on the smaller types and concatenate the result back
15802   MVT EltVT = VT.getVectorElementType();
15803   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
15804   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
15805                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
15806                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
15807 }
15808
15809 static SDValue LowerIntVSETCC_AVX512(SDValue Op, SelectionDAG &DAG,
15810                                      const X86Subtarget *Subtarget) {
15811   SDValue Op0 = Op.getOperand(0);
15812   SDValue Op1 = Op.getOperand(1);
15813   SDValue CC = Op.getOperand(2);
15814   MVT VT = Op.getSimpleValueType();
15815   SDLoc dl(Op);
15816
15817   assert(Op0.getValueType().getVectorElementType().getSizeInBits() >= 8 &&
15818          Op.getValueType().getScalarType() == MVT::i1 &&
15819          "Cannot set masked compare for this operation");
15820
15821   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
15822   unsigned  Opc = 0;
15823   bool Unsigned = false;
15824   bool Swap = false;
15825   unsigned SSECC;
15826   switch (SetCCOpcode) {
15827   default: llvm_unreachable("Unexpected SETCC condition");
15828   case ISD::SETNE:  SSECC = 4; break;
15829   case ISD::SETEQ:  Opc = X86ISD::PCMPEQM; break;
15830   case ISD::SETUGT: SSECC = 6; Unsigned = true; break;
15831   case ISD::SETLT:  Swap = true; //fall-through
15832   case ISD::SETGT:  Opc = X86ISD::PCMPGTM; break;
15833   case ISD::SETULT: SSECC = 1; Unsigned = true; break;
15834   case ISD::SETUGE: SSECC = 5; Unsigned = true; break; //NLT
15835   case ISD::SETGE:  Swap = true; SSECC = 2; break; // LE + swap
15836   case ISD::SETULE: Unsigned = true; //fall-through
15837   case ISD::SETLE:  SSECC = 2; break;
15838   }
15839
15840   if (Swap)
15841     std::swap(Op0, Op1);
15842   if (Opc)
15843     return DAG.getNode(Opc, dl, VT, Op0, Op1);
15844   Opc = Unsigned ? X86ISD::CMPMU: X86ISD::CMPM;
15845   return DAG.getNode(Opc, dl, VT, Op0, Op1,
15846                      DAG.getConstant(SSECC, MVT::i8));
15847 }
15848
15849 /// \brief Try to turn a VSETULT into a VSETULE by modifying its second
15850 /// operand \p Op1.  If non-trivial (for example because it's not constant)
15851 /// return an empty value.
15852 static SDValue ChangeVSETULTtoVSETULE(SDLoc dl, SDValue Op1, SelectionDAG &DAG)
15853 {
15854   BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Op1.getNode());
15855   if (!BV)
15856     return SDValue();
15857
15858   MVT VT = Op1.getSimpleValueType();
15859   MVT EVT = VT.getVectorElementType();
15860   unsigned n = VT.getVectorNumElements();
15861   SmallVector<SDValue, 8> ULTOp1;
15862
15863   for (unsigned i = 0; i < n; ++i) {
15864     ConstantSDNode *Elt = dyn_cast<ConstantSDNode>(BV->getOperand(i));
15865     if (!Elt || Elt->isOpaque() || Elt->getValueType(0) != EVT)
15866       return SDValue();
15867
15868     // Avoid underflow.
15869     APInt Val = Elt->getAPIntValue();
15870     if (Val == 0)
15871       return SDValue();
15872
15873     ULTOp1.push_back(DAG.getConstant(Val - 1, EVT));
15874   }
15875
15876   return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, ULTOp1);
15877 }
15878
15879 static SDValue LowerVSETCC(SDValue Op, const X86Subtarget *Subtarget,
15880                            SelectionDAG &DAG) {
15881   SDValue Op0 = Op.getOperand(0);
15882   SDValue Op1 = Op.getOperand(1);
15883   SDValue CC = Op.getOperand(2);
15884   MVT VT = Op.getSimpleValueType();
15885   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
15886   bool isFP = Op.getOperand(1).getSimpleValueType().isFloatingPoint();
15887   SDLoc dl(Op);
15888
15889   if (isFP) {
15890 #ifndef NDEBUG
15891     MVT EltVT = Op0.getSimpleValueType().getVectorElementType();
15892     assert(EltVT == MVT::f32 || EltVT == MVT::f64);
15893 #endif
15894
15895     unsigned SSECC = translateX86FSETCC(SetCCOpcode, Op0, Op1);
15896     unsigned Opc = X86ISD::CMPP;
15897     if (Subtarget->hasAVX512() && VT.getVectorElementType() == MVT::i1) {
15898       assert(VT.getVectorNumElements() <= 16);
15899       Opc = X86ISD::CMPM;
15900     }
15901     // In the two special cases we can't handle, emit two comparisons.
15902     if (SSECC == 8) {
15903       unsigned CC0, CC1;
15904       unsigned CombineOpc;
15905       if (SetCCOpcode == ISD::SETUEQ) {
15906         CC0 = 3; CC1 = 0; CombineOpc = ISD::OR;
15907       } else {
15908         assert(SetCCOpcode == ISD::SETONE);
15909         CC0 = 7; CC1 = 4; CombineOpc = ISD::AND;
15910       }
15911
15912       SDValue Cmp0 = DAG.getNode(Opc, dl, VT, Op0, Op1,
15913                                  DAG.getConstant(CC0, MVT::i8));
15914       SDValue Cmp1 = DAG.getNode(Opc, dl, VT, Op0, Op1,
15915                                  DAG.getConstant(CC1, MVT::i8));
15916       return DAG.getNode(CombineOpc, dl, VT, Cmp0, Cmp1);
15917     }
15918     // Handle all other FP comparisons here.
15919     return DAG.getNode(Opc, dl, VT, Op0, Op1,
15920                        DAG.getConstant(SSECC, MVT::i8));
15921   }
15922
15923   // Break 256-bit integer vector compare into smaller ones.
15924   if (VT.is256BitVector() && !Subtarget->hasInt256())
15925     return Lower256IntVSETCC(Op, DAG);
15926
15927   bool MaskResult = (VT.getVectorElementType() == MVT::i1);
15928   EVT OpVT = Op1.getValueType();
15929   if (Subtarget->hasAVX512()) {
15930     if (Op1.getValueType().is512BitVector() ||
15931         (Subtarget->hasBWI() && Subtarget->hasVLX()) ||
15932         (MaskResult && OpVT.getVectorElementType().getSizeInBits() >= 32))
15933       return LowerIntVSETCC_AVX512(Op, DAG, Subtarget);
15934
15935     // In AVX-512 architecture setcc returns mask with i1 elements,
15936     // But there is no compare instruction for i8 and i16 elements in KNL.
15937     // We are not talking about 512-bit operands in this case, these
15938     // types are illegal.
15939     if (MaskResult &&
15940         (OpVT.getVectorElementType().getSizeInBits() < 32 &&
15941          OpVT.getVectorElementType().getSizeInBits() >= 8))
15942       return DAG.getNode(ISD::TRUNCATE, dl, VT,
15943                          DAG.getNode(ISD::SETCC, dl, OpVT, Op0, Op1, CC));
15944   }
15945
15946   // We are handling one of the integer comparisons here.  Since SSE only has
15947   // GT and EQ comparisons for integer, swapping operands and multiple
15948   // operations may be required for some comparisons.
15949   unsigned Opc;
15950   bool Swap = false, Invert = false, FlipSigns = false, MinMax = false;
15951   bool Subus = false;
15952
15953   switch (SetCCOpcode) {
15954   default: llvm_unreachable("Unexpected SETCC condition");
15955   case ISD::SETNE:  Invert = true;
15956   case ISD::SETEQ:  Opc = X86ISD::PCMPEQ; break;
15957   case ISD::SETLT:  Swap = true;
15958   case ISD::SETGT:  Opc = X86ISD::PCMPGT; break;
15959   case ISD::SETGE:  Swap = true;
15960   case ISD::SETLE:  Opc = X86ISD::PCMPGT;
15961                     Invert = true; break;
15962   case ISD::SETULT: Swap = true;
15963   case ISD::SETUGT: Opc = X86ISD::PCMPGT;
15964                     FlipSigns = true; break;
15965   case ISD::SETUGE: Swap = true;
15966   case ISD::SETULE: Opc = X86ISD::PCMPGT;
15967                     FlipSigns = true; Invert = true; break;
15968   }
15969
15970   // Special case: Use min/max operations for SETULE/SETUGE
15971   MVT VET = VT.getVectorElementType();
15972   bool hasMinMax =
15973        (Subtarget->hasSSE41() && (VET >= MVT::i8 && VET <= MVT::i32))
15974     || (Subtarget->hasSSE2()  && (VET == MVT::i8));
15975
15976   if (hasMinMax) {
15977     switch (SetCCOpcode) {
15978     default: break;
15979     case ISD::SETULE: Opc = X86ISD::UMIN; MinMax = true; break;
15980     case ISD::SETUGE: Opc = X86ISD::UMAX; MinMax = true; break;
15981     }
15982
15983     if (MinMax) { Swap = false; Invert = false; FlipSigns = false; }
15984   }
15985
15986   bool hasSubus = Subtarget->hasSSE2() && (VET == MVT::i8 || VET == MVT::i16);
15987   if (!MinMax && hasSubus) {
15988     // As another special case, use PSUBUS[BW] when it's profitable. E.g. for
15989     // Op0 u<= Op1:
15990     //   t = psubus Op0, Op1
15991     //   pcmpeq t, <0..0>
15992     switch (SetCCOpcode) {
15993     default: break;
15994     case ISD::SETULT: {
15995       // If the comparison is against a constant we can turn this into a
15996       // setule.  With psubus, setule does not require a swap.  This is
15997       // beneficial because the constant in the register is no longer
15998       // destructed as the destination so it can be hoisted out of a loop.
15999       // Only do this pre-AVX since vpcmp* is no longer destructive.
16000       if (Subtarget->hasAVX())
16001         break;
16002       SDValue ULEOp1 = ChangeVSETULTtoVSETULE(dl, Op1, DAG);
16003       if (ULEOp1.getNode()) {
16004         Op1 = ULEOp1;
16005         Subus = true; Invert = false; Swap = false;
16006       }
16007       break;
16008     }
16009     // Psubus is better than flip-sign because it requires no inversion.
16010     case ISD::SETUGE: Subus = true; Invert = false; Swap = true;  break;
16011     case ISD::SETULE: Subus = true; Invert = false; Swap = false; break;
16012     }
16013
16014     if (Subus) {
16015       Opc = X86ISD::SUBUS;
16016       FlipSigns = false;
16017     }
16018   }
16019
16020   if (Swap)
16021     std::swap(Op0, Op1);
16022
16023   // Check that the operation in question is available (most are plain SSE2,
16024   // but PCMPGTQ and PCMPEQQ have different requirements).
16025   if (VT == MVT::v2i64) {
16026     if (Opc == X86ISD::PCMPGT && !Subtarget->hasSSE42()) {
16027       assert(Subtarget->hasSSE2() && "Don't know how to lower!");
16028
16029       // First cast everything to the right type.
16030       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
16031       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
16032
16033       // Since SSE has no unsigned integer comparisons, we need to flip the sign
16034       // bits of the inputs before performing those operations. The lower
16035       // compare is always unsigned.
16036       SDValue SB;
16037       if (FlipSigns) {
16038         SB = DAG.getConstant(0x80000000U, MVT::v4i32);
16039       } else {
16040         SDValue Sign = DAG.getConstant(0x80000000U, MVT::i32);
16041         SDValue Zero = DAG.getConstant(0x00000000U, MVT::i32);
16042         SB = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
16043                          Sign, Zero, Sign, Zero);
16044       }
16045       Op0 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op0, SB);
16046       Op1 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op1, SB);
16047
16048       // Emulate PCMPGTQ with (hi1 > hi2) | ((hi1 == hi2) & (lo1 > lo2))
16049       SDValue GT = DAG.getNode(X86ISD::PCMPGT, dl, MVT::v4i32, Op0, Op1);
16050       SDValue EQ = DAG.getNode(X86ISD::PCMPEQ, dl, MVT::v4i32, Op0, Op1);
16051
16052       // Create masks for only the low parts/high parts of the 64 bit integers.
16053       static const int MaskHi[] = { 1, 1, 3, 3 };
16054       static const int MaskLo[] = { 0, 0, 2, 2 };
16055       SDValue EQHi = DAG.getVectorShuffle(MVT::v4i32, dl, EQ, EQ, MaskHi);
16056       SDValue GTLo = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskLo);
16057       SDValue GTHi = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskHi);
16058
16059       SDValue Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, EQHi, GTLo);
16060       Result = DAG.getNode(ISD::OR, dl, MVT::v4i32, Result, GTHi);
16061
16062       if (Invert)
16063         Result = DAG.getNOT(dl, Result, MVT::v4i32);
16064
16065       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
16066     }
16067
16068     if (Opc == X86ISD::PCMPEQ && !Subtarget->hasSSE41()) {
16069       // If pcmpeqq is missing but pcmpeqd is available synthesize pcmpeqq with
16070       // pcmpeqd + pshufd + pand.
16071       assert(Subtarget->hasSSE2() && !FlipSigns && "Don't know how to lower!");
16072
16073       // First cast everything to the right type.
16074       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
16075       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
16076
16077       // Do the compare.
16078       SDValue Result = DAG.getNode(Opc, dl, MVT::v4i32, Op0, Op1);
16079
16080       // Make sure the lower and upper halves are both all-ones.
16081       static const int Mask[] = { 1, 0, 3, 2 };
16082       SDValue Shuf = DAG.getVectorShuffle(MVT::v4i32, dl, Result, Result, Mask);
16083       Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, Result, Shuf);
16084
16085       if (Invert)
16086         Result = DAG.getNOT(dl, Result, MVT::v4i32);
16087
16088       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
16089     }
16090   }
16091
16092   // Since SSE has no unsigned integer comparisons, we need to flip the sign
16093   // bits of the inputs before performing those operations.
16094   if (FlipSigns) {
16095     EVT EltVT = VT.getVectorElementType();
16096     SDValue SB = DAG.getConstant(APInt::getSignBit(EltVT.getSizeInBits()), VT);
16097     Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SB);
16098     Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SB);
16099   }
16100
16101   SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
16102
16103   // If the logical-not of the result is required, perform that now.
16104   if (Invert)
16105     Result = DAG.getNOT(dl, Result, VT);
16106
16107   if (MinMax)
16108     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Op0, Result);
16109
16110   if (Subus)
16111     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Result,
16112                          getZeroVector(VT, Subtarget, DAG, dl));
16113
16114   return Result;
16115 }
16116
16117 SDValue X86TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
16118
16119   MVT VT = Op.getSimpleValueType();
16120
16121   if (VT.isVector()) return LowerVSETCC(Op, Subtarget, DAG);
16122
16123   assert(((!Subtarget->hasAVX512() && VT == MVT::i8) || (VT == MVT::i1))
16124          && "SetCC type must be 8-bit or 1-bit integer");
16125   SDValue Op0 = Op.getOperand(0);
16126   SDValue Op1 = Op.getOperand(1);
16127   SDLoc dl(Op);
16128   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
16129
16130   // Optimize to BT if possible.
16131   // Lower (X & (1 << N)) == 0 to BT(X, N).
16132   // Lower ((X >>u N) & 1) != 0 to BT(X, N).
16133   // Lower ((X >>s N) & 1) != 0 to BT(X, N).
16134   if (Op0.getOpcode() == ISD::AND && Op0.hasOneUse() &&
16135       Op1.getOpcode() == ISD::Constant &&
16136       cast<ConstantSDNode>(Op1)->isNullValue() &&
16137       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
16138     SDValue NewSetCC = LowerToBT(Op0, CC, dl, DAG);
16139     if (NewSetCC.getNode()) {
16140       if (VT == MVT::i1)
16141         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewSetCC);
16142       return NewSetCC;
16143     }
16144   }
16145
16146   // Look for X == 0, X == 1, X != 0, or X != 1.  We can simplify some forms of
16147   // these.
16148   if (Op1.getOpcode() == ISD::Constant &&
16149       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1 ||
16150        cast<ConstantSDNode>(Op1)->isNullValue()) &&
16151       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
16152
16153     // If the input is a setcc, then reuse the input setcc or use a new one with
16154     // the inverted condition.
16155     if (Op0.getOpcode() == X86ISD::SETCC) {
16156       X86::CondCode CCode = (X86::CondCode)Op0.getConstantOperandVal(0);
16157       bool Invert = (CC == ISD::SETNE) ^
16158         cast<ConstantSDNode>(Op1)->isNullValue();
16159       if (!Invert)
16160         return Op0;
16161
16162       CCode = X86::GetOppositeBranchCondition(CCode);
16163       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
16164                                   DAG.getConstant(CCode, MVT::i8),
16165                                   Op0.getOperand(1));
16166       if (VT == MVT::i1)
16167         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
16168       return SetCC;
16169     }
16170   }
16171   if ((Op0.getValueType() == MVT::i1) && (Op1.getOpcode() == ISD::Constant) &&
16172       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1) &&
16173       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
16174
16175     ISD::CondCode NewCC = ISD::getSetCCInverse(CC, true);
16176     return DAG.getSetCC(dl, VT, Op0, DAG.getConstant(0, MVT::i1), NewCC);
16177   }
16178
16179   bool isFP = Op1.getSimpleValueType().isFloatingPoint();
16180   unsigned X86CC = TranslateX86CC(CC, isFP, Op0, Op1, DAG);
16181   if (X86CC == X86::COND_INVALID)
16182     return SDValue();
16183
16184   SDValue EFLAGS = EmitCmp(Op0, Op1, X86CC, dl, DAG);
16185   EFLAGS = ConvertCmpIfNecessary(EFLAGS, DAG);
16186   SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
16187                               DAG.getConstant(X86CC, MVT::i8), EFLAGS);
16188   if (VT == MVT::i1)
16189     return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
16190   return SetCC;
16191 }
16192
16193 // isX86LogicalCmp - Return true if opcode is a X86 logical comparison.
16194 static bool isX86LogicalCmp(SDValue Op) {
16195   unsigned Opc = Op.getNode()->getOpcode();
16196   if (Opc == X86ISD::CMP || Opc == X86ISD::COMI || Opc == X86ISD::UCOMI ||
16197       Opc == X86ISD::SAHF)
16198     return true;
16199   if (Op.getResNo() == 1 &&
16200       (Opc == X86ISD::ADD ||
16201        Opc == X86ISD::SUB ||
16202        Opc == X86ISD::ADC ||
16203        Opc == X86ISD::SBB ||
16204        Opc == X86ISD::SMUL ||
16205        Opc == X86ISD::UMUL ||
16206        Opc == X86ISD::INC ||
16207        Opc == X86ISD::DEC ||
16208        Opc == X86ISD::OR ||
16209        Opc == X86ISD::XOR ||
16210        Opc == X86ISD::AND))
16211     return true;
16212
16213   if (Op.getResNo() == 2 && Opc == X86ISD::UMUL)
16214     return true;
16215
16216   return false;
16217 }
16218
16219 static bool isTruncWithZeroHighBitsInput(SDValue V, SelectionDAG &DAG) {
16220   if (V.getOpcode() != ISD::TRUNCATE)
16221     return false;
16222
16223   SDValue VOp0 = V.getOperand(0);
16224   unsigned InBits = VOp0.getValueSizeInBits();
16225   unsigned Bits = V.getValueSizeInBits();
16226   return DAG.MaskedValueIsZero(VOp0, APInt::getHighBitsSet(InBits,InBits-Bits));
16227 }
16228
16229 SDValue X86TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
16230   bool addTest = true;
16231   SDValue Cond  = Op.getOperand(0);
16232   SDValue Op1 = Op.getOperand(1);
16233   SDValue Op2 = Op.getOperand(2);
16234   SDLoc DL(Op);
16235   EVT VT = Op1.getValueType();
16236   SDValue CC;
16237
16238   // Lower fp selects into a CMP/AND/ANDN/OR sequence when the necessary SSE ops
16239   // are available. Otherwise fp cmovs get lowered into a less efficient branch
16240   // sequence later on.
16241   if (Cond.getOpcode() == ISD::SETCC &&
16242       ((Subtarget->hasSSE2() && (VT == MVT::f32 || VT == MVT::f64)) ||
16243        (Subtarget->hasSSE1() && VT == MVT::f32)) &&
16244       VT == Cond.getOperand(0).getValueType() && Cond->hasOneUse()) {
16245     SDValue CondOp0 = Cond.getOperand(0), CondOp1 = Cond.getOperand(1);
16246     int SSECC = translateX86FSETCC(
16247         cast<CondCodeSDNode>(Cond.getOperand(2))->get(), CondOp0, CondOp1);
16248
16249     if (SSECC != 8) {
16250       if (Subtarget->hasAVX512()) {
16251         SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CondOp0, CondOp1,
16252                                   DAG.getConstant(SSECC, MVT::i8));
16253         return DAG.getNode(X86ISD::SELECT, DL, VT, Cmp, Op1, Op2);
16254       }
16255       SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, VT, CondOp0, CondOp1,
16256                                 DAG.getConstant(SSECC, MVT::i8));
16257       SDValue AndN = DAG.getNode(X86ISD::FANDN, DL, VT, Cmp, Op2);
16258       SDValue And = DAG.getNode(X86ISD::FAND, DL, VT, Cmp, Op1);
16259       return DAG.getNode(X86ISD::FOR, DL, VT, AndN, And);
16260     }
16261   }
16262
16263   if (Cond.getOpcode() == ISD::SETCC) {
16264     SDValue NewCond = LowerSETCC(Cond, DAG);
16265     if (NewCond.getNode())
16266       Cond = NewCond;
16267   }
16268
16269   // (select (x == 0), -1, y) -> (sign_bit (x - 1)) | y
16270   // (select (x == 0), y, -1) -> ~(sign_bit (x - 1)) | y
16271   // (select (x != 0), y, -1) -> (sign_bit (x - 1)) | y
16272   // (select (x != 0), -1, y) -> ~(sign_bit (x - 1)) | y
16273   if (Cond.getOpcode() == X86ISD::SETCC &&
16274       Cond.getOperand(1).getOpcode() == X86ISD::CMP &&
16275       isZero(Cond.getOperand(1).getOperand(1))) {
16276     SDValue Cmp = Cond.getOperand(1);
16277
16278     unsigned CondCode =cast<ConstantSDNode>(Cond.getOperand(0))->getZExtValue();
16279
16280     if ((isAllOnes(Op1) || isAllOnes(Op2)) &&
16281         (CondCode == X86::COND_E || CondCode == X86::COND_NE)) {
16282       SDValue Y = isAllOnes(Op2) ? Op1 : Op2;
16283
16284       SDValue CmpOp0 = Cmp.getOperand(0);
16285       // Apply further optimizations for special cases
16286       // (select (x != 0), -1, 0) -> neg & sbb
16287       // (select (x == 0), 0, -1) -> neg & sbb
16288       if (ConstantSDNode *YC = dyn_cast<ConstantSDNode>(Y))
16289         if (YC->isNullValue() &&
16290             (isAllOnes(Op1) == (CondCode == X86::COND_NE))) {
16291           SDVTList VTs = DAG.getVTList(CmpOp0.getValueType(), MVT::i32);
16292           SDValue Neg = DAG.getNode(X86ISD::SUB, DL, VTs,
16293                                     DAG.getConstant(0, CmpOp0.getValueType()),
16294                                     CmpOp0);
16295           SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
16296                                     DAG.getConstant(X86::COND_B, MVT::i8),
16297                                     SDValue(Neg.getNode(), 1));
16298           return Res;
16299         }
16300
16301       Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
16302                         CmpOp0, DAG.getConstant(1, CmpOp0.getValueType()));
16303       Cmp = ConvertCmpIfNecessary(Cmp, DAG);
16304
16305       SDValue Res =   // Res = 0 or -1.
16306         DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
16307                     DAG.getConstant(X86::COND_B, MVT::i8), Cmp);
16308
16309       if (isAllOnes(Op1) != (CondCode == X86::COND_E))
16310         Res = DAG.getNOT(DL, Res, Res.getValueType());
16311
16312       ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(Op2);
16313       if (!N2C || !N2C->isNullValue())
16314         Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
16315       return Res;
16316     }
16317   }
16318
16319   // Look past (and (setcc_carry (cmp ...)), 1).
16320   if (Cond.getOpcode() == ISD::AND &&
16321       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
16322     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
16323     if (C && C->getAPIntValue() == 1)
16324       Cond = Cond.getOperand(0);
16325   }
16326
16327   // If condition flag is set by a X86ISD::CMP, then use it as the condition
16328   // setting operand in place of the X86ISD::SETCC.
16329   unsigned CondOpcode = Cond.getOpcode();
16330   if (CondOpcode == X86ISD::SETCC ||
16331       CondOpcode == X86ISD::SETCC_CARRY) {
16332     CC = Cond.getOperand(0);
16333
16334     SDValue Cmp = Cond.getOperand(1);
16335     unsigned Opc = Cmp.getOpcode();
16336     MVT VT = Op.getSimpleValueType();
16337
16338     bool IllegalFPCMov = false;
16339     if (VT.isFloatingPoint() && !VT.isVector() &&
16340         !isScalarFPTypeInSSEReg(VT))  // FPStack?
16341       IllegalFPCMov = !hasFPCMov(cast<ConstantSDNode>(CC)->getSExtValue());
16342
16343     if ((isX86LogicalCmp(Cmp) && !IllegalFPCMov) ||
16344         Opc == X86ISD::BT) { // FIXME
16345       Cond = Cmp;
16346       addTest = false;
16347     }
16348   } else if (CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
16349              CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
16350              ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
16351               Cond.getOperand(0).getValueType() != MVT::i8)) {
16352     SDValue LHS = Cond.getOperand(0);
16353     SDValue RHS = Cond.getOperand(1);
16354     unsigned X86Opcode;
16355     unsigned X86Cond;
16356     SDVTList VTs;
16357     switch (CondOpcode) {
16358     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
16359     case ISD::SADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
16360     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
16361     case ISD::SSUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
16362     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
16363     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
16364     default: llvm_unreachable("unexpected overflowing operator");
16365     }
16366     if (CondOpcode == ISD::UMULO)
16367       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
16368                           MVT::i32);
16369     else
16370       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
16371
16372     SDValue X86Op = DAG.getNode(X86Opcode, DL, VTs, LHS, RHS);
16373
16374     if (CondOpcode == ISD::UMULO)
16375       Cond = X86Op.getValue(2);
16376     else
16377       Cond = X86Op.getValue(1);
16378
16379     CC = DAG.getConstant(X86Cond, MVT::i8);
16380     addTest = false;
16381   }
16382
16383   if (addTest) {
16384     // Look pass the truncate if the high bits are known zero.
16385     if (isTruncWithZeroHighBitsInput(Cond, DAG))
16386         Cond = Cond.getOperand(0);
16387
16388     // We know the result of AND is compared against zero. Try to match
16389     // it to BT.
16390     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
16391       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, DL, DAG);
16392       if (NewSetCC.getNode()) {
16393         CC = NewSetCC.getOperand(0);
16394         Cond = NewSetCC.getOperand(1);
16395         addTest = false;
16396       }
16397     }
16398   }
16399
16400   if (addTest) {
16401     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
16402     Cond = EmitTest(Cond, X86::COND_NE, DL, DAG);
16403   }
16404
16405   // a <  b ? -1 :  0 -> RES = ~setcc_carry
16406   // a <  b ?  0 : -1 -> RES = setcc_carry
16407   // a >= b ? -1 :  0 -> RES = setcc_carry
16408   // a >= b ?  0 : -1 -> RES = ~setcc_carry
16409   if (Cond.getOpcode() == X86ISD::SUB) {
16410     Cond = ConvertCmpIfNecessary(Cond, DAG);
16411     unsigned CondCode = cast<ConstantSDNode>(CC)->getZExtValue();
16412
16413     if ((CondCode == X86::COND_AE || CondCode == X86::COND_B) &&
16414         (isAllOnes(Op1) || isAllOnes(Op2)) && (isZero(Op1) || isZero(Op2))) {
16415       SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
16416                                 DAG.getConstant(X86::COND_B, MVT::i8), Cond);
16417       if (isAllOnes(Op1) != (CondCode == X86::COND_B))
16418         return DAG.getNOT(DL, Res, Res.getValueType());
16419       return Res;
16420     }
16421   }
16422
16423   // X86 doesn't have an i8 cmov. If both operands are the result of a truncate
16424   // widen the cmov and push the truncate through. This avoids introducing a new
16425   // branch during isel and doesn't add any extensions.
16426   if (Op.getValueType() == MVT::i8 &&
16427       Op1.getOpcode() == ISD::TRUNCATE && Op2.getOpcode() == ISD::TRUNCATE) {
16428     SDValue T1 = Op1.getOperand(0), T2 = Op2.getOperand(0);
16429     if (T1.getValueType() == T2.getValueType() &&
16430         // Blacklist CopyFromReg to avoid partial register stalls.
16431         T1.getOpcode() != ISD::CopyFromReg && T2.getOpcode()!=ISD::CopyFromReg){
16432       SDVTList VTs = DAG.getVTList(T1.getValueType(), MVT::Glue);
16433       SDValue Cmov = DAG.getNode(X86ISD::CMOV, DL, VTs, T2, T1, CC, Cond);
16434       return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
16435     }
16436   }
16437
16438   // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
16439   // condition is true.
16440   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
16441   SDValue Ops[] = { Op2, Op1, CC, Cond };
16442   return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops);
16443 }
16444
16445 static SDValue LowerSIGN_EXTEND_AVX512(SDValue Op, const X86Subtarget *Subtarget,
16446                                        SelectionDAG &DAG) {
16447   MVT VT = Op->getSimpleValueType(0);
16448   SDValue In = Op->getOperand(0);
16449   MVT InVT = In.getSimpleValueType();
16450   MVT VTElt = VT.getVectorElementType();
16451   MVT InVTElt = InVT.getVectorElementType();
16452   SDLoc dl(Op);
16453
16454   // SKX processor
16455   if ((InVTElt == MVT::i1) &&
16456       (((Subtarget->hasBWI() && Subtarget->hasVLX() &&
16457         VT.getSizeInBits() <= 256 && VTElt.getSizeInBits() <= 16)) ||
16458
16459        ((Subtarget->hasBWI() && VT.is512BitVector() &&
16460         VTElt.getSizeInBits() <= 16)) ||
16461
16462        ((Subtarget->hasDQI() && Subtarget->hasVLX() &&
16463         VT.getSizeInBits() <= 256 && VTElt.getSizeInBits() >= 32)) ||
16464
16465        ((Subtarget->hasDQI() && VT.is512BitVector() &&
16466         VTElt.getSizeInBits() >= 32))))
16467     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16468
16469   unsigned int NumElts = VT.getVectorNumElements();
16470
16471   if (NumElts != 8 && NumElts != 16)
16472     return SDValue();
16473
16474   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1) {
16475     if (In.getOpcode() == X86ISD::VSEXT || In.getOpcode() == X86ISD::VZEXT)
16476       return DAG.getNode(In.getOpcode(), dl, VT, In.getOperand(0));
16477     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16478   }
16479
16480   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16481   assert (InVT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
16482
16483   MVT ExtVT = (NumElts == 8) ? MVT::v8i64 : MVT::v16i32;
16484   Constant *C = ConstantInt::get(*DAG.getContext(),
16485     APInt::getAllOnesValue(ExtVT.getScalarType().getSizeInBits()));
16486
16487   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
16488   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
16489   SDValue Ld = DAG.getLoad(ExtVT.getScalarType(), dl, DAG.getEntryNode(), CP,
16490                           MachinePointerInfo::getConstantPool(),
16491                           false, false, false, Alignment);
16492   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, dl, ExtVT, In, Ld);
16493   if (VT.is512BitVector())
16494     return Brcst;
16495   return DAG.getNode(X86ISD::VTRUNC, dl, VT, Brcst);
16496 }
16497
16498 static SDValue LowerSIGN_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
16499                                 SelectionDAG &DAG) {
16500   MVT VT = Op->getSimpleValueType(0);
16501   SDValue In = Op->getOperand(0);
16502   MVT InVT = In.getSimpleValueType();
16503   SDLoc dl(Op);
16504
16505   if (VT.is512BitVector() || InVT.getVectorElementType() == MVT::i1)
16506     return LowerSIGN_EXTEND_AVX512(Op, Subtarget, DAG);
16507
16508   if ((VT != MVT::v4i64 || InVT != MVT::v4i32) &&
16509       (VT != MVT::v8i32 || InVT != MVT::v8i16) &&
16510       (VT != MVT::v16i16 || InVT != MVT::v16i8))
16511     return SDValue();
16512
16513   if (Subtarget->hasInt256())
16514     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16515
16516   // Optimize vectors in AVX mode
16517   // Sign extend  v8i16 to v8i32 and
16518   //              v4i32 to v4i64
16519   //
16520   // Divide input vector into two parts
16521   // for v4i32 the shuffle mask will be { 0, 1, -1, -1} {2, 3, -1, -1}
16522   // use vpmovsx instruction to extend v4i32 -> v2i64; v8i16 -> v4i32
16523   // concat the vectors to original VT
16524
16525   unsigned NumElems = InVT.getVectorNumElements();
16526   SDValue Undef = DAG.getUNDEF(InVT);
16527
16528   SmallVector<int,8> ShufMask1(NumElems, -1);
16529   for (unsigned i = 0; i != NumElems/2; ++i)
16530     ShufMask1[i] = i;
16531
16532   SDValue OpLo = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask1[0]);
16533
16534   SmallVector<int,8> ShufMask2(NumElems, -1);
16535   for (unsigned i = 0; i != NumElems/2; ++i)
16536     ShufMask2[i] = i + NumElems/2;
16537
16538   SDValue OpHi = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask2[0]);
16539
16540   MVT HalfVT = MVT::getVectorVT(VT.getScalarType(),
16541                                 VT.getVectorNumElements()/2);
16542
16543   OpLo = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpLo);
16544   OpHi = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpHi);
16545
16546   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
16547 }
16548
16549 // Lower vector extended loads using a shuffle. If SSSE3 is not available we
16550 // may emit an illegal shuffle but the expansion is still better than scalar
16551 // code. We generate X86ISD::VSEXT for SEXTLOADs if it's available, otherwise
16552 // we'll emit a shuffle and a arithmetic shift.
16553 // FIXME: Is the expansion actually better than scalar code? It doesn't seem so.
16554 // TODO: It is possible to support ZExt by zeroing the undef values during
16555 // the shuffle phase or after the shuffle.
16556 static SDValue LowerExtendedLoad(SDValue Op, const X86Subtarget *Subtarget,
16557                                  SelectionDAG &DAG) {
16558   MVT RegVT = Op.getSimpleValueType();
16559   assert(RegVT.isVector() && "We only custom lower vector sext loads.");
16560   assert(RegVT.isInteger() &&
16561          "We only custom lower integer vector sext loads.");
16562
16563   // Nothing useful we can do without SSE2 shuffles.
16564   assert(Subtarget->hasSSE2() && "We only custom lower sext loads with SSE2.");
16565
16566   LoadSDNode *Ld = cast<LoadSDNode>(Op.getNode());
16567   SDLoc dl(Ld);
16568   EVT MemVT = Ld->getMemoryVT();
16569   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16570   unsigned RegSz = RegVT.getSizeInBits();
16571
16572   ISD::LoadExtType Ext = Ld->getExtensionType();
16573
16574   assert((Ext == ISD::EXTLOAD || Ext == ISD::SEXTLOAD)
16575          && "Only anyext and sext are currently implemented.");
16576   assert(MemVT != RegVT && "Cannot extend to the same type");
16577   assert(MemVT.isVector() && "Must load a vector from memory");
16578
16579   unsigned NumElems = RegVT.getVectorNumElements();
16580   unsigned MemSz = MemVT.getSizeInBits();
16581   assert(RegSz > MemSz && "Register size must be greater than the mem size");
16582
16583   if (Ext == ISD::SEXTLOAD && RegSz == 256 && !Subtarget->hasInt256()) {
16584     // The only way in which we have a legal 256-bit vector result but not the
16585     // integer 256-bit operations needed to directly lower a sextload is if we
16586     // have AVX1 but not AVX2. In that case, we can always emit a sextload to
16587     // a 128-bit vector and a normal sign_extend to 256-bits that should get
16588     // correctly legalized. We do this late to allow the canonical form of
16589     // sextload to persist throughout the rest of the DAG combiner -- it wants
16590     // to fold together any extensions it can, and so will fuse a sign_extend
16591     // of an sextload into a sextload targeting a wider value.
16592     SDValue Load;
16593     if (MemSz == 128) {
16594       // Just switch this to a normal load.
16595       assert(TLI.isTypeLegal(MemVT) && "If the memory type is a 128-bit type, "
16596                                        "it must be a legal 128-bit vector "
16597                                        "type!");
16598       Load = DAG.getLoad(MemVT, dl, Ld->getChain(), Ld->getBasePtr(),
16599                   Ld->getPointerInfo(), Ld->isVolatile(), Ld->isNonTemporal(),
16600                   Ld->isInvariant(), Ld->getAlignment());
16601     } else {
16602       assert(MemSz < 128 &&
16603              "Can't extend a type wider than 128 bits to a 256 bit vector!");
16604       // Do an sext load to a 128-bit vector type. We want to use the same
16605       // number of elements, but elements half as wide. This will end up being
16606       // recursively lowered by this routine, but will succeed as we definitely
16607       // have all the necessary features if we're using AVX1.
16608       EVT HalfEltVT =
16609           EVT::getIntegerVT(*DAG.getContext(), RegVT.getScalarSizeInBits() / 2);
16610       EVT HalfVecVT = EVT::getVectorVT(*DAG.getContext(), HalfEltVT, NumElems);
16611       Load =
16612           DAG.getExtLoad(Ext, dl, HalfVecVT, Ld->getChain(), Ld->getBasePtr(),
16613                          Ld->getPointerInfo(), MemVT, Ld->isVolatile(),
16614                          Ld->isNonTemporal(), Ld->isInvariant(),
16615                          Ld->getAlignment());
16616     }
16617
16618     // Replace chain users with the new chain.
16619     assert(Load->getNumValues() == 2 && "Loads must carry a chain!");
16620     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), Load.getValue(1));
16621
16622     // Finally, do a normal sign-extend to the desired register.
16623     return DAG.getSExtOrTrunc(Load, dl, RegVT);
16624   }
16625
16626   // All sizes must be a power of two.
16627   assert(isPowerOf2_32(RegSz * MemSz * NumElems) &&
16628          "Non-power-of-two elements are not custom lowered!");
16629
16630   // Attempt to load the original value using scalar loads.
16631   // Find the largest scalar type that divides the total loaded size.
16632   MVT SclrLoadTy = MVT::i8;
16633   for (MVT Tp : MVT::integer_valuetypes()) {
16634     if (TLI.isTypeLegal(Tp) && ((MemSz % Tp.getSizeInBits()) == 0)) {
16635       SclrLoadTy = Tp;
16636     }
16637   }
16638
16639   // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
16640   if (TLI.isTypeLegal(MVT::f64) && SclrLoadTy.getSizeInBits() < 64 &&
16641       (64 <= MemSz))
16642     SclrLoadTy = MVT::f64;
16643
16644   // Calculate the number of scalar loads that we need to perform
16645   // in order to load our vector from memory.
16646   unsigned NumLoads = MemSz / SclrLoadTy.getSizeInBits();
16647
16648   assert((Ext != ISD::SEXTLOAD || NumLoads == 1) &&
16649          "Can only lower sext loads with a single scalar load!");
16650
16651   unsigned loadRegZize = RegSz;
16652   if (Ext == ISD::SEXTLOAD && RegSz == 256)
16653     loadRegZize /= 2;
16654
16655   // Represent our vector as a sequence of elements which are the
16656   // largest scalar that we can load.
16657   EVT LoadUnitVecVT = EVT::getVectorVT(
16658       *DAG.getContext(), SclrLoadTy, loadRegZize / SclrLoadTy.getSizeInBits());
16659
16660   // Represent the data using the same element type that is stored in
16661   // memory. In practice, we ''widen'' MemVT.
16662   EVT WideVecVT =
16663       EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
16664                        loadRegZize / MemVT.getScalarType().getSizeInBits());
16665
16666   assert(WideVecVT.getSizeInBits() == LoadUnitVecVT.getSizeInBits() &&
16667          "Invalid vector type");
16668
16669   // We can't shuffle using an illegal type.
16670   assert(TLI.isTypeLegal(WideVecVT) &&
16671          "We only lower types that form legal widened vector types");
16672
16673   SmallVector<SDValue, 8> Chains;
16674   SDValue Ptr = Ld->getBasePtr();
16675   SDValue Increment =
16676       DAG.getConstant(SclrLoadTy.getSizeInBits() / 8, TLI.getPointerTy());
16677   SDValue Res = DAG.getUNDEF(LoadUnitVecVT);
16678
16679   for (unsigned i = 0; i < NumLoads; ++i) {
16680     // Perform a single load.
16681     SDValue ScalarLoad =
16682         DAG.getLoad(SclrLoadTy, dl, Ld->getChain(), Ptr, Ld->getPointerInfo(),
16683                     Ld->isVolatile(), Ld->isNonTemporal(), Ld->isInvariant(),
16684                     Ld->getAlignment());
16685     Chains.push_back(ScalarLoad.getValue(1));
16686     // Create the first element type using SCALAR_TO_VECTOR in order to avoid
16687     // another round of DAGCombining.
16688     if (i == 0)
16689       Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoadUnitVecVT, ScalarLoad);
16690     else
16691       Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, LoadUnitVecVT, Res,
16692                         ScalarLoad, DAG.getIntPtrConstant(i));
16693
16694     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
16695   }
16696
16697   SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
16698
16699   // Bitcast the loaded value to a vector of the original element type, in
16700   // the size of the target vector type.
16701   SDValue SlicedVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Res);
16702   unsigned SizeRatio = RegSz / MemSz;
16703
16704   if (Ext == ISD::SEXTLOAD) {
16705     // If we have SSE4.1, we can directly emit a VSEXT node.
16706     if (Subtarget->hasSSE41()) {
16707       SDValue Sext = DAG.getNode(X86ISD::VSEXT, dl, RegVT, SlicedVec);
16708       DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16709       return Sext;
16710     }
16711
16712     // Otherwise we'll shuffle the small elements in the high bits of the
16713     // larger type and perform an arithmetic shift. If the shift is not legal
16714     // it's better to scalarize.
16715     assert(TLI.isOperationLegalOrCustom(ISD::SRA, RegVT) &&
16716            "We can't implement a sext load without an arithmetic right shift!");
16717
16718     // Redistribute the loaded elements into the different locations.
16719     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
16720     for (unsigned i = 0; i != NumElems; ++i)
16721       ShuffleVec[i * SizeRatio + SizeRatio - 1] = i;
16722
16723     SDValue Shuff = DAG.getVectorShuffle(
16724         WideVecVT, dl, SlicedVec, DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
16725
16726     Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
16727
16728     // Build the arithmetic shift.
16729     unsigned Amt = RegVT.getVectorElementType().getSizeInBits() -
16730                    MemVT.getVectorElementType().getSizeInBits();
16731     Shuff =
16732         DAG.getNode(ISD::SRA, dl, RegVT, Shuff, DAG.getConstant(Amt, RegVT));
16733
16734     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16735     return Shuff;
16736   }
16737
16738   // Redistribute the loaded elements into the different locations.
16739   SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
16740   for (unsigned i = 0; i != NumElems; ++i)
16741     ShuffleVec[i * SizeRatio] = i;
16742
16743   SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, SlicedVec,
16744                                        DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
16745
16746   // Bitcast to the requested type.
16747   Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
16748   DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16749   return Shuff;
16750 }
16751
16752 // isAndOrOfSingleUseSetCCs - Return true if node is an ISD::AND or
16753 // ISD::OR of two X86ISD::SETCC nodes each of which has no other use apart
16754 // from the AND / OR.
16755 static bool isAndOrOfSetCCs(SDValue Op, unsigned &Opc) {
16756   Opc = Op.getOpcode();
16757   if (Opc != ISD::OR && Opc != ISD::AND)
16758     return false;
16759   return (Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
16760           Op.getOperand(0).hasOneUse() &&
16761           Op.getOperand(1).getOpcode() == X86ISD::SETCC &&
16762           Op.getOperand(1).hasOneUse());
16763 }
16764
16765 // isXor1OfSetCC - Return true if node is an ISD::XOR of a X86ISD::SETCC and
16766 // 1 and that the SETCC node has a single use.
16767 static bool isXor1OfSetCC(SDValue Op) {
16768   if (Op.getOpcode() != ISD::XOR)
16769     return false;
16770   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
16771   if (N1C && N1C->getAPIntValue() == 1) {
16772     return Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
16773       Op.getOperand(0).hasOneUse();
16774   }
16775   return false;
16776 }
16777
16778 SDValue X86TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
16779   bool addTest = true;
16780   SDValue Chain = Op.getOperand(0);
16781   SDValue Cond  = Op.getOperand(1);
16782   SDValue Dest  = Op.getOperand(2);
16783   SDLoc dl(Op);
16784   SDValue CC;
16785   bool Inverted = false;
16786
16787   if (Cond.getOpcode() == ISD::SETCC) {
16788     // Check for setcc([su]{add,sub,mul}o == 0).
16789     if (cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETEQ &&
16790         isa<ConstantSDNode>(Cond.getOperand(1)) &&
16791         cast<ConstantSDNode>(Cond.getOperand(1))->isNullValue() &&
16792         Cond.getOperand(0).getResNo() == 1 &&
16793         (Cond.getOperand(0).getOpcode() == ISD::SADDO ||
16794          Cond.getOperand(0).getOpcode() == ISD::UADDO ||
16795          Cond.getOperand(0).getOpcode() == ISD::SSUBO ||
16796          Cond.getOperand(0).getOpcode() == ISD::USUBO ||
16797          Cond.getOperand(0).getOpcode() == ISD::SMULO ||
16798          Cond.getOperand(0).getOpcode() == ISD::UMULO)) {
16799       Inverted = true;
16800       Cond = Cond.getOperand(0);
16801     } else {
16802       SDValue NewCond = LowerSETCC(Cond, DAG);
16803       if (NewCond.getNode())
16804         Cond = NewCond;
16805     }
16806   }
16807 #if 0
16808   // FIXME: LowerXALUO doesn't handle these!!
16809   else if (Cond.getOpcode() == X86ISD::ADD  ||
16810            Cond.getOpcode() == X86ISD::SUB  ||
16811            Cond.getOpcode() == X86ISD::SMUL ||
16812            Cond.getOpcode() == X86ISD::UMUL)
16813     Cond = LowerXALUO(Cond, DAG);
16814 #endif
16815
16816   // Look pass (and (setcc_carry (cmp ...)), 1).
16817   if (Cond.getOpcode() == ISD::AND &&
16818       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
16819     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
16820     if (C && C->getAPIntValue() == 1)
16821       Cond = Cond.getOperand(0);
16822   }
16823
16824   // If condition flag is set by a X86ISD::CMP, then use it as the condition
16825   // setting operand in place of the X86ISD::SETCC.
16826   unsigned CondOpcode = Cond.getOpcode();
16827   if (CondOpcode == X86ISD::SETCC ||
16828       CondOpcode == X86ISD::SETCC_CARRY) {
16829     CC = Cond.getOperand(0);
16830
16831     SDValue Cmp = Cond.getOperand(1);
16832     unsigned Opc = Cmp.getOpcode();
16833     // FIXME: WHY THE SPECIAL CASING OF LogicalCmp??
16834     if (isX86LogicalCmp(Cmp) || Opc == X86ISD::BT) {
16835       Cond = Cmp;
16836       addTest = false;
16837     } else {
16838       switch (cast<ConstantSDNode>(CC)->getZExtValue()) {
16839       default: break;
16840       case X86::COND_O:
16841       case X86::COND_B:
16842         // These can only come from an arithmetic instruction with overflow,
16843         // e.g. SADDO, UADDO.
16844         Cond = Cond.getNode()->getOperand(1);
16845         addTest = false;
16846         break;
16847       }
16848     }
16849   }
16850   CondOpcode = Cond.getOpcode();
16851   if (CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
16852       CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
16853       ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
16854        Cond.getOperand(0).getValueType() != MVT::i8)) {
16855     SDValue LHS = Cond.getOperand(0);
16856     SDValue RHS = Cond.getOperand(1);
16857     unsigned X86Opcode;
16858     unsigned X86Cond;
16859     SDVTList VTs;
16860     // Keep this in sync with LowerXALUO, otherwise we might create redundant
16861     // instructions that can't be removed afterwards (i.e. X86ISD::ADD and
16862     // X86ISD::INC).
16863     switch (CondOpcode) {
16864     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
16865     case ISD::SADDO:
16866       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
16867         if (C->isOne()) {
16868           X86Opcode = X86ISD::INC; X86Cond = X86::COND_O;
16869           break;
16870         }
16871       X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
16872     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
16873     case ISD::SSUBO:
16874       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
16875         if (C->isOne()) {
16876           X86Opcode = X86ISD::DEC; X86Cond = X86::COND_O;
16877           break;
16878         }
16879       X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
16880     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
16881     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
16882     default: llvm_unreachable("unexpected overflowing operator");
16883     }
16884     if (Inverted)
16885       X86Cond = X86::GetOppositeBranchCondition((X86::CondCode)X86Cond);
16886     if (CondOpcode == ISD::UMULO)
16887       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
16888                           MVT::i32);
16889     else
16890       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
16891
16892     SDValue X86Op = DAG.getNode(X86Opcode, dl, VTs, LHS, RHS);
16893
16894     if (CondOpcode == ISD::UMULO)
16895       Cond = X86Op.getValue(2);
16896     else
16897       Cond = X86Op.getValue(1);
16898
16899     CC = DAG.getConstant(X86Cond, MVT::i8);
16900     addTest = false;
16901   } else {
16902     unsigned CondOpc;
16903     if (Cond.hasOneUse() && isAndOrOfSetCCs(Cond, CondOpc)) {
16904       SDValue Cmp = Cond.getOperand(0).getOperand(1);
16905       if (CondOpc == ISD::OR) {
16906         // Also, recognize the pattern generated by an FCMP_UNE. We can emit
16907         // two branches instead of an explicit OR instruction with a
16908         // separate test.
16909         if (Cmp == Cond.getOperand(1).getOperand(1) &&
16910             isX86LogicalCmp(Cmp)) {
16911           CC = Cond.getOperand(0).getOperand(0);
16912           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16913                               Chain, Dest, CC, Cmp);
16914           CC = Cond.getOperand(1).getOperand(0);
16915           Cond = Cmp;
16916           addTest = false;
16917         }
16918       } else { // ISD::AND
16919         // Also, recognize the pattern generated by an FCMP_OEQ. We can emit
16920         // two branches instead of an explicit AND instruction with a
16921         // separate test. However, we only do this if this block doesn't
16922         // have a fall-through edge, because this requires an explicit
16923         // jmp when the condition is false.
16924         if (Cmp == Cond.getOperand(1).getOperand(1) &&
16925             isX86LogicalCmp(Cmp) &&
16926             Op.getNode()->hasOneUse()) {
16927           X86::CondCode CCode =
16928             (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
16929           CCode = X86::GetOppositeBranchCondition(CCode);
16930           CC = DAG.getConstant(CCode, MVT::i8);
16931           SDNode *User = *Op.getNode()->use_begin();
16932           // Look for an unconditional branch following this conditional branch.
16933           // We need this because we need to reverse the successors in order
16934           // to implement FCMP_OEQ.
16935           if (User->getOpcode() == ISD::BR) {
16936             SDValue FalseBB = User->getOperand(1);
16937             SDNode *NewBR =
16938               DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
16939             assert(NewBR == User);
16940             (void)NewBR;
16941             Dest = FalseBB;
16942
16943             Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16944                                 Chain, Dest, CC, Cmp);
16945             X86::CondCode CCode =
16946               (X86::CondCode)Cond.getOperand(1).getConstantOperandVal(0);
16947             CCode = X86::GetOppositeBranchCondition(CCode);
16948             CC = DAG.getConstant(CCode, MVT::i8);
16949             Cond = Cmp;
16950             addTest = false;
16951           }
16952         }
16953       }
16954     } else if (Cond.hasOneUse() && isXor1OfSetCC(Cond)) {
16955       // Recognize for xorb (setcc), 1 patterns. The xor inverts the condition.
16956       // It should be transformed during dag combiner except when the condition
16957       // is set by a arithmetics with overflow node.
16958       X86::CondCode CCode =
16959         (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
16960       CCode = X86::GetOppositeBranchCondition(CCode);
16961       CC = DAG.getConstant(CCode, MVT::i8);
16962       Cond = Cond.getOperand(0).getOperand(1);
16963       addTest = false;
16964     } else if (Cond.getOpcode() == ISD::SETCC &&
16965                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETOEQ) {
16966       // For FCMP_OEQ, we can emit
16967       // two branches instead of an explicit AND instruction with a
16968       // separate test. However, we only do this if this block doesn't
16969       // have a fall-through edge, because this requires an explicit
16970       // jmp when the condition is false.
16971       if (Op.getNode()->hasOneUse()) {
16972         SDNode *User = *Op.getNode()->use_begin();
16973         // Look for an unconditional branch following this conditional branch.
16974         // We need this because we need to reverse the successors in order
16975         // to implement FCMP_OEQ.
16976         if (User->getOpcode() == ISD::BR) {
16977           SDValue FalseBB = User->getOperand(1);
16978           SDNode *NewBR =
16979             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
16980           assert(NewBR == User);
16981           (void)NewBR;
16982           Dest = FalseBB;
16983
16984           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
16985                                     Cond.getOperand(0), Cond.getOperand(1));
16986           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
16987           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
16988           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16989                               Chain, Dest, CC, Cmp);
16990           CC = DAG.getConstant(X86::COND_P, MVT::i8);
16991           Cond = Cmp;
16992           addTest = false;
16993         }
16994       }
16995     } else if (Cond.getOpcode() == ISD::SETCC &&
16996                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETUNE) {
16997       // For FCMP_UNE, we can emit
16998       // two branches instead of an explicit AND instruction with a
16999       // separate test. However, we only do this if this block doesn't
17000       // have a fall-through edge, because this requires an explicit
17001       // jmp when the condition is false.
17002       if (Op.getNode()->hasOneUse()) {
17003         SDNode *User = *Op.getNode()->use_begin();
17004         // Look for an unconditional branch following this conditional branch.
17005         // We need this because we need to reverse the successors in order
17006         // to implement FCMP_UNE.
17007         if (User->getOpcode() == ISD::BR) {
17008           SDValue FalseBB = User->getOperand(1);
17009           SDNode *NewBR =
17010             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
17011           assert(NewBR == User);
17012           (void)NewBR;
17013
17014           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
17015                                     Cond.getOperand(0), Cond.getOperand(1));
17016           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
17017           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
17018           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
17019                               Chain, Dest, CC, Cmp);
17020           CC = DAG.getConstant(X86::COND_NP, MVT::i8);
17021           Cond = Cmp;
17022           addTest = false;
17023           Dest = FalseBB;
17024         }
17025       }
17026     }
17027   }
17028
17029   if (addTest) {
17030     // Look pass the truncate if the high bits are known zero.
17031     if (isTruncWithZeroHighBitsInput(Cond, DAG))
17032         Cond = Cond.getOperand(0);
17033
17034     // We know the result of AND is compared against zero. Try to match
17035     // it to BT.
17036     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
17037       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, dl, DAG);
17038       if (NewSetCC.getNode()) {
17039         CC = NewSetCC.getOperand(0);
17040         Cond = NewSetCC.getOperand(1);
17041         addTest = false;
17042       }
17043     }
17044   }
17045
17046   if (addTest) {
17047     X86::CondCode X86Cond = Inverted ? X86::COND_E : X86::COND_NE;
17048     CC = DAG.getConstant(X86Cond, MVT::i8);
17049     Cond = EmitTest(Cond, X86Cond, dl, DAG);
17050   }
17051   Cond = ConvertCmpIfNecessary(Cond, DAG);
17052   return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
17053                      Chain, Dest, CC, Cond);
17054 }
17055
17056 // Lower dynamic stack allocation to _alloca call for Cygwin/Mingw targets.
17057 // Calls to _alloca are needed to probe the stack when allocating more than 4k
17058 // bytes in one go. Touching the stack at 4K increments is necessary to ensure
17059 // that the guard pages used by the OS virtual memory manager are allocated in
17060 // correct sequence.
17061 SDValue
17062 X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
17063                                            SelectionDAG &DAG) const {
17064   MachineFunction &MF = DAG.getMachineFunction();
17065   bool SplitStack = MF.shouldSplitStack();
17066   bool Lower = (Subtarget->isOSWindows() && !Subtarget->isTargetMachO()) ||
17067                SplitStack;
17068   SDLoc dl(Op);
17069
17070   if (!Lower) {
17071     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
17072     SDNode* Node = Op.getNode();
17073
17074     unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore();
17075     assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and"
17076         " not tell us which reg is the stack pointer!");
17077     EVT VT = Node->getValueType(0);
17078     SDValue Tmp1 = SDValue(Node, 0);
17079     SDValue Tmp2 = SDValue(Node, 1);
17080     SDValue Tmp3 = Node->getOperand(2);
17081     SDValue Chain = Tmp1.getOperand(0);
17082
17083     // Chain the dynamic stack allocation so that it doesn't modify the stack
17084     // pointer when other instructions are using the stack.
17085     Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true),
17086         SDLoc(Node));
17087
17088     SDValue Size = Tmp2.getOperand(1);
17089     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
17090     Chain = SP.getValue(1);
17091     unsigned Align = cast<ConstantSDNode>(Tmp3)->getZExtValue();
17092     const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
17093     unsigned StackAlign = TFI.getStackAlignment();
17094     Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
17095     if (Align > StackAlign)
17096       Tmp1 = DAG.getNode(ISD::AND, dl, VT, Tmp1,
17097           DAG.getConstant(-(uint64_t)Align, VT));
17098     Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain
17099
17100     Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true),
17101         DAG.getIntPtrConstant(0, true), SDValue(),
17102         SDLoc(Node));
17103
17104     SDValue Ops[2] = { Tmp1, Tmp2 };
17105     return DAG.getMergeValues(Ops, dl);
17106   }
17107
17108   // Get the inputs.
17109   SDValue Chain = Op.getOperand(0);
17110   SDValue Size  = Op.getOperand(1);
17111   unsigned Align = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue();
17112   EVT VT = Op.getNode()->getValueType(0);
17113
17114   bool Is64Bit = Subtarget->is64Bit();
17115   EVT SPTy = getPointerTy();
17116
17117   if (SplitStack) {
17118     MachineRegisterInfo &MRI = MF.getRegInfo();
17119
17120     if (Is64Bit) {
17121       // The 64 bit implementation of segmented stacks needs to clobber both r10
17122       // r11. This makes it impossible to use it along with nested parameters.
17123       const Function *F = MF.getFunction();
17124
17125       for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
17126            I != E; ++I)
17127         if (I->hasNestAttr())
17128           report_fatal_error("Cannot use segmented stacks with functions that "
17129                              "have nested arguments.");
17130     }
17131
17132     const TargetRegisterClass *AddrRegClass =
17133       getRegClassFor(getPointerTy());
17134     unsigned Vreg = MRI.createVirtualRegister(AddrRegClass);
17135     Chain = DAG.getCopyToReg(Chain, dl, Vreg, Size);
17136     SDValue Value = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
17137                                 DAG.getRegister(Vreg, SPTy));
17138     SDValue Ops1[2] = { Value, Chain };
17139     return DAG.getMergeValues(Ops1, dl);
17140   } else {
17141     SDValue Flag;
17142     const unsigned Reg = (Subtarget->isTarget64BitLP64() ? X86::RAX : X86::EAX);
17143
17144     Chain = DAG.getCopyToReg(Chain, dl, Reg, Size, Flag);
17145     Flag = Chain.getValue(1);
17146     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
17147
17148     Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
17149
17150     const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
17151     unsigned SPReg = RegInfo->getStackRegister();
17152     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, SPTy);
17153     Chain = SP.getValue(1);
17154
17155     if (Align) {
17156       SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
17157                        DAG.getConstant(-(uint64_t)Align, VT));
17158       Chain = DAG.getCopyToReg(Chain, dl, SPReg, SP);
17159     }
17160
17161     SDValue Ops1[2] = { SP, Chain };
17162     return DAG.getMergeValues(Ops1, dl);
17163   }
17164 }
17165
17166 SDValue X86TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
17167   MachineFunction &MF = DAG.getMachineFunction();
17168   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
17169
17170   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
17171   SDLoc DL(Op);
17172
17173   if (!Subtarget->is64Bit() || Subtarget->isTargetWin64()) {
17174     // vastart just stores the address of the VarArgsFrameIndex slot into the
17175     // memory location argument.
17176     SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
17177                                    getPointerTy());
17178     return DAG.getStore(Op.getOperand(0), DL, FR, Op.getOperand(1),
17179                         MachinePointerInfo(SV), false, false, 0);
17180   }
17181
17182   // __va_list_tag:
17183   //   gp_offset         (0 - 6 * 8)
17184   //   fp_offset         (48 - 48 + 8 * 16)
17185   //   overflow_arg_area (point to parameters coming in memory).
17186   //   reg_save_area
17187   SmallVector<SDValue, 8> MemOps;
17188   SDValue FIN = Op.getOperand(1);
17189   // Store gp_offset
17190   SDValue Store = DAG.getStore(Op.getOperand(0), DL,
17191                                DAG.getConstant(FuncInfo->getVarArgsGPOffset(),
17192                                                MVT::i32),
17193                                FIN, MachinePointerInfo(SV), false, false, 0);
17194   MemOps.push_back(Store);
17195
17196   // Store fp_offset
17197   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
17198                     FIN, DAG.getIntPtrConstant(4));
17199   Store = DAG.getStore(Op.getOperand(0), DL,
17200                        DAG.getConstant(FuncInfo->getVarArgsFPOffset(),
17201                                        MVT::i32),
17202                        FIN, MachinePointerInfo(SV, 4), false, false, 0);
17203   MemOps.push_back(Store);
17204
17205   // Store ptr to overflow_arg_area
17206   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
17207                     FIN, DAG.getIntPtrConstant(4));
17208   SDValue OVFIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
17209                                     getPointerTy());
17210   Store = DAG.getStore(Op.getOperand(0), DL, OVFIN, FIN,
17211                        MachinePointerInfo(SV, 8),
17212                        false, false, 0);
17213   MemOps.push_back(Store);
17214
17215   // Store ptr to reg_save_area.
17216   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
17217                     FIN, DAG.getIntPtrConstant(8));
17218   SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
17219                                     getPointerTy());
17220   Store = DAG.getStore(Op.getOperand(0), DL, RSFIN, FIN,
17221                        MachinePointerInfo(SV, 16), false, false, 0);
17222   MemOps.push_back(Store);
17223   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
17224 }
17225
17226 SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
17227   assert(Subtarget->is64Bit() &&
17228          "LowerVAARG only handles 64-bit va_arg!");
17229   assert((Subtarget->isTargetLinux() ||
17230           Subtarget->isTargetDarwin()) &&
17231           "Unhandled target in LowerVAARG");
17232   assert(Op.getNode()->getNumOperands() == 4);
17233   SDValue Chain = Op.getOperand(0);
17234   SDValue SrcPtr = Op.getOperand(1);
17235   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
17236   unsigned Align = Op.getConstantOperandVal(3);
17237   SDLoc dl(Op);
17238
17239   EVT ArgVT = Op.getNode()->getValueType(0);
17240   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
17241   uint32_t ArgSize = getDataLayout()->getTypeAllocSize(ArgTy);
17242   uint8_t ArgMode;
17243
17244   // Decide which area this value should be read from.
17245   // TODO: Implement the AMD64 ABI in its entirety. This simple
17246   // selection mechanism works only for the basic types.
17247   if (ArgVT == MVT::f80) {
17248     llvm_unreachable("va_arg for f80 not yet implemented");
17249   } else if (ArgVT.isFloatingPoint() && ArgSize <= 16 /*bytes*/) {
17250     ArgMode = 2;  // Argument passed in XMM register. Use fp_offset.
17251   } else if (ArgVT.isInteger() && ArgSize <= 32 /*bytes*/) {
17252     ArgMode = 1;  // Argument passed in GPR64 register(s). Use gp_offset.
17253   } else {
17254     llvm_unreachable("Unhandled argument type in LowerVAARG");
17255   }
17256
17257   if (ArgMode == 2) {
17258     // Sanity Check: Make sure using fp_offset makes sense.
17259     assert(!DAG.getTarget().Options.UseSoftFloat &&
17260            !(DAG.getMachineFunction().getFunction()->hasFnAttribute(
17261                Attribute::NoImplicitFloat)) &&
17262            Subtarget->hasSSE1());
17263   }
17264
17265   // Insert VAARG_64 node into the DAG
17266   // VAARG_64 returns two values: Variable Argument Address, Chain
17267   SmallVector<SDValue, 11> InstOps;
17268   InstOps.push_back(Chain);
17269   InstOps.push_back(SrcPtr);
17270   InstOps.push_back(DAG.getConstant(ArgSize, MVT::i32));
17271   InstOps.push_back(DAG.getConstant(ArgMode, MVT::i8));
17272   InstOps.push_back(DAG.getConstant(Align, MVT::i32));
17273   SDVTList VTs = DAG.getVTList(getPointerTy(), MVT::Other);
17274   SDValue VAARG = DAG.getMemIntrinsicNode(X86ISD::VAARG_64, dl,
17275                                           VTs, InstOps, MVT::i64,
17276                                           MachinePointerInfo(SV),
17277                                           /*Align=*/0,
17278                                           /*Volatile=*/false,
17279                                           /*ReadMem=*/true,
17280                                           /*WriteMem=*/true);
17281   Chain = VAARG.getValue(1);
17282
17283   // Load the next argument and return it
17284   return DAG.getLoad(ArgVT, dl,
17285                      Chain,
17286                      VAARG,
17287                      MachinePointerInfo(),
17288                      false, false, false, 0);
17289 }
17290
17291 static SDValue LowerVACOPY(SDValue Op, const X86Subtarget *Subtarget,
17292                            SelectionDAG &DAG) {
17293   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
17294   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_copy!");
17295   SDValue Chain = Op.getOperand(0);
17296   SDValue DstPtr = Op.getOperand(1);
17297   SDValue SrcPtr = Op.getOperand(2);
17298   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
17299   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
17300   SDLoc DL(Op);
17301
17302   return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr,
17303                        DAG.getIntPtrConstant(24), 8, /*isVolatile*/false,
17304                        false,
17305                        MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV));
17306 }
17307
17308 // getTargetVShiftByConstNode - Handle vector element shifts where the shift
17309 // amount is a constant. Takes immediate version of shift as input.
17310 static SDValue getTargetVShiftByConstNode(unsigned Opc, SDLoc dl, MVT VT,
17311                                           SDValue SrcOp, uint64_t ShiftAmt,
17312                                           SelectionDAG &DAG) {
17313   MVT ElementType = VT.getVectorElementType();
17314
17315   // Fold this packed shift into its first operand if ShiftAmt is 0.
17316   if (ShiftAmt == 0)
17317     return SrcOp;
17318
17319   // Check for ShiftAmt >= element width
17320   if (ShiftAmt >= ElementType.getSizeInBits()) {
17321     if (Opc == X86ISD::VSRAI)
17322       ShiftAmt = ElementType.getSizeInBits() - 1;
17323     else
17324       return DAG.getConstant(0, VT);
17325   }
17326
17327   assert((Opc == X86ISD::VSHLI || Opc == X86ISD::VSRLI || Opc == X86ISD::VSRAI)
17328          && "Unknown target vector shift-by-constant node");
17329
17330   // Fold this packed vector shift into a build vector if SrcOp is a
17331   // vector of Constants or UNDEFs, and SrcOp valuetype is the same as VT.
17332   if (VT == SrcOp.getSimpleValueType() &&
17333       ISD::isBuildVectorOfConstantSDNodes(SrcOp.getNode())) {
17334     SmallVector<SDValue, 8> Elts;
17335     unsigned NumElts = SrcOp->getNumOperands();
17336     ConstantSDNode *ND;
17337
17338     switch(Opc) {
17339     default: llvm_unreachable(nullptr);
17340     case X86ISD::VSHLI:
17341       for (unsigned i=0; i!=NumElts; ++i) {
17342         SDValue CurrentOp = SrcOp->getOperand(i);
17343         if (CurrentOp->getOpcode() == ISD::UNDEF) {
17344           Elts.push_back(CurrentOp);
17345           continue;
17346         }
17347         ND = cast<ConstantSDNode>(CurrentOp);
17348         const APInt &C = ND->getAPIntValue();
17349         Elts.push_back(DAG.getConstant(C.shl(ShiftAmt), ElementType));
17350       }
17351       break;
17352     case X86ISD::VSRLI:
17353       for (unsigned i=0; i!=NumElts; ++i) {
17354         SDValue CurrentOp = SrcOp->getOperand(i);
17355         if (CurrentOp->getOpcode() == ISD::UNDEF) {
17356           Elts.push_back(CurrentOp);
17357           continue;
17358         }
17359         ND = cast<ConstantSDNode>(CurrentOp);
17360         const APInt &C = ND->getAPIntValue();
17361         Elts.push_back(DAG.getConstant(C.lshr(ShiftAmt), ElementType));
17362       }
17363       break;
17364     case X86ISD::VSRAI:
17365       for (unsigned i=0; i!=NumElts; ++i) {
17366         SDValue CurrentOp = SrcOp->getOperand(i);
17367         if (CurrentOp->getOpcode() == ISD::UNDEF) {
17368           Elts.push_back(CurrentOp);
17369           continue;
17370         }
17371         ND = cast<ConstantSDNode>(CurrentOp);
17372         const APInt &C = ND->getAPIntValue();
17373         Elts.push_back(DAG.getConstant(C.ashr(ShiftAmt), ElementType));
17374       }
17375       break;
17376     }
17377
17378     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
17379   }
17380
17381   return DAG.getNode(Opc, dl, VT, SrcOp, DAG.getConstant(ShiftAmt, MVT::i8));
17382 }
17383
17384 // getTargetVShiftNode - Handle vector element shifts where the shift amount
17385 // may or may not be a constant. Takes immediate version of shift as input.
17386 static SDValue getTargetVShiftNode(unsigned Opc, SDLoc dl, MVT VT,
17387                                    SDValue SrcOp, SDValue ShAmt,
17388                                    SelectionDAG &DAG) {
17389   MVT SVT = ShAmt.getSimpleValueType();
17390   assert((SVT == MVT::i32 || SVT == MVT::i64) && "Unexpected value type!");
17391
17392   // Catch shift-by-constant.
17393   if (ConstantSDNode *CShAmt = dyn_cast<ConstantSDNode>(ShAmt))
17394     return getTargetVShiftByConstNode(Opc, dl, VT, SrcOp,
17395                                       CShAmt->getZExtValue(), DAG);
17396
17397   // Change opcode to non-immediate version
17398   switch (Opc) {
17399     default: llvm_unreachable("Unknown target vector shift node");
17400     case X86ISD::VSHLI: Opc = X86ISD::VSHL; break;
17401     case X86ISD::VSRLI: Opc = X86ISD::VSRL; break;
17402     case X86ISD::VSRAI: Opc = X86ISD::VSRA; break;
17403   }
17404
17405   const X86Subtarget &Subtarget =
17406       static_cast<const X86Subtarget &>(DAG.getSubtarget());
17407   if (Subtarget.hasSSE41() && ShAmt.getOpcode() == ISD::ZERO_EXTEND &&
17408       ShAmt.getOperand(0).getSimpleValueType() == MVT::i16) {
17409     // Let the shuffle legalizer expand this shift amount node.
17410     SDValue Op0 = ShAmt.getOperand(0);
17411     Op0 = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(Op0), MVT::v8i16, Op0);
17412     ShAmt = getShuffleVectorZeroOrUndef(Op0, 0, true, &Subtarget, DAG);
17413   } else {
17414     // Need to build a vector containing shift amount.
17415     // SSE/AVX packed shifts only use the lower 64-bit of the shift count.
17416     SmallVector<SDValue, 4> ShOps;
17417     ShOps.push_back(ShAmt);
17418     if (SVT == MVT::i32) {
17419       ShOps.push_back(DAG.getConstant(0, SVT));
17420       ShOps.push_back(DAG.getUNDEF(SVT));
17421     }
17422     ShOps.push_back(DAG.getUNDEF(SVT));
17423
17424     MVT BVT = SVT == MVT::i32 ? MVT::v4i32 : MVT::v2i64;
17425     ShAmt = DAG.getNode(ISD::BUILD_VECTOR, dl, BVT, ShOps);
17426   }
17427
17428   // The return type has to be a 128-bit type with the same element
17429   // type as the input type.
17430   MVT EltVT = VT.getVectorElementType();
17431   EVT ShVT = MVT::getVectorVT(EltVT, 128/EltVT.getSizeInBits());
17432
17433   ShAmt = DAG.getNode(ISD::BITCAST, dl, ShVT, ShAmt);
17434   return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
17435 }
17436
17437 /// \brief Return (and \p Op, \p Mask) for compare instructions or
17438 /// (vselect \p Mask, \p Op, \p PreservedSrc) for others along with the
17439 /// necessary casting for \p Mask when lowering masking intrinsics.
17440 static SDValue getVectorMaskingNode(SDValue Op, SDValue Mask,
17441                                     SDValue PreservedSrc,
17442                                     const X86Subtarget *Subtarget,
17443                                     SelectionDAG &DAG) {
17444     EVT VT = Op.getValueType();
17445     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(),
17446                                   MVT::i1, VT.getVectorNumElements());
17447     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17448                                      Mask.getValueType().getSizeInBits());
17449     SDLoc dl(Op);
17450
17451     assert(MaskVT.isSimple() && "invalid mask type");
17452
17453     if (isAllOnes(Mask))
17454       return Op;
17455
17456     // In case when MaskVT equals v2i1 or v4i1, low 2 or 4 elements
17457     // are extracted by EXTRACT_SUBVECTOR.
17458     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17459                               DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17460                               DAG.getIntPtrConstant(0));
17461
17462     switch (Op.getOpcode()) {
17463       default: break;
17464       case X86ISD::PCMPEQM:
17465       case X86ISD::PCMPGTM:
17466       case X86ISD::CMPM:
17467       case X86ISD::CMPMU:
17468         return DAG.getNode(ISD::AND, dl, VT, Op, VMask);
17469     }
17470     if (PreservedSrc.getOpcode() == ISD::UNDEF)
17471       PreservedSrc = getZeroVector(VT, Subtarget, DAG, dl);
17472     return DAG.getNode(ISD::VSELECT, dl, VT, VMask, Op, PreservedSrc);
17473 }
17474
17475 /// \brief Creates an SDNode for a predicated scalar operation.
17476 /// \returns (X86vselect \p Mask, \p Op, \p PreservedSrc).
17477 /// The mask is comming as MVT::i8 and it should be truncated
17478 /// to MVT::i1 while lowering masking intrinsics.
17479 /// The main difference between ScalarMaskingNode and VectorMaskingNode is using
17480 /// "X86select" instead of "vselect". We just can't create the "vselect" node for
17481 /// a scalar instruction.
17482 static SDValue getScalarMaskingNode(SDValue Op, SDValue Mask,
17483                                     SDValue PreservedSrc,
17484                                     const X86Subtarget *Subtarget,
17485                                     SelectionDAG &DAG) {
17486     if (isAllOnes(Mask))
17487       return Op;
17488
17489     EVT VT = Op.getValueType();
17490     SDLoc dl(Op);
17491     // The mask should be of type MVT::i1
17492     SDValue IMask = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, Mask);
17493
17494     if (PreservedSrc.getOpcode() == ISD::UNDEF)
17495       PreservedSrc = getZeroVector(VT, Subtarget, DAG, dl);
17496     return DAG.getNode(X86ISD::SELECT, dl, VT, IMask, Op, PreservedSrc);
17497 }
17498
17499 static SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
17500                                        SelectionDAG &DAG) {
17501   SDLoc dl(Op);
17502   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
17503   EVT VT = Op.getValueType();
17504   const IntrinsicData* IntrData = getIntrinsicWithoutChain(IntNo);
17505   if (IntrData) {
17506     switch(IntrData->Type) {
17507     case INTR_TYPE_1OP:
17508       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1));
17509     case INTR_TYPE_2OP:
17510       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1),
17511         Op.getOperand(2));
17512     case INTR_TYPE_3OP:
17513       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1),
17514         Op.getOperand(2), Op.getOperand(3));
17515     case INTR_TYPE_1OP_MASK_RM: {
17516       SDValue Src = Op.getOperand(1);
17517       SDValue Src0 = Op.getOperand(2);
17518       SDValue Mask = Op.getOperand(3);
17519       SDValue RoundingMode = Op.getOperand(4);
17520       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src,
17521                                               RoundingMode),
17522                                   Mask, Src0, Subtarget, DAG);
17523     }
17524     case INTR_TYPE_SCALAR_MASK_RM: {
17525       SDValue Src1 = Op.getOperand(1);
17526       SDValue Src2 = Op.getOperand(2);
17527       SDValue Src0 = Op.getOperand(3);
17528       SDValue Mask = Op.getOperand(4);
17529       // There are 2 kinds of intrinsics in this group:
17530       // (1) With supress-all-exceptions (sae) - 6 operands
17531       // (2) With rounding mode and sae - 7 operands.
17532       if (Op.getNumOperands() == 6) {
17533         SDValue Sae  = Op.getOperand(5);
17534         return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2,
17535                                                 Sae),
17536                                     Mask, Src0, Subtarget, DAG);
17537       }
17538       assert(Op.getNumOperands() == 7 && "Unexpected intrinsic form");
17539       SDValue RoundingMode  = Op.getOperand(5);
17540       SDValue Sae  = Op.getOperand(6);
17541       return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2,
17542                                               RoundingMode, Sae),
17543                                   Mask, Src0, Subtarget, DAG);
17544     }
17545     case INTR_TYPE_2OP_MASK: {
17546       SDValue Src1 = Op.getOperand(1);
17547       SDValue Src2 = Op.getOperand(2);
17548       SDValue PassThru = Op.getOperand(3);
17549       SDValue Mask = Op.getOperand(4);
17550       // We specify 2 possible opcodes for intrinsics with rounding modes.
17551       // First, we check if the intrinsic may have non-default rounding mode,
17552       // (IntrData->Opc1 != 0), then we check the rounding mode operand.
17553       unsigned IntrWithRoundingModeOpcode = IntrData->Opc1;
17554       if (IntrWithRoundingModeOpcode != 0) {
17555         SDValue Rnd = Op.getOperand(5);
17556         unsigned Round = cast<ConstantSDNode>(Rnd)->getZExtValue();
17557         if (Round != X86::STATIC_ROUNDING::CUR_DIRECTION) {
17558           return getVectorMaskingNode(DAG.getNode(IntrWithRoundingModeOpcode,
17559                                       dl, Op.getValueType(),
17560                                       Src1, Src2, Rnd),
17561                                       Mask, PassThru, Subtarget, DAG);
17562         }
17563       }
17564       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT,
17565                                               Src1,Src2),
17566                                   Mask, PassThru, Subtarget, DAG);
17567     }
17568     case FMA_OP_MASK: {
17569       SDValue Src1 = Op.getOperand(1);
17570       SDValue Src2 = Op.getOperand(2);
17571       SDValue Src3 = Op.getOperand(3);
17572       SDValue Mask = Op.getOperand(4);
17573       // We specify 2 possible opcodes for intrinsics with rounding modes.
17574       // First, we check if the intrinsic may have non-default rounding mode,
17575       // (IntrData->Opc1 != 0), then we check the rounding mode operand.
17576       unsigned IntrWithRoundingModeOpcode = IntrData->Opc1;
17577       if (IntrWithRoundingModeOpcode != 0) {
17578         SDValue Rnd = Op.getOperand(5);
17579         if (cast<ConstantSDNode>(Rnd)->getZExtValue() !=
17580             X86::STATIC_ROUNDING::CUR_DIRECTION)
17581           return getVectorMaskingNode(DAG.getNode(IntrWithRoundingModeOpcode,
17582                                                   dl, Op.getValueType(),
17583                                                   Src1, Src2, Src3, Rnd),
17584                                       Mask, Src1, Subtarget, DAG);
17585       }
17586       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0,
17587                                               dl, Op.getValueType(),
17588                                               Src1, Src2, Src3),
17589                                   Mask, Src1, Subtarget, DAG);
17590     }
17591     case CMP_MASK:
17592     case CMP_MASK_CC: {
17593       // Comparison intrinsics with masks.
17594       // Example of transformation:
17595       // (i8 (int_x86_avx512_mask_pcmpeq_q_128
17596       //             (v2i64 %a), (v2i64 %b), (i8 %mask))) ->
17597       // (i8 (bitcast
17598       //   (v8i1 (insert_subvector undef,
17599       //           (v2i1 (and (PCMPEQM %a, %b),
17600       //                      (extract_subvector
17601       //                         (v8i1 (bitcast %mask)), 0))), 0))))
17602       EVT VT = Op.getOperand(1).getValueType();
17603       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17604                                     VT.getVectorNumElements());
17605       SDValue Mask = Op.getOperand((IntrData->Type == CMP_MASK_CC) ? 4 : 3);
17606       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17607                                        Mask.getValueType().getSizeInBits());
17608       SDValue Cmp;
17609       if (IntrData->Type == CMP_MASK_CC) {
17610         Cmp = DAG.getNode(IntrData->Opc0, dl, MaskVT, Op.getOperand(1),
17611                     Op.getOperand(2), Op.getOperand(3));
17612       } else {
17613         assert(IntrData->Type == CMP_MASK && "Unexpected intrinsic type!");
17614         Cmp = DAG.getNode(IntrData->Opc0, dl, MaskVT, Op.getOperand(1),
17615                     Op.getOperand(2));
17616       }
17617       SDValue CmpMask = getVectorMaskingNode(Cmp, Mask,
17618                                              DAG.getTargetConstant(0, MaskVT),
17619                                              Subtarget, DAG);
17620       SDValue Res = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, BitcastVT,
17621                                 DAG.getUNDEF(BitcastVT), CmpMask,
17622                                 DAG.getIntPtrConstant(0));
17623       return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
17624     }
17625     case COMI: { // Comparison intrinsics
17626       ISD::CondCode CC = (ISD::CondCode)IntrData->Opc1;
17627       SDValue LHS = Op.getOperand(1);
17628       SDValue RHS = Op.getOperand(2);
17629       unsigned X86CC = TranslateX86CC(CC, true, LHS, RHS, DAG);
17630       assert(X86CC != X86::COND_INVALID && "Unexpected illegal condition!");
17631       SDValue Cond = DAG.getNode(IntrData->Opc0, dl, MVT::i32, LHS, RHS);
17632       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17633                                   DAG.getConstant(X86CC, MVT::i8), Cond);
17634       return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17635     }
17636     case VSHIFT:
17637       return getTargetVShiftNode(IntrData->Opc0, dl, Op.getSimpleValueType(),
17638                                  Op.getOperand(1), Op.getOperand(2), DAG);
17639     case VSHIFT_MASK:
17640       return getVectorMaskingNode(getTargetVShiftNode(IntrData->Opc0, dl,
17641                                                       Op.getSimpleValueType(),
17642                                                       Op.getOperand(1),
17643                                                       Op.getOperand(2), DAG),
17644                                   Op.getOperand(4), Op.getOperand(3), Subtarget,
17645                                   DAG);
17646     case COMPRESS_EXPAND_IN_REG: {
17647       SDValue Mask = Op.getOperand(3);
17648       SDValue DataToCompress = Op.getOperand(1);
17649       SDValue PassThru = Op.getOperand(2);
17650       if (isAllOnes(Mask)) // return data as is
17651         return Op.getOperand(1);
17652       EVT VT = Op.getValueType();
17653       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17654                                     VT.getVectorNumElements());
17655       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17656                                        Mask.getValueType().getSizeInBits());
17657       SDLoc dl(Op);
17658       SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17659                                   DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17660                                   DAG.getIntPtrConstant(0));
17661
17662       return DAG.getNode(IntrData->Opc0, dl, VT, VMask, DataToCompress,
17663                          PassThru);
17664     }
17665     case BLEND: {
17666       SDValue Mask = Op.getOperand(3);
17667       EVT VT = Op.getValueType();
17668       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17669                                     VT.getVectorNumElements());
17670       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17671                                        Mask.getValueType().getSizeInBits());
17672       SDLoc dl(Op);
17673       SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17674                                   DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17675                                   DAG.getIntPtrConstant(0));
17676       return DAG.getNode(IntrData->Opc0, dl, VT, VMask, Op.getOperand(1),
17677                          Op.getOperand(2));
17678     }
17679     default:
17680       break;
17681     }
17682   }
17683
17684   switch (IntNo) {
17685   default: return SDValue();    // Don't custom lower most intrinsics.
17686
17687   case Intrinsic::x86_avx512_mask_valign_q_512:
17688   case Intrinsic::x86_avx512_mask_valign_d_512:
17689     // Vector source operands are swapped.
17690     return getVectorMaskingNode(DAG.getNode(X86ISD::VALIGN, dl,
17691                                             Op.getValueType(), Op.getOperand(2),
17692                                             Op.getOperand(1),
17693                                             Op.getOperand(3)),
17694                                 Op.getOperand(5), Op.getOperand(4),
17695                                 Subtarget, DAG);
17696
17697   // ptest and testp intrinsics. The intrinsic these come from are designed to
17698   // return an integer value, not just an instruction so lower it to the ptest
17699   // or testp pattern and a setcc for the result.
17700   case Intrinsic::x86_sse41_ptestz:
17701   case Intrinsic::x86_sse41_ptestc:
17702   case Intrinsic::x86_sse41_ptestnzc:
17703   case Intrinsic::x86_avx_ptestz_256:
17704   case Intrinsic::x86_avx_ptestc_256:
17705   case Intrinsic::x86_avx_ptestnzc_256:
17706   case Intrinsic::x86_avx_vtestz_ps:
17707   case Intrinsic::x86_avx_vtestc_ps:
17708   case Intrinsic::x86_avx_vtestnzc_ps:
17709   case Intrinsic::x86_avx_vtestz_pd:
17710   case Intrinsic::x86_avx_vtestc_pd:
17711   case Intrinsic::x86_avx_vtestnzc_pd:
17712   case Intrinsic::x86_avx_vtestz_ps_256:
17713   case Intrinsic::x86_avx_vtestc_ps_256:
17714   case Intrinsic::x86_avx_vtestnzc_ps_256:
17715   case Intrinsic::x86_avx_vtestz_pd_256:
17716   case Intrinsic::x86_avx_vtestc_pd_256:
17717   case Intrinsic::x86_avx_vtestnzc_pd_256: {
17718     bool IsTestPacked = false;
17719     unsigned X86CC;
17720     switch (IntNo) {
17721     default: llvm_unreachable("Bad fallthrough in Intrinsic lowering.");
17722     case Intrinsic::x86_avx_vtestz_ps:
17723     case Intrinsic::x86_avx_vtestz_pd:
17724     case Intrinsic::x86_avx_vtestz_ps_256:
17725     case Intrinsic::x86_avx_vtestz_pd_256:
17726       IsTestPacked = true; // Fallthrough
17727     case Intrinsic::x86_sse41_ptestz:
17728     case Intrinsic::x86_avx_ptestz_256:
17729       // ZF = 1
17730       X86CC = X86::COND_E;
17731       break;
17732     case Intrinsic::x86_avx_vtestc_ps:
17733     case Intrinsic::x86_avx_vtestc_pd:
17734     case Intrinsic::x86_avx_vtestc_ps_256:
17735     case Intrinsic::x86_avx_vtestc_pd_256:
17736       IsTestPacked = true; // Fallthrough
17737     case Intrinsic::x86_sse41_ptestc:
17738     case Intrinsic::x86_avx_ptestc_256:
17739       // CF = 1
17740       X86CC = X86::COND_B;
17741       break;
17742     case Intrinsic::x86_avx_vtestnzc_ps:
17743     case Intrinsic::x86_avx_vtestnzc_pd:
17744     case Intrinsic::x86_avx_vtestnzc_ps_256:
17745     case Intrinsic::x86_avx_vtestnzc_pd_256:
17746       IsTestPacked = true; // Fallthrough
17747     case Intrinsic::x86_sse41_ptestnzc:
17748     case Intrinsic::x86_avx_ptestnzc_256:
17749       // ZF and CF = 0
17750       X86CC = X86::COND_A;
17751       break;
17752     }
17753
17754     SDValue LHS = Op.getOperand(1);
17755     SDValue RHS = Op.getOperand(2);
17756     unsigned TestOpc = IsTestPacked ? X86ISD::TESTP : X86ISD::PTEST;
17757     SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
17758     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
17759     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
17760     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17761   }
17762   case Intrinsic::x86_avx512_kortestz_w:
17763   case Intrinsic::x86_avx512_kortestc_w: {
17764     unsigned X86CC = (IntNo == Intrinsic::x86_avx512_kortestz_w)? X86::COND_E: X86::COND_B;
17765     SDValue LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(1));
17766     SDValue RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(2));
17767     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
17768     SDValue Test = DAG.getNode(X86ISD::KORTEST, dl, MVT::i32, LHS, RHS);
17769     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i1, CC, Test);
17770     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17771   }
17772
17773   case Intrinsic::x86_sse42_pcmpistria128:
17774   case Intrinsic::x86_sse42_pcmpestria128:
17775   case Intrinsic::x86_sse42_pcmpistric128:
17776   case Intrinsic::x86_sse42_pcmpestric128:
17777   case Intrinsic::x86_sse42_pcmpistrio128:
17778   case Intrinsic::x86_sse42_pcmpestrio128:
17779   case Intrinsic::x86_sse42_pcmpistris128:
17780   case Intrinsic::x86_sse42_pcmpestris128:
17781   case Intrinsic::x86_sse42_pcmpistriz128:
17782   case Intrinsic::x86_sse42_pcmpestriz128: {
17783     unsigned Opcode;
17784     unsigned X86CC;
17785     switch (IntNo) {
17786     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
17787     case Intrinsic::x86_sse42_pcmpistria128:
17788       Opcode = X86ISD::PCMPISTRI;
17789       X86CC = X86::COND_A;
17790       break;
17791     case Intrinsic::x86_sse42_pcmpestria128:
17792       Opcode = X86ISD::PCMPESTRI;
17793       X86CC = X86::COND_A;
17794       break;
17795     case Intrinsic::x86_sse42_pcmpistric128:
17796       Opcode = X86ISD::PCMPISTRI;
17797       X86CC = X86::COND_B;
17798       break;
17799     case Intrinsic::x86_sse42_pcmpestric128:
17800       Opcode = X86ISD::PCMPESTRI;
17801       X86CC = X86::COND_B;
17802       break;
17803     case Intrinsic::x86_sse42_pcmpistrio128:
17804       Opcode = X86ISD::PCMPISTRI;
17805       X86CC = X86::COND_O;
17806       break;
17807     case Intrinsic::x86_sse42_pcmpestrio128:
17808       Opcode = X86ISD::PCMPESTRI;
17809       X86CC = X86::COND_O;
17810       break;
17811     case Intrinsic::x86_sse42_pcmpistris128:
17812       Opcode = X86ISD::PCMPISTRI;
17813       X86CC = X86::COND_S;
17814       break;
17815     case Intrinsic::x86_sse42_pcmpestris128:
17816       Opcode = X86ISD::PCMPESTRI;
17817       X86CC = X86::COND_S;
17818       break;
17819     case Intrinsic::x86_sse42_pcmpistriz128:
17820       Opcode = X86ISD::PCMPISTRI;
17821       X86CC = X86::COND_E;
17822       break;
17823     case Intrinsic::x86_sse42_pcmpestriz128:
17824       Opcode = X86ISD::PCMPESTRI;
17825       X86CC = X86::COND_E;
17826       break;
17827     }
17828     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
17829     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
17830     SDValue PCMP = DAG.getNode(Opcode, dl, VTs, NewOps);
17831     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17832                                 DAG.getConstant(X86CC, MVT::i8),
17833                                 SDValue(PCMP.getNode(), 1));
17834     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17835   }
17836
17837   case Intrinsic::x86_sse42_pcmpistri128:
17838   case Intrinsic::x86_sse42_pcmpestri128: {
17839     unsigned Opcode;
17840     if (IntNo == Intrinsic::x86_sse42_pcmpistri128)
17841       Opcode = X86ISD::PCMPISTRI;
17842     else
17843       Opcode = X86ISD::PCMPESTRI;
17844
17845     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
17846     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
17847     return DAG.getNode(Opcode, dl, VTs, NewOps);
17848   }
17849   }
17850 }
17851
17852 static SDValue getGatherNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17853                               SDValue Src, SDValue Mask, SDValue Base,
17854                               SDValue Index, SDValue ScaleOp, SDValue Chain,
17855                               const X86Subtarget * Subtarget) {
17856   SDLoc dl(Op);
17857   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17858   assert(C && "Invalid scale type");
17859   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17860   EVT MaskVT = MVT::getVectorVT(MVT::i1,
17861                              Index.getSimpleValueType().getVectorNumElements());
17862   SDValue MaskInReg;
17863   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17864   if (MaskC)
17865     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17866   else
17867     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17868   SDVTList VTs = DAG.getVTList(Op.getValueType(), MaskVT, MVT::Other);
17869   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17870   SDValue Segment = DAG.getRegister(0, MVT::i32);
17871   if (Src.getOpcode() == ISD::UNDEF)
17872     Src = getZeroVector(Op.getValueType(), Subtarget, DAG, dl);
17873   SDValue Ops[] = {Src, MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
17874   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
17875   SDValue RetOps[] = { SDValue(Res, 0), SDValue(Res, 2) };
17876   return DAG.getMergeValues(RetOps, dl);
17877 }
17878
17879 static SDValue getScatterNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17880                                SDValue Src, SDValue Mask, SDValue Base,
17881                                SDValue Index, SDValue ScaleOp, SDValue Chain) {
17882   SDLoc dl(Op);
17883   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17884   assert(C && "Invalid scale type");
17885   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17886   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17887   SDValue Segment = DAG.getRegister(0, MVT::i32);
17888   EVT MaskVT = MVT::getVectorVT(MVT::i1,
17889                              Index.getSimpleValueType().getVectorNumElements());
17890   SDValue MaskInReg;
17891   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17892   if (MaskC)
17893     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17894   else
17895     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17896   SDVTList VTs = DAG.getVTList(MaskVT, MVT::Other);
17897   SDValue Ops[] = {Base, Scale, Index, Disp, Segment, MaskInReg, Src, Chain};
17898   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
17899   return SDValue(Res, 1);
17900 }
17901
17902 static SDValue getPrefetchNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17903                                SDValue Mask, SDValue Base, SDValue Index,
17904                                SDValue ScaleOp, SDValue Chain) {
17905   SDLoc dl(Op);
17906   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17907   assert(C && "Invalid scale type");
17908   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17909   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17910   SDValue Segment = DAG.getRegister(0, MVT::i32);
17911   EVT MaskVT =
17912     MVT::getVectorVT(MVT::i1, Index.getSimpleValueType().getVectorNumElements());
17913   SDValue MaskInReg;
17914   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17915   if (MaskC)
17916     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17917   else
17918     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17919   //SDVTList VTs = DAG.getVTList(MVT::Other);
17920   SDValue Ops[] = {MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
17921   SDNode *Res = DAG.getMachineNode(Opc, dl, MVT::Other, Ops);
17922   return SDValue(Res, 0);
17923 }
17924
17925 // getReadPerformanceCounter - Handles the lowering of builtin intrinsics that
17926 // read performance monitor counters (x86_rdpmc).
17927 static void getReadPerformanceCounter(SDNode *N, SDLoc DL,
17928                               SelectionDAG &DAG, const X86Subtarget *Subtarget,
17929                               SmallVectorImpl<SDValue> &Results) {
17930   assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
17931   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
17932   SDValue LO, HI;
17933
17934   // The ECX register is used to select the index of the performance counter
17935   // to read.
17936   SDValue Chain = DAG.getCopyToReg(N->getOperand(0), DL, X86::ECX,
17937                                    N->getOperand(2));
17938   SDValue rd = DAG.getNode(X86ISD::RDPMC_DAG, DL, Tys, Chain);
17939
17940   // Reads the content of a 64-bit performance counter and returns it in the
17941   // registers EDX:EAX.
17942   if (Subtarget->is64Bit()) {
17943     LO = DAG.getCopyFromReg(rd, DL, X86::RAX, MVT::i64, rd.getValue(1));
17944     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::RDX, MVT::i64,
17945                             LO.getValue(2));
17946   } else {
17947     LO = DAG.getCopyFromReg(rd, DL, X86::EAX, MVT::i32, rd.getValue(1));
17948     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::EDX, MVT::i32,
17949                             LO.getValue(2));
17950   }
17951   Chain = HI.getValue(1);
17952
17953   if (Subtarget->is64Bit()) {
17954     // The EAX register is loaded with the low-order 32 bits. The EDX register
17955     // is loaded with the supported high-order bits of the counter.
17956     SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
17957                               DAG.getConstant(32, MVT::i8));
17958     Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
17959     Results.push_back(Chain);
17960     return;
17961   }
17962
17963   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
17964   SDValue Ops[] = { LO, HI };
17965   SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
17966   Results.push_back(Pair);
17967   Results.push_back(Chain);
17968 }
17969
17970 // getReadTimeStampCounter - Handles the lowering of builtin intrinsics that
17971 // read the time stamp counter (x86_rdtsc and x86_rdtscp). This function is
17972 // also used to custom lower READCYCLECOUNTER nodes.
17973 static void getReadTimeStampCounter(SDNode *N, SDLoc DL, unsigned Opcode,
17974                               SelectionDAG &DAG, const X86Subtarget *Subtarget,
17975                               SmallVectorImpl<SDValue> &Results) {
17976   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
17977   SDValue rd = DAG.getNode(Opcode, DL, Tys, N->getOperand(0));
17978   SDValue LO, HI;
17979
17980   // The processor's time-stamp counter (a 64-bit MSR) is stored into the
17981   // EDX:EAX registers. EDX is loaded with the high-order 32 bits of the MSR
17982   // and the EAX register is loaded with the low-order 32 bits.
17983   if (Subtarget->is64Bit()) {
17984     LO = DAG.getCopyFromReg(rd, DL, X86::RAX, MVT::i64, rd.getValue(1));
17985     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::RDX, MVT::i64,
17986                             LO.getValue(2));
17987   } else {
17988     LO = DAG.getCopyFromReg(rd, DL, X86::EAX, MVT::i32, rd.getValue(1));
17989     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::EDX, MVT::i32,
17990                             LO.getValue(2));
17991   }
17992   SDValue Chain = HI.getValue(1);
17993
17994   if (Opcode == X86ISD::RDTSCP_DAG) {
17995     assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
17996
17997     // Instruction RDTSCP loads the IA32:TSC_AUX_MSR (address C000_0103H) into
17998     // the ECX register. Add 'ecx' explicitly to the chain.
17999     SDValue ecx = DAG.getCopyFromReg(Chain, DL, X86::ECX, MVT::i32,
18000                                      HI.getValue(2));
18001     // Explicitly store the content of ECX at the location passed in input
18002     // to the 'rdtscp' intrinsic.
18003     Chain = DAG.getStore(ecx.getValue(1), DL, ecx, N->getOperand(2),
18004                          MachinePointerInfo(), false, false, 0);
18005   }
18006
18007   if (Subtarget->is64Bit()) {
18008     // The EDX register is loaded with the high-order 32 bits of the MSR, and
18009     // the EAX register is loaded with the low-order 32 bits.
18010     SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
18011                               DAG.getConstant(32, MVT::i8));
18012     Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
18013     Results.push_back(Chain);
18014     return;
18015   }
18016
18017   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
18018   SDValue Ops[] = { LO, HI };
18019   SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
18020   Results.push_back(Pair);
18021   Results.push_back(Chain);
18022 }
18023
18024 static SDValue LowerREADCYCLECOUNTER(SDValue Op, const X86Subtarget *Subtarget,
18025                                      SelectionDAG &DAG) {
18026   SmallVector<SDValue, 2> Results;
18027   SDLoc DL(Op);
18028   getReadTimeStampCounter(Op.getNode(), DL, X86ISD::RDTSC_DAG, DAG, Subtarget,
18029                           Results);
18030   return DAG.getMergeValues(Results, DL);
18031 }
18032
18033
18034 static SDValue LowerINTRINSIC_W_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
18035                                       SelectionDAG &DAG) {
18036   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
18037
18038   const IntrinsicData* IntrData = getIntrinsicWithChain(IntNo);
18039   if (!IntrData)
18040     return SDValue();
18041
18042   SDLoc dl(Op);
18043   switch(IntrData->Type) {
18044   default:
18045     llvm_unreachable("Unknown Intrinsic Type");
18046     break;
18047   case RDSEED:
18048   case RDRAND: {
18049     // Emit the node with the right value type.
18050     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Glue, MVT::Other);
18051     SDValue Result = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(0));
18052
18053     // If the value returned by RDRAND/RDSEED was valid (CF=1), return 1.
18054     // Otherwise return the value from Rand, which is always 0, casted to i32.
18055     SDValue Ops[] = { DAG.getZExtOrTrunc(Result, dl, Op->getValueType(1)),
18056                       DAG.getConstant(1, Op->getValueType(1)),
18057                       DAG.getConstant(X86::COND_B, MVT::i32),
18058                       SDValue(Result.getNode(), 1) };
18059     SDValue isValid = DAG.getNode(X86ISD::CMOV, dl,
18060                                   DAG.getVTList(Op->getValueType(1), MVT::Glue),
18061                                   Ops);
18062
18063     // Return { result, isValid, chain }.
18064     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
18065                        SDValue(Result.getNode(), 2));
18066   }
18067   case GATHER: {
18068   //gather(v1, mask, index, base, scale);
18069     SDValue Chain = Op.getOperand(0);
18070     SDValue Src   = Op.getOperand(2);
18071     SDValue Base  = Op.getOperand(3);
18072     SDValue Index = Op.getOperand(4);
18073     SDValue Mask  = Op.getOperand(5);
18074     SDValue Scale = Op.getOperand(6);
18075     return getGatherNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index, Scale, Chain,
18076                           Subtarget);
18077   }
18078   case SCATTER: {
18079   //scatter(base, mask, index, v1, scale);
18080     SDValue Chain = Op.getOperand(0);
18081     SDValue Base  = Op.getOperand(2);
18082     SDValue Mask  = Op.getOperand(3);
18083     SDValue Index = Op.getOperand(4);
18084     SDValue Src   = Op.getOperand(5);
18085     SDValue Scale = Op.getOperand(6);
18086     return getScatterNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index, Scale, Chain);
18087   }
18088   case PREFETCH: {
18089     SDValue Hint = Op.getOperand(6);
18090     unsigned HintVal;
18091     if (dyn_cast<ConstantSDNode> (Hint) == nullptr ||
18092         (HintVal = dyn_cast<ConstantSDNode> (Hint)->getZExtValue()) > 1)
18093       llvm_unreachable("Wrong prefetch hint in intrinsic: should be 0 or 1");
18094     unsigned Opcode = (HintVal ? IntrData->Opc1 : IntrData->Opc0);
18095     SDValue Chain = Op.getOperand(0);
18096     SDValue Mask  = Op.getOperand(2);
18097     SDValue Index = Op.getOperand(3);
18098     SDValue Base  = Op.getOperand(4);
18099     SDValue Scale = Op.getOperand(5);
18100     return getPrefetchNode(Opcode, Op, DAG, Mask, Base, Index, Scale, Chain);
18101   }
18102   // Read Time Stamp Counter (RDTSC) and Processor ID (RDTSCP).
18103   case RDTSC: {
18104     SmallVector<SDValue, 2> Results;
18105     getReadTimeStampCounter(Op.getNode(), dl, IntrData->Opc0, DAG, Subtarget, Results);
18106     return DAG.getMergeValues(Results, dl);
18107   }
18108   // Read Performance Monitoring Counters.
18109   case RDPMC: {
18110     SmallVector<SDValue, 2> Results;
18111     getReadPerformanceCounter(Op.getNode(), dl, DAG, Subtarget, Results);
18112     return DAG.getMergeValues(Results, dl);
18113   }
18114   // XTEST intrinsics.
18115   case XTEST: {
18116     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
18117     SDValue InTrans = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(0));
18118     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
18119                                 DAG.getConstant(X86::COND_NE, MVT::i8),
18120                                 InTrans);
18121     SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
18122     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(),
18123                        Ret, SDValue(InTrans.getNode(), 1));
18124   }
18125   // ADC/ADCX/SBB
18126   case ADX: {
18127     SmallVector<SDValue, 2> Results;
18128     SDVTList CFVTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
18129     SDVTList VTs = DAG.getVTList(Op.getOperand(3)->getValueType(0), MVT::Other);
18130     SDValue GenCF = DAG.getNode(X86ISD::ADD, dl, CFVTs, Op.getOperand(2),
18131                                 DAG.getConstant(-1, MVT::i8));
18132     SDValue Res = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(3),
18133                               Op.getOperand(4), GenCF.getValue(1));
18134     SDValue Store = DAG.getStore(Op.getOperand(0), dl, Res.getValue(0),
18135                                  Op.getOperand(5), MachinePointerInfo(),
18136                                  false, false, 0);
18137     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
18138                                 DAG.getConstant(X86::COND_B, MVT::i8),
18139                                 Res.getValue(1));
18140     Results.push_back(SetCC);
18141     Results.push_back(Store);
18142     return DAG.getMergeValues(Results, dl);
18143   }
18144   case COMPRESS_TO_MEM: {
18145     SDLoc dl(Op);
18146     SDValue Mask = Op.getOperand(4);
18147     SDValue DataToCompress = Op.getOperand(3);
18148     SDValue Addr = Op.getOperand(2);
18149     SDValue Chain = Op.getOperand(0);
18150
18151     if (isAllOnes(Mask)) // return just a store
18152       return DAG.getStore(Chain, dl, DataToCompress, Addr,
18153                           MachinePointerInfo(), false, false, 0);
18154
18155     EVT VT = DataToCompress.getValueType();
18156     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
18157                                   VT.getVectorNumElements());
18158     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
18159                                      Mask.getValueType().getSizeInBits());
18160     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
18161                                 DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
18162                                 DAG.getIntPtrConstant(0));
18163
18164     SDValue Compressed =  DAG.getNode(IntrData->Opc0, dl, VT, VMask,
18165                                       DataToCompress, DAG.getUNDEF(VT));
18166     return DAG.getStore(Chain, dl, Compressed, Addr,
18167                         MachinePointerInfo(), false, false, 0);
18168   }
18169   case EXPAND_FROM_MEM: {
18170     SDLoc dl(Op);
18171     SDValue Mask = Op.getOperand(4);
18172     SDValue PathThru = Op.getOperand(3);
18173     SDValue Addr = Op.getOperand(2);
18174     SDValue Chain = Op.getOperand(0);
18175     EVT VT = Op.getValueType();
18176
18177     if (isAllOnes(Mask)) // return just a load
18178       return DAG.getLoad(VT, dl, Chain, Addr, MachinePointerInfo(), false, false,
18179                          false, 0);
18180     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
18181                                   VT.getVectorNumElements());
18182     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
18183                                      Mask.getValueType().getSizeInBits());
18184     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
18185                                 DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
18186                                 DAG.getIntPtrConstant(0));
18187
18188     SDValue DataToExpand = DAG.getLoad(VT, dl, Chain, Addr, MachinePointerInfo(),
18189                                    false, false, false, 0);
18190
18191     SmallVector<SDValue, 2> Results;
18192     Results.push_back(DAG.getNode(IntrData->Opc0, dl, VT, VMask, DataToExpand,
18193                                   PathThru));
18194     Results.push_back(Chain);
18195     return DAG.getMergeValues(Results, dl);
18196   }
18197   }
18198 }
18199
18200 SDValue X86TargetLowering::LowerRETURNADDR(SDValue Op,
18201                                            SelectionDAG &DAG) const {
18202   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
18203   MFI->setReturnAddressIsTaken(true);
18204
18205   if (verifyReturnAddressArgumentIsConstant(Op, DAG))
18206     return SDValue();
18207
18208   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
18209   SDLoc dl(Op);
18210   EVT PtrVT = getPointerTy();
18211
18212   if (Depth > 0) {
18213     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
18214     const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18215     SDValue Offset = DAG.getConstant(RegInfo->getSlotSize(), PtrVT);
18216     return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
18217                        DAG.getNode(ISD::ADD, dl, PtrVT,
18218                                    FrameAddr, Offset),
18219                        MachinePointerInfo(), false, false, false, 0);
18220   }
18221
18222   // Just load the return address.
18223   SDValue RetAddrFI = getReturnAddressFrameIndex(DAG);
18224   return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
18225                      RetAddrFI, MachinePointerInfo(), false, false, false, 0);
18226 }
18227
18228 SDValue X86TargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
18229   MachineFunction &MF = DAG.getMachineFunction();
18230   MachineFrameInfo *MFI = MF.getFrameInfo();
18231   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
18232   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18233   EVT VT = Op.getValueType();
18234
18235   MFI->setFrameAddressIsTaken(true);
18236
18237   if (MF.getTarget().getMCAsmInfo()->usesWindowsCFI()) {
18238     // Depth > 0 makes no sense on targets which use Windows unwind codes.  It
18239     // is not possible to crawl up the stack without looking at the unwind codes
18240     // simultaneously.
18241     int FrameAddrIndex = FuncInfo->getFAIndex();
18242     if (!FrameAddrIndex) {
18243       // Set up a frame object for the return address.
18244       unsigned SlotSize = RegInfo->getSlotSize();
18245       FrameAddrIndex = MF.getFrameInfo()->CreateFixedObject(
18246           SlotSize, /*Offset=*/INT64_MIN, /*IsImmutable=*/false);
18247       FuncInfo->setFAIndex(FrameAddrIndex);
18248     }
18249     return DAG.getFrameIndex(FrameAddrIndex, VT);
18250   }
18251
18252   unsigned FrameReg =
18253       RegInfo->getPtrSizedFrameRegister(DAG.getMachineFunction());
18254   SDLoc dl(Op);  // FIXME probably not meaningful
18255   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
18256   assert(((FrameReg == X86::RBP && VT == MVT::i64) ||
18257           (FrameReg == X86::EBP && VT == MVT::i32)) &&
18258          "Invalid Frame Register!");
18259   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
18260   while (Depth--)
18261     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
18262                             MachinePointerInfo(),
18263                             false, false, false, 0);
18264   return FrameAddr;
18265 }
18266
18267 // FIXME? Maybe this could be a TableGen attribute on some registers and
18268 // this table could be generated automatically from RegInfo.
18269 unsigned X86TargetLowering::getRegisterByName(const char* RegName,
18270                                               EVT VT) const {
18271   unsigned Reg = StringSwitch<unsigned>(RegName)
18272                        .Case("esp", X86::ESP)
18273                        .Case("rsp", X86::RSP)
18274                        .Default(0);
18275   if (Reg)
18276     return Reg;
18277   report_fatal_error("Invalid register name global variable");
18278 }
18279
18280 SDValue X86TargetLowering::LowerFRAME_TO_ARGS_OFFSET(SDValue Op,
18281                                                      SelectionDAG &DAG) const {
18282   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18283   return DAG.getIntPtrConstant(2 * RegInfo->getSlotSize());
18284 }
18285
18286 SDValue X86TargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
18287   SDValue Chain     = Op.getOperand(0);
18288   SDValue Offset    = Op.getOperand(1);
18289   SDValue Handler   = Op.getOperand(2);
18290   SDLoc dl      (Op);
18291
18292   EVT PtrVT = getPointerTy();
18293   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18294   unsigned FrameReg = RegInfo->getFrameRegister(DAG.getMachineFunction());
18295   assert(((FrameReg == X86::RBP && PtrVT == MVT::i64) ||
18296           (FrameReg == X86::EBP && PtrVT == MVT::i32)) &&
18297          "Invalid Frame Register!");
18298   SDValue Frame = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, PtrVT);
18299   unsigned StoreAddrReg = (PtrVT == MVT::i64) ? X86::RCX : X86::ECX;
18300
18301   SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, Frame,
18302                                  DAG.getIntPtrConstant(RegInfo->getSlotSize()));
18303   StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, StoreAddr, Offset);
18304   Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo(),
18305                        false, false, 0);
18306   Chain = DAG.getCopyToReg(Chain, dl, StoreAddrReg, StoreAddr);
18307
18308   return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
18309                      DAG.getRegister(StoreAddrReg, PtrVT));
18310 }
18311
18312 SDValue X86TargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op,
18313                                                SelectionDAG &DAG) const {
18314   SDLoc DL(Op);
18315   return DAG.getNode(X86ISD::EH_SJLJ_SETJMP, DL,
18316                      DAG.getVTList(MVT::i32, MVT::Other),
18317                      Op.getOperand(0), Op.getOperand(1));
18318 }
18319
18320 SDValue X86TargetLowering::lowerEH_SJLJ_LONGJMP(SDValue Op,
18321                                                 SelectionDAG &DAG) const {
18322   SDLoc DL(Op);
18323   return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
18324                      Op.getOperand(0), Op.getOperand(1));
18325 }
18326
18327 static SDValue LowerADJUST_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) {
18328   return Op.getOperand(0);
18329 }
18330
18331 SDValue X86TargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
18332                                                 SelectionDAG &DAG) const {
18333   SDValue Root = Op.getOperand(0);
18334   SDValue Trmp = Op.getOperand(1); // trampoline
18335   SDValue FPtr = Op.getOperand(2); // nested function
18336   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
18337   SDLoc dl (Op);
18338
18339   const Value *TrmpAddr = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
18340   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
18341
18342   if (Subtarget->is64Bit()) {
18343     SDValue OutChains[6];
18344
18345     // Large code-model.
18346     const unsigned char JMP64r  = 0xFF; // 64-bit jmp through register opcode.
18347     const unsigned char MOV64ri = 0xB8; // X86::MOV64ri opcode.
18348
18349     const unsigned char N86R10 = TRI->getEncodingValue(X86::R10) & 0x7;
18350     const unsigned char N86R11 = TRI->getEncodingValue(X86::R11) & 0x7;
18351
18352     const unsigned char REX_WB = 0x40 | 0x08 | 0x01; // REX prefix
18353
18354     // Load the pointer to the nested function into R11.
18355     unsigned OpCode = ((MOV64ri | N86R11) << 8) | REX_WB; // movabsq r11
18356     SDValue Addr = Trmp;
18357     OutChains[0] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
18358                                 Addr, MachinePointerInfo(TrmpAddr),
18359                                 false, false, 0);
18360
18361     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18362                        DAG.getConstant(2, MVT::i64));
18363     OutChains[1] = DAG.getStore(Root, dl, FPtr, Addr,
18364                                 MachinePointerInfo(TrmpAddr, 2),
18365                                 false, false, 2);
18366
18367     // Load the 'nest' parameter value into R10.
18368     // R10 is specified in X86CallingConv.td
18369     OpCode = ((MOV64ri | N86R10) << 8) | REX_WB; // movabsq r10
18370     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18371                        DAG.getConstant(10, MVT::i64));
18372     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
18373                                 Addr, MachinePointerInfo(TrmpAddr, 10),
18374                                 false, false, 0);
18375
18376     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18377                        DAG.getConstant(12, MVT::i64));
18378     OutChains[3] = DAG.getStore(Root, dl, Nest, Addr,
18379                                 MachinePointerInfo(TrmpAddr, 12),
18380                                 false, false, 2);
18381
18382     // Jump to the nested function.
18383     OpCode = (JMP64r << 8) | REX_WB; // jmpq *...
18384     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18385                        DAG.getConstant(20, MVT::i64));
18386     OutChains[4] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
18387                                 Addr, MachinePointerInfo(TrmpAddr, 20),
18388                                 false, false, 0);
18389
18390     unsigned char ModRM = N86R11 | (4 << 3) | (3 << 6); // ...r11
18391     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18392                        DAG.getConstant(22, MVT::i64));
18393     OutChains[5] = DAG.getStore(Root, dl, DAG.getConstant(ModRM, MVT::i8), Addr,
18394                                 MachinePointerInfo(TrmpAddr, 22),
18395                                 false, false, 0);
18396
18397     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
18398   } else {
18399     const Function *Func =
18400       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
18401     CallingConv::ID CC = Func->getCallingConv();
18402     unsigned NestReg;
18403
18404     switch (CC) {
18405     default:
18406       llvm_unreachable("Unsupported calling convention");
18407     case CallingConv::C:
18408     case CallingConv::X86_StdCall: {
18409       // Pass 'nest' parameter in ECX.
18410       // Must be kept in sync with X86CallingConv.td
18411       NestReg = X86::ECX;
18412
18413       // Check that ECX wasn't needed by an 'inreg' parameter.
18414       FunctionType *FTy = Func->getFunctionType();
18415       const AttributeSet &Attrs = Func->getAttributes();
18416
18417       if (!Attrs.isEmpty() && !Func->isVarArg()) {
18418         unsigned InRegCount = 0;
18419         unsigned Idx = 1;
18420
18421         for (FunctionType::param_iterator I = FTy->param_begin(),
18422              E = FTy->param_end(); I != E; ++I, ++Idx)
18423           if (Attrs.hasAttribute(Idx, Attribute::InReg))
18424             // FIXME: should only count parameters that are lowered to integers.
18425             InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
18426
18427         if (InRegCount > 2) {
18428           report_fatal_error("Nest register in use - reduce number of inreg"
18429                              " parameters!");
18430         }
18431       }
18432       break;
18433     }
18434     case CallingConv::X86_FastCall:
18435     case CallingConv::X86_ThisCall:
18436     case CallingConv::Fast:
18437       // Pass 'nest' parameter in EAX.
18438       // Must be kept in sync with X86CallingConv.td
18439       NestReg = X86::EAX;
18440       break;
18441     }
18442
18443     SDValue OutChains[4];
18444     SDValue Addr, Disp;
18445
18446     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18447                        DAG.getConstant(10, MVT::i32));
18448     Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
18449
18450     // This is storing the opcode for MOV32ri.
18451     const unsigned char MOV32ri = 0xB8; // X86::MOV32ri's opcode byte.
18452     const unsigned char N86Reg = TRI->getEncodingValue(NestReg) & 0x7;
18453     OutChains[0] = DAG.getStore(Root, dl,
18454                                 DAG.getConstant(MOV32ri|N86Reg, MVT::i8),
18455                                 Trmp, MachinePointerInfo(TrmpAddr),
18456                                 false, false, 0);
18457
18458     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18459                        DAG.getConstant(1, MVT::i32));
18460     OutChains[1] = DAG.getStore(Root, dl, Nest, Addr,
18461                                 MachinePointerInfo(TrmpAddr, 1),
18462                                 false, false, 1);
18463
18464     const unsigned char JMP = 0xE9; // jmp <32bit dst> opcode.
18465     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18466                        DAG.getConstant(5, MVT::i32));
18467     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(JMP, MVT::i8), Addr,
18468                                 MachinePointerInfo(TrmpAddr, 5),
18469                                 false, false, 1);
18470
18471     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18472                        DAG.getConstant(6, MVT::i32));
18473     OutChains[3] = DAG.getStore(Root, dl, Disp, Addr,
18474                                 MachinePointerInfo(TrmpAddr, 6),
18475                                 false, false, 1);
18476
18477     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
18478   }
18479 }
18480
18481 SDValue X86TargetLowering::LowerFLT_ROUNDS_(SDValue Op,
18482                                             SelectionDAG &DAG) const {
18483   /*
18484    The rounding mode is in bits 11:10 of FPSR, and has the following
18485    settings:
18486      00 Round to nearest
18487      01 Round to -inf
18488      10 Round to +inf
18489      11 Round to 0
18490
18491   FLT_ROUNDS, on the other hand, expects the following:
18492     -1 Undefined
18493      0 Round to 0
18494      1 Round to nearest
18495      2 Round to +inf
18496      3 Round to -inf
18497
18498   To perform the conversion, we do:
18499     (((((FPSR & 0x800) >> 11) | ((FPSR & 0x400) >> 9)) + 1) & 3)
18500   */
18501
18502   MachineFunction &MF = DAG.getMachineFunction();
18503   const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
18504   unsigned StackAlignment = TFI.getStackAlignment();
18505   MVT VT = Op.getSimpleValueType();
18506   SDLoc DL(Op);
18507
18508   // Save FP Control Word to stack slot
18509   int SSFI = MF.getFrameInfo()->CreateStackObject(2, StackAlignment, false);
18510   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
18511
18512   MachineMemOperand *MMO =
18513    MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
18514                            MachineMemOperand::MOStore, 2, 2);
18515
18516   SDValue Ops[] = { DAG.getEntryNode(), StackSlot };
18517   SDValue Chain = DAG.getMemIntrinsicNode(X86ISD::FNSTCW16m, DL,
18518                                           DAG.getVTList(MVT::Other),
18519                                           Ops, MVT::i16, MMO);
18520
18521   // Load FP Control Word from stack slot
18522   SDValue CWD = DAG.getLoad(MVT::i16, DL, Chain, StackSlot,
18523                             MachinePointerInfo(), false, false, false, 0);
18524
18525   // Transform as necessary
18526   SDValue CWD1 =
18527     DAG.getNode(ISD::SRL, DL, MVT::i16,
18528                 DAG.getNode(ISD::AND, DL, MVT::i16,
18529                             CWD, DAG.getConstant(0x800, MVT::i16)),
18530                 DAG.getConstant(11, MVT::i8));
18531   SDValue CWD2 =
18532     DAG.getNode(ISD::SRL, DL, MVT::i16,
18533                 DAG.getNode(ISD::AND, DL, MVT::i16,
18534                             CWD, DAG.getConstant(0x400, MVT::i16)),
18535                 DAG.getConstant(9, MVT::i8));
18536
18537   SDValue RetVal =
18538     DAG.getNode(ISD::AND, DL, MVT::i16,
18539                 DAG.getNode(ISD::ADD, DL, MVT::i16,
18540                             DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
18541                             DAG.getConstant(1, MVT::i16)),
18542                 DAG.getConstant(3, MVT::i16));
18543
18544   return DAG.getNode((VT.getSizeInBits() < 16 ?
18545                       ISD::TRUNCATE : ISD::ZERO_EXTEND), DL, VT, RetVal);
18546 }
18547
18548 static SDValue LowerCTLZ(SDValue Op, SelectionDAG &DAG) {
18549   MVT VT = Op.getSimpleValueType();
18550   EVT OpVT = VT;
18551   unsigned NumBits = VT.getSizeInBits();
18552   SDLoc dl(Op);
18553
18554   Op = Op.getOperand(0);
18555   if (VT == MVT::i8) {
18556     // Zero extend to i32 since there is not an i8 bsr.
18557     OpVT = MVT::i32;
18558     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
18559   }
18560
18561   // Issue a bsr (scan bits in reverse) which also sets EFLAGS.
18562   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
18563   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
18564
18565   // If src is zero (i.e. bsr sets ZF), returns NumBits.
18566   SDValue Ops[] = {
18567     Op,
18568     DAG.getConstant(NumBits+NumBits-1, OpVT),
18569     DAG.getConstant(X86::COND_E, MVT::i8),
18570     Op.getValue(1)
18571   };
18572   Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops);
18573
18574   // Finally xor with NumBits-1.
18575   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
18576
18577   if (VT == MVT::i8)
18578     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
18579   return Op;
18580 }
18581
18582 static SDValue LowerCTLZ_ZERO_UNDEF(SDValue Op, SelectionDAG &DAG) {
18583   MVT VT = Op.getSimpleValueType();
18584   EVT OpVT = VT;
18585   unsigned NumBits = VT.getSizeInBits();
18586   SDLoc dl(Op);
18587
18588   Op = Op.getOperand(0);
18589   if (VT == MVT::i8) {
18590     // Zero extend to i32 since there is not an i8 bsr.
18591     OpVT = MVT::i32;
18592     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
18593   }
18594
18595   // Issue a bsr (scan bits in reverse).
18596   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
18597   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
18598
18599   // And xor with NumBits-1.
18600   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
18601
18602   if (VT == MVT::i8)
18603     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
18604   return Op;
18605 }
18606
18607 static SDValue LowerCTTZ(SDValue Op, SelectionDAG &DAG) {
18608   MVT VT = Op.getSimpleValueType();
18609   unsigned NumBits = VT.getSizeInBits();
18610   SDLoc dl(Op);
18611   Op = Op.getOperand(0);
18612
18613   // Issue a bsf (scan bits forward) which also sets EFLAGS.
18614   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
18615   Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
18616
18617   // If src is zero (i.e. bsf sets ZF), returns NumBits.
18618   SDValue Ops[] = {
18619     Op,
18620     DAG.getConstant(NumBits, VT),
18621     DAG.getConstant(X86::COND_E, MVT::i8),
18622     Op.getValue(1)
18623   };
18624   return DAG.getNode(X86ISD::CMOV, dl, VT, Ops);
18625 }
18626
18627 // Lower256IntArith - Break a 256-bit integer operation into two new 128-bit
18628 // ones, and then concatenate the result back.
18629 static SDValue Lower256IntArith(SDValue Op, SelectionDAG &DAG) {
18630   MVT VT = Op.getSimpleValueType();
18631
18632   assert(VT.is256BitVector() && VT.isInteger() &&
18633          "Unsupported value type for operation");
18634
18635   unsigned NumElems = VT.getVectorNumElements();
18636   SDLoc dl(Op);
18637
18638   // Extract the LHS vectors
18639   SDValue LHS = Op.getOperand(0);
18640   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
18641   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
18642
18643   // Extract the RHS vectors
18644   SDValue RHS = Op.getOperand(1);
18645   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
18646   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
18647
18648   MVT EltVT = VT.getVectorElementType();
18649   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
18650
18651   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
18652                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
18653                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
18654 }
18655
18656 static SDValue LowerADD(SDValue Op, SelectionDAG &DAG) {
18657   assert(Op.getSimpleValueType().is256BitVector() &&
18658          Op.getSimpleValueType().isInteger() &&
18659          "Only handle AVX 256-bit vector integer operation");
18660   return Lower256IntArith(Op, DAG);
18661 }
18662
18663 static SDValue LowerSUB(SDValue Op, SelectionDAG &DAG) {
18664   assert(Op.getSimpleValueType().is256BitVector() &&
18665          Op.getSimpleValueType().isInteger() &&
18666          "Only handle AVX 256-bit vector integer operation");
18667   return Lower256IntArith(Op, DAG);
18668 }
18669
18670 static SDValue LowerMUL(SDValue Op, const X86Subtarget *Subtarget,
18671                         SelectionDAG &DAG) {
18672   SDLoc dl(Op);
18673   MVT VT = Op.getSimpleValueType();
18674
18675   // Decompose 256-bit ops into smaller 128-bit ops.
18676   if (VT.is256BitVector() && !Subtarget->hasInt256())
18677     return Lower256IntArith(Op, DAG);
18678
18679   SDValue A = Op.getOperand(0);
18680   SDValue B = Op.getOperand(1);
18681
18682   // Lower v4i32 mul as 2x shuffle, 2x pmuludq, 2x shuffle.
18683   if (VT == MVT::v4i32) {
18684     assert(Subtarget->hasSSE2() && !Subtarget->hasSSE41() &&
18685            "Should not custom lower when pmuldq is available!");
18686
18687     // Extract the odd parts.
18688     static const int UnpackMask[] = { 1, -1, 3, -1 };
18689     SDValue Aodds = DAG.getVectorShuffle(VT, dl, A, A, UnpackMask);
18690     SDValue Bodds = DAG.getVectorShuffle(VT, dl, B, B, UnpackMask);
18691
18692     // Multiply the even parts.
18693     SDValue Evens = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, A, B);
18694     // Now multiply odd parts.
18695     SDValue Odds = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, Aodds, Bodds);
18696
18697     Evens = DAG.getNode(ISD::BITCAST, dl, VT, Evens);
18698     Odds = DAG.getNode(ISD::BITCAST, dl, VT, Odds);
18699
18700     // Merge the two vectors back together with a shuffle. This expands into 2
18701     // shuffles.
18702     static const int ShufMask[] = { 0, 4, 2, 6 };
18703     return DAG.getVectorShuffle(VT, dl, Evens, Odds, ShufMask);
18704   }
18705
18706   assert((VT == MVT::v2i64 || VT == MVT::v4i64 || VT == MVT::v8i64) &&
18707          "Only know how to lower V2I64/V4I64/V8I64 multiply");
18708
18709   //  Ahi = psrlqi(a, 32);
18710   //  Bhi = psrlqi(b, 32);
18711   //
18712   //  AloBlo = pmuludq(a, b);
18713   //  AloBhi = pmuludq(a, Bhi);
18714   //  AhiBlo = pmuludq(Ahi, b);
18715
18716   //  AloBhi = psllqi(AloBhi, 32);
18717   //  AhiBlo = psllqi(AhiBlo, 32);
18718   //  return AloBlo + AloBhi + AhiBlo;
18719
18720   SDValue Ahi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, A, 32, DAG);
18721   SDValue Bhi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, B, 32, DAG);
18722
18723   // Bit cast to 32-bit vectors for MULUDQ
18724   EVT MulVT = (VT == MVT::v2i64) ? MVT::v4i32 :
18725                                   (VT == MVT::v4i64) ? MVT::v8i32 : MVT::v16i32;
18726   A = DAG.getNode(ISD::BITCAST, dl, MulVT, A);
18727   B = DAG.getNode(ISD::BITCAST, dl, MulVT, B);
18728   Ahi = DAG.getNode(ISD::BITCAST, dl, MulVT, Ahi);
18729   Bhi = DAG.getNode(ISD::BITCAST, dl, MulVT, Bhi);
18730
18731   SDValue AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
18732   SDValue AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
18733   SDValue AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
18734
18735   AloBhi = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AloBhi, 32, DAG);
18736   AhiBlo = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AhiBlo, 32, DAG);
18737
18738   SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
18739   return DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
18740 }
18741
18742 SDValue X86TargetLowering::LowerWin64_i128OP(SDValue Op, SelectionDAG &DAG) const {
18743   assert(Subtarget->isTargetWin64() && "Unexpected target");
18744   EVT VT = Op.getValueType();
18745   assert(VT.isInteger() && VT.getSizeInBits() == 128 &&
18746          "Unexpected return type for lowering");
18747
18748   RTLIB::Libcall LC;
18749   bool isSigned;
18750   switch (Op->getOpcode()) {
18751   default: llvm_unreachable("Unexpected request for libcall!");
18752   case ISD::SDIV:      isSigned = true;  LC = RTLIB::SDIV_I128;    break;
18753   case ISD::UDIV:      isSigned = false; LC = RTLIB::UDIV_I128;    break;
18754   case ISD::SREM:      isSigned = true;  LC = RTLIB::SREM_I128;    break;
18755   case ISD::UREM:      isSigned = false; LC = RTLIB::UREM_I128;    break;
18756   case ISD::SDIVREM:   isSigned = true;  LC = RTLIB::SDIVREM_I128; break;
18757   case ISD::UDIVREM:   isSigned = false; LC = RTLIB::UDIVREM_I128; break;
18758   }
18759
18760   SDLoc dl(Op);
18761   SDValue InChain = DAG.getEntryNode();
18762
18763   TargetLowering::ArgListTy Args;
18764   TargetLowering::ArgListEntry Entry;
18765   for (unsigned i = 0, e = Op->getNumOperands(); i != e; ++i) {
18766     EVT ArgVT = Op->getOperand(i).getValueType();
18767     assert(ArgVT.isInteger() && ArgVT.getSizeInBits() == 128 &&
18768            "Unexpected argument type for lowering");
18769     SDValue StackPtr = DAG.CreateStackTemporary(ArgVT, 16);
18770     Entry.Node = StackPtr;
18771     InChain = DAG.getStore(InChain, dl, Op->getOperand(i), StackPtr, MachinePointerInfo(),
18772                            false, false, 16);
18773     Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
18774     Entry.Ty = PointerType::get(ArgTy,0);
18775     Entry.isSExt = false;
18776     Entry.isZExt = false;
18777     Args.push_back(Entry);
18778   }
18779
18780   SDValue Callee = DAG.getExternalSymbol(getLibcallName(LC),
18781                                          getPointerTy());
18782
18783   TargetLowering::CallLoweringInfo CLI(DAG);
18784   CLI.setDebugLoc(dl).setChain(InChain)
18785     .setCallee(getLibcallCallingConv(LC),
18786                static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext()),
18787                Callee, std::move(Args), 0)
18788     .setInRegister().setSExtResult(isSigned).setZExtResult(!isSigned);
18789
18790   std::pair<SDValue, SDValue> CallInfo = LowerCallTo(CLI);
18791   return DAG.getNode(ISD::BITCAST, dl, VT, CallInfo.first);
18792 }
18793
18794 static SDValue LowerMUL_LOHI(SDValue Op, const X86Subtarget *Subtarget,
18795                              SelectionDAG &DAG) {
18796   SDValue Op0 = Op.getOperand(0), Op1 = Op.getOperand(1);
18797   EVT VT = Op0.getValueType();
18798   SDLoc dl(Op);
18799
18800   assert((VT == MVT::v4i32 && Subtarget->hasSSE2()) ||
18801          (VT == MVT::v8i32 && Subtarget->hasInt256()));
18802
18803   // PMULxD operations multiply each even value (starting at 0) of LHS with
18804   // the related value of RHS and produce a widen result.
18805   // E.g., PMULUDQ <4 x i32> <a|b|c|d>, <4 x i32> <e|f|g|h>
18806   // => <2 x i64> <ae|cg>
18807   //
18808   // In other word, to have all the results, we need to perform two PMULxD:
18809   // 1. one with the even values.
18810   // 2. one with the odd values.
18811   // To achieve #2, with need to place the odd values at an even position.
18812   //
18813   // Place the odd value at an even position (basically, shift all values 1
18814   // step to the left):
18815   const int Mask[] = {1, -1, 3, -1, 5, -1, 7, -1};
18816   // <a|b|c|d> => <b|undef|d|undef>
18817   SDValue Odd0 = DAG.getVectorShuffle(VT, dl, Op0, Op0, Mask);
18818   // <e|f|g|h> => <f|undef|h|undef>
18819   SDValue Odd1 = DAG.getVectorShuffle(VT, dl, Op1, Op1, Mask);
18820
18821   // Emit two multiplies, one for the lower 2 ints and one for the higher 2
18822   // ints.
18823   MVT MulVT = VT == MVT::v4i32 ? MVT::v2i64 : MVT::v4i64;
18824   bool IsSigned = Op->getOpcode() == ISD::SMUL_LOHI;
18825   unsigned Opcode =
18826       (!IsSigned || !Subtarget->hasSSE41()) ? X86ISD::PMULUDQ : X86ISD::PMULDQ;
18827   // PMULUDQ <4 x i32> <a|b|c|d>, <4 x i32> <e|f|g|h>
18828   // => <2 x i64> <ae|cg>
18829   SDValue Mul1 = DAG.getNode(ISD::BITCAST, dl, VT,
18830                              DAG.getNode(Opcode, dl, MulVT, Op0, Op1));
18831   // PMULUDQ <4 x i32> <b|undef|d|undef>, <4 x i32> <f|undef|h|undef>
18832   // => <2 x i64> <bf|dh>
18833   SDValue Mul2 = DAG.getNode(ISD::BITCAST, dl, VT,
18834                              DAG.getNode(Opcode, dl, MulVT, Odd0, Odd1));
18835
18836   // Shuffle it back into the right order.
18837   SDValue Highs, Lows;
18838   if (VT == MVT::v8i32) {
18839     const int HighMask[] = {1, 9, 3, 11, 5, 13, 7, 15};
18840     Highs = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, HighMask);
18841     const int LowMask[] = {0, 8, 2, 10, 4, 12, 6, 14};
18842     Lows = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, LowMask);
18843   } else {
18844     const int HighMask[] = {1, 5, 3, 7};
18845     Highs = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, HighMask);
18846     const int LowMask[] = {0, 4, 2, 6};
18847     Lows = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, LowMask);
18848   }
18849
18850   // If we have a signed multiply but no PMULDQ fix up the high parts of a
18851   // unsigned multiply.
18852   if (IsSigned && !Subtarget->hasSSE41()) {
18853     SDValue ShAmt =
18854         DAG.getConstant(31, DAG.getTargetLoweringInfo().getShiftAmountTy(VT));
18855     SDValue T1 = DAG.getNode(ISD::AND, dl, VT,
18856                              DAG.getNode(ISD::SRA, dl, VT, Op0, ShAmt), Op1);
18857     SDValue T2 = DAG.getNode(ISD::AND, dl, VT,
18858                              DAG.getNode(ISD::SRA, dl, VT, Op1, ShAmt), Op0);
18859
18860     SDValue Fixup = DAG.getNode(ISD::ADD, dl, VT, T1, T2);
18861     Highs = DAG.getNode(ISD::SUB, dl, VT, Highs, Fixup);
18862   }
18863
18864   // The first result of MUL_LOHI is actually the low value, followed by the
18865   // high value.
18866   SDValue Ops[] = {Lows, Highs};
18867   return DAG.getMergeValues(Ops, dl);
18868 }
18869
18870 static SDValue LowerScalarImmediateShift(SDValue Op, SelectionDAG &DAG,
18871                                          const X86Subtarget *Subtarget) {
18872   MVT VT = Op.getSimpleValueType();
18873   SDLoc dl(Op);
18874   SDValue R = Op.getOperand(0);
18875   SDValue Amt = Op.getOperand(1);
18876
18877   // Optimize shl/srl/sra with constant shift amount.
18878   if (auto *BVAmt = dyn_cast<BuildVectorSDNode>(Amt)) {
18879     if (auto *ShiftConst = BVAmt->getConstantSplatNode()) {
18880       uint64_t ShiftAmt = ShiftConst->getZExtValue();
18881
18882       if (VT == MVT::v2i64 || VT == MVT::v4i32 || VT == MVT::v8i16 ||
18883           (Subtarget->hasInt256() &&
18884            (VT == MVT::v4i64 || VT == MVT::v8i32 || VT == MVT::v16i16)) ||
18885           (Subtarget->hasAVX512() &&
18886            (VT == MVT::v8i64 || VT == MVT::v16i32))) {
18887         if (Op.getOpcode() == ISD::SHL)
18888           return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
18889                                             DAG);
18890         if (Op.getOpcode() == ISD::SRL)
18891           return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
18892                                             DAG);
18893         if (Op.getOpcode() == ISD::SRA && VT != MVT::v2i64 && VT != MVT::v4i64)
18894           return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
18895                                             DAG);
18896       }
18897
18898       if (VT == MVT::v16i8) {
18899         if (Op.getOpcode() == ISD::SHL) {
18900           // Make a large shift.
18901           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl,
18902                                                    MVT::v8i16, R, ShiftAmt,
18903                                                    DAG);
18904           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
18905           // Zero out the rightmost bits.
18906           SmallVector<SDValue, 16> V(16,
18907                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
18908                                                      MVT::i8));
18909           return DAG.getNode(ISD::AND, dl, VT, SHL,
18910                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18911         }
18912         if (Op.getOpcode() == ISD::SRL) {
18913           // Make a large shift.
18914           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl,
18915                                                    MVT::v8i16, R, ShiftAmt,
18916                                                    DAG);
18917           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
18918           // Zero out the leftmost bits.
18919           SmallVector<SDValue, 16> V(16,
18920                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
18921                                                      MVT::i8));
18922           return DAG.getNode(ISD::AND, dl, VT, SRL,
18923                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18924         }
18925         if (Op.getOpcode() == ISD::SRA) {
18926           if (ShiftAmt == 7) {
18927             // R s>> 7  ===  R s< 0
18928             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
18929             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
18930           }
18931
18932           // R s>> a === ((R u>> a) ^ m) - m
18933           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
18934           SmallVector<SDValue, 16> V(16, DAG.getConstant(128 >> ShiftAmt,
18935                                                          MVT::i8));
18936           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
18937           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
18938           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
18939           return Res;
18940         }
18941         llvm_unreachable("Unknown shift opcode.");
18942       }
18943
18944       if (Subtarget->hasInt256() && VT == MVT::v32i8) {
18945         if (Op.getOpcode() == ISD::SHL) {
18946           // Make a large shift.
18947           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl,
18948                                                    MVT::v16i16, R, ShiftAmt,
18949                                                    DAG);
18950           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
18951           // Zero out the rightmost bits.
18952           SmallVector<SDValue, 32> V(32,
18953                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
18954                                                      MVT::i8));
18955           return DAG.getNode(ISD::AND, dl, VT, SHL,
18956                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18957         }
18958         if (Op.getOpcode() == ISD::SRL) {
18959           // Make a large shift.
18960           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl,
18961                                                    MVT::v16i16, R, ShiftAmt,
18962                                                    DAG);
18963           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
18964           // Zero out the leftmost bits.
18965           SmallVector<SDValue, 32> V(32,
18966                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
18967                                                      MVT::i8));
18968           return DAG.getNode(ISD::AND, dl, VT, SRL,
18969                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18970         }
18971         if (Op.getOpcode() == ISD::SRA) {
18972           if (ShiftAmt == 7) {
18973             // R s>> 7  ===  R s< 0
18974             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
18975             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
18976           }
18977
18978           // R s>> a === ((R u>> a) ^ m) - m
18979           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
18980           SmallVector<SDValue, 32> V(32, DAG.getConstant(128 >> ShiftAmt,
18981                                                          MVT::i8));
18982           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
18983           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
18984           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
18985           return Res;
18986         }
18987         llvm_unreachable("Unknown shift opcode.");
18988       }
18989     }
18990   }
18991
18992   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
18993   if (!Subtarget->is64Bit() &&
18994       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64)) &&
18995       Amt.getOpcode() == ISD::BITCAST &&
18996       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
18997     Amt = Amt.getOperand(0);
18998     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
18999                      VT.getVectorNumElements();
19000     unsigned RatioInLog2 = Log2_32_Ceil(Ratio);
19001     uint64_t ShiftAmt = 0;
19002     for (unsigned i = 0; i != Ratio; ++i) {
19003       ConstantSDNode *C = dyn_cast<ConstantSDNode>(Amt.getOperand(i));
19004       if (!C)
19005         return SDValue();
19006       // 6 == Log2(64)
19007       ShiftAmt |= C->getZExtValue() << (i * (1 << (6 - RatioInLog2)));
19008     }
19009     // Check remaining shift amounts.
19010     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
19011       uint64_t ShAmt = 0;
19012       for (unsigned j = 0; j != Ratio; ++j) {
19013         ConstantSDNode *C =
19014           dyn_cast<ConstantSDNode>(Amt.getOperand(i + j));
19015         if (!C)
19016           return SDValue();
19017         // 6 == Log2(64)
19018         ShAmt |= C->getZExtValue() << (j * (1 << (6 - RatioInLog2)));
19019       }
19020       if (ShAmt != ShiftAmt)
19021         return SDValue();
19022     }
19023     switch (Op.getOpcode()) {
19024     default:
19025       llvm_unreachable("Unknown shift opcode!");
19026     case ISD::SHL:
19027       return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
19028                                         DAG);
19029     case ISD::SRL:
19030       return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
19031                                         DAG);
19032     case ISD::SRA:
19033       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
19034                                         DAG);
19035     }
19036   }
19037
19038   return SDValue();
19039 }
19040
19041 static SDValue LowerScalarVariableShift(SDValue Op, SelectionDAG &DAG,
19042                                         const X86Subtarget* Subtarget) {
19043   MVT VT = Op.getSimpleValueType();
19044   SDLoc dl(Op);
19045   SDValue R = Op.getOperand(0);
19046   SDValue Amt = Op.getOperand(1);
19047
19048   if ((VT == MVT::v2i64 && Op.getOpcode() != ISD::SRA) ||
19049       VT == MVT::v4i32 || VT == MVT::v8i16 ||
19050       (Subtarget->hasInt256() &&
19051        ((VT == MVT::v4i64 && Op.getOpcode() != ISD::SRA) ||
19052         VT == MVT::v8i32 || VT == MVT::v16i16)) ||
19053        (Subtarget->hasAVX512() && (VT == MVT::v8i64 || VT == MVT::v16i32))) {
19054     SDValue BaseShAmt;
19055     EVT EltVT = VT.getVectorElementType();
19056
19057     if (BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Amt)) {
19058       // Check if this build_vector node is doing a splat.
19059       // If so, then set BaseShAmt equal to the splat value.
19060       BaseShAmt = BV->getSplatValue();
19061       if (BaseShAmt && BaseShAmt.getOpcode() == ISD::UNDEF)
19062         BaseShAmt = SDValue();
19063     } else {
19064       if (Amt.getOpcode() == ISD::EXTRACT_SUBVECTOR)
19065         Amt = Amt.getOperand(0);
19066
19067       ShuffleVectorSDNode *SVN = dyn_cast<ShuffleVectorSDNode>(Amt);
19068       if (SVN && SVN->isSplat()) {
19069         unsigned SplatIdx = (unsigned)SVN->getSplatIndex();
19070         SDValue InVec = Amt.getOperand(0);
19071         if (InVec.getOpcode() == ISD::BUILD_VECTOR) {
19072           assert((SplatIdx < InVec.getValueType().getVectorNumElements()) &&
19073                  "Unexpected shuffle index found!");
19074           BaseShAmt = InVec.getOperand(SplatIdx);
19075         } else if (InVec.getOpcode() == ISD::INSERT_VECTOR_ELT) {
19076            if (ConstantSDNode *C =
19077                dyn_cast<ConstantSDNode>(InVec.getOperand(2))) {
19078              if (C->getZExtValue() == SplatIdx)
19079                BaseShAmt = InVec.getOperand(1);
19080            }
19081         }
19082
19083         if (!BaseShAmt)
19084           // Avoid introducing an extract element from a shuffle.
19085           BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InVec,
19086                                     DAG.getIntPtrConstant(SplatIdx));
19087       }
19088     }
19089
19090     if (BaseShAmt.getNode()) {
19091       assert(EltVT.bitsLE(MVT::i64) && "Unexpected element type!");
19092       if (EltVT != MVT::i64 && EltVT.bitsGT(MVT::i32))
19093         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, BaseShAmt);
19094       else if (EltVT.bitsLT(MVT::i32))
19095         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
19096
19097       switch (Op.getOpcode()) {
19098       default:
19099         llvm_unreachable("Unknown shift opcode!");
19100       case ISD::SHL:
19101         switch (VT.SimpleTy) {
19102         default: return SDValue();
19103         case MVT::v2i64:
19104         case MVT::v4i32:
19105         case MVT::v8i16:
19106         case MVT::v4i64:
19107         case MVT::v8i32:
19108         case MVT::v16i16:
19109         case MVT::v16i32:
19110         case MVT::v8i64:
19111           return getTargetVShiftNode(X86ISD::VSHLI, dl, VT, R, BaseShAmt, DAG);
19112         }
19113       case ISD::SRA:
19114         switch (VT.SimpleTy) {
19115         default: return SDValue();
19116         case MVT::v4i32:
19117         case MVT::v8i16:
19118         case MVT::v8i32:
19119         case MVT::v16i16:
19120         case MVT::v16i32:
19121         case MVT::v8i64:
19122           return getTargetVShiftNode(X86ISD::VSRAI, dl, VT, R, BaseShAmt, DAG);
19123         }
19124       case ISD::SRL:
19125         switch (VT.SimpleTy) {
19126         default: return SDValue();
19127         case MVT::v2i64:
19128         case MVT::v4i32:
19129         case MVT::v8i16:
19130         case MVT::v4i64:
19131         case MVT::v8i32:
19132         case MVT::v16i16:
19133         case MVT::v16i32:
19134         case MVT::v8i64:
19135           return getTargetVShiftNode(X86ISD::VSRLI, dl, VT, R, BaseShAmt, DAG);
19136         }
19137       }
19138     }
19139   }
19140
19141   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
19142   if (!Subtarget->is64Bit() &&
19143       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64) ||
19144       (Subtarget->hasAVX512() && VT == MVT::v8i64)) &&
19145       Amt.getOpcode() == ISD::BITCAST &&
19146       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
19147     Amt = Amt.getOperand(0);
19148     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
19149                      VT.getVectorNumElements();
19150     std::vector<SDValue> Vals(Ratio);
19151     for (unsigned i = 0; i != Ratio; ++i)
19152       Vals[i] = Amt.getOperand(i);
19153     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
19154       for (unsigned j = 0; j != Ratio; ++j)
19155         if (Vals[j] != Amt.getOperand(i + j))
19156           return SDValue();
19157     }
19158     switch (Op.getOpcode()) {
19159     default:
19160       llvm_unreachable("Unknown shift opcode!");
19161     case ISD::SHL:
19162       return DAG.getNode(X86ISD::VSHL, dl, VT, R, Op.getOperand(1));
19163     case ISD::SRL:
19164       return DAG.getNode(X86ISD::VSRL, dl, VT, R, Op.getOperand(1));
19165     case ISD::SRA:
19166       return DAG.getNode(X86ISD::VSRA, dl, VT, R, Op.getOperand(1));
19167     }
19168   }
19169
19170   return SDValue();
19171 }
19172
19173 static SDValue LowerShift(SDValue Op, const X86Subtarget* Subtarget,
19174                           SelectionDAG &DAG) {
19175   MVT VT = Op.getSimpleValueType();
19176   SDLoc dl(Op);
19177   SDValue R = Op.getOperand(0);
19178   SDValue Amt = Op.getOperand(1);
19179   SDValue V;
19180
19181   assert(VT.isVector() && "Custom lowering only for vector shifts!");
19182   assert(Subtarget->hasSSE2() && "Only custom lower when we have SSE2!");
19183
19184   V = LowerScalarImmediateShift(Op, DAG, Subtarget);
19185   if (V.getNode())
19186     return V;
19187
19188   V = LowerScalarVariableShift(Op, DAG, Subtarget);
19189   if (V.getNode())
19190       return V;
19191
19192   if (Subtarget->hasAVX512() && (VT == MVT::v16i32 || VT == MVT::v8i64))
19193     return Op;
19194   // AVX2 has VPSLLV/VPSRAV/VPSRLV.
19195   if (Subtarget->hasInt256()) {
19196     if (Op.getOpcode() == ISD::SRL &&
19197         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
19198          VT == MVT::v4i64 || VT == MVT::v8i32))
19199       return Op;
19200     if (Op.getOpcode() == ISD::SHL &&
19201         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
19202          VT == MVT::v4i64 || VT == MVT::v8i32))
19203       return Op;
19204     if (Op.getOpcode() == ISD::SRA && (VT == MVT::v4i32 || VT == MVT::v8i32))
19205       return Op;
19206   }
19207
19208   // If possible, lower this packed shift into a vector multiply instead of
19209   // expanding it into a sequence of scalar shifts.
19210   // Do this only if the vector shift count is a constant build_vector.
19211   if (Op.getOpcode() == ISD::SHL &&
19212       (VT == MVT::v8i16 || VT == MVT::v4i32 ||
19213        (Subtarget->hasInt256() && VT == MVT::v16i16)) &&
19214       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
19215     SmallVector<SDValue, 8> Elts;
19216     EVT SVT = VT.getScalarType();
19217     unsigned SVTBits = SVT.getSizeInBits();
19218     const APInt &One = APInt(SVTBits, 1);
19219     unsigned NumElems = VT.getVectorNumElements();
19220
19221     for (unsigned i=0; i !=NumElems; ++i) {
19222       SDValue Op = Amt->getOperand(i);
19223       if (Op->getOpcode() == ISD::UNDEF) {
19224         Elts.push_back(Op);
19225         continue;
19226       }
19227
19228       ConstantSDNode *ND = cast<ConstantSDNode>(Op);
19229       const APInt &C = APInt(SVTBits, ND->getAPIntValue().getZExtValue());
19230       uint64_t ShAmt = C.getZExtValue();
19231       if (ShAmt >= SVTBits) {
19232         Elts.push_back(DAG.getUNDEF(SVT));
19233         continue;
19234       }
19235       Elts.push_back(DAG.getConstant(One.shl(ShAmt), SVT));
19236     }
19237     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
19238     return DAG.getNode(ISD::MUL, dl, VT, R, BV);
19239   }
19240
19241   // Lower SHL with variable shift amount.
19242   if (VT == MVT::v4i32 && Op->getOpcode() == ISD::SHL) {
19243     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, VT));
19244
19245     Op = DAG.getNode(ISD::ADD, dl, VT, Op, DAG.getConstant(0x3f800000U, VT));
19246     Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
19247     Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
19248     return DAG.getNode(ISD::MUL, dl, VT, Op, R);
19249   }
19250
19251   // If possible, lower this shift as a sequence of two shifts by
19252   // constant plus a MOVSS/MOVSD instead of scalarizing it.
19253   // Example:
19254   //   (v4i32 (srl A, (build_vector < X, Y, Y, Y>)))
19255   //
19256   // Could be rewritten as:
19257   //   (v4i32 (MOVSS (srl A, <Y,Y,Y,Y>), (srl A, <X,X,X,X>)))
19258   //
19259   // The advantage is that the two shifts from the example would be
19260   // lowered as X86ISD::VSRLI nodes. This would be cheaper than scalarizing
19261   // the vector shift into four scalar shifts plus four pairs of vector
19262   // insert/extract.
19263   if ((VT == MVT::v8i16 || VT == MVT::v4i32) &&
19264       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
19265     unsigned TargetOpcode = X86ISD::MOVSS;
19266     bool CanBeSimplified;
19267     // The splat value for the first packed shift (the 'X' from the example).
19268     SDValue Amt1 = Amt->getOperand(0);
19269     // The splat value for the second packed shift (the 'Y' from the example).
19270     SDValue Amt2 = (VT == MVT::v4i32) ? Amt->getOperand(1) :
19271                                         Amt->getOperand(2);
19272
19273     // See if it is possible to replace this node with a sequence of
19274     // two shifts followed by a MOVSS/MOVSD
19275     if (VT == MVT::v4i32) {
19276       // Check if it is legal to use a MOVSS.
19277       CanBeSimplified = Amt2 == Amt->getOperand(2) &&
19278                         Amt2 == Amt->getOperand(3);
19279       if (!CanBeSimplified) {
19280         // Otherwise, check if we can still simplify this node using a MOVSD.
19281         CanBeSimplified = Amt1 == Amt->getOperand(1) &&
19282                           Amt->getOperand(2) == Amt->getOperand(3);
19283         TargetOpcode = X86ISD::MOVSD;
19284         Amt2 = Amt->getOperand(2);
19285       }
19286     } else {
19287       // Do similar checks for the case where the machine value type
19288       // is MVT::v8i16.
19289       CanBeSimplified = Amt1 == Amt->getOperand(1);
19290       for (unsigned i=3; i != 8 && CanBeSimplified; ++i)
19291         CanBeSimplified = Amt2 == Amt->getOperand(i);
19292
19293       if (!CanBeSimplified) {
19294         TargetOpcode = X86ISD::MOVSD;
19295         CanBeSimplified = true;
19296         Amt2 = Amt->getOperand(4);
19297         for (unsigned i=0; i != 4 && CanBeSimplified; ++i)
19298           CanBeSimplified = Amt1 == Amt->getOperand(i);
19299         for (unsigned j=4; j != 8 && CanBeSimplified; ++j)
19300           CanBeSimplified = Amt2 == Amt->getOperand(j);
19301       }
19302     }
19303
19304     if (CanBeSimplified && isa<ConstantSDNode>(Amt1) &&
19305         isa<ConstantSDNode>(Amt2)) {
19306       // Replace this node with two shifts followed by a MOVSS/MOVSD.
19307       EVT CastVT = MVT::v4i32;
19308       SDValue Splat1 =
19309         DAG.getConstant(cast<ConstantSDNode>(Amt1)->getAPIntValue(), VT);
19310       SDValue Shift1 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat1);
19311       SDValue Splat2 =
19312         DAG.getConstant(cast<ConstantSDNode>(Amt2)->getAPIntValue(), VT);
19313       SDValue Shift2 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat2);
19314       if (TargetOpcode == X86ISD::MOVSD)
19315         CastVT = MVT::v2i64;
19316       SDValue BitCast1 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift1);
19317       SDValue BitCast2 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift2);
19318       SDValue Result = getTargetShuffleNode(TargetOpcode, dl, CastVT, BitCast2,
19319                                             BitCast1, DAG);
19320       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
19321     }
19322   }
19323
19324   if (VT == MVT::v16i8 && Op->getOpcode() == ISD::SHL) {
19325     assert(Subtarget->hasSSE2() && "Need SSE2 for pslli/pcmpeq.");
19326
19327     // a = a << 5;
19328     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(5, VT));
19329     Op = DAG.getNode(ISD::BITCAST, dl, VT, Op);
19330
19331     // Turn 'a' into a mask suitable for VSELECT
19332     SDValue VSelM = DAG.getConstant(0x80, VT);
19333     SDValue OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
19334     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
19335
19336     SDValue CM1 = DAG.getConstant(0x0f, VT);
19337     SDValue CM2 = DAG.getConstant(0x3f, VT);
19338
19339     // r = VSELECT(r, psllw(r & (char16)15, 4), a);
19340     SDValue M = DAG.getNode(ISD::AND, dl, VT, R, CM1);
19341     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 4, DAG);
19342     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
19343     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
19344
19345     // a += a
19346     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
19347     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
19348     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
19349
19350     // r = VSELECT(r, psllw(r & (char16)63, 2), a);
19351     M = DAG.getNode(ISD::AND, dl, VT, R, CM2);
19352     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 2, DAG);
19353     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
19354     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
19355
19356     // a += a
19357     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
19358     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
19359     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
19360
19361     // return VSELECT(r, r+r, a);
19362     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel,
19363                     DAG.getNode(ISD::ADD, dl, VT, R, R), R);
19364     return R;
19365   }
19366
19367   // It's worth extending once and using the v8i32 shifts for 16-bit types, but
19368   // the extra overheads to get from v16i8 to v8i32 make the existing SSE
19369   // solution better.
19370   if (Subtarget->hasInt256() && VT == MVT::v8i16) {
19371     MVT NewVT = VT == MVT::v8i16 ? MVT::v8i32 : MVT::v16i16;
19372     unsigned ExtOpc =
19373         Op.getOpcode() == ISD::SRA ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
19374     R = DAG.getNode(ExtOpc, dl, NewVT, R);
19375     Amt = DAG.getNode(ISD::ANY_EXTEND, dl, NewVT, Amt);
19376     return DAG.getNode(ISD::TRUNCATE, dl, VT,
19377                        DAG.getNode(Op.getOpcode(), dl, NewVT, R, Amt));
19378     }
19379
19380   // Decompose 256-bit shifts into smaller 128-bit shifts.
19381   if (VT.is256BitVector()) {
19382     unsigned NumElems = VT.getVectorNumElements();
19383     MVT EltVT = VT.getVectorElementType();
19384     EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
19385
19386     // Extract the two vectors
19387     SDValue V1 = Extract128BitVector(R, 0, DAG, dl);
19388     SDValue V2 = Extract128BitVector(R, NumElems/2, DAG, dl);
19389
19390     // Recreate the shift amount vectors
19391     SDValue Amt1, Amt2;
19392     if (Amt.getOpcode() == ISD::BUILD_VECTOR) {
19393       // Constant shift amount
19394       SmallVector<SDValue, 4> Amt1Csts;
19395       SmallVector<SDValue, 4> Amt2Csts;
19396       for (unsigned i = 0; i != NumElems/2; ++i)
19397         Amt1Csts.push_back(Amt->getOperand(i));
19398       for (unsigned i = NumElems/2; i != NumElems; ++i)
19399         Amt2Csts.push_back(Amt->getOperand(i));
19400
19401       Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt1Csts);
19402       Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt2Csts);
19403     } else {
19404       // Variable shift amount
19405       Amt1 = Extract128BitVector(Amt, 0, DAG, dl);
19406       Amt2 = Extract128BitVector(Amt, NumElems/2, DAG, dl);
19407     }
19408
19409     // Issue new vector shifts for the smaller types
19410     V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
19411     V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
19412
19413     // Concatenate the result back
19414     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
19415   }
19416
19417   return SDValue();
19418 }
19419
19420 static SDValue LowerXALUO(SDValue Op, SelectionDAG &DAG) {
19421   // Lower the "add/sub/mul with overflow" instruction into a regular ins plus
19422   // a "setcc" instruction that checks the overflow flag. The "brcond" lowering
19423   // looks for this combo and may remove the "setcc" instruction if the "setcc"
19424   // has only one use.
19425   SDNode *N = Op.getNode();
19426   SDValue LHS = N->getOperand(0);
19427   SDValue RHS = N->getOperand(1);
19428   unsigned BaseOp = 0;
19429   unsigned Cond = 0;
19430   SDLoc DL(Op);
19431   switch (Op.getOpcode()) {
19432   default: llvm_unreachable("Unknown ovf instruction!");
19433   case ISD::SADDO:
19434     // A subtract of one will be selected as a INC. Note that INC doesn't
19435     // set CF, so we can't do this for UADDO.
19436     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
19437       if (C->isOne()) {
19438         BaseOp = X86ISD::INC;
19439         Cond = X86::COND_O;
19440         break;
19441       }
19442     BaseOp = X86ISD::ADD;
19443     Cond = X86::COND_O;
19444     break;
19445   case ISD::UADDO:
19446     BaseOp = X86ISD::ADD;
19447     Cond = X86::COND_B;
19448     break;
19449   case ISD::SSUBO:
19450     // A subtract of one will be selected as a DEC. Note that DEC doesn't
19451     // set CF, so we can't do this for USUBO.
19452     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
19453       if (C->isOne()) {
19454         BaseOp = X86ISD::DEC;
19455         Cond = X86::COND_O;
19456         break;
19457       }
19458     BaseOp = X86ISD::SUB;
19459     Cond = X86::COND_O;
19460     break;
19461   case ISD::USUBO:
19462     BaseOp = X86ISD::SUB;
19463     Cond = X86::COND_B;
19464     break;
19465   case ISD::SMULO:
19466     BaseOp = N->getValueType(0) == MVT::i8 ? X86ISD::SMUL8 : X86ISD::SMUL;
19467     Cond = X86::COND_O;
19468     break;
19469   case ISD::UMULO: { // i64, i8 = umulo lhs, rhs --> i64, i64, i32 umul lhs,rhs
19470     if (N->getValueType(0) == MVT::i8) {
19471       BaseOp = X86ISD::UMUL8;
19472       Cond = X86::COND_O;
19473       break;
19474     }
19475     SDVTList VTs = DAG.getVTList(N->getValueType(0), N->getValueType(0),
19476                                  MVT::i32);
19477     SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
19478
19479     SDValue SetCC =
19480       DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
19481                   DAG.getConstant(X86::COND_O, MVT::i32),
19482                   SDValue(Sum.getNode(), 2));
19483
19484     return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
19485   }
19486   }
19487
19488   // Also sets EFLAGS.
19489   SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::i32);
19490   SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
19491
19492   SDValue SetCC =
19493     DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
19494                 DAG.getConstant(Cond, MVT::i32),
19495                 SDValue(Sum.getNode(), 1));
19496
19497   return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
19498 }
19499
19500 // Sign extension of the low part of vector elements. This may be used either
19501 // when sign extend instructions are not available or if the vector element
19502 // sizes already match the sign-extended size. If the vector elements are in
19503 // their pre-extended size and sign extend instructions are available, that will
19504 // be handled by LowerSIGN_EXTEND.
19505 SDValue X86TargetLowering::LowerSIGN_EXTEND_INREG(SDValue Op,
19506                                                   SelectionDAG &DAG) const {
19507   SDLoc dl(Op);
19508   EVT ExtraVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
19509   MVT VT = Op.getSimpleValueType();
19510
19511   if (!Subtarget->hasSSE2() || !VT.isVector())
19512     return SDValue();
19513
19514   unsigned BitsDiff = VT.getScalarType().getSizeInBits() -
19515                       ExtraVT.getScalarType().getSizeInBits();
19516
19517   switch (VT.SimpleTy) {
19518     default: return SDValue();
19519     case MVT::v8i32:
19520     case MVT::v16i16:
19521       if (!Subtarget->hasFp256())
19522         return SDValue();
19523       if (!Subtarget->hasInt256()) {
19524         // needs to be split
19525         unsigned NumElems = VT.getVectorNumElements();
19526
19527         // Extract the LHS vectors
19528         SDValue LHS = Op.getOperand(0);
19529         SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
19530         SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
19531
19532         MVT EltVT = VT.getVectorElementType();
19533         EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
19534
19535         EVT ExtraEltVT = ExtraVT.getVectorElementType();
19536         unsigned ExtraNumElems = ExtraVT.getVectorNumElements();
19537         ExtraVT = EVT::getVectorVT(*DAG.getContext(), ExtraEltVT,
19538                                    ExtraNumElems/2);
19539         SDValue Extra = DAG.getValueType(ExtraVT);
19540
19541         LHS1 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, Extra);
19542         LHS2 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, Extra);
19543
19544         return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, LHS1, LHS2);
19545       }
19546       // fall through
19547     case MVT::v4i32:
19548     case MVT::v8i16: {
19549       SDValue Op0 = Op.getOperand(0);
19550
19551       // This is a sign extension of some low part of vector elements without
19552       // changing the size of the vector elements themselves:
19553       // Shift-Left + Shift-Right-Algebraic.
19554       SDValue Shl = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, Op0,
19555                                                BitsDiff, DAG);
19556       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, Shl, BitsDiff,
19557                                         DAG);
19558     }
19559   }
19560 }
19561
19562 /// Returns true if the operand type is exactly twice the native width, and
19563 /// the corresponding cmpxchg8b or cmpxchg16b instruction is available.
19564 /// Used to know whether to use cmpxchg8/16b when expanding atomic operations
19565 /// (otherwise we leave them alone to become __sync_fetch_and_... calls).
19566 bool X86TargetLowering::needsCmpXchgNb(const Type *MemType) const {
19567   unsigned OpWidth = MemType->getPrimitiveSizeInBits();
19568
19569   if (OpWidth == 64)
19570     return !Subtarget->is64Bit(); // FIXME this should be Subtarget.hasCmpxchg8b
19571   else if (OpWidth == 128)
19572     return Subtarget->hasCmpxchg16b();
19573   else
19574     return false;
19575 }
19576
19577 bool X86TargetLowering::shouldExpandAtomicStoreInIR(StoreInst *SI) const {
19578   return needsCmpXchgNb(SI->getValueOperand()->getType());
19579 }
19580
19581 // Note: this turns large loads into lock cmpxchg8b/16b.
19582 // FIXME: On 32 bits x86, fild/movq might be faster than lock cmpxchg8b.
19583 bool X86TargetLowering::shouldExpandAtomicLoadInIR(LoadInst *LI) const {
19584   auto PTy = cast<PointerType>(LI->getPointerOperand()->getType());
19585   return needsCmpXchgNb(PTy->getElementType());
19586 }
19587
19588 bool X86TargetLowering::shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const {
19589   unsigned NativeWidth = Subtarget->is64Bit() ? 64 : 32;
19590   const Type *MemType = AI->getType();
19591
19592   // If the operand is too big, we must see if cmpxchg8/16b is available
19593   // and default to library calls otherwise.
19594   if (MemType->getPrimitiveSizeInBits() > NativeWidth)
19595     return needsCmpXchgNb(MemType);
19596
19597   AtomicRMWInst::BinOp Op = AI->getOperation();
19598   switch (Op) {
19599   default:
19600     llvm_unreachable("Unknown atomic operation");
19601   case AtomicRMWInst::Xchg:
19602   case AtomicRMWInst::Add:
19603   case AtomicRMWInst::Sub:
19604     // It's better to use xadd, xsub or xchg for these in all cases.
19605     return false;
19606   case AtomicRMWInst::Or:
19607   case AtomicRMWInst::And:
19608   case AtomicRMWInst::Xor:
19609     // If the atomicrmw's result isn't actually used, we can just add a "lock"
19610     // prefix to a normal instruction for these operations.
19611     return !AI->use_empty();
19612   case AtomicRMWInst::Nand:
19613   case AtomicRMWInst::Max:
19614   case AtomicRMWInst::Min:
19615   case AtomicRMWInst::UMax:
19616   case AtomicRMWInst::UMin:
19617     // These always require a non-trivial set of data operations on x86. We must
19618     // use a cmpxchg loop.
19619     return true;
19620   }
19621 }
19622
19623 static bool hasMFENCE(const X86Subtarget& Subtarget) {
19624   // Use mfence if we have SSE2 or we're on x86-64 (even if we asked for
19625   // no-sse2). There isn't any reason to disable it if the target processor
19626   // supports it.
19627   return Subtarget.hasSSE2() || Subtarget.is64Bit();
19628 }
19629
19630 LoadInst *
19631 X86TargetLowering::lowerIdempotentRMWIntoFencedLoad(AtomicRMWInst *AI) const {
19632   unsigned NativeWidth = Subtarget->is64Bit() ? 64 : 32;
19633   const Type *MemType = AI->getType();
19634   // Accesses larger than the native width are turned into cmpxchg/libcalls, so
19635   // there is no benefit in turning such RMWs into loads, and it is actually
19636   // harmful as it introduces a mfence.
19637   if (MemType->getPrimitiveSizeInBits() > NativeWidth)
19638     return nullptr;
19639
19640   auto Builder = IRBuilder<>(AI);
19641   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
19642   auto SynchScope = AI->getSynchScope();
19643   // We must restrict the ordering to avoid generating loads with Release or
19644   // ReleaseAcquire orderings.
19645   auto Order = AtomicCmpXchgInst::getStrongestFailureOrdering(AI->getOrdering());
19646   auto Ptr = AI->getPointerOperand();
19647
19648   // Before the load we need a fence. Here is an example lifted from
19649   // http://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf showing why a fence
19650   // is required:
19651   // Thread 0:
19652   //   x.store(1, relaxed);
19653   //   r1 = y.fetch_add(0, release);
19654   // Thread 1:
19655   //   y.fetch_add(42, acquire);
19656   //   r2 = x.load(relaxed);
19657   // r1 = r2 = 0 is impossible, but becomes possible if the idempotent rmw is
19658   // lowered to just a load without a fence. A mfence flushes the store buffer,
19659   // making the optimization clearly correct.
19660   // FIXME: it is required if isAtLeastRelease(Order) but it is not clear
19661   // otherwise, we might be able to be more agressive on relaxed idempotent
19662   // rmw. In practice, they do not look useful, so we don't try to be
19663   // especially clever.
19664   if (SynchScope == SingleThread) {
19665     // FIXME: we could just insert an X86ISD::MEMBARRIER here, except we are at
19666     // the IR level, so we must wrap it in an intrinsic.
19667     return nullptr;
19668   } else if (hasMFENCE(*Subtarget)) {
19669     Function *MFence = llvm::Intrinsic::getDeclaration(M,
19670             Intrinsic::x86_sse2_mfence);
19671     Builder.CreateCall(MFence);
19672   } else {
19673     // FIXME: it might make sense to use a locked operation here but on a
19674     // different cache-line to prevent cache-line bouncing. In practice it
19675     // is probably a small win, and x86 processors without mfence are rare
19676     // enough that we do not bother.
19677     return nullptr;
19678   }
19679
19680   // Finally we can emit the atomic load.
19681   LoadInst *Loaded = Builder.CreateAlignedLoad(Ptr,
19682           AI->getType()->getPrimitiveSizeInBits());
19683   Loaded->setAtomic(Order, SynchScope);
19684   AI->replaceAllUsesWith(Loaded);
19685   AI->eraseFromParent();
19686   return Loaded;
19687 }
19688
19689 static SDValue LowerATOMIC_FENCE(SDValue Op, const X86Subtarget *Subtarget,
19690                                  SelectionDAG &DAG) {
19691   SDLoc dl(Op);
19692   AtomicOrdering FenceOrdering = static_cast<AtomicOrdering>(
19693     cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue());
19694   SynchronizationScope FenceScope = static_cast<SynchronizationScope>(
19695     cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue());
19696
19697   // The only fence that needs an instruction is a sequentially-consistent
19698   // cross-thread fence.
19699   if (FenceOrdering == SequentiallyConsistent && FenceScope == CrossThread) {
19700     if (hasMFENCE(*Subtarget))
19701       return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
19702
19703     SDValue Chain = Op.getOperand(0);
19704     SDValue Zero = DAG.getConstant(0, MVT::i32);
19705     SDValue Ops[] = {
19706       DAG.getRegister(X86::ESP, MVT::i32), // Base
19707       DAG.getTargetConstant(1, MVT::i8),   // Scale
19708       DAG.getRegister(0, MVT::i32),        // Index
19709       DAG.getTargetConstant(0, MVT::i32),  // Disp
19710       DAG.getRegister(0, MVT::i32),        // Segment.
19711       Zero,
19712       Chain
19713     };
19714     SDNode *Res = DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops);
19715     return SDValue(Res, 0);
19716   }
19717
19718   // MEMBARRIER is a compiler barrier; it codegens to a no-op.
19719   return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
19720 }
19721
19722 static SDValue LowerCMP_SWAP(SDValue Op, const X86Subtarget *Subtarget,
19723                              SelectionDAG &DAG) {
19724   MVT T = Op.getSimpleValueType();
19725   SDLoc DL(Op);
19726   unsigned Reg = 0;
19727   unsigned size = 0;
19728   switch(T.SimpleTy) {
19729   default: llvm_unreachable("Invalid value type!");
19730   case MVT::i8:  Reg = X86::AL;  size = 1; break;
19731   case MVT::i16: Reg = X86::AX;  size = 2; break;
19732   case MVT::i32: Reg = X86::EAX; size = 4; break;
19733   case MVT::i64:
19734     assert(Subtarget->is64Bit() && "Node not type legal!");
19735     Reg = X86::RAX; size = 8;
19736     break;
19737   }
19738   SDValue cpIn = DAG.getCopyToReg(Op.getOperand(0), DL, Reg,
19739                                   Op.getOperand(2), SDValue());
19740   SDValue Ops[] = { cpIn.getValue(0),
19741                     Op.getOperand(1),
19742                     Op.getOperand(3),
19743                     DAG.getTargetConstant(size, MVT::i8),
19744                     cpIn.getValue(1) };
19745   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
19746   MachineMemOperand *MMO = cast<AtomicSDNode>(Op)->getMemOperand();
19747   SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG_DAG, DL, Tys,
19748                                            Ops, T, MMO);
19749
19750   SDValue cpOut =
19751     DAG.getCopyFromReg(Result.getValue(0), DL, Reg, T, Result.getValue(1));
19752   SDValue EFLAGS = DAG.getCopyFromReg(cpOut.getValue(1), DL, X86::EFLAGS,
19753                                       MVT::i32, cpOut.getValue(2));
19754   SDValue Success = DAG.getNode(X86ISD::SETCC, DL, Op->getValueType(1),
19755                                 DAG.getConstant(X86::COND_E, MVT::i8), EFLAGS);
19756
19757   DAG.ReplaceAllUsesOfValueWith(Op.getValue(0), cpOut);
19758   DAG.ReplaceAllUsesOfValueWith(Op.getValue(1), Success);
19759   DAG.ReplaceAllUsesOfValueWith(Op.getValue(2), EFLAGS.getValue(1));
19760   return SDValue();
19761 }
19762
19763 static SDValue LowerBITCAST(SDValue Op, const X86Subtarget *Subtarget,
19764                             SelectionDAG &DAG) {
19765   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
19766   MVT DstVT = Op.getSimpleValueType();
19767
19768   if (SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 || SrcVT == MVT::v8i8) {
19769     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
19770     if (DstVT != MVT::f64)
19771       // This conversion needs to be expanded.
19772       return SDValue();
19773
19774     SDValue InVec = Op->getOperand(0);
19775     SDLoc dl(Op);
19776     unsigned NumElts = SrcVT.getVectorNumElements();
19777     EVT SVT = SrcVT.getVectorElementType();
19778
19779     // Widen the vector in input in the case of MVT::v2i32.
19780     // Example: from MVT::v2i32 to MVT::v4i32.
19781     SmallVector<SDValue, 16> Elts;
19782     for (unsigned i = 0, e = NumElts; i != e; ++i)
19783       Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT, InVec,
19784                                  DAG.getIntPtrConstant(i)));
19785
19786     // Explicitly mark the extra elements as Undef.
19787     Elts.append(NumElts, DAG.getUNDEF(SVT));
19788
19789     EVT NewVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumElts * 2);
19790     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Elts);
19791     SDValue ToV2F64 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, BV);
19792     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, ToV2F64,
19793                        DAG.getIntPtrConstant(0));
19794   }
19795
19796   assert(Subtarget->is64Bit() && !Subtarget->hasSSE2() &&
19797          Subtarget->hasMMX() && "Unexpected custom BITCAST");
19798   assert((DstVT == MVT::i64 ||
19799           (DstVT.isVector() && DstVT.getSizeInBits()==64)) &&
19800          "Unexpected custom BITCAST");
19801   // i64 <=> MMX conversions are Legal.
19802   if (SrcVT==MVT::i64 && DstVT.isVector())
19803     return Op;
19804   if (DstVT==MVT::i64 && SrcVT.isVector())
19805     return Op;
19806   // MMX <=> MMX conversions are Legal.
19807   if (SrcVT.isVector() && DstVT.isVector())
19808     return Op;
19809   // All other conversions need to be expanded.
19810   return SDValue();
19811 }
19812
19813 static SDValue LowerCTPOP(SDValue Op, const X86Subtarget *Subtarget,
19814                           SelectionDAG &DAG) {
19815   SDNode *Node = Op.getNode();
19816   SDLoc dl(Node);
19817
19818   Op = Op.getOperand(0);
19819   EVT VT = Op.getValueType();
19820   assert((VT.is128BitVector() || VT.is256BitVector()) &&
19821          "CTPOP lowering only implemented for 128/256-bit wide vector types");
19822
19823   unsigned NumElts = VT.getVectorNumElements();
19824   EVT EltVT = VT.getVectorElementType();
19825   unsigned Len = EltVT.getSizeInBits();
19826
19827   // This is the vectorized version of the "best" algorithm from
19828   // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
19829   // with a minor tweak to use a series of adds + shifts instead of vector
19830   // multiplications. Implemented for the v2i64, v4i64, v4i32, v8i32 types:
19831   //
19832   //  v2i64, v4i64, v4i32 => Only profitable w/ popcnt disabled
19833   //  v8i32 => Always profitable
19834   //
19835   // FIXME: There a couple of possible improvements:
19836   //
19837   // 1) Support for i8 and i16 vectors (needs measurements if popcnt enabled).
19838   // 2) Use strategies from http://wm.ite.pl/articles/sse-popcount.html
19839   //
19840   assert(EltVT.isInteger() && (Len == 32 || Len == 64) && Len % 8 == 0 &&
19841          "CTPOP not implemented for this vector element type.");
19842
19843   // X86 canonicalize ANDs to vXi64, generate the appropriate bitcasts to avoid
19844   // extra legalization.
19845   bool NeedsBitcast = EltVT == MVT::i32;
19846   MVT BitcastVT = VT.is256BitVector() ? MVT::v4i64 : MVT::v2i64;
19847
19848   SDValue Cst55 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x55)), EltVT);
19849   SDValue Cst33 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x33)), EltVT);
19850   SDValue Cst0F = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x0F)), EltVT);
19851
19852   // v = v - ((v >> 1) & 0x55555555...)
19853   SmallVector<SDValue, 8> Ones(NumElts, DAG.getConstant(1, EltVT));
19854   SDValue OnesV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ones);
19855   SDValue Srl = DAG.getNode(ISD::SRL, dl, VT, Op, OnesV);
19856   if (NeedsBitcast)
19857     Srl = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Srl);
19858
19859   SmallVector<SDValue, 8> Mask55(NumElts, Cst55);
19860   SDValue M55 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask55);
19861   if (NeedsBitcast)
19862     M55 = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M55);
19863
19864   SDValue And = DAG.getNode(ISD::AND, dl, Srl.getValueType(), Srl, M55);
19865   if (VT != And.getValueType())
19866     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19867   SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, Op, And);
19868
19869   // v = (v & 0x33333333...) + ((v >> 2) & 0x33333333...)
19870   SmallVector<SDValue, 8> Mask33(NumElts, Cst33);
19871   SDValue M33 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask33);
19872   SmallVector<SDValue, 8> Twos(NumElts, DAG.getConstant(2, EltVT));
19873   SDValue TwosV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Twos);
19874
19875   Srl = DAG.getNode(ISD::SRL, dl, VT, Sub, TwosV);
19876   if (NeedsBitcast) {
19877     Srl = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Srl);
19878     M33 = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M33);
19879     Sub = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Sub);
19880   }
19881
19882   SDValue AndRHS = DAG.getNode(ISD::AND, dl, M33.getValueType(), Srl, M33);
19883   SDValue AndLHS = DAG.getNode(ISD::AND, dl, M33.getValueType(), Sub, M33);
19884   if (VT != AndRHS.getValueType()) {
19885     AndRHS = DAG.getNode(ISD::BITCAST, dl, VT, AndRHS);
19886     AndLHS = DAG.getNode(ISD::BITCAST, dl, VT, AndLHS);
19887   }
19888   SDValue Add = DAG.getNode(ISD::ADD, dl, VT, AndLHS, AndRHS);
19889
19890   // v = (v + (v >> 4)) & 0x0F0F0F0F...
19891   SmallVector<SDValue, 8> Fours(NumElts, DAG.getConstant(4, EltVT));
19892   SDValue FoursV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Fours);
19893   Srl = DAG.getNode(ISD::SRL, dl, VT, Add, FoursV);
19894   Add = DAG.getNode(ISD::ADD, dl, VT, Add, Srl);
19895
19896   SmallVector<SDValue, 8> Mask0F(NumElts, Cst0F);
19897   SDValue M0F = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask0F);
19898   if (NeedsBitcast) {
19899     Add = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Add);
19900     M0F = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M0F);
19901   }
19902   And = DAG.getNode(ISD::AND, dl, M0F.getValueType(), Add, M0F);
19903   if (VT != And.getValueType())
19904     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19905
19906   // The algorithm mentioned above uses:
19907   //    v = (v * 0x01010101...) >> (Len - 8)
19908   //
19909   // Change it to use vector adds + vector shifts which yield faster results on
19910   // Haswell than using vector integer multiplication.
19911   //
19912   // For i32 elements:
19913   //    v = v + (v >> 8)
19914   //    v = v + (v >> 16)
19915   //
19916   // For i64 elements:
19917   //    v = v + (v >> 8)
19918   //    v = v + (v >> 16)
19919   //    v = v + (v >> 32)
19920   //
19921   Add = And;
19922   SmallVector<SDValue, 8> Csts;
19923   for (unsigned i = 8; i <= Len/2; i *= 2) {
19924     Csts.assign(NumElts, DAG.getConstant(i, EltVT));
19925     SDValue CstsV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Csts);
19926     Srl = DAG.getNode(ISD::SRL, dl, VT, Add, CstsV);
19927     Add = DAG.getNode(ISD::ADD, dl, VT, Add, Srl);
19928     Csts.clear();
19929   }
19930
19931   // The result is on the least significant 6-bits on i32 and 7-bits on i64.
19932   SDValue Cst3F = DAG.getConstant(APInt(Len, Len == 32 ? 0x3F : 0x7F), EltVT);
19933   SmallVector<SDValue, 8> Cst3FV(NumElts, Cst3F);
19934   SDValue M3F = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Cst3FV);
19935   if (NeedsBitcast) {
19936     Add = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Add);
19937     M3F = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M3F);
19938   }
19939   And = DAG.getNode(ISD::AND, dl, M3F.getValueType(), Add, M3F);
19940   if (VT != And.getValueType())
19941     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19942
19943   return And;
19944 }
19945
19946 static SDValue LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) {
19947   SDNode *Node = Op.getNode();
19948   SDLoc dl(Node);
19949   EVT T = Node->getValueType(0);
19950   SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
19951                               DAG.getConstant(0, T), Node->getOperand(2));
19952   return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, dl,
19953                        cast<AtomicSDNode>(Node)->getMemoryVT(),
19954                        Node->getOperand(0),
19955                        Node->getOperand(1), negOp,
19956                        cast<AtomicSDNode>(Node)->getMemOperand(),
19957                        cast<AtomicSDNode>(Node)->getOrdering(),
19958                        cast<AtomicSDNode>(Node)->getSynchScope());
19959 }
19960
19961 static SDValue LowerATOMIC_STORE(SDValue Op, SelectionDAG &DAG) {
19962   SDNode *Node = Op.getNode();
19963   SDLoc dl(Node);
19964   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
19965
19966   // Convert seq_cst store -> xchg
19967   // Convert wide store -> swap (-> cmpxchg8b/cmpxchg16b)
19968   // FIXME: On 32-bit, store -> fist or movq would be more efficient
19969   //        (The only way to get a 16-byte store is cmpxchg16b)
19970   // FIXME: 16-byte ATOMIC_SWAP isn't actually hooked up at the moment.
19971   if (cast<AtomicSDNode>(Node)->getOrdering() == SequentiallyConsistent ||
19972       !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
19973     SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
19974                                  cast<AtomicSDNode>(Node)->getMemoryVT(),
19975                                  Node->getOperand(0),
19976                                  Node->getOperand(1), Node->getOperand(2),
19977                                  cast<AtomicSDNode>(Node)->getMemOperand(),
19978                                  cast<AtomicSDNode>(Node)->getOrdering(),
19979                                  cast<AtomicSDNode>(Node)->getSynchScope());
19980     return Swap.getValue(1);
19981   }
19982   // Other atomic stores have a simple pattern.
19983   return Op;
19984 }
19985
19986 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
19987   EVT VT = Op.getNode()->getSimpleValueType(0);
19988
19989   // Let legalize expand this if it isn't a legal type yet.
19990   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
19991     return SDValue();
19992
19993   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
19994
19995   unsigned Opc;
19996   bool ExtraOp = false;
19997   switch (Op.getOpcode()) {
19998   default: llvm_unreachable("Invalid code");
19999   case ISD::ADDC: Opc = X86ISD::ADD; break;
20000   case ISD::ADDE: Opc = X86ISD::ADC; ExtraOp = true; break;
20001   case ISD::SUBC: Opc = X86ISD::SUB; break;
20002   case ISD::SUBE: Opc = X86ISD::SBB; ExtraOp = true; break;
20003   }
20004
20005   if (!ExtraOp)
20006     return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
20007                        Op.getOperand(1));
20008   return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
20009                      Op.getOperand(1), Op.getOperand(2));
20010 }
20011
20012 static SDValue LowerFSINCOS(SDValue Op, const X86Subtarget *Subtarget,
20013                             SelectionDAG &DAG) {
20014   assert(Subtarget->isTargetDarwin() && Subtarget->is64Bit());
20015
20016   // For MacOSX, we want to call an alternative entry point: __sincos_stret,
20017   // which returns the values as { float, float } (in XMM0) or
20018   // { double, double } (which is returned in XMM0, XMM1).
20019   SDLoc dl(Op);
20020   SDValue Arg = Op.getOperand(0);
20021   EVT ArgVT = Arg.getValueType();
20022   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
20023
20024   TargetLowering::ArgListTy Args;
20025   TargetLowering::ArgListEntry Entry;
20026
20027   Entry.Node = Arg;
20028   Entry.Ty = ArgTy;
20029   Entry.isSExt = false;
20030   Entry.isZExt = false;
20031   Args.push_back(Entry);
20032
20033   bool isF64 = ArgVT == MVT::f64;
20034   // Only optimize x86_64 for now. i386 is a bit messy. For f32,
20035   // the small struct {f32, f32} is returned in (eax, edx). For f64,
20036   // the results are returned via SRet in memory.
20037   const char *LibcallName =  isF64 ? "__sincos_stret" : "__sincosf_stret";
20038   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20039   SDValue Callee = DAG.getExternalSymbol(LibcallName, TLI.getPointerTy());
20040
20041   Type *RetTy = isF64
20042     ? (Type*)StructType::get(ArgTy, ArgTy, nullptr)
20043     : (Type*)VectorType::get(ArgTy, 4);
20044
20045   TargetLowering::CallLoweringInfo CLI(DAG);
20046   CLI.setDebugLoc(dl).setChain(DAG.getEntryNode())
20047     .setCallee(CallingConv::C, RetTy, Callee, std::move(Args), 0);
20048
20049   std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
20050
20051   if (isF64)
20052     // Returned in xmm0 and xmm1.
20053     return CallResult.first;
20054
20055   // Returned in bits 0:31 and 32:64 xmm0.
20056   SDValue SinVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
20057                                CallResult.first, DAG.getIntPtrConstant(0));
20058   SDValue CosVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
20059                                CallResult.first, DAG.getIntPtrConstant(1));
20060   SDVTList Tys = DAG.getVTList(ArgVT, ArgVT);
20061   return DAG.getNode(ISD::MERGE_VALUES, dl, Tys, SinVal, CosVal);
20062 }
20063
20064 /// LowerOperation - Provide custom lowering hooks for some operations.
20065 ///
20066 SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
20067   switch (Op.getOpcode()) {
20068   default: llvm_unreachable("Should not custom lower this!");
20069   case ISD::SIGN_EXTEND_INREG:  return LowerSIGN_EXTEND_INREG(Op,DAG);
20070   case ISD::ATOMIC_FENCE:       return LowerATOMIC_FENCE(Op, Subtarget, DAG);
20071   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS:
20072     return LowerCMP_SWAP(Op, Subtarget, DAG);
20073   case ISD::CTPOP:              return LowerCTPOP(Op, Subtarget, DAG);
20074   case ISD::ATOMIC_LOAD_SUB:    return LowerLOAD_SUB(Op,DAG);
20075   case ISD::ATOMIC_STORE:       return LowerATOMIC_STORE(Op,DAG);
20076   case ISD::BUILD_VECTOR:       return LowerBUILD_VECTOR(Op, DAG);
20077   case ISD::CONCAT_VECTORS:     return LowerCONCAT_VECTORS(Op, DAG);
20078   case ISD::VECTOR_SHUFFLE:     return LowerVECTOR_SHUFFLE(Op, DAG);
20079   case ISD::VSELECT:            return LowerVSELECT(Op, DAG);
20080   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
20081   case ISD::INSERT_VECTOR_ELT:  return LowerINSERT_VECTOR_ELT(Op, DAG);
20082   case ISD::EXTRACT_SUBVECTOR:  return LowerEXTRACT_SUBVECTOR(Op,Subtarget,DAG);
20083   case ISD::INSERT_SUBVECTOR:   return LowerINSERT_SUBVECTOR(Op, Subtarget,DAG);
20084   case ISD::SCALAR_TO_VECTOR:   return LowerSCALAR_TO_VECTOR(Op, DAG);
20085   case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
20086   case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
20087   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
20088   case ISD::ExternalSymbol:     return LowerExternalSymbol(Op, DAG);
20089   case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
20090   case ISD::SHL_PARTS:
20091   case ISD::SRA_PARTS:
20092   case ISD::SRL_PARTS:          return LowerShiftParts(Op, DAG);
20093   case ISD::SINT_TO_FP:         return LowerSINT_TO_FP(Op, DAG);
20094   case ISD::UINT_TO_FP:         return LowerUINT_TO_FP(Op, DAG);
20095   case ISD::TRUNCATE:           return LowerTRUNCATE(Op, DAG);
20096   case ISD::ZERO_EXTEND:        return LowerZERO_EXTEND(Op, Subtarget, DAG);
20097   case ISD::SIGN_EXTEND:        return LowerSIGN_EXTEND(Op, Subtarget, DAG);
20098   case ISD::ANY_EXTEND:         return LowerANY_EXTEND(Op, Subtarget, DAG);
20099   case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
20100   case ISD::FP_TO_UINT:         return LowerFP_TO_UINT(Op, DAG);
20101   case ISD::FP_EXTEND:          return LowerFP_EXTEND(Op, DAG);
20102   case ISD::LOAD:               return LowerExtendedLoad(Op, Subtarget, DAG);
20103   case ISD::FABS:
20104   case ISD::FNEG:               return LowerFABSorFNEG(Op, DAG);
20105   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
20106   case ISD::FGETSIGN:           return LowerFGETSIGN(Op, DAG);
20107   case ISD::SETCC:              return LowerSETCC(Op, DAG);
20108   case ISD::SELECT:             return LowerSELECT(Op, DAG);
20109   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
20110   case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
20111   case ISD::VASTART:            return LowerVASTART(Op, DAG);
20112   case ISD::VAARG:              return LowerVAARG(Op, DAG);
20113   case ISD::VACOPY:             return LowerVACOPY(Op, Subtarget, DAG);
20114   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, Subtarget, DAG);
20115   case ISD::INTRINSIC_VOID:
20116   case ISD::INTRINSIC_W_CHAIN:  return LowerINTRINSIC_W_CHAIN(Op, Subtarget, DAG);
20117   case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
20118   case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
20119   case ISD::FRAME_TO_ARGS_OFFSET:
20120                                 return LowerFRAME_TO_ARGS_OFFSET(Op, DAG);
20121   case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
20122   case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
20123   case ISD::EH_SJLJ_SETJMP:     return lowerEH_SJLJ_SETJMP(Op, DAG);
20124   case ISD::EH_SJLJ_LONGJMP:    return lowerEH_SJLJ_LONGJMP(Op, DAG);
20125   case ISD::INIT_TRAMPOLINE:    return LowerINIT_TRAMPOLINE(Op, DAG);
20126   case ISD::ADJUST_TRAMPOLINE:  return LowerADJUST_TRAMPOLINE(Op, DAG);
20127   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
20128   case ISD::CTLZ:               return LowerCTLZ(Op, DAG);
20129   case ISD::CTLZ_ZERO_UNDEF:    return LowerCTLZ_ZERO_UNDEF(Op, DAG);
20130   case ISD::CTTZ:               return LowerCTTZ(Op, DAG);
20131   case ISD::MUL:                return LowerMUL(Op, Subtarget, DAG);
20132   case ISD::UMUL_LOHI:
20133   case ISD::SMUL_LOHI:          return LowerMUL_LOHI(Op, Subtarget, DAG);
20134   case ISD::SRA:
20135   case ISD::SRL:
20136   case ISD::SHL:                return LowerShift(Op, Subtarget, DAG);
20137   case ISD::SADDO:
20138   case ISD::UADDO:
20139   case ISD::SSUBO:
20140   case ISD::USUBO:
20141   case ISD::SMULO:
20142   case ISD::UMULO:              return LowerXALUO(Op, DAG);
20143   case ISD::READCYCLECOUNTER:   return LowerREADCYCLECOUNTER(Op, Subtarget,DAG);
20144   case ISD::BITCAST:            return LowerBITCAST(Op, Subtarget, DAG);
20145   case ISD::ADDC:
20146   case ISD::ADDE:
20147   case ISD::SUBC:
20148   case ISD::SUBE:               return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
20149   case ISD::ADD:                return LowerADD(Op, DAG);
20150   case ISD::SUB:                return LowerSUB(Op, DAG);
20151   case ISD::FSINCOS:            return LowerFSINCOS(Op, Subtarget, DAG);
20152   }
20153 }
20154
20155 /// ReplaceNodeResults - Replace a node with an illegal result type
20156 /// with a new node built out of custom code.
20157 void X86TargetLowering::ReplaceNodeResults(SDNode *N,
20158                                            SmallVectorImpl<SDValue>&Results,
20159                                            SelectionDAG &DAG) const {
20160   SDLoc dl(N);
20161   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20162   switch (N->getOpcode()) {
20163   default:
20164     llvm_unreachable("Do not know how to custom type legalize this operation!");
20165   // We might have generated v2f32 FMIN/FMAX operations. Widen them to v4f32.
20166   case X86ISD::FMINC:
20167   case X86ISD::FMIN:
20168   case X86ISD::FMAXC:
20169   case X86ISD::FMAX: {
20170     EVT VT = N->getValueType(0);
20171     if (VT != MVT::v2f32)
20172       llvm_unreachable("Unexpected type (!= v2f32) on FMIN/FMAX.");
20173     SDValue UNDEF = DAG.getUNDEF(VT);
20174     SDValue LHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
20175                               N->getOperand(0), UNDEF);
20176     SDValue RHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
20177                               N->getOperand(1), UNDEF);
20178     Results.push_back(DAG.getNode(N->getOpcode(), dl, MVT::v4f32, LHS, RHS));
20179     return;
20180   }
20181   case ISD::SIGN_EXTEND_INREG:
20182   case ISD::ADDC:
20183   case ISD::ADDE:
20184   case ISD::SUBC:
20185   case ISD::SUBE:
20186     // We don't want to expand or promote these.
20187     return;
20188   case ISD::SDIV:
20189   case ISD::UDIV:
20190   case ISD::SREM:
20191   case ISD::UREM:
20192   case ISD::SDIVREM:
20193   case ISD::UDIVREM: {
20194     SDValue V = LowerWin64_i128OP(SDValue(N,0), DAG);
20195     Results.push_back(V);
20196     return;
20197   }
20198   case ISD::FP_TO_SINT:
20199   case ISD::FP_TO_UINT: {
20200     bool IsSigned = N->getOpcode() == ISD::FP_TO_SINT;
20201
20202     if (!IsSigned && !isIntegerTypeFTOL(SDValue(N, 0).getValueType()))
20203       return;
20204
20205     std::pair<SDValue,SDValue> Vals =
20206         FP_TO_INTHelper(SDValue(N, 0), DAG, IsSigned, /*IsReplace=*/ true);
20207     SDValue FIST = Vals.first, StackSlot = Vals.second;
20208     if (FIST.getNode()) {
20209       EVT VT = N->getValueType(0);
20210       // Return a load from the stack slot.
20211       if (StackSlot.getNode())
20212         Results.push_back(DAG.getLoad(VT, dl, FIST, StackSlot,
20213                                       MachinePointerInfo(),
20214                                       false, false, false, 0));
20215       else
20216         Results.push_back(FIST);
20217     }
20218     return;
20219   }
20220   case ISD::UINT_TO_FP: {
20221     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
20222     if (N->getOperand(0).getValueType() != MVT::v2i32 ||
20223         N->getValueType(0) != MVT::v2f32)
20224       return;
20225     SDValue ZExtIn = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v2i64,
20226                                  N->getOperand(0));
20227     SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
20228                                      MVT::f64);
20229     SDValue VBias = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2f64, Bias, Bias);
20230     SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64, ZExtIn,
20231                              DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, VBias));
20232     Or = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or);
20233     SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, Or, VBias);
20234     Results.push_back(DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, Sub));
20235     return;
20236   }
20237   case ISD::FP_ROUND: {
20238     if (!TLI.isTypeLegal(N->getOperand(0).getValueType()))
20239         return;
20240     SDValue V = DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, N->getOperand(0));
20241     Results.push_back(V);
20242     return;
20243   }
20244   case ISD::INTRINSIC_W_CHAIN: {
20245     unsigned IntNo = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue();
20246     switch (IntNo) {
20247     default : llvm_unreachable("Do not know how to custom type "
20248                                "legalize this intrinsic operation!");
20249     case Intrinsic::x86_rdtsc:
20250       return getReadTimeStampCounter(N, dl, X86ISD::RDTSC_DAG, DAG, Subtarget,
20251                                      Results);
20252     case Intrinsic::x86_rdtscp:
20253       return getReadTimeStampCounter(N, dl, X86ISD::RDTSCP_DAG, DAG, Subtarget,
20254                                      Results);
20255     case Intrinsic::x86_rdpmc:
20256       return getReadPerformanceCounter(N, dl, DAG, Subtarget, Results);
20257     }
20258   }
20259   case ISD::READCYCLECOUNTER: {
20260     return getReadTimeStampCounter(N, dl, X86ISD::RDTSC_DAG, DAG, Subtarget,
20261                                    Results);
20262   }
20263   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: {
20264     EVT T = N->getValueType(0);
20265     assert((T == MVT::i64 || T == MVT::i128) && "can only expand cmpxchg pair");
20266     bool Regs64bit = T == MVT::i128;
20267     EVT HalfT = Regs64bit ? MVT::i64 : MVT::i32;
20268     SDValue cpInL, cpInH;
20269     cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
20270                         DAG.getConstant(0, HalfT));
20271     cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
20272                         DAG.getConstant(1, HalfT));
20273     cpInL = DAG.getCopyToReg(N->getOperand(0), dl,
20274                              Regs64bit ? X86::RAX : X86::EAX,
20275                              cpInL, SDValue());
20276     cpInH = DAG.getCopyToReg(cpInL.getValue(0), dl,
20277                              Regs64bit ? X86::RDX : X86::EDX,
20278                              cpInH, cpInL.getValue(1));
20279     SDValue swapInL, swapInH;
20280     swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
20281                           DAG.getConstant(0, HalfT));
20282     swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
20283                           DAG.getConstant(1, HalfT));
20284     swapInL = DAG.getCopyToReg(cpInH.getValue(0), dl,
20285                                Regs64bit ? X86::RBX : X86::EBX,
20286                                swapInL, cpInH.getValue(1));
20287     swapInH = DAG.getCopyToReg(swapInL.getValue(0), dl,
20288                                Regs64bit ? X86::RCX : X86::ECX,
20289                                swapInH, swapInL.getValue(1));
20290     SDValue Ops[] = { swapInH.getValue(0),
20291                       N->getOperand(1),
20292                       swapInH.getValue(1) };
20293     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
20294     MachineMemOperand *MMO = cast<AtomicSDNode>(N)->getMemOperand();
20295     unsigned Opcode = Regs64bit ? X86ISD::LCMPXCHG16_DAG :
20296                                   X86ISD::LCMPXCHG8_DAG;
20297     SDValue Result = DAG.getMemIntrinsicNode(Opcode, dl, Tys, Ops, T, MMO);
20298     SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), dl,
20299                                         Regs64bit ? X86::RAX : X86::EAX,
20300                                         HalfT, Result.getValue(1));
20301     SDValue cpOutH = DAG.getCopyFromReg(cpOutL.getValue(1), dl,
20302                                         Regs64bit ? X86::RDX : X86::EDX,
20303                                         HalfT, cpOutL.getValue(2));
20304     SDValue OpsF[] = { cpOutL.getValue(0), cpOutH.getValue(0)};
20305
20306     SDValue EFLAGS = DAG.getCopyFromReg(cpOutH.getValue(1), dl, X86::EFLAGS,
20307                                         MVT::i32, cpOutH.getValue(2));
20308     SDValue Success =
20309         DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
20310                     DAG.getConstant(X86::COND_E, MVT::i8), EFLAGS);
20311     Success = DAG.getZExtOrTrunc(Success, dl, N->getValueType(1));
20312
20313     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF));
20314     Results.push_back(Success);
20315     Results.push_back(EFLAGS.getValue(1));
20316     return;
20317   }
20318   case ISD::ATOMIC_SWAP:
20319   case ISD::ATOMIC_LOAD_ADD:
20320   case ISD::ATOMIC_LOAD_SUB:
20321   case ISD::ATOMIC_LOAD_AND:
20322   case ISD::ATOMIC_LOAD_OR:
20323   case ISD::ATOMIC_LOAD_XOR:
20324   case ISD::ATOMIC_LOAD_NAND:
20325   case ISD::ATOMIC_LOAD_MIN:
20326   case ISD::ATOMIC_LOAD_MAX:
20327   case ISD::ATOMIC_LOAD_UMIN:
20328   case ISD::ATOMIC_LOAD_UMAX:
20329   case ISD::ATOMIC_LOAD: {
20330     // Delegate to generic TypeLegalization. Situations we can really handle
20331     // should have already been dealt with by AtomicExpandPass.cpp.
20332     break;
20333   }
20334   case ISD::BITCAST: {
20335     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
20336     EVT DstVT = N->getValueType(0);
20337     EVT SrcVT = N->getOperand(0)->getValueType(0);
20338
20339     if (SrcVT != MVT::f64 ||
20340         (DstVT != MVT::v2i32 && DstVT != MVT::v4i16 && DstVT != MVT::v8i8))
20341       return;
20342
20343     unsigned NumElts = DstVT.getVectorNumElements();
20344     EVT SVT = DstVT.getVectorElementType();
20345     EVT WiderVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumElts * 2);
20346     SDValue Expanded = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
20347                                    MVT::v2f64, N->getOperand(0));
20348     SDValue ToVecInt = DAG.getNode(ISD::BITCAST, dl, WiderVT, Expanded);
20349
20350     if (ExperimentalVectorWideningLegalization) {
20351       // If we are legalizing vectors by widening, we already have the desired
20352       // legal vector type, just return it.
20353       Results.push_back(ToVecInt);
20354       return;
20355     }
20356
20357     SmallVector<SDValue, 8> Elts;
20358     for (unsigned i = 0, e = NumElts; i != e; ++i)
20359       Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT,
20360                                    ToVecInt, DAG.getIntPtrConstant(i)));
20361
20362     Results.push_back(DAG.getNode(ISD::BUILD_VECTOR, dl, DstVT, Elts));
20363   }
20364   }
20365 }
20366
20367 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
20368   switch (Opcode) {
20369   default: return nullptr;
20370   case X86ISD::BSF:                return "X86ISD::BSF";
20371   case X86ISD::BSR:                return "X86ISD::BSR";
20372   case X86ISD::SHLD:               return "X86ISD::SHLD";
20373   case X86ISD::SHRD:               return "X86ISD::SHRD";
20374   case X86ISD::FAND:               return "X86ISD::FAND";
20375   case X86ISD::FANDN:              return "X86ISD::FANDN";
20376   case X86ISD::FOR:                return "X86ISD::FOR";
20377   case X86ISD::FXOR:               return "X86ISD::FXOR";
20378   case X86ISD::FSRL:               return "X86ISD::FSRL";
20379   case X86ISD::FILD:               return "X86ISD::FILD";
20380   case X86ISD::FILD_FLAG:          return "X86ISD::FILD_FLAG";
20381   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
20382   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
20383   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
20384   case X86ISD::FLD:                return "X86ISD::FLD";
20385   case X86ISD::FST:                return "X86ISD::FST";
20386   case X86ISD::CALL:               return "X86ISD::CALL";
20387   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
20388   case X86ISD::RDTSCP_DAG:         return "X86ISD::RDTSCP_DAG";
20389   case X86ISD::RDPMC_DAG:          return "X86ISD::RDPMC_DAG";
20390   case X86ISD::BT:                 return "X86ISD::BT";
20391   case X86ISD::CMP:                return "X86ISD::CMP";
20392   case X86ISD::COMI:               return "X86ISD::COMI";
20393   case X86ISD::UCOMI:              return "X86ISD::UCOMI";
20394   case X86ISD::CMPM:               return "X86ISD::CMPM";
20395   case X86ISD::CMPMU:              return "X86ISD::CMPMU";
20396   case X86ISD::SETCC:              return "X86ISD::SETCC";
20397   case X86ISD::SETCC_CARRY:        return "X86ISD::SETCC_CARRY";
20398   case X86ISD::FSETCC:             return "X86ISD::FSETCC";
20399   case X86ISD::CMOV:               return "X86ISD::CMOV";
20400   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
20401   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
20402   case X86ISD::REP_STOS:           return "X86ISD::REP_STOS";
20403   case X86ISD::REP_MOVS:           return "X86ISD::REP_MOVS";
20404   case X86ISD::GlobalBaseReg:      return "X86ISD::GlobalBaseReg";
20405   case X86ISD::Wrapper:            return "X86ISD::Wrapper";
20406   case X86ISD::WrapperRIP:         return "X86ISD::WrapperRIP";
20407   case X86ISD::PEXTRB:             return "X86ISD::PEXTRB";
20408   case X86ISD::PEXTRW:             return "X86ISD::PEXTRW";
20409   case X86ISD::INSERTPS:           return "X86ISD::INSERTPS";
20410   case X86ISD::PINSRB:             return "X86ISD::PINSRB";
20411   case X86ISD::PINSRW:             return "X86ISD::PINSRW";
20412   case X86ISD::PSHUFB:             return "X86ISD::PSHUFB";
20413   case X86ISD::ANDNP:              return "X86ISD::ANDNP";
20414   case X86ISD::PSIGN:              return "X86ISD::PSIGN";
20415   case X86ISD::BLENDI:             return "X86ISD::BLENDI";
20416   case X86ISD::SHRUNKBLEND:        return "X86ISD::SHRUNKBLEND";
20417   case X86ISD::SUBUS:              return "X86ISD::SUBUS";
20418   case X86ISD::HADD:               return "X86ISD::HADD";
20419   case X86ISD::HSUB:               return "X86ISD::HSUB";
20420   case X86ISD::FHADD:              return "X86ISD::FHADD";
20421   case X86ISD::FHSUB:              return "X86ISD::FHSUB";
20422   case X86ISD::UMAX:               return "X86ISD::UMAX";
20423   case X86ISD::UMIN:               return "X86ISD::UMIN";
20424   case X86ISD::SMAX:               return "X86ISD::SMAX";
20425   case X86ISD::SMIN:               return "X86ISD::SMIN";
20426   case X86ISD::FMAX:               return "X86ISD::FMAX";
20427   case X86ISD::FMIN:               return "X86ISD::FMIN";
20428   case X86ISD::FMAXC:              return "X86ISD::FMAXC";
20429   case X86ISD::FMINC:              return "X86ISD::FMINC";
20430   case X86ISD::FRSQRT:             return "X86ISD::FRSQRT";
20431   case X86ISD::FRCP:               return "X86ISD::FRCP";
20432   case X86ISD::TLSADDR:            return "X86ISD::TLSADDR";
20433   case X86ISD::TLSBASEADDR:        return "X86ISD::TLSBASEADDR";
20434   case X86ISD::TLSCALL:            return "X86ISD::TLSCALL";
20435   case X86ISD::EH_SJLJ_SETJMP:     return "X86ISD::EH_SJLJ_SETJMP";
20436   case X86ISD::EH_SJLJ_LONGJMP:    return "X86ISD::EH_SJLJ_LONGJMP";
20437   case X86ISD::EH_RETURN:          return "X86ISD::EH_RETURN";
20438   case X86ISD::TC_RETURN:          return "X86ISD::TC_RETURN";
20439   case X86ISD::FNSTCW16m:          return "X86ISD::FNSTCW16m";
20440   case X86ISD::FNSTSW16r:          return "X86ISD::FNSTSW16r";
20441   case X86ISD::LCMPXCHG_DAG:       return "X86ISD::LCMPXCHG_DAG";
20442   case X86ISD::LCMPXCHG8_DAG:      return "X86ISD::LCMPXCHG8_DAG";
20443   case X86ISD::LCMPXCHG16_DAG:     return "X86ISD::LCMPXCHG16_DAG";
20444   case X86ISD::VZEXT_MOVL:         return "X86ISD::VZEXT_MOVL";
20445   case X86ISD::VZEXT_LOAD:         return "X86ISD::VZEXT_LOAD";
20446   case X86ISD::VZEXT:              return "X86ISD::VZEXT";
20447   case X86ISD::VSEXT:              return "X86ISD::VSEXT";
20448   case X86ISD::VTRUNC:             return "X86ISD::VTRUNC";
20449   case X86ISD::VTRUNCM:            return "X86ISD::VTRUNCM";
20450   case X86ISD::VINSERT:            return "X86ISD::VINSERT";
20451   case X86ISD::VFPEXT:             return "X86ISD::VFPEXT";
20452   case X86ISD::VFPROUND:           return "X86ISD::VFPROUND";
20453   case X86ISD::VSHLDQ:             return "X86ISD::VSHLDQ";
20454   case X86ISD::VSRLDQ:             return "X86ISD::VSRLDQ";
20455   case X86ISD::VSHL:               return "X86ISD::VSHL";
20456   case X86ISD::VSRL:               return "X86ISD::VSRL";
20457   case X86ISD::VSRA:               return "X86ISD::VSRA";
20458   case X86ISD::VSHLI:              return "X86ISD::VSHLI";
20459   case X86ISD::VSRLI:              return "X86ISD::VSRLI";
20460   case X86ISD::VSRAI:              return "X86ISD::VSRAI";
20461   case X86ISD::CMPP:               return "X86ISD::CMPP";
20462   case X86ISD::PCMPEQ:             return "X86ISD::PCMPEQ";
20463   case X86ISD::PCMPGT:             return "X86ISD::PCMPGT";
20464   case X86ISD::PCMPEQM:            return "X86ISD::PCMPEQM";
20465   case X86ISD::PCMPGTM:            return "X86ISD::PCMPGTM";
20466   case X86ISD::ADD:                return "X86ISD::ADD";
20467   case X86ISD::SUB:                return "X86ISD::SUB";
20468   case X86ISD::ADC:                return "X86ISD::ADC";
20469   case X86ISD::SBB:                return "X86ISD::SBB";
20470   case X86ISD::SMUL:               return "X86ISD::SMUL";
20471   case X86ISD::UMUL:               return "X86ISD::UMUL";
20472   case X86ISD::SMUL8:              return "X86ISD::SMUL8";
20473   case X86ISD::UMUL8:              return "X86ISD::UMUL8";
20474   case X86ISD::SDIVREM8_SEXT_HREG: return "X86ISD::SDIVREM8_SEXT_HREG";
20475   case X86ISD::UDIVREM8_ZEXT_HREG: return "X86ISD::UDIVREM8_ZEXT_HREG";
20476   case X86ISD::INC:                return "X86ISD::INC";
20477   case X86ISD::DEC:                return "X86ISD::DEC";
20478   case X86ISD::OR:                 return "X86ISD::OR";
20479   case X86ISD::XOR:                return "X86ISD::XOR";
20480   case X86ISD::AND:                return "X86ISD::AND";
20481   case X86ISD::BEXTR:              return "X86ISD::BEXTR";
20482   case X86ISD::MUL_IMM:            return "X86ISD::MUL_IMM";
20483   case X86ISD::PTEST:              return "X86ISD::PTEST";
20484   case X86ISD::TESTP:              return "X86ISD::TESTP";
20485   case X86ISD::TESTM:              return "X86ISD::TESTM";
20486   case X86ISD::TESTNM:             return "X86ISD::TESTNM";
20487   case X86ISD::KORTEST:            return "X86ISD::KORTEST";
20488   case X86ISD::PACKSS:             return "X86ISD::PACKSS";
20489   case X86ISD::PACKUS:             return "X86ISD::PACKUS";
20490   case X86ISD::PALIGNR:            return "X86ISD::PALIGNR";
20491   case X86ISD::VALIGN:             return "X86ISD::VALIGN";
20492   case X86ISD::PSHUFD:             return "X86ISD::PSHUFD";
20493   case X86ISD::PSHUFHW:            return "X86ISD::PSHUFHW";
20494   case X86ISD::PSHUFLW:            return "X86ISD::PSHUFLW";
20495   case X86ISD::SHUFP:              return "X86ISD::SHUFP";
20496   case X86ISD::MOVLHPS:            return "X86ISD::MOVLHPS";
20497   case X86ISD::MOVLHPD:            return "X86ISD::MOVLHPD";
20498   case X86ISD::MOVHLPS:            return "X86ISD::MOVHLPS";
20499   case X86ISD::MOVLPS:             return "X86ISD::MOVLPS";
20500   case X86ISD::MOVLPD:             return "X86ISD::MOVLPD";
20501   case X86ISD::MOVDDUP:            return "X86ISD::MOVDDUP";
20502   case X86ISD::MOVSHDUP:           return "X86ISD::MOVSHDUP";
20503   case X86ISD::MOVSLDUP:           return "X86ISD::MOVSLDUP";
20504   case X86ISD::MOVSD:              return "X86ISD::MOVSD";
20505   case X86ISD::MOVSS:              return "X86ISD::MOVSS";
20506   case X86ISD::UNPCKL:             return "X86ISD::UNPCKL";
20507   case X86ISD::UNPCKH:             return "X86ISD::UNPCKH";
20508   case X86ISD::VBROADCAST:         return "X86ISD::VBROADCAST";
20509   case X86ISD::VBROADCASTM:        return "X86ISD::VBROADCASTM";
20510   case X86ISD::VEXTRACT:           return "X86ISD::VEXTRACT";
20511   case X86ISD::VPERMILPI:          return "X86ISD::VPERMILPI";
20512   case X86ISD::VPERM2X128:         return "X86ISD::VPERM2X128";
20513   case X86ISD::VPERMV:             return "X86ISD::VPERMV";
20514   case X86ISD::VPERMV3:            return "X86ISD::VPERMV3";
20515   case X86ISD::VPERMIV3:           return "X86ISD::VPERMIV3";
20516   case X86ISD::VPERMI:             return "X86ISD::VPERMI";
20517   case X86ISD::PMULUDQ:            return "X86ISD::PMULUDQ";
20518   case X86ISD::PMULDQ:             return "X86ISD::PMULDQ";
20519   case X86ISD::VASTART_SAVE_XMM_REGS: return "X86ISD::VASTART_SAVE_XMM_REGS";
20520   case X86ISD::VAARG_64:           return "X86ISD::VAARG_64";
20521   case X86ISD::WIN_ALLOCA:         return "X86ISD::WIN_ALLOCA";
20522   case X86ISD::MEMBARRIER:         return "X86ISD::MEMBARRIER";
20523   case X86ISD::SEG_ALLOCA:         return "X86ISD::SEG_ALLOCA";
20524   case X86ISD::WIN_FTOL:           return "X86ISD::WIN_FTOL";
20525   case X86ISD::SAHF:               return "X86ISD::SAHF";
20526   case X86ISD::RDRAND:             return "X86ISD::RDRAND";
20527   case X86ISD::RDSEED:             return "X86ISD::RDSEED";
20528   case X86ISD::FMADD:              return "X86ISD::FMADD";
20529   case X86ISD::FMSUB:              return "X86ISD::FMSUB";
20530   case X86ISD::FNMADD:             return "X86ISD::FNMADD";
20531   case X86ISD::FNMSUB:             return "X86ISD::FNMSUB";
20532   case X86ISD::FMADDSUB:           return "X86ISD::FMADDSUB";
20533   case X86ISD::FMSUBADD:           return "X86ISD::FMSUBADD";
20534   case X86ISD::PCMPESTRI:          return "X86ISD::PCMPESTRI";
20535   case X86ISD::PCMPISTRI:          return "X86ISD::PCMPISTRI";
20536   case X86ISD::XTEST:              return "X86ISD::XTEST";
20537   case X86ISD::COMPRESS:           return "X86ISD::COMPRESS";
20538   case X86ISD::EXPAND:             return "X86ISD::EXPAND";
20539   case X86ISD::SELECT:             return "X86ISD::SELECT";
20540   case X86ISD::ADDSUB:             return "X86ISD::ADDSUB";
20541   case X86ISD::RCP28:              return "X86ISD::RCP28";
20542   case X86ISD::RSQRT28:            return "X86ISD::RSQRT28";
20543   case X86ISD::FADD_RND:           return "X86ISD::FADD_RND";
20544   case X86ISD::FSUB_RND:           return "X86ISD::FSUB_RND";
20545   case X86ISD::FMUL_RND:           return "X86ISD::FMUL_RND";
20546   case X86ISD::FDIV_RND:           return "X86ISD::FDIV_RND";
20547   }
20548 }
20549
20550 // isLegalAddressingMode - Return true if the addressing mode represented
20551 // by AM is legal for this target, for a load/store of the specified type.
20552 bool X86TargetLowering::isLegalAddressingMode(const AddrMode &AM,
20553                                               Type *Ty) const {
20554   // X86 supports extremely general addressing modes.
20555   CodeModel::Model M = getTargetMachine().getCodeModel();
20556   Reloc::Model R = getTargetMachine().getRelocationModel();
20557
20558   // X86 allows a sign-extended 32-bit immediate field as a displacement.
20559   if (!X86::isOffsetSuitableForCodeModel(AM.BaseOffs, M, AM.BaseGV != nullptr))
20560     return false;
20561
20562   if (AM.BaseGV) {
20563     unsigned GVFlags =
20564       Subtarget->ClassifyGlobalReference(AM.BaseGV, getTargetMachine());
20565
20566     // If a reference to this global requires an extra load, we can't fold it.
20567     if (isGlobalStubReference(GVFlags))
20568       return false;
20569
20570     // If BaseGV requires a register for the PIC base, we cannot also have a
20571     // BaseReg specified.
20572     if (AM.HasBaseReg && isGlobalRelativeToPICBase(GVFlags))
20573       return false;
20574
20575     // If lower 4G is not available, then we must use rip-relative addressing.
20576     if ((M != CodeModel::Small || R != Reloc::Static) &&
20577         Subtarget->is64Bit() && (AM.BaseOffs || AM.Scale > 1))
20578       return false;
20579   }
20580
20581   switch (AM.Scale) {
20582   case 0:
20583   case 1:
20584   case 2:
20585   case 4:
20586   case 8:
20587     // These scales always work.
20588     break;
20589   case 3:
20590   case 5:
20591   case 9:
20592     // These scales are formed with basereg+scalereg.  Only accept if there is
20593     // no basereg yet.
20594     if (AM.HasBaseReg)
20595       return false;
20596     break;
20597   default:  // Other stuff never works.
20598     return false;
20599   }
20600
20601   return true;
20602 }
20603
20604 bool X86TargetLowering::isVectorShiftByScalarCheap(Type *Ty) const {
20605   unsigned Bits = Ty->getScalarSizeInBits();
20606
20607   // 8-bit shifts are always expensive, but versions with a scalar amount aren't
20608   // particularly cheaper than those without.
20609   if (Bits == 8)
20610     return false;
20611
20612   // On AVX2 there are new vpsllv[dq] instructions (and other shifts), that make
20613   // variable shifts just as cheap as scalar ones.
20614   if (Subtarget->hasInt256() && (Bits == 32 || Bits == 64))
20615     return false;
20616
20617   // Otherwise, it's significantly cheaper to shift by a scalar amount than by a
20618   // fully general vector.
20619   return true;
20620 }
20621
20622 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
20623   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
20624     return false;
20625   unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
20626   unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
20627   return NumBits1 > NumBits2;
20628 }
20629
20630 bool X86TargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
20631   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
20632     return false;
20633
20634   if (!isTypeLegal(EVT::getEVT(Ty1)))
20635     return false;
20636
20637   assert(Ty1->getPrimitiveSizeInBits() <= 64 && "i128 is probably not a noop");
20638
20639   // Assuming the caller doesn't have a zeroext or signext return parameter,
20640   // truncation all the way down to i1 is valid.
20641   return true;
20642 }
20643
20644 bool X86TargetLowering::isLegalICmpImmediate(int64_t Imm) const {
20645   return isInt<32>(Imm);
20646 }
20647
20648 bool X86TargetLowering::isLegalAddImmediate(int64_t Imm) const {
20649   // Can also use sub to handle negated immediates.
20650   return isInt<32>(Imm);
20651 }
20652
20653 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
20654   if (!VT1.isInteger() || !VT2.isInteger())
20655     return false;
20656   unsigned NumBits1 = VT1.getSizeInBits();
20657   unsigned NumBits2 = VT2.getSizeInBits();
20658   return NumBits1 > NumBits2;
20659 }
20660
20661 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
20662   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
20663   return Ty1->isIntegerTy(32) && Ty2->isIntegerTy(64) && Subtarget->is64Bit();
20664 }
20665
20666 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
20667   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
20668   return VT1 == MVT::i32 && VT2 == MVT::i64 && Subtarget->is64Bit();
20669 }
20670
20671 bool X86TargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
20672   EVT VT1 = Val.getValueType();
20673   if (isZExtFree(VT1, VT2))
20674     return true;
20675
20676   if (Val.getOpcode() != ISD::LOAD)
20677     return false;
20678
20679   if (!VT1.isSimple() || !VT1.isInteger() ||
20680       !VT2.isSimple() || !VT2.isInteger())
20681     return false;
20682
20683   switch (VT1.getSimpleVT().SimpleTy) {
20684   default: break;
20685   case MVT::i8:
20686   case MVT::i16:
20687   case MVT::i32:
20688     // X86 has 8, 16, and 32-bit zero-extending loads.
20689     return true;
20690   }
20691
20692   return false;
20693 }
20694
20695 bool X86TargetLowering::isVectorLoadExtDesirable(SDValue) const { return true; }
20696
20697 bool
20698 X86TargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
20699   if (!(Subtarget->hasFMA() || Subtarget->hasFMA4()))
20700     return false;
20701
20702   VT = VT.getScalarType();
20703
20704   if (!VT.isSimple())
20705     return false;
20706
20707   switch (VT.getSimpleVT().SimpleTy) {
20708   case MVT::f32:
20709   case MVT::f64:
20710     return true;
20711   default:
20712     break;
20713   }
20714
20715   return false;
20716 }
20717
20718 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
20719   // i16 instructions are longer (0x66 prefix) and potentially slower.
20720   return !(VT1 == MVT::i32 && VT2 == MVT::i16);
20721 }
20722
20723 /// isShuffleMaskLegal - Targets can use this to indicate that they only
20724 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
20725 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
20726 /// are assumed to be legal.
20727 bool
20728 X86TargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
20729                                       EVT VT) const {
20730   if (!VT.isSimple())
20731     return false;
20732
20733   MVT SVT = VT.getSimpleVT();
20734
20735   // Very little shuffling can be done for 64-bit vectors right now.
20736   if (VT.getSizeInBits() == 64)
20737     return false;
20738
20739   // This is an experimental legality test that is tailored to match the
20740   // legality test of the experimental lowering more closely. They are gated
20741   // separately to ease testing of performance differences.
20742   if (ExperimentalVectorShuffleLegality)
20743     // We only care that the types being shuffled are legal. The lowering can
20744     // handle any possible shuffle mask that results.
20745     return isTypeLegal(SVT);
20746
20747   // If this is a single-input shuffle with no 128 bit lane crossings we can
20748   // lower it into pshufb.
20749   if ((SVT.is128BitVector() && Subtarget->hasSSSE3()) ||
20750       (SVT.is256BitVector() && Subtarget->hasInt256())) {
20751     bool isLegal = true;
20752     for (unsigned I = 0, E = M.size(); I != E; ++I) {
20753       if (M[I] >= (int)SVT.getVectorNumElements() ||
20754           ShuffleCrosses128bitLane(SVT, I, M[I])) {
20755         isLegal = false;
20756         break;
20757       }
20758     }
20759     if (isLegal)
20760       return true;
20761   }
20762
20763   // FIXME: blends, shifts.
20764   return (SVT.getVectorNumElements() == 2 ||
20765           ShuffleVectorSDNode::isSplatMask(&M[0], VT) ||
20766           isMOVLMask(M, SVT) ||
20767           isCommutedMOVLMask(M, SVT) ||
20768           isMOVHLPSMask(M, SVT) ||
20769           isSHUFPMask(M, SVT) ||
20770           isSHUFPMask(M, SVT, /* Commuted */ true) ||
20771           isPSHUFDMask(M, SVT) ||
20772           isPSHUFDMask(M, SVT, /* SecondOperand */ true) ||
20773           isPSHUFHWMask(M, SVT, Subtarget->hasInt256()) ||
20774           isPSHUFLWMask(M, SVT, Subtarget->hasInt256()) ||
20775           isPALIGNRMask(M, SVT, Subtarget) ||
20776           isUNPCKLMask(M, SVT, Subtarget->hasInt256()) ||
20777           isUNPCKHMask(M, SVT, Subtarget->hasInt256()) ||
20778           isUNPCKL_v_undef_Mask(M, SVT, Subtarget->hasInt256()) ||
20779           isUNPCKH_v_undef_Mask(M, SVT, Subtarget->hasInt256()) ||
20780           isBlendMask(M, SVT, Subtarget->hasSSE41(), Subtarget->hasInt256()) ||
20781           (Subtarget->hasSSE41() && isINSERTPSMask(M, SVT)));
20782 }
20783
20784 bool
20785 X86TargetLowering::isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
20786                                           EVT VT) const {
20787   if (!VT.isSimple())
20788     return false;
20789
20790   MVT SVT = VT.getSimpleVT();
20791
20792   // This is an experimental legality test that is tailored to match the
20793   // legality test of the experimental lowering more closely. They are gated
20794   // separately to ease testing of performance differences.
20795   if (ExperimentalVectorShuffleLegality)
20796     // The new vector shuffle lowering is very good at managing zero-inputs.
20797     return isShuffleMaskLegal(Mask, VT);
20798
20799   unsigned NumElts = SVT.getVectorNumElements();
20800   // FIXME: This collection of masks seems suspect.
20801   if (NumElts == 2)
20802     return true;
20803   if (NumElts == 4 && SVT.is128BitVector()) {
20804     return (isMOVLMask(Mask, SVT)  ||
20805             isCommutedMOVLMask(Mask, SVT, true) ||
20806             isSHUFPMask(Mask, SVT) ||
20807             isSHUFPMask(Mask, SVT, /* Commuted */ true) ||
20808             isBlendMask(Mask, SVT, Subtarget->hasSSE41(),
20809                         Subtarget->hasInt256()));
20810   }
20811   return false;
20812 }
20813
20814 //===----------------------------------------------------------------------===//
20815 //                           X86 Scheduler Hooks
20816 //===----------------------------------------------------------------------===//
20817
20818 /// Utility function to emit xbegin specifying the start of an RTM region.
20819 static MachineBasicBlock *EmitXBegin(MachineInstr *MI, MachineBasicBlock *MBB,
20820                                      const TargetInstrInfo *TII) {
20821   DebugLoc DL = MI->getDebugLoc();
20822
20823   const BasicBlock *BB = MBB->getBasicBlock();
20824   MachineFunction::iterator I = MBB;
20825   ++I;
20826
20827   // For the v = xbegin(), we generate
20828   //
20829   // thisMBB:
20830   //  xbegin sinkMBB
20831   //
20832   // mainMBB:
20833   //  eax = -1
20834   //
20835   // sinkMBB:
20836   //  v = eax
20837
20838   MachineBasicBlock *thisMBB = MBB;
20839   MachineFunction *MF = MBB->getParent();
20840   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
20841   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
20842   MF->insert(I, mainMBB);
20843   MF->insert(I, sinkMBB);
20844
20845   // Transfer the remainder of BB and its successor edges to sinkMBB.
20846   sinkMBB->splice(sinkMBB->begin(), MBB,
20847                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
20848   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
20849
20850   // thisMBB:
20851   //  xbegin sinkMBB
20852   //  # fallthrough to mainMBB
20853   //  # abortion to sinkMBB
20854   BuildMI(thisMBB, DL, TII->get(X86::XBEGIN_4)).addMBB(sinkMBB);
20855   thisMBB->addSuccessor(mainMBB);
20856   thisMBB->addSuccessor(sinkMBB);
20857
20858   // mainMBB:
20859   //  EAX = -1
20860   BuildMI(mainMBB, DL, TII->get(X86::MOV32ri), X86::EAX).addImm(-1);
20861   mainMBB->addSuccessor(sinkMBB);
20862
20863   // sinkMBB:
20864   // EAX is live into the sinkMBB
20865   sinkMBB->addLiveIn(X86::EAX);
20866   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
20867           TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20868     .addReg(X86::EAX);
20869
20870   MI->eraseFromParent();
20871   return sinkMBB;
20872 }
20873
20874 // FIXME: When we get size specific XMM0 registers, i.e. XMM0_V16I8
20875 // or XMM0_V32I8 in AVX all of this code can be replaced with that
20876 // in the .td file.
20877 static MachineBasicBlock *EmitPCMPSTRM(MachineInstr *MI, MachineBasicBlock *BB,
20878                                        const TargetInstrInfo *TII) {
20879   unsigned Opc;
20880   switch (MI->getOpcode()) {
20881   default: llvm_unreachable("illegal opcode!");
20882   case X86::PCMPISTRM128REG:  Opc = X86::PCMPISTRM128rr;  break;
20883   case X86::VPCMPISTRM128REG: Opc = X86::VPCMPISTRM128rr; break;
20884   case X86::PCMPISTRM128MEM:  Opc = X86::PCMPISTRM128rm;  break;
20885   case X86::VPCMPISTRM128MEM: Opc = X86::VPCMPISTRM128rm; break;
20886   case X86::PCMPESTRM128REG:  Opc = X86::PCMPESTRM128rr;  break;
20887   case X86::VPCMPESTRM128REG: Opc = X86::VPCMPESTRM128rr; break;
20888   case X86::PCMPESTRM128MEM:  Opc = X86::PCMPESTRM128rm;  break;
20889   case X86::VPCMPESTRM128MEM: Opc = X86::VPCMPESTRM128rm; break;
20890   }
20891
20892   DebugLoc dl = MI->getDebugLoc();
20893   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
20894
20895   unsigned NumArgs = MI->getNumOperands();
20896   for (unsigned i = 1; i < NumArgs; ++i) {
20897     MachineOperand &Op = MI->getOperand(i);
20898     if (!(Op.isReg() && Op.isImplicit()))
20899       MIB.addOperand(Op);
20900   }
20901   if (MI->hasOneMemOperand())
20902     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
20903
20904   BuildMI(*BB, MI, dl,
20905     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20906     .addReg(X86::XMM0);
20907
20908   MI->eraseFromParent();
20909   return BB;
20910 }
20911
20912 // FIXME: Custom handling because TableGen doesn't support multiple implicit
20913 // defs in an instruction pattern
20914 static MachineBasicBlock *EmitPCMPSTRI(MachineInstr *MI, MachineBasicBlock *BB,
20915                                        const TargetInstrInfo *TII) {
20916   unsigned Opc;
20917   switch (MI->getOpcode()) {
20918   default: llvm_unreachable("illegal opcode!");
20919   case X86::PCMPISTRIREG:  Opc = X86::PCMPISTRIrr;  break;
20920   case X86::VPCMPISTRIREG: Opc = X86::VPCMPISTRIrr; break;
20921   case X86::PCMPISTRIMEM:  Opc = X86::PCMPISTRIrm;  break;
20922   case X86::VPCMPISTRIMEM: Opc = X86::VPCMPISTRIrm; break;
20923   case X86::PCMPESTRIREG:  Opc = X86::PCMPESTRIrr;  break;
20924   case X86::VPCMPESTRIREG: Opc = X86::VPCMPESTRIrr; break;
20925   case X86::PCMPESTRIMEM:  Opc = X86::PCMPESTRIrm;  break;
20926   case X86::VPCMPESTRIMEM: Opc = X86::VPCMPESTRIrm; break;
20927   }
20928
20929   DebugLoc dl = MI->getDebugLoc();
20930   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
20931
20932   unsigned NumArgs = MI->getNumOperands(); // remove the results
20933   for (unsigned i = 1; i < NumArgs; ++i) {
20934     MachineOperand &Op = MI->getOperand(i);
20935     if (!(Op.isReg() && Op.isImplicit()))
20936       MIB.addOperand(Op);
20937   }
20938   if (MI->hasOneMemOperand())
20939     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
20940
20941   BuildMI(*BB, MI, dl,
20942     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20943     .addReg(X86::ECX);
20944
20945   MI->eraseFromParent();
20946   return BB;
20947 }
20948
20949 static MachineBasicBlock *EmitMonitor(MachineInstr *MI, MachineBasicBlock *BB,
20950                                       const X86Subtarget *Subtarget) {
20951   DebugLoc dl = MI->getDebugLoc();
20952   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
20953   // Address into RAX/EAX, other two args into ECX, EDX.
20954   unsigned MemOpc = Subtarget->is64Bit() ? X86::LEA64r : X86::LEA32r;
20955   unsigned MemReg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
20956   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(MemOpc), MemReg);
20957   for (int i = 0; i < X86::AddrNumOperands; ++i)
20958     MIB.addOperand(MI->getOperand(i));
20959
20960   unsigned ValOps = X86::AddrNumOperands;
20961   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::ECX)
20962     .addReg(MI->getOperand(ValOps).getReg());
20963   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::EDX)
20964     .addReg(MI->getOperand(ValOps+1).getReg());
20965
20966   // The instruction doesn't actually take any operands though.
20967   BuildMI(*BB, MI, dl, TII->get(X86::MONITORrrr));
20968
20969   MI->eraseFromParent(); // The pseudo is gone now.
20970   return BB;
20971 }
20972
20973 MachineBasicBlock *
20974 X86TargetLowering::EmitVAARG64WithCustomInserter(MachineInstr *MI,
20975                                                  MachineBasicBlock *MBB) const {
20976   // Emit va_arg instruction on X86-64.
20977
20978   // Operands to this pseudo-instruction:
20979   // 0  ) Output        : destination address (reg)
20980   // 1-5) Input         : va_list address (addr, i64mem)
20981   // 6  ) ArgSize       : Size (in bytes) of vararg type
20982   // 7  ) ArgMode       : 0=overflow only, 1=use gp_offset, 2=use fp_offset
20983   // 8  ) Align         : Alignment of type
20984   // 9  ) EFLAGS (implicit-def)
20985
20986   assert(MI->getNumOperands() == 10 && "VAARG_64 should have 10 operands!");
20987   assert(X86::AddrNumOperands == 5 && "VAARG_64 assumes 5 address operands");
20988
20989   unsigned DestReg = MI->getOperand(0).getReg();
20990   MachineOperand &Base = MI->getOperand(1);
20991   MachineOperand &Scale = MI->getOperand(2);
20992   MachineOperand &Index = MI->getOperand(3);
20993   MachineOperand &Disp = MI->getOperand(4);
20994   MachineOperand &Segment = MI->getOperand(5);
20995   unsigned ArgSize = MI->getOperand(6).getImm();
20996   unsigned ArgMode = MI->getOperand(7).getImm();
20997   unsigned Align = MI->getOperand(8).getImm();
20998
20999   // Memory Reference
21000   assert(MI->hasOneMemOperand() && "Expected VAARG_64 to have one memoperand");
21001   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
21002   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
21003
21004   // Machine Information
21005   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21006   MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
21007   const TargetRegisterClass *AddrRegClass = getRegClassFor(MVT::i64);
21008   const TargetRegisterClass *OffsetRegClass = getRegClassFor(MVT::i32);
21009   DebugLoc DL = MI->getDebugLoc();
21010
21011   // struct va_list {
21012   //   i32   gp_offset
21013   //   i32   fp_offset
21014   //   i64   overflow_area (address)
21015   //   i64   reg_save_area (address)
21016   // }
21017   // sizeof(va_list) = 24
21018   // alignment(va_list) = 8
21019
21020   unsigned TotalNumIntRegs = 6;
21021   unsigned TotalNumXMMRegs = 8;
21022   bool UseGPOffset = (ArgMode == 1);
21023   bool UseFPOffset = (ArgMode == 2);
21024   unsigned MaxOffset = TotalNumIntRegs * 8 +
21025                        (UseFPOffset ? TotalNumXMMRegs * 16 : 0);
21026
21027   /* Align ArgSize to a multiple of 8 */
21028   unsigned ArgSizeA8 = (ArgSize + 7) & ~7;
21029   bool NeedsAlign = (Align > 8);
21030
21031   MachineBasicBlock *thisMBB = MBB;
21032   MachineBasicBlock *overflowMBB;
21033   MachineBasicBlock *offsetMBB;
21034   MachineBasicBlock *endMBB;
21035
21036   unsigned OffsetDestReg = 0;    // Argument address computed by offsetMBB
21037   unsigned OverflowDestReg = 0;  // Argument address computed by overflowMBB
21038   unsigned OffsetReg = 0;
21039
21040   if (!UseGPOffset && !UseFPOffset) {
21041     // If we only pull from the overflow region, we don't create a branch.
21042     // We don't need to alter control flow.
21043     OffsetDestReg = 0; // unused
21044     OverflowDestReg = DestReg;
21045
21046     offsetMBB = nullptr;
21047     overflowMBB = thisMBB;
21048     endMBB = thisMBB;
21049   } else {
21050     // First emit code to check if gp_offset (or fp_offset) is below the bound.
21051     // If so, pull the argument from reg_save_area. (branch to offsetMBB)
21052     // If not, pull from overflow_area. (branch to overflowMBB)
21053     //
21054     //       thisMBB
21055     //         |     .
21056     //         |        .
21057     //     offsetMBB   overflowMBB
21058     //         |        .
21059     //         |     .
21060     //        endMBB
21061
21062     // Registers for the PHI in endMBB
21063     OffsetDestReg = MRI.createVirtualRegister(AddrRegClass);
21064     OverflowDestReg = MRI.createVirtualRegister(AddrRegClass);
21065
21066     const BasicBlock *LLVM_BB = MBB->getBasicBlock();
21067     MachineFunction *MF = MBB->getParent();
21068     overflowMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21069     offsetMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21070     endMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21071
21072     MachineFunction::iterator MBBIter = MBB;
21073     ++MBBIter;
21074
21075     // Insert the new basic blocks
21076     MF->insert(MBBIter, offsetMBB);
21077     MF->insert(MBBIter, overflowMBB);
21078     MF->insert(MBBIter, endMBB);
21079
21080     // Transfer the remainder of MBB and its successor edges to endMBB.
21081     endMBB->splice(endMBB->begin(), thisMBB,
21082                    std::next(MachineBasicBlock::iterator(MI)), thisMBB->end());
21083     endMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
21084
21085     // Make offsetMBB and overflowMBB successors of thisMBB
21086     thisMBB->addSuccessor(offsetMBB);
21087     thisMBB->addSuccessor(overflowMBB);
21088
21089     // endMBB is a successor of both offsetMBB and overflowMBB
21090     offsetMBB->addSuccessor(endMBB);
21091     overflowMBB->addSuccessor(endMBB);
21092
21093     // Load the offset value into a register
21094     OffsetReg = MRI.createVirtualRegister(OffsetRegClass);
21095     BuildMI(thisMBB, DL, TII->get(X86::MOV32rm), OffsetReg)
21096       .addOperand(Base)
21097       .addOperand(Scale)
21098       .addOperand(Index)
21099       .addDisp(Disp, UseFPOffset ? 4 : 0)
21100       .addOperand(Segment)
21101       .setMemRefs(MMOBegin, MMOEnd);
21102
21103     // Check if there is enough room left to pull this argument.
21104     BuildMI(thisMBB, DL, TII->get(X86::CMP32ri))
21105       .addReg(OffsetReg)
21106       .addImm(MaxOffset + 8 - ArgSizeA8);
21107
21108     // Branch to "overflowMBB" if offset >= max
21109     // Fall through to "offsetMBB" otherwise
21110     BuildMI(thisMBB, DL, TII->get(X86::GetCondBranchFromCond(X86::COND_AE)))
21111       .addMBB(overflowMBB);
21112   }
21113
21114   // In offsetMBB, emit code to use the reg_save_area.
21115   if (offsetMBB) {
21116     assert(OffsetReg != 0);
21117
21118     // Read the reg_save_area address.
21119     unsigned RegSaveReg = MRI.createVirtualRegister(AddrRegClass);
21120     BuildMI(offsetMBB, DL, TII->get(X86::MOV64rm), RegSaveReg)
21121       .addOperand(Base)
21122       .addOperand(Scale)
21123       .addOperand(Index)
21124       .addDisp(Disp, 16)
21125       .addOperand(Segment)
21126       .setMemRefs(MMOBegin, MMOEnd);
21127
21128     // Zero-extend the offset
21129     unsigned OffsetReg64 = MRI.createVirtualRegister(AddrRegClass);
21130       BuildMI(offsetMBB, DL, TII->get(X86::SUBREG_TO_REG), OffsetReg64)
21131         .addImm(0)
21132         .addReg(OffsetReg)
21133         .addImm(X86::sub_32bit);
21134
21135     // Add the offset to the reg_save_area to get the final address.
21136     BuildMI(offsetMBB, DL, TII->get(X86::ADD64rr), OffsetDestReg)
21137       .addReg(OffsetReg64)
21138       .addReg(RegSaveReg);
21139
21140     // Compute the offset for the next argument
21141     unsigned NextOffsetReg = MRI.createVirtualRegister(OffsetRegClass);
21142     BuildMI(offsetMBB, DL, TII->get(X86::ADD32ri), NextOffsetReg)
21143       .addReg(OffsetReg)
21144       .addImm(UseFPOffset ? 16 : 8);
21145
21146     // Store it back into the va_list.
21147     BuildMI(offsetMBB, DL, TII->get(X86::MOV32mr))
21148       .addOperand(Base)
21149       .addOperand(Scale)
21150       .addOperand(Index)
21151       .addDisp(Disp, UseFPOffset ? 4 : 0)
21152       .addOperand(Segment)
21153       .addReg(NextOffsetReg)
21154       .setMemRefs(MMOBegin, MMOEnd);
21155
21156     // Jump to endMBB
21157     BuildMI(offsetMBB, DL, TII->get(X86::JMP_1))
21158       .addMBB(endMBB);
21159   }
21160
21161   //
21162   // Emit code to use overflow area
21163   //
21164
21165   // Load the overflow_area address into a register.
21166   unsigned OverflowAddrReg = MRI.createVirtualRegister(AddrRegClass);
21167   BuildMI(overflowMBB, DL, TII->get(X86::MOV64rm), OverflowAddrReg)
21168     .addOperand(Base)
21169     .addOperand(Scale)
21170     .addOperand(Index)
21171     .addDisp(Disp, 8)
21172     .addOperand(Segment)
21173     .setMemRefs(MMOBegin, MMOEnd);
21174
21175   // If we need to align it, do so. Otherwise, just copy the address
21176   // to OverflowDestReg.
21177   if (NeedsAlign) {
21178     // Align the overflow address
21179     assert((Align & (Align-1)) == 0 && "Alignment must be a power of 2");
21180     unsigned TmpReg = MRI.createVirtualRegister(AddrRegClass);
21181
21182     // aligned_addr = (addr + (align-1)) & ~(align-1)
21183     BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), TmpReg)
21184       .addReg(OverflowAddrReg)
21185       .addImm(Align-1);
21186
21187     BuildMI(overflowMBB, DL, TII->get(X86::AND64ri32), OverflowDestReg)
21188       .addReg(TmpReg)
21189       .addImm(~(uint64_t)(Align-1));
21190   } else {
21191     BuildMI(overflowMBB, DL, TII->get(TargetOpcode::COPY), OverflowDestReg)
21192       .addReg(OverflowAddrReg);
21193   }
21194
21195   // Compute the next overflow address after this argument.
21196   // (the overflow address should be kept 8-byte aligned)
21197   unsigned NextAddrReg = MRI.createVirtualRegister(AddrRegClass);
21198   BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), NextAddrReg)
21199     .addReg(OverflowDestReg)
21200     .addImm(ArgSizeA8);
21201
21202   // Store the new overflow address.
21203   BuildMI(overflowMBB, DL, TII->get(X86::MOV64mr))
21204     .addOperand(Base)
21205     .addOperand(Scale)
21206     .addOperand(Index)
21207     .addDisp(Disp, 8)
21208     .addOperand(Segment)
21209     .addReg(NextAddrReg)
21210     .setMemRefs(MMOBegin, MMOEnd);
21211
21212   // If we branched, emit the PHI to the front of endMBB.
21213   if (offsetMBB) {
21214     BuildMI(*endMBB, endMBB->begin(), DL,
21215             TII->get(X86::PHI), DestReg)
21216       .addReg(OffsetDestReg).addMBB(offsetMBB)
21217       .addReg(OverflowDestReg).addMBB(overflowMBB);
21218   }
21219
21220   // Erase the pseudo instruction
21221   MI->eraseFromParent();
21222
21223   return endMBB;
21224 }
21225
21226 MachineBasicBlock *
21227 X86TargetLowering::EmitVAStartSaveXMMRegsWithCustomInserter(
21228                                                  MachineInstr *MI,
21229                                                  MachineBasicBlock *MBB) const {
21230   // Emit code to save XMM registers to the stack. The ABI says that the
21231   // number of registers to save is given in %al, so it's theoretically
21232   // possible to do an indirect jump trick to avoid saving all of them,
21233   // however this code takes a simpler approach and just executes all
21234   // of the stores if %al is non-zero. It's less code, and it's probably
21235   // easier on the hardware branch predictor, and stores aren't all that
21236   // expensive anyway.
21237
21238   // Create the new basic blocks. One block contains all the XMM stores,
21239   // and one block is the final destination regardless of whether any
21240   // stores were performed.
21241   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
21242   MachineFunction *F = MBB->getParent();
21243   MachineFunction::iterator MBBIter = MBB;
21244   ++MBBIter;
21245   MachineBasicBlock *XMMSaveMBB = F->CreateMachineBasicBlock(LLVM_BB);
21246   MachineBasicBlock *EndMBB = F->CreateMachineBasicBlock(LLVM_BB);
21247   F->insert(MBBIter, XMMSaveMBB);
21248   F->insert(MBBIter, EndMBB);
21249
21250   // Transfer the remainder of MBB and its successor edges to EndMBB.
21251   EndMBB->splice(EndMBB->begin(), MBB,
21252                  std::next(MachineBasicBlock::iterator(MI)), MBB->end());
21253   EndMBB->transferSuccessorsAndUpdatePHIs(MBB);
21254
21255   // The original block will now fall through to the XMM save block.
21256   MBB->addSuccessor(XMMSaveMBB);
21257   // The XMMSaveMBB will fall through to the end block.
21258   XMMSaveMBB->addSuccessor(EndMBB);
21259
21260   // Now add the instructions.
21261   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21262   DebugLoc DL = MI->getDebugLoc();
21263
21264   unsigned CountReg = MI->getOperand(0).getReg();
21265   int64_t RegSaveFrameIndex = MI->getOperand(1).getImm();
21266   int64_t VarArgsFPOffset = MI->getOperand(2).getImm();
21267
21268   if (!Subtarget->isTargetWin64()) {
21269     // If %al is 0, branch around the XMM save block.
21270     BuildMI(MBB, DL, TII->get(X86::TEST8rr)).addReg(CountReg).addReg(CountReg);
21271     BuildMI(MBB, DL, TII->get(X86::JE_1)).addMBB(EndMBB);
21272     MBB->addSuccessor(EndMBB);
21273   }
21274
21275   // Make sure the last operand is EFLAGS, which gets clobbered by the branch
21276   // that was just emitted, but clearly shouldn't be "saved".
21277   assert((MI->getNumOperands() <= 3 ||
21278           !MI->getOperand(MI->getNumOperands() - 1).isReg() ||
21279           MI->getOperand(MI->getNumOperands() - 1).getReg() == X86::EFLAGS)
21280          && "Expected last argument to be EFLAGS");
21281   unsigned MOVOpc = Subtarget->hasFp256() ? X86::VMOVAPSmr : X86::MOVAPSmr;
21282   // In the XMM save block, save all the XMM argument registers.
21283   for (int i = 3, e = MI->getNumOperands() - 1; i != e; ++i) {
21284     int64_t Offset = (i - 3) * 16 + VarArgsFPOffset;
21285     MachineMemOperand *MMO =
21286       F->getMachineMemOperand(
21287           MachinePointerInfo::getFixedStack(RegSaveFrameIndex, Offset),
21288         MachineMemOperand::MOStore,
21289         /*Size=*/16, /*Align=*/16);
21290     BuildMI(XMMSaveMBB, DL, TII->get(MOVOpc))
21291       .addFrameIndex(RegSaveFrameIndex)
21292       .addImm(/*Scale=*/1)
21293       .addReg(/*IndexReg=*/0)
21294       .addImm(/*Disp=*/Offset)
21295       .addReg(/*Segment=*/0)
21296       .addReg(MI->getOperand(i).getReg())
21297       .addMemOperand(MMO);
21298   }
21299
21300   MI->eraseFromParent();   // The pseudo instruction is gone now.
21301
21302   return EndMBB;
21303 }
21304
21305 // The EFLAGS operand of SelectItr might be missing a kill marker
21306 // because there were multiple uses of EFLAGS, and ISel didn't know
21307 // which to mark. Figure out whether SelectItr should have had a
21308 // kill marker, and set it if it should. Returns the correct kill
21309 // marker value.
21310 static bool checkAndUpdateEFLAGSKill(MachineBasicBlock::iterator SelectItr,
21311                                      MachineBasicBlock* BB,
21312                                      const TargetRegisterInfo* TRI) {
21313   // Scan forward through BB for a use/def of EFLAGS.
21314   MachineBasicBlock::iterator miI(std::next(SelectItr));
21315   for (MachineBasicBlock::iterator miE = BB->end(); miI != miE; ++miI) {
21316     const MachineInstr& mi = *miI;
21317     if (mi.readsRegister(X86::EFLAGS))
21318       return false;
21319     if (mi.definesRegister(X86::EFLAGS))
21320       break; // Should have kill-flag - update below.
21321   }
21322
21323   // If we hit the end of the block, check whether EFLAGS is live into a
21324   // successor.
21325   if (miI == BB->end()) {
21326     for (MachineBasicBlock::succ_iterator sItr = BB->succ_begin(),
21327                                           sEnd = BB->succ_end();
21328          sItr != sEnd; ++sItr) {
21329       MachineBasicBlock* succ = *sItr;
21330       if (succ->isLiveIn(X86::EFLAGS))
21331         return false;
21332     }
21333   }
21334
21335   // We found a def, or hit the end of the basic block and EFLAGS wasn't live
21336   // out. SelectMI should have a kill flag on EFLAGS.
21337   SelectItr->addRegisterKilled(X86::EFLAGS, TRI);
21338   return true;
21339 }
21340
21341 MachineBasicBlock *
21342 X86TargetLowering::EmitLoweredSelect(MachineInstr *MI,
21343                                      MachineBasicBlock *BB) const {
21344   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21345   DebugLoc DL = MI->getDebugLoc();
21346
21347   // To "insert" a SELECT_CC instruction, we actually have to insert the
21348   // diamond control-flow pattern.  The incoming instruction knows the
21349   // destination vreg to set, the condition code register to branch on, the
21350   // true/false values to select between, and a branch opcode to use.
21351   const BasicBlock *LLVM_BB = BB->getBasicBlock();
21352   MachineFunction::iterator It = BB;
21353   ++It;
21354
21355   //  thisMBB:
21356   //  ...
21357   //   TrueVal = ...
21358   //   cmpTY ccX, r1, r2
21359   //   bCC copy1MBB
21360   //   fallthrough --> copy0MBB
21361   MachineBasicBlock *thisMBB = BB;
21362   MachineFunction *F = BB->getParent();
21363   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
21364   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
21365   F->insert(It, copy0MBB);
21366   F->insert(It, sinkMBB);
21367
21368   // If the EFLAGS register isn't dead in the terminator, then claim that it's
21369   // live into the sink and copy blocks.
21370   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
21371   if (!MI->killsRegister(X86::EFLAGS) &&
21372       !checkAndUpdateEFLAGSKill(MI, BB, TRI)) {
21373     copy0MBB->addLiveIn(X86::EFLAGS);
21374     sinkMBB->addLiveIn(X86::EFLAGS);
21375   }
21376
21377   // Transfer the remainder of BB and its successor edges to sinkMBB.
21378   sinkMBB->splice(sinkMBB->begin(), BB,
21379                   std::next(MachineBasicBlock::iterator(MI)), BB->end());
21380   sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
21381
21382   // Add the true and fallthrough blocks as its successors.
21383   BB->addSuccessor(copy0MBB);
21384   BB->addSuccessor(sinkMBB);
21385
21386   // Create the conditional branch instruction.
21387   unsigned Opc =
21388     X86::GetCondBranchFromCond((X86::CondCode)MI->getOperand(3).getImm());
21389   BuildMI(BB, DL, TII->get(Opc)).addMBB(sinkMBB);
21390
21391   //  copy0MBB:
21392   //   %FalseValue = ...
21393   //   # fallthrough to sinkMBB
21394   copy0MBB->addSuccessor(sinkMBB);
21395
21396   //  sinkMBB:
21397   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
21398   //  ...
21399   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
21400           TII->get(X86::PHI), MI->getOperand(0).getReg())
21401     .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
21402     .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
21403
21404   MI->eraseFromParent();   // The pseudo instruction is gone now.
21405   return sinkMBB;
21406 }
21407
21408 MachineBasicBlock *
21409 X86TargetLowering::EmitLoweredSegAlloca(MachineInstr *MI,
21410                                         MachineBasicBlock *BB) const {
21411   MachineFunction *MF = BB->getParent();
21412   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21413   DebugLoc DL = MI->getDebugLoc();
21414   const BasicBlock *LLVM_BB = BB->getBasicBlock();
21415
21416   assert(MF->shouldSplitStack());
21417
21418   const bool Is64Bit = Subtarget->is64Bit();
21419   const bool IsLP64 = Subtarget->isTarget64BitLP64();
21420
21421   const unsigned TlsReg = Is64Bit ? X86::FS : X86::GS;
21422   const unsigned TlsOffset = IsLP64 ? 0x70 : Is64Bit ? 0x40 : 0x30;
21423
21424   // BB:
21425   //  ... [Till the alloca]
21426   // If stacklet is not large enough, jump to mallocMBB
21427   //
21428   // bumpMBB:
21429   //  Allocate by subtracting from RSP
21430   //  Jump to continueMBB
21431   //
21432   // mallocMBB:
21433   //  Allocate by call to runtime
21434   //
21435   // continueMBB:
21436   //  ...
21437   //  [rest of original BB]
21438   //
21439
21440   MachineBasicBlock *mallocMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21441   MachineBasicBlock *bumpMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21442   MachineBasicBlock *continueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21443
21444   MachineRegisterInfo &MRI = MF->getRegInfo();
21445   const TargetRegisterClass *AddrRegClass =
21446     getRegClassFor(getPointerTy());
21447
21448   unsigned mallocPtrVReg = MRI.createVirtualRegister(AddrRegClass),
21449     bumpSPPtrVReg = MRI.createVirtualRegister(AddrRegClass),
21450     tmpSPVReg = MRI.createVirtualRegister(AddrRegClass),
21451     SPLimitVReg = MRI.createVirtualRegister(AddrRegClass),
21452     sizeVReg = MI->getOperand(1).getReg(),
21453     physSPReg = IsLP64 || Subtarget->isTargetNaCl64() ? X86::RSP : X86::ESP;
21454
21455   MachineFunction::iterator MBBIter = BB;
21456   ++MBBIter;
21457
21458   MF->insert(MBBIter, bumpMBB);
21459   MF->insert(MBBIter, mallocMBB);
21460   MF->insert(MBBIter, continueMBB);
21461
21462   continueMBB->splice(continueMBB->begin(), BB,
21463                       std::next(MachineBasicBlock::iterator(MI)), BB->end());
21464   continueMBB->transferSuccessorsAndUpdatePHIs(BB);
21465
21466   // Add code to the main basic block to check if the stack limit has been hit,
21467   // and if so, jump to mallocMBB otherwise to bumpMBB.
21468   BuildMI(BB, DL, TII->get(TargetOpcode::COPY), tmpSPVReg).addReg(physSPReg);
21469   BuildMI(BB, DL, TII->get(IsLP64 ? X86::SUB64rr:X86::SUB32rr), SPLimitVReg)
21470     .addReg(tmpSPVReg).addReg(sizeVReg);
21471   BuildMI(BB, DL, TII->get(IsLP64 ? X86::CMP64mr:X86::CMP32mr))
21472     .addReg(0).addImm(1).addReg(0).addImm(TlsOffset).addReg(TlsReg)
21473     .addReg(SPLimitVReg);
21474   BuildMI(BB, DL, TII->get(X86::JG_1)).addMBB(mallocMBB);
21475
21476   // bumpMBB simply decreases the stack pointer, since we know the current
21477   // stacklet has enough space.
21478   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), physSPReg)
21479     .addReg(SPLimitVReg);
21480   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), bumpSPPtrVReg)
21481     .addReg(SPLimitVReg);
21482   BuildMI(bumpMBB, DL, TII->get(X86::JMP_1)).addMBB(continueMBB);
21483
21484   // Calls into a routine in libgcc to allocate more space from the heap.
21485   const uint32_t *RegMask =
21486       Subtarget->getRegisterInfo()->getCallPreservedMask(CallingConv::C);
21487   if (IsLP64) {
21488     BuildMI(mallocMBB, DL, TII->get(X86::MOV64rr), X86::RDI)
21489       .addReg(sizeVReg);
21490     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
21491       .addExternalSymbol("__morestack_allocate_stack_space")
21492       .addRegMask(RegMask)
21493       .addReg(X86::RDI, RegState::Implicit)
21494       .addReg(X86::RAX, RegState::ImplicitDefine);
21495   } else if (Is64Bit) {
21496     BuildMI(mallocMBB, DL, TII->get(X86::MOV32rr), X86::EDI)
21497       .addReg(sizeVReg);
21498     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
21499       .addExternalSymbol("__morestack_allocate_stack_space")
21500       .addRegMask(RegMask)
21501       .addReg(X86::EDI, RegState::Implicit)
21502       .addReg(X86::EAX, RegState::ImplicitDefine);
21503   } else {
21504     BuildMI(mallocMBB, DL, TII->get(X86::SUB32ri), physSPReg).addReg(physSPReg)
21505       .addImm(12);
21506     BuildMI(mallocMBB, DL, TII->get(X86::PUSH32r)).addReg(sizeVReg);
21507     BuildMI(mallocMBB, DL, TII->get(X86::CALLpcrel32))
21508       .addExternalSymbol("__morestack_allocate_stack_space")
21509       .addRegMask(RegMask)
21510       .addReg(X86::EAX, RegState::ImplicitDefine);
21511   }
21512
21513   if (!Is64Bit)
21514     BuildMI(mallocMBB, DL, TII->get(X86::ADD32ri), physSPReg).addReg(physSPReg)
21515       .addImm(16);
21516
21517   BuildMI(mallocMBB, DL, TII->get(TargetOpcode::COPY), mallocPtrVReg)
21518     .addReg(IsLP64 ? X86::RAX : X86::EAX);
21519   BuildMI(mallocMBB, DL, TII->get(X86::JMP_1)).addMBB(continueMBB);
21520
21521   // Set up the CFG correctly.
21522   BB->addSuccessor(bumpMBB);
21523   BB->addSuccessor(mallocMBB);
21524   mallocMBB->addSuccessor(continueMBB);
21525   bumpMBB->addSuccessor(continueMBB);
21526
21527   // Take care of the PHI nodes.
21528   BuildMI(*continueMBB, continueMBB->begin(), DL, TII->get(X86::PHI),
21529           MI->getOperand(0).getReg())
21530     .addReg(mallocPtrVReg).addMBB(mallocMBB)
21531     .addReg(bumpSPPtrVReg).addMBB(bumpMBB);
21532
21533   // Delete the original pseudo instruction.
21534   MI->eraseFromParent();
21535
21536   // And we're done.
21537   return continueMBB;
21538 }
21539
21540 MachineBasicBlock *
21541 X86TargetLowering::EmitLoweredWinAlloca(MachineInstr *MI,
21542                                         MachineBasicBlock *BB) const {
21543   DebugLoc DL = MI->getDebugLoc();
21544
21545   assert(!Subtarget->isTargetMachO());
21546
21547   X86FrameLowering::emitStackProbeCall(*BB->getParent(), *BB, MI, DL);
21548
21549   MI->eraseFromParent();   // The pseudo instruction is gone now.
21550   return BB;
21551 }
21552
21553 MachineBasicBlock *
21554 X86TargetLowering::EmitLoweredTLSCall(MachineInstr *MI,
21555                                       MachineBasicBlock *BB) const {
21556   // This is pretty easy.  We're taking the value that we received from
21557   // our load from the relocation, sticking it in either RDI (x86-64)
21558   // or EAX and doing an indirect call.  The return value will then
21559   // be in the normal return register.
21560   MachineFunction *F = BB->getParent();
21561   const X86InstrInfo *TII = Subtarget->getInstrInfo();
21562   DebugLoc DL = MI->getDebugLoc();
21563
21564   assert(Subtarget->isTargetDarwin() && "Darwin only instr emitted?");
21565   assert(MI->getOperand(3).isGlobal() && "This should be a global");
21566
21567   // Get a register mask for the lowered call.
21568   // FIXME: The 32-bit calls have non-standard calling conventions. Use a
21569   // proper register mask.
21570   const uint32_t *RegMask =
21571       Subtarget->getRegisterInfo()->getCallPreservedMask(CallingConv::C);
21572   if (Subtarget->is64Bit()) {
21573     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21574                                       TII->get(X86::MOV64rm), X86::RDI)
21575     .addReg(X86::RIP)
21576     .addImm(0).addReg(0)
21577     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21578                       MI->getOperand(3).getTargetFlags())
21579     .addReg(0);
21580     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL64m));
21581     addDirectMem(MIB, X86::RDI);
21582     MIB.addReg(X86::RAX, RegState::ImplicitDefine).addRegMask(RegMask);
21583   } else if (F->getTarget().getRelocationModel() != Reloc::PIC_) {
21584     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21585                                       TII->get(X86::MOV32rm), X86::EAX)
21586     .addReg(0)
21587     .addImm(0).addReg(0)
21588     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21589                       MI->getOperand(3).getTargetFlags())
21590     .addReg(0);
21591     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
21592     addDirectMem(MIB, X86::EAX);
21593     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
21594   } else {
21595     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21596                                       TII->get(X86::MOV32rm), X86::EAX)
21597     .addReg(TII->getGlobalBaseReg(F))
21598     .addImm(0).addReg(0)
21599     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21600                       MI->getOperand(3).getTargetFlags())
21601     .addReg(0);
21602     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
21603     addDirectMem(MIB, X86::EAX);
21604     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
21605   }
21606
21607   MI->eraseFromParent(); // The pseudo instruction is gone now.
21608   return BB;
21609 }
21610
21611 MachineBasicBlock *
21612 X86TargetLowering::emitEHSjLjSetJmp(MachineInstr *MI,
21613                                     MachineBasicBlock *MBB) const {
21614   DebugLoc DL = MI->getDebugLoc();
21615   MachineFunction *MF = MBB->getParent();
21616   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21617   MachineRegisterInfo &MRI = MF->getRegInfo();
21618
21619   const BasicBlock *BB = MBB->getBasicBlock();
21620   MachineFunction::iterator I = MBB;
21621   ++I;
21622
21623   // Memory Reference
21624   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
21625   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
21626
21627   unsigned DstReg;
21628   unsigned MemOpndSlot = 0;
21629
21630   unsigned CurOp = 0;
21631
21632   DstReg = MI->getOperand(CurOp++).getReg();
21633   const TargetRegisterClass *RC = MRI.getRegClass(DstReg);
21634   assert(RC->hasType(MVT::i32) && "Invalid destination!");
21635   unsigned mainDstReg = MRI.createVirtualRegister(RC);
21636   unsigned restoreDstReg = MRI.createVirtualRegister(RC);
21637
21638   MemOpndSlot = CurOp;
21639
21640   MVT PVT = getPointerTy();
21641   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
21642          "Invalid Pointer Size!");
21643
21644   // For v = setjmp(buf), we generate
21645   //
21646   // thisMBB:
21647   //  buf[LabelOffset] = restoreMBB
21648   //  SjLjSetup restoreMBB
21649   //
21650   // mainMBB:
21651   //  v_main = 0
21652   //
21653   // sinkMBB:
21654   //  v = phi(main, restore)
21655   //
21656   // restoreMBB:
21657   //  if base pointer being used, load it from frame
21658   //  v_restore = 1
21659
21660   MachineBasicBlock *thisMBB = MBB;
21661   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
21662   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
21663   MachineBasicBlock *restoreMBB = MF->CreateMachineBasicBlock(BB);
21664   MF->insert(I, mainMBB);
21665   MF->insert(I, sinkMBB);
21666   MF->push_back(restoreMBB);
21667
21668   MachineInstrBuilder MIB;
21669
21670   // Transfer the remainder of BB and its successor edges to sinkMBB.
21671   sinkMBB->splice(sinkMBB->begin(), MBB,
21672                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
21673   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
21674
21675   // thisMBB:
21676   unsigned PtrStoreOpc = 0;
21677   unsigned LabelReg = 0;
21678   const int64_t LabelOffset = 1 * PVT.getStoreSize();
21679   Reloc::Model RM = MF->getTarget().getRelocationModel();
21680   bool UseImmLabel = (MF->getTarget().getCodeModel() == CodeModel::Small) &&
21681                      (RM == Reloc::Static || RM == Reloc::DynamicNoPIC);
21682
21683   // Prepare IP either in reg or imm.
21684   if (!UseImmLabel) {
21685     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mr : X86::MOV32mr;
21686     const TargetRegisterClass *PtrRC = getRegClassFor(PVT);
21687     LabelReg = MRI.createVirtualRegister(PtrRC);
21688     if (Subtarget->is64Bit()) {
21689       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA64r), LabelReg)
21690               .addReg(X86::RIP)
21691               .addImm(0)
21692               .addReg(0)
21693               .addMBB(restoreMBB)
21694               .addReg(0);
21695     } else {
21696       const X86InstrInfo *XII = static_cast<const X86InstrInfo*>(TII);
21697       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA32r), LabelReg)
21698               .addReg(XII->getGlobalBaseReg(MF))
21699               .addImm(0)
21700               .addReg(0)
21701               .addMBB(restoreMBB, Subtarget->ClassifyBlockAddressReference())
21702               .addReg(0);
21703     }
21704   } else
21705     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mi32 : X86::MOV32mi;
21706   // Store IP
21707   MIB = BuildMI(*thisMBB, MI, DL, TII->get(PtrStoreOpc));
21708   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21709     if (i == X86::AddrDisp)
21710       MIB.addDisp(MI->getOperand(MemOpndSlot + i), LabelOffset);
21711     else
21712       MIB.addOperand(MI->getOperand(MemOpndSlot + i));
21713   }
21714   if (!UseImmLabel)
21715     MIB.addReg(LabelReg);
21716   else
21717     MIB.addMBB(restoreMBB);
21718   MIB.setMemRefs(MMOBegin, MMOEnd);
21719   // Setup
21720   MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::EH_SjLj_Setup))
21721           .addMBB(restoreMBB);
21722
21723   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
21724   MIB.addRegMask(RegInfo->getNoPreservedMask());
21725   thisMBB->addSuccessor(mainMBB);
21726   thisMBB->addSuccessor(restoreMBB);
21727
21728   // mainMBB:
21729   //  EAX = 0
21730   BuildMI(mainMBB, DL, TII->get(X86::MOV32r0), mainDstReg);
21731   mainMBB->addSuccessor(sinkMBB);
21732
21733   // sinkMBB:
21734   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
21735           TII->get(X86::PHI), DstReg)
21736     .addReg(mainDstReg).addMBB(mainMBB)
21737     .addReg(restoreDstReg).addMBB(restoreMBB);
21738
21739   // restoreMBB:
21740   if (RegInfo->hasBasePointer(*MF)) {
21741     const bool Uses64BitFramePtr =
21742         Subtarget->isTarget64BitLP64() || Subtarget->isTargetNaCl64();
21743     X86MachineFunctionInfo *X86FI = MF->getInfo<X86MachineFunctionInfo>();
21744     X86FI->setRestoreBasePointer(MF);
21745     unsigned FramePtr = RegInfo->getFrameRegister(*MF);
21746     unsigned BasePtr = RegInfo->getBaseRegister();
21747     unsigned Opm = Uses64BitFramePtr ? X86::MOV64rm : X86::MOV32rm;
21748     addRegOffset(BuildMI(restoreMBB, DL, TII->get(Opm), BasePtr),
21749                  FramePtr, true, X86FI->getRestoreBasePointerOffset())
21750       .setMIFlag(MachineInstr::FrameSetup);
21751   }
21752   BuildMI(restoreMBB, DL, TII->get(X86::MOV32ri), restoreDstReg).addImm(1);
21753   BuildMI(restoreMBB, DL, TII->get(X86::JMP_1)).addMBB(sinkMBB);
21754   restoreMBB->addSuccessor(sinkMBB);
21755
21756   MI->eraseFromParent();
21757   return sinkMBB;
21758 }
21759
21760 MachineBasicBlock *
21761 X86TargetLowering::emitEHSjLjLongJmp(MachineInstr *MI,
21762                                      MachineBasicBlock *MBB) const {
21763   DebugLoc DL = MI->getDebugLoc();
21764   MachineFunction *MF = MBB->getParent();
21765   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21766   MachineRegisterInfo &MRI = MF->getRegInfo();
21767
21768   // Memory Reference
21769   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
21770   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
21771
21772   MVT PVT = getPointerTy();
21773   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
21774          "Invalid Pointer Size!");
21775
21776   const TargetRegisterClass *RC =
21777     (PVT == MVT::i64) ? &X86::GR64RegClass : &X86::GR32RegClass;
21778   unsigned Tmp = MRI.createVirtualRegister(RC);
21779   // Since FP is only updated here but NOT referenced, it's treated as GPR.
21780   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
21781   unsigned FP = (PVT == MVT::i64) ? X86::RBP : X86::EBP;
21782   unsigned SP = RegInfo->getStackRegister();
21783
21784   MachineInstrBuilder MIB;
21785
21786   const int64_t LabelOffset = 1 * PVT.getStoreSize();
21787   const int64_t SPOffset = 2 * PVT.getStoreSize();
21788
21789   unsigned PtrLoadOpc = (PVT == MVT::i64) ? X86::MOV64rm : X86::MOV32rm;
21790   unsigned IJmpOpc = (PVT == MVT::i64) ? X86::JMP64r : X86::JMP32r;
21791
21792   // Reload FP
21793   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), FP);
21794   for (unsigned i = 0; i < X86::AddrNumOperands; ++i)
21795     MIB.addOperand(MI->getOperand(i));
21796   MIB.setMemRefs(MMOBegin, MMOEnd);
21797   // Reload IP
21798   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), Tmp);
21799   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21800     if (i == X86::AddrDisp)
21801       MIB.addDisp(MI->getOperand(i), LabelOffset);
21802     else
21803       MIB.addOperand(MI->getOperand(i));
21804   }
21805   MIB.setMemRefs(MMOBegin, MMOEnd);
21806   // Reload SP
21807   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), SP);
21808   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21809     if (i == X86::AddrDisp)
21810       MIB.addDisp(MI->getOperand(i), SPOffset);
21811     else
21812       MIB.addOperand(MI->getOperand(i));
21813   }
21814   MIB.setMemRefs(MMOBegin, MMOEnd);
21815   // Jump
21816   BuildMI(*MBB, MI, DL, TII->get(IJmpOpc)).addReg(Tmp);
21817
21818   MI->eraseFromParent();
21819   return MBB;
21820 }
21821
21822 // Replace 213-type (isel default) FMA3 instructions with 231-type for
21823 // accumulator loops. Writing back to the accumulator allows the coalescer
21824 // to remove extra copies in the loop.
21825 MachineBasicBlock *
21826 X86TargetLowering::emitFMA3Instr(MachineInstr *MI,
21827                                  MachineBasicBlock *MBB) const {
21828   MachineOperand &AddendOp = MI->getOperand(3);
21829
21830   // Bail out early if the addend isn't a register - we can't switch these.
21831   if (!AddendOp.isReg())
21832     return MBB;
21833
21834   MachineFunction &MF = *MBB->getParent();
21835   MachineRegisterInfo &MRI = MF.getRegInfo();
21836
21837   // Check whether the addend is defined by a PHI:
21838   assert(MRI.hasOneDef(AddendOp.getReg()) && "Multiple defs in SSA?");
21839   MachineInstr &AddendDef = *MRI.def_instr_begin(AddendOp.getReg());
21840   if (!AddendDef.isPHI())
21841     return MBB;
21842
21843   // Look for the following pattern:
21844   // loop:
21845   //   %addend = phi [%entry, 0], [%loop, %result]
21846   //   ...
21847   //   %result<tied1> = FMA213 %m2<tied0>, %m1, %addend
21848
21849   // Replace with:
21850   //   loop:
21851   //   %addend = phi [%entry, 0], [%loop, %result]
21852   //   ...
21853   //   %result<tied1> = FMA231 %addend<tied0>, %m1, %m2
21854
21855   for (unsigned i = 1, e = AddendDef.getNumOperands(); i < e; i += 2) {
21856     assert(AddendDef.getOperand(i).isReg());
21857     MachineOperand PHISrcOp = AddendDef.getOperand(i);
21858     MachineInstr &PHISrcInst = *MRI.def_instr_begin(PHISrcOp.getReg());
21859     if (&PHISrcInst == MI) {
21860       // Found a matching instruction.
21861       unsigned NewFMAOpc = 0;
21862       switch (MI->getOpcode()) {
21863         case X86::VFMADDPDr213r: NewFMAOpc = X86::VFMADDPDr231r; break;
21864         case X86::VFMADDPSr213r: NewFMAOpc = X86::VFMADDPSr231r; break;
21865         case X86::VFMADDSDr213r: NewFMAOpc = X86::VFMADDSDr231r; break;
21866         case X86::VFMADDSSr213r: NewFMAOpc = X86::VFMADDSSr231r; break;
21867         case X86::VFMSUBPDr213r: NewFMAOpc = X86::VFMSUBPDr231r; break;
21868         case X86::VFMSUBPSr213r: NewFMAOpc = X86::VFMSUBPSr231r; break;
21869         case X86::VFMSUBSDr213r: NewFMAOpc = X86::VFMSUBSDr231r; break;
21870         case X86::VFMSUBSSr213r: NewFMAOpc = X86::VFMSUBSSr231r; break;
21871         case X86::VFNMADDPDr213r: NewFMAOpc = X86::VFNMADDPDr231r; break;
21872         case X86::VFNMADDPSr213r: NewFMAOpc = X86::VFNMADDPSr231r; break;
21873         case X86::VFNMADDSDr213r: NewFMAOpc = X86::VFNMADDSDr231r; break;
21874         case X86::VFNMADDSSr213r: NewFMAOpc = X86::VFNMADDSSr231r; break;
21875         case X86::VFNMSUBPDr213r: NewFMAOpc = X86::VFNMSUBPDr231r; break;
21876         case X86::VFNMSUBPSr213r: NewFMAOpc = X86::VFNMSUBPSr231r; break;
21877         case X86::VFNMSUBSDr213r: NewFMAOpc = X86::VFNMSUBSDr231r; break;
21878         case X86::VFNMSUBSSr213r: NewFMAOpc = X86::VFNMSUBSSr231r; break;
21879         case X86::VFMADDSUBPDr213r: NewFMAOpc = X86::VFMADDSUBPDr231r; break;
21880         case X86::VFMADDSUBPSr213r: NewFMAOpc = X86::VFMADDSUBPSr231r; break;
21881         case X86::VFMSUBADDPDr213r: NewFMAOpc = X86::VFMSUBADDPDr231r; break;
21882         case X86::VFMSUBADDPSr213r: NewFMAOpc = X86::VFMSUBADDPSr231r; break;
21883
21884         case X86::VFMADDPDr213rY: NewFMAOpc = X86::VFMADDPDr231rY; break;
21885         case X86::VFMADDPSr213rY: NewFMAOpc = X86::VFMADDPSr231rY; break;
21886         case X86::VFMSUBPDr213rY: NewFMAOpc = X86::VFMSUBPDr231rY; break;
21887         case X86::VFMSUBPSr213rY: NewFMAOpc = X86::VFMSUBPSr231rY; break;
21888         case X86::VFNMADDPDr213rY: NewFMAOpc = X86::VFNMADDPDr231rY; break;
21889         case X86::VFNMADDPSr213rY: NewFMAOpc = X86::VFNMADDPSr231rY; break;
21890         case X86::VFNMSUBPDr213rY: NewFMAOpc = X86::VFNMSUBPDr231rY; break;
21891         case X86::VFNMSUBPSr213rY: NewFMAOpc = X86::VFNMSUBPSr231rY; break;
21892         case X86::VFMADDSUBPDr213rY: NewFMAOpc = X86::VFMADDSUBPDr231rY; break;
21893         case X86::VFMADDSUBPSr213rY: NewFMAOpc = X86::VFMADDSUBPSr231rY; break;
21894         case X86::VFMSUBADDPDr213rY: NewFMAOpc = X86::VFMSUBADDPDr231rY; break;
21895         case X86::VFMSUBADDPSr213rY: NewFMAOpc = X86::VFMSUBADDPSr231rY; break;
21896         default: llvm_unreachable("Unrecognized FMA variant.");
21897       }
21898
21899       const TargetInstrInfo &TII = *Subtarget->getInstrInfo();
21900       MachineInstrBuilder MIB =
21901         BuildMI(MF, MI->getDebugLoc(), TII.get(NewFMAOpc))
21902         .addOperand(MI->getOperand(0))
21903         .addOperand(MI->getOperand(3))
21904         .addOperand(MI->getOperand(2))
21905         .addOperand(MI->getOperand(1));
21906       MBB->insert(MachineBasicBlock::iterator(MI), MIB);
21907       MI->eraseFromParent();
21908     }
21909   }
21910
21911   return MBB;
21912 }
21913
21914 MachineBasicBlock *
21915 X86TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
21916                                                MachineBasicBlock *BB) const {
21917   switch (MI->getOpcode()) {
21918   default: llvm_unreachable("Unexpected instr type to insert");
21919   case X86::TAILJMPd64:
21920   case X86::TAILJMPr64:
21921   case X86::TAILJMPm64:
21922   case X86::TAILJMPd64_REX:
21923   case X86::TAILJMPr64_REX:
21924   case X86::TAILJMPm64_REX:
21925     llvm_unreachable("TAILJMP64 would not be touched here.");
21926   case X86::TCRETURNdi64:
21927   case X86::TCRETURNri64:
21928   case X86::TCRETURNmi64:
21929     return BB;
21930   case X86::WIN_ALLOCA:
21931     return EmitLoweredWinAlloca(MI, BB);
21932   case X86::SEG_ALLOCA_32:
21933   case X86::SEG_ALLOCA_64:
21934     return EmitLoweredSegAlloca(MI, BB);
21935   case X86::TLSCall_32:
21936   case X86::TLSCall_64:
21937     return EmitLoweredTLSCall(MI, BB);
21938   case X86::CMOV_GR8:
21939   case X86::CMOV_FR32:
21940   case X86::CMOV_FR64:
21941   case X86::CMOV_V4F32:
21942   case X86::CMOV_V2F64:
21943   case X86::CMOV_V2I64:
21944   case X86::CMOV_V8F32:
21945   case X86::CMOV_V4F64:
21946   case X86::CMOV_V4I64:
21947   case X86::CMOV_V16F32:
21948   case X86::CMOV_V8F64:
21949   case X86::CMOV_V8I64:
21950   case X86::CMOV_GR16:
21951   case X86::CMOV_GR32:
21952   case X86::CMOV_RFP32:
21953   case X86::CMOV_RFP64:
21954   case X86::CMOV_RFP80:
21955     return EmitLoweredSelect(MI, BB);
21956
21957   case X86::FP32_TO_INT16_IN_MEM:
21958   case X86::FP32_TO_INT32_IN_MEM:
21959   case X86::FP32_TO_INT64_IN_MEM:
21960   case X86::FP64_TO_INT16_IN_MEM:
21961   case X86::FP64_TO_INT32_IN_MEM:
21962   case X86::FP64_TO_INT64_IN_MEM:
21963   case X86::FP80_TO_INT16_IN_MEM:
21964   case X86::FP80_TO_INT32_IN_MEM:
21965   case X86::FP80_TO_INT64_IN_MEM: {
21966     MachineFunction *F = BB->getParent();
21967     const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21968     DebugLoc DL = MI->getDebugLoc();
21969
21970     // Change the floating point control register to use "round towards zero"
21971     // mode when truncating to an integer value.
21972     int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2, false);
21973     addFrameReference(BuildMI(*BB, MI, DL,
21974                               TII->get(X86::FNSTCW16m)), CWFrameIdx);
21975
21976     // Load the old value of the high byte of the control word...
21977     unsigned OldCW =
21978       F->getRegInfo().createVirtualRegister(&X86::GR16RegClass);
21979     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16rm), OldCW),
21980                       CWFrameIdx);
21981
21982     // Set the high part to be round to zero...
21983     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mi)), CWFrameIdx)
21984       .addImm(0xC7F);
21985
21986     // Reload the modified control word now...
21987     addFrameReference(BuildMI(*BB, MI, DL,
21988                               TII->get(X86::FLDCW16m)), CWFrameIdx);
21989
21990     // Restore the memory image of control word to original value
21991     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mr)), CWFrameIdx)
21992       .addReg(OldCW);
21993
21994     // Get the X86 opcode to use.
21995     unsigned Opc;
21996     switch (MI->getOpcode()) {
21997     default: llvm_unreachable("illegal opcode!");
21998     case X86::FP32_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m32; break;
21999     case X86::FP32_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m32; break;
22000     case X86::FP32_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m32; break;
22001     case X86::FP64_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m64; break;
22002     case X86::FP64_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m64; break;
22003     case X86::FP64_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m64; break;
22004     case X86::FP80_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m80; break;
22005     case X86::FP80_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m80; break;
22006     case X86::FP80_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m80; break;
22007     }
22008
22009     X86AddressMode AM;
22010     MachineOperand &Op = MI->getOperand(0);
22011     if (Op.isReg()) {
22012       AM.BaseType = X86AddressMode::RegBase;
22013       AM.Base.Reg = Op.getReg();
22014     } else {
22015       AM.BaseType = X86AddressMode::FrameIndexBase;
22016       AM.Base.FrameIndex = Op.getIndex();
22017     }
22018     Op = MI->getOperand(1);
22019     if (Op.isImm())
22020       AM.Scale = Op.getImm();
22021     Op = MI->getOperand(2);
22022     if (Op.isImm())
22023       AM.IndexReg = Op.getImm();
22024     Op = MI->getOperand(3);
22025     if (Op.isGlobal()) {
22026       AM.GV = Op.getGlobal();
22027     } else {
22028       AM.Disp = Op.getImm();
22029     }
22030     addFullAddress(BuildMI(*BB, MI, DL, TII->get(Opc)), AM)
22031                       .addReg(MI->getOperand(X86::AddrNumOperands).getReg());
22032
22033     // Reload the original control word now.
22034     addFrameReference(BuildMI(*BB, MI, DL,
22035                               TII->get(X86::FLDCW16m)), CWFrameIdx);
22036
22037     MI->eraseFromParent();   // The pseudo instruction is gone now.
22038     return BB;
22039   }
22040     // String/text processing lowering.
22041   case X86::PCMPISTRM128REG:
22042   case X86::VPCMPISTRM128REG:
22043   case X86::PCMPISTRM128MEM:
22044   case X86::VPCMPISTRM128MEM:
22045   case X86::PCMPESTRM128REG:
22046   case X86::VPCMPESTRM128REG:
22047   case X86::PCMPESTRM128MEM:
22048   case X86::VPCMPESTRM128MEM:
22049     assert(Subtarget->hasSSE42() &&
22050            "Target must have SSE4.2 or AVX features enabled");
22051     return EmitPCMPSTRM(MI, BB, Subtarget->getInstrInfo());
22052
22053   // String/text processing lowering.
22054   case X86::PCMPISTRIREG:
22055   case X86::VPCMPISTRIREG:
22056   case X86::PCMPISTRIMEM:
22057   case X86::VPCMPISTRIMEM:
22058   case X86::PCMPESTRIREG:
22059   case X86::VPCMPESTRIREG:
22060   case X86::PCMPESTRIMEM:
22061   case X86::VPCMPESTRIMEM:
22062     assert(Subtarget->hasSSE42() &&
22063            "Target must have SSE4.2 or AVX features enabled");
22064     return EmitPCMPSTRI(MI, BB, Subtarget->getInstrInfo());
22065
22066   // Thread synchronization.
22067   case X86::MONITOR:
22068     return EmitMonitor(MI, BB, Subtarget);
22069
22070   // xbegin
22071   case X86::XBEGIN:
22072     return EmitXBegin(MI, BB, Subtarget->getInstrInfo());
22073
22074   case X86::VASTART_SAVE_XMM_REGS:
22075     return EmitVAStartSaveXMMRegsWithCustomInserter(MI, BB);
22076
22077   case X86::VAARG_64:
22078     return EmitVAARG64WithCustomInserter(MI, BB);
22079
22080   case X86::EH_SjLj_SetJmp32:
22081   case X86::EH_SjLj_SetJmp64:
22082     return emitEHSjLjSetJmp(MI, BB);
22083
22084   case X86::EH_SjLj_LongJmp32:
22085   case X86::EH_SjLj_LongJmp64:
22086     return emitEHSjLjLongJmp(MI, BB);
22087
22088   case TargetOpcode::STATEPOINT:
22089     // As an implementation detail, STATEPOINT shares the STACKMAP format at
22090     // this point in the process.  We diverge later.
22091     return emitPatchPoint(MI, BB);
22092
22093   case TargetOpcode::STACKMAP:
22094   case TargetOpcode::PATCHPOINT:
22095     return emitPatchPoint(MI, BB);
22096
22097   case X86::VFMADDPDr213r:
22098   case X86::VFMADDPSr213r:
22099   case X86::VFMADDSDr213r:
22100   case X86::VFMADDSSr213r:
22101   case X86::VFMSUBPDr213r:
22102   case X86::VFMSUBPSr213r:
22103   case X86::VFMSUBSDr213r:
22104   case X86::VFMSUBSSr213r:
22105   case X86::VFNMADDPDr213r:
22106   case X86::VFNMADDPSr213r:
22107   case X86::VFNMADDSDr213r:
22108   case X86::VFNMADDSSr213r:
22109   case X86::VFNMSUBPDr213r:
22110   case X86::VFNMSUBPSr213r:
22111   case X86::VFNMSUBSDr213r:
22112   case X86::VFNMSUBSSr213r:
22113   case X86::VFMADDSUBPDr213r:
22114   case X86::VFMADDSUBPSr213r:
22115   case X86::VFMSUBADDPDr213r:
22116   case X86::VFMSUBADDPSr213r:
22117   case X86::VFMADDPDr213rY:
22118   case X86::VFMADDPSr213rY:
22119   case X86::VFMSUBPDr213rY:
22120   case X86::VFMSUBPSr213rY:
22121   case X86::VFNMADDPDr213rY:
22122   case X86::VFNMADDPSr213rY:
22123   case X86::VFNMSUBPDr213rY:
22124   case X86::VFNMSUBPSr213rY:
22125   case X86::VFMADDSUBPDr213rY:
22126   case X86::VFMADDSUBPSr213rY:
22127   case X86::VFMSUBADDPDr213rY:
22128   case X86::VFMSUBADDPSr213rY:
22129     return emitFMA3Instr(MI, BB);
22130   }
22131 }
22132
22133 //===----------------------------------------------------------------------===//
22134 //                           X86 Optimization Hooks
22135 //===----------------------------------------------------------------------===//
22136
22137 void X86TargetLowering::computeKnownBitsForTargetNode(const SDValue Op,
22138                                                       APInt &KnownZero,
22139                                                       APInt &KnownOne,
22140                                                       const SelectionDAG &DAG,
22141                                                       unsigned Depth) const {
22142   unsigned BitWidth = KnownZero.getBitWidth();
22143   unsigned Opc = Op.getOpcode();
22144   assert((Opc >= ISD::BUILTIN_OP_END ||
22145           Opc == ISD::INTRINSIC_WO_CHAIN ||
22146           Opc == ISD::INTRINSIC_W_CHAIN ||
22147           Opc == ISD::INTRINSIC_VOID) &&
22148          "Should use MaskedValueIsZero if you don't know whether Op"
22149          " is a target node!");
22150
22151   KnownZero = KnownOne = APInt(BitWidth, 0);   // Don't know anything.
22152   switch (Opc) {
22153   default: break;
22154   case X86ISD::ADD:
22155   case X86ISD::SUB:
22156   case X86ISD::ADC:
22157   case X86ISD::SBB:
22158   case X86ISD::SMUL:
22159   case X86ISD::UMUL:
22160   case X86ISD::INC:
22161   case X86ISD::DEC:
22162   case X86ISD::OR:
22163   case X86ISD::XOR:
22164   case X86ISD::AND:
22165     // These nodes' second result is a boolean.
22166     if (Op.getResNo() == 0)
22167       break;
22168     // Fallthrough
22169   case X86ISD::SETCC:
22170     KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
22171     break;
22172   case ISD::INTRINSIC_WO_CHAIN: {
22173     unsigned IntId = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
22174     unsigned NumLoBits = 0;
22175     switch (IntId) {
22176     default: break;
22177     case Intrinsic::x86_sse_movmsk_ps:
22178     case Intrinsic::x86_avx_movmsk_ps_256:
22179     case Intrinsic::x86_sse2_movmsk_pd:
22180     case Intrinsic::x86_avx_movmsk_pd_256:
22181     case Intrinsic::x86_mmx_pmovmskb:
22182     case Intrinsic::x86_sse2_pmovmskb_128:
22183     case Intrinsic::x86_avx2_pmovmskb: {
22184       // High bits of movmskp{s|d}, pmovmskb are known zero.
22185       switch (IntId) {
22186         default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
22187         case Intrinsic::x86_sse_movmsk_ps:      NumLoBits = 4; break;
22188         case Intrinsic::x86_avx_movmsk_ps_256:  NumLoBits = 8; break;
22189         case Intrinsic::x86_sse2_movmsk_pd:     NumLoBits = 2; break;
22190         case Intrinsic::x86_avx_movmsk_pd_256:  NumLoBits = 4; break;
22191         case Intrinsic::x86_mmx_pmovmskb:       NumLoBits = 8; break;
22192         case Intrinsic::x86_sse2_pmovmskb_128:  NumLoBits = 16; break;
22193         case Intrinsic::x86_avx2_pmovmskb:      NumLoBits = 32; break;
22194       }
22195       KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - NumLoBits);
22196       break;
22197     }
22198     }
22199     break;
22200   }
22201   }
22202 }
22203
22204 unsigned X86TargetLowering::ComputeNumSignBitsForTargetNode(
22205   SDValue Op,
22206   const SelectionDAG &,
22207   unsigned Depth) const {
22208   // SETCC_CARRY sets the dest to ~0 for true or 0 for false.
22209   if (Op.getOpcode() == X86ISD::SETCC_CARRY)
22210     return Op.getValueType().getScalarType().getSizeInBits();
22211
22212   // Fallback case.
22213   return 1;
22214 }
22215
22216 /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
22217 /// node is a GlobalAddress + offset.
22218 bool X86TargetLowering::isGAPlusOffset(SDNode *N,
22219                                        const GlobalValue* &GA,
22220                                        int64_t &Offset) const {
22221   if (N->getOpcode() == X86ISD::Wrapper) {
22222     if (isa<GlobalAddressSDNode>(N->getOperand(0))) {
22223       GA = cast<GlobalAddressSDNode>(N->getOperand(0))->getGlobal();
22224       Offset = cast<GlobalAddressSDNode>(N->getOperand(0))->getOffset();
22225       return true;
22226     }
22227   }
22228   return TargetLowering::isGAPlusOffset(N, GA, Offset);
22229 }
22230
22231 /// isShuffleHigh128VectorInsertLow - Checks whether the shuffle node is the
22232 /// same as extracting the high 128-bit part of 256-bit vector and then
22233 /// inserting the result into the low part of a new 256-bit vector
22234 static bool isShuffleHigh128VectorInsertLow(ShuffleVectorSDNode *SVOp) {
22235   EVT VT = SVOp->getValueType(0);
22236   unsigned NumElems = VT.getVectorNumElements();
22237
22238   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
22239   for (unsigned i = 0, j = NumElems/2; i != NumElems/2; ++i, ++j)
22240     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
22241         SVOp->getMaskElt(j) >= 0)
22242       return false;
22243
22244   return true;
22245 }
22246
22247 /// isShuffleLow128VectorInsertHigh - Checks whether the shuffle node is the
22248 /// same as extracting the low 128-bit part of 256-bit vector and then
22249 /// inserting the result into the high part of a new 256-bit vector
22250 static bool isShuffleLow128VectorInsertHigh(ShuffleVectorSDNode *SVOp) {
22251   EVT VT = SVOp->getValueType(0);
22252   unsigned NumElems = VT.getVectorNumElements();
22253
22254   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
22255   for (unsigned i = NumElems/2, j = 0; i != NumElems; ++i, ++j)
22256     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
22257         SVOp->getMaskElt(j) >= 0)
22258       return false;
22259
22260   return true;
22261 }
22262
22263 /// PerformShuffleCombine256 - Performs shuffle combines for 256-bit vectors.
22264 static SDValue PerformShuffleCombine256(SDNode *N, SelectionDAG &DAG,
22265                                         TargetLowering::DAGCombinerInfo &DCI,
22266                                         const X86Subtarget* Subtarget) {
22267   SDLoc dl(N);
22268   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
22269   SDValue V1 = SVOp->getOperand(0);
22270   SDValue V2 = SVOp->getOperand(1);
22271   EVT VT = SVOp->getValueType(0);
22272   unsigned NumElems = VT.getVectorNumElements();
22273
22274   if (V1.getOpcode() == ISD::CONCAT_VECTORS &&
22275       V2.getOpcode() == ISD::CONCAT_VECTORS) {
22276     //
22277     //                   0,0,0,...
22278     //                      |
22279     //    V      UNDEF    BUILD_VECTOR    UNDEF
22280     //     \      /           \           /
22281     //  CONCAT_VECTOR         CONCAT_VECTOR
22282     //         \                  /
22283     //          \                /
22284     //          RESULT: V + zero extended
22285     //
22286     if (V2.getOperand(0).getOpcode() != ISD::BUILD_VECTOR ||
22287         V2.getOperand(1).getOpcode() != ISD::UNDEF ||
22288         V1.getOperand(1).getOpcode() != ISD::UNDEF)
22289       return SDValue();
22290
22291     if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
22292       return SDValue();
22293
22294     // To match the shuffle mask, the first half of the mask should
22295     // be exactly the first vector, and all the rest a splat with the
22296     // first element of the second one.
22297     for (unsigned i = 0; i != NumElems/2; ++i)
22298       if (!isUndefOrEqual(SVOp->getMaskElt(i), i) ||
22299           !isUndefOrEqual(SVOp->getMaskElt(i+NumElems/2), NumElems))
22300         return SDValue();
22301
22302     // If V1 is coming from a vector load then just fold to a VZEXT_LOAD.
22303     if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(V1.getOperand(0))) {
22304       if (Ld->hasNUsesOfValue(1, 0)) {
22305         SDVTList Tys = DAG.getVTList(MVT::v4i64, MVT::Other);
22306         SDValue Ops[] = { Ld->getChain(), Ld->getBasePtr() };
22307         SDValue ResNode =
22308           DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, dl, Tys, Ops,
22309                                   Ld->getMemoryVT(),
22310                                   Ld->getPointerInfo(),
22311                                   Ld->getAlignment(),
22312                                   false/*isVolatile*/, true/*ReadMem*/,
22313                                   false/*WriteMem*/);
22314
22315         // Make sure the newly-created LOAD is in the same position as Ld in
22316         // terms of dependency. We create a TokenFactor for Ld and ResNode,
22317         // and update uses of Ld's output chain to use the TokenFactor.
22318         if (Ld->hasAnyUseOfValue(1)) {
22319           SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
22320                              SDValue(Ld, 1), SDValue(ResNode.getNode(), 1));
22321           DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), NewChain);
22322           DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(Ld, 1),
22323                                  SDValue(ResNode.getNode(), 1));
22324         }
22325
22326         return DAG.getNode(ISD::BITCAST, dl, VT, ResNode);
22327       }
22328     }
22329
22330     // Emit a zeroed vector and insert the desired subvector on its
22331     // first half.
22332     SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
22333     SDValue InsV = Insert128BitVector(Zeros, V1.getOperand(0), 0, DAG, dl);
22334     return DCI.CombineTo(N, InsV);
22335   }
22336
22337   //===--------------------------------------------------------------------===//
22338   // Combine some shuffles into subvector extracts and inserts:
22339   //
22340
22341   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
22342   if (isShuffleHigh128VectorInsertLow(SVOp)) {
22343     SDValue V = Extract128BitVector(V1, NumElems/2, DAG, dl);
22344     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, 0, DAG, dl);
22345     return DCI.CombineTo(N, InsV);
22346   }
22347
22348   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
22349   if (isShuffleLow128VectorInsertHigh(SVOp)) {
22350     SDValue V = Extract128BitVector(V1, 0, DAG, dl);
22351     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, NumElems/2, DAG, dl);
22352     return DCI.CombineTo(N, InsV);
22353   }
22354
22355   return SDValue();
22356 }
22357
22358 /// \brief Combine an arbitrary chain of shuffles into a single instruction if
22359 /// possible.
22360 ///
22361 /// This is the leaf of the recursive combinine below. When we have found some
22362 /// chain of single-use x86 shuffle instructions and accumulated the combined
22363 /// shuffle mask represented by them, this will try to pattern match that mask
22364 /// into either a single instruction if there is a special purpose instruction
22365 /// for this operation, or into a PSHUFB instruction which is a fully general
22366 /// instruction but should only be used to replace chains over a certain depth.
22367 static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef<int> Mask,
22368                                    int Depth, bool HasPSHUFB, SelectionDAG &DAG,
22369                                    TargetLowering::DAGCombinerInfo &DCI,
22370                                    const X86Subtarget *Subtarget) {
22371   assert(!Mask.empty() && "Cannot combine an empty shuffle mask!");
22372
22373   // Find the operand that enters the chain. Note that multiple uses are OK
22374   // here, we're not going to remove the operand we find.
22375   SDValue Input = Op.getOperand(0);
22376   while (Input.getOpcode() == ISD::BITCAST)
22377     Input = Input.getOperand(0);
22378
22379   MVT VT = Input.getSimpleValueType();
22380   MVT RootVT = Root.getSimpleValueType();
22381   SDLoc DL(Root);
22382
22383   // Just remove no-op shuffle masks.
22384   if (Mask.size() == 1) {
22385     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Input),
22386                   /*AddTo*/ true);
22387     return true;
22388   }
22389
22390   // Use the float domain if the operand type is a floating point type.
22391   bool FloatDomain = VT.isFloatingPoint();
22392
22393   // For floating point shuffles, we don't have free copies in the shuffle
22394   // instructions or the ability to load as part of the instruction, so
22395   // canonicalize their shuffles to UNPCK or MOV variants.
22396   //
22397   // Note that even with AVX we prefer the PSHUFD form of shuffle for integer
22398   // vectors because it can have a load folded into it that UNPCK cannot. This
22399   // doesn't preclude something switching to the shorter encoding post-RA.
22400   if (FloatDomain) {
22401     if (Mask.equals(0, 0) || Mask.equals(1, 1)) {
22402       bool Lo = Mask.equals(0, 0);
22403       unsigned Shuffle;
22404       MVT ShuffleVT;
22405       // Check if we have SSE3 which will let us use MOVDDUP. That instruction
22406       // is no slower than UNPCKLPD but has the option to fold the input operand
22407       // into even an unaligned memory load.
22408       if (Lo && Subtarget->hasSSE3()) {
22409         Shuffle = X86ISD::MOVDDUP;
22410         ShuffleVT = MVT::v2f64;
22411       } else {
22412         // We have MOVLHPS and MOVHLPS throughout SSE and they encode smaller
22413         // than the UNPCK variants.
22414         Shuffle = Lo ? X86ISD::MOVLHPS : X86ISD::MOVHLPS;
22415         ShuffleVT = MVT::v4f32;
22416       }
22417       if (Depth == 1 && Root->getOpcode() == Shuffle)
22418         return false; // Nothing to do!
22419       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22420       DCI.AddToWorklist(Op.getNode());
22421       if (Shuffle == X86ISD::MOVDDUP)
22422         Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op);
22423       else
22424         Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22425       DCI.AddToWorklist(Op.getNode());
22426       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22427                     /*AddTo*/ true);
22428       return true;
22429     }
22430     if (Subtarget->hasSSE3() &&
22431         (Mask.equals(0, 0, 2, 2) || Mask.equals(1, 1, 3, 3))) {
22432       bool Lo = Mask.equals(0, 0, 2, 2);
22433       unsigned Shuffle = Lo ? X86ISD::MOVSLDUP : X86ISD::MOVSHDUP;
22434       MVT ShuffleVT = MVT::v4f32;
22435       if (Depth == 1 && Root->getOpcode() == Shuffle)
22436         return false; // Nothing to do!
22437       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22438       DCI.AddToWorklist(Op.getNode());
22439       Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op);
22440       DCI.AddToWorklist(Op.getNode());
22441       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22442                     /*AddTo*/ true);
22443       return true;
22444     }
22445     if (Mask.equals(0, 0, 1, 1) || Mask.equals(2, 2, 3, 3)) {
22446       bool Lo = Mask.equals(0, 0, 1, 1);
22447       unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
22448       MVT ShuffleVT = MVT::v4f32;
22449       if (Depth == 1 && Root->getOpcode() == Shuffle)
22450         return false; // Nothing to do!
22451       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22452       DCI.AddToWorklist(Op.getNode());
22453       Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22454       DCI.AddToWorklist(Op.getNode());
22455       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22456                     /*AddTo*/ true);
22457       return true;
22458     }
22459   }
22460
22461   // We always canonicalize the 8 x i16 and 16 x i8 shuffles into their UNPCK
22462   // variants as none of these have single-instruction variants that are
22463   // superior to the UNPCK formulation.
22464   if (!FloatDomain &&
22465       (Mask.equals(0, 0, 1, 1, 2, 2, 3, 3) ||
22466        Mask.equals(4, 4, 5, 5, 6, 6, 7, 7) ||
22467        Mask.equals(0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7) ||
22468        Mask.equals(8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15,
22469                    15))) {
22470     bool Lo = Mask[0] == 0;
22471     unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
22472     if (Depth == 1 && Root->getOpcode() == Shuffle)
22473       return false; // Nothing to do!
22474     MVT ShuffleVT;
22475     switch (Mask.size()) {
22476     case 8:
22477       ShuffleVT = MVT::v8i16;
22478       break;
22479     case 16:
22480       ShuffleVT = MVT::v16i8;
22481       break;
22482     default:
22483       llvm_unreachable("Impossible mask size!");
22484     };
22485     Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22486     DCI.AddToWorklist(Op.getNode());
22487     Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22488     DCI.AddToWorklist(Op.getNode());
22489     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22490                   /*AddTo*/ true);
22491     return true;
22492   }
22493
22494   // Don't try to re-form single instruction chains under any circumstances now
22495   // that we've done encoding canonicalization for them.
22496   if (Depth < 2)
22497     return false;
22498
22499   // If we have 3 or more shuffle instructions or a chain involving PSHUFB, we
22500   // can replace them with a single PSHUFB instruction profitably. Intel's
22501   // manuals suggest only using PSHUFB if doing so replacing 5 instructions, but
22502   // in practice PSHUFB tends to be *very* fast so we're more aggressive.
22503   if ((Depth >= 3 || HasPSHUFB) && Subtarget->hasSSSE3()) {
22504     SmallVector<SDValue, 16> PSHUFBMask;
22505     assert(Mask.size() <= 16 && "Can't shuffle elements smaller than bytes!");
22506     int Ratio = 16 / Mask.size();
22507     for (unsigned i = 0; i < 16; ++i) {
22508       if (Mask[i / Ratio] == SM_SentinelUndef) {
22509         PSHUFBMask.push_back(DAG.getUNDEF(MVT::i8));
22510         continue;
22511       }
22512       int M = Mask[i / Ratio] != SM_SentinelZero
22513                   ? Ratio * Mask[i / Ratio] + i % Ratio
22514                   : 255;
22515       PSHUFBMask.push_back(DAG.getConstant(M, MVT::i8));
22516     }
22517     Op = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Input);
22518     DCI.AddToWorklist(Op.getNode());
22519     SDValue PSHUFBMaskOp =
22520         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, PSHUFBMask);
22521     DCI.AddToWorklist(PSHUFBMaskOp.getNode());
22522     Op = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, Op, PSHUFBMaskOp);
22523     DCI.AddToWorklist(Op.getNode());
22524     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22525                   /*AddTo*/ true);
22526     return true;
22527   }
22528
22529   // Failed to find any combines.
22530   return false;
22531 }
22532
22533 /// \brief Fully generic combining of x86 shuffle instructions.
22534 ///
22535 /// This should be the last combine run over the x86 shuffle instructions. Once
22536 /// they have been fully optimized, this will recursively consider all chains
22537 /// of single-use shuffle instructions, build a generic model of the cumulative
22538 /// shuffle operation, and check for simpler instructions which implement this
22539 /// operation. We use this primarily for two purposes:
22540 ///
22541 /// 1) Collapse generic shuffles to specialized single instructions when
22542 ///    equivalent. In most cases, this is just an encoding size win, but
22543 ///    sometimes we will collapse multiple generic shuffles into a single
22544 ///    special-purpose shuffle.
22545 /// 2) Look for sequences of shuffle instructions with 3 or more total
22546 ///    instructions, and replace them with the slightly more expensive SSSE3
22547 ///    PSHUFB instruction if available. We do this as the last combining step
22548 ///    to ensure we avoid using PSHUFB if we can implement the shuffle with
22549 ///    a suitable short sequence of other instructions. The PHUFB will either
22550 ///    use a register or have to read from memory and so is slightly (but only
22551 ///    slightly) more expensive than the other shuffle instructions.
22552 ///
22553 /// Because this is inherently a quadratic operation (for each shuffle in
22554 /// a chain, we recurse up the chain), the depth is limited to 8 instructions.
22555 /// This should never be an issue in practice as the shuffle lowering doesn't
22556 /// produce sequences of more than 8 instructions.
22557 ///
22558 /// FIXME: We will currently miss some cases where the redundant shuffling
22559 /// would simplify under the threshold for PSHUFB formation because of
22560 /// combine-ordering. To fix this, we should do the redundant instruction
22561 /// combining in this recursive walk.
22562 static bool combineX86ShufflesRecursively(SDValue Op, SDValue Root,
22563                                           ArrayRef<int> RootMask,
22564                                           int Depth, bool HasPSHUFB,
22565                                           SelectionDAG &DAG,
22566                                           TargetLowering::DAGCombinerInfo &DCI,
22567                                           const X86Subtarget *Subtarget) {
22568   // Bound the depth of our recursive combine because this is ultimately
22569   // quadratic in nature.
22570   if (Depth > 8)
22571     return false;
22572
22573   // Directly rip through bitcasts to find the underlying operand.
22574   while (Op.getOpcode() == ISD::BITCAST && Op.getOperand(0).hasOneUse())
22575     Op = Op.getOperand(0);
22576
22577   MVT VT = Op.getSimpleValueType();
22578   if (!VT.isVector())
22579     return false; // Bail if we hit a non-vector.
22580   // FIXME: This routine should be taught about 256-bit shuffles, or a 256-bit
22581   // version should be added.
22582   if (VT.getSizeInBits() != 128)
22583     return false;
22584
22585   assert(Root.getSimpleValueType().isVector() &&
22586          "Shuffles operate on vector types!");
22587   assert(VT.getSizeInBits() == Root.getSimpleValueType().getSizeInBits() &&
22588          "Can only combine shuffles of the same vector register size.");
22589
22590   if (!isTargetShuffle(Op.getOpcode()))
22591     return false;
22592   SmallVector<int, 16> OpMask;
22593   bool IsUnary;
22594   bool HaveMask = getTargetShuffleMask(Op.getNode(), VT, OpMask, IsUnary);
22595   // We only can combine unary shuffles which we can decode the mask for.
22596   if (!HaveMask || !IsUnary)
22597     return false;
22598
22599   assert(VT.getVectorNumElements() == OpMask.size() &&
22600          "Different mask size from vector size!");
22601   assert(((RootMask.size() > OpMask.size() &&
22602            RootMask.size() % OpMask.size() == 0) ||
22603           (OpMask.size() > RootMask.size() &&
22604            OpMask.size() % RootMask.size() == 0) ||
22605           OpMask.size() == RootMask.size()) &&
22606          "The smaller number of elements must divide the larger.");
22607   int RootRatio = std::max<int>(1, OpMask.size() / RootMask.size());
22608   int OpRatio = std::max<int>(1, RootMask.size() / OpMask.size());
22609   assert(((RootRatio == 1 && OpRatio == 1) ||
22610           (RootRatio == 1) != (OpRatio == 1)) &&
22611          "Must not have a ratio for both incoming and op masks!");
22612
22613   SmallVector<int, 16> Mask;
22614   Mask.reserve(std::max(OpMask.size(), RootMask.size()));
22615
22616   // Merge this shuffle operation's mask into our accumulated mask. Note that
22617   // this shuffle's mask will be the first applied to the input, followed by the
22618   // root mask to get us all the way to the root value arrangement. The reason
22619   // for this order is that we are recursing up the operation chain.
22620   for (int i = 0, e = std::max(OpMask.size(), RootMask.size()); i < e; ++i) {
22621     int RootIdx = i / RootRatio;
22622     if (RootMask[RootIdx] < 0) {
22623       // This is a zero or undef lane, we're done.
22624       Mask.push_back(RootMask[RootIdx]);
22625       continue;
22626     }
22627
22628     int RootMaskedIdx = RootMask[RootIdx] * RootRatio + i % RootRatio;
22629     int OpIdx = RootMaskedIdx / OpRatio;
22630     if (OpMask[OpIdx] < 0) {
22631       // The incoming lanes are zero or undef, it doesn't matter which ones we
22632       // are using.
22633       Mask.push_back(OpMask[OpIdx]);
22634       continue;
22635     }
22636
22637     // Ok, we have non-zero lanes, map them through.
22638     Mask.push_back(OpMask[OpIdx] * OpRatio +
22639                    RootMaskedIdx % OpRatio);
22640   }
22641
22642   // See if we can recurse into the operand to combine more things.
22643   switch (Op.getOpcode()) {
22644     case X86ISD::PSHUFB:
22645       HasPSHUFB = true;
22646     case X86ISD::PSHUFD:
22647     case X86ISD::PSHUFHW:
22648     case X86ISD::PSHUFLW:
22649       if (Op.getOperand(0).hasOneUse() &&
22650           combineX86ShufflesRecursively(Op.getOperand(0), Root, Mask, Depth + 1,
22651                                         HasPSHUFB, DAG, DCI, Subtarget))
22652         return true;
22653       break;
22654
22655     case X86ISD::UNPCKL:
22656     case X86ISD::UNPCKH:
22657       assert(Op.getOperand(0) == Op.getOperand(1) && "We only combine unary shuffles!");
22658       // We can't check for single use, we have to check that this shuffle is the only user.
22659       if (Op->isOnlyUserOf(Op.getOperand(0).getNode()) &&
22660           combineX86ShufflesRecursively(Op.getOperand(0), Root, Mask, Depth + 1,
22661                                         HasPSHUFB, DAG, DCI, Subtarget))
22662           return true;
22663       break;
22664   }
22665
22666   // Minor canonicalization of the accumulated shuffle mask to make it easier
22667   // to match below. All this does is detect masks with squential pairs of
22668   // elements, and shrink them to the half-width mask. It does this in a loop
22669   // so it will reduce the size of the mask to the minimal width mask which
22670   // performs an equivalent shuffle.
22671   SmallVector<int, 16> WidenedMask;
22672   while (Mask.size() > 1 && canWidenShuffleElements(Mask, WidenedMask)) {
22673     Mask = std::move(WidenedMask);
22674     WidenedMask.clear();
22675   }
22676
22677   return combineX86ShuffleChain(Op, Root, Mask, Depth, HasPSHUFB, DAG, DCI,
22678                                 Subtarget);
22679 }
22680
22681 /// \brief Get the PSHUF-style mask from PSHUF node.
22682 ///
22683 /// This is a very minor wrapper around getTargetShuffleMask to easy forming v4
22684 /// PSHUF-style masks that can be reused with such instructions.
22685 static SmallVector<int, 4> getPSHUFShuffleMask(SDValue N) {
22686   SmallVector<int, 4> Mask;
22687   bool IsUnary;
22688   bool HaveMask = getTargetShuffleMask(N.getNode(), N.getSimpleValueType(), Mask, IsUnary);
22689   (void)HaveMask;
22690   assert(HaveMask);
22691
22692   switch (N.getOpcode()) {
22693   case X86ISD::PSHUFD:
22694     return Mask;
22695   case X86ISD::PSHUFLW:
22696     Mask.resize(4);
22697     return Mask;
22698   case X86ISD::PSHUFHW:
22699     Mask.erase(Mask.begin(), Mask.begin() + 4);
22700     for (int &M : Mask)
22701       M -= 4;
22702     return Mask;
22703   default:
22704     llvm_unreachable("No valid shuffle instruction found!");
22705   }
22706 }
22707
22708 /// \brief Search for a combinable shuffle across a chain ending in pshufd.
22709 ///
22710 /// We walk up the chain and look for a combinable shuffle, skipping over
22711 /// shuffles that we could hoist this shuffle's transformation past without
22712 /// altering anything.
22713 static SDValue
22714 combineRedundantDWordShuffle(SDValue N, MutableArrayRef<int> Mask,
22715                              SelectionDAG &DAG,
22716                              TargetLowering::DAGCombinerInfo &DCI) {
22717   assert(N.getOpcode() == X86ISD::PSHUFD &&
22718          "Called with something other than an x86 128-bit half shuffle!");
22719   SDLoc DL(N);
22720
22721   // Walk up a single-use chain looking for a combinable shuffle. Keep a stack
22722   // of the shuffles in the chain so that we can form a fresh chain to replace
22723   // this one.
22724   SmallVector<SDValue, 8> Chain;
22725   SDValue V = N.getOperand(0);
22726   for (; V.hasOneUse(); V = V.getOperand(0)) {
22727     switch (V.getOpcode()) {
22728     default:
22729       return SDValue(); // Nothing combined!
22730
22731     case ISD::BITCAST:
22732       // Skip bitcasts as we always know the type for the target specific
22733       // instructions.
22734       continue;
22735
22736     case X86ISD::PSHUFD:
22737       // Found another dword shuffle.
22738       break;
22739
22740     case X86ISD::PSHUFLW:
22741       // Check that the low words (being shuffled) are the identity in the
22742       // dword shuffle, and the high words are self-contained.
22743       if (Mask[0] != 0 || Mask[1] != 1 ||
22744           !(Mask[2] >= 2 && Mask[2] < 4 && Mask[3] >= 2 && Mask[3] < 4))
22745         return SDValue();
22746
22747       Chain.push_back(V);
22748       continue;
22749
22750     case X86ISD::PSHUFHW:
22751       // Check that the high words (being shuffled) are the identity in the
22752       // dword shuffle, and the low words are self-contained.
22753       if (Mask[2] != 2 || Mask[3] != 3 ||
22754           !(Mask[0] >= 0 && Mask[0] < 2 && Mask[1] >= 0 && Mask[1] < 2))
22755         return SDValue();
22756
22757       Chain.push_back(V);
22758       continue;
22759
22760     case X86ISD::UNPCKL:
22761     case X86ISD::UNPCKH:
22762       // For either i8 -> i16 or i16 -> i32 unpacks, we can combine a dword
22763       // shuffle into a preceding word shuffle.
22764       if (V.getValueType() != MVT::v16i8 && V.getValueType() != MVT::v8i16)
22765         return SDValue();
22766
22767       // Search for a half-shuffle which we can combine with.
22768       unsigned CombineOp =
22769           V.getOpcode() == X86ISD::UNPCKL ? X86ISD::PSHUFLW : X86ISD::PSHUFHW;
22770       if (V.getOperand(0) != V.getOperand(1) ||
22771           !V->isOnlyUserOf(V.getOperand(0).getNode()))
22772         return SDValue();
22773       Chain.push_back(V);
22774       V = V.getOperand(0);
22775       do {
22776         switch (V.getOpcode()) {
22777         default:
22778           return SDValue(); // Nothing to combine.
22779
22780         case X86ISD::PSHUFLW:
22781         case X86ISD::PSHUFHW:
22782           if (V.getOpcode() == CombineOp)
22783             break;
22784
22785           Chain.push_back(V);
22786
22787           // Fallthrough!
22788         case ISD::BITCAST:
22789           V = V.getOperand(0);
22790           continue;
22791         }
22792         break;
22793       } while (V.hasOneUse());
22794       break;
22795     }
22796     // Break out of the loop if we break out of the switch.
22797     break;
22798   }
22799
22800   if (!V.hasOneUse())
22801     // We fell out of the loop without finding a viable combining instruction.
22802     return SDValue();
22803
22804   // Merge this node's mask and our incoming mask.
22805   SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22806   for (int &M : Mask)
22807     M = VMask[M];
22808   V = DAG.getNode(V.getOpcode(), DL, V.getValueType(), V.getOperand(0),
22809                   getV4X86ShuffleImm8ForMask(Mask, DAG));
22810
22811   // Rebuild the chain around this new shuffle.
22812   while (!Chain.empty()) {
22813     SDValue W = Chain.pop_back_val();
22814
22815     if (V.getValueType() != W.getOperand(0).getValueType())
22816       V = DAG.getNode(ISD::BITCAST, DL, W.getOperand(0).getValueType(), V);
22817
22818     switch (W.getOpcode()) {
22819     default:
22820       llvm_unreachable("Only PSHUF and UNPCK instructions get here!");
22821
22822     case X86ISD::UNPCKL:
22823     case X86ISD::UNPCKH:
22824       V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, V);
22825       break;
22826
22827     case X86ISD::PSHUFD:
22828     case X86ISD::PSHUFLW:
22829     case X86ISD::PSHUFHW:
22830       V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, W.getOperand(1));
22831       break;
22832     }
22833   }
22834   if (V.getValueType() != N.getValueType())
22835     V = DAG.getNode(ISD::BITCAST, DL, N.getValueType(), V);
22836
22837   // Return the new chain to replace N.
22838   return V;
22839 }
22840
22841 /// \brief Search for a combinable shuffle across a chain ending in pshuflw or pshufhw.
22842 ///
22843 /// We walk up the chain, skipping shuffles of the other half and looking
22844 /// through shuffles which switch halves trying to find a shuffle of the same
22845 /// pair of dwords.
22846 static bool combineRedundantHalfShuffle(SDValue N, MutableArrayRef<int> Mask,
22847                                         SelectionDAG &DAG,
22848                                         TargetLowering::DAGCombinerInfo &DCI) {
22849   assert(
22850       (N.getOpcode() == X86ISD::PSHUFLW || N.getOpcode() == X86ISD::PSHUFHW) &&
22851       "Called with something other than an x86 128-bit half shuffle!");
22852   SDLoc DL(N);
22853   unsigned CombineOpcode = N.getOpcode();
22854
22855   // Walk up a single-use chain looking for a combinable shuffle.
22856   SDValue V = N.getOperand(0);
22857   for (; V.hasOneUse(); V = V.getOperand(0)) {
22858     switch (V.getOpcode()) {
22859     default:
22860       return false; // Nothing combined!
22861
22862     case ISD::BITCAST:
22863       // Skip bitcasts as we always know the type for the target specific
22864       // instructions.
22865       continue;
22866
22867     case X86ISD::PSHUFLW:
22868     case X86ISD::PSHUFHW:
22869       if (V.getOpcode() == CombineOpcode)
22870         break;
22871
22872       // Other-half shuffles are no-ops.
22873       continue;
22874     }
22875     // Break out of the loop if we break out of the switch.
22876     break;
22877   }
22878
22879   if (!V.hasOneUse())
22880     // We fell out of the loop without finding a viable combining instruction.
22881     return false;
22882
22883   // Combine away the bottom node as its shuffle will be accumulated into
22884   // a preceding shuffle.
22885   DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
22886
22887   // Record the old value.
22888   SDValue Old = V;
22889
22890   // Merge this node's mask and our incoming mask (adjusted to account for all
22891   // the pshufd instructions encountered).
22892   SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22893   for (int &M : Mask)
22894     M = VMask[M];
22895   V = DAG.getNode(V.getOpcode(), DL, MVT::v8i16, V.getOperand(0),
22896                   getV4X86ShuffleImm8ForMask(Mask, DAG));
22897
22898   // Check that the shuffles didn't cancel each other out. If not, we need to
22899   // combine to the new one.
22900   if (Old != V)
22901     // Replace the combinable shuffle with the combined one, updating all users
22902     // so that we re-evaluate the chain here.
22903     DCI.CombineTo(Old.getNode(), V, /*AddTo*/ true);
22904
22905   return true;
22906 }
22907
22908 /// \brief Try to combine x86 target specific shuffles.
22909 static SDValue PerformTargetShuffleCombine(SDValue N, SelectionDAG &DAG,
22910                                            TargetLowering::DAGCombinerInfo &DCI,
22911                                            const X86Subtarget *Subtarget) {
22912   SDLoc DL(N);
22913   MVT VT = N.getSimpleValueType();
22914   SmallVector<int, 4> Mask;
22915
22916   switch (N.getOpcode()) {
22917   case X86ISD::PSHUFD:
22918   case X86ISD::PSHUFLW:
22919   case X86ISD::PSHUFHW:
22920     Mask = getPSHUFShuffleMask(N);
22921     assert(Mask.size() == 4);
22922     break;
22923   default:
22924     return SDValue();
22925   }
22926
22927   // Nuke no-op shuffles that show up after combining.
22928   if (isNoopShuffleMask(Mask))
22929     return DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
22930
22931   // Look for simplifications involving one or two shuffle instructions.
22932   SDValue V = N.getOperand(0);
22933   switch (N.getOpcode()) {
22934   default:
22935     break;
22936   case X86ISD::PSHUFLW:
22937   case X86ISD::PSHUFHW:
22938     assert(VT == MVT::v8i16);
22939     (void)VT;
22940
22941     if (combineRedundantHalfShuffle(N, Mask, DAG, DCI))
22942       return SDValue(); // We combined away this shuffle, so we're done.
22943
22944     // See if this reduces to a PSHUFD which is no more expensive and can
22945     // combine with more operations. Note that it has to at least flip the
22946     // dwords as otherwise it would have been removed as a no-op.
22947     if (Mask[0] == 2 && Mask[1] == 3 && Mask[2] == 0 && Mask[3] == 1) {
22948       int DMask[] = {0, 1, 2, 3};
22949       int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2;
22950       DMask[DOffset + 0] = DOffset + 1;
22951       DMask[DOffset + 1] = DOffset + 0;
22952       V = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V);
22953       DCI.AddToWorklist(V.getNode());
22954       V = DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V,
22955                       getV4X86ShuffleImm8ForMask(DMask, DAG));
22956       DCI.AddToWorklist(V.getNode());
22957       return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
22958     }
22959
22960     // Look for shuffle patterns which can be implemented as a single unpack.
22961     // FIXME: This doesn't handle the location of the PSHUFD generically, and
22962     // only works when we have a PSHUFD followed by two half-shuffles.
22963     if (Mask[0] == Mask[1] && Mask[2] == Mask[3] &&
22964         (V.getOpcode() == X86ISD::PSHUFLW ||
22965          V.getOpcode() == X86ISD::PSHUFHW) &&
22966         V.getOpcode() != N.getOpcode() &&
22967         V.hasOneUse()) {
22968       SDValue D = V.getOperand(0);
22969       while (D.getOpcode() == ISD::BITCAST && D.hasOneUse())
22970         D = D.getOperand(0);
22971       if (D.getOpcode() == X86ISD::PSHUFD && D.hasOneUse()) {
22972         SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22973         SmallVector<int, 4> DMask = getPSHUFShuffleMask(D);
22974         int NOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 4;
22975         int VOffset = V.getOpcode() == X86ISD::PSHUFLW ? 0 : 4;
22976         int WordMask[8];
22977         for (int i = 0; i < 4; ++i) {
22978           WordMask[i + NOffset] = Mask[i] + NOffset;
22979           WordMask[i + VOffset] = VMask[i] + VOffset;
22980         }
22981         // Map the word mask through the DWord mask.
22982         int MappedMask[8];
22983         for (int i = 0; i < 8; ++i)
22984           MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2;
22985         const int UnpackLoMask[] = {0, 0, 1, 1, 2, 2, 3, 3};
22986         const int UnpackHiMask[] = {4, 4, 5, 5, 6, 6, 7, 7};
22987         if (std::equal(std::begin(MappedMask), std::end(MappedMask),
22988                        std::begin(UnpackLoMask)) ||
22989             std::equal(std::begin(MappedMask), std::end(MappedMask),
22990                        std::begin(UnpackHiMask))) {
22991           // We can replace all three shuffles with an unpack.
22992           V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, D.getOperand(0));
22993           DCI.AddToWorklist(V.getNode());
22994           return DAG.getNode(MappedMask[0] == 0 ? X86ISD::UNPCKL
22995                                                 : X86ISD::UNPCKH,
22996                              DL, MVT::v8i16, V, V);
22997         }
22998       }
22999     }
23000
23001     break;
23002
23003   case X86ISD::PSHUFD:
23004     if (SDValue NewN = combineRedundantDWordShuffle(N, Mask, DAG, DCI))
23005       return NewN;
23006
23007     break;
23008   }
23009
23010   return SDValue();
23011 }
23012
23013 /// \brief Try to combine a shuffle into a target-specific add-sub node.
23014 ///
23015 /// We combine this directly on the abstract vector shuffle nodes so it is
23016 /// easier to generically match. We also insert dummy vector shuffle nodes for
23017 /// the operands which explicitly discard the lanes which are unused by this
23018 /// operation to try to flow through the rest of the combiner the fact that
23019 /// they're unused.
23020 static SDValue combineShuffleToAddSub(SDNode *N, SelectionDAG &DAG) {
23021   SDLoc DL(N);
23022   EVT VT = N->getValueType(0);
23023
23024   // We only handle target-independent shuffles.
23025   // FIXME: It would be easy and harmless to use the target shuffle mask
23026   // extraction tool to support more.
23027   if (N->getOpcode() != ISD::VECTOR_SHUFFLE)
23028     return SDValue();
23029
23030   auto *SVN = cast<ShuffleVectorSDNode>(N);
23031   ArrayRef<int> Mask = SVN->getMask();
23032   SDValue V1 = N->getOperand(0);
23033   SDValue V2 = N->getOperand(1);
23034
23035   // We require the first shuffle operand to be the SUB node, and the second to
23036   // be the ADD node.
23037   // FIXME: We should support the commuted patterns.
23038   if (V1->getOpcode() != ISD::FSUB || V2->getOpcode() != ISD::FADD)
23039     return SDValue();
23040
23041   // If there are other uses of these operations we can't fold them.
23042   if (!V1->hasOneUse() || !V2->hasOneUse())
23043     return SDValue();
23044
23045   // Ensure that both operations have the same operands. Note that we can
23046   // commute the FADD operands.
23047   SDValue LHS = V1->getOperand(0), RHS = V1->getOperand(1);
23048   if ((V2->getOperand(0) != LHS || V2->getOperand(1) != RHS) &&
23049       (V2->getOperand(0) != RHS || V2->getOperand(1) != LHS))
23050     return SDValue();
23051
23052   // We're looking for blends between FADD and FSUB nodes. We insist on these
23053   // nodes being lined up in a specific expected pattern.
23054   if (!(isShuffleEquivalent(V1, V2, Mask, 0, 3) ||
23055         isShuffleEquivalent(V1, V2, Mask, 0, 5, 2, 7) ||
23056         isShuffleEquivalent(V1, V2, Mask, 0, 9, 2, 11, 4, 13, 6, 15)))
23057     return SDValue();
23058
23059   // Only specific types are legal at this point, assert so we notice if and
23060   // when these change.
23061   assert((VT == MVT::v4f32 || VT == MVT::v2f64 || VT == MVT::v8f32 ||
23062           VT == MVT::v4f64) &&
23063          "Unknown vector type encountered!");
23064
23065   return DAG.getNode(X86ISD::ADDSUB, DL, VT, LHS, RHS);
23066 }
23067
23068 /// PerformShuffleCombine - Performs several different shuffle combines.
23069 static SDValue PerformShuffleCombine(SDNode *N, SelectionDAG &DAG,
23070                                      TargetLowering::DAGCombinerInfo &DCI,
23071                                      const X86Subtarget *Subtarget) {
23072   SDLoc dl(N);
23073   SDValue N0 = N->getOperand(0);
23074   SDValue N1 = N->getOperand(1);
23075   EVT VT = N->getValueType(0);
23076
23077   // Don't create instructions with illegal types after legalize types has run.
23078   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23079   if (!DCI.isBeforeLegalize() && !TLI.isTypeLegal(VT.getVectorElementType()))
23080     return SDValue();
23081
23082   // If we have legalized the vector types, look for blends of FADD and FSUB
23083   // nodes that we can fuse into an ADDSUB node.
23084   if (TLI.isTypeLegal(VT) && Subtarget->hasSSE3())
23085     if (SDValue AddSub = combineShuffleToAddSub(N, DAG))
23086       return AddSub;
23087
23088   // Combine 256-bit vector shuffles. This is only profitable when in AVX mode
23089   if (Subtarget->hasFp256() && VT.is256BitVector() &&
23090       N->getOpcode() == ISD::VECTOR_SHUFFLE)
23091     return PerformShuffleCombine256(N, DAG, DCI, Subtarget);
23092
23093   // During Type Legalization, when promoting illegal vector types,
23094   // the backend might introduce new shuffle dag nodes and bitcasts.
23095   //
23096   // This code performs the following transformation:
23097   // fold: (shuffle (bitcast (BINOP A, B)), Undef, <Mask>) ->
23098   //       (shuffle (BINOP (bitcast A), (bitcast B)), Undef, <Mask>)
23099   //
23100   // We do this only if both the bitcast and the BINOP dag nodes have
23101   // one use. Also, perform this transformation only if the new binary
23102   // operation is legal. This is to avoid introducing dag nodes that
23103   // potentially need to be further expanded (or custom lowered) into a
23104   // less optimal sequence of dag nodes.
23105   if (!DCI.isBeforeLegalize() && DCI.isBeforeLegalizeOps() &&
23106       N1.getOpcode() == ISD::UNDEF && N0.hasOneUse() &&
23107       N0.getOpcode() == ISD::BITCAST) {
23108     SDValue BC0 = N0.getOperand(0);
23109     EVT SVT = BC0.getValueType();
23110     unsigned Opcode = BC0.getOpcode();
23111     unsigned NumElts = VT.getVectorNumElements();
23112
23113     if (BC0.hasOneUse() && SVT.isVector() &&
23114         SVT.getVectorNumElements() * 2 == NumElts &&
23115         TLI.isOperationLegal(Opcode, VT)) {
23116       bool CanFold = false;
23117       switch (Opcode) {
23118       default : break;
23119       case ISD::ADD :
23120       case ISD::FADD :
23121       case ISD::SUB :
23122       case ISD::FSUB :
23123       case ISD::MUL :
23124       case ISD::FMUL :
23125         CanFold = true;
23126       }
23127
23128       unsigned SVTNumElts = SVT.getVectorNumElements();
23129       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
23130       for (unsigned i = 0, e = SVTNumElts; i != e && CanFold; ++i)
23131         CanFold = SVOp->getMaskElt(i) == (int)(i * 2);
23132       for (unsigned i = SVTNumElts, e = NumElts; i != e && CanFold; ++i)
23133         CanFold = SVOp->getMaskElt(i) < 0;
23134
23135       if (CanFold) {
23136         SDValue BC00 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(0));
23137         SDValue BC01 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(1));
23138         SDValue NewBinOp = DAG.getNode(BC0.getOpcode(), dl, VT, BC00, BC01);
23139         return DAG.getVectorShuffle(VT, dl, NewBinOp, N1, &SVOp->getMask()[0]);
23140       }
23141     }
23142   }
23143
23144   // Only handle 128 wide vector from here on.
23145   if (!VT.is128BitVector())
23146     return SDValue();
23147
23148   // Combine a vector_shuffle that is equal to build_vector load1, load2, load3,
23149   // load4, <0, 1, 2, 3> into a 128-bit load if the load addresses are
23150   // consecutive, non-overlapping, and in the right order.
23151   SmallVector<SDValue, 16> Elts;
23152   for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
23153     Elts.push_back(getShuffleScalarElt(N, i, DAG, 0));
23154
23155   SDValue LD = EltsFromConsecutiveLoads(VT, Elts, dl, DAG, true);
23156   if (LD.getNode())
23157     return LD;
23158
23159   if (isTargetShuffle(N->getOpcode())) {
23160     SDValue Shuffle =
23161         PerformTargetShuffleCombine(SDValue(N, 0), DAG, DCI, Subtarget);
23162     if (Shuffle.getNode())
23163       return Shuffle;
23164
23165     // Try recursively combining arbitrary sequences of x86 shuffle
23166     // instructions into higher-order shuffles. We do this after combining
23167     // specific PSHUF instruction sequences into their minimal form so that we
23168     // can evaluate how many specialized shuffle instructions are involved in
23169     // a particular chain.
23170     SmallVector<int, 1> NonceMask; // Just a placeholder.
23171     NonceMask.push_back(0);
23172     if (combineX86ShufflesRecursively(SDValue(N, 0), SDValue(N, 0), NonceMask,
23173                                       /*Depth*/ 1, /*HasPSHUFB*/ false, DAG,
23174                                       DCI, Subtarget))
23175       return SDValue(); // This routine will use CombineTo to replace N.
23176   }
23177
23178   return SDValue();
23179 }
23180
23181 /// PerformTruncateCombine - Converts truncate operation to
23182 /// a sequence of vector shuffle operations.
23183 /// It is possible when we truncate 256-bit vector to 128-bit vector
23184 static SDValue PerformTruncateCombine(SDNode *N, SelectionDAG &DAG,
23185                                       TargetLowering::DAGCombinerInfo &DCI,
23186                                       const X86Subtarget *Subtarget)  {
23187   return SDValue();
23188 }
23189
23190 /// XFormVExtractWithShuffleIntoLoad - Check if a vector extract from a target
23191 /// specific shuffle of a load can be folded into a single element load.
23192 /// Similar handling for VECTOR_SHUFFLE is performed by DAGCombiner, but
23193 /// shuffles have been custom lowered so we need to handle those here.
23194 static SDValue XFormVExtractWithShuffleIntoLoad(SDNode *N, SelectionDAG &DAG,
23195                                          TargetLowering::DAGCombinerInfo &DCI) {
23196   if (DCI.isBeforeLegalizeOps())
23197     return SDValue();
23198
23199   SDValue InVec = N->getOperand(0);
23200   SDValue EltNo = N->getOperand(1);
23201
23202   if (!isa<ConstantSDNode>(EltNo))
23203     return SDValue();
23204
23205   EVT OriginalVT = InVec.getValueType();
23206
23207   if (InVec.getOpcode() == ISD::BITCAST) {
23208     // Don't duplicate a load with other uses.
23209     if (!InVec.hasOneUse())
23210       return SDValue();
23211     EVT BCVT = InVec.getOperand(0).getValueType();
23212     if (BCVT.getVectorNumElements() != OriginalVT.getVectorNumElements())
23213       return SDValue();
23214     InVec = InVec.getOperand(0);
23215   }
23216
23217   EVT CurrentVT = InVec.getValueType();
23218
23219   if (!isTargetShuffle(InVec.getOpcode()))
23220     return SDValue();
23221
23222   // Don't duplicate a load with other uses.
23223   if (!InVec.hasOneUse())
23224     return SDValue();
23225
23226   SmallVector<int, 16> ShuffleMask;
23227   bool UnaryShuffle;
23228   if (!getTargetShuffleMask(InVec.getNode(), CurrentVT.getSimpleVT(),
23229                             ShuffleMask, UnaryShuffle))
23230     return SDValue();
23231
23232   // Select the input vector, guarding against out of range extract vector.
23233   unsigned NumElems = CurrentVT.getVectorNumElements();
23234   int Elt = cast<ConstantSDNode>(EltNo)->getZExtValue();
23235   int Idx = (Elt > (int)NumElems) ? -1 : ShuffleMask[Elt];
23236   SDValue LdNode = (Idx < (int)NumElems) ? InVec.getOperand(0)
23237                                          : InVec.getOperand(1);
23238
23239   // If inputs to shuffle are the same for both ops, then allow 2 uses
23240   unsigned AllowedUses = InVec.getNumOperands() > 1 &&
23241                          InVec.getOperand(0) == InVec.getOperand(1) ? 2 : 1;
23242
23243   if (LdNode.getOpcode() == ISD::BITCAST) {
23244     // Don't duplicate a load with other uses.
23245     if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
23246       return SDValue();
23247
23248     AllowedUses = 1; // only allow 1 load use if we have a bitcast
23249     LdNode = LdNode.getOperand(0);
23250   }
23251
23252   if (!ISD::isNormalLoad(LdNode.getNode()))
23253     return SDValue();
23254
23255   LoadSDNode *LN0 = cast<LoadSDNode>(LdNode);
23256
23257   if (!LN0 ||!LN0->hasNUsesOfValue(AllowedUses, 0) || LN0->isVolatile())
23258     return SDValue();
23259
23260   EVT EltVT = N->getValueType(0);
23261   // If there's a bitcast before the shuffle, check if the load type and
23262   // alignment is valid.
23263   unsigned Align = LN0->getAlignment();
23264   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23265   unsigned NewAlign = TLI.getDataLayout()->getABITypeAlignment(
23266       EltVT.getTypeForEVT(*DAG.getContext()));
23267
23268   if (NewAlign > Align || !TLI.isOperationLegalOrCustom(ISD::LOAD, EltVT))
23269     return SDValue();
23270
23271   // All checks match so transform back to vector_shuffle so that DAG combiner
23272   // can finish the job
23273   SDLoc dl(N);
23274
23275   // Create shuffle node taking into account the case that its a unary shuffle
23276   SDValue Shuffle = (UnaryShuffle) ? DAG.getUNDEF(CurrentVT)
23277                                    : InVec.getOperand(1);
23278   Shuffle = DAG.getVectorShuffle(CurrentVT, dl,
23279                                  InVec.getOperand(0), Shuffle,
23280                                  &ShuffleMask[0]);
23281   Shuffle = DAG.getNode(ISD::BITCAST, dl, OriginalVT, Shuffle);
23282   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
23283                      EltNo);
23284 }
23285
23286 /// \brief Detect bitcasts between i32 to x86mmx low word. Since MMX types are
23287 /// special and don't usually play with other vector types, it's better to
23288 /// handle them early to be sure we emit efficient code by avoiding
23289 /// store-load conversions.
23290 static SDValue PerformBITCASTCombine(SDNode *N, SelectionDAG &DAG) {
23291   if (N->getValueType(0) != MVT::x86mmx ||
23292       N->getOperand(0)->getOpcode() != ISD::BUILD_VECTOR ||
23293       N->getOperand(0)->getValueType(0) != MVT::v2i32)
23294     return SDValue();
23295
23296   SDValue V = N->getOperand(0);
23297   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V.getOperand(1));
23298   if (C && C->getZExtValue() == 0 && V.getOperand(0).getValueType() == MVT::i32)
23299     return DAG.getNode(X86ISD::MMX_MOVW2D, SDLoc(V.getOperand(0)),
23300                        N->getValueType(0), V.getOperand(0));
23301
23302   return SDValue();
23303 }
23304
23305 /// PerformEXTRACT_VECTOR_ELTCombine - Detect vector gather/scatter index
23306 /// generation and convert it from being a bunch of shuffles and extracts
23307 /// into a somewhat faster sequence. For i686, the best sequence is apparently
23308 /// storing the value and loading scalars back, while for x64 we should
23309 /// use 64-bit extracts and shifts.
23310 static SDValue PerformEXTRACT_VECTOR_ELTCombine(SDNode *N, SelectionDAG &DAG,
23311                                          TargetLowering::DAGCombinerInfo &DCI) {
23312   SDValue NewOp = XFormVExtractWithShuffleIntoLoad(N, DAG, DCI);
23313   if (NewOp.getNode())
23314     return NewOp;
23315
23316   SDValue InputVector = N->getOperand(0);
23317
23318   // Detect mmx to i32 conversion through a v2i32 elt extract.
23319   if (InputVector.getOpcode() == ISD::BITCAST && InputVector.hasOneUse() &&
23320       N->getValueType(0) == MVT::i32 &&
23321       InputVector.getValueType() == MVT::v2i32) {
23322
23323     // The bitcast source is a direct mmx result.
23324     SDValue MMXSrc = InputVector.getNode()->getOperand(0);
23325     if (MMXSrc.getValueType() == MVT::x86mmx)
23326       return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
23327                          N->getValueType(0),
23328                          InputVector.getNode()->getOperand(0));
23329
23330     // The mmx is indirect: (i64 extract_elt (v1i64 bitcast (x86mmx ...))).
23331     SDValue MMXSrcOp = MMXSrc.getOperand(0);
23332     if (MMXSrc.getOpcode() == ISD::EXTRACT_VECTOR_ELT && MMXSrc.hasOneUse() &&
23333         MMXSrc.getValueType() == MVT::i64 && MMXSrcOp.hasOneUse() &&
23334         MMXSrcOp.getOpcode() == ISD::BITCAST &&
23335         MMXSrcOp.getValueType() == MVT::v1i64 &&
23336         MMXSrcOp.getOperand(0).getValueType() == MVT::x86mmx)
23337       return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
23338                          N->getValueType(0),
23339                          MMXSrcOp.getOperand(0));
23340   }
23341
23342   // Only operate on vectors of 4 elements, where the alternative shuffling
23343   // gets to be more expensive.
23344   if (InputVector.getValueType() != MVT::v4i32)
23345     return SDValue();
23346
23347   // Check whether every use of InputVector is an EXTRACT_VECTOR_ELT with a
23348   // single use which is a sign-extend or zero-extend, and all elements are
23349   // used.
23350   SmallVector<SDNode *, 4> Uses;
23351   unsigned ExtractedElements = 0;
23352   for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
23353        UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
23354     if (UI.getUse().getResNo() != InputVector.getResNo())
23355       return SDValue();
23356
23357     SDNode *Extract = *UI;
23358     if (Extract->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
23359       return SDValue();
23360
23361     if (Extract->getValueType(0) != MVT::i32)
23362       return SDValue();
23363     if (!Extract->hasOneUse())
23364       return SDValue();
23365     if (Extract->use_begin()->getOpcode() != ISD::SIGN_EXTEND &&
23366         Extract->use_begin()->getOpcode() != ISD::ZERO_EXTEND)
23367       return SDValue();
23368     if (!isa<ConstantSDNode>(Extract->getOperand(1)))
23369       return SDValue();
23370
23371     // Record which element was extracted.
23372     ExtractedElements |=
23373       1 << cast<ConstantSDNode>(Extract->getOperand(1))->getZExtValue();
23374
23375     Uses.push_back(Extract);
23376   }
23377
23378   // If not all the elements were used, this may not be worthwhile.
23379   if (ExtractedElements != 15)
23380     return SDValue();
23381
23382   // Ok, we've now decided to do the transformation.
23383   // If 64-bit shifts are legal, use the extract-shift sequence,
23384   // otherwise bounce the vector off the cache.
23385   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23386   SDValue Vals[4];
23387   SDLoc dl(InputVector);
23388
23389   if (TLI.isOperationLegal(ISD::SRA, MVT::i64)) {
23390     SDValue Cst = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, InputVector);
23391     EVT VecIdxTy = DAG.getTargetLoweringInfo().getVectorIdxTy();
23392     SDValue BottomHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Cst,
23393       DAG.getConstant(0, VecIdxTy));
23394     SDValue TopHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Cst,
23395       DAG.getConstant(1, VecIdxTy));
23396
23397     SDValue ShAmt = DAG.getConstant(32,
23398       DAG.getTargetLoweringInfo().getShiftAmountTy(MVT::i64));
23399     Vals[0] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BottomHalf);
23400     Vals[1] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
23401       DAG.getNode(ISD::SRA, dl, MVT::i64, BottomHalf, ShAmt));
23402     Vals[2] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, TopHalf);
23403     Vals[3] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
23404       DAG.getNode(ISD::SRA, dl, MVT::i64, TopHalf, ShAmt));
23405   } else {
23406     // Store the value to a temporary stack slot.
23407     SDValue StackPtr = DAG.CreateStackTemporary(InputVector.getValueType());
23408     SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, InputVector, StackPtr,
23409       MachinePointerInfo(), false, false, 0);
23410
23411     EVT ElementType = InputVector.getValueType().getVectorElementType();
23412     unsigned EltSize = ElementType.getSizeInBits() / 8;
23413
23414     // Replace each use (extract) with a load of the appropriate element.
23415     for (unsigned i = 0; i < 4; ++i) {
23416       uint64_t Offset = EltSize * i;
23417       SDValue OffsetVal = DAG.getConstant(Offset, TLI.getPointerTy());
23418
23419       SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
23420                                        StackPtr, OffsetVal);
23421
23422       // Load the scalar.
23423       Vals[i] = DAG.getLoad(ElementType, dl, Ch,
23424                             ScalarAddr, MachinePointerInfo(),
23425                             false, false, false, 0);
23426
23427     }
23428   }
23429
23430   // Replace the extracts
23431   for (SmallVectorImpl<SDNode *>::iterator UI = Uses.begin(),
23432     UE = Uses.end(); UI != UE; ++UI) {
23433     SDNode *Extract = *UI;
23434
23435     SDValue Idx = Extract->getOperand(1);
23436     uint64_t IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
23437     DAG.ReplaceAllUsesOfValueWith(SDValue(Extract, 0), Vals[IdxVal]);
23438   }
23439
23440   // The replacement was made in place; don't return anything.
23441   return SDValue();
23442 }
23443
23444 /// \brief Matches a VSELECT onto min/max or return 0 if the node doesn't match.
23445 static std::pair<unsigned, bool>
23446 matchIntegerMINMAX(SDValue Cond, EVT VT, SDValue LHS, SDValue RHS,
23447                    SelectionDAG &DAG, const X86Subtarget *Subtarget) {
23448   if (!VT.isVector())
23449     return std::make_pair(0, false);
23450
23451   bool NeedSplit = false;
23452   switch (VT.getSimpleVT().SimpleTy) {
23453   default: return std::make_pair(0, false);
23454   case MVT::v4i64:
23455   case MVT::v2i64:
23456     if (!Subtarget->hasVLX())
23457       return std::make_pair(0, false);
23458     break;
23459   case MVT::v64i8:
23460   case MVT::v32i16:
23461     if (!Subtarget->hasBWI())
23462       return std::make_pair(0, false);
23463     break;
23464   case MVT::v16i32:
23465   case MVT::v8i64:
23466     if (!Subtarget->hasAVX512())
23467       return std::make_pair(0, false);
23468     break;
23469   case MVT::v32i8:
23470   case MVT::v16i16:
23471   case MVT::v8i32:
23472     if (!Subtarget->hasAVX2())
23473       NeedSplit = true;
23474     if (!Subtarget->hasAVX())
23475       return std::make_pair(0, false);
23476     break;
23477   case MVT::v16i8:
23478   case MVT::v8i16:
23479   case MVT::v4i32:
23480     if (!Subtarget->hasSSE2())
23481       return std::make_pair(0, false);
23482   }
23483
23484   // SSE2 has only a small subset of the operations.
23485   bool hasUnsigned = Subtarget->hasSSE41() ||
23486                      (Subtarget->hasSSE2() && VT == MVT::v16i8);
23487   bool hasSigned = Subtarget->hasSSE41() ||
23488                    (Subtarget->hasSSE2() && VT == MVT::v8i16);
23489
23490   ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23491
23492   unsigned Opc = 0;
23493   // Check for x CC y ? x : y.
23494   if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23495       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23496     switch (CC) {
23497     default: break;
23498     case ISD::SETULT:
23499     case ISD::SETULE:
23500       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
23501     case ISD::SETUGT:
23502     case ISD::SETUGE:
23503       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
23504     case ISD::SETLT:
23505     case ISD::SETLE:
23506       Opc = hasSigned ? X86ISD::SMIN : 0; break;
23507     case ISD::SETGT:
23508     case ISD::SETGE:
23509       Opc = hasSigned ? X86ISD::SMAX : 0; break;
23510     }
23511   // Check for x CC y ? y : x -- a min/max with reversed arms.
23512   } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
23513              DAG.isEqualTo(RHS, Cond.getOperand(0))) {
23514     switch (CC) {
23515     default: break;
23516     case ISD::SETULT:
23517     case ISD::SETULE:
23518       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
23519     case ISD::SETUGT:
23520     case ISD::SETUGE:
23521       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
23522     case ISD::SETLT:
23523     case ISD::SETLE:
23524       Opc = hasSigned ? X86ISD::SMAX : 0; break;
23525     case ISD::SETGT:
23526     case ISD::SETGE:
23527       Opc = hasSigned ? X86ISD::SMIN : 0; break;
23528     }
23529   }
23530
23531   return std::make_pair(Opc, NeedSplit);
23532 }
23533
23534 static SDValue
23535 transformVSELECTtoBlendVECTOR_SHUFFLE(SDNode *N, SelectionDAG &DAG,
23536                                       const X86Subtarget *Subtarget) {
23537   SDLoc dl(N);
23538   SDValue Cond = N->getOperand(0);
23539   SDValue LHS = N->getOperand(1);
23540   SDValue RHS = N->getOperand(2);
23541
23542   if (Cond.getOpcode() == ISD::SIGN_EXTEND) {
23543     SDValue CondSrc = Cond->getOperand(0);
23544     if (CondSrc->getOpcode() == ISD::SIGN_EXTEND_INREG)
23545       Cond = CondSrc->getOperand(0);
23546   }
23547
23548   if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
23549     return SDValue();
23550
23551   // A vselect where all conditions and data are constants can be optimized into
23552   // a single vector load by SelectionDAGLegalize::ExpandBUILD_VECTOR().
23553   if (ISD::isBuildVectorOfConstantSDNodes(LHS.getNode()) &&
23554       ISD::isBuildVectorOfConstantSDNodes(RHS.getNode()))
23555     return SDValue();
23556
23557   unsigned MaskValue = 0;
23558   if (!BUILD_VECTORtoBlendMask(cast<BuildVectorSDNode>(Cond), MaskValue))
23559     return SDValue();
23560
23561   MVT VT = N->getSimpleValueType(0);
23562   unsigned NumElems = VT.getVectorNumElements();
23563   SmallVector<int, 8> ShuffleMask(NumElems, -1);
23564   for (unsigned i = 0; i < NumElems; ++i) {
23565     // Be sure we emit undef where we can.
23566     if (Cond.getOperand(i)->getOpcode() == ISD::UNDEF)
23567       ShuffleMask[i] = -1;
23568     else
23569       ShuffleMask[i] = i + NumElems * ((MaskValue >> i) & 1);
23570   }
23571
23572   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23573   if (!TLI.isShuffleMaskLegal(ShuffleMask, VT))
23574     return SDValue();
23575   return DAG.getVectorShuffle(VT, dl, LHS, RHS, &ShuffleMask[0]);
23576 }
23577
23578 /// PerformSELECTCombine - Do target-specific dag combines on SELECT and VSELECT
23579 /// nodes.
23580 static SDValue PerformSELECTCombine(SDNode *N, SelectionDAG &DAG,
23581                                     TargetLowering::DAGCombinerInfo &DCI,
23582                                     const X86Subtarget *Subtarget) {
23583   SDLoc DL(N);
23584   SDValue Cond = N->getOperand(0);
23585   // Get the LHS/RHS of the select.
23586   SDValue LHS = N->getOperand(1);
23587   SDValue RHS = N->getOperand(2);
23588   EVT VT = LHS.getValueType();
23589   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23590
23591   // If we have SSE[12] support, try to form min/max nodes. SSE min/max
23592   // instructions match the semantics of the common C idiom x<y?x:y but not
23593   // x<=y?x:y, because of how they handle negative zero (which can be
23594   // ignored in unsafe-math mode).
23595   // We also try to create v2f32 min/max nodes, which we later widen to v4f32.
23596   if (Cond.getOpcode() == ISD::SETCC && VT.isFloatingPoint() &&
23597       VT != MVT::f80 && (TLI.isTypeLegal(VT) || VT == MVT::v2f32) &&
23598       (Subtarget->hasSSE2() ||
23599        (Subtarget->hasSSE1() && VT.getScalarType() == MVT::f32))) {
23600     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23601
23602     unsigned Opcode = 0;
23603     // Check for x CC y ? x : y.
23604     if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23605         DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23606       switch (CC) {
23607       default: break;
23608       case ISD::SETULT:
23609         // Converting this to a min would handle NaNs incorrectly, and swapping
23610         // the operands would cause it to handle comparisons between positive
23611         // and negative zero incorrectly.
23612         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
23613           if (!DAG.getTarget().Options.UnsafeFPMath &&
23614               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
23615             break;
23616           std::swap(LHS, RHS);
23617         }
23618         Opcode = X86ISD::FMIN;
23619         break;
23620       case ISD::SETOLE:
23621         // Converting this to a min would handle comparisons between positive
23622         // and negative zero incorrectly.
23623         if (!DAG.getTarget().Options.UnsafeFPMath &&
23624             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
23625           break;
23626         Opcode = X86ISD::FMIN;
23627         break;
23628       case ISD::SETULE:
23629         // Converting this to a min would handle both negative zeros and NaNs
23630         // incorrectly, but we can swap the operands to fix both.
23631         std::swap(LHS, RHS);
23632       case ISD::SETOLT:
23633       case ISD::SETLT:
23634       case ISD::SETLE:
23635         Opcode = X86ISD::FMIN;
23636         break;
23637
23638       case ISD::SETOGE:
23639         // Converting this to a max would handle comparisons between positive
23640         // and negative zero incorrectly.
23641         if (!DAG.getTarget().Options.UnsafeFPMath &&
23642             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
23643           break;
23644         Opcode = X86ISD::FMAX;
23645         break;
23646       case ISD::SETUGT:
23647         // Converting this to a max would handle NaNs incorrectly, and swapping
23648         // the operands would cause it to handle comparisons between positive
23649         // and negative zero incorrectly.
23650         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
23651           if (!DAG.getTarget().Options.UnsafeFPMath &&
23652               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
23653             break;
23654           std::swap(LHS, RHS);
23655         }
23656         Opcode = X86ISD::FMAX;
23657         break;
23658       case ISD::SETUGE:
23659         // Converting this to a max would handle both negative zeros and NaNs
23660         // incorrectly, but we can swap the operands to fix both.
23661         std::swap(LHS, RHS);
23662       case ISD::SETOGT:
23663       case ISD::SETGT:
23664       case ISD::SETGE:
23665         Opcode = X86ISD::FMAX;
23666         break;
23667       }
23668     // Check for x CC y ? y : x -- a min/max with reversed arms.
23669     } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
23670                DAG.isEqualTo(RHS, Cond.getOperand(0))) {
23671       switch (CC) {
23672       default: break;
23673       case ISD::SETOGE:
23674         // Converting this to a min would handle comparisons between positive
23675         // and negative zero incorrectly, and swapping the operands would
23676         // cause it to handle NaNs incorrectly.
23677         if (!DAG.getTarget().Options.UnsafeFPMath &&
23678             !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS))) {
23679           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23680             break;
23681           std::swap(LHS, RHS);
23682         }
23683         Opcode = X86ISD::FMIN;
23684         break;
23685       case ISD::SETUGT:
23686         // Converting this to a min would handle NaNs incorrectly.
23687         if (!DAG.getTarget().Options.UnsafeFPMath &&
23688             (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)))
23689           break;
23690         Opcode = X86ISD::FMIN;
23691         break;
23692       case ISD::SETUGE:
23693         // Converting this to a min would handle both negative zeros and NaNs
23694         // incorrectly, but we can swap the operands to fix both.
23695         std::swap(LHS, RHS);
23696       case ISD::SETOGT:
23697       case ISD::SETGT:
23698       case ISD::SETGE:
23699         Opcode = X86ISD::FMIN;
23700         break;
23701
23702       case ISD::SETULT:
23703         // Converting this to a max would handle NaNs incorrectly.
23704         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23705           break;
23706         Opcode = X86ISD::FMAX;
23707         break;
23708       case ISD::SETOLE:
23709         // Converting this to a max would handle comparisons between positive
23710         // and negative zero incorrectly, and swapping the operands would
23711         // cause it to handle NaNs incorrectly.
23712         if (!DAG.getTarget().Options.UnsafeFPMath &&
23713             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS)) {
23714           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23715             break;
23716           std::swap(LHS, RHS);
23717         }
23718         Opcode = X86ISD::FMAX;
23719         break;
23720       case ISD::SETULE:
23721         // Converting this to a max would handle both negative zeros and NaNs
23722         // incorrectly, but we can swap the operands to fix both.
23723         std::swap(LHS, RHS);
23724       case ISD::SETOLT:
23725       case ISD::SETLT:
23726       case ISD::SETLE:
23727         Opcode = X86ISD::FMAX;
23728         break;
23729       }
23730     }
23731
23732     if (Opcode)
23733       return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
23734   }
23735
23736   EVT CondVT = Cond.getValueType();
23737   if (Subtarget->hasAVX512() && VT.isVector() && CondVT.isVector() &&
23738       CondVT.getVectorElementType() == MVT::i1) {
23739     // v16i8 (select v16i1, v16i8, v16i8) does not have a proper
23740     // lowering on KNL. In this case we convert it to
23741     // v16i8 (select v16i8, v16i8, v16i8) and use AVX instruction.
23742     // The same situation for all 128 and 256-bit vectors of i8 and i16.
23743     // Since SKX these selects have a proper lowering.
23744     EVT OpVT = LHS.getValueType();
23745     if ((OpVT.is128BitVector() || OpVT.is256BitVector()) &&
23746         (OpVT.getVectorElementType() == MVT::i8 ||
23747          OpVT.getVectorElementType() == MVT::i16) &&
23748         !(Subtarget->hasBWI() && Subtarget->hasVLX())) {
23749       Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, OpVT, Cond);
23750       DCI.AddToWorklist(Cond.getNode());
23751       return DAG.getNode(N->getOpcode(), DL, OpVT, Cond, LHS, RHS);
23752     }
23753   }
23754   // If this is a select between two integer constants, try to do some
23755   // optimizations.
23756   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(LHS)) {
23757     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(RHS))
23758       // Don't do this for crazy integer types.
23759       if (DAG.getTargetLoweringInfo().isTypeLegal(LHS.getValueType())) {
23760         // If this is efficiently invertible, canonicalize the LHSC/RHSC values
23761         // so that TrueC (the true value) is larger than FalseC.
23762         bool NeedsCondInvert = false;
23763
23764         if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue()) &&
23765             // Efficiently invertible.
23766             (Cond.getOpcode() == ISD::SETCC ||  // setcc -> invertible.
23767              (Cond.getOpcode() == ISD::XOR &&   // xor(X, C) -> invertible.
23768               isa<ConstantSDNode>(Cond.getOperand(1))))) {
23769           NeedsCondInvert = true;
23770           std::swap(TrueC, FalseC);
23771         }
23772
23773         // Optimize C ? 8 : 0 -> zext(C) << 3.  Likewise for any pow2/0.
23774         if (FalseC->getAPIntValue() == 0 &&
23775             TrueC->getAPIntValue().isPowerOf2()) {
23776           if (NeedsCondInvert) // Invert the condition if needed.
23777             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23778                                DAG.getConstant(1, Cond.getValueType()));
23779
23780           // Zero extend the condition if needed.
23781           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
23782
23783           unsigned ShAmt = TrueC->getAPIntValue().logBase2();
23784           return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
23785                              DAG.getConstant(ShAmt, MVT::i8));
23786         }
23787
23788         // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.
23789         if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
23790           if (NeedsCondInvert) // Invert the condition if needed.
23791             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23792                                DAG.getConstant(1, Cond.getValueType()));
23793
23794           // Zero extend the condition if needed.
23795           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
23796                              FalseC->getValueType(0), Cond);
23797           return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
23798                              SDValue(FalseC, 0));
23799         }
23800
23801         // Optimize cases that will turn into an LEA instruction.  This requires
23802         // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
23803         if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
23804           uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
23805           if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
23806
23807           bool isFastMultiplier = false;
23808           if (Diff < 10) {
23809             switch ((unsigned char)Diff) {
23810               default: break;
23811               case 1:  // result = add base, cond
23812               case 2:  // result = lea base(    , cond*2)
23813               case 3:  // result = lea base(cond, cond*2)
23814               case 4:  // result = lea base(    , cond*4)
23815               case 5:  // result = lea base(cond, cond*4)
23816               case 8:  // result = lea base(    , cond*8)
23817               case 9:  // result = lea base(cond, cond*8)
23818                 isFastMultiplier = true;
23819                 break;
23820             }
23821           }
23822
23823           if (isFastMultiplier) {
23824             APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
23825             if (NeedsCondInvert) // Invert the condition if needed.
23826               Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23827                                  DAG.getConstant(1, Cond.getValueType()));
23828
23829             // Zero extend the condition if needed.
23830             Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
23831                                Cond);
23832             // Scale the condition by the difference.
23833             if (Diff != 1)
23834               Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
23835                                  DAG.getConstant(Diff, Cond.getValueType()));
23836
23837             // Add the base if non-zero.
23838             if (FalseC->getAPIntValue() != 0)
23839               Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
23840                                  SDValue(FalseC, 0));
23841             return Cond;
23842           }
23843         }
23844       }
23845   }
23846
23847   // Canonicalize max and min:
23848   // (x > y) ? x : y -> (x >= y) ? x : y
23849   // (x < y) ? x : y -> (x <= y) ? x : y
23850   // This allows use of COND_S / COND_NS (see TranslateX86CC) which eliminates
23851   // the need for an extra compare
23852   // against zero. e.g.
23853   // (x - y) > 0 : (x - y) ? 0 -> (x - y) >= 0 : (x - y) ? 0
23854   // subl   %esi, %edi
23855   // testl  %edi, %edi
23856   // movl   $0, %eax
23857   // cmovgl %edi, %eax
23858   // =>
23859   // xorl   %eax, %eax
23860   // subl   %esi, $edi
23861   // cmovsl %eax, %edi
23862   if (N->getOpcode() == ISD::SELECT && Cond.getOpcode() == ISD::SETCC &&
23863       DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23864       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23865     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23866     switch (CC) {
23867     default: break;
23868     case ISD::SETLT:
23869     case ISD::SETGT: {
23870       ISD::CondCode NewCC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGE;
23871       Cond = DAG.getSetCC(SDLoc(Cond), Cond.getValueType(),
23872                           Cond.getOperand(0), Cond.getOperand(1), NewCC);
23873       return DAG.getNode(ISD::SELECT, DL, VT, Cond, LHS, RHS);
23874     }
23875     }
23876   }
23877
23878   // Early exit check
23879   if (!TLI.isTypeLegal(VT))
23880     return SDValue();
23881
23882   // Match VSELECTs into subs with unsigned saturation.
23883   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC &&
23884       // psubus is available in SSE2 and AVX2 for i8 and i16 vectors.
23885       ((Subtarget->hasSSE2() && (VT == MVT::v16i8 || VT == MVT::v8i16)) ||
23886        (Subtarget->hasAVX2() && (VT == MVT::v32i8 || VT == MVT::v16i16)))) {
23887     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23888
23889     // Check if one of the arms of the VSELECT is a zero vector. If it's on the
23890     // left side invert the predicate to simplify logic below.
23891     SDValue Other;
23892     if (ISD::isBuildVectorAllZeros(LHS.getNode())) {
23893       Other = RHS;
23894       CC = ISD::getSetCCInverse(CC, true);
23895     } else if (ISD::isBuildVectorAllZeros(RHS.getNode())) {
23896       Other = LHS;
23897     }
23898
23899     if (Other.getNode() && Other->getNumOperands() == 2 &&
23900         DAG.isEqualTo(Other->getOperand(0), Cond.getOperand(0))) {
23901       SDValue OpLHS = Other->getOperand(0), OpRHS = Other->getOperand(1);
23902       SDValue CondRHS = Cond->getOperand(1);
23903
23904       // Look for a general sub with unsigned saturation first.
23905       // x >= y ? x-y : 0 --> subus x, y
23906       // x >  y ? x-y : 0 --> subus x, y
23907       if ((CC == ISD::SETUGE || CC == ISD::SETUGT) &&
23908           Other->getOpcode() == ISD::SUB && DAG.isEqualTo(OpRHS, CondRHS))
23909         return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
23910
23911       if (auto *OpRHSBV = dyn_cast<BuildVectorSDNode>(OpRHS))
23912         if (auto *OpRHSConst = OpRHSBV->getConstantSplatNode()) {
23913           if (auto *CondRHSBV = dyn_cast<BuildVectorSDNode>(CondRHS))
23914             if (auto *CondRHSConst = CondRHSBV->getConstantSplatNode())
23915               // If the RHS is a constant we have to reverse the const
23916               // canonicalization.
23917               // x > C-1 ? x+-C : 0 --> subus x, C
23918               if (CC == ISD::SETUGT && Other->getOpcode() == ISD::ADD &&
23919                   CondRHSConst->getAPIntValue() ==
23920                       (-OpRHSConst->getAPIntValue() - 1))
23921                 return DAG.getNode(
23922                     X86ISD::SUBUS, DL, VT, OpLHS,
23923                     DAG.getConstant(-OpRHSConst->getAPIntValue(), VT));
23924
23925           // Another special case: If C was a sign bit, the sub has been
23926           // canonicalized into a xor.
23927           // FIXME: Would it be better to use computeKnownBits to determine
23928           //        whether it's safe to decanonicalize the xor?
23929           // x s< 0 ? x^C : 0 --> subus x, C
23930           if (CC == ISD::SETLT && Other->getOpcode() == ISD::XOR &&
23931               ISD::isBuildVectorAllZeros(CondRHS.getNode()) &&
23932               OpRHSConst->getAPIntValue().isSignBit())
23933             // Note that we have to rebuild the RHS constant here to ensure we
23934             // don't rely on particular values of undef lanes.
23935             return DAG.getNode(
23936                 X86ISD::SUBUS, DL, VT, OpLHS,
23937                 DAG.getConstant(OpRHSConst->getAPIntValue(), VT));
23938         }
23939     }
23940   }
23941
23942   // Try to match a min/max vector operation.
23943   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC) {
23944     std::pair<unsigned, bool> ret = matchIntegerMINMAX(Cond, VT, LHS, RHS, DAG, Subtarget);
23945     unsigned Opc = ret.first;
23946     bool NeedSplit = ret.second;
23947
23948     if (Opc && NeedSplit) {
23949       unsigned NumElems = VT.getVectorNumElements();
23950       // Extract the LHS vectors
23951       SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, DL);
23952       SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, DL);
23953
23954       // Extract the RHS vectors
23955       SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, DL);
23956       SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, DL);
23957
23958       // Create min/max for each subvector
23959       LHS = DAG.getNode(Opc, DL, LHS1.getValueType(), LHS1, RHS1);
23960       RHS = DAG.getNode(Opc, DL, LHS2.getValueType(), LHS2, RHS2);
23961
23962       // Merge the result
23963       return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LHS, RHS);
23964     } else if (Opc)
23965       return DAG.getNode(Opc, DL, VT, LHS, RHS);
23966   }
23967
23968   // Simplify vector selection if condition value type matches vselect
23969   // operand type
23970   if (N->getOpcode() == ISD::VSELECT && CondVT == VT) {
23971     assert(Cond.getValueType().isVector() &&
23972            "vector select expects a vector selector!");
23973
23974     bool TValIsAllOnes = ISD::isBuildVectorAllOnes(LHS.getNode());
23975     bool FValIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
23976
23977     // Try invert the condition if true value is not all 1s and false value
23978     // is not all 0s.
23979     if (!TValIsAllOnes && !FValIsAllZeros &&
23980         // Check if the selector will be produced by CMPP*/PCMP*
23981         Cond.getOpcode() == ISD::SETCC &&
23982         // Check if SETCC has already been promoted
23983         TLI.getSetCCResultType(*DAG.getContext(), VT) == CondVT) {
23984       bool TValIsAllZeros = ISD::isBuildVectorAllZeros(LHS.getNode());
23985       bool FValIsAllOnes = ISD::isBuildVectorAllOnes(RHS.getNode());
23986
23987       if (TValIsAllZeros || FValIsAllOnes) {
23988         SDValue CC = Cond.getOperand(2);
23989         ISD::CondCode NewCC =
23990           ISD::getSetCCInverse(cast<CondCodeSDNode>(CC)->get(),
23991                                Cond.getOperand(0).getValueType().isInteger());
23992         Cond = DAG.getSetCC(DL, CondVT, Cond.getOperand(0), Cond.getOperand(1), NewCC);
23993         std::swap(LHS, RHS);
23994         TValIsAllOnes = FValIsAllOnes;
23995         FValIsAllZeros = TValIsAllZeros;
23996       }
23997     }
23998
23999     if (TValIsAllOnes || FValIsAllZeros) {
24000       SDValue Ret;
24001
24002       if (TValIsAllOnes && FValIsAllZeros)
24003         Ret = Cond;
24004       else if (TValIsAllOnes)
24005         Ret = DAG.getNode(ISD::OR, DL, CondVT, Cond,
24006                           DAG.getNode(ISD::BITCAST, DL, CondVT, RHS));
24007       else if (FValIsAllZeros)
24008         Ret = DAG.getNode(ISD::AND, DL, CondVT, Cond,
24009                           DAG.getNode(ISD::BITCAST, DL, CondVT, LHS));
24010
24011       return DAG.getNode(ISD::BITCAST, DL, VT, Ret);
24012     }
24013   }
24014
24015   // If we know that this node is legal then we know that it is going to be
24016   // matched by one of the SSE/AVX BLEND instructions. These instructions only
24017   // depend on the highest bit in each word. Try to use SimplifyDemandedBits
24018   // to simplify previous instructions.
24019   if (N->getOpcode() == ISD::VSELECT && DCI.isBeforeLegalizeOps() &&
24020       !DCI.isBeforeLegalize() &&
24021       // We explicitly check against SSE4.1, v8i16 and v16i16 because, although
24022       // vselect nodes may be marked as Custom, they might only be legal when
24023       // Cond is a build_vector of constants. This will be taken care in
24024       // a later condition.
24025       (TLI.isOperationLegalOrCustom(ISD::VSELECT, VT) &&
24026        Subtarget->hasSSE41() && VT != MVT::v16i16 && VT != MVT::v8i16) &&
24027       // Don't optimize vector of constants. Those are handled by
24028       // the generic code and all the bits must be properly set for
24029       // the generic optimizer.
24030       !ISD::isBuildVectorOfConstantSDNodes(Cond.getNode())) {
24031     unsigned BitWidth = Cond.getValueType().getScalarType().getSizeInBits();
24032
24033     // Don't optimize vector selects that map to mask-registers.
24034     if (BitWidth == 1)
24035       return SDValue();
24036
24037     assert(BitWidth >= 8 && BitWidth <= 64 && "Invalid mask size");
24038     APInt DemandedMask = APInt::getHighBitsSet(BitWidth, 1);
24039
24040     APInt KnownZero, KnownOne;
24041     TargetLowering::TargetLoweringOpt TLO(DAG, DCI.isBeforeLegalize(),
24042                                           DCI.isBeforeLegalizeOps());
24043     if (TLO.ShrinkDemandedConstant(Cond, DemandedMask) ||
24044         TLI.SimplifyDemandedBits(Cond, DemandedMask, KnownZero, KnownOne,
24045                                  TLO)) {
24046       // If we changed the computation somewhere in the DAG, this change
24047       // will affect all users of Cond.
24048       // Make sure it is fine and update all the nodes so that we do not
24049       // use the generic VSELECT anymore. Otherwise, we may perform
24050       // wrong optimizations as we messed up with the actual expectation
24051       // for the vector boolean values.
24052       if (Cond != TLO.Old) {
24053         // Check all uses of that condition operand to check whether it will be
24054         // consumed by non-BLEND instructions, which may depend on all bits are
24055         // set properly.
24056         for (SDNode::use_iterator I = Cond->use_begin(), E = Cond->use_end();
24057              I != E; ++I)
24058           if (I->getOpcode() != ISD::VSELECT)
24059             // TODO: Add other opcodes eventually lowered into BLEND.
24060             return SDValue();
24061
24062         // Update all the users of the condition, before committing the change,
24063         // so that the VSELECT optimizations that expect the correct vector
24064         // boolean value will not be triggered.
24065         for (SDNode::use_iterator I = Cond->use_begin(), E = Cond->use_end();
24066              I != E; ++I)
24067           DAG.ReplaceAllUsesOfValueWith(
24068               SDValue(*I, 0),
24069               DAG.getNode(X86ISD::SHRUNKBLEND, SDLoc(*I), I->getValueType(0),
24070                           Cond, I->getOperand(1), I->getOperand(2)));
24071         DCI.CommitTargetLoweringOpt(TLO);
24072         return SDValue();
24073       }
24074       // At this point, only Cond is changed. Change the condition
24075       // just for N to keep the opportunity to optimize all other
24076       // users their own way.
24077       DAG.ReplaceAllUsesOfValueWith(
24078           SDValue(N, 0),
24079           DAG.getNode(X86ISD::SHRUNKBLEND, SDLoc(N), N->getValueType(0),
24080                       TLO.New, N->getOperand(1), N->getOperand(2)));
24081       return SDValue();
24082     }
24083   }
24084
24085   // We should generate an X86ISD::BLENDI from a vselect if its argument
24086   // is a sign_extend_inreg of an any_extend of a BUILD_VECTOR of
24087   // constants. This specific pattern gets generated when we split a
24088   // selector for a 512 bit vector in a machine without AVX512 (but with
24089   // 256-bit vectors), during legalization:
24090   //
24091   // (vselect (sign_extend (any_extend (BUILD_VECTOR)) i1) LHS RHS)
24092   //
24093   // Iff we find this pattern and the build_vectors are built from
24094   // constants, we translate the vselect into a shuffle_vector that we
24095   // know will be matched by LowerVECTOR_SHUFFLEtoBlend.
24096   if ((N->getOpcode() == ISD::VSELECT ||
24097        N->getOpcode() == X86ISD::SHRUNKBLEND) &&
24098       !DCI.isBeforeLegalize()) {
24099     SDValue Shuffle = transformVSELECTtoBlendVECTOR_SHUFFLE(N, DAG, Subtarget);
24100     if (Shuffle.getNode())
24101       return Shuffle;
24102   }
24103
24104   return SDValue();
24105 }
24106
24107 // Check whether a boolean test is testing a boolean value generated by
24108 // X86ISD::SETCC. If so, return the operand of that SETCC and proper condition
24109 // code.
24110 //
24111 // Simplify the following patterns:
24112 // (Op (CMP (SETCC Cond EFLAGS) 1) EQ) or
24113 // (Op (CMP (SETCC Cond EFLAGS) 0) NEQ)
24114 // to (Op EFLAGS Cond)
24115 //
24116 // (Op (CMP (SETCC Cond EFLAGS) 0) EQ) or
24117 // (Op (CMP (SETCC Cond EFLAGS) 1) NEQ)
24118 // to (Op EFLAGS !Cond)
24119 //
24120 // where Op could be BRCOND or CMOV.
24121 //
24122 static SDValue checkBoolTestSetCCCombine(SDValue Cmp, X86::CondCode &CC) {
24123   // Quit if not CMP and SUB with its value result used.
24124   if (Cmp.getOpcode() != X86ISD::CMP &&
24125       (Cmp.getOpcode() != X86ISD::SUB || Cmp.getNode()->hasAnyUseOfValue(0)))
24126       return SDValue();
24127
24128   // Quit if not used as a boolean value.
24129   if (CC != X86::COND_E && CC != X86::COND_NE)
24130     return SDValue();
24131
24132   // Check CMP operands. One of them should be 0 or 1 and the other should be
24133   // an SetCC or extended from it.
24134   SDValue Op1 = Cmp.getOperand(0);
24135   SDValue Op2 = Cmp.getOperand(1);
24136
24137   SDValue SetCC;
24138   const ConstantSDNode* C = nullptr;
24139   bool needOppositeCond = (CC == X86::COND_E);
24140   bool checkAgainstTrue = false; // Is it a comparison against 1?
24141
24142   if ((C = dyn_cast<ConstantSDNode>(Op1)))
24143     SetCC = Op2;
24144   else if ((C = dyn_cast<ConstantSDNode>(Op2)))
24145     SetCC = Op1;
24146   else // Quit if all operands are not constants.
24147     return SDValue();
24148
24149   if (C->getZExtValue() == 1) {
24150     needOppositeCond = !needOppositeCond;
24151     checkAgainstTrue = true;
24152   } else if (C->getZExtValue() != 0)
24153     // Quit if the constant is neither 0 or 1.
24154     return SDValue();
24155
24156   bool truncatedToBoolWithAnd = false;
24157   // Skip (zext $x), (trunc $x), or (and $x, 1) node.
24158   while (SetCC.getOpcode() == ISD::ZERO_EXTEND ||
24159          SetCC.getOpcode() == ISD::TRUNCATE ||
24160          SetCC.getOpcode() == ISD::AND) {
24161     if (SetCC.getOpcode() == ISD::AND) {
24162       int OpIdx = -1;
24163       ConstantSDNode *CS;
24164       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(0))) &&
24165           CS->getZExtValue() == 1)
24166         OpIdx = 1;
24167       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(1))) &&
24168           CS->getZExtValue() == 1)
24169         OpIdx = 0;
24170       if (OpIdx == -1)
24171         break;
24172       SetCC = SetCC.getOperand(OpIdx);
24173       truncatedToBoolWithAnd = true;
24174     } else
24175       SetCC = SetCC.getOperand(0);
24176   }
24177
24178   switch (SetCC.getOpcode()) {
24179   case X86ISD::SETCC_CARRY:
24180     // Since SETCC_CARRY gives output based on R = CF ? ~0 : 0, it's unsafe to
24181     // simplify it if the result of SETCC_CARRY is not canonicalized to 0 or 1,
24182     // i.e. it's a comparison against true but the result of SETCC_CARRY is not
24183     // truncated to i1 using 'and'.
24184     if (checkAgainstTrue && !truncatedToBoolWithAnd)
24185       break;
24186     assert(X86::CondCode(SetCC.getConstantOperandVal(0)) == X86::COND_B &&
24187            "Invalid use of SETCC_CARRY!");
24188     // FALL THROUGH
24189   case X86ISD::SETCC:
24190     // Set the condition code or opposite one if necessary.
24191     CC = X86::CondCode(SetCC.getConstantOperandVal(0));
24192     if (needOppositeCond)
24193       CC = X86::GetOppositeBranchCondition(CC);
24194     return SetCC.getOperand(1);
24195   case X86ISD::CMOV: {
24196     // Check whether false/true value has canonical one, i.e. 0 or 1.
24197     ConstantSDNode *FVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(0));
24198     ConstantSDNode *TVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(1));
24199     // Quit if true value is not a constant.
24200     if (!TVal)
24201       return SDValue();
24202     // Quit if false value is not a constant.
24203     if (!FVal) {
24204       SDValue Op = SetCC.getOperand(0);
24205       // Skip 'zext' or 'trunc' node.
24206       if (Op.getOpcode() == ISD::ZERO_EXTEND ||
24207           Op.getOpcode() == ISD::TRUNCATE)
24208         Op = Op.getOperand(0);
24209       // A special case for rdrand/rdseed, where 0 is set if false cond is
24210       // found.
24211       if ((Op.getOpcode() != X86ISD::RDRAND &&
24212            Op.getOpcode() != X86ISD::RDSEED) || Op.getResNo() != 0)
24213         return SDValue();
24214     }
24215     // Quit if false value is not the constant 0 or 1.
24216     bool FValIsFalse = true;
24217     if (FVal && FVal->getZExtValue() != 0) {
24218       if (FVal->getZExtValue() != 1)
24219         return SDValue();
24220       // If FVal is 1, opposite cond is needed.
24221       needOppositeCond = !needOppositeCond;
24222       FValIsFalse = false;
24223     }
24224     // Quit if TVal is not the constant opposite of FVal.
24225     if (FValIsFalse && TVal->getZExtValue() != 1)
24226       return SDValue();
24227     if (!FValIsFalse && TVal->getZExtValue() != 0)
24228       return SDValue();
24229     CC = X86::CondCode(SetCC.getConstantOperandVal(2));
24230     if (needOppositeCond)
24231       CC = X86::GetOppositeBranchCondition(CC);
24232     return SetCC.getOperand(3);
24233   }
24234   }
24235
24236   return SDValue();
24237 }
24238
24239 /// Optimize X86ISD::CMOV [LHS, RHS, CONDCODE (e.g. X86::COND_NE), CONDVAL]
24240 static SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG,
24241                                   TargetLowering::DAGCombinerInfo &DCI,
24242                                   const X86Subtarget *Subtarget) {
24243   SDLoc DL(N);
24244
24245   // If the flag operand isn't dead, don't touch this CMOV.
24246   if (N->getNumValues() == 2 && !SDValue(N, 1).use_empty())
24247     return SDValue();
24248
24249   SDValue FalseOp = N->getOperand(0);
24250   SDValue TrueOp = N->getOperand(1);
24251   X86::CondCode CC = (X86::CondCode)N->getConstantOperandVal(2);
24252   SDValue Cond = N->getOperand(3);
24253
24254   if (CC == X86::COND_E || CC == X86::COND_NE) {
24255     switch (Cond.getOpcode()) {
24256     default: break;
24257     case X86ISD::BSR:
24258     case X86ISD::BSF:
24259       // If operand of BSR / BSF are proven never zero, then ZF cannot be set.
24260       if (DAG.isKnownNeverZero(Cond.getOperand(0)))
24261         return (CC == X86::COND_E) ? FalseOp : TrueOp;
24262     }
24263   }
24264
24265   SDValue Flags;
24266
24267   Flags = checkBoolTestSetCCCombine(Cond, CC);
24268   if (Flags.getNode() &&
24269       // Extra check as FCMOV only supports a subset of X86 cond.
24270       (FalseOp.getValueType() != MVT::f80 || hasFPCMov(CC))) {
24271     SDValue Ops[] = { FalseOp, TrueOp,
24272                       DAG.getConstant(CC, MVT::i8), Flags };
24273     return DAG.getNode(X86ISD::CMOV, DL, N->getVTList(), Ops);
24274   }
24275
24276   // If this is a select between two integer constants, try to do some
24277   // optimizations.  Note that the operands are ordered the opposite of SELECT
24278   // operands.
24279   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(TrueOp)) {
24280     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(FalseOp)) {
24281       // Canonicalize the TrueC/FalseC values so that TrueC (the true value) is
24282       // larger than FalseC (the false value).
24283       if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue())) {
24284         CC = X86::GetOppositeBranchCondition(CC);
24285         std::swap(TrueC, FalseC);
24286         std::swap(TrueOp, FalseOp);
24287       }
24288
24289       // Optimize C ? 8 : 0 -> zext(setcc(C)) << 3.  Likewise for any pow2/0.
24290       // This is efficient for any integer data type (including i8/i16) and
24291       // shift amount.
24292       if (FalseC->getAPIntValue() == 0 && TrueC->getAPIntValue().isPowerOf2()) {
24293         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
24294                            DAG.getConstant(CC, MVT::i8), Cond);
24295
24296         // Zero extend the condition if needed.
24297         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
24298
24299         unsigned ShAmt = TrueC->getAPIntValue().logBase2();
24300         Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
24301                            DAG.getConstant(ShAmt, MVT::i8));
24302         if (N->getNumValues() == 2)  // Dead flag value?
24303           return DCI.CombineTo(N, Cond, SDValue());
24304         return Cond;
24305       }
24306
24307       // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.  This is efficient
24308       // for any integer data type, including i8/i16.
24309       if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
24310         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
24311                            DAG.getConstant(CC, MVT::i8), Cond);
24312
24313         // Zero extend the condition if needed.
24314         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
24315                            FalseC->getValueType(0), Cond);
24316         Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
24317                            SDValue(FalseC, 0));
24318
24319         if (N->getNumValues() == 2)  // Dead flag value?
24320           return DCI.CombineTo(N, Cond, SDValue());
24321         return Cond;
24322       }
24323
24324       // Optimize cases that will turn into an LEA instruction.  This requires
24325       // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
24326       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
24327         uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
24328         if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
24329
24330         bool isFastMultiplier = false;
24331         if (Diff < 10) {
24332           switch ((unsigned char)Diff) {
24333           default: break;
24334           case 1:  // result = add base, cond
24335           case 2:  // result = lea base(    , cond*2)
24336           case 3:  // result = lea base(cond, cond*2)
24337           case 4:  // result = lea base(    , cond*4)
24338           case 5:  // result = lea base(cond, cond*4)
24339           case 8:  // result = lea base(    , cond*8)
24340           case 9:  // result = lea base(cond, cond*8)
24341             isFastMultiplier = true;
24342             break;
24343           }
24344         }
24345
24346         if (isFastMultiplier) {
24347           APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
24348           Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
24349                              DAG.getConstant(CC, MVT::i8), Cond);
24350           // Zero extend the condition if needed.
24351           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
24352                              Cond);
24353           // Scale the condition by the difference.
24354           if (Diff != 1)
24355             Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
24356                                DAG.getConstant(Diff, Cond.getValueType()));
24357
24358           // Add the base if non-zero.
24359           if (FalseC->getAPIntValue() != 0)
24360             Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
24361                                SDValue(FalseC, 0));
24362           if (N->getNumValues() == 2)  // Dead flag value?
24363             return DCI.CombineTo(N, Cond, SDValue());
24364           return Cond;
24365         }
24366       }
24367     }
24368   }
24369
24370   // Handle these cases:
24371   //   (select (x != c), e, c) -> select (x != c), e, x),
24372   //   (select (x == c), c, e) -> select (x == c), x, e)
24373   // where the c is an integer constant, and the "select" is the combination
24374   // of CMOV and CMP.
24375   //
24376   // The rationale for this change is that the conditional-move from a constant
24377   // needs two instructions, however, conditional-move from a register needs
24378   // only one instruction.
24379   //
24380   // CAVEAT: By replacing a constant with a symbolic value, it may obscure
24381   //  some instruction-combining opportunities. This opt needs to be
24382   //  postponed as late as possible.
24383   //
24384   if (!DCI.isBeforeLegalize() && !DCI.isBeforeLegalizeOps()) {
24385     // the DCI.xxxx conditions are provided to postpone the optimization as
24386     // late as possible.
24387
24388     ConstantSDNode *CmpAgainst = nullptr;
24389     if ((Cond.getOpcode() == X86ISD::CMP || Cond.getOpcode() == X86ISD::SUB) &&
24390         (CmpAgainst = dyn_cast<ConstantSDNode>(Cond.getOperand(1))) &&
24391         !isa<ConstantSDNode>(Cond.getOperand(0))) {
24392
24393       if (CC == X86::COND_NE &&
24394           CmpAgainst == dyn_cast<ConstantSDNode>(FalseOp)) {
24395         CC = X86::GetOppositeBranchCondition(CC);
24396         std::swap(TrueOp, FalseOp);
24397       }
24398
24399       if (CC == X86::COND_E &&
24400           CmpAgainst == dyn_cast<ConstantSDNode>(TrueOp)) {
24401         SDValue Ops[] = { FalseOp, Cond.getOperand(0),
24402                           DAG.getConstant(CC, MVT::i8), Cond };
24403         return DAG.getNode(X86ISD::CMOV, DL, N->getVTList (), Ops);
24404       }
24405     }
24406   }
24407
24408   return SDValue();
24409 }
24410
24411 static SDValue PerformINTRINSIC_WO_CHAINCombine(SDNode *N, SelectionDAG &DAG,
24412                                                 const X86Subtarget *Subtarget) {
24413   unsigned IntNo = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
24414   switch (IntNo) {
24415   default: return SDValue();
24416   // SSE/AVX/AVX2 blend intrinsics.
24417   case Intrinsic::x86_avx2_pblendvb:
24418   case Intrinsic::x86_avx2_pblendw:
24419   case Intrinsic::x86_avx2_pblendd_128:
24420   case Intrinsic::x86_avx2_pblendd_256:
24421     // Don't try to simplify this intrinsic if we don't have AVX2.
24422     if (!Subtarget->hasAVX2())
24423       return SDValue();
24424     // FALL-THROUGH
24425   case Intrinsic::x86_avx_blend_pd_256:
24426   case Intrinsic::x86_avx_blend_ps_256:
24427   case Intrinsic::x86_avx_blendv_pd_256:
24428   case Intrinsic::x86_avx_blendv_ps_256:
24429     // Don't try to simplify this intrinsic if we don't have AVX.
24430     if (!Subtarget->hasAVX())
24431       return SDValue();
24432     // FALL-THROUGH
24433   case Intrinsic::x86_sse41_pblendw:
24434   case Intrinsic::x86_sse41_blendpd:
24435   case Intrinsic::x86_sse41_blendps:
24436   case Intrinsic::x86_sse41_blendvps:
24437   case Intrinsic::x86_sse41_blendvpd:
24438   case Intrinsic::x86_sse41_pblendvb: {
24439     SDValue Op0 = N->getOperand(1);
24440     SDValue Op1 = N->getOperand(2);
24441     SDValue Mask = N->getOperand(3);
24442
24443     // Don't try to simplify this intrinsic if we don't have SSE4.1.
24444     if (!Subtarget->hasSSE41())
24445       return SDValue();
24446
24447     // fold (blend A, A, Mask) -> A
24448     if (Op0 == Op1)
24449       return Op0;
24450     // fold (blend A, B, allZeros) -> A
24451     if (ISD::isBuildVectorAllZeros(Mask.getNode()))
24452       return Op0;
24453     // fold (blend A, B, allOnes) -> B
24454     if (ISD::isBuildVectorAllOnes(Mask.getNode()))
24455       return Op1;
24456
24457     // Simplify the case where the mask is a constant i32 value.
24458     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Mask)) {
24459       if (C->isNullValue())
24460         return Op0;
24461       if (C->isAllOnesValue())
24462         return Op1;
24463     }
24464
24465     return SDValue();
24466   }
24467
24468   // Packed SSE2/AVX2 arithmetic shift immediate intrinsics.
24469   case Intrinsic::x86_sse2_psrai_w:
24470   case Intrinsic::x86_sse2_psrai_d:
24471   case Intrinsic::x86_avx2_psrai_w:
24472   case Intrinsic::x86_avx2_psrai_d:
24473   case Intrinsic::x86_sse2_psra_w:
24474   case Intrinsic::x86_sse2_psra_d:
24475   case Intrinsic::x86_avx2_psra_w:
24476   case Intrinsic::x86_avx2_psra_d: {
24477     SDValue Op0 = N->getOperand(1);
24478     SDValue Op1 = N->getOperand(2);
24479     EVT VT = Op0.getValueType();
24480     assert(VT.isVector() && "Expected a vector type!");
24481
24482     if (isa<BuildVectorSDNode>(Op1))
24483       Op1 = Op1.getOperand(0);
24484
24485     if (!isa<ConstantSDNode>(Op1))
24486       return SDValue();
24487
24488     EVT SVT = VT.getVectorElementType();
24489     unsigned SVTBits = SVT.getSizeInBits();
24490
24491     ConstantSDNode *CND = cast<ConstantSDNode>(Op1);
24492     const APInt &C = APInt(SVTBits, CND->getAPIntValue().getZExtValue());
24493     uint64_t ShAmt = C.getZExtValue();
24494
24495     // Don't try to convert this shift into a ISD::SRA if the shift
24496     // count is bigger than or equal to the element size.
24497     if (ShAmt >= SVTBits)
24498       return SDValue();
24499
24500     // Trivial case: if the shift count is zero, then fold this
24501     // into the first operand.
24502     if (ShAmt == 0)
24503       return Op0;
24504
24505     // Replace this packed shift intrinsic with a target independent
24506     // shift dag node.
24507     SDValue Splat = DAG.getConstant(C, VT);
24508     return DAG.getNode(ISD::SRA, SDLoc(N), VT, Op0, Splat);
24509   }
24510   }
24511 }
24512
24513 /// PerformMulCombine - Optimize a single multiply with constant into two
24514 /// in order to implement it with two cheaper instructions, e.g.
24515 /// LEA + SHL, LEA + LEA.
24516 static SDValue PerformMulCombine(SDNode *N, SelectionDAG &DAG,
24517                                  TargetLowering::DAGCombinerInfo &DCI) {
24518   if (DCI.isBeforeLegalize() || DCI.isCalledByLegalizer())
24519     return SDValue();
24520
24521   EVT VT = N->getValueType(0);
24522   if (VT != MVT::i64 && VT != MVT::i32)
24523     return SDValue();
24524
24525   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1));
24526   if (!C)
24527     return SDValue();
24528   uint64_t MulAmt = C->getZExtValue();
24529   if (isPowerOf2_64(MulAmt) || MulAmt == 3 || MulAmt == 5 || MulAmt == 9)
24530     return SDValue();
24531
24532   uint64_t MulAmt1 = 0;
24533   uint64_t MulAmt2 = 0;
24534   if ((MulAmt % 9) == 0) {
24535     MulAmt1 = 9;
24536     MulAmt2 = MulAmt / 9;
24537   } else if ((MulAmt % 5) == 0) {
24538     MulAmt1 = 5;
24539     MulAmt2 = MulAmt / 5;
24540   } else if ((MulAmt % 3) == 0) {
24541     MulAmt1 = 3;
24542     MulAmt2 = MulAmt / 3;
24543   }
24544   if (MulAmt2 &&
24545       (isPowerOf2_64(MulAmt2) || MulAmt2 == 3 || MulAmt2 == 5 || MulAmt2 == 9)){
24546     SDLoc DL(N);
24547
24548     if (isPowerOf2_64(MulAmt2) &&
24549         !(N->hasOneUse() && N->use_begin()->getOpcode() == ISD::ADD))
24550       // If second multiplifer is pow2, issue it first. We want the multiply by
24551       // 3, 5, or 9 to be folded into the addressing mode unless the lone use
24552       // is an add.
24553       std::swap(MulAmt1, MulAmt2);
24554
24555     SDValue NewMul;
24556     if (isPowerOf2_64(MulAmt1))
24557       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
24558                            DAG.getConstant(Log2_64(MulAmt1), MVT::i8));
24559     else
24560       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
24561                            DAG.getConstant(MulAmt1, VT));
24562
24563     if (isPowerOf2_64(MulAmt2))
24564       NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
24565                            DAG.getConstant(Log2_64(MulAmt2), MVT::i8));
24566     else
24567       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
24568                            DAG.getConstant(MulAmt2, VT));
24569
24570     // Do not add new nodes to DAG combiner worklist.
24571     DCI.CombineTo(N, NewMul, false);
24572   }
24573   return SDValue();
24574 }
24575
24576 static SDValue PerformSHLCombine(SDNode *N, SelectionDAG &DAG) {
24577   SDValue N0 = N->getOperand(0);
24578   SDValue N1 = N->getOperand(1);
24579   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
24580   EVT VT = N0.getValueType();
24581
24582   // fold (shl (and (setcc_c), c1), c2) -> (and setcc_c, (c1 << c2))
24583   // since the result of setcc_c is all zero's or all ones.
24584   if (VT.isInteger() && !VT.isVector() &&
24585       N1C && N0.getOpcode() == ISD::AND &&
24586       N0.getOperand(1).getOpcode() == ISD::Constant) {
24587     SDValue N00 = N0.getOperand(0);
24588     if (N00.getOpcode() == X86ISD::SETCC_CARRY ||
24589         ((N00.getOpcode() == ISD::ANY_EXTEND ||
24590           N00.getOpcode() == ISD::ZERO_EXTEND) &&
24591          N00.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY)) {
24592       APInt Mask = cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue();
24593       APInt ShAmt = N1C->getAPIntValue();
24594       Mask = Mask.shl(ShAmt);
24595       if (Mask != 0)
24596         return DAG.getNode(ISD::AND, SDLoc(N), VT,
24597                            N00, DAG.getConstant(Mask, VT));
24598     }
24599   }
24600
24601   // Hardware support for vector shifts is sparse which makes us scalarize the
24602   // vector operations in many cases. Also, on sandybridge ADD is faster than
24603   // shl.
24604   // (shl V, 1) -> add V,V
24605   if (auto *N1BV = dyn_cast<BuildVectorSDNode>(N1))
24606     if (auto *N1SplatC = N1BV->getConstantSplatNode()) {
24607       assert(N0.getValueType().isVector() && "Invalid vector shift type");
24608       // We shift all of the values by one. In many cases we do not have
24609       // hardware support for this operation. This is better expressed as an ADD
24610       // of two values.
24611       if (N1SplatC->getZExtValue() == 1)
24612         return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N0);
24613     }
24614
24615   return SDValue();
24616 }
24617
24618 /// \brief Returns a vector of 0s if the node in input is a vector logical
24619 /// shift by a constant amount which is known to be bigger than or equal
24620 /// to the vector element size in bits.
24621 static SDValue performShiftToAllZeros(SDNode *N, SelectionDAG &DAG,
24622                                       const X86Subtarget *Subtarget) {
24623   EVT VT = N->getValueType(0);
24624
24625   if (VT != MVT::v2i64 && VT != MVT::v4i32 && VT != MVT::v8i16 &&
24626       (!Subtarget->hasInt256() ||
24627        (VT != MVT::v4i64 && VT != MVT::v8i32 && VT != MVT::v16i16)))
24628     return SDValue();
24629
24630   SDValue Amt = N->getOperand(1);
24631   SDLoc DL(N);
24632   if (auto *AmtBV = dyn_cast<BuildVectorSDNode>(Amt))
24633     if (auto *AmtSplat = AmtBV->getConstantSplatNode()) {
24634       APInt ShiftAmt = AmtSplat->getAPIntValue();
24635       unsigned MaxAmount = VT.getVectorElementType().getSizeInBits();
24636
24637       // SSE2/AVX2 logical shifts always return a vector of 0s
24638       // if the shift amount is bigger than or equal to
24639       // the element size. The constant shift amount will be
24640       // encoded as a 8-bit immediate.
24641       if (ShiftAmt.trunc(8).uge(MaxAmount))
24642         return getZeroVector(VT, Subtarget, DAG, DL);
24643     }
24644
24645   return SDValue();
24646 }
24647
24648 /// PerformShiftCombine - Combine shifts.
24649 static SDValue PerformShiftCombine(SDNode* N, SelectionDAG &DAG,
24650                                    TargetLowering::DAGCombinerInfo &DCI,
24651                                    const X86Subtarget *Subtarget) {
24652   if (N->getOpcode() == ISD::SHL) {
24653     SDValue V = PerformSHLCombine(N, DAG);
24654     if (V.getNode()) return V;
24655   }
24656
24657   if (N->getOpcode() != ISD::SRA) {
24658     // Try to fold this logical shift into a zero vector.
24659     SDValue V = performShiftToAllZeros(N, DAG, Subtarget);
24660     if (V.getNode()) return V;
24661   }
24662
24663   return SDValue();
24664 }
24665
24666 // CMPEQCombine - Recognize the distinctive  (AND (setcc ...) (setcc ..))
24667 // where both setccs reference the same FP CMP, and rewrite for CMPEQSS
24668 // and friends.  Likewise for OR -> CMPNEQSS.
24669 static SDValue CMPEQCombine(SDNode *N, SelectionDAG &DAG,
24670                             TargetLowering::DAGCombinerInfo &DCI,
24671                             const X86Subtarget *Subtarget) {
24672   unsigned opcode;
24673
24674   // SSE1 supports CMP{eq|ne}SS, and SSE2 added CMP{eq|ne}SD, but
24675   // we're requiring SSE2 for both.
24676   if (Subtarget->hasSSE2() && isAndOrOfSetCCs(SDValue(N, 0U), opcode)) {
24677     SDValue N0 = N->getOperand(0);
24678     SDValue N1 = N->getOperand(1);
24679     SDValue CMP0 = N0->getOperand(1);
24680     SDValue CMP1 = N1->getOperand(1);
24681     SDLoc DL(N);
24682
24683     // The SETCCs should both refer to the same CMP.
24684     if (CMP0.getOpcode() != X86ISD::CMP || CMP0 != CMP1)
24685       return SDValue();
24686
24687     SDValue CMP00 = CMP0->getOperand(0);
24688     SDValue CMP01 = CMP0->getOperand(1);
24689     EVT     VT    = CMP00.getValueType();
24690
24691     if (VT == MVT::f32 || VT == MVT::f64) {
24692       bool ExpectingFlags = false;
24693       // Check for any users that want flags:
24694       for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end();
24695            !ExpectingFlags && UI != UE; ++UI)
24696         switch (UI->getOpcode()) {
24697         default:
24698         case ISD::BR_CC:
24699         case ISD::BRCOND:
24700         case ISD::SELECT:
24701           ExpectingFlags = true;
24702           break;
24703         case ISD::CopyToReg:
24704         case ISD::SIGN_EXTEND:
24705         case ISD::ZERO_EXTEND:
24706         case ISD::ANY_EXTEND:
24707           break;
24708         }
24709
24710       if (!ExpectingFlags) {
24711         enum X86::CondCode cc0 = (enum X86::CondCode)N0.getConstantOperandVal(0);
24712         enum X86::CondCode cc1 = (enum X86::CondCode)N1.getConstantOperandVal(0);
24713
24714         if (cc1 == X86::COND_E || cc1 == X86::COND_NE) {
24715           X86::CondCode tmp = cc0;
24716           cc0 = cc1;
24717           cc1 = tmp;
24718         }
24719
24720         if ((cc0 == X86::COND_E  && cc1 == X86::COND_NP) ||
24721             (cc0 == X86::COND_NE && cc1 == X86::COND_P)) {
24722           // FIXME: need symbolic constants for these magic numbers.
24723           // See X86ATTInstPrinter.cpp:printSSECC().
24724           unsigned x86cc = (cc0 == X86::COND_E) ? 0 : 4;
24725           if (Subtarget->hasAVX512()) {
24726             SDValue FSetCC = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CMP00,
24727                                          CMP01, DAG.getConstant(x86cc, MVT::i8));
24728             if (N->getValueType(0) != MVT::i1)
24729               return DAG.getNode(ISD::ZERO_EXTEND, DL, N->getValueType(0),
24730                                  FSetCC);
24731             return FSetCC;
24732           }
24733           SDValue OnesOrZeroesF = DAG.getNode(X86ISD::FSETCC, DL,
24734                                               CMP00.getValueType(), CMP00, CMP01,
24735                                               DAG.getConstant(x86cc, MVT::i8));
24736
24737           bool is64BitFP = (CMP00.getValueType() == MVT::f64);
24738           MVT IntVT = is64BitFP ? MVT::i64 : MVT::i32;
24739
24740           if (is64BitFP && !Subtarget->is64Bit()) {
24741             // On a 32-bit target, we cannot bitcast the 64-bit float to a
24742             // 64-bit integer, since that's not a legal type. Since
24743             // OnesOrZeroesF is all ones of all zeroes, we don't need all the
24744             // bits, but can do this little dance to extract the lowest 32 bits
24745             // and work with those going forward.
24746             SDValue Vector64 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64,
24747                                            OnesOrZeroesF);
24748             SDValue Vector32 = DAG.getNode(ISD::BITCAST, DL, MVT::v4f32,
24749                                            Vector64);
24750             OnesOrZeroesF = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32,
24751                                         Vector32, DAG.getIntPtrConstant(0));
24752             IntVT = MVT::i32;
24753           }
24754
24755           SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, IntVT, OnesOrZeroesF);
24756           SDValue ANDed = DAG.getNode(ISD::AND, DL, IntVT, OnesOrZeroesI,
24757                                       DAG.getConstant(1, IntVT));
24758           SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
24759           return OneBitOfTruth;
24760         }
24761       }
24762     }
24763   }
24764   return SDValue();
24765 }
24766
24767 /// CanFoldXORWithAllOnes - Test whether the XOR operand is a AllOnes vector
24768 /// so it can be folded inside ANDNP.
24769 static bool CanFoldXORWithAllOnes(const SDNode *N) {
24770   EVT VT = N->getValueType(0);
24771
24772   // Match direct AllOnes for 128 and 256-bit vectors
24773   if (ISD::isBuildVectorAllOnes(N))
24774     return true;
24775
24776   // Look through a bit convert.
24777   if (N->getOpcode() == ISD::BITCAST)
24778     N = N->getOperand(0).getNode();
24779
24780   // Sometimes the operand may come from a insert_subvector building a 256-bit
24781   // allones vector
24782   if (VT.is256BitVector() &&
24783       N->getOpcode() == ISD::INSERT_SUBVECTOR) {
24784     SDValue V1 = N->getOperand(0);
24785     SDValue V2 = N->getOperand(1);
24786
24787     if (V1.getOpcode() == ISD::INSERT_SUBVECTOR &&
24788         V1.getOperand(0).getOpcode() == ISD::UNDEF &&
24789         ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
24790         ISD::isBuildVectorAllOnes(V2.getNode()))
24791       return true;
24792   }
24793
24794   return false;
24795 }
24796
24797 // On AVX/AVX2 the type v8i1 is legalized to v8i16, which is an XMM sized
24798 // register. In most cases we actually compare or select YMM-sized registers
24799 // and mixing the two types creates horrible code. This method optimizes
24800 // some of the transition sequences.
24801 static SDValue WidenMaskArithmetic(SDNode *N, SelectionDAG &DAG,
24802                                  TargetLowering::DAGCombinerInfo &DCI,
24803                                  const X86Subtarget *Subtarget) {
24804   EVT VT = N->getValueType(0);
24805   if (!VT.is256BitVector())
24806     return SDValue();
24807
24808   assert((N->getOpcode() == ISD::ANY_EXTEND ||
24809           N->getOpcode() == ISD::ZERO_EXTEND ||
24810           N->getOpcode() == ISD::SIGN_EXTEND) && "Invalid Node");
24811
24812   SDValue Narrow = N->getOperand(0);
24813   EVT NarrowVT = Narrow->getValueType(0);
24814   if (!NarrowVT.is128BitVector())
24815     return SDValue();
24816
24817   if (Narrow->getOpcode() != ISD::XOR &&
24818       Narrow->getOpcode() != ISD::AND &&
24819       Narrow->getOpcode() != ISD::OR)
24820     return SDValue();
24821
24822   SDValue N0  = Narrow->getOperand(0);
24823   SDValue N1  = Narrow->getOperand(1);
24824   SDLoc DL(Narrow);
24825
24826   // The Left side has to be a trunc.
24827   if (N0.getOpcode() != ISD::TRUNCATE)
24828     return SDValue();
24829
24830   // The type of the truncated inputs.
24831   EVT WideVT = N0->getOperand(0)->getValueType(0);
24832   if (WideVT != VT)
24833     return SDValue();
24834
24835   // The right side has to be a 'trunc' or a constant vector.
24836   bool RHSTrunc = N1.getOpcode() == ISD::TRUNCATE;
24837   ConstantSDNode *RHSConstSplat = nullptr;
24838   if (auto *RHSBV = dyn_cast<BuildVectorSDNode>(N1))
24839     RHSConstSplat = RHSBV->getConstantSplatNode();
24840   if (!RHSTrunc && !RHSConstSplat)
24841     return SDValue();
24842
24843   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
24844
24845   if (!TLI.isOperationLegalOrPromote(Narrow->getOpcode(), WideVT))
24846     return SDValue();
24847
24848   // Set N0 and N1 to hold the inputs to the new wide operation.
24849   N0 = N0->getOperand(0);
24850   if (RHSConstSplat) {
24851     N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, WideVT.getScalarType(),
24852                      SDValue(RHSConstSplat, 0));
24853     SmallVector<SDValue, 8> C(WideVT.getVectorNumElements(), N1);
24854     N1 = DAG.getNode(ISD::BUILD_VECTOR, DL, WideVT, C);
24855   } else if (RHSTrunc) {
24856     N1 = N1->getOperand(0);
24857   }
24858
24859   // Generate the wide operation.
24860   SDValue Op = DAG.getNode(Narrow->getOpcode(), DL, WideVT, N0, N1);
24861   unsigned Opcode = N->getOpcode();
24862   switch (Opcode) {
24863   case ISD::ANY_EXTEND:
24864     return Op;
24865   case ISD::ZERO_EXTEND: {
24866     unsigned InBits = NarrowVT.getScalarType().getSizeInBits();
24867     APInt Mask = APInt::getAllOnesValue(InBits);
24868     Mask = Mask.zext(VT.getScalarType().getSizeInBits());
24869     return DAG.getNode(ISD::AND, DL, VT,
24870                        Op, DAG.getConstant(Mask, VT));
24871   }
24872   case ISD::SIGN_EXTEND:
24873     return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT,
24874                        Op, DAG.getValueType(NarrowVT));
24875   default:
24876     llvm_unreachable("Unexpected opcode");
24877   }
24878 }
24879
24880 static SDValue VectorZextCombine(SDNode *N, SelectionDAG &DAG,
24881                                  TargetLowering::DAGCombinerInfo &DCI,
24882                                  const X86Subtarget *Subtarget) {
24883   SDValue N0 = N->getOperand(0);
24884   SDValue N1 = N->getOperand(1);
24885   SDLoc DL(N);
24886
24887   // A vector zext_in_reg may be represented as a shuffle,
24888   // feeding into a bitcast (this represents anyext) feeding into
24889   // an and with a mask.
24890   // We'd like to try to combine that into a shuffle with zero
24891   // plus a bitcast, removing the and.
24892   if (N0.getOpcode() != ISD::BITCAST ||
24893       N0.getOperand(0).getOpcode() != ISD::VECTOR_SHUFFLE)
24894     return SDValue();
24895
24896   // The other side of the AND should be a splat of 2^C, where C
24897   // is the number of bits in the source type.
24898   if (N1.getOpcode() == ISD::BITCAST)
24899     N1 = N1.getOperand(0);
24900   if (N1.getOpcode() != ISD::BUILD_VECTOR)
24901     return SDValue();
24902   BuildVectorSDNode *Vector = cast<BuildVectorSDNode>(N1);
24903
24904   ShuffleVectorSDNode *Shuffle = cast<ShuffleVectorSDNode>(N0.getOperand(0));
24905   EVT SrcType = Shuffle->getValueType(0);
24906
24907   // We expect a single-source shuffle
24908   if (Shuffle->getOperand(1)->getOpcode() != ISD::UNDEF)
24909     return SDValue();
24910
24911   unsigned SrcSize = SrcType.getScalarSizeInBits();
24912
24913   APInt SplatValue, SplatUndef;
24914   unsigned SplatBitSize;
24915   bool HasAnyUndefs;
24916   if (!Vector->isConstantSplat(SplatValue, SplatUndef,
24917                                 SplatBitSize, HasAnyUndefs))
24918     return SDValue();
24919
24920   unsigned ResSize = N1.getValueType().getScalarSizeInBits();
24921   // Make sure the splat matches the mask we expect
24922   if (SplatBitSize > ResSize ||
24923       (SplatValue + 1).exactLogBase2() != (int)SrcSize)
24924     return SDValue();
24925
24926   // Make sure the input and output size make sense
24927   if (SrcSize >= ResSize || ResSize % SrcSize)
24928     return SDValue();
24929
24930   // We expect a shuffle of the form <0, u, u, u, 1, u, u, u...>
24931   // The number of u's between each two values depends on the ratio between
24932   // the source and dest type.
24933   unsigned ZextRatio = ResSize / SrcSize;
24934   bool IsZext = true;
24935   for (unsigned i = 0; i < SrcType.getVectorNumElements(); ++i) {
24936     if (i % ZextRatio) {
24937       if (Shuffle->getMaskElt(i) > 0) {
24938         // Expected undef
24939         IsZext = false;
24940         break;
24941       }
24942     } else {
24943       if (Shuffle->getMaskElt(i) != (int)(i / ZextRatio)) {
24944         // Expected element number
24945         IsZext = false;
24946         break;
24947       }
24948     }
24949   }
24950
24951   if (!IsZext)
24952     return SDValue();
24953
24954   // Ok, perform the transformation - replace the shuffle with
24955   // a shuffle of the form <0, k, k, k, 1, k, k, k> with zero
24956   // (instead of undef) where the k elements come from the zero vector.
24957   SmallVector<int, 8> Mask;
24958   unsigned NumElems = SrcType.getVectorNumElements();
24959   for (unsigned i = 0; i < NumElems; ++i)
24960     if (i % ZextRatio)
24961       Mask.push_back(NumElems);
24962     else
24963       Mask.push_back(i / ZextRatio);
24964
24965   SDValue NewShuffle = DAG.getVectorShuffle(Shuffle->getValueType(0), DL,
24966     Shuffle->getOperand(0), DAG.getConstant(0, SrcType), Mask);
24967   return DAG.getNode(ISD::BITCAST, DL,  N0.getValueType(), NewShuffle);
24968 }
24969
24970 static SDValue PerformAndCombine(SDNode *N, SelectionDAG &DAG,
24971                                  TargetLowering::DAGCombinerInfo &DCI,
24972                                  const X86Subtarget *Subtarget) {
24973   if (DCI.isBeforeLegalizeOps())
24974     return SDValue();
24975
24976   SDValue Zext = VectorZextCombine(N, DAG, DCI, Subtarget);
24977   if (Zext.getNode())
24978     return Zext;
24979
24980   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
24981   if (R.getNode())
24982     return R;
24983
24984   EVT VT = N->getValueType(0);
24985   SDValue N0 = N->getOperand(0);
24986   SDValue N1 = N->getOperand(1);
24987   SDLoc DL(N);
24988
24989   // Create BEXTR instructions
24990   // BEXTR is ((X >> imm) & (2**size-1))
24991   if (VT == MVT::i32 || VT == MVT::i64) {
24992     // Check for BEXTR.
24993     if ((Subtarget->hasBMI() || Subtarget->hasTBM()) &&
24994         (N0.getOpcode() == ISD::SRA || N0.getOpcode() == ISD::SRL)) {
24995       ConstantSDNode *MaskNode = dyn_cast<ConstantSDNode>(N1);
24996       ConstantSDNode *ShiftNode = dyn_cast<ConstantSDNode>(N0.getOperand(1));
24997       if (MaskNode && ShiftNode) {
24998         uint64_t Mask = MaskNode->getZExtValue();
24999         uint64_t Shift = ShiftNode->getZExtValue();
25000         if (isMask_64(Mask)) {
25001           uint64_t MaskSize = countPopulation(Mask);
25002           if (Shift + MaskSize <= VT.getSizeInBits())
25003             return DAG.getNode(X86ISD::BEXTR, DL, VT, N0.getOperand(0),
25004                                DAG.getConstant(Shift | (MaskSize << 8), VT));
25005         }
25006       }
25007     } // BEXTR
25008
25009     return SDValue();
25010   }
25011
25012   // Want to form ANDNP nodes:
25013   // 1) In the hopes of then easily combining them with OR and AND nodes
25014   //    to form PBLEND/PSIGN.
25015   // 2) To match ANDN packed intrinsics
25016   if (VT != MVT::v2i64 && VT != MVT::v4i64)
25017     return SDValue();
25018
25019   // Check LHS for vnot
25020   if (N0.getOpcode() == ISD::XOR &&
25021       //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
25022       CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
25023     return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
25024
25025   // Check RHS for vnot
25026   if (N1.getOpcode() == ISD::XOR &&
25027       //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
25028       CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
25029     return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
25030
25031   return SDValue();
25032 }
25033
25034 static SDValue PerformOrCombine(SDNode *N, SelectionDAG &DAG,
25035                                 TargetLowering::DAGCombinerInfo &DCI,
25036                                 const X86Subtarget *Subtarget) {
25037   if (DCI.isBeforeLegalizeOps())
25038     return SDValue();
25039
25040   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
25041   if (R.getNode())
25042     return R;
25043
25044   SDValue N0 = N->getOperand(0);
25045   SDValue N1 = N->getOperand(1);
25046   EVT VT = N->getValueType(0);
25047
25048   // look for psign/blend
25049   if (VT == MVT::v2i64 || VT == MVT::v4i64) {
25050     if (!Subtarget->hasSSSE3() ||
25051         (VT == MVT::v4i64 && !Subtarget->hasInt256()))
25052       return SDValue();
25053
25054     // Canonicalize pandn to RHS
25055     if (N0.getOpcode() == X86ISD::ANDNP)
25056       std::swap(N0, N1);
25057     // or (and (m, y), (pandn m, x))
25058     if (N0.getOpcode() == ISD::AND && N1.getOpcode() == X86ISD::ANDNP) {
25059       SDValue Mask = N1.getOperand(0);
25060       SDValue X    = N1.getOperand(1);
25061       SDValue Y;
25062       if (N0.getOperand(0) == Mask)
25063         Y = N0.getOperand(1);
25064       if (N0.getOperand(1) == Mask)
25065         Y = N0.getOperand(0);
25066
25067       // Check to see if the mask appeared in both the AND and ANDNP and
25068       if (!Y.getNode())
25069         return SDValue();
25070
25071       // Validate that X, Y, and Mask are BIT_CONVERTS, and see through them.
25072       // Look through mask bitcast.
25073       if (Mask.getOpcode() == ISD::BITCAST)
25074         Mask = Mask.getOperand(0);
25075       if (X.getOpcode() == ISD::BITCAST)
25076         X = X.getOperand(0);
25077       if (Y.getOpcode() == ISD::BITCAST)
25078         Y = Y.getOperand(0);
25079
25080       EVT MaskVT = Mask.getValueType();
25081
25082       // Validate that the Mask operand is a vector sra node.
25083       // FIXME: what to do for bytes, since there is a psignb/pblendvb, but
25084       // there is no psrai.b
25085       unsigned EltBits = MaskVT.getVectorElementType().getSizeInBits();
25086       unsigned SraAmt = ~0;
25087       if (Mask.getOpcode() == ISD::SRA) {
25088         if (auto *AmtBV = dyn_cast<BuildVectorSDNode>(Mask.getOperand(1)))
25089           if (auto *AmtConst = AmtBV->getConstantSplatNode())
25090             SraAmt = AmtConst->getZExtValue();
25091       } else if (Mask.getOpcode() == X86ISD::VSRAI) {
25092         SDValue SraC = Mask.getOperand(1);
25093         SraAmt  = cast<ConstantSDNode>(SraC)->getZExtValue();
25094       }
25095       if ((SraAmt + 1) != EltBits)
25096         return SDValue();
25097
25098       SDLoc DL(N);
25099
25100       // Now we know we at least have a plendvb with the mask val.  See if
25101       // we can form a psignb/w/d.
25102       // psign = x.type == y.type == mask.type && y = sub(0, x);
25103       if (Y.getOpcode() == ISD::SUB && Y.getOperand(1) == X &&
25104           ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
25105           X.getValueType() == MaskVT && Y.getValueType() == MaskVT) {
25106         assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
25107                "Unsupported VT for PSIGN");
25108         Mask = DAG.getNode(X86ISD::PSIGN, DL, MaskVT, X, Mask.getOperand(0));
25109         return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
25110       }
25111       // PBLENDVB only available on SSE 4.1
25112       if (!Subtarget->hasSSE41())
25113         return SDValue();
25114
25115       EVT BlendVT = (VT == MVT::v4i64) ? MVT::v32i8 : MVT::v16i8;
25116
25117       X = DAG.getNode(ISD::BITCAST, DL, BlendVT, X);
25118       Y = DAG.getNode(ISD::BITCAST, DL, BlendVT, Y);
25119       Mask = DAG.getNode(ISD::BITCAST, DL, BlendVT, Mask);
25120       Mask = DAG.getNode(ISD::VSELECT, DL, BlendVT, Mask, Y, X);
25121       return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
25122     }
25123   }
25124
25125   if (VT != MVT::i16 && VT != MVT::i32 && VT != MVT::i64)
25126     return SDValue();
25127
25128   // fold (or (x << c) | (y >> (64 - c))) ==> (shld64 x, y, c)
25129   MachineFunction &MF = DAG.getMachineFunction();
25130   bool OptForSize =
25131       MF.getFunction()->hasFnAttribute(Attribute::OptimizeForSize);
25132
25133   // SHLD/SHRD instructions have lower register pressure, but on some
25134   // platforms they have higher latency than the equivalent
25135   // series of shifts/or that would otherwise be generated.
25136   // Don't fold (or (x << c) | (y >> (64 - c))) if SHLD/SHRD instructions
25137   // have higher latencies and we are not optimizing for size.
25138   if (!OptForSize && Subtarget->isSHLDSlow())
25139     return SDValue();
25140
25141   if (N0.getOpcode() == ISD::SRL && N1.getOpcode() == ISD::SHL)
25142     std::swap(N0, N1);
25143   if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
25144     return SDValue();
25145   if (!N0.hasOneUse() || !N1.hasOneUse())
25146     return SDValue();
25147
25148   SDValue ShAmt0 = N0.getOperand(1);
25149   if (ShAmt0.getValueType() != MVT::i8)
25150     return SDValue();
25151   SDValue ShAmt1 = N1.getOperand(1);
25152   if (ShAmt1.getValueType() != MVT::i8)
25153     return SDValue();
25154   if (ShAmt0.getOpcode() == ISD::TRUNCATE)
25155     ShAmt0 = ShAmt0.getOperand(0);
25156   if (ShAmt1.getOpcode() == ISD::TRUNCATE)
25157     ShAmt1 = ShAmt1.getOperand(0);
25158
25159   SDLoc DL(N);
25160   unsigned Opc = X86ISD::SHLD;
25161   SDValue Op0 = N0.getOperand(0);
25162   SDValue Op1 = N1.getOperand(0);
25163   if (ShAmt0.getOpcode() == ISD::SUB) {
25164     Opc = X86ISD::SHRD;
25165     std::swap(Op0, Op1);
25166     std::swap(ShAmt0, ShAmt1);
25167   }
25168
25169   unsigned Bits = VT.getSizeInBits();
25170   if (ShAmt1.getOpcode() == ISD::SUB) {
25171     SDValue Sum = ShAmt1.getOperand(0);
25172     if (ConstantSDNode *SumC = dyn_cast<ConstantSDNode>(Sum)) {
25173       SDValue ShAmt1Op1 = ShAmt1.getOperand(1);
25174       if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
25175         ShAmt1Op1 = ShAmt1Op1.getOperand(0);
25176       if (SumC->getSExtValue() == Bits && ShAmt1Op1 == ShAmt0)
25177         return DAG.getNode(Opc, DL, VT,
25178                            Op0, Op1,
25179                            DAG.getNode(ISD::TRUNCATE, DL,
25180                                        MVT::i8, ShAmt0));
25181     }
25182   } else if (ConstantSDNode *ShAmt1C = dyn_cast<ConstantSDNode>(ShAmt1)) {
25183     ConstantSDNode *ShAmt0C = dyn_cast<ConstantSDNode>(ShAmt0);
25184     if (ShAmt0C &&
25185         ShAmt0C->getSExtValue() + ShAmt1C->getSExtValue() == Bits)
25186       return DAG.getNode(Opc, DL, VT,
25187                          N0.getOperand(0), N1.getOperand(0),
25188                          DAG.getNode(ISD::TRUNCATE, DL,
25189                                        MVT::i8, ShAmt0));
25190   }
25191
25192   return SDValue();
25193 }
25194
25195 // Generate NEG and CMOV for integer abs.
25196 static SDValue performIntegerAbsCombine(SDNode *N, SelectionDAG &DAG) {
25197   EVT VT = N->getValueType(0);
25198
25199   // Since X86 does not have CMOV for 8-bit integer, we don't convert
25200   // 8-bit integer abs to NEG and CMOV.
25201   if (VT.isInteger() && VT.getSizeInBits() == 8)
25202     return SDValue();
25203
25204   SDValue N0 = N->getOperand(0);
25205   SDValue N1 = N->getOperand(1);
25206   SDLoc DL(N);
25207
25208   // Check pattern of XOR(ADD(X,Y), Y) where Y is SRA(X, size(X)-1)
25209   // and change it to SUB and CMOV.
25210   if (VT.isInteger() && N->getOpcode() == ISD::XOR &&
25211       N0.getOpcode() == ISD::ADD &&
25212       N0.getOperand(1) == N1 &&
25213       N1.getOpcode() == ISD::SRA &&
25214       N1.getOperand(0) == N0.getOperand(0))
25215     if (ConstantSDNode *Y1C = dyn_cast<ConstantSDNode>(N1.getOperand(1)))
25216       if (Y1C->getAPIntValue() == VT.getSizeInBits()-1) {
25217         // Generate SUB & CMOV.
25218         SDValue Neg = DAG.getNode(X86ISD::SUB, DL, DAG.getVTList(VT, MVT::i32),
25219                                   DAG.getConstant(0, VT), N0.getOperand(0));
25220
25221         SDValue Ops[] = { N0.getOperand(0), Neg,
25222                           DAG.getConstant(X86::COND_GE, MVT::i8),
25223                           SDValue(Neg.getNode(), 1) };
25224         return DAG.getNode(X86ISD::CMOV, DL, DAG.getVTList(VT, MVT::Glue), Ops);
25225       }
25226   return SDValue();
25227 }
25228
25229 // PerformXorCombine - Attempts to turn XOR nodes into BLSMSK nodes
25230 static SDValue PerformXorCombine(SDNode *N, SelectionDAG &DAG,
25231                                  TargetLowering::DAGCombinerInfo &DCI,
25232                                  const X86Subtarget *Subtarget) {
25233   if (DCI.isBeforeLegalizeOps())
25234     return SDValue();
25235
25236   if (Subtarget->hasCMov()) {
25237     SDValue RV = performIntegerAbsCombine(N, DAG);
25238     if (RV.getNode())
25239       return RV;
25240   }
25241
25242   return SDValue();
25243 }
25244
25245 /// PerformLOADCombine - Do target-specific dag combines on LOAD nodes.
25246 static SDValue PerformLOADCombine(SDNode *N, SelectionDAG &DAG,
25247                                   TargetLowering::DAGCombinerInfo &DCI,
25248                                   const X86Subtarget *Subtarget) {
25249   LoadSDNode *Ld = cast<LoadSDNode>(N);
25250   EVT RegVT = Ld->getValueType(0);
25251   EVT MemVT = Ld->getMemoryVT();
25252   SDLoc dl(Ld);
25253   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25254
25255   // For chips with slow 32-byte unaligned loads, break the 32-byte operation
25256   // into two 16-byte operations.
25257   ISD::LoadExtType Ext = Ld->getExtensionType();
25258   unsigned Alignment = Ld->getAlignment();
25259   bool IsAligned = Alignment == 0 || Alignment >= MemVT.getSizeInBits()/8;
25260   if (RegVT.is256BitVector() && Subtarget->isUnalignedMem32Slow() &&
25261       !DCI.isBeforeLegalizeOps() && !IsAligned && Ext == ISD::NON_EXTLOAD) {
25262     unsigned NumElems = RegVT.getVectorNumElements();
25263     if (NumElems < 2)
25264       return SDValue();
25265
25266     SDValue Ptr = Ld->getBasePtr();
25267     SDValue Increment = DAG.getConstant(16, TLI.getPointerTy());
25268
25269     EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
25270                                   NumElems/2);
25271     SDValue Load1 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
25272                                 Ld->getPointerInfo(), Ld->isVolatile(),
25273                                 Ld->isNonTemporal(), Ld->isInvariant(),
25274                                 Alignment);
25275     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
25276     SDValue Load2 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
25277                                 Ld->getPointerInfo(), Ld->isVolatile(),
25278                                 Ld->isNonTemporal(), Ld->isInvariant(),
25279                                 std::min(16U, Alignment));
25280     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
25281                              Load1.getValue(1),
25282                              Load2.getValue(1));
25283
25284     SDValue NewVec = DAG.getUNDEF(RegVT);
25285     NewVec = Insert128BitVector(NewVec, Load1, 0, DAG, dl);
25286     NewVec = Insert128BitVector(NewVec, Load2, NumElems/2, DAG, dl);
25287     return DCI.CombineTo(N, NewVec, TF, true);
25288   }
25289
25290   return SDValue();
25291 }
25292
25293 /// PerformMLOADCombine - Resolve extending loads
25294 static SDValue PerformMLOADCombine(SDNode *N, SelectionDAG &DAG,
25295                                    TargetLowering::DAGCombinerInfo &DCI,
25296                                    const X86Subtarget *Subtarget) {
25297   MaskedLoadSDNode *Mld = cast<MaskedLoadSDNode>(N);
25298   if (Mld->getExtensionType() != ISD::SEXTLOAD)
25299     return SDValue();
25300
25301   EVT VT = Mld->getValueType(0);
25302   unsigned NumElems = VT.getVectorNumElements();
25303   EVT LdVT = Mld->getMemoryVT();
25304   SDLoc dl(Mld);
25305
25306   assert(LdVT != VT && "Cannot extend to the same type");
25307   unsigned ToSz = VT.getVectorElementType().getSizeInBits();
25308   unsigned FromSz = LdVT.getVectorElementType().getSizeInBits();
25309   // From, To sizes and ElemCount must be pow of two
25310   assert (isPowerOf2_32(NumElems * FromSz * ToSz) &&
25311     "Unexpected size for extending masked load");
25312
25313   unsigned SizeRatio  = ToSz / FromSz;
25314   assert(SizeRatio * NumElems * FromSz == VT.getSizeInBits());
25315
25316   // Create a type on which we perform the shuffle
25317   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
25318           LdVT.getScalarType(), NumElems*SizeRatio);
25319   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
25320
25321   // Convert Src0 value
25322   SDValue WideSrc0 = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mld->getSrc0());
25323   if (Mld->getSrc0().getOpcode() != ISD::UNDEF) {
25324     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
25325     for (unsigned i = 0; i != NumElems; ++i)
25326       ShuffleVec[i] = i * SizeRatio;
25327
25328     // Can't shuffle using an illegal type.
25329     assert (DAG.getTargetLoweringInfo().isTypeLegal(WideVecVT)
25330             && "WideVecVT should be legal");
25331     WideSrc0 = DAG.getVectorShuffle(WideVecVT, dl, WideSrc0,
25332                                     DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
25333   }
25334   // Prepare the new mask
25335   SDValue NewMask;
25336   SDValue Mask = Mld->getMask();
25337   if (Mask.getValueType() == VT) {
25338     // Mask and original value have the same type
25339     NewMask = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mask);
25340     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
25341     for (unsigned i = 0; i != NumElems; ++i)
25342       ShuffleVec[i] = i * SizeRatio;
25343     for (unsigned i = NumElems; i != NumElems*SizeRatio; ++i)
25344       ShuffleVec[i] = NumElems*SizeRatio;
25345     NewMask = DAG.getVectorShuffle(WideVecVT, dl, NewMask,
25346                                    DAG.getConstant(0, WideVecVT),
25347                                    &ShuffleVec[0]);
25348   }
25349   else {
25350     assert(Mask.getValueType().getVectorElementType() == MVT::i1);
25351     unsigned WidenNumElts = NumElems*SizeRatio;
25352     unsigned MaskNumElts = VT.getVectorNumElements();
25353     EVT NewMaskVT = EVT::getVectorVT(*DAG.getContext(),  MVT::i1,
25354                                      WidenNumElts);
25355
25356     unsigned NumConcat = WidenNumElts / MaskNumElts;
25357     SmallVector<SDValue, 16> Ops(NumConcat);
25358     SDValue ZeroVal = DAG.getConstant(0, Mask.getValueType());
25359     Ops[0] = Mask;
25360     for (unsigned i = 1; i != NumConcat; ++i)
25361       Ops[i] = ZeroVal;
25362
25363     NewMask = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewMaskVT, Ops);
25364   }
25365
25366   SDValue WideLd = DAG.getMaskedLoad(WideVecVT, dl, Mld->getChain(),
25367                                      Mld->getBasePtr(), NewMask, WideSrc0,
25368                                      Mld->getMemoryVT(), Mld->getMemOperand(),
25369                                      ISD::NON_EXTLOAD);
25370   SDValue NewVec = DAG.getNode(X86ISD::VSEXT, dl, VT, WideLd);
25371   return DCI.CombineTo(N, NewVec, WideLd.getValue(1), true);
25372
25373 }
25374 /// PerformMSTORECombine - Resolve truncating stores
25375 static SDValue PerformMSTORECombine(SDNode *N, SelectionDAG &DAG,
25376                                     const X86Subtarget *Subtarget) {
25377   MaskedStoreSDNode *Mst = cast<MaskedStoreSDNode>(N);
25378   if (!Mst->isTruncatingStore())
25379     return SDValue();
25380
25381   EVT VT = Mst->getValue().getValueType();
25382   unsigned NumElems = VT.getVectorNumElements();
25383   EVT StVT = Mst->getMemoryVT();
25384   SDLoc dl(Mst);
25385
25386   assert(StVT != VT && "Cannot truncate to the same type");
25387   unsigned FromSz = VT.getVectorElementType().getSizeInBits();
25388   unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
25389
25390   // From, To sizes and ElemCount must be pow of two
25391   assert (isPowerOf2_32(NumElems * FromSz * ToSz) &&
25392     "Unexpected size for truncating masked store");
25393   // We are going to use the original vector elt for storing.
25394   // Accumulated smaller vector elements must be a multiple of the store size.
25395   assert (((NumElems * FromSz) % ToSz) == 0 &&
25396           "Unexpected ratio for truncating masked store");
25397
25398   unsigned SizeRatio  = FromSz / ToSz;
25399   assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
25400
25401   // Create a type on which we perform the shuffle
25402   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
25403           StVT.getScalarType(), NumElems*SizeRatio);
25404
25405   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
25406
25407   SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mst->getValue());
25408   SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
25409   for (unsigned i = 0; i != NumElems; ++i)
25410     ShuffleVec[i] = i * SizeRatio;
25411
25412   // Can't shuffle using an illegal type.
25413   assert (DAG.getTargetLoweringInfo().isTypeLegal(WideVecVT)
25414           && "WideVecVT should be legal");
25415
25416   SDValue TruncatedVal = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
25417                                         DAG.getUNDEF(WideVecVT),
25418                                         &ShuffleVec[0]);
25419
25420   SDValue NewMask;
25421   SDValue Mask = Mst->getMask();
25422   if (Mask.getValueType() == VT) {
25423     // Mask and original value have the same type
25424     NewMask = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mask);
25425     for (unsigned i = 0; i != NumElems; ++i)
25426       ShuffleVec[i] = i * SizeRatio;
25427     for (unsigned i = NumElems; i != NumElems*SizeRatio; ++i)
25428       ShuffleVec[i] = NumElems*SizeRatio;
25429     NewMask = DAG.getVectorShuffle(WideVecVT, dl, NewMask,
25430                                    DAG.getConstant(0, WideVecVT),
25431                                    &ShuffleVec[0]);
25432   }
25433   else {
25434     assert(Mask.getValueType().getVectorElementType() == MVT::i1);
25435     unsigned WidenNumElts = NumElems*SizeRatio;
25436     unsigned MaskNumElts = VT.getVectorNumElements();
25437     EVT NewMaskVT = EVT::getVectorVT(*DAG.getContext(),  MVT::i1,
25438                                      WidenNumElts);
25439
25440     unsigned NumConcat = WidenNumElts / MaskNumElts;
25441     SmallVector<SDValue, 16> Ops(NumConcat);
25442     SDValue ZeroVal = DAG.getConstant(0, Mask.getValueType());
25443     Ops[0] = Mask;
25444     for (unsigned i = 1; i != NumConcat; ++i)
25445       Ops[i] = ZeroVal;
25446
25447     NewMask = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewMaskVT, Ops);
25448   }
25449
25450   return DAG.getMaskedStore(Mst->getChain(), dl, TruncatedVal, Mst->getBasePtr(),
25451                             NewMask, StVT, Mst->getMemOperand(), false);
25452 }
25453 /// PerformSTORECombine - Do target-specific dag combines on STORE nodes.
25454 static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
25455                                    const X86Subtarget *Subtarget) {
25456   StoreSDNode *St = cast<StoreSDNode>(N);
25457   EVT VT = St->getValue().getValueType();
25458   EVT StVT = St->getMemoryVT();
25459   SDLoc dl(St);
25460   SDValue StoredVal = St->getOperand(1);
25461   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25462
25463   // If we are saving a concatenation of two XMM registers and 32-byte stores
25464   // are slow, such as on Sandy Bridge, perform two 16-byte stores.
25465   unsigned Alignment = St->getAlignment();
25466   bool IsAligned = Alignment == 0 || Alignment >= VT.getSizeInBits()/8;
25467   if (VT.is256BitVector() && Subtarget->isUnalignedMem32Slow() &&
25468       StVT == VT && !IsAligned) {
25469     unsigned NumElems = VT.getVectorNumElements();
25470     if (NumElems < 2)
25471       return SDValue();
25472
25473     SDValue Value0 = Extract128BitVector(StoredVal, 0, DAG, dl);
25474     SDValue Value1 = Extract128BitVector(StoredVal, NumElems/2, DAG, dl);
25475
25476     SDValue Stride = DAG.getConstant(16, TLI.getPointerTy());
25477     SDValue Ptr0 = St->getBasePtr();
25478     SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
25479
25480     SDValue Ch0 = DAG.getStore(St->getChain(), dl, Value0, Ptr0,
25481                                 St->getPointerInfo(), St->isVolatile(),
25482                                 St->isNonTemporal(), Alignment);
25483     SDValue Ch1 = DAG.getStore(St->getChain(), dl, Value1, Ptr1,
25484                                 St->getPointerInfo(), St->isVolatile(),
25485                                 St->isNonTemporal(),
25486                                 std::min(16U, Alignment));
25487     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
25488   }
25489
25490   // Optimize trunc store (of multiple scalars) to shuffle and store.
25491   // First, pack all of the elements in one place. Next, store to memory
25492   // in fewer chunks.
25493   if (St->isTruncatingStore() && VT.isVector()) {
25494     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25495     unsigned NumElems = VT.getVectorNumElements();
25496     assert(StVT != VT && "Cannot truncate to the same type");
25497     unsigned FromSz = VT.getVectorElementType().getSizeInBits();
25498     unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
25499
25500     // From, To sizes and ElemCount must be pow of two
25501     if (!isPowerOf2_32(NumElems * FromSz * ToSz)) return SDValue();
25502     // We are going to use the original vector elt for storing.
25503     // Accumulated smaller vector elements must be a multiple of the store size.
25504     if (0 != (NumElems * FromSz) % ToSz) return SDValue();
25505
25506     unsigned SizeRatio  = FromSz / ToSz;
25507
25508     assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
25509
25510     // Create a type on which we perform the shuffle
25511     EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
25512             StVT.getScalarType(), NumElems*SizeRatio);
25513
25514     assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
25515
25516     SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
25517     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
25518     for (unsigned i = 0; i != NumElems; ++i)
25519       ShuffleVec[i] = i * SizeRatio;
25520
25521     // Can't shuffle using an illegal type.
25522     if (!TLI.isTypeLegal(WideVecVT))
25523       return SDValue();
25524
25525     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
25526                                          DAG.getUNDEF(WideVecVT),
25527                                          &ShuffleVec[0]);
25528     // At this point all of the data is stored at the bottom of the
25529     // register. We now need to save it to mem.
25530
25531     // Find the largest store unit
25532     MVT StoreType = MVT::i8;
25533     for (MVT Tp : MVT::integer_valuetypes()) {
25534       if (TLI.isTypeLegal(Tp) && Tp.getSizeInBits() <= NumElems * ToSz)
25535         StoreType = Tp;
25536     }
25537
25538     // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
25539     if (TLI.isTypeLegal(MVT::f64) && StoreType.getSizeInBits() < 64 &&
25540         (64 <= NumElems * ToSz))
25541       StoreType = MVT::f64;
25542
25543     // Bitcast the original vector into a vector of store-size units
25544     EVT StoreVecVT = EVT::getVectorVT(*DAG.getContext(),
25545             StoreType, VT.getSizeInBits()/StoreType.getSizeInBits());
25546     assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
25547     SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
25548     SmallVector<SDValue, 8> Chains;
25549     SDValue Increment = DAG.getConstant(StoreType.getSizeInBits()/8,
25550                                         TLI.getPointerTy());
25551     SDValue Ptr = St->getBasePtr();
25552
25553     // Perform one or more big stores into memory.
25554     for (unsigned i=0, e=(ToSz*NumElems)/StoreType.getSizeInBits(); i!=e; ++i) {
25555       SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
25556                                    StoreType, ShuffWide,
25557                                    DAG.getIntPtrConstant(i));
25558       SDValue Ch = DAG.getStore(St->getChain(), dl, SubVec, Ptr,
25559                                 St->getPointerInfo(), St->isVolatile(),
25560                                 St->isNonTemporal(), St->getAlignment());
25561       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
25562       Chains.push_back(Ch);
25563     }
25564
25565     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
25566   }
25567
25568   // Turn load->store of MMX types into GPR load/stores.  This avoids clobbering
25569   // the FP state in cases where an emms may be missing.
25570   // A preferable solution to the general problem is to figure out the right
25571   // places to insert EMMS.  This qualifies as a quick hack.
25572
25573   // Similarly, turn load->store of i64 into double load/stores in 32-bit mode.
25574   if (VT.getSizeInBits() != 64)
25575     return SDValue();
25576
25577   const Function *F = DAG.getMachineFunction().getFunction();
25578   bool NoImplicitFloatOps = F->hasFnAttribute(Attribute::NoImplicitFloat);
25579   bool F64IsLegal = !DAG.getTarget().Options.UseSoftFloat && !NoImplicitFloatOps
25580                      && Subtarget->hasSSE2();
25581   if ((VT.isVector() ||
25582        (VT == MVT::i64 && F64IsLegal && !Subtarget->is64Bit())) &&
25583       isa<LoadSDNode>(St->getValue()) &&
25584       !cast<LoadSDNode>(St->getValue())->isVolatile() &&
25585       St->getChain().hasOneUse() && !St->isVolatile()) {
25586     SDNode* LdVal = St->getValue().getNode();
25587     LoadSDNode *Ld = nullptr;
25588     int TokenFactorIndex = -1;
25589     SmallVector<SDValue, 8> Ops;
25590     SDNode* ChainVal = St->getChain().getNode();
25591     // Must be a store of a load.  We currently handle two cases:  the load
25592     // is a direct child, and it's under an intervening TokenFactor.  It is
25593     // possible to dig deeper under nested TokenFactors.
25594     if (ChainVal == LdVal)
25595       Ld = cast<LoadSDNode>(St->getChain());
25596     else if (St->getValue().hasOneUse() &&
25597              ChainVal->getOpcode() == ISD::TokenFactor) {
25598       for (unsigned i = 0, e = ChainVal->getNumOperands(); i != e; ++i) {
25599         if (ChainVal->getOperand(i).getNode() == LdVal) {
25600           TokenFactorIndex = i;
25601           Ld = cast<LoadSDNode>(St->getValue());
25602         } else
25603           Ops.push_back(ChainVal->getOperand(i));
25604       }
25605     }
25606
25607     if (!Ld || !ISD::isNormalLoad(Ld))
25608       return SDValue();
25609
25610     // If this is not the MMX case, i.e. we are just turning i64 load/store
25611     // into f64 load/store, avoid the transformation if there are multiple
25612     // uses of the loaded value.
25613     if (!VT.isVector() && !Ld->hasNUsesOfValue(1, 0))
25614       return SDValue();
25615
25616     SDLoc LdDL(Ld);
25617     SDLoc StDL(N);
25618     // If we are a 64-bit capable x86, lower to a single movq load/store pair.
25619     // Otherwise, if it's legal to use f64 SSE instructions, use f64 load/store
25620     // pair instead.
25621     if (Subtarget->is64Bit() || F64IsLegal) {
25622       EVT LdVT = Subtarget->is64Bit() ? MVT::i64 : MVT::f64;
25623       SDValue NewLd = DAG.getLoad(LdVT, LdDL, Ld->getChain(), Ld->getBasePtr(),
25624                                   Ld->getPointerInfo(), Ld->isVolatile(),
25625                                   Ld->isNonTemporal(), Ld->isInvariant(),
25626                                   Ld->getAlignment());
25627       SDValue NewChain = NewLd.getValue(1);
25628       if (TokenFactorIndex != -1) {
25629         Ops.push_back(NewChain);
25630         NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
25631       }
25632       return DAG.getStore(NewChain, StDL, NewLd, St->getBasePtr(),
25633                           St->getPointerInfo(),
25634                           St->isVolatile(), St->isNonTemporal(),
25635                           St->getAlignment());
25636     }
25637
25638     // Otherwise, lower to two pairs of 32-bit loads / stores.
25639     SDValue LoAddr = Ld->getBasePtr();
25640     SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
25641                                  DAG.getConstant(4, MVT::i32));
25642
25643     SDValue LoLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), LoAddr,
25644                                Ld->getPointerInfo(),
25645                                Ld->isVolatile(), Ld->isNonTemporal(),
25646                                Ld->isInvariant(), Ld->getAlignment());
25647     SDValue HiLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), HiAddr,
25648                                Ld->getPointerInfo().getWithOffset(4),
25649                                Ld->isVolatile(), Ld->isNonTemporal(),
25650                                Ld->isInvariant(),
25651                                MinAlign(Ld->getAlignment(), 4));
25652
25653     SDValue NewChain = LoLd.getValue(1);
25654     if (TokenFactorIndex != -1) {
25655       Ops.push_back(LoLd);
25656       Ops.push_back(HiLd);
25657       NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
25658     }
25659
25660     LoAddr = St->getBasePtr();
25661     HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
25662                          DAG.getConstant(4, MVT::i32));
25663
25664     SDValue LoSt = DAG.getStore(NewChain, StDL, LoLd, LoAddr,
25665                                 St->getPointerInfo(),
25666                                 St->isVolatile(), St->isNonTemporal(),
25667                                 St->getAlignment());
25668     SDValue HiSt = DAG.getStore(NewChain, StDL, HiLd, HiAddr,
25669                                 St->getPointerInfo().getWithOffset(4),
25670                                 St->isVolatile(),
25671                                 St->isNonTemporal(),
25672                                 MinAlign(St->getAlignment(), 4));
25673     return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
25674   }
25675   return SDValue();
25676 }
25677
25678 /// Return 'true' if this vector operation is "horizontal"
25679 /// and return the operands for the horizontal operation in LHS and RHS.  A
25680 /// horizontal operation performs the binary operation on successive elements
25681 /// of its first operand, then on successive elements of its second operand,
25682 /// returning the resulting values in a vector.  For example, if
25683 ///   A = < float a0, float a1, float a2, float a3 >
25684 /// and
25685 ///   B = < float b0, float b1, float b2, float b3 >
25686 /// then the result of doing a horizontal operation on A and B is
25687 ///   A horizontal-op B = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >.
25688 /// In short, LHS and RHS are inspected to see if LHS op RHS is of the form
25689 /// A horizontal-op B, for some already available A and B, and if so then LHS is
25690 /// set to A, RHS to B, and the routine returns 'true'.
25691 /// Note that the binary operation should have the property that if one of the
25692 /// operands is UNDEF then the result is UNDEF.
25693 static bool isHorizontalBinOp(SDValue &LHS, SDValue &RHS, bool IsCommutative) {
25694   // Look for the following pattern: if
25695   //   A = < float a0, float a1, float a2, float a3 >
25696   //   B = < float b0, float b1, float b2, float b3 >
25697   // and
25698   //   LHS = VECTOR_SHUFFLE A, B, <0, 2, 4, 6>
25699   //   RHS = VECTOR_SHUFFLE A, B, <1, 3, 5, 7>
25700   // then LHS op RHS = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >
25701   // which is A horizontal-op B.
25702
25703   // At least one of the operands should be a vector shuffle.
25704   if (LHS.getOpcode() != ISD::VECTOR_SHUFFLE &&
25705       RHS.getOpcode() != ISD::VECTOR_SHUFFLE)
25706     return false;
25707
25708   MVT VT = LHS.getSimpleValueType();
25709
25710   assert((VT.is128BitVector() || VT.is256BitVector()) &&
25711          "Unsupported vector type for horizontal add/sub");
25712
25713   // Handle 128 and 256-bit vector lengths. AVX defines horizontal add/sub to
25714   // operate independently on 128-bit lanes.
25715   unsigned NumElts = VT.getVectorNumElements();
25716   unsigned NumLanes = VT.getSizeInBits()/128;
25717   unsigned NumLaneElts = NumElts / NumLanes;
25718   assert((NumLaneElts % 2 == 0) &&
25719          "Vector type should have an even number of elements in each lane");
25720   unsigned HalfLaneElts = NumLaneElts/2;
25721
25722   // View LHS in the form
25723   //   LHS = VECTOR_SHUFFLE A, B, LMask
25724   // If LHS is not a shuffle then pretend it is the shuffle
25725   //   LHS = VECTOR_SHUFFLE LHS, undef, <0, 1, ..., N-1>
25726   // NOTE: in what follows a default initialized SDValue represents an UNDEF of
25727   // type VT.
25728   SDValue A, B;
25729   SmallVector<int, 16> LMask(NumElts);
25730   if (LHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
25731     if (LHS.getOperand(0).getOpcode() != ISD::UNDEF)
25732       A = LHS.getOperand(0);
25733     if (LHS.getOperand(1).getOpcode() != ISD::UNDEF)
25734       B = LHS.getOperand(1);
25735     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(LHS.getNode())->getMask();
25736     std::copy(Mask.begin(), Mask.end(), LMask.begin());
25737   } else {
25738     if (LHS.getOpcode() != ISD::UNDEF)
25739       A = LHS;
25740     for (unsigned i = 0; i != NumElts; ++i)
25741       LMask[i] = i;
25742   }
25743
25744   // Likewise, view RHS in the form
25745   //   RHS = VECTOR_SHUFFLE C, D, RMask
25746   SDValue C, D;
25747   SmallVector<int, 16> RMask(NumElts);
25748   if (RHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
25749     if (RHS.getOperand(0).getOpcode() != ISD::UNDEF)
25750       C = RHS.getOperand(0);
25751     if (RHS.getOperand(1).getOpcode() != ISD::UNDEF)
25752       D = RHS.getOperand(1);
25753     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(RHS.getNode())->getMask();
25754     std::copy(Mask.begin(), Mask.end(), RMask.begin());
25755   } else {
25756     if (RHS.getOpcode() != ISD::UNDEF)
25757       C = RHS;
25758     for (unsigned i = 0; i != NumElts; ++i)
25759       RMask[i] = i;
25760   }
25761
25762   // Check that the shuffles are both shuffling the same vectors.
25763   if (!(A == C && B == D) && !(A == D && B == C))
25764     return false;
25765
25766   // If everything is UNDEF then bail out: it would be better to fold to UNDEF.
25767   if (!A.getNode() && !B.getNode())
25768     return false;
25769
25770   // If A and B occur in reverse order in RHS, then "swap" them (which means
25771   // rewriting the mask).
25772   if (A != C)
25773     CommuteVectorShuffleMask(RMask, NumElts);
25774
25775   // At this point LHS and RHS are equivalent to
25776   //   LHS = VECTOR_SHUFFLE A, B, LMask
25777   //   RHS = VECTOR_SHUFFLE A, B, RMask
25778   // Check that the masks correspond to performing a horizontal operation.
25779   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
25780     for (unsigned i = 0; i != NumLaneElts; ++i) {
25781       int LIdx = LMask[i+l], RIdx = RMask[i+l];
25782
25783       // Ignore any UNDEF components.
25784       if (LIdx < 0 || RIdx < 0 ||
25785           (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
25786           (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
25787         continue;
25788
25789       // Check that successive elements are being operated on.  If not, this is
25790       // not a horizontal operation.
25791       unsigned Src = (i/HalfLaneElts); // each lane is split between srcs
25792       int Index = 2*(i%HalfLaneElts) + NumElts*Src + l;
25793       if (!(LIdx == Index && RIdx == Index + 1) &&
25794           !(IsCommutative && LIdx == Index + 1 && RIdx == Index))
25795         return false;
25796     }
25797   }
25798
25799   LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
25800   RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
25801   return true;
25802 }
25803
25804 /// Do target-specific dag combines on floating point adds.
25805 static SDValue PerformFADDCombine(SDNode *N, SelectionDAG &DAG,
25806                                   const X86Subtarget *Subtarget) {
25807   EVT VT = N->getValueType(0);
25808   SDValue LHS = N->getOperand(0);
25809   SDValue RHS = N->getOperand(1);
25810
25811   // Try to synthesize horizontal adds from adds of shuffles.
25812   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
25813        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
25814       isHorizontalBinOp(LHS, RHS, true))
25815     return DAG.getNode(X86ISD::FHADD, SDLoc(N), VT, LHS, RHS);
25816   return SDValue();
25817 }
25818
25819 /// Do target-specific dag combines on floating point subs.
25820 static SDValue PerformFSUBCombine(SDNode *N, SelectionDAG &DAG,
25821                                   const X86Subtarget *Subtarget) {
25822   EVT VT = N->getValueType(0);
25823   SDValue LHS = N->getOperand(0);
25824   SDValue RHS = N->getOperand(1);
25825
25826   // Try to synthesize horizontal subs from subs of shuffles.
25827   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
25828        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
25829       isHorizontalBinOp(LHS, RHS, false))
25830     return DAG.getNode(X86ISD::FHSUB, SDLoc(N), VT, LHS, RHS);
25831   return SDValue();
25832 }
25833
25834 /// Do target-specific dag combines on X86ISD::FOR and X86ISD::FXOR nodes.
25835 static SDValue PerformFORCombine(SDNode *N, SelectionDAG &DAG) {
25836   assert(N->getOpcode() == X86ISD::FOR || N->getOpcode() == X86ISD::FXOR);
25837
25838   // F[X]OR(0.0, x) -> x
25839   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25840     if (C->getValueAPF().isPosZero())
25841       return N->getOperand(1);
25842
25843   // F[X]OR(x, 0.0) -> x
25844   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
25845     if (C->getValueAPF().isPosZero())
25846       return N->getOperand(0);
25847   return SDValue();
25848 }
25849
25850 /// Do target-specific dag combines on X86ISD::FMIN and X86ISD::FMAX nodes.
25851 static SDValue PerformFMinFMaxCombine(SDNode *N, SelectionDAG &DAG) {
25852   assert(N->getOpcode() == X86ISD::FMIN || N->getOpcode() == X86ISD::FMAX);
25853
25854   // Only perform optimizations if UnsafeMath is used.
25855   if (!DAG.getTarget().Options.UnsafeFPMath)
25856     return SDValue();
25857
25858   // If we run in unsafe-math mode, then convert the FMAX and FMIN nodes
25859   // into FMINC and FMAXC, which are Commutative operations.
25860   unsigned NewOp = 0;
25861   switch (N->getOpcode()) {
25862     default: llvm_unreachable("unknown opcode");
25863     case X86ISD::FMIN:  NewOp = X86ISD::FMINC; break;
25864     case X86ISD::FMAX:  NewOp = X86ISD::FMAXC; break;
25865   }
25866
25867   return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
25868                      N->getOperand(0), N->getOperand(1));
25869 }
25870
25871 /// Do target-specific dag combines on X86ISD::FAND nodes.
25872 static SDValue PerformFANDCombine(SDNode *N, SelectionDAG &DAG) {
25873   // FAND(0.0, x) -> 0.0
25874   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25875     if (C->getValueAPF().isPosZero())
25876       return N->getOperand(0);
25877
25878   // FAND(x, 0.0) -> 0.0
25879   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
25880     if (C->getValueAPF().isPosZero())
25881       return N->getOperand(1);
25882
25883   return SDValue();
25884 }
25885
25886 /// Do target-specific dag combines on X86ISD::FANDN nodes
25887 static SDValue PerformFANDNCombine(SDNode *N, SelectionDAG &DAG) {
25888   // FANDN(0.0, x) -> x
25889   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25890     if (C->getValueAPF().isPosZero())
25891       return N->getOperand(1);
25892
25893   // FANDN(x, 0.0) -> 0.0
25894   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
25895     if (C->getValueAPF().isPosZero())
25896       return N->getOperand(1);
25897
25898   return SDValue();
25899 }
25900
25901 static SDValue PerformBTCombine(SDNode *N,
25902                                 SelectionDAG &DAG,
25903                                 TargetLowering::DAGCombinerInfo &DCI) {
25904   // BT ignores high bits in the bit index operand.
25905   SDValue Op1 = N->getOperand(1);
25906   if (Op1.hasOneUse()) {
25907     unsigned BitWidth = Op1.getValueSizeInBits();
25908     APInt DemandedMask = APInt::getLowBitsSet(BitWidth, Log2_32(BitWidth));
25909     APInt KnownZero, KnownOne;
25910     TargetLowering::TargetLoweringOpt TLO(DAG, !DCI.isBeforeLegalize(),
25911                                           !DCI.isBeforeLegalizeOps());
25912     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25913     if (TLO.ShrinkDemandedConstant(Op1, DemandedMask) ||
25914         TLI.SimplifyDemandedBits(Op1, DemandedMask, KnownZero, KnownOne, TLO))
25915       DCI.CommitTargetLoweringOpt(TLO);
25916   }
25917   return SDValue();
25918 }
25919
25920 static SDValue PerformVZEXT_MOVLCombine(SDNode *N, SelectionDAG &DAG) {
25921   SDValue Op = N->getOperand(0);
25922   if (Op.getOpcode() == ISD::BITCAST)
25923     Op = Op.getOperand(0);
25924   EVT VT = N->getValueType(0), OpVT = Op.getValueType();
25925   if (Op.getOpcode() == X86ISD::VZEXT_LOAD &&
25926       VT.getVectorElementType().getSizeInBits() ==
25927       OpVT.getVectorElementType().getSizeInBits()) {
25928     return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
25929   }
25930   return SDValue();
25931 }
25932
25933 static SDValue PerformSIGN_EXTEND_INREGCombine(SDNode *N, SelectionDAG &DAG,
25934                                                const X86Subtarget *Subtarget) {
25935   EVT VT = N->getValueType(0);
25936   if (!VT.isVector())
25937     return SDValue();
25938
25939   SDValue N0 = N->getOperand(0);
25940   SDValue N1 = N->getOperand(1);
25941   EVT ExtraVT = cast<VTSDNode>(N1)->getVT();
25942   SDLoc dl(N);
25943
25944   // The SIGN_EXTEND_INREG to v4i64 is expensive operation on the
25945   // both SSE and AVX2 since there is no sign-extended shift right
25946   // operation on a vector with 64-bit elements.
25947   //(sext_in_reg (v4i64 anyext (v4i32 x )), ExtraVT) ->
25948   // (v4i64 sext (v4i32 sext_in_reg (v4i32 x , ExtraVT)))
25949   if (VT == MVT::v4i64 && (N0.getOpcode() == ISD::ANY_EXTEND ||
25950       N0.getOpcode() == ISD::SIGN_EXTEND)) {
25951     SDValue N00 = N0.getOperand(0);
25952
25953     // EXTLOAD has a better solution on AVX2,
25954     // it may be replaced with X86ISD::VSEXT node.
25955     if (N00.getOpcode() == ISD::LOAD && Subtarget->hasInt256())
25956       if (!ISD::isNormalLoad(N00.getNode()))
25957         return SDValue();
25958
25959     if (N00.getValueType() == MVT::v4i32 && ExtraVT.getSizeInBits() < 128) {
25960         SDValue Tmp = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32,
25961                                   N00, N1);
25962       return DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i64, Tmp);
25963     }
25964   }
25965   return SDValue();
25966 }
25967
25968 static SDValue PerformSExtCombine(SDNode *N, SelectionDAG &DAG,
25969                                   TargetLowering::DAGCombinerInfo &DCI,
25970                                   const X86Subtarget *Subtarget) {
25971   SDValue N0 = N->getOperand(0);
25972   EVT VT = N->getValueType(0);
25973
25974   // (i8,i32 sext (sdivrem (i8 x, i8 y)) ->
25975   // (i8,i32 (sdivrem_sext_hreg (i8 x, i8 y)
25976   // This exposes the sext to the sdivrem lowering, so that it directly extends
25977   // from AH (which we otherwise need to do contortions to access).
25978   if (N0.getOpcode() == ISD::SDIVREM && N0.getResNo() == 1 &&
25979       N0.getValueType() == MVT::i8 && VT == MVT::i32) {
25980     SDLoc dl(N);
25981     SDVTList NodeTys = DAG.getVTList(MVT::i8, VT);
25982     SDValue R = DAG.getNode(X86ISD::SDIVREM8_SEXT_HREG, dl, NodeTys,
25983                             N0.getOperand(0), N0.getOperand(1));
25984     DAG.ReplaceAllUsesOfValueWith(N0.getValue(0), R.getValue(0));
25985     return R.getValue(1);
25986   }
25987
25988   if (!DCI.isBeforeLegalizeOps())
25989     return SDValue();
25990
25991   if (!Subtarget->hasFp256())
25992     return SDValue();
25993
25994   if (VT.isVector() && VT.getSizeInBits() == 256) {
25995     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
25996     if (R.getNode())
25997       return R;
25998   }
25999
26000   return SDValue();
26001 }
26002
26003 static SDValue PerformFMACombine(SDNode *N, SelectionDAG &DAG,
26004                                  const X86Subtarget* Subtarget) {
26005   SDLoc dl(N);
26006   EVT VT = N->getValueType(0);
26007
26008   // Let legalize expand this if it isn't a legal type yet.
26009   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
26010     return SDValue();
26011
26012   EVT ScalarVT = VT.getScalarType();
26013   if ((ScalarVT != MVT::f32 && ScalarVT != MVT::f64) ||
26014       (!Subtarget->hasFMA() && !Subtarget->hasFMA4()))
26015     return SDValue();
26016
26017   SDValue A = N->getOperand(0);
26018   SDValue B = N->getOperand(1);
26019   SDValue C = N->getOperand(2);
26020
26021   bool NegA = (A.getOpcode() == ISD::FNEG);
26022   bool NegB = (B.getOpcode() == ISD::FNEG);
26023   bool NegC = (C.getOpcode() == ISD::FNEG);
26024
26025   // Negative multiplication when NegA xor NegB
26026   bool NegMul = (NegA != NegB);
26027   if (NegA)
26028     A = A.getOperand(0);
26029   if (NegB)
26030     B = B.getOperand(0);
26031   if (NegC)
26032     C = C.getOperand(0);
26033
26034   unsigned Opcode;
26035   if (!NegMul)
26036     Opcode = (!NegC) ? X86ISD::FMADD : X86ISD::FMSUB;
26037   else
26038     Opcode = (!NegC) ? X86ISD::FNMADD : X86ISD::FNMSUB;
26039
26040   return DAG.getNode(Opcode, dl, VT, A, B, C);
26041 }
26042
26043 static SDValue PerformZExtCombine(SDNode *N, SelectionDAG &DAG,
26044                                   TargetLowering::DAGCombinerInfo &DCI,
26045                                   const X86Subtarget *Subtarget) {
26046   // (i32 zext (and (i8  x86isd::setcc_carry), 1)) ->
26047   //           (and (i32 x86isd::setcc_carry), 1)
26048   // This eliminates the zext. This transformation is necessary because
26049   // ISD::SETCC is always legalized to i8.
26050   SDLoc dl(N);
26051   SDValue N0 = N->getOperand(0);
26052   EVT VT = N->getValueType(0);
26053
26054   if (N0.getOpcode() == ISD::AND &&
26055       N0.hasOneUse() &&
26056       N0.getOperand(0).hasOneUse()) {
26057     SDValue N00 = N0.getOperand(0);
26058     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
26059       ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
26060       if (!C || C->getZExtValue() != 1)
26061         return SDValue();
26062       return DAG.getNode(ISD::AND, dl, VT,
26063                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
26064                                      N00.getOperand(0), N00.getOperand(1)),
26065                          DAG.getConstant(1, VT));
26066     }
26067   }
26068
26069   if (N0.getOpcode() == ISD::TRUNCATE &&
26070       N0.hasOneUse() &&
26071       N0.getOperand(0).hasOneUse()) {
26072     SDValue N00 = N0.getOperand(0);
26073     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
26074       return DAG.getNode(ISD::AND, dl, VT,
26075                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
26076                                      N00.getOperand(0), N00.getOperand(1)),
26077                          DAG.getConstant(1, VT));
26078     }
26079   }
26080   if (VT.is256BitVector()) {
26081     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
26082     if (R.getNode())
26083       return R;
26084   }
26085
26086   // (i8,i32 zext (udivrem (i8 x, i8 y)) ->
26087   // (i8,i32 (udivrem_zext_hreg (i8 x, i8 y)
26088   // This exposes the zext to the udivrem lowering, so that it directly extends
26089   // from AH (which we otherwise need to do contortions to access).
26090   if (N0.getOpcode() == ISD::UDIVREM &&
26091       N0.getResNo() == 1 && N0.getValueType() == MVT::i8 &&
26092       (VT == MVT::i32 || VT == MVT::i64)) {
26093     SDVTList NodeTys = DAG.getVTList(MVT::i8, VT);
26094     SDValue R = DAG.getNode(X86ISD::UDIVREM8_ZEXT_HREG, dl, NodeTys,
26095                             N0.getOperand(0), N0.getOperand(1));
26096     DAG.ReplaceAllUsesOfValueWith(N0.getValue(0), R.getValue(0));
26097     return R.getValue(1);
26098   }
26099
26100   return SDValue();
26101 }
26102
26103 // Optimize x == -y --> x+y == 0
26104 //          x != -y --> x+y != 0
26105 static SDValue PerformISDSETCCCombine(SDNode *N, SelectionDAG &DAG,
26106                                       const X86Subtarget* Subtarget) {
26107   ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
26108   SDValue LHS = N->getOperand(0);
26109   SDValue RHS = N->getOperand(1);
26110   EVT VT = N->getValueType(0);
26111   SDLoc DL(N);
26112
26113   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && LHS.getOpcode() == ISD::SUB)
26114     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHS.getOperand(0)))
26115       if (C->getAPIntValue() == 0 && LHS.hasOneUse()) {
26116         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
26117                                    LHS.getValueType(), RHS, LHS.getOperand(1));
26118         return DAG.getSetCC(SDLoc(N), N->getValueType(0),
26119                             addV, DAG.getConstant(0, addV.getValueType()), CC);
26120       }
26121   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && RHS.getOpcode() == ISD::SUB)
26122     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS.getOperand(0)))
26123       if (C->getAPIntValue() == 0 && RHS.hasOneUse()) {
26124         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
26125                                    RHS.getValueType(), LHS, RHS.getOperand(1));
26126         return DAG.getSetCC(SDLoc(N), N->getValueType(0),
26127                             addV, DAG.getConstant(0, addV.getValueType()), CC);
26128       }
26129
26130   if (VT.getScalarType() == MVT::i1) {
26131     bool IsSEXT0 = (LHS.getOpcode() == ISD::SIGN_EXTEND) &&
26132       (LHS.getOperand(0).getValueType().getScalarType() ==  MVT::i1);
26133     bool IsVZero0 = ISD::isBuildVectorAllZeros(LHS.getNode());
26134     if (!IsSEXT0 && !IsVZero0)
26135       return SDValue();
26136     bool IsSEXT1 = (RHS.getOpcode() == ISD::SIGN_EXTEND) &&
26137       (RHS.getOperand(0).getValueType().getScalarType() ==  MVT::i1);
26138     bool IsVZero1 = ISD::isBuildVectorAllZeros(RHS.getNode());
26139
26140     if (!IsSEXT1 && !IsVZero1)
26141       return SDValue();
26142
26143     if (IsSEXT0 && IsVZero1) {
26144       assert(VT == LHS.getOperand(0).getValueType() && "Uexpected operand type");
26145       if (CC == ISD::SETEQ)
26146         return DAG.getNOT(DL, LHS.getOperand(0), VT);
26147       return LHS.getOperand(0);
26148     }
26149     if (IsSEXT1 && IsVZero0) {
26150       assert(VT == RHS.getOperand(0).getValueType() && "Uexpected operand type");
26151       if (CC == ISD::SETEQ)
26152         return DAG.getNOT(DL, RHS.getOperand(0), VT);
26153       return RHS.getOperand(0);
26154     }
26155   }
26156
26157   return SDValue();
26158 }
26159
26160 static SDValue PerformINSERTPSCombine(SDNode *N, SelectionDAG &DAG,
26161                                       const X86Subtarget *Subtarget) {
26162   SDLoc dl(N);
26163   MVT VT = N->getOperand(1)->getSimpleValueType(0);
26164   assert((VT == MVT::v4f32 || VT == MVT::v4i32) &&
26165          "X86insertps is only defined for v4x32");
26166
26167   SDValue Ld = N->getOperand(1);
26168   if (MayFoldLoad(Ld)) {
26169     // Extract the countS bits from the immediate so we can get the proper
26170     // address when narrowing the vector load to a specific element.
26171     // When the second source op is a memory address, interps doesn't use
26172     // countS and just gets an f32 from that address.
26173     unsigned DestIndex =
26174         cast<ConstantSDNode>(N->getOperand(2))->getZExtValue() >> 6;
26175     Ld = NarrowVectorLoadToElement(cast<LoadSDNode>(Ld), DestIndex, DAG);
26176   } else
26177     return SDValue();
26178
26179   // Create this as a scalar to vector to match the instruction pattern.
26180   SDValue LoadScalarToVector = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Ld);
26181   // countS bits are ignored when loading from memory on insertps, which
26182   // means we don't need to explicitly set them to 0.
26183   return DAG.getNode(X86ISD::INSERTPS, dl, VT, N->getOperand(0),
26184                      LoadScalarToVector, N->getOperand(2));
26185 }
26186
26187 // Helper function of PerformSETCCCombine. It is to materialize "setb reg"
26188 // as "sbb reg,reg", since it can be extended without zext and produces
26189 // an all-ones bit which is more useful than 0/1 in some cases.
26190 static SDValue MaterializeSETB(SDLoc DL, SDValue EFLAGS, SelectionDAG &DAG,
26191                                MVT VT) {
26192   if (VT == MVT::i8)
26193     return DAG.getNode(ISD::AND, DL, VT,
26194                        DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
26195                                    DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS),
26196                        DAG.getConstant(1, VT));
26197   assert (VT == MVT::i1 && "Unexpected type for SECCC node");
26198   return DAG.getNode(ISD::TRUNCATE, DL, MVT::i1,
26199                      DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
26200                                  DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS));
26201 }
26202
26203 // Optimize  RES = X86ISD::SETCC CONDCODE, EFLAG_INPUT
26204 static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG &DAG,
26205                                    TargetLowering::DAGCombinerInfo &DCI,
26206                                    const X86Subtarget *Subtarget) {
26207   SDLoc DL(N);
26208   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(0));
26209   SDValue EFLAGS = N->getOperand(1);
26210
26211   if (CC == X86::COND_A) {
26212     // Try to convert COND_A into COND_B in an attempt to facilitate
26213     // materializing "setb reg".
26214     //
26215     // Do not flip "e > c", where "c" is a constant, because Cmp instruction
26216     // cannot take an immediate as its first operand.
26217     //
26218     if (EFLAGS.getOpcode() == X86ISD::SUB && EFLAGS.hasOneUse() &&
26219         EFLAGS.getValueType().isInteger() &&
26220         !isa<ConstantSDNode>(EFLAGS.getOperand(1))) {
26221       SDValue NewSub = DAG.getNode(X86ISD::SUB, SDLoc(EFLAGS),
26222                                    EFLAGS.getNode()->getVTList(),
26223                                    EFLAGS.getOperand(1), EFLAGS.getOperand(0));
26224       SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
26225       return MaterializeSETB(DL, NewEFLAGS, DAG, N->getSimpleValueType(0));
26226     }
26227   }
26228
26229   // Materialize "setb reg" as "sbb reg,reg", since it can be extended without
26230   // a zext and produces an all-ones bit which is more useful than 0/1 in some
26231   // cases.
26232   if (CC == X86::COND_B)
26233     return MaterializeSETB(DL, EFLAGS, DAG, N->getSimpleValueType(0));
26234
26235   SDValue Flags;
26236
26237   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
26238   if (Flags.getNode()) {
26239     SDValue Cond = DAG.getConstant(CC, MVT::i8);
26240     return DAG.getNode(X86ISD::SETCC, DL, N->getVTList(), Cond, Flags);
26241   }
26242
26243   return SDValue();
26244 }
26245
26246 // Optimize branch condition evaluation.
26247 //
26248 static SDValue PerformBrCondCombine(SDNode *N, SelectionDAG &DAG,
26249                                     TargetLowering::DAGCombinerInfo &DCI,
26250                                     const X86Subtarget *Subtarget) {
26251   SDLoc DL(N);
26252   SDValue Chain = N->getOperand(0);
26253   SDValue Dest = N->getOperand(1);
26254   SDValue EFLAGS = N->getOperand(3);
26255   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(2));
26256
26257   SDValue Flags;
26258
26259   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
26260   if (Flags.getNode()) {
26261     SDValue Cond = DAG.getConstant(CC, MVT::i8);
26262     return DAG.getNode(X86ISD::BRCOND, DL, N->getVTList(), Chain, Dest, Cond,
26263                        Flags);
26264   }
26265
26266   return SDValue();
26267 }
26268
26269 static SDValue performVectorCompareAndMaskUnaryOpCombine(SDNode *N,
26270                                                          SelectionDAG &DAG) {
26271   // Take advantage of vector comparisons producing 0 or -1 in each lane to
26272   // optimize away operation when it's from a constant.
26273   //
26274   // The general transformation is:
26275   //    UNARYOP(AND(VECTOR_CMP(x,y), constant)) -->
26276   //       AND(VECTOR_CMP(x,y), constant2)
26277   //    constant2 = UNARYOP(constant)
26278
26279   // Early exit if this isn't a vector operation, the operand of the
26280   // unary operation isn't a bitwise AND, or if the sizes of the operations
26281   // aren't the same.
26282   EVT VT = N->getValueType(0);
26283   if (!VT.isVector() || N->getOperand(0)->getOpcode() != ISD::AND ||
26284       N->getOperand(0)->getOperand(0)->getOpcode() != ISD::SETCC ||
26285       VT.getSizeInBits() != N->getOperand(0)->getValueType(0).getSizeInBits())
26286     return SDValue();
26287
26288   // Now check that the other operand of the AND is a constant. We could
26289   // make the transformation for non-constant splats as well, but it's unclear
26290   // that would be a benefit as it would not eliminate any operations, just
26291   // perform one more step in scalar code before moving to the vector unit.
26292   if (BuildVectorSDNode *BV =
26293           dyn_cast<BuildVectorSDNode>(N->getOperand(0)->getOperand(1))) {
26294     // Bail out if the vector isn't a constant.
26295     if (!BV->isConstant())
26296       return SDValue();
26297
26298     // Everything checks out. Build up the new and improved node.
26299     SDLoc DL(N);
26300     EVT IntVT = BV->getValueType(0);
26301     // Create a new constant of the appropriate type for the transformed
26302     // DAG.
26303     SDValue SourceConst = DAG.getNode(N->getOpcode(), DL, VT, SDValue(BV, 0));
26304     // The AND node needs bitcasts to/from an integer vector type around it.
26305     SDValue MaskConst = DAG.getNode(ISD::BITCAST, DL, IntVT, SourceConst);
26306     SDValue NewAnd = DAG.getNode(ISD::AND, DL, IntVT,
26307                                  N->getOperand(0)->getOperand(0), MaskConst);
26308     SDValue Res = DAG.getNode(ISD::BITCAST, DL, VT, NewAnd);
26309     return Res;
26310   }
26311
26312   return SDValue();
26313 }
26314
26315 static SDValue PerformSINT_TO_FPCombine(SDNode *N, SelectionDAG &DAG,
26316                                         const X86Subtarget *Subtarget) {
26317   // First try to optimize away the conversion entirely when it's
26318   // conditionally from a constant. Vectors only.
26319   SDValue Res = performVectorCompareAndMaskUnaryOpCombine(N, DAG);
26320   if (Res != SDValue())
26321     return Res;
26322
26323   // Now move on to more general possibilities.
26324   SDValue Op0 = N->getOperand(0);
26325   EVT InVT = Op0->getValueType(0);
26326
26327   // SINT_TO_FP(v4i8) -> SINT_TO_FP(SEXT(v4i8 to v4i32))
26328   if (InVT == MVT::v8i8 || InVT == MVT::v4i8) {
26329     SDLoc dl(N);
26330     MVT DstVT = InVT == MVT::v4i8 ? MVT::v4i32 : MVT::v8i32;
26331     SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
26332     return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
26333   }
26334
26335   // Transform (SINT_TO_FP (i64 ...)) into an x87 operation if we have
26336   // a 32-bit target where SSE doesn't support i64->FP operations.
26337   if (Op0.getOpcode() == ISD::LOAD) {
26338     LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
26339     EVT VT = Ld->getValueType(0);
26340     if (!Ld->isVolatile() && !N->getValueType(0).isVector() &&
26341         ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
26342         !Subtarget->is64Bit() && VT == MVT::i64) {
26343       SDValue FILDChain = Subtarget->getTargetLowering()->BuildFILD(
26344           SDValue(N, 0), Ld->getValueType(0), Ld->getChain(), Op0, DAG);
26345       DAG.ReplaceAllUsesOfValueWith(Op0.getValue(1), FILDChain.getValue(1));
26346       return FILDChain;
26347     }
26348   }
26349   return SDValue();
26350 }
26351
26352 // Optimize RES, EFLAGS = X86ISD::ADC LHS, RHS, EFLAGS
26353 static SDValue PerformADCCombine(SDNode *N, SelectionDAG &DAG,
26354                                  X86TargetLowering::DAGCombinerInfo &DCI) {
26355   // If the LHS and RHS of the ADC node are zero, then it can't overflow and
26356   // the result is either zero or one (depending on the input carry bit).
26357   // Strength reduce this down to a "set on carry" aka SETCC_CARRY&1.
26358   if (X86::isZeroNode(N->getOperand(0)) &&
26359       X86::isZeroNode(N->getOperand(1)) &&
26360       // We don't have a good way to replace an EFLAGS use, so only do this when
26361       // dead right now.
26362       SDValue(N, 1).use_empty()) {
26363     SDLoc DL(N);
26364     EVT VT = N->getValueType(0);
26365     SDValue CarryOut = DAG.getConstant(0, N->getValueType(1));
26366     SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
26367                                DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
26368                                            DAG.getConstant(X86::COND_B,MVT::i8),
26369                                            N->getOperand(2)),
26370                                DAG.getConstant(1, VT));
26371     return DCI.CombineTo(N, Res1, CarryOut);
26372   }
26373
26374   return SDValue();
26375 }
26376
26377 // fold (add Y, (sete  X, 0)) -> adc  0, Y
26378 //      (add Y, (setne X, 0)) -> sbb -1, Y
26379 //      (sub (sete  X, 0), Y) -> sbb  0, Y
26380 //      (sub (setne X, 0), Y) -> adc -1, Y
26381 static SDValue OptimizeConditionalInDecrement(SDNode *N, SelectionDAG &DAG) {
26382   SDLoc DL(N);
26383
26384   // Look through ZExts.
26385   SDValue Ext = N->getOperand(N->getOpcode() == ISD::SUB ? 1 : 0);
26386   if (Ext.getOpcode() != ISD::ZERO_EXTEND || !Ext.hasOneUse())
26387     return SDValue();
26388
26389   SDValue SetCC = Ext.getOperand(0);
26390   if (SetCC.getOpcode() != X86ISD::SETCC || !SetCC.hasOneUse())
26391     return SDValue();
26392
26393   X86::CondCode CC = (X86::CondCode)SetCC.getConstantOperandVal(0);
26394   if (CC != X86::COND_E && CC != X86::COND_NE)
26395     return SDValue();
26396
26397   SDValue Cmp = SetCC.getOperand(1);
26398   if (Cmp.getOpcode() != X86ISD::CMP || !Cmp.hasOneUse() ||
26399       !X86::isZeroNode(Cmp.getOperand(1)) ||
26400       !Cmp.getOperand(0).getValueType().isInteger())
26401     return SDValue();
26402
26403   SDValue CmpOp0 = Cmp.getOperand(0);
26404   SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
26405                                DAG.getConstant(1, CmpOp0.getValueType()));
26406
26407   SDValue OtherVal = N->getOperand(N->getOpcode() == ISD::SUB ? 0 : 1);
26408   if (CC == X86::COND_NE)
26409     return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
26410                        DL, OtherVal.getValueType(), OtherVal,
26411                        DAG.getConstant(-1ULL, OtherVal.getValueType()), NewCmp);
26412   return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
26413                      DL, OtherVal.getValueType(), OtherVal,
26414                      DAG.getConstant(0, OtherVal.getValueType()), NewCmp);
26415 }
26416
26417 /// PerformADDCombine - Do target-specific dag combines on integer adds.
26418 static SDValue PerformAddCombine(SDNode *N, SelectionDAG &DAG,
26419                                  const X86Subtarget *Subtarget) {
26420   EVT VT = N->getValueType(0);
26421   SDValue Op0 = N->getOperand(0);
26422   SDValue Op1 = N->getOperand(1);
26423
26424   // Try to synthesize horizontal adds from adds of shuffles.
26425   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
26426        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
26427       isHorizontalBinOp(Op0, Op1, true))
26428     return DAG.getNode(X86ISD::HADD, SDLoc(N), VT, Op0, Op1);
26429
26430   return OptimizeConditionalInDecrement(N, DAG);
26431 }
26432
26433 static SDValue PerformSubCombine(SDNode *N, SelectionDAG &DAG,
26434                                  const X86Subtarget *Subtarget) {
26435   SDValue Op0 = N->getOperand(0);
26436   SDValue Op1 = N->getOperand(1);
26437
26438   // X86 can't encode an immediate LHS of a sub. See if we can push the
26439   // negation into a preceding instruction.
26440   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op0)) {
26441     // If the RHS of the sub is a XOR with one use and a constant, invert the
26442     // immediate. Then add one to the LHS of the sub so we can turn
26443     // X-Y -> X+~Y+1, saving one register.
26444     if (Op1->hasOneUse() && Op1.getOpcode() == ISD::XOR &&
26445         isa<ConstantSDNode>(Op1.getOperand(1))) {
26446       APInt XorC = cast<ConstantSDNode>(Op1.getOperand(1))->getAPIntValue();
26447       EVT VT = Op0.getValueType();
26448       SDValue NewXor = DAG.getNode(ISD::XOR, SDLoc(Op1), VT,
26449                                    Op1.getOperand(0),
26450                                    DAG.getConstant(~XorC, VT));
26451       return DAG.getNode(ISD::ADD, SDLoc(N), VT, NewXor,
26452                          DAG.getConstant(C->getAPIntValue()+1, VT));
26453     }
26454   }
26455
26456   // Try to synthesize horizontal adds from adds of shuffles.
26457   EVT VT = N->getValueType(0);
26458   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
26459        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
26460       isHorizontalBinOp(Op0, Op1, true))
26461     return DAG.getNode(X86ISD::HSUB, SDLoc(N), VT, Op0, Op1);
26462
26463   return OptimizeConditionalInDecrement(N, DAG);
26464 }
26465
26466 /// performVZEXTCombine - Performs build vector combines
26467 static SDValue performVZEXTCombine(SDNode *N, SelectionDAG &DAG,
26468                                    TargetLowering::DAGCombinerInfo &DCI,
26469                                    const X86Subtarget *Subtarget) {
26470   SDLoc DL(N);
26471   MVT VT = N->getSimpleValueType(0);
26472   SDValue Op = N->getOperand(0);
26473   MVT OpVT = Op.getSimpleValueType();
26474   MVT OpEltVT = OpVT.getVectorElementType();
26475   unsigned InputBits = OpEltVT.getSizeInBits() * VT.getVectorNumElements();
26476
26477   // (vzext (bitcast (vzext (x)) -> (vzext x)
26478   SDValue V = Op;
26479   while (V.getOpcode() == ISD::BITCAST)
26480     V = V.getOperand(0);
26481
26482   if (V != Op && V.getOpcode() == X86ISD::VZEXT) {
26483     MVT InnerVT = V.getSimpleValueType();
26484     MVT InnerEltVT = InnerVT.getVectorElementType();
26485
26486     // If the element sizes match exactly, we can just do one larger vzext. This
26487     // is always an exact type match as vzext operates on integer types.
26488     if (OpEltVT == InnerEltVT) {
26489       assert(OpVT == InnerVT && "Types must match for vzext!");
26490       return DAG.getNode(X86ISD::VZEXT, DL, VT, V.getOperand(0));
26491     }
26492
26493     // The only other way we can combine them is if only a single element of the
26494     // inner vzext is used in the input to the outer vzext.
26495     if (InnerEltVT.getSizeInBits() < InputBits)
26496       return SDValue();
26497
26498     // In this case, the inner vzext is completely dead because we're going to
26499     // only look at bits inside of the low element. Just do the outer vzext on
26500     // a bitcast of the input to the inner.
26501     return DAG.getNode(X86ISD::VZEXT, DL, VT,
26502                        DAG.getNode(ISD::BITCAST, DL, OpVT, V));
26503   }
26504
26505   // Check if we can bypass extracting and re-inserting an element of an input
26506   // vector. Essentialy:
26507   // (bitcast (sclr2vec (ext_vec_elt x))) -> (bitcast x)
26508   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR &&
26509       V.getOperand(0).getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
26510       V.getOperand(0).getSimpleValueType().getSizeInBits() == InputBits) {
26511     SDValue ExtractedV = V.getOperand(0);
26512     SDValue OrigV = ExtractedV.getOperand(0);
26513     if (auto *ExtractIdx = dyn_cast<ConstantSDNode>(ExtractedV.getOperand(1)))
26514       if (ExtractIdx->getZExtValue() == 0) {
26515         MVT OrigVT = OrigV.getSimpleValueType();
26516         // Extract a subvector if necessary...
26517         if (OrigVT.getSizeInBits() > OpVT.getSizeInBits()) {
26518           int Ratio = OrigVT.getSizeInBits() / OpVT.getSizeInBits();
26519           OrigVT = MVT::getVectorVT(OrigVT.getVectorElementType(),
26520                                     OrigVT.getVectorNumElements() / Ratio);
26521           OrigV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigVT, OrigV,
26522                               DAG.getIntPtrConstant(0));
26523         }
26524         Op = DAG.getNode(ISD::BITCAST, DL, OpVT, OrigV);
26525         return DAG.getNode(X86ISD::VZEXT, DL, VT, Op);
26526       }
26527   }
26528
26529   return SDValue();
26530 }
26531
26532 SDValue X86TargetLowering::PerformDAGCombine(SDNode *N,
26533                                              DAGCombinerInfo &DCI) const {
26534   SelectionDAG &DAG = DCI.DAG;
26535   switch (N->getOpcode()) {
26536   default: break;
26537   case ISD::EXTRACT_VECTOR_ELT:
26538     return PerformEXTRACT_VECTOR_ELTCombine(N, DAG, DCI);
26539   case ISD::VSELECT:
26540   case ISD::SELECT:
26541   case X86ISD::SHRUNKBLEND:
26542     return PerformSELECTCombine(N, DAG, DCI, Subtarget);
26543   case ISD::BITCAST:        return PerformBITCASTCombine(N, DAG);
26544   case X86ISD::CMOV:        return PerformCMOVCombine(N, DAG, DCI, Subtarget);
26545   case ISD::ADD:            return PerformAddCombine(N, DAG, Subtarget);
26546   case ISD::SUB:            return PerformSubCombine(N, DAG, Subtarget);
26547   case X86ISD::ADC:         return PerformADCCombine(N, DAG, DCI);
26548   case ISD::MUL:            return PerformMulCombine(N, DAG, DCI);
26549   case ISD::SHL:
26550   case ISD::SRA:
26551   case ISD::SRL:            return PerformShiftCombine(N, DAG, DCI, Subtarget);
26552   case ISD::AND:            return PerformAndCombine(N, DAG, DCI, Subtarget);
26553   case ISD::OR:             return PerformOrCombine(N, DAG, DCI, Subtarget);
26554   case ISD::XOR:            return PerformXorCombine(N, DAG, DCI, Subtarget);
26555   case ISD::LOAD:           return PerformLOADCombine(N, DAG, DCI, Subtarget);
26556   case ISD::MLOAD:          return PerformMLOADCombine(N, DAG, DCI, Subtarget);
26557   case ISD::STORE:          return PerformSTORECombine(N, DAG, Subtarget);
26558   case ISD::MSTORE:         return PerformMSTORECombine(N, DAG, Subtarget);
26559   case ISD::SINT_TO_FP:     return PerformSINT_TO_FPCombine(N, DAG, Subtarget);
26560   case ISD::FADD:           return PerformFADDCombine(N, DAG, Subtarget);
26561   case ISD::FSUB:           return PerformFSUBCombine(N, DAG, Subtarget);
26562   case X86ISD::FXOR:
26563   case X86ISD::FOR:         return PerformFORCombine(N, DAG);
26564   case X86ISD::FMIN:
26565   case X86ISD::FMAX:        return PerformFMinFMaxCombine(N, DAG);
26566   case X86ISD::FAND:        return PerformFANDCombine(N, DAG);
26567   case X86ISD::FANDN:       return PerformFANDNCombine(N, DAG);
26568   case X86ISD::BT:          return PerformBTCombine(N, DAG, DCI);
26569   case X86ISD::VZEXT_MOVL:  return PerformVZEXT_MOVLCombine(N, DAG);
26570   case ISD::ANY_EXTEND:
26571   case ISD::ZERO_EXTEND:    return PerformZExtCombine(N, DAG, DCI, Subtarget);
26572   case ISD::SIGN_EXTEND:    return PerformSExtCombine(N, DAG, DCI, Subtarget);
26573   case ISD::SIGN_EXTEND_INREG:
26574     return PerformSIGN_EXTEND_INREGCombine(N, DAG, Subtarget);
26575   case ISD::TRUNCATE:       return PerformTruncateCombine(N, DAG,DCI,Subtarget);
26576   case ISD::SETCC:          return PerformISDSETCCCombine(N, DAG, Subtarget);
26577   case X86ISD::SETCC:       return PerformSETCCCombine(N, DAG, DCI, Subtarget);
26578   case X86ISD::BRCOND:      return PerformBrCondCombine(N, DAG, DCI, Subtarget);
26579   case X86ISD::VZEXT:       return performVZEXTCombine(N, DAG, DCI, Subtarget);
26580   case X86ISD::SHUFP:       // Handle all target specific shuffles
26581   case X86ISD::PALIGNR:
26582   case X86ISD::UNPCKH:
26583   case X86ISD::UNPCKL:
26584   case X86ISD::MOVHLPS:
26585   case X86ISD::MOVLHPS:
26586   case X86ISD::PSHUFB:
26587   case X86ISD::PSHUFD:
26588   case X86ISD::PSHUFHW:
26589   case X86ISD::PSHUFLW:
26590   case X86ISD::MOVSS:
26591   case X86ISD::MOVSD:
26592   case X86ISD::VPERMILPI:
26593   case X86ISD::VPERM2X128:
26594   case ISD::VECTOR_SHUFFLE: return PerformShuffleCombine(N, DAG, DCI,Subtarget);
26595   case ISD::FMA:            return PerformFMACombine(N, DAG, Subtarget);
26596   case ISD::INTRINSIC_WO_CHAIN:
26597     return PerformINTRINSIC_WO_CHAINCombine(N, DAG, Subtarget);
26598   case X86ISD::INSERTPS: {
26599     if (getTargetMachine().getOptLevel() > CodeGenOpt::None)
26600       return PerformINSERTPSCombine(N, DAG, Subtarget);
26601     break;
26602   }
26603   case ISD::BUILD_VECTOR: return PerformBUILD_VECTORCombine(N, DAG, Subtarget);
26604   }
26605
26606   return SDValue();
26607 }
26608
26609 /// isTypeDesirableForOp - Return true if the target has native support for
26610 /// the specified value type and it is 'desirable' to use the type for the
26611 /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
26612 /// instruction encodings are longer and some i16 instructions are slow.
26613 bool X86TargetLowering::isTypeDesirableForOp(unsigned Opc, EVT VT) const {
26614   if (!isTypeLegal(VT))
26615     return false;
26616   if (VT != MVT::i16)
26617     return true;
26618
26619   switch (Opc) {
26620   default:
26621     return true;
26622   case ISD::LOAD:
26623   case ISD::SIGN_EXTEND:
26624   case ISD::ZERO_EXTEND:
26625   case ISD::ANY_EXTEND:
26626   case ISD::SHL:
26627   case ISD::SRL:
26628   case ISD::SUB:
26629   case ISD::ADD:
26630   case ISD::MUL:
26631   case ISD::AND:
26632   case ISD::OR:
26633   case ISD::XOR:
26634     return false;
26635   }
26636 }
26637
26638 /// IsDesirableToPromoteOp - This method query the target whether it is
26639 /// beneficial for dag combiner to promote the specified node. If true, it
26640 /// should return the desired promotion type by reference.
26641 bool X86TargetLowering::IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
26642   EVT VT = Op.getValueType();
26643   if (VT != MVT::i16)
26644     return false;
26645
26646   bool Promote = false;
26647   bool Commute = false;
26648   switch (Op.getOpcode()) {
26649   default: break;
26650   case ISD::LOAD: {
26651     LoadSDNode *LD = cast<LoadSDNode>(Op);
26652     // If the non-extending load has a single use and it's not live out, then it
26653     // might be folded.
26654     if (LD->getExtensionType() == ISD::NON_EXTLOAD /*&&
26655                                                      Op.hasOneUse()*/) {
26656       for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
26657              UE = Op.getNode()->use_end(); UI != UE; ++UI) {
26658         // The only case where we'd want to promote LOAD (rather then it being
26659         // promoted as an operand is when it's only use is liveout.
26660         if (UI->getOpcode() != ISD::CopyToReg)
26661           return false;
26662       }
26663     }
26664     Promote = true;
26665     break;
26666   }
26667   case ISD::SIGN_EXTEND:
26668   case ISD::ZERO_EXTEND:
26669   case ISD::ANY_EXTEND:
26670     Promote = true;
26671     break;
26672   case ISD::SHL:
26673   case ISD::SRL: {
26674     SDValue N0 = Op.getOperand(0);
26675     // Look out for (store (shl (load), x)).
26676     if (MayFoldLoad(N0) && MayFoldIntoStore(Op))
26677       return false;
26678     Promote = true;
26679     break;
26680   }
26681   case ISD::ADD:
26682   case ISD::MUL:
26683   case ISD::AND:
26684   case ISD::OR:
26685   case ISD::XOR:
26686     Commute = true;
26687     // fallthrough
26688   case ISD::SUB: {
26689     SDValue N0 = Op.getOperand(0);
26690     SDValue N1 = Op.getOperand(1);
26691     if (!Commute && MayFoldLoad(N1))
26692       return false;
26693     // Avoid disabling potential load folding opportunities.
26694     if (MayFoldLoad(N0) && (!isa<ConstantSDNode>(N1) || MayFoldIntoStore(Op)))
26695       return false;
26696     if (MayFoldLoad(N1) && (!isa<ConstantSDNode>(N0) || MayFoldIntoStore(Op)))
26697       return false;
26698     Promote = true;
26699   }
26700   }
26701
26702   PVT = MVT::i32;
26703   return Promote;
26704 }
26705
26706 //===----------------------------------------------------------------------===//
26707 //                           X86 Inline Assembly Support
26708 //===----------------------------------------------------------------------===//
26709
26710 namespace {
26711   // Helper to match a string separated by whitespace.
26712   bool matchAsmImpl(StringRef s, ArrayRef<const StringRef *> args) {
26713     s = s.substr(s.find_first_not_of(" \t")); // Skip leading whitespace.
26714
26715     for (unsigned i = 0, e = args.size(); i != e; ++i) {
26716       StringRef piece(*args[i]);
26717       if (!s.startswith(piece)) // Check if the piece matches.
26718         return false;
26719
26720       s = s.substr(piece.size());
26721       StringRef::size_type pos = s.find_first_not_of(" \t");
26722       if (pos == 0) // We matched a prefix.
26723         return false;
26724
26725       s = s.substr(pos);
26726     }
26727
26728     return s.empty();
26729   }
26730   const VariadicFunction1<bool, StringRef, StringRef, matchAsmImpl> matchAsm={};
26731 }
26732
26733 static bool clobbersFlagRegisters(const SmallVector<StringRef, 4> &AsmPieces) {
26734
26735   if (AsmPieces.size() == 3 || AsmPieces.size() == 4) {
26736     if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{cc}") &&
26737         std::count(AsmPieces.begin(), AsmPieces.end(), "~{flags}") &&
26738         std::count(AsmPieces.begin(), AsmPieces.end(), "~{fpsr}")) {
26739
26740       if (AsmPieces.size() == 3)
26741         return true;
26742       else if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{dirflag}"))
26743         return true;
26744     }
26745   }
26746   return false;
26747 }
26748
26749 bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const {
26750   InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
26751
26752   std::string AsmStr = IA->getAsmString();
26753
26754   IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
26755   if (!Ty || Ty->getBitWidth() % 16 != 0)
26756     return false;
26757
26758   // TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
26759   SmallVector<StringRef, 4> AsmPieces;
26760   SplitString(AsmStr, AsmPieces, ";\n");
26761
26762   switch (AsmPieces.size()) {
26763   default: return false;
26764   case 1:
26765     // FIXME: this should verify that we are targeting a 486 or better.  If not,
26766     // we will turn this bswap into something that will be lowered to logical
26767     // ops instead of emitting the bswap asm.  For now, we don't support 486 or
26768     // lower so don't worry about this.
26769     // bswap $0
26770     if (matchAsm(AsmPieces[0], "bswap", "$0") ||
26771         matchAsm(AsmPieces[0], "bswapl", "$0") ||
26772         matchAsm(AsmPieces[0], "bswapq", "$0") ||
26773         matchAsm(AsmPieces[0], "bswap", "${0:q}") ||
26774         matchAsm(AsmPieces[0], "bswapl", "${0:q}") ||
26775         matchAsm(AsmPieces[0], "bswapq", "${0:q}")) {
26776       // No need to check constraints, nothing other than the equivalent of
26777       // "=r,0" would be valid here.
26778       return IntrinsicLowering::LowerToByteSwap(CI);
26779     }
26780
26781     // rorw $$8, ${0:w}  -->  llvm.bswap.i16
26782     if (CI->getType()->isIntegerTy(16) &&
26783         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
26784         (matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") ||
26785          matchAsm(AsmPieces[0], "rolw", "$$8,", "${0:w}"))) {
26786       AsmPieces.clear();
26787       const std::string &ConstraintsStr = IA->getConstraintString();
26788       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
26789       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
26790       if (clobbersFlagRegisters(AsmPieces))
26791         return IntrinsicLowering::LowerToByteSwap(CI);
26792     }
26793     break;
26794   case 3:
26795     if (CI->getType()->isIntegerTy(32) &&
26796         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
26797         matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") &&
26798         matchAsm(AsmPieces[1], "rorl", "$$16,", "$0") &&
26799         matchAsm(AsmPieces[2], "rorw", "$$8,", "${0:w}")) {
26800       AsmPieces.clear();
26801       const std::string &ConstraintsStr = IA->getConstraintString();
26802       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
26803       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
26804       if (clobbersFlagRegisters(AsmPieces))
26805         return IntrinsicLowering::LowerToByteSwap(CI);
26806     }
26807
26808     if (CI->getType()->isIntegerTy(64)) {
26809       InlineAsm::ConstraintInfoVector Constraints = IA->ParseConstraints();
26810       if (Constraints.size() >= 2 &&
26811           Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
26812           Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {
26813         // bswap %eax / bswap %edx / xchgl %eax, %edx  -> llvm.bswap.i64
26814         if (matchAsm(AsmPieces[0], "bswap", "%eax") &&
26815             matchAsm(AsmPieces[1], "bswap", "%edx") &&
26816             matchAsm(AsmPieces[2], "xchgl", "%eax,", "%edx"))
26817           return IntrinsicLowering::LowerToByteSwap(CI);
26818       }
26819     }
26820     break;
26821   }
26822   return false;
26823 }
26824
26825 /// getConstraintType - Given a constraint letter, return the type of
26826 /// constraint it is for this target.
26827 X86TargetLowering::ConstraintType
26828 X86TargetLowering::getConstraintType(const std::string &Constraint) const {
26829   if (Constraint.size() == 1) {
26830     switch (Constraint[0]) {
26831     case 'R':
26832     case 'q':
26833     case 'Q':
26834     case 'f':
26835     case 't':
26836     case 'u':
26837     case 'y':
26838     case 'x':
26839     case 'Y':
26840     case 'l':
26841       return C_RegisterClass;
26842     case 'a':
26843     case 'b':
26844     case 'c':
26845     case 'd':
26846     case 'S':
26847     case 'D':
26848     case 'A':
26849       return C_Register;
26850     case 'I':
26851     case 'J':
26852     case 'K':
26853     case 'L':
26854     case 'M':
26855     case 'N':
26856     case 'G':
26857     case 'C':
26858     case 'e':
26859     case 'Z':
26860       return C_Other;
26861     default:
26862       break;
26863     }
26864   }
26865   return TargetLowering::getConstraintType(Constraint);
26866 }
26867
26868 /// Examine constraint type and operand type and determine a weight value.
26869 /// This object must already have been set up with the operand type
26870 /// and the current alternative constraint selected.
26871 TargetLowering::ConstraintWeight
26872   X86TargetLowering::getSingleConstraintMatchWeight(
26873     AsmOperandInfo &info, const char *constraint) const {
26874   ConstraintWeight weight = CW_Invalid;
26875   Value *CallOperandVal = info.CallOperandVal;
26876     // If we don't have a value, we can't do a match,
26877     // but allow it at the lowest weight.
26878   if (!CallOperandVal)
26879     return CW_Default;
26880   Type *type = CallOperandVal->getType();
26881   // Look at the constraint type.
26882   switch (*constraint) {
26883   default:
26884     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
26885   case 'R':
26886   case 'q':
26887   case 'Q':
26888   case 'a':
26889   case 'b':
26890   case 'c':
26891   case 'd':
26892   case 'S':
26893   case 'D':
26894   case 'A':
26895     if (CallOperandVal->getType()->isIntegerTy())
26896       weight = CW_SpecificReg;
26897     break;
26898   case 'f':
26899   case 't':
26900   case 'u':
26901     if (type->isFloatingPointTy())
26902       weight = CW_SpecificReg;
26903     break;
26904   case 'y':
26905     if (type->isX86_MMXTy() && Subtarget->hasMMX())
26906       weight = CW_SpecificReg;
26907     break;
26908   case 'x':
26909   case 'Y':
26910     if (((type->getPrimitiveSizeInBits() == 128) && Subtarget->hasSSE1()) ||
26911         ((type->getPrimitiveSizeInBits() == 256) && Subtarget->hasFp256()))
26912       weight = CW_Register;
26913     break;
26914   case 'I':
26915     if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
26916       if (C->getZExtValue() <= 31)
26917         weight = CW_Constant;
26918     }
26919     break;
26920   case 'J':
26921     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26922       if (C->getZExtValue() <= 63)
26923         weight = CW_Constant;
26924     }
26925     break;
26926   case 'K':
26927     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26928       if ((C->getSExtValue() >= -0x80) && (C->getSExtValue() <= 0x7f))
26929         weight = CW_Constant;
26930     }
26931     break;
26932   case 'L':
26933     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26934       if ((C->getZExtValue() == 0xff) || (C->getZExtValue() == 0xffff))
26935         weight = CW_Constant;
26936     }
26937     break;
26938   case 'M':
26939     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26940       if (C->getZExtValue() <= 3)
26941         weight = CW_Constant;
26942     }
26943     break;
26944   case 'N':
26945     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26946       if (C->getZExtValue() <= 0xff)
26947         weight = CW_Constant;
26948     }
26949     break;
26950   case 'G':
26951   case 'C':
26952     if (dyn_cast<ConstantFP>(CallOperandVal)) {
26953       weight = CW_Constant;
26954     }
26955     break;
26956   case 'e':
26957     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26958       if ((C->getSExtValue() >= -0x80000000LL) &&
26959           (C->getSExtValue() <= 0x7fffffffLL))
26960         weight = CW_Constant;
26961     }
26962     break;
26963   case 'Z':
26964     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26965       if (C->getZExtValue() <= 0xffffffff)
26966         weight = CW_Constant;
26967     }
26968     break;
26969   }
26970   return weight;
26971 }
26972
26973 /// LowerXConstraint - try to replace an X constraint, which matches anything,
26974 /// with another that has more specific requirements based on the type of the
26975 /// corresponding operand.
26976 const char *X86TargetLowering::
26977 LowerXConstraint(EVT ConstraintVT) const {
26978   // FP X constraints get lowered to SSE1/2 registers if available, otherwise
26979   // 'f' like normal targets.
26980   if (ConstraintVT.isFloatingPoint()) {
26981     if (Subtarget->hasSSE2())
26982       return "Y";
26983     if (Subtarget->hasSSE1())
26984       return "x";
26985   }
26986
26987   return TargetLowering::LowerXConstraint(ConstraintVT);
26988 }
26989
26990 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
26991 /// vector.  If it is invalid, don't add anything to Ops.
26992 void X86TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
26993                                                      std::string &Constraint,
26994                                                      std::vector<SDValue>&Ops,
26995                                                      SelectionDAG &DAG) const {
26996   SDValue Result;
26997
26998   // Only support length 1 constraints for now.
26999   if (Constraint.length() > 1) return;
27000
27001   char ConstraintLetter = Constraint[0];
27002   switch (ConstraintLetter) {
27003   default: break;
27004   case 'I':
27005     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27006       if (C->getZExtValue() <= 31) {
27007         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27008         break;
27009       }
27010     }
27011     return;
27012   case 'J':
27013     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27014       if (C->getZExtValue() <= 63) {
27015         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27016         break;
27017       }
27018     }
27019     return;
27020   case 'K':
27021     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27022       if (isInt<8>(C->getSExtValue())) {
27023         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27024         break;
27025       }
27026     }
27027     return;
27028   case 'L':
27029     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27030       if (C->getZExtValue() == 0xff || C->getZExtValue() == 0xffff ||
27031           (Subtarget->is64Bit() && C->getZExtValue() == 0xffffffff)) {
27032         Result = DAG.getTargetConstant(C->getSExtValue(), Op.getValueType());
27033         break;
27034       }
27035     }
27036     return;
27037   case 'M':
27038     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27039       if (C->getZExtValue() <= 3) {
27040         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27041         break;
27042       }
27043     }
27044     return;
27045   case 'N':
27046     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27047       if (C->getZExtValue() <= 255) {
27048         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27049         break;
27050       }
27051     }
27052     return;
27053   case 'O':
27054     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27055       if (C->getZExtValue() <= 127) {
27056         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27057         break;
27058       }
27059     }
27060     return;
27061   case 'e': {
27062     // 32-bit signed value
27063     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27064       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
27065                                            C->getSExtValue())) {
27066         // Widen to 64 bits here to get it sign extended.
27067         Result = DAG.getTargetConstant(C->getSExtValue(), MVT::i64);
27068         break;
27069       }
27070     // FIXME gcc accepts some relocatable values here too, but only in certain
27071     // memory models; it's complicated.
27072     }
27073     return;
27074   }
27075   case 'Z': {
27076     // 32-bit unsigned value
27077     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27078       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
27079                                            C->getZExtValue())) {
27080         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27081         break;
27082       }
27083     }
27084     // FIXME gcc accepts some relocatable values here too, but only in certain
27085     // memory models; it's complicated.
27086     return;
27087   }
27088   case 'i': {
27089     // Literal immediates are always ok.
27090     if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op)) {
27091       // Widen to 64 bits here to get it sign extended.
27092       Result = DAG.getTargetConstant(CST->getSExtValue(), MVT::i64);
27093       break;
27094     }
27095
27096     // In any sort of PIC mode addresses need to be computed at runtime by
27097     // adding in a register or some sort of table lookup.  These can't
27098     // be used as immediates.
27099     if (Subtarget->isPICStyleGOT() || Subtarget->isPICStyleStubPIC())
27100       return;
27101
27102     // If we are in non-pic codegen mode, we allow the address of a global (with
27103     // an optional displacement) to be used with 'i'.
27104     GlobalAddressSDNode *GA = nullptr;
27105     int64_t Offset = 0;
27106
27107     // Match either (GA), (GA+C), (GA+C1+C2), etc.
27108     while (1) {
27109       if ((GA = dyn_cast<GlobalAddressSDNode>(Op))) {
27110         Offset += GA->getOffset();
27111         break;
27112       } else if (Op.getOpcode() == ISD::ADD) {
27113         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
27114           Offset += C->getZExtValue();
27115           Op = Op.getOperand(0);
27116           continue;
27117         }
27118       } else if (Op.getOpcode() == ISD::SUB) {
27119         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
27120           Offset += -C->getZExtValue();
27121           Op = Op.getOperand(0);
27122           continue;
27123         }
27124       }
27125
27126       // Otherwise, this isn't something we can handle, reject it.
27127       return;
27128     }
27129
27130     const GlobalValue *GV = GA->getGlobal();
27131     // If we require an extra load to get this address, as in PIC mode, we
27132     // can't accept it.
27133     if (isGlobalStubReference(
27134             Subtarget->ClassifyGlobalReference(GV, DAG.getTarget())))
27135       return;
27136
27137     Result = DAG.getTargetGlobalAddress(GV, SDLoc(Op),
27138                                         GA->getValueType(0), Offset);
27139     break;
27140   }
27141   }
27142
27143   if (Result.getNode()) {
27144     Ops.push_back(Result);
27145     return;
27146   }
27147   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
27148 }
27149
27150 std::pair<unsigned, const TargetRegisterClass*>
27151 X86TargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
27152                                                 MVT VT) const {
27153   // First, see if this is a constraint that directly corresponds to an LLVM
27154   // register class.
27155   if (Constraint.size() == 1) {
27156     // GCC Constraint Letters
27157     switch (Constraint[0]) {
27158     default: break;
27159       // TODO: Slight differences here in allocation order and leaving
27160       // RIP in the class. Do they matter any more here than they do
27161       // in the normal allocation?
27162     case 'q':   // GENERAL_REGS in 64-bit mode, Q_REGS in 32-bit mode.
27163       if (Subtarget->is64Bit()) {
27164         if (VT == MVT::i32 || VT == MVT::f32)
27165           return std::make_pair(0U, &X86::GR32RegClass);
27166         if (VT == MVT::i16)
27167           return std::make_pair(0U, &X86::GR16RegClass);
27168         if (VT == MVT::i8 || VT == MVT::i1)
27169           return std::make_pair(0U, &X86::GR8RegClass);
27170         if (VT == MVT::i64 || VT == MVT::f64)
27171           return std::make_pair(0U, &X86::GR64RegClass);
27172         break;
27173       }
27174       // 32-bit fallthrough
27175     case 'Q':   // Q_REGS
27176       if (VT == MVT::i32 || VT == MVT::f32)
27177         return std::make_pair(0U, &X86::GR32_ABCDRegClass);
27178       if (VT == MVT::i16)
27179         return std::make_pair(0U, &X86::GR16_ABCDRegClass);
27180       if (VT == MVT::i8 || VT == MVT::i1)
27181         return std::make_pair(0U, &X86::GR8_ABCD_LRegClass);
27182       if (VT == MVT::i64)
27183         return std::make_pair(0U, &X86::GR64_ABCDRegClass);
27184       break;
27185     case 'r':   // GENERAL_REGS
27186     case 'l':   // INDEX_REGS
27187       if (VT == MVT::i8 || VT == MVT::i1)
27188         return std::make_pair(0U, &X86::GR8RegClass);
27189       if (VT == MVT::i16)
27190         return std::make_pair(0U, &X86::GR16RegClass);
27191       if (VT == MVT::i32 || VT == MVT::f32 || !Subtarget->is64Bit())
27192         return std::make_pair(0U, &X86::GR32RegClass);
27193       return std::make_pair(0U, &X86::GR64RegClass);
27194     case 'R':   // LEGACY_REGS
27195       if (VT == MVT::i8 || VT == MVT::i1)
27196         return std::make_pair(0U, &X86::GR8_NOREXRegClass);
27197       if (VT == MVT::i16)
27198         return std::make_pair(0U, &X86::GR16_NOREXRegClass);
27199       if (VT == MVT::i32 || !Subtarget->is64Bit())
27200         return std::make_pair(0U, &X86::GR32_NOREXRegClass);
27201       return std::make_pair(0U, &X86::GR64_NOREXRegClass);
27202     case 'f':  // FP Stack registers.
27203       // If SSE is enabled for this VT, use f80 to ensure the isel moves the
27204       // value to the correct fpstack register class.
27205       if (VT == MVT::f32 && !isScalarFPTypeInSSEReg(VT))
27206         return std::make_pair(0U, &X86::RFP32RegClass);
27207       if (VT == MVT::f64 && !isScalarFPTypeInSSEReg(VT))
27208         return std::make_pair(0U, &X86::RFP64RegClass);
27209       return std::make_pair(0U, &X86::RFP80RegClass);
27210     case 'y':   // MMX_REGS if MMX allowed.
27211       if (!Subtarget->hasMMX()) break;
27212       return std::make_pair(0U, &X86::VR64RegClass);
27213     case 'Y':   // SSE_REGS if SSE2 allowed
27214       if (!Subtarget->hasSSE2()) break;
27215       // FALL THROUGH.
27216     case 'x':   // SSE_REGS if SSE1 allowed or AVX_REGS if AVX allowed
27217       if (!Subtarget->hasSSE1()) break;
27218
27219       switch (VT.SimpleTy) {
27220       default: break;
27221       // Scalar SSE types.
27222       case MVT::f32:
27223       case MVT::i32:
27224         return std::make_pair(0U, &X86::FR32RegClass);
27225       case MVT::f64:
27226       case MVT::i64:
27227         return std::make_pair(0U, &X86::FR64RegClass);
27228       // Vector types.
27229       case MVT::v16i8:
27230       case MVT::v8i16:
27231       case MVT::v4i32:
27232       case MVT::v2i64:
27233       case MVT::v4f32:
27234       case MVT::v2f64:
27235         return std::make_pair(0U, &X86::VR128RegClass);
27236       // AVX types.
27237       case MVT::v32i8:
27238       case MVT::v16i16:
27239       case MVT::v8i32:
27240       case MVT::v4i64:
27241       case MVT::v8f32:
27242       case MVT::v4f64:
27243         return std::make_pair(0U, &X86::VR256RegClass);
27244       case MVT::v8f64:
27245       case MVT::v16f32:
27246       case MVT::v16i32:
27247       case MVT::v8i64:
27248         return std::make_pair(0U, &X86::VR512RegClass);
27249       }
27250       break;
27251     }
27252   }
27253
27254   // Use the default implementation in TargetLowering to convert the register
27255   // constraint into a member of a register class.
27256   std::pair<unsigned, const TargetRegisterClass*> Res;
27257   Res = TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
27258
27259   // Not found as a standard register?
27260   if (!Res.second) {
27261     // Map st(0) -> st(7) -> ST0
27262     if (Constraint.size() == 7 && Constraint[0] == '{' &&
27263         tolower(Constraint[1]) == 's' &&
27264         tolower(Constraint[2]) == 't' &&
27265         Constraint[3] == '(' &&
27266         (Constraint[4] >= '0' && Constraint[4] <= '7') &&
27267         Constraint[5] == ')' &&
27268         Constraint[6] == '}') {
27269
27270       Res.first = X86::FP0+Constraint[4]-'0';
27271       Res.second = &X86::RFP80RegClass;
27272       return Res;
27273     }
27274
27275     // GCC allows "st(0)" to be called just plain "st".
27276     if (StringRef("{st}").equals_lower(Constraint)) {
27277       Res.first = X86::FP0;
27278       Res.second = &X86::RFP80RegClass;
27279       return Res;
27280     }
27281
27282     // flags -> EFLAGS
27283     if (StringRef("{flags}").equals_lower(Constraint)) {
27284       Res.first = X86::EFLAGS;
27285       Res.second = &X86::CCRRegClass;
27286       return Res;
27287     }
27288
27289     // 'A' means EAX + EDX.
27290     if (Constraint == "A") {
27291       Res.first = X86::EAX;
27292       Res.second = &X86::GR32_ADRegClass;
27293       return Res;
27294     }
27295     return Res;
27296   }
27297
27298   // Otherwise, check to see if this is a register class of the wrong value
27299   // type.  For example, we want to map "{ax},i32" -> {eax}, we don't want it to
27300   // turn into {ax},{dx}.
27301   if (Res.second->hasType(VT))
27302     return Res;   // Correct type already, nothing to do.
27303
27304   // All of the single-register GCC register classes map their values onto
27305   // 16-bit register pieces "ax","dx","cx","bx","si","di","bp","sp".  If we
27306   // really want an 8-bit or 32-bit register, map to the appropriate register
27307   // class and return the appropriate register.
27308   if (Res.second == &X86::GR16RegClass) {
27309     if (VT == MVT::i8 || VT == MVT::i1) {
27310       unsigned DestReg = 0;
27311       switch (Res.first) {
27312       default: break;
27313       case X86::AX: DestReg = X86::AL; break;
27314       case X86::DX: DestReg = X86::DL; break;
27315       case X86::CX: DestReg = X86::CL; break;
27316       case X86::BX: DestReg = X86::BL; break;
27317       }
27318       if (DestReg) {
27319         Res.first = DestReg;
27320         Res.second = &X86::GR8RegClass;
27321       }
27322     } else if (VT == MVT::i32 || VT == MVT::f32) {
27323       unsigned DestReg = 0;
27324       switch (Res.first) {
27325       default: break;
27326       case X86::AX: DestReg = X86::EAX; break;
27327       case X86::DX: DestReg = X86::EDX; break;
27328       case X86::CX: DestReg = X86::ECX; break;
27329       case X86::BX: DestReg = X86::EBX; break;
27330       case X86::SI: DestReg = X86::ESI; break;
27331       case X86::DI: DestReg = X86::EDI; break;
27332       case X86::BP: DestReg = X86::EBP; break;
27333       case X86::SP: DestReg = X86::ESP; break;
27334       }
27335       if (DestReg) {
27336         Res.first = DestReg;
27337         Res.second = &X86::GR32RegClass;
27338       }
27339     } else if (VT == MVT::i64 || VT == MVT::f64) {
27340       unsigned DestReg = 0;
27341       switch (Res.first) {
27342       default: break;
27343       case X86::AX: DestReg = X86::RAX; break;
27344       case X86::DX: DestReg = X86::RDX; break;
27345       case X86::CX: DestReg = X86::RCX; break;
27346       case X86::BX: DestReg = X86::RBX; break;
27347       case X86::SI: DestReg = X86::RSI; break;
27348       case X86::DI: DestReg = X86::RDI; break;
27349       case X86::BP: DestReg = X86::RBP; break;
27350       case X86::SP: DestReg = X86::RSP; break;
27351       }
27352       if (DestReg) {
27353         Res.first = DestReg;
27354         Res.second = &X86::GR64RegClass;
27355       }
27356     }
27357   } else if (Res.second == &X86::FR32RegClass ||
27358              Res.second == &X86::FR64RegClass ||
27359              Res.second == &X86::VR128RegClass ||
27360              Res.second == &X86::VR256RegClass ||
27361              Res.second == &X86::FR32XRegClass ||
27362              Res.second == &X86::FR64XRegClass ||
27363              Res.second == &X86::VR128XRegClass ||
27364              Res.second == &X86::VR256XRegClass ||
27365              Res.second == &X86::VR512RegClass) {
27366     // Handle references to XMM physical registers that got mapped into the
27367     // wrong class.  This can happen with constraints like {xmm0} where the
27368     // target independent register mapper will just pick the first match it can
27369     // find, ignoring the required type.
27370
27371     if (VT == MVT::f32 || VT == MVT::i32)
27372       Res.second = &X86::FR32RegClass;
27373     else if (VT == MVT::f64 || VT == MVT::i64)
27374       Res.second = &X86::FR64RegClass;
27375     else if (X86::VR128RegClass.hasType(VT))
27376       Res.second = &X86::VR128RegClass;
27377     else if (X86::VR256RegClass.hasType(VT))
27378       Res.second = &X86::VR256RegClass;
27379     else if (X86::VR512RegClass.hasType(VT))
27380       Res.second = &X86::VR512RegClass;
27381   }
27382
27383   return Res;
27384 }
27385
27386 int X86TargetLowering::getScalingFactorCost(const AddrMode &AM,
27387                                             Type *Ty) const {
27388   // Scaling factors are not free at all.
27389   // An indexed folded instruction, i.e., inst (reg1, reg2, scale),
27390   // will take 2 allocations in the out of order engine instead of 1
27391   // for plain addressing mode, i.e. inst (reg1).
27392   // E.g.,
27393   // vaddps (%rsi,%drx), %ymm0, %ymm1
27394   // Requires two allocations (one for the load, one for the computation)
27395   // whereas:
27396   // vaddps (%rsi), %ymm0, %ymm1
27397   // Requires just 1 allocation, i.e., freeing allocations for other operations
27398   // and having less micro operations to execute.
27399   //
27400   // For some X86 architectures, this is even worse because for instance for
27401   // stores, the complex addressing mode forces the instruction to use the
27402   // "load" ports instead of the dedicated "store" port.
27403   // E.g., on Haswell:
27404   // vmovaps %ymm1, (%r8, %rdi) can use port 2 or 3.
27405   // vmovaps %ymm1, (%r8) can use port 2, 3, or 7.
27406   if (isLegalAddressingMode(AM, Ty))
27407     // Scale represents reg2 * scale, thus account for 1
27408     // as soon as we use a second register.
27409     return AM.Scale != 0;
27410   return -1;
27411 }
27412
27413 bool X86TargetLowering::isTargetFTOL() const {
27414   return Subtarget->isTargetKnownWindowsMSVC() && !Subtarget->is64Bit();
27415 }