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 Generic lowering of 8-lane i16 shuffles.
9641 ///
9642 /// This handles both single-input shuffles and combined shuffle/blends with
9643 /// two inputs. The single input shuffles are immediately delegated to
9644 /// a dedicated lowering routine.
9645 ///
9646 /// The blends are lowered in one of three fundamental ways. If there are few
9647 /// enough inputs, it delegates to a basic UNPCK-based strategy. If the shuffle
9648 /// of the input is significantly cheaper when lowered as an interleaving of
9649 /// the two inputs, try to interleave them. Otherwise, blend the low and high
9650 /// halves of the inputs separately (making them have relatively few inputs)
9651 /// and then concatenate them.
9652 static SDValue lowerV8I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9653                                        const X86Subtarget *Subtarget,
9654                                        SelectionDAG &DAG) {
9655   SDLoc DL(Op);
9656   assert(Op.getSimpleValueType() == MVT::v8i16 && "Bad shuffle type!");
9657   assert(V1.getSimpleValueType() == MVT::v8i16 && "Bad operand type!");
9658   assert(V2.getSimpleValueType() == MVT::v8i16 && "Bad operand type!");
9659   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9660   ArrayRef<int> OrigMask = SVOp->getMask();
9661   int MaskStorage[8] = {OrigMask[0], OrigMask[1], OrigMask[2], OrigMask[3],
9662                         OrigMask[4], OrigMask[5], OrigMask[6], OrigMask[7]};
9663   MutableArrayRef<int> Mask(MaskStorage);
9664
9665   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
9666
9667   // Whenever we can lower this as a zext, that instruction is strictly faster
9668   // than any alternative.
9669   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(
9670           DL, MVT::v8i16, V1, V2, OrigMask, Subtarget, DAG))
9671     return ZExt;
9672
9673   auto isV1 = [](int M) { return M >= 0 && M < 8; };
9674   auto isV2 = [](int M) { return M >= 8; };
9675
9676   int NumV1Inputs = std::count_if(Mask.begin(), Mask.end(), isV1);
9677   int NumV2Inputs = std::count_if(Mask.begin(), Mask.end(), isV2);
9678
9679   if (NumV2Inputs == 0)
9680     return lowerV8I16SingleInputVectorShuffle(DL, V1, Mask, Subtarget, DAG);
9681
9682   assert(NumV1Inputs > 0 && "All single-input shuffles should be canonicalized "
9683                             "to be V1-input shuffles.");
9684
9685   // Try to use shift instructions.
9686   if (SDValue Shift =
9687           lowerVectorShuffleAsShift(DL, MVT::v8i16, V1, V2, Mask, DAG))
9688     return Shift;
9689
9690   // There are special ways we can lower some single-element blends.
9691   if (NumV2Inputs == 1)
9692     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v8i16, DL, V1, V2,
9693                                                          Mask, Subtarget, DAG))
9694       return V;
9695
9696   // We have different paths for blend lowering, but they all must use the
9697   // *exact* same predicate.
9698   bool IsBlendSupported = Subtarget->hasSSE41();
9699   if (IsBlendSupported)
9700     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8i16, V1, V2, Mask,
9701                                                   Subtarget, DAG))
9702       return Blend;
9703
9704   if (SDValue Masked =
9705           lowerVectorShuffleAsBitMask(DL, MVT::v8i16, V1, V2, Mask, DAG))
9706     return Masked;
9707
9708   // Use dedicated unpack instructions for masks that match their pattern.
9709   if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 1, 9, 2, 10, 3, 11))
9710     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, V1, V2);
9711   if (isShuffleEquivalent(V1, V2, Mask, 4, 12, 5, 13, 6, 14, 7, 15))
9712     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i16, V1, V2);
9713
9714   // Try to use byte rotation instructions.
9715   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9716           DL, MVT::v8i16, V1, V2, Mask, Subtarget, DAG))
9717     return Rotate;
9718
9719   if (SDValue BitBlend =
9720           lowerVectorShuffleAsBitBlend(DL, MVT::v8i16, V1, V2, Mask, DAG))
9721     return BitBlend;
9722
9723   if (NumV1Inputs + NumV2Inputs <= 4)
9724     return lowerV8I16BasicBlendVectorShuffle(DL, V1, V2, Mask, Subtarget, DAG);
9725
9726   // Check whether an interleaving lowering is likely to be more efficient.
9727   // This isn't perfect but it is a strong heuristic that tends to work well on
9728   // the kinds of shuffles that show up in practice.
9729   //
9730   // FIXME: Handle 1x, 2x, and 4x interleaving.
9731   if (shouldLowerAsInterleaving(Mask)) {
9732     // FIXME: Figure out whether we should pack these into the low or high
9733     // halves.
9734
9735     int EMask[8], OMask[8];
9736     for (int i = 0; i < 4; ++i) {
9737       EMask[i] = Mask[2*i];
9738       OMask[i] = Mask[2*i + 1];
9739       EMask[i + 4] = -1;
9740       OMask[i + 4] = -1;
9741     }
9742
9743     SDValue Evens = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, EMask);
9744     SDValue Odds = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, OMask);
9745
9746     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, Evens, Odds);
9747   }
9748
9749   // If we have direct support for blends, we should lower by decomposing into
9750   // a permute.
9751   if (IsBlendSupported)
9752     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8i16, V1, V2,
9753                                                       Mask, DAG);
9754
9755   // Try to lower by permuting the inputs into an unpack instruction.
9756   if (SDValue Unpack =
9757           lowerVectorShuffleAsUnpack(MVT::v8i16, DL, V1, V2, Mask, DAG))
9758     return Unpack;
9759
9760   int LoBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9761   int HiBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9762
9763   for (int i = 0; i < 4; ++i) {
9764     LoBlendMask[i] = Mask[i];
9765     HiBlendMask[i] = Mask[i + 4];
9766   }
9767
9768   SDValue LoV = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, LoBlendMask);
9769   SDValue HiV = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, HiBlendMask);
9770   LoV = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, LoV);
9771   HiV = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, HiV);
9772
9773   return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
9774                      DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2i64, LoV, HiV));
9775 }
9776
9777 /// \brief Check whether a compaction lowering can be done by dropping even
9778 /// elements and compute how many times even elements must be dropped.
9779 ///
9780 /// This handles shuffles which take every Nth element where N is a power of
9781 /// two. Example shuffle masks:
9782 ///
9783 ///  N = 1:  0,  2,  4,  6,  8, 10, 12, 14,  0,  2,  4,  6,  8, 10, 12, 14
9784 ///  N = 1:  0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30
9785 ///  N = 2:  0,  4,  8, 12,  0,  4,  8, 12,  0,  4,  8, 12,  0,  4,  8, 12
9786 ///  N = 2:  0,  4,  8, 12, 16, 20, 24, 28,  0,  4,  8, 12, 16, 20, 24, 28
9787 ///  N = 3:  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8
9788 ///  N = 3:  0,  8, 16, 24,  0,  8, 16, 24,  0,  8, 16, 24,  0,  8, 16, 24
9789 ///
9790 /// Any of these lanes can of course be undef.
9791 ///
9792 /// This routine only supports N <= 3.
9793 /// FIXME: Evaluate whether either AVX or AVX-512 have any opportunities here
9794 /// for larger N.
9795 ///
9796 /// \returns N above, or the number of times even elements must be dropped if
9797 /// there is such a number. Otherwise returns zero.
9798 static int canLowerByDroppingEvenElements(ArrayRef<int> Mask) {
9799   // Figure out whether we're looping over two inputs or just one.
9800   bool IsSingleInput = isSingleInputShuffleMask(Mask);
9801
9802   // The modulus for the shuffle vector entries is based on whether this is
9803   // a single input or not.
9804   int ShuffleModulus = Mask.size() * (IsSingleInput ? 1 : 2);
9805   assert(isPowerOf2_32((uint32_t)ShuffleModulus) &&
9806          "We should only be called with masks with a power-of-2 size!");
9807
9808   uint64_t ModMask = (uint64_t)ShuffleModulus - 1;
9809
9810   // We track whether the input is viable for all power-of-2 strides 2^1, 2^2,
9811   // and 2^3 simultaneously. This is because we may have ambiguity with
9812   // partially undef inputs.
9813   bool ViableForN[3] = {true, true, true};
9814
9815   for (int i = 0, e = Mask.size(); i < e; ++i) {
9816     // Ignore undef lanes, we'll optimistically collapse them to the pattern we
9817     // want.
9818     if (Mask[i] == -1)
9819       continue;
9820
9821     bool IsAnyViable = false;
9822     for (unsigned j = 0; j != array_lengthof(ViableForN); ++j)
9823       if (ViableForN[j]) {
9824         uint64_t N = j + 1;
9825
9826         // The shuffle mask must be equal to (i * 2^N) % M.
9827         if ((uint64_t)Mask[i] == (((uint64_t)i << N) & ModMask))
9828           IsAnyViable = true;
9829         else
9830           ViableForN[j] = false;
9831       }
9832     // Early exit if we exhaust the possible powers of two.
9833     if (!IsAnyViable)
9834       break;
9835   }
9836
9837   for (unsigned j = 0; j != array_lengthof(ViableForN); ++j)
9838     if (ViableForN[j])
9839       return j + 1;
9840
9841   // Return 0 as there is no viable power of two.
9842   return 0;
9843 }
9844
9845 /// \brief Generic lowering of v16i8 shuffles.
9846 ///
9847 /// This is a hybrid strategy to lower v16i8 vectors. It first attempts to
9848 /// detect any complexity reducing interleaving. If that doesn't help, it uses
9849 /// UNPCK to spread the i8 elements across two i16-element vectors, and uses
9850 /// the existing lowering for v8i16 blends on each half, finally PACK-ing them
9851 /// back together.
9852 static SDValue lowerV16I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9853                                        const X86Subtarget *Subtarget,
9854                                        SelectionDAG &DAG) {
9855   SDLoc DL(Op);
9856   assert(Op.getSimpleValueType() == MVT::v16i8 && "Bad shuffle type!");
9857   assert(V1.getSimpleValueType() == MVT::v16i8 && "Bad operand type!");
9858   assert(V2.getSimpleValueType() == MVT::v16i8 && "Bad operand type!");
9859   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9860   ArrayRef<int> Mask = SVOp->getMask();
9861   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
9862
9863   // Try to use shift instructions.
9864   if (SDValue Shift =
9865           lowerVectorShuffleAsShift(DL, MVT::v16i8, V1, V2, Mask, DAG))
9866     return Shift;
9867
9868   // Try to use byte rotation instructions.
9869   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9870           DL, MVT::v16i8, V1, V2, Mask, Subtarget, DAG))
9871     return Rotate;
9872
9873   // Try to use a zext lowering.
9874   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(
9875           DL, MVT::v16i8, V1, V2, Mask, Subtarget, DAG))
9876     return ZExt;
9877
9878   int NumV2Elements =
9879       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 16; });
9880
9881   // For single-input shuffles, there are some nicer lowering tricks we can use.
9882   if (NumV2Elements == 0) {
9883     // Check for being able to broadcast a single element.
9884     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v16i8, DL, V1,
9885                                                           Mask, Subtarget, DAG))
9886       return Broadcast;
9887
9888     // Check whether we can widen this to an i16 shuffle by duplicating bytes.
9889     // Notably, this handles splat and partial-splat shuffles more efficiently.
9890     // However, it only makes sense if the pre-duplication shuffle simplifies
9891     // things significantly. Currently, this means we need to be able to
9892     // express the pre-duplication shuffle as an i16 shuffle.
9893     //
9894     // FIXME: We should check for other patterns which can be widened into an
9895     // i16 shuffle as well.
9896     auto canWidenViaDuplication = [](ArrayRef<int> Mask) {
9897       for (int i = 0; i < 16; i += 2)
9898         if (Mask[i] != -1 && Mask[i + 1] != -1 && Mask[i] != Mask[i + 1])
9899           return false;
9900
9901       return true;
9902     };
9903     auto tryToWidenViaDuplication = [&]() -> SDValue {
9904       if (!canWidenViaDuplication(Mask))
9905         return SDValue();
9906       SmallVector<int, 4> LoInputs;
9907       std::copy_if(Mask.begin(), Mask.end(), std::back_inserter(LoInputs),
9908                    [](int M) { return M >= 0 && M < 8; });
9909       std::sort(LoInputs.begin(), LoInputs.end());
9910       LoInputs.erase(std::unique(LoInputs.begin(), LoInputs.end()),
9911                      LoInputs.end());
9912       SmallVector<int, 4> HiInputs;
9913       std::copy_if(Mask.begin(), Mask.end(), std::back_inserter(HiInputs),
9914                    [](int M) { return M >= 8; });
9915       std::sort(HiInputs.begin(), HiInputs.end());
9916       HiInputs.erase(std::unique(HiInputs.begin(), HiInputs.end()),
9917                      HiInputs.end());
9918
9919       bool TargetLo = LoInputs.size() >= HiInputs.size();
9920       ArrayRef<int> InPlaceInputs = TargetLo ? LoInputs : HiInputs;
9921       ArrayRef<int> MovingInputs = TargetLo ? HiInputs : LoInputs;
9922
9923       int PreDupI16Shuffle[] = {-1, -1, -1, -1, -1, -1, -1, -1};
9924       SmallDenseMap<int, int, 8> LaneMap;
9925       for (int I : InPlaceInputs) {
9926         PreDupI16Shuffle[I/2] = I/2;
9927         LaneMap[I] = I;
9928       }
9929       int j = TargetLo ? 0 : 4, je = j + 4;
9930       for (int i = 0, ie = MovingInputs.size(); i < ie; ++i) {
9931         // Check if j is already a shuffle of this input. This happens when
9932         // there are two adjacent bytes after we move the low one.
9933         if (PreDupI16Shuffle[j] != MovingInputs[i] / 2) {
9934           // If we haven't yet mapped the input, search for a slot into which
9935           // we can map it.
9936           while (j < je && PreDupI16Shuffle[j] != -1)
9937             ++j;
9938
9939           if (j == je)
9940             // We can't place the inputs into a single half with a simple i16 shuffle, so bail.
9941             return SDValue();
9942
9943           // Map this input with the i16 shuffle.
9944           PreDupI16Shuffle[j] = MovingInputs[i] / 2;
9945         }
9946
9947         // Update the lane map based on the mapping we ended up with.
9948         LaneMap[MovingInputs[i]] = 2 * j + MovingInputs[i] % 2;
9949       }
9950       V1 = DAG.getNode(
9951           ISD::BITCAST, DL, MVT::v16i8,
9952           DAG.getVectorShuffle(MVT::v8i16, DL,
9953                                DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
9954                                DAG.getUNDEF(MVT::v8i16), PreDupI16Shuffle));
9955
9956       // Unpack the bytes to form the i16s that will be shuffled into place.
9957       V1 = DAG.getNode(TargetLo ? X86ISD::UNPCKL : X86ISD::UNPCKH, DL,
9958                        MVT::v16i8, V1, V1);
9959
9960       int PostDupI16Shuffle[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9961       for (int i = 0; i < 16; ++i)
9962         if (Mask[i] != -1) {
9963           int MappedMask = LaneMap[Mask[i]] - (TargetLo ? 0 : 8);
9964           assert(MappedMask < 8 && "Invalid v8 shuffle mask!");
9965           if (PostDupI16Shuffle[i / 2] == -1)
9966             PostDupI16Shuffle[i / 2] = MappedMask;
9967           else
9968             assert(PostDupI16Shuffle[i / 2] == MappedMask &&
9969                    "Conflicting entrties in the original shuffle!");
9970         }
9971       return DAG.getNode(
9972           ISD::BITCAST, DL, MVT::v16i8,
9973           DAG.getVectorShuffle(MVT::v8i16, DL,
9974                                DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
9975                                DAG.getUNDEF(MVT::v8i16), PostDupI16Shuffle));
9976     };
9977     if (SDValue V = tryToWidenViaDuplication())
9978       return V;
9979   }
9980
9981   // Use dedicated unpack instructions for masks that match their pattern.
9982   if (isShuffleEquivalent(V1, V2, Mask,
9983                           0,  16,  1, 17,  2, 18,  3, 19,
9984                           4,  20,  5, 21,  6, 22,  7, 23))
9985     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V1, V2);
9986   if (isShuffleEquivalent(V1, V2, Mask,
9987                           8,  24,  9, 25, 10, 26, 11, 27,
9988                           12, 28, 13, 29, 14, 30, 15, 31))
9989     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V1, V2);
9990
9991   // Check for SSSE3 which lets us lower all v16i8 shuffles much more directly
9992   // with PSHUFB. It is important to do this before we attempt to generate any
9993   // blends but after all of the single-input lowerings. If the single input
9994   // lowerings can find an instruction sequence that is faster than a PSHUFB, we
9995   // want to preserve that and we can DAG combine any longer sequences into
9996   // a PSHUFB in the end. But once we start blending from multiple inputs,
9997   // the complexity of DAG combining bad patterns back into PSHUFB is too high,
9998   // and there are *very* few patterns that would actually be faster than the
9999   // PSHUFB approach because of its ability to zero lanes.
10000   //
10001   // FIXME: The only exceptions to the above are blends which are exact
10002   // interleavings with direct instructions supporting them. We currently don't
10003   // handle those well here.
10004   if (Subtarget->hasSSSE3()) {
10005     SDValue V1Mask[16];
10006     SDValue V2Mask[16];
10007     bool V1InUse = false;
10008     bool V2InUse = false;
10009     SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
10010
10011     for (int i = 0; i < 16; ++i) {
10012       if (Mask[i] == -1) {
10013         V1Mask[i] = V2Mask[i] = DAG.getUNDEF(MVT::i8);
10014       } else {
10015         const int ZeroMask = 0x80;
10016         int V1Idx = (Mask[i] < 16 ? Mask[i] : ZeroMask);
10017         int V2Idx = (Mask[i] < 16 ? ZeroMask : Mask[i] - 16);
10018         if (Zeroable[i])
10019           V1Idx = V2Idx = ZeroMask;
10020         V1Mask[i] = DAG.getConstant(V1Idx, MVT::i8);
10021         V2Mask[i] = DAG.getConstant(V2Idx, MVT::i8);
10022         V1InUse |= (ZeroMask != V1Idx);
10023         V2InUse |= (ZeroMask != V2Idx);
10024       }
10025     }
10026
10027     // If both V1 and V2 are in use and we can use a direct blend or an unpack,
10028     // do so. This avoids using them to handle blends-with-zero which is
10029     // important as a single pshufb is significantly faster for that.
10030     if (V1InUse && V2InUse) {
10031       if (Subtarget->hasSSE41())
10032         if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v16i8, V1, V2,
10033                                                       Mask, Subtarget, DAG))
10034           return Blend;
10035
10036       // We can use an unpack to do the blending rather than an or in some
10037       // cases. Even though the or may be (very minorly) more efficient, we
10038       // preference this lowering because there are common cases where part of
10039       // the complexity of the shuffles goes away when we do the final blend as
10040       // an unpack.
10041       // FIXME: It might be worth trying to detect if the unpack-feeding
10042       // shuffles will both be pshufb, in which case we shouldn't bother with
10043       // this.
10044       if (SDValue Unpack =
10045               lowerVectorShuffleAsUnpack(MVT::v16i8, DL, V1, V2, Mask, DAG))
10046         return Unpack;
10047     }
10048
10049     if (V1InUse)
10050       V1 = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, V1,
10051                        DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, V1Mask));
10052     if (V2InUse)
10053       V2 = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, V2,
10054                        DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, V2Mask));
10055
10056     // If we need shuffled inputs from both, blend the two.
10057     if (V1InUse && V2InUse)
10058       return DAG.getNode(ISD::OR, DL, MVT::v16i8, V1, V2);
10059     if (V1InUse)
10060       return V1; // Single inputs are easy.
10061     if (V2InUse)
10062       return V2; // Single inputs are easy.
10063     // Shuffling to a zeroable vector.
10064     return getZeroVector(MVT::v16i8, Subtarget, DAG, DL);
10065   }
10066
10067   // There are special ways we can lower some single-element blends.
10068   if (NumV2Elements == 1)
10069     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v16i8, DL, V1, V2,
10070                                                          Mask, Subtarget, DAG))
10071       return V;
10072
10073   if (SDValue BitBlend =
10074           lowerVectorShuffleAsBitBlend(DL, MVT::v16i8, V1, V2, Mask, DAG))
10075     return BitBlend;
10076
10077   // Check whether a compaction lowering can be done. This handles shuffles
10078   // which take every Nth element for some even N. See the helper function for
10079   // details.
10080   //
10081   // We special case these as they can be particularly efficiently handled with
10082   // the PACKUSB instruction on x86 and they show up in common patterns of
10083   // rearranging bytes to truncate wide elements.
10084   if (int NumEvenDrops = canLowerByDroppingEvenElements(Mask)) {
10085     // NumEvenDrops is the power of two stride of the elements. Another way of
10086     // thinking about it is that we need to drop the even elements this many
10087     // times to get the original input.
10088     bool IsSingleInput = isSingleInputShuffleMask(Mask);
10089
10090     // First we need to zero all the dropped bytes.
10091     assert(NumEvenDrops <= 3 &&
10092            "No support for dropping even elements more than 3 times.");
10093     // We use the mask type to pick which bytes are preserved based on how many
10094     // elements are dropped.
10095     MVT MaskVTs[] = { MVT::v8i16, MVT::v4i32, MVT::v2i64 };
10096     SDValue ByteClearMask =
10097         DAG.getNode(ISD::BITCAST, DL, MVT::v16i8,
10098                     DAG.getConstant(0xFF, MaskVTs[NumEvenDrops - 1]));
10099     V1 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V1, ByteClearMask);
10100     if (!IsSingleInput)
10101       V2 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V2, ByteClearMask);
10102
10103     // Now pack things back together.
10104     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1);
10105     V2 = IsSingleInput ? V1 : DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V2);
10106     SDValue Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, V1, V2);
10107     for (int i = 1; i < NumEvenDrops; ++i) {
10108       Result = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, Result);
10109       Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, Result, Result);
10110     }
10111
10112     return Result;
10113   }
10114
10115   // Handle multi-input cases by blending single-input shuffles.
10116   if (NumV2Elements > 0)
10117     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v16i8, V1, V2,
10118                                                       Mask, DAG);
10119
10120   // The fallback path for single-input shuffles widens this into two v8i16
10121   // vectors with unpacks, shuffles those, and then pulls them back together
10122   // with a pack.
10123   SDValue V = V1;
10124
10125   int LoBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
10126   int HiBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
10127   for (int i = 0; i < 16; ++i)
10128     if (Mask[i] >= 0)
10129       (i < 8 ? LoBlendMask[i] : HiBlendMask[i % 8]) = Mask[i];
10130
10131   SDValue Zero = getZeroVector(MVT::v8i16, Subtarget, DAG, DL);
10132
10133   SDValue VLoHalf, VHiHalf;
10134   // Check if any of the odd lanes in the v16i8 are used. If not, we can mask
10135   // them out and avoid using UNPCK{L,H} to extract the elements of V as
10136   // i16s.
10137   if (std::none_of(std::begin(LoBlendMask), std::end(LoBlendMask),
10138                    [](int M) { return M >= 0 && M % 2 == 1; }) &&
10139       std::none_of(std::begin(HiBlendMask), std::end(HiBlendMask),
10140                    [](int M) { return M >= 0 && M % 2 == 1; })) {
10141     // Use a mask to drop the high bytes.
10142     VLoHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
10143     VLoHalf = DAG.getNode(ISD::AND, DL, MVT::v8i16, VLoHalf,
10144                      DAG.getConstant(0x00FF, MVT::v8i16));
10145
10146     // This will be a single vector shuffle instead of a blend so nuke VHiHalf.
10147     VHiHalf = DAG.getUNDEF(MVT::v8i16);
10148
10149     // Squash the masks to point directly into VLoHalf.
10150     for (int &M : LoBlendMask)
10151       if (M >= 0)
10152         M /= 2;
10153     for (int &M : HiBlendMask)
10154       if (M >= 0)
10155         M /= 2;
10156   } else {
10157     // Otherwise just unpack the low half of V into VLoHalf and the high half into
10158     // VHiHalf so that we can blend them as i16s.
10159     VLoHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
10160                      DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V, Zero));
10161     VHiHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
10162                      DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V, Zero));
10163   }
10164
10165   SDValue LoV = DAG.getVectorShuffle(MVT::v8i16, DL, VLoHalf, VHiHalf, LoBlendMask);
10166   SDValue HiV = DAG.getVectorShuffle(MVT::v8i16, DL, VLoHalf, VHiHalf, HiBlendMask);
10167
10168   return DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, LoV, HiV);
10169 }
10170
10171 /// \brief Dispatching routine to lower various 128-bit x86 vector shuffles.
10172 ///
10173 /// This routine breaks down the specific type of 128-bit shuffle and
10174 /// dispatches to the lowering routines accordingly.
10175 static SDValue lower128BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10176                                         MVT VT, const X86Subtarget *Subtarget,
10177                                         SelectionDAG &DAG) {
10178   switch (VT.SimpleTy) {
10179   case MVT::v2i64:
10180     return lowerV2I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10181   case MVT::v2f64:
10182     return lowerV2F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10183   case MVT::v4i32:
10184     return lowerV4I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10185   case MVT::v4f32:
10186     return lowerV4F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10187   case MVT::v8i16:
10188     return lowerV8I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
10189   case MVT::v16i8:
10190     return lowerV16I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
10191
10192   default:
10193     llvm_unreachable("Unimplemented!");
10194   }
10195 }
10196
10197 /// \brief Helper function to test whether a shuffle mask could be
10198 /// simplified by widening the elements being shuffled.
10199 ///
10200 /// Appends the mask for wider elements in WidenedMask if valid. Otherwise
10201 /// leaves it in an unspecified state.
10202 ///
10203 /// NOTE: This must handle normal vector shuffle masks and *target* vector
10204 /// shuffle masks. The latter have the special property of a '-2' representing
10205 /// a zero-ed lane of a vector.
10206 static bool canWidenShuffleElements(ArrayRef<int> Mask,
10207                                     SmallVectorImpl<int> &WidenedMask) {
10208   for (int i = 0, Size = Mask.size(); i < Size; i += 2) {
10209     // If both elements are undef, its trivial.
10210     if (Mask[i] == SM_SentinelUndef && Mask[i + 1] == SM_SentinelUndef) {
10211       WidenedMask.push_back(SM_SentinelUndef);
10212       continue;
10213     }
10214
10215     // Check for an undef mask and a mask value properly aligned to fit with
10216     // a pair of values. If we find such a case, use the non-undef mask's value.
10217     if (Mask[i] == SM_SentinelUndef && Mask[i + 1] >= 0 && Mask[i + 1] % 2 == 1) {
10218       WidenedMask.push_back(Mask[i + 1] / 2);
10219       continue;
10220     }
10221     if (Mask[i + 1] == SM_SentinelUndef && Mask[i] >= 0 && Mask[i] % 2 == 0) {
10222       WidenedMask.push_back(Mask[i] / 2);
10223       continue;
10224     }
10225
10226     // When zeroing, we need to spread the zeroing across both lanes to widen.
10227     if (Mask[i] == SM_SentinelZero || Mask[i + 1] == SM_SentinelZero) {
10228       if ((Mask[i] == SM_SentinelZero || Mask[i] == SM_SentinelUndef) &&
10229           (Mask[i + 1] == SM_SentinelZero || Mask[i + 1] == SM_SentinelUndef)) {
10230         WidenedMask.push_back(SM_SentinelZero);
10231         continue;
10232       }
10233       return false;
10234     }
10235
10236     // Finally check if the two mask values are adjacent and aligned with
10237     // a pair.
10238     if (Mask[i] != SM_SentinelUndef && Mask[i] % 2 == 0 && Mask[i] + 1 == Mask[i + 1]) {
10239       WidenedMask.push_back(Mask[i] / 2);
10240       continue;
10241     }
10242
10243     // Otherwise we can't safely widen the elements used in this shuffle.
10244     return false;
10245   }
10246   assert(WidenedMask.size() == Mask.size() / 2 &&
10247          "Incorrect size of mask after widening the elements!");
10248
10249   return true;
10250 }
10251
10252 /// \brief Generic routine to split vector shuffle into half-sized shuffles.
10253 ///
10254 /// This routine just extracts two subvectors, shuffles them independently, and
10255 /// then concatenates them back together. This should work effectively with all
10256 /// AVX vector shuffle types.
10257 static SDValue splitAndLowerVectorShuffle(SDLoc DL, MVT VT, SDValue V1,
10258                                           SDValue V2, ArrayRef<int> Mask,
10259                                           SelectionDAG &DAG) {
10260   assert(VT.getSizeInBits() >= 256 &&
10261          "Only for 256-bit or wider vector shuffles!");
10262   assert(V1.getSimpleValueType() == VT && "Bad operand type!");
10263   assert(V2.getSimpleValueType() == VT && "Bad operand type!");
10264
10265   ArrayRef<int> LoMask = Mask.slice(0, Mask.size() / 2);
10266   ArrayRef<int> HiMask = Mask.slice(Mask.size() / 2);
10267
10268   int NumElements = VT.getVectorNumElements();
10269   int SplitNumElements = NumElements / 2;
10270   MVT ScalarVT = VT.getScalarType();
10271   MVT SplitVT = MVT::getVectorVT(ScalarVT, NumElements / 2);
10272
10273   // Rather than splitting build-vectors, just build two narrower build
10274   // vectors. This helps shuffling with splats and zeros.
10275   auto SplitVector = [&](SDValue V) {
10276     while (V.getOpcode() == ISD::BITCAST)
10277       V = V->getOperand(0);
10278
10279     MVT OrigVT = V.getSimpleValueType();
10280     int OrigNumElements = OrigVT.getVectorNumElements();
10281     int OrigSplitNumElements = OrigNumElements / 2;
10282     MVT OrigScalarVT = OrigVT.getScalarType();
10283     MVT OrigSplitVT = MVT::getVectorVT(OrigScalarVT, OrigNumElements / 2);
10284
10285     SDValue LoV, HiV;
10286
10287     auto *BV = dyn_cast<BuildVectorSDNode>(V);
10288     if (!BV) {
10289       LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigSplitVT, V,
10290                         DAG.getIntPtrConstant(0));
10291       HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigSplitVT, V,
10292                         DAG.getIntPtrConstant(OrigSplitNumElements));
10293     } else {
10294
10295       SmallVector<SDValue, 16> LoOps, HiOps;
10296       for (int i = 0; i < OrigSplitNumElements; ++i) {
10297         LoOps.push_back(BV->getOperand(i));
10298         HiOps.push_back(BV->getOperand(i + OrigSplitNumElements));
10299       }
10300       LoV = DAG.getNode(ISD::BUILD_VECTOR, DL, OrigSplitVT, LoOps);
10301       HiV = DAG.getNode(ISD::BUILD_VECTOR, DL, OrigSplitVT, HiOps);
10302     }
10303     return std::make_pair(DAG.getNode(ISD::BITCAST, DL, SplitVT, LoV),
10304                           DAG.getNode(ISD::BITCAST, DL, SplitVT, HiV));
10305   };
10306
10307   SDValue LoV1, HiV1, LoV2, HiV2;
10308   std::tie(LoV1, HiV1) = SplitVector(V1);
10309   std::tie(LoV2, HiV2) = SplitVector(V2);
10310
10311   // Now create two 4-way blends of these half-width vectors.
10312   auto HalfBlend = [&](ArrayRef<int> HalfMask) {
10313     bool UseLoV1 = false, UseHiV1 = false, UseLoV2 = false, UseHiV2 = false;
10314     SmallVector<int, 32> V1BlendMask, V2BlendMask, BlendMask;
10315     for (int i = 0; i < SplitNumElements; ++i) {
10316       int M = HalfMask[i];
10317       if (M >= NumElements) {
10318         if (M >= NumElements + SplitNumElements)
10319           UseHiV2 = true;
10320         else
10321           UseLoV2 = true;
10322         V2BlendMask.push_back(M - NumElements);
10323         V1BlendMask.push_back(-1);
10324         BlendMask.push_back(SplitNumElements + i);
10325       } else if (M >= 0) {
10326         if (M >= SplitNumElements)
10327           UseHiV1 = true;
10328         else
10329           UseLoV1 = true;
10330         V2BlendMask.push_back(-1);
10331         V1BlendMask.push_back(M);
10332         BlendMask.push_back(i);
10333       } else {
10334         V2BlendMask.push_back(-1);
10335         V1BlendMask.push_back(-1);
10336         BlendMask.push_back(-1);
10337       }
10338     }
10339
10340     // Because the lowering happens after all combining takes place, we need to
10341     // manually combine these blend masks as much as possible so that we create
10342     // a minimal number of high-level vector shuffle nodes.
10343
10344     // First try just blending the halves of V1 or V2.
10345     if (!UseLoV1 && !UseHiV1 && !UseLoV2 && !UseHiV2)
10346       return DAG.getUNDEF(SplitVT);
10347     if (!UseLoV2 && !UseHiV2)
10348       return DAG.getVectorShuffle(SplitVT, DL, LoV1, HiV1, V1BlendMask);
10349     if (!UseLoV1 && !UseHiV1)
10350       return DAG.getVectorShuffle(SplitVT, DL, LoV2, HiV2, V2BlendMask);
10351
10352     SDValue V1Blend, V2Blend;
10353     if (UseLoV1 && UseHiV1) {
10354       V1Blend =
10355         DAG.getVectorShuffle(SplitVT, DL, LoV1, HiV1, V1BlendMask);
10356     } else {
10357       // We only use half of V1 so map the usage down into the final blend mask.
10358       V1Blend = UseLoV1 ? LoV1 : HiV1;
10359       for (int i = 0; i < SplitNumElements; ++i)
10360         if (BlendMask[i] >= 0 && BlendMask[i] < SplitNumElements)
10361           BlendMask[i] = V1BlendMask[i] - (UseLoV1 ? 0 : SplitNumElements);
10362     }
10363     if (UseLoV2 && UseHiV2) {
10364       V2Blend =
10365         DAG.getVectorShuffle(SplitVT, DL, LoV2, HiV2, V2BlendMask);
10366     } else {
10367       // We only use half of V2 so map the usage down into the final blend mask.
10368       V2Blend = UseLoV2 ? LoV2 : HiV2;
10369       for (int i = 0; i < SplitNumElements; ++i)
10370         if (BlendMask[i] >= SplitNumElements)
10371           BlendMask[i] = V2BlendMask[i] + (UseLoV2 ? SplitNumElements : 0);
10372     }
10373     return DAG.getVectorShuffle(SplitVT, DL, V1Blend, V2Blend, BlendMask);
10374   };
10375   SDValue Lo = HalfBlend(LoMask);
10376   SDValue Hi = HalfBlend(HiMask);
10377   return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
10378 }
10379
10380 /// \brief Either split a vector in halves or decompose the shuffles and the
10381 /// blend.
10382 ///
10383 /// This is provided as a good fallback for many lowerings of non-single-input
10384 /// shuffles with more than one 128-bit lane. In those cases, we want to select
10385 /// between splitting the shuffle into 128-bit components and stitching those
10386 /// back together vs. extracting the single-input shuffles and blending those
10387 /// results.
10388 static SDValue lowerVectorShuffleAsSplitOrBlend(SDLoc DL, MVT VT, SDValue V1,
10389                                                 SDValue V2, ArrayRef<int> Mask,
10390                                                 SelectionDAG &DAG) {
10391   assert(!isSingleInputShuffleMask(Mask) && "This routine must not be used to "
10392                                             "lower single-input shuffles as it "
10393                                             "could then recurse on itself.");
10394   int Size = Mask.size();
10395
10396   // If this can be modeled as a broadcast of two elements followed by a blend,
10397   // prefer that lowering. This is especially important because broadcasts can
10398   // often fold with memory operands.
10399   auto DoBothBroadcast = [&] {
10400     int V1BroadcastIdx = -1, V2BroadcastIdx = -1;
10401     for (int M : Mask)
10402       if (M >= Size) {
10403         if (V2BroadcastIdx == -1)
10404           V2BroadcastIdx = M - Size;
10405         else if (M - Size != V2BroadcastIdx)
10406           return false;
10407       } else if (M >= 0) {
10408         if (V1BroadcastIdx == -1)
10409           V1BroadcastIdx = M;
10410         else if (M != V1BroadcastIdx)
10411           return false;
10412       }
10413     return true;
10414   };
10415   if (DoBothBroadcast())
10416     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask,
10417                                                       DAG);
10418
10419   // If the inputs all stem from a single 128-bit lane of each input, then we
10420   // split them rather than blending because the split will decompose to
10421   // unusually few instructions.
10422   int LaneCount = VT.getSizeInBits() / 128;
10423   int LaneSize = Size / LaneCount;
10424   SmallBitVector LaneInputs[2];
10425   LaneInputs[0].resize(LaneCount, false);
10426   LaneInputs[1].resize(LaneCount, false);
10427   for (int i = 0; i < Size; ++i)
10428     if (Mask[i] >= 0)
10429       LaneInputs[Mask[i] / Size][(Mask[i] % Size) / LaneSize] = true;
10430   if (LaneInputs[0].count() <= 1 && LaneInputs[1].count() <= 1)
10431     return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10432
10433   // Otherwise, just fall back to decomposed shuffles and a blend. This requires
10434   // that the decomposed single-input shuffles don't end up here.
10435   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask, DAG);
10436 }
10437
10438 /// \brief Lower a vector shuffle crossing multiple 128-bit lanes as
10439 /// a permutation and blend of those lanes.
10440 ///
10441 /// This essentially blends the out-of-lane inputs to each lane into the lane
10442 /// from a permuted copy of the vector. This lowering strategy results in four
10443 /// instructions in the worst case for a single-input cross lane shuffle which
10444 /// is lower than any other fully general cross-lane shuffle strategy I'm aware
10445 /// of. Special cases for each particular shuffle pattern should be handled
10446 /// prior to trying this lowering.
10447 static SDValue lowerVectorShuffleAsLanePermuteAndBlend(SDLoc DL, MVT VT,
10448                                                        SDValue V1, SDValue V2,
10449                                                        ArrayRef<int> Mask,
10450                                                        SelectionDAG &DAG) {
10451   // FIXME: This should probably be generalized for 512-bit vectors as well.
10452   assert(VT.getSizeInBits() == 256 && "Only for 256-bit vector shuffles!");
10453   int LaneSize = Mask.size() / 2;
10454
10455   // If there are only inputs from one 128-bit lane, splitting will in fact be
10456   // less expensive. The flags track wether the given lane contains an element
10457   // that crosses to another lane.
10458   bool LaneCrossing[2] = {false, false};
10459   for (int i = 0, Size = Mask.size(); i < Size; ++i)
10460     if (Mask[i] >= 0 && (Mask[i] % Size) / LaneSize != i / LaneSize)
10461       LaneCrossing[(Mask[i] % Size) / LaneSize] = true;
10462   if (!LaneCrossing[0] || !LaneCrossing[1])
10463     return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10464
10465   if (isSingleInputShuffleMask(Mask)) {
10466     SmallVector<int, 32> FlippedBlendMask;
10467     for (int i = 0, Size = Mask.size(); i < Size; ++i)
10468       FlippedBlendMask.push_back(
10469           Mask[i] < 0 ? -1 : (((Mask[i] % Size) / LaneSize == i / LaneSize)
10470                                   ? Mask[i]
10471                                   : Mask[i] % LaneSize +
10472                                         (i / LaneSize) * LaneSize + Size));
10473
10474     // Flip the vector, and blend the results which should now be in-lane. The
10475     // VPERM2X128 mask uses the low 2 bits for the low source and bits 4 and
10476     // 5 for the high source. The value 3 selects the high half of source 2 and
10477     // the value 2 selects the low half of source 2. We only use source 2 to
10478     // allow folding it into a memory operand.
10479     unsigned PERMMask = 3 | 2 << 4;
10480     SDValue Flipped = DAG.getNode(X86ISD::VPERM2X128, DL, VT, DAG.getUNDEF(VT),
10481                                   V1, DAG.getConstant(PERMMask, MVT::i8));
10482     return DAG.getVectorShuffle(VT, DL, V1, Flipped, FlippedBlendMask);
10483   }
10484
10485   // This now reduces to two single-input shuffles of V1 and V2 which at worst
10486   // will be handled by the above logic and a blend of the results, much like
10487   // other patterns in AVX.
10488   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask, DAG);
10489 }
10490
10491 /// \brief Handle lowering 2-lane 128-bit shuffles.
10492 static SDValue lowerV2X128VectorShuffle(SDLoc DL, MVT VT, SDValue V1,
10493                                         SDValue V2, ArrayRef<int> Mask,
10494                                         const X86Subtarget *Subtarget,
10495                                         SelectionDAG &DAG) {
10496   // Blends are faster and handle all the non-lane-crossing cases.
10497   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, VT, V1, V2, Mask,
10498                                                 Subtarget, DAG))
10499     return Blend;
10500
10501   MVT SubVT = MVT::getVectorVT(VT.getVectorElementType(),
10502                                VT.getVectorNumElements() / 2);
10503   // Check for patterns which can be matched with a single insert of a 128-bit
10504   // subvector.
10505   if (isShuffleEquivalent(V1, V2, Mask, 0, 1, 0, 1) ||
10506       isShuffleEquivalent(V1, V2, Mask, 0, 1, 4, 5)) {
10507     SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
10508                               DAG.getIntPtrConstant(0));
10509     SDValue HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT,
10510                               Mask[2] < 4 ? V1 : V2, DAG.getIntPtrConstant(0));
10511     return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LoV, HiV);
10512   }
10513   if (isShuffleEquivalent(V1, V2, Mask, 0, 1, 6, 7)) {
10514     SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
10515                               DAG.getIntPtrConstant(0));
10516     SDValue HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V2,
10517                               DAG.getIntPtrConstant(2));
10518     return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LoV, HiV);
10519   }
10520
10521   // Otherwise form a 128-bit permutation.
10522   // FIXME: Detect zero-vector inputs and use the VPERM2X128 to zero that half.
10523   unsigned PermMask = Mask[0] / 2 | (Mask[2] / 2) << 4;
10524   return DAG.getNode(X86ISD::VPERM2X128, DL, VT, V1, V2,
10525                      DAG.getConstant(PermMask, MVT::i8));
10526 }
10527
10528 /// \brief Lower a vector shuffle by first fixing the 128-bit lanes and then
10529 /// shuffling each lane.
10530 ///
10531 /// This will only succeed when the result of fixing the 128-bit lanes results
10532 /// in a single-input non-lane-crossing shuffle with a repeating shuffle mask in
10533 /// each 128-bit lanes. This handles many cases where we can quickly blend away
10534 /// the lane crosses early and then use simpler shuffles within each lane.
10535 ///
10536 /// FIXME: It might be worthwhile at some point to support this without
10537 /// requiring the 128-bit lane-relative shuffles to be repeating, but currently
10538 /// in x86 only floating point has interesting non-repeating shuffles, and even
10539 /// those are still *marginally* more expensive.
10540 static SDValue lowerVectorShuffleByMerging128BitLanes(
10541     SDLoc DL, MVT VT, SDValue V1, SDValue V2, ArrayRef<int> Mask,
10542     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
10543   assert(!isSingleInputShuffleMask(Mask) &&
10544          "This is only useful with multiple inputs.");
10545
10546   int Size = Mask.size();
10547   int LaneSize = 128 / VT.getScalarSizeInBits();
10548   int NumLanes = Size / LaneSize;
10549   assert(NumLanes > 1 && "Only handles 256-bit and wider shuffles.");
10550
10551   // See if we can build a hypothetical 128-bit lane-fixing shuffle mask. Also
10552   // check whether the in-128-bit lane shuffles share a repeating pattern.
10553   SmallVector<int, 4> Lanes;
10554   Lanes.resize(NumLanes, -1);
10555   SmallVector<int, 4> InLaneMask;
10556   InLaneMask.resize(LaneSize, -1);
10557   for (int i = 0; i < Size; ++i) {
10558     if (Mask[i] < 0)
10559       continue;
10560
10561     int j = i / LaneSize;
10562
10563     if (Lanes[j] < 0) {
10564       // First entry we've seen for this lane.
10565       Lanes[j] = Mask[i] / LaneSize;
10566     } else if (Lanes[j] != Mask[i] / LaneSize) {
10567       // This doesn't match the lane selected previously!
10568       return SDValue();
10569     }
10570
10571     // Check that within each lane we have a consistent shuffle mask.
10572     int k = i % LaneSize;
10573     if (InLaneMask[k] < 0) {
10574       InLaneMask[k] = Mask[i] % LaneSize;
10575     } else if (InLaneMask[k] != Mask[i] % LaneSize) {
10576       // This doesn't fit a repeating in-lane mask.
10577       return SDValue();
10578     }
10579   }
10580
10581   // First shuffle the lanes into place.
10582   MVT LaneVT = MVT::getVectorVT(VT.isFloatingPoint() ? MVT::f64 : MVT::i64,
10583                                 VT.getSizeInBits() / 64);
10584   SmallVector<int, 8> LaneMask;
10585   LaneMask.resize(NumLanes * 2, -1);
10586   for (int i = 0; i < NumLanes; ++i)
10587     if (Lanes[i] >= 0) {
10588       LaneMask[2 * i + 0] = 2*Lanes[i] + 0;
10589       LaneMask[2 * i + 1] = 2*Lanes[i] + 1;
10590     }
10591
10592   V1 = DAG.getNode(ISD::BITCAST, DL, LaneVT, V1);
10593   V2 = DAG.getNode(ISD::BITCAST, DL, LaneVT, V2);
10594   SDValue LaneShuffle = DAG.getVectorShuffle(LaneVT, DL, V1, V2, LaneMask);
10595
10596   // Cast it back to the type we actually want.
10597   LaneShuffle = DAG.getNode(ISD::BITCAST, DL, VT, LaneShuffle);
10598
10599   // Now do a simple shuffle that isn't lane crossing.
10600   SmallVector<int, 8> NewMask;
10601   NewMask.resize(Size, -1);
10602   for (int i = 0; i < Size; ++i)
10603     if (Mask[i] >= 0)
10604       NewMask[i] = (i / LaneSize) * LaneSize + Mask[i] % LaneSize;
10605   assert(!is128BitLaneCrossingShuffleMask(VT, NewMask) &&
10606          "Must not introduce lane crosses at this point!");
10607
10608   return DAG.getVectorShuffle(VT, DL, LaneShuffle, DAG.getUNDEF(VT), NewMask);
10609 }
10610
10611 /// \brief Test whether the specified input (0 or 1) is in-place blended by the
10612 /// given mask.
10613 ///
10614 /// This returns true if the elements from a particular input are already in the
10615 /// slot required by the given mask and require no permutation.
10616 static bool isShuffleMaskInputInPlace(int Input, ArrayRef<int> Mask) {
10617   assert((Input == 0 || Input == 1) && "Only two inputs to shuffles.");
10618   int Size = Mask.size();
10619   for (int i = 0; i < Size; ++i)
10620     if (Mask[i] >= 0 && Mask[i] / Size == Input && Mask[i] % Size != i)
10621       return false;
10622
10623   return true;
10624 }
10625
10626 /// \brief Handle lowering of 4-lane 64-bit floating point shuffles.
10627 ///
10628 /// Also ends up handling lowering of 4-lane 64-bit integer shuffles when AVX2
10629 /// isn't available.
10630 static SDValue lowerV4F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10631                                        const X86Subtarget *Subtarget,
10632                                        SelectionDAG &DAG) {
10633   SDLoc DL(Op);
10634   assert(V1.getSimpleValueType() == MVT::v4f64 && "Bad operand type!");
10635   assert(V2.getSimpleValueType() == MVT::v4f64 && "Bad operand type!");
10636   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10637   ArrayRef<int> Mask = SVOp->getMask();
10638   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
10639
10640   SmallVector<int, 4> WidenedMask;
10641   if (canWidenShuffleElements(Mask, WidenedMask))
10642     return lowerV2X128VectorShuffle(DL, MVT::v4f64, V1, V2, Mask, Subtarget,
10643                                     DAG);
10644
10645   if (isSingleInputShuffleMask(Mask)) {
10646     // Check for being able to broadcast a single element.
10647     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4f64, DL, V1,
10648                                                           Mask, Subtarget, DAG))
10649       return Broadcast;
10650
10651     // Use low duplicate instructions for masks that match their pattern.
10652     if (isShuffleEquivalent(V1, V2, Mask, 0, 0, 2, 2))
10653       return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v4f64, V1);
10654
10655     if (!is128BitLaneCrossingShuffleMask(MVT::v4f64, Mask)) {
10656       // Non-half-crossing single input shuffles can be lowerid with an
10657       // interleaved permutation.
10658       unsigned VPERMILPMask = (Mask[0] == 1) | ((Mask[1] == 1) << 1) |
10659                               ((Mask[2] == 3) << 2) | ((Mask[3] == 3) << 3);
10660       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f64, V1,
10661                          DAG.getConstant(VPERMILPMask, MVT::i8));
10662     }
10663
10664     // With AVX2 we have direct support for this permutation.
10665     if (Subtarget->hasAVX2())
10666       return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4f64, V1,
10667                          getV4X86ShuffleImm8ForMask(Mask, DAG));
10668
10669     // Otherwise, fall back.
10670     return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v4f64, V1, V2, Mask,
10671                                                    DAG);
10672   }
10673
10674   // X86 has dedicated unpack instructions that can handle specific blend
10675   // operations: UNPCKH and UNPCKL.
10676   if (isShuffleEquivalent(V1, V2, Mask, 0, 4, 2, 6))
10677     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f64, V1, V2);
10678   if (isShuffleEquivalent(V1, V2, Mask, 1, 5, 3, 7))
10679     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f64, V1, V2);
10680   if (isShuffleEquivalent(V1, V2, Mask, 4, 0, 6, 2))
10681     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f64, V2, V1);
10682   if (isShuffleEquivalent(V1, V2, Mask, 5, 1, 7, 3))
10683     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f64, V2, V1);
10684
10685   // If we have a single input to the zero element, insert that into V1 if we
10686   // can do so cheaply.
10687   int NumV2Elements =
10688       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
10689   if (NumV2Elements == 1 && Mask[0] >= 4)
10690     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
10691             MVT::v4f64, DL, V1, V2, Mask, Subtarget, DAG))
10692       return Insertion;
10693
10694   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4f64, V1, V2, Mask,
10695                                                 Subtarget, DAG))
10696     return Blend;
10697
10698   // Check if the blend happens to exactly fit that of SHUFPD.
10699   if ((Mask[0] == -1 || Mask[0] < 2) &&
10700       (Mask[1] == -1 || (Mask[1] >= 4 && Mask[1] < 6)) &&
10701       (Mask[2] == -1 || (Mask[2] >= 2 && Mask[2] < 4)) &&
10702       (Mask[3] == -1 || Mask[3] >= 6)) {
10703     unsigned SHUFPDMask = (Mask[0] == 1) | ((Mask[1] == 5) << 1) |
10704                           ((Mask[2] == 3) << 2) | ((Mask[3] == 7) << 3);
10705     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f64, V1, V2,
10706                        DAG.getConstant(SHUFPDMask, MVT::i8));
10707   }
10708   if ((Mask[0] == -1 || (Mask[0] >= 4 && Mask[0] < 6)) &&
10709       (Mask[1] == -1 || Mask[1] < 2) &&
10710       (Mask[2] == -1 || Mask[2] >= 6) &&
10711       (Mask[3] == -1 || (Mask[3] >= 2 && Mask[3] < 4))) {
10712     unsigned SHUFPDMask = (Mask[0] == 5) | ((Mask[1] == 1) << 1) |
10713                           ((Mask[2] == 7) << 2) | ((Mask[3] == 3) << 3);
10714     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f64, V2, V1,
10715                        DAG.getConstant(SHUFPDMask, MVT::i8));
10716   }
10717
10718   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10719   // shuffle. However, if we have AVX2 and either inputs are already in place,
10720   // we will be able to shuffle even across lanes the other input in a single
10721   // instruction so skip this pattern.
10722   if (!(Subtarget->hasAVX2() && (isShuffleMaskInputInPlace(0, Mask) ||
10723                                  isShuffleMaskInputInPlace(1, Mask))))
10724     if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10725             DL, MVT::v4f64, V1, V2, Mask, Subtarget, DAG))
10726       return Result;
10727
10728   // If we have AVX2 then we always want to lower with a blend because an v4 we
10729   // can fully permute the elements.
10730   if (Subtarget->hasAVX2())
10731     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4f64, V1, V2,
10732                                                       Mask, DAG);
10733
10734   // Otherwise fall back on generic lowering.
10735   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v4f64, V1, V2, Mask, DAG);
10736 }
10737
10738 /// \brief Handle lowering of 4-lane 64-bit integer shuffles.
10739 ///
10740 /// This routine is only called when we have AVX2 and thus a reasonable
10741 /// instruction set for v4i64 shuffling..
10742 static SDValue lowerV4I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10743                                        const X86Subtarget *Subtarget,
10744                                        SelectionDAG &DAG) {
10745   SDLoc DL(Op);
10746   assert(V1.getSimpleValueType() == MVT::v4i64 && "Bad operand type!");
10747   assert(V2.getSimpleValueType() == MVT::v4i64 && "Bad operand type!");
10748   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10749   ArrayRef<int> Mask = SVOp->getMask();
10750   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
10751   assert(Subtarget->hasAVX2() && "We can only lower v4i64 with AVX2!");
10752
10753   SmallVector<int, 4> WidenedMask;
10754   if (canWidenShuffleElements(Mask, WidenedMask))
10755     return lowerV2X128VectorShuffle(DL, MVT::v4i64, V1, V2, Mask, Subtarget,
10756                                     DAG);
10757
10758   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4i64, V1, V2, Mask,
10759                                                 Subtarget, DAG))
10760     return Blend;
10761
10762   // Check for being able to broadcast a single element.
10763   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4i64, DL, V1,
10764                                                         Mask, Subtarget, DAG))
10765     return Broadcast;
10766
10767   // When the shuffle is mirrored between the 128-bit lanes of the unit, we can
10768   // use lower latency instructions that will operate on both 128-bit lanes.
10769   SmallVector<int, 2> RepeatedMask;
10770   if (is128BitLaneRepeatedShuffleMask(MVT::v4i64, Mask, RepeatedMask)) {
10771     if (isSingleInputShuffleMask(Mask)) {
10772       int PSHUFDMask[] = {-1, -1, -1, -1};
10773       for (int i = 0; i < 2; ++i)
10774         if (RepeatedMask[i] >= 0) {
10775           PSHUFDMask[2 * i] = 2 * RepeatedMask[i];
10776           PSHUFDMask[2 * i + 1] = 2 * RepeatedMask[i] + 1;
10777         }
10778       return DAG.getNode(
10779           ISD::BITCAST, DL, MVT::v4i64,
10780           DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32,
10781                       DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, V1),
10782                       getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
10783     }
10784   }
10785
10786   // AVX2 provides a direct instruction for permuting a single input across
10787   // lanes.
10788   if (isSingleInputShuffleMask(Mask))
10789     return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4i64, V1,
10790                        getV4X86ShuffleImm8ForMask(Mask, DAG));
10791
10792   // Try to use shift instructions.
10793   if (SDValue Shift =
10794           lowerVectorShuffleAsShift(DL, MVT::v4i64, V1, V2, Mask, DAG))
10795     return Shift;
10796
10797   // Use dedicated unpack instructions for masks that match their pattern.
10798   if (isShuffleEquivalent(V1, V2, Mask, 0, 4, 2, 6))
10799     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i64, V1, V2);
10800   if (isShuffleEquivalent(V1, V2, Mask, 1, 5, 3, 7))
10801     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i64, V1, V2);
10802   if (isShuffleEquivalent(V1, V2, Mask, 4, 0, 6, 2))
10803     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i64, V2, V1);
10804   if (isShuffleEquivalent(V1, V2, Mask, 5, 1, 7, 3))
10805     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i64, V2, V1);
10806
10807   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10808   // shuffle. However, if we have AVX2 and either inputs are already in place,
10809   // we will be able to shuffle even across lanes the other input in a single
10810   // instruction so skip this pattern.
10811   if (!(Subtarget->hasAVX2() && (isShuffleMaskInputInPlace(0, Mask) ||
10812                                  isShuffleMaskInputInPlace(1, Mask))))
10813     if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10814             DL, MVT::v4i64, V1, V2, Mask, Subtarget, DAG))
10815       return Result;
10816
10817   // Otherwise fall back on generic blend lowering.
10818   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4i64, V1, V2,
10819                                                     Mask, DAG);
10820 }
10821
10822 /// \brief Handle lowering of 8-lane 32-bit floating point shuffles.
10823 ///
10824 /// Also ends up handling lowering of 8-lane 32-bit integer shuffles when AVX2
10825 /// isn't available.
10826 static SDValue lowerV8F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10827                                        const X86Subtarget *Subtarget,
10828                                        SelectionDAG &DAG) {
10829   SDLoc DL(Op);
10830   assert(V1.getSimpleValueType() == MVT::v8f32 && "Bad operand type!");
10831   assert(V2.getSimpleValueType() == MVT::v8f32 && "Bad operand type!");
10832   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10833   ArrayRef<int> Mask = SVOp->getMask();
10834   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
10835
10836   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8f32, V1, V2, Mask,
10837                                                 Subtarget, DAG))
10838     return Blend;
10839
10840   // Check for being able to broadcast a single element.
10841   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v8f32, DL, V1,
10842                                                         Mask, Subtarget, DAG))
10843     return Broadcast;
10844
10845   // If the shuffle mask is repeated in each 128-bit lane, we have many more
10846   // options to efficiently lower the shuffle.
10847   SmallVector<int, 4> RepeatedMask;
10848   if (is128BitLaneRepeatedShuffleMask(MVT::v8f32, Mask, RepeatedMask)) {
10849     assert(RepeatedMask.size() == 4 &&
10850            "Repeated masks must be half the mask width!");
10851
10852     // Use even/odd duplicate instructions for masks that match their pattern.
10853     if (isShuffleEquivalent(V1, V2, Mask, 0, 0, 2, 2, 4, 4, 6, 6))
10854       return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v8f32, V1);
10855     if (isShuffleEquivalent(V1, V2, Mask, 1, 1, 3, 3, 5, 5, 7, 7))
10856       return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v8f32, V1);
10857
10858     if (isSingleInputShuffleMask(Mask))
10859       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v8f32, V1,
10860                          getV4X86ShuffleImm8ForMask(RepeatedMask, DAG));
10861
10862     // Use dedicated unpack instructions for masks that match their pattern.
10863     if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 1, 9, 4, 12, 5, 13))
10864       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f32, V1, V2);
10865     if (isShuffleEquivalent(V1, V2, Mask, 2, 10, 3, 11, 6, 14, 7, 15))
10866       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f32, V1, V2);
10867     if (isShuffleEquivalent(V1, V2, Mask, 8, 0, 9, 1, 12, 4, 13, 5))
10868       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f32, V2, V1);
10869     if (isShuffleEquivalent(V1, V2, Mask, 10, 2, 11, 3, 14, 6, 15, 7))
10870       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f32, V2, V1);
10871
10872     // Otherwise, fall back to a SHUFPS sequence. Here it is important that we
10873     // have already handled any direct blends. We also need to squash the
10874     // repeated mask into a simulated v4f32 mask.
10875     for (int i = 0; i < 4; ++i)
10876       if (RepeatedMask[i] >= 8)
10877         RepeatedMask[i] -= 4;
10878     return lowerVectorShuffleWithSHUFPS(DL, MVT::v8f32, RepeatedMask, V1, V2, DAG);
10879   }
10880
10881   // If we have a single input shuffle with different shuffle patterns in the
10882   // two 128-bit lanes use the variable mask to VPERMILPS.
10883   if (isSingleInputShuffleMask(Mask)) {
10884     SDValue VPermMask[8];
10885     for (int i = 0; i < 8; ++i)
10886       VPermMask[i] = Mask[i] < 0 ? DAG.getUNDEF(MVT::i32)
10887                                  : DAG.getConstant(Mask[i], MVT::i32);
10888     if (!is128BitLaneCrossingShuffleMask(MVT::v8f32, Mask))
10889       return DAG.getNode(
10890           X86ISD::VPERMILPV, DL, MVT::v8f32, V1,
10891           DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v8i32, VPermMask));
10892
10893     if (Subtarget->hasAVX2())
10894       return DAG.getNode(X86ISD::VPERMV, DL, MVT::v8f32,
10895                          DAG.getNode(ISD::BITCAST, DL, MVT::v8f32,
10896                                      DAG.getNode(ISD::BUILD_VECTOR, DL,
10897                                                  MVT::v8i32, VPermMask)),
10898                          V1);
10899
10900     // Otherwise, fall back.
10901     return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v8f32, V1, V2, Mask,
10902                                                    DAG);
10903   }
10904
10905   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10906   // shuffle.
10907   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10908           DL, MVT::v8f32, V1, V2, Mask, Subtarget, DAG))
10909     return Result;
10910
10911   // If we have AVX2 then we always want to lower with a blend because at v8 we
10912   // can fully permute the elements.
10913   if (Subtarget->hasAVX2())
10914     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8f32, V1, V2,
10915                                                       Mask, DAG);
10916
10917   // Otherwise fall back on generic lowering.
10918   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v8f32, V1, V2, Mask, DAG);
10919 }
10920
10921 /// \brief Handle lowering of 8-lane 32-bit integer shuffles.
10922 ///
10923 /// This routine is only called when we have AVX2 and thus a reasonable
10924 /// instruction set for v8i32 shuffling..
10925 static SDValue lowerV8I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10926                                        const X86Subtarget *Subtarget,
10927                                        SelectionDAG &DAG) {
10928   SDLoc DL(Op);
10929   assert(V1.getSimpleValueType() == MVT::v8i32 && "Bad operand type!");
10930   assert(V2.getSimpleValueType() == MVT::v8i32 && "Bad operand type!");
10931   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10932   ArrayRef<int> Mask = SVOp->getMask();
10933   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
10934   assert(Subtarget->hasAVX2() && "We can only lower v8i32 with AVX2!");
10935
10936   // Whenever we can lower this as a zext, that instruction is strictly faster
10937   // than any alternative. It also allows us to fold memory operands into the
10938   // shuffle in many cases.
10939   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v8i32, V1, V2,
10940                                                          Mask, Subtarget, DAG))
10941     return ZExt;
10942
10943   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8i32, V1, V2, Mask,
10944                                                 Subtarget, DAG))
10945     return Blend;
10946
10947   // Check for being able to broadcast a single element.
10948   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v8i32, DL, V1,
10949                                                         Mask, Subtarget, DAG))
10950     return Broadcast;
10951
10952   // If the shuffle mask is repeated in each 128-bit lane we can use more
10953   // efficient instructions that mirror the shuffles across the two 128-bit
10954   // lanes.
10955   SmallVector<int, 4> RepeatedMask;
10956   if (is128BitLaneRepeatedShuffleMask(MVT::v8i32, Mask, RepeatedMask)) {
10957     assert(RepeatedMask.size() == 4 && "Unexpected repeated mask size!");
10958     if (isSingleInputShuffleMask(Mask))
10959       return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32, V1,
10960                          getV4X86ShuffleImm8ForMask(RepeatedMask, DAG));
10961
10962     // Use dedicated unpack instructions for masks that match their pattern.
10963     if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 1, 9, 4, 12, 5, 13))
10964       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i32, V1, V2);
10965     if (isShuffleEquivalent(V1, V2, Mask, 2, 10, 3, 11, 6, 14, 7, 15))
10966       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i32, V1, V2);
10967     if (isShuffleEquivalent(V1, V2, Mask, 8, 0, 9, 1, 12, 4, 13, 5))
10968       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i32, V2, V1);
10969     if (isShuffleEquivalent(V1, V2, Mask, 10, 2, 11, 3, 14, 6, 15, 7))
10970       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i32, V2, V1);
10971   }
10972
10973   // Try to use shift instructions.
10974   if (SDValue Shift =
10975           lowerVectorShuffleAsShift(DL, MVT::v8i32, V1, V2, Mask, DAG))
10976     return Shift;
10977
10978   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
10979           DL, MVT::v8i32, V1, V2, Mask, Subtarget, DAG))
10980     return Rotate;
10981
10982   // If the shuffle patterns aren't repeated but it is a single input, directly
10983   // generate a cross-lane VPERMD instruction.
10984   if (isSingleInputShuffleMask(Mask)) {
10985     SDValue VPermMask[8];
10986     for (int i = 0; i < 8; ++i)
10987       VPermMask[i] = Mask[i] < 0 ? DAG.getUNDEF(MVT::i32)
10988                                  : DAG.getConstant(Mask[i], MVT::i32);
10989     return DAG.getNode(
10990         X86ISD::VPERMV, DL, MVT::v8i32,
10991         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v8i32, VPermMask), V1);
10992   }
10993
10994   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10995   // shuffle.
10996   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10997           DL, MVT::v8i32, V1, V2, Mask, Subtarget, DAG))
10998     return Result;
10999
11000   // Otherwise fall back on generic blend lowering.
11001   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8i32, V1, V2,
11002                                                     Mask, DAG);
11003 }
11004
11005 /// \brief Handle lowering of 16-lane 16-bit integer shuffles.
11006 ///
11007 /// This routine is only called when we have AVX2 and thus a reasonable
11008 /// instruction set for v16i16 shuffling..
11009 static SDValue lowerV16I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11010                                         const X86Subtarget *Subtarget,
11011                                         SelectionDAG &DAG) {
11012   SDLoc DL(Op);
11013   assert(V1.getSimpleValueType() == MVT::v16i16 && "Bad operand type!");
11014   assert(V2.getSimpleValueType() == MVT::v16i16 && "Bad operand type!");
11015   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11016   ArrayRef<int> Mask = SVOp->getMask();
11017   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
11018   assert(Subtarget->hasAVX2() && "We can only lower v16i16 with AVX2!");
11019
11020   // Whenever we can lower this as a zext, that instruction is strictly faster
11021   // than any alternative. It also allows us to fold memory operands into the
11022   // shuffle in many cases.
11023   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v16i16, V1, V2,
11024                                                          Mask, Subtarget, DAG))
11025     return ZExt;
11026
11027   // Check for being able to broadcast a single element.
11028   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v16i16, DL, V1,
11029                                                         Mask, Subtarget, DAG))
11030     return Broadcast;
11031
11032   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v16i16, V1, V2, Mask,
11033                                                 Subtarget, DAG))
11034     return Blend;
11035
11036   // Use dedicated unpack instructions for masks that match their pattern.
11037   if (isShuffleEquivalent(V1, V2, Mask,
11038                           // First 128-bit lane:
11039                           0, 16, 1, 17, 2, 18, 3, 19,
11040                           // Second 128-bit lane:
11041                           8, 24, 9, 25, 10, 26, 11, 27))
11042     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i16, V1, V2);
11043   if (isShuffleEquivalent(V1, V2, Mask,
11044                           // First 128-bit lane:
11045                           4, 20, 5, 21, 6, 22, 7, 23,
11046                           // Second 128-bit lane:
11047                           12, 28, 13, 29, 14, 30, 15, 31))
11048     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i16, V1, V2);
11049
11050   // Try to use shift instructions.
11051   if (SDValue Shift =
11052           lowerVectorShuffleAsShift(DL, MVT::v16i16, V1, V2, Mask, DAG))
11053     return Shift;
11054
11055   // Try to use byte rotation instructions.
11056   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
11057           DL, MVT::v16i16, V1, V2, Mask, Subtarget, DAG))
11058     return Rotate;
11059
11060   if (isSingleInputShuffleMask(Mask)) {
11061     // There are no generalized cross-lane shuffle operations available on i16
11062     // element types.
11063     if (is128BitLaneCrossingShuffleMask(MVT::v16i16, Mask))
11064       return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v16i16, V1, V2,
11065                                                      Mask, DAG);
11066
11067     SDValue PSHUFBMask[32];
11068     for (int i = 0; i < 16; ++i) {
11069       if (Mask[i] == -1) {
11070         PSHUFBMask[2 * i] = PSHUFBMask[2 * i + 1] = DAG.getUNDEF(MVT::i8);
11071         continue;
11072       }
11073
11074       int M = i < 8 ? Mask[i] : Mask[i] - 8;
11075       assert(M >= 0 && M < 8 && "Invalid single-input mask!");
11076       PSHUFBMask[2 * i] = DAG.getConstant(2 * M, MVT::i8);
11077       PSHUFBMask[2 * i + 1] = DAG.getConstant(2 * M + 1, MVT::i8);
11078     }
11079     return DAG.getNode(
11080         ISD::BITCAST, DL, MVT::v16i16,
11081         DAG.getNode(
11082             X86ISD::PSHUFB, DL, MVT::v32i8,
11083             DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, V1),
11084             DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, PSHUFBMask)));
11085   }
11086
11087   // Try to simplify this by merging 128-bit lanes to enable a lane-based
11088   // shuffle.
11089   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
11090           DL, MVT::v16i16, V1, V2, Mask, Subtarget, DAG))
11091     return Result;
11092
11093   // Otherwise fall back on generic lowering.
11094   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v16i16, V1, V2, Mask, DAG);
11095 }
11096
11097 /// \brief Handle lowering of 32-lane 8-bit integer shuffles.
11098 ///
11099 /// This routine is only called when we have AVX2 and thus a reasonable
11100 /// instruction set for v32i8 shuffling..
11101 static SDValue lowerV32I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11102                                        const X86Subtarget *Subtarget,
11103                                        SelectionDAG &DAG) {
11104   SDLoc DL(Op);
11105   assert(V1.getSimpleValueType() == MVT::v32i8 && "Bad operand type!");
11106   assert(V2.getSimpleValueType() == MVT::v32i8 && "Bad operand type!");
11107   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11108   ArrayRef<int> Mask = SVOp->getMask();
11109   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
11110   assert(Subtarget->hasAVX2() && "We can only lower v32i8 with AVX2!");
11111
11112   // Whenever we can lower this as a zext, that instruction is strictly faster
11113   // than any alternative. It also allows us to fold memory operands into the
11114   // shuffle in many cases.
11115   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v32i8, V1, V2,
11116                                                          Mask, Subtarget, DAG))
11117     return ZExt;
11118
11119   // Check for being able to broadcast a single element.
11120   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v32i8, DL, V1,
11121                                                         Mask, Subtarget, DAG))
11122     return Broadcast;
11123
11124   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v32i8, V1, V2, Mask,
11125                                                 Subtarget, DAG))
11126     return Blend;
11127
11128   // Use dedicated unpack instructions for masks that match their pattern.
11129   // Note that these are repeated 128-bit lane unpacks, not unpacks across all
11130   // 256-bit lanes.
11131   if (isShuffleEquivalent(
11132           V1, V2, Mask,
11133           // First 128-bit lane:
11134           0, 32, 1, 33, 2, 34, 3, 35, 4, 36, 5, 37, 6, 38, 7, 39,
11135           // Second 128-bit lane:
11136           16, 48, 17, 49, 18, 50, 19, 51, 20, 52, 21, 53, 22, 54, 23, 55))
11137     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v32i8, V1, V2);
11138   if (isShuffleEquivalent(
11139           V1, V2, Mask,
11140           // First 128-bit lane:
11141           8, 40, 9, 41, 10, 42, 11, 43, 12, 44, 13, 45, 14, 46, 15, 47,
11142           // Second 128-bit lane:
11143           24, 56, 25, 57, 26, 58, 27, 59, 28, 60, 29, 61, 30, 62, 31, 63))
11144     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v32i8, V1, V2);
11145
11146   // Try to use shift instructions.
11147   if (SDValue Shift =
11148           lowerVectorShuffleAsShift(DL, MVT::v32i8, V1, V2, Mask, DAG))
11149     return Shift;
11150
11151   // Try to use byte rotation instructions.
11152   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
11153           DL, MVT::v32i8, V1, V2, Mask, Subtarget, DAG))
11154     return Rotate;
11155
11156   if (isSingleInputShuffleMask(Mask)) {
11157     // There are no generalized cross-lane shuffle operations available on i8
11158     // element types.
11159     if (is128BitLaneCrossingShuffleMask(MVT::v32i8, Mask))
11160       return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v32i8, V1, V2,
11161                                                      Mask, DAG);
11162
11163     SDValue PSHUFBMask[32];
11164     for (int i = 0; i < 32; ++i)
11165       PSHUFBMask[i] =
11166           Mask[i] < 0
11167               ? DAG.getUNDEF(MVT::i8)
11168               : DAG.getConstant(Mask[i] < 16 ? Mask[i] : Mask[i] - 16, MVT::i8);
11169
11170     return DAG.getNode(
11171         X86ISD::PSHUFB, DL, MVT::v32i8, V1,
11172         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, PSHUFBMask));
11173   }
11174
11175   // Try to simplify this by merging 128-bit lanes to enable a lane-based
11176   // shuffle.
11177   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
11178           DL, MVT::v32i8, V1, V2, Mask, Subtarget, DAG))
11179     return Result;
11180
11181   // Otherwise fall back on generic lowering.
11182   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v32i8, V1, V2, Mask, DAG);
11183 }
11184
11185 /// \brief High-level routine to lower various 256-bit x86 vector shuffles.
11186 ///
11187 /// This routine either breaks down the specific type of a 256-bit x86 vector
11188 /// shuffle or splits it into two 128-bit shuffles and fuses the results back
11189 /// together based on the available instructions.
11190 static SDValue lower256BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11191                                         MVT VT, const X86Subtarget *Subtarget,
11192                                         SelectionDAG &DAG) {
11193   SDLoc DL(Op);
11194   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11195   ArrayRef<int> Mask = SVOp->getMask();
11196
11197   // There is a really nice hard cut-over between AVX1 and AVX2 that means we can
11198   // check for those subtargets here and avoid much of the subtarget querying in
11199   // the per-vector-type lowering routines. With AVX1 we have essentially *zero*
11200   // ability to manipulate a 256-bit vector with integer types. Since we'll use
11201   // floating point types there eventually, just immediately cast everything to
11202   // a float and operate entirely in that domain.
11203   if (VT.isInteger() && !Subtarget->hasAVX2()) {
11204     int ElementBits = VT.getScalarSizeInBits();
11205     if (ElementBits < 32)
11206       // No floating point type available, decompose into 128-bit vectors.
11207       return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
11208
11209     MVT FpVT = MVT::getVectorVT(MVT::getFloatingPointVT(ElementBits),
11210                                 VT.getVectorNumElements());
11211     V1 = DAG.getNode(ISD::BITCAST, DL, FpVT, V1);
11212     V2 = DAG.getNode(ISD::BITCAST, DL, FpVT, V2);
11213     return DAG.getNode(ISD::BITCAST, DL, VT,
11214                        DAG.getVectorShuffle(FpVT, DL, V1, V2, Mask));
11215   }
11216
11217   switch (VT.SimpleTy) {
11218   case MVT::v4f64:
11219     return lowerV4F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
11220   case MVT::v4i64:
11221     return lowerV4I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
11222   case MVT::v8f32:
11223     return lowerV8F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
11224   case MVT::v8i32:
11225     return lowerV8I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
11226   case MVT::v16i16:
11227     return lowerV16I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
11228   case MVT::v32i8:
11229     return lowerV32I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
11230
11231   default:
11232     llvm_unreachable("Not a valid 256-bit x86 vector type!");
11233   }
11234 }
11235
11236 /// \brief Handle lowering of 8-lane 64-bit floating point shuffles.
11237 static SDValue lowerV8F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11238                                        const X86Subtarget *Subtarget,
11239                                        SelectionDAG &DAG) {
11240   SDLoc DL(Op);
11241   assert(V1.getSimpleValueType() == MVT::v8f64 && "Bad operand type!");
11242   assert(V2.getSimpleValueType() == MVT::v8f64 && "Bad operand type!");
11243   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11244   ArrayRef<int> Mask = SVOp->getMask();
11245   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
11246
11247   // X86 has dedicated unpack instructions that can handle specific blend
11248   // operations: UNPCKH and UNPCKL.
11249   if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 2, 10, 4, 12, 6, 14))
11250     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f64, V1, V2);
11251   if (isShuffleEquivalent(V1, V2, Mask, 1, 9, 3, 11, 5, 13, 7, 15))
11252     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f64, V1, V2);
11253
11254   // FIXME: Implement direct support for this type!
11255   return splitAndLowerVectorShuffle(DL, MVT::v8f64, V1, V2, Mask, DAG);
11256 }
11257
11258 /// \brief Handle lowering of 16-lane 32-bit floating point shuffles.
11259 static SDValue lowerV16F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11260                                        const X86Subtarget *Subtarget,
11261                                        SelectionDAG &DAG) {
11262   SDLoc DL(Op);
11263   assert(V1.getSimpleValueType() == MVT::v16f32 && "Bad operand type!");
11264   assert(V2.getSimpleValueType() == MVT::v16f32 && "Bad operand type!");
11265   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11266   ArrayRef<int> Mask = SVOp->getMask();
11267   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
11268
11269   // Use dedicated unpack instructions for masks that match their pattern.
11270   if (isShuffleEquivalent(V1, V2, Mask,
11271                           0, 16, 1, 17, 4, 20, 5, 21,
11272                           8, 24, 9, 25, 12, 28, 13, 29))
11273     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16f32, V1, V2);
11274   if (isShuffleEquivalent(V1, V2, Mask,
11275                           2, 18, 3, 19, 6, 22, 7, 23,
11276                           10, 26, 11, 27, 14, 30, 15, 31))
11277     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16f32, V1, V2);
11278
11279   // FIXME: Implement direct support for this type!
11280   return splitAndLowerVectorShuffle(DL, MVT::v16f32, V1, V2, Mask, DAG);
11281 }
11282
11283 /// \brief Handle lowering of 8-lane 64-bit integer shuffles.
11284 static SDValue lowerV8I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11285                                        const X86Subtarget *Subtarget,
11286                                        SelectionDAG &DAG) {
11287   SDLoc DL(Op);
11288   assert(V1.getSimpleValueType() == MVT::v8i64 && "Bad operand type!");
11289   assert(V2.getSimpleValueType() == MVT::v8i64 && "Bad operand type!");
11290   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11291   ArrayRef<int> Mask = SVOp->getMask();
11292   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
11293
11294   // X86 has dedicated unpack instructions that can handle specific blend
11295   // operations: UNPCKH and UNPCKL.
11296   if (isShuffleEquivalent(V1, V2, Mask, 0, 8, 2, 10, 4, 12, 6, 14))
11297     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i64, V1, V2);
11298   if (isShuffleEquivalent(V1, V2, Mask, 1, 9, 3, 11, 5, 13, 7, 15))
11299     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i64, V1, V2);
11300
11301   // FIXME: Implement direct support for this type!
11302   return splitAndLowerVectorShuffle(DL, MVT::v8i64, V1, V2, Mask, DAG);
11303 }
11304
11305 /// \brief Handle lowering of 16-lane 32-bit integer shuffles.
11306 static SDValue lowerV16I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11307                                        const X86Subtarget *Subtarget,
11308                                        SelectionDAG &DAG) {
11309   SDLoc DL(Op);
11310   assert(V1.getSimpleValueType() == MVT::v16i32 && "Bad operand type!");
11311   assert(V2.getSimpleValueType() == MVT::v16i32 && "Bad operand type!");
11312   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11313   ArrayRef<int> Mask = SVOp->getMask();
11314   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
11315
11316   // Use dedicated unpack instructions for masks that match their pattern.
11317   if (isShuffleEquivalent(V1, V2, Mask,
11318                           0, 16, 1, 17, 4, 20, 5, 21,
11319                           8, 24, 9, 25, 12, 28, 13, 29))
11320     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i32, V1, V2);
11321   if (isShuffleEquivalent(V1, V2, Mask,
11322                           2, 18, 3, 19, 6, 22, 7, 23,
11323                           10, 26, 11, 27, 14, 30, 15, 31))
11324     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i32, V1, V2);
11325
11326   // FIXME: Implement direct support for this type!
11327   return splitAndLowerVectorShuffle(DL, MVT::v16i32, V1, V2, Mask, DAG);
11328 }
11329
11330 /// \brief Handle lowering of 32-lane 16-bit integer shuffles.
11331 static SDValue lowerV32I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11332                                         const X86Subtarget *Subtarget,
11333                                         SelectionDAG &DAG) {
11334   SDLoc DL(Op);
11335   assert(V1.getSimpleValueType() == MVT::v32i16 && "Bad operand type!");
11336   assert(V2.getSimpleValueType() == MVT::v32i16 && "Bad operand type!");
11337   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11338   ArrayRef<int> Mask = SVOp->getMask();
11339   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
11340   assert(Subtarget->hasBWI() && "We can only lower v32i16 with AVX-512-BWI!");
11341
11342   // FIXME: Implement direct support for this type!
11343   return splitAndLowerVectorShuffle(DL, MVT::v32i16, V1, V2, Mask, DAG);
11344 }
11345
11346 /// \brief Handle lowering of 64-lane 8-bit integer shuffles.
11347 static SDValue lowerV64I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11348                                        const X86Subtarget *Subtarget,
11349                                        SelectionDAG &DAG) {
11350   SDLoc DL(Op);
11351   assert(V1.getSimpleValueType() == MVT::v64i8 && "Bad operand type!");
11352   assert(V2.getSimpleValueType() == MVT::v64i8 && "Bad operand type!");
11353   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11354   ArrayRef<int> Mask = SVOp->getMask();
11355   assert(Mask.size() == 64 && "Unexpected mask size for v64 shuffle!");
11356   assert(Subtarget->hasBWI() && "We can only lower v64i8 with AVX-512-BWI!");
11357
11358   // FIXME: Implement direct support for this type!
11359   return splitAndLowerVectorShuffle(DL, MVT::v64i8, V1, V2, Mask, DAG);
11360 }
11361
11362 /// \brief High-level routine to lower various 512-bit x86 vector shuffles.
11363 ///
11364 /// This routine either breaks down the specific type of a 512-bit x86 vector
11365 /// shuffle or splits it into two 256-bit shuffles and fuses the results back
11366 /// together based on the available instructions.
11367 static SDValue lower512BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
11368                                         MVT VT, const X86Subtarget *Subtarget,
11369                                         SelectionDAG &DAG) {
11370   SDLoc DL(Op);
11371   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11372   ArrayRef<int> Mask = SVOp->getMask();
11373   assert(Subtarget->hasAVX512() &&
11374          "Cannot lower 512-bit vectors w/ basic ISA!");
11375
11376   // Check for being able to broadcast a single element.
11377   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(VT.SimpleTy, DL, V1,
11378                                                         Mask, Subtarget, DAG))
11379     return Broadcast;
11380
11381   // Dispatch to each element type for lowering. If we don't have supprot for
11382   // specific element type shuffles at 512 bits, immediately split them and
11383   // lower them. Each lowering routine of a given type is allowed to assume that
11384   // the requisite ISA extensions for that element type are available.
11385   switch (VT.SimpleTy) {
11386   case MVT::v8f64:
11387     return lowerV8F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
11388   case MVT::v16f32:
11389     return lowerV16F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
11390   case MVT::v8i64:
11391     return lowerV8I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
11392   case MVT::v16i32:
11393     return lowerV16I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
11394   case MVT::v32i16:
11395     if (Subtarget->hasBWI())
11396       return lowerV32I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
11397     break;
11398   case MVT::v64i8:
11399     if (Subtarget->hasBWI())
11400       return lowerV64I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
11401     break;
11402
11403   default:
11404     llvm_unreachable("Not a valid 512-bit x86 vector type!");
11405   }
11406
11407   // Otherwise fall back on splitting.
11408   return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
11409 }
11410
11411 /// \brief Top-level lowering for x86 vector shuffles.
11412 ///
11413 /// This handles decomposition, canonicalization, and lowering of all x86
11414 /// vector shuffles. Most of the specific lowering strategies are encapsulated
11415 /// above in helper routines. The canonicalization attempts to widen shuffles
11416 /// to involve fewer lanes of wider elements, consolidate symmetric patterns
11417 /// s.t. only one of the two inputs needs to be tested, etc.
11418 static SDValue lowerVectorShuffle(SDValue Op, const X86Subtarget *Subtarget,
11419                                   SelectionDAG &DAG) {
11420   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11421   ArrayRef<int> Mask = SVOp->getMask();
11422   SDValue V1 = Op.getOperand(0);
11423   SDValue V2 = Op.getOperand(1);
11424   MVT VT = Op.getSimpleValueType();
11425   int NumElements = VT.getVectorNumElements();
11426   SDLoc dl(Op);
11427
11428   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
11429
11430   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
11431   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
11432   if (V1IsUndef && V2IsUndef)
11433     return DAG.getUNDEF(VT);
11434
11435   // When we create a shuffle node we put the UNDEF node to second operand,
11436   // but in some cases the first operand may be transformed to UNDEF.
11437   // In this case we should just commute the node.
11438   if (V1IsUndef)
11439     return DAG.getCommutedVectorShuffle(*SVOp);
11440
11441   // Check for non-undef masks pointing at an undef vector and make the masks
11442   // undef as well. This makes it easier to match the shuffle based solely on
11443   // the mask.
11444   if (V2IsUndef)
11445     for (int M : Mask)
11446       if (M >= NumElements) {
11447         SmallVector<int, 8> NewMask(Mask.begin(), Mask.end());
11448         for (int &M : NewMask)
11449           if (M >= NumElements)
11450             M = -1;
11451         return DAG.getVectorShuffle(VT, dl, V1, V2, NewMask);
11452       }
11453
11454   // We actually see shuffles that are entirely re-arrangements of a set of
11455   // zero inputs. This mostly happens while decomposing complex shuffles into
11456   // simple ones. Directly lower these as a buildvector of zeros.
11457   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
11458   if (Zeroable.all())
11459     return getZeroVector(VT, Subtarget, DAG, dl);
11460
11461   // Try to collapse shuffles into using a vector type with fewer elements but
11462   // wider element types. We cap this to not form integers or floating point
11463   // elements wider than 64 bits, but it might be interesting to form i128
11464   // integers to handle flipping the low and high halves of AVX 256-bit vectors.
11465   SmallVector<int, 16> WidenedMask;
11466   if (VT.getScalarSizeInBits() < 64 &&
11467       canWidenShuffleElements(Mask, WidenedMask)) {
11468     MVT NewEltVT = VT.isFloatingPoint()
11469                        ? MVT::getFloatingPointVT(VT.getScalarSizeInBits() * 2)
11470                        : MVT::getIntegerVT(VT.getScalarSizeInBits() * 2);
11471     MVT NewVT = MVT::getVectorVT(NewEltVT, VT.getVectorNumElements() / 2);
11472     // Make sure that the new vector type is legal. For example, v2f64 isn't
11473     // legal on SSE1.
11474     if (DAG.getTargetLoweringInfo().isTypeLegal(NewVT)) {
11475       V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, V1);
11476       V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, V2);
11477       return DAG.getNode(ISD::BITCAST, dl, VT,
11478                          DAG.getVectorShuffle(NewVT, dl, V1, V2, WidenedMask));
11479     }
11480   }
11481
11482   int NumV1Elements = 0, NumUndefElements = 0, NumV2Elements = 0;
11483   for (int M : SVOp->getMask())
11484     if (M < 0)
11485       ++NumUndefElements;
11486     else if (M < NumElements)
11487       ++NumV1Elements;
11488     else
11489       ++NumV2Elements;
11490
11491   // Commute the shuffle as needed such that more elements come from V1 than
11492   // V2. This allows us to match the shuffle pattern strictly on how many
11493   // elements come from V1 without handling the symmetric cases.
11494   if (NumV2Elements > NumV1Elements)
11495     return DAG.getCommutedVectorShuffle(*SVOp);
11496
11497   // When the number of V1 and V2 elements are the same, try to minimize the
11498   // number of uses of V2 in the low half of the vector. When that is tied,
11499   // ensure that the sum of indices for V1 is equal to or lower than the sum
11500   // indices for V2. When those are equal, try to ensure that the number of odd
11501   // indices for V1 is lower than the number of odd indices for V2.
11502   if (NumV1Elements == NumV2Elements) {
11503     int LowV1Elements = 0, LowV2Elements = 0;
11504     for (int M : SVOp->getMask().slice(0, NumElements / 2))
11505       if (M >= NumElements)
11506         ++LowV2Elements;
11507       else if (M >= 0)
11508         ++LowV1Elements;
11509     if (LowV2Elements > LowV1Elements) {
11510       return DAG.getCommutedVectorShuffle(*SVOp);
11511     } else if (LowV2Elements == LowV1Elements) {
11512       int SumV1Indices = 0, SumV2Indices = 0;
11513       for (int i = 0, Size = SVOp->getMask().size(); i < Size; ++i)
11514         if (SVOp->getMask()[i] >= NumElements)
11515           SumV2Indices += i;
11516         else if (SVOp->getMask()[i] >= 0)
11517           SumV1Indices += i;
11518       if (SumV2Indices < SumV1Indices) {
11519         return DAG.getCommutedVectorShuffle(*SVOp);
11520       } else if (SumV2Indices == SumV1Indices) {
11521         int NumV1OddIndices = 0, NumV2OddIndices = 0;
11522         for (int i = 0, Size = SVOp->getMask().size(); i < Size; ++i)
11523           if (SVOp->getMask()[i] >= NumElements)
11524             NumV2OddIndices += i % 2;
11525           else if (SVOp->getMask()[i] >= 0)
11526             NumV1OddIndices += i % 2;
11527         if (NumV2OddIndices < NumV1OddIndices)
11528           return DAG.getCommutedVectorShuffle(*SVOp);
11529       }
11530     }
11531   }
11532
11533   // For each vector width, delegate to a specialized lowering routine.
11534   if (VT.getSizeInBits() == 128)
11535     return lower128BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11536
11537   if (VT.getSizeInBits() == 256)
11538     return lower256BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11539
11540   // Force AVX-512 vectors to be scalarized for now.
11541   // FIXME: Implement AVX-512 support!
11542   if (VT.getSizeInBits() == 512)
11543     return lower512BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11544
11545   llvm_unreachable("Unimplemented!");
11546 }
11547
11548
11549 //===----------------------------------------------------------------------===//
11550 // Legacy vector shuffle lowering
11551 //
11552 // This code is the legacy code handling vector shuffles until the above
11553 // replaces its functionality and performance.
11554 //===----------------------------------------------------------------------===//
11555
11556 static bool isBlendMask(ArrayRef<int> MaskVals, MVT VT, bool hasSSE41,
11557                         bool hasInt256, unsigned *MaskOut = nullptr) {
11558   MVT EltVT = VT.getVectorElementType();
11559
11560   // There is no blend with immediate in AVX-512.
11561   if (VT.is512BitVector())
11562     return false;
11563
11564   if (!hasSSE41 || EltVT == MVT::i8)
11565     return false;
11566   if (!hasInt256 && VT == MVT::v16i16)
11567     return false;
11568
11569   unsigned MaskValue = 0;
11570   unsigned NumElems = VT.getVectorNumElements();
11571   // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
11572   unsigned NumLanes = (NumElems - 1) / 8 + 1;
11573   unsigned NumElemsInLane = NumElems / NumLanes;
11574
11575   // Blend for v16i16 should be symmetric for both lanes.
11576   for (unsigned i = 0; i < NumElemsInLane; ++i) {
11577
11578     int SndLaneEltIdx = (NumLanes == 2) ? MaskVals[i + NumElemsInLane] : -1;
11579     int EltIdx = MaskVals[i];
11580
11581     if ((EltIdx < 0 || EltIdx == (int)i) &&
11582         (SndLaneEltIdx < 0 || SndLaneEltIdx == (int)(i + NumElemsInLane)))
11583       continue;
11584
11585     if (((unsigned)EltIdx == (i + NumElems)) &&
11586         (SndLaneEltIdx < 0 ||
11587          (unsigned)SndLaneEltIdx == i + NumElems + NumElemsInLane))
11588       MaskValue |= (1 << i);
11589     else
11590       return false;
11591   }
11592
11593   if (MaskOut)
11594     *MaskOut = MaskValue;
11595   return true;
11596 }
11597
11598 // Try to lower a shuffle node into a simple blend instruction.
11599 // This function assumes isBlendMask returns true for this
11600 // SuffleVectorSDNode
11601 static SDValue LowerVECTOR_SHUFFLEtoBlend(ShuffleVectorSDNode *SVOp,
11602                                           unsigned MaskValue,
11603                                           const X86Subtarget *Subtarget,
11604                                           SelectionDAG &DAG) {
11605   MVT VT = SVOp->getSimpleValueType(0);
11606   MVT EltVT = VT.getVectorElementType();
11607   assert(isBlendMask(SVOp->getMask(), VT, Subtarget->hasSSE41(),
11608                      Subtarget->hasInt256() && "Trying to lower a "
11609                                                "VECTOR_SHUFFLE to a Blend but "
11610                                                "with the wrong mask"));
11611   SDValue V1 = SVOp->getOperand(0);
11612   SDValue V2 = SVOp->getOperand(1);
11613   SDLoc dl(SVOp);
11614   unsigned NumElems = VT.getVectorNumElements();
11615
11616   // Convert i32 vectors to floating point if it is not AVX2.
11617   // AVX2 introduced VPBLENDD instruction for 128 and 256-bit vectors.
11618   MVT BlendVT = VT;
11619   if (EltVT == MVT::i64 || (EltVT == MVT::i32 && !Subtarget->hasInt256())) {
11620     BlendVT = MVT::getVectorVT(MVT::getFloatingPointVT(EltVT.getSizeInBits()),
11621                                NumElems);
11622     V1 = DAG.getNode(ISD::BITCAST, dl, VT, V1);
11623     V2 = DAG.getNode(ISD::BITCAST, dl, VT, V2);
11624   }
11625
11626   SDValue Ret = DAG.getNode(X86ISD::BLENDI, dl, BlendVT, V1, V2,
11627                             DAG.getConstant(MaskValue, MVT::i32));
11628   return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
11629 }
11630
11631 /// In vector type \p VT, return true if the element at index \p InputIdx
11632 /// falls on a different 128-bit lane than \p OutputIdx.
11633 static bool ShuffleCrosses128bitLane(MVT VT, unsigned InputIdx,
11634                                      unsigned OutputIdx) {
11635   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
11636   return InputIdx * EltSize / 128 != OutputIdx * EltSize / 128;
11637 }
11638
11639 /// Generate a PSHUFB if possible.  Selects elements from \p V1 according to
11640 /// \p MaskVals.  MaskVals[OutputIdx] = InputIdx specifies that we want to
11641 /// shuffle the element at InputIdx in V1 to OutputIdx in the result.  If \p
11642 /// MaskVals refers to elements outside of \p V1 or is undef (-1), insert a
11643 /// zero.
11644 static SDValue getPSHUFB(ArrayRef<int> MaskVals, SDValue V1, SDLoc &dl,
11645                          SelectionDAG &DAG) {
11646   MVT VT = V1.getSimpleValueType();
11647   assert(VT.is128BitVector() || VT.is256BitVector());
11648
11649   MVT EltVT = VT.getVectorElementType();
11650   unsigned EltSizeInBytes = EltVT.getSizeInBits() / 8;
11651   unsigned NumElts = VT.getVectorNumElements();
11652
11653   SmallVector<SDValue, 32> PshufbMask;
11654   for (unsigned OutputIdx = 0; OutputIdx < NumElts; ++OutputIdx) {
11655     int InputIdx = MaskVals[OutputIdx];
11656     unsigned InputByteIdx;
11657
11658     if (InputIdx < 0 || NumElts <= (unsigned)InputIdx)
11659       InputByteIdx = 0x80;
11660     else {
11661       // Cross lane is not allowed.
11662       if (ShuffleCrosses128bitLane(VT, InputIdx, OutputIdx))
11663         return SDValue();
11664       InputByteIdx = InputIdx * EltSizeInBytes;
11665       // Index is an byte offset within the 128-bit lane.
11666       InputByteIdx &= 0xf;
11667     }
11668
11669     for (unsigned j = 0; j < EltSizeInBytes; ++j) {
11670       PshufbMask.push_back(DAG.getConstant(InputByteIdx, MVT::i8));
11671       if (InputByteIdx != 0x80)
11672         ++InputByteIdx;
11673     }
11674   }
11675
11676   MVT ShufVT = MVT::getVectorVT(MVT::i8, PshufbMask.size());
11677   if (ShufVT != VT)
11678     V1 = DAG.getNode(ISD::BITCAST, dl, ShufVT, V1);
11679   return DAG.getNode(X86ISD::PSHUFB, dl, ShufVT, V1,
11680                      DAG.getNode(ISD::BUILD_VECTOR, dl, ShufVT, PshufbMask));
11681 }
11682
11683 // v8i16 shuffles - Prefer shuffles in the following order:
11684 // 1. [all]   pshuflw, pshufhw, optional move
11685 // 2. [ssse3] 1 x pshufb
11686 // 3. [ssse3] 2 x pshufb + 1 x por
11687 // 4. [all]   mov + pshuflw + pshufhw + N x (pextrw + pinsrw)
11688 static SDValue
11689 LowerVECTOR_SHUFFLEv8i16(SDValue Op, const X86Subtarget *Subtarget,
11690                          SelectionDAG &DAG) {
11691   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11692   SDValue V1 = SVOp->getOperand(0);
11693   SDValue V2 = SVOp->getOperand(1);
11694   SDLoc dl(SVOp);
11695   SmallVector<int, 8> MaskVals;
11696
11697   // Determine if more than 1 of the words in each of the low and high quadwords
11698   // of the result come from the same quadword of one of the two inputs.  Undef
11699   // mask values count as coming from any quadword, for better codegen.
11700   //
11701   // Lo/HiQuad[i] = j indicates how many words from the ith quad of the input
11702   // feeds this quad.  For i, 0 and 1 refer to V1, 2 and 3 refer to V2.
11703   unsigned LoQuad[] = { 0, 0, 0, 0 };
11704   unsigned HiQuad[] = { 0, 0, 0, 0 };
11705   // Indices of quads used.
11706   std::bitset<4> InputQuads;
11707   for (unsigned i = 0; i < 8; ++i) {
11708     unsigned *Quad = i < 4 ? LoQuad : HiQuad;
11709     int EltIdx = SVOp->getMaskElt(i);
11710     MaskVals.push_back(EltIdx);
11711     if (EltIdx < 0) {
11712       ++Quad[0];
11713       ++Quad[1];
11714       ++Quad[2];
11715       ++Quad[3];
11716       continue;
11717     }
11718     ++Quad[EltIdx / 4];
11719     InputQuads.set(EltIdx / 4);
11720   }
11721
11722   int BestLoQuad = -1;
11723   unsigned MaxQuad = 1;
11724   for (unsigned i = 0; i < 4; ++i) {
11725     if (LoQuad[i] > MaxQuad) {
11726       BestLoQuad = i;
11727       MaxQuad = LoQuad[i];
11728     }
11729   }
11730
11731   int BestHiQuad = -1;
11732   MaxQuad = 1;
11733   for (unsigned i = 0; i < 4; ++i) {
11734     if (HiQuad[i] > MaxQuad) {
11735       BestHiQuad = i;
11736       MaxQuad = HiQuad[i];
11737     }
11738   }
11739
11740   // For SSSE3, If all 8 words of the result come from only 1 quadword of each
11741   // of the two input vectors, shuffle them into one input vector so only a
11742   // single pshufb instruction is necessary. If there are more than 2 input
11743   // quads, disable the next transformation since it does not help SSSE3.
11744   bool V1Used = InputQuads[0] || InputQuads[1];
11745   bool V2Used = InputQuads[2] || InputQuads[3];
11746   if (Subtarget->hasSSSE3()) {
11747     if (InputQuads.count() == 2 && V1Used && V2Used) {
11748       BestLoQuad = InputQuads[0] ? 0 : 1;
11749       BestHiQuad = InputQuads[2] ? 2 : 3;
11750     }
11751     if (InputQuads.count() > 2) {
11752       BestLoQuad = -1;
11753       BestHiQuad = -1;
11754     }
11755   }
11756
11757   // If BestLoQuad or BestHiQuad are set, shuffle the quads together and update
11758   // the shuffle mask.  If a quad is scored as -1, that means that it contains
11759   // words from all 4 input quadwords.
11760   SDValue NewV;
11761   if (BestLoQuad >= 0 || BestHiQuad >= 0) {
11762     int MaskV[] = {
11763       BestLoQuad < 0 ? 0 : BestLoQuad,
11764       BestHiQuad < 0 ? 1 : BestHiQuad
11765     };
11766     NewV = DAG.getVectorShuffle(MVT::v2i64, dl,
11767                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1),
11768                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2), &MaskV[0]);
11769     NewV = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, NewV);
11770
11771     // Rewrite the MaskVals and assign NewV to V1 if NewV now contains all the
11772     // source words for the shuffle, to aid later transformations.
11773     bool AllWordsInNewV = true;
11774     bool InOrder[2] = { true, true };
11775     for (unsigned i = 0; i != 8; ++i) {
11776       int idx = MaskVals[i];
11777       if (idx != (int)i)
11778         InOrder[i/4] = false;
11779       if (idx < 0 || (idx/4) == BestLoQuad || (idx/4) == BestHiQuad)
11780         continue;
11781       AllWordsInNewV = false;
11782       break;
11783     }
11784
11785     bool pshuflw = AllWordsInNewV, pshufhw = AllWordsInNewV;
11786     if (AllWordsInNewV) {
11787       for (int i = 0; i != 8; ++i) {
11788         int idx = MaskVals[i];
11789         if (idx < 0)
11790           continue;
11791         idx = MaskVals[i] = (idx / 4) == BestLoQuad ? (idx & 3) : (idx & 3) + 4;
11792         if ((idx != i) && idx < 4)
11793           pshufhw = false;
11794         if ((idx != i) && idx > 3)
11795           pshuflw = false;
11796       }
11797       V1 = NewV;
11798       V2Used = false;
11799       BestLoQuad = 0;
11800       BestHiQuad = 1;
11801     }
11802
11803     // If we've eliminated the use of V2, and the new mask is a pshuflw or
11804     // pshufhw, that's as cheap as it gets.  Return the new shuffle.
11805     if ((pshufhw && InOrder[0]) || (pshuflw && InOrder[1])) {
11806       unsigned Opc = pshufhw ? X86ISD::PSHUFHW : X86ISD::PSHUFLW;
11807       unsigned TargetMask = 0;
11808       NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV,
11809                                   DAG.getUNDEF(MVT::v8i16), &MaskVals[0]);
11810       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11811       TargetMask = pshufhw ? getShufflePSHUFHWImmediate(SVOp):
11812                              getShufflePSHUFLWImmediate(SVOp);
11813       V1 = NewV.getOperand(0);
11814       return getTargetShuffleNode(Opc, dl, MVT::v8i16, V1, TargetMask, DAG);
11815     }
11816   }
11817
11818   // Promote splats to a larger type which usually leads to more efficient code.
11819   // FIXME: Is this true if pshufb is available?
11820   if (SVOp->isSplat())
11821     return PromoteSplat(SVOp, DAG);
11822
11823   // If we have SSSE3, and all words of the result are from 1 input vector,
11824   // case 2 is generated, otherwise case 3 is generated.  If no SSSE3
11825   // is present, fall back to case 4.
11826   if (Subtarget->hasSSSE3()) {
11827     SmallVector<SDValue,16> pshufbMask;
11828
11829     // If we have elements from both input vectors, set the high bit of the
11830     // shuffle mask element to zero out elements that come from V2 in the V1
11831     // mask, and elements that come from V1 in the V2 mask, so that the two
11832     // results can be OR'd together.
11833     bool TwoInputs = V1Used && V2Used;
11834     V1 = getPSHUFB(MaskVals, V1, dl, DAG);
11835     if (!TwoInputs)
11836       return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
11837
11838     // Calculate the shuffle mask for the second input, shuffle it, and
11839     // OR it with the first shuffled input.
11840     CommuteVectorShuffleMask(MaskVals, 8);
11841     V2 = getPSHUFB(MaskVals, V2, dl, DAG);
11842     V1 = DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
11843     return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
11844   }
11845
11846   // If BestLoQuad >= 0, generate a pshuflw to put the low elements in order,
11847   // and update MaskVals with new element order.
11848   std::bitset<8> InOrder;
11849   if (BestLoQuad >= 0) {
11850     int MaskV[] = { -1, -1, -1, -1, 4, 5, 6, 7 };
11851     for (int i = 0; i != 4; ++i) {
11852       int idx = MaskVals[i];
11853       if (idx < 0) {
11854         InOrder.set(i);
11855       } else if ((idx / 4) == BestLoQuad) {
11856         MaskV[i] = idx & 3;
11857         InOrder.set(i);
11858       }
11859     }
11860     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
11861                                 &MaskV[0]);
11862
11863     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSE2()) {
11864       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11865       NewV = getTargetShuffleNode(X86ISD::PSHUFLW, dl, MVT::v8i16,
11866                                   NewV.getOperand(0),
11867                                   getShufflePSHUFLWImmediate(SVOp), DAG);
11868     }
11869   }
11870
11871   // If BestHi >= 0, generate a pshufhw to put the high elements in order,
11872   // and update MaskVals with the new element order.
11873   if (BestHiQuad >= 0) {
11874     int MaskV[] = { 0, 1, 2, 3, -1, -1, -1, -1 };
11875     for (unsigned i = 4; i != 8; ++i) {
11876       int idx = MaskVals[i];
11877       if (idx < 0) {
11878         InOrder.set(i);
11879       } else if ((idx / 4) == BestHiQuad) {
11880         MaskV[i] = (idx & 3) + 4;
11881         InOrder.set(i);
11882       }
11883     }
11884     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
11885                                 &MaskV[0]);
11886
11887     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSE2()) {
11888       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11889       NewV = getTargetShuffleNode(X86ISD::PSHUFHW, dl, MVT::v8i16,
11890                                   NewV.getOperand(0),
11891                                   getShufflePSHUFHWImmediate(SVOp), DAG);
11892     }
11893   }
11894
11895   // In case BestHi & BestLo were both -1, which means each quadword has a word
11896   // from each of the four input quadwords, calculate the InOrder bitvector now
11897   // before falling through to the insert/extract cleanup.
11898   if (BestLoQuad == -1 && BestHiQuad == -1) {
11899     NewV = V1;
11900     for (int i = 0; i != 8; ++i)
11901       if (MaskVals[i] < 0 || MaskVals[i] == i)
11902         InOrder.set(i);
11903   }
11904
11905   // The other elements are put in the right place using pextrw and pinsrw.
11906   for (unsigned i = 0; i != 8; ++i) {
11907     if (InOrder[i])
11908       continue;
11909     int EltIdx = MaskVals[i];
11910     if (EltIdx < 0)
11911       continue;
11912     SDValue ExtOp = (EltIdx < 8) ?
11913       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V1,
11914                   DAG.getIntPtrConstant(EltIdx)) :
11915       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V2,
11916                   DAG.getIntPtrConstant(EltIdx - 8));
11917     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, ExtOp,
11918                        DAG.getIntPtrConstant(i));
11919   }
11920   return NewV;
11921 }
11922
11923 /// \brief v16i16 shuffles
11924 ///
11925 /// FIXME: We only support generation of a single pshufb currently.  We can
11926 /// generalize the other applicable cases from LowerVECTOR_SHUFFLEv8i16 as
11927 /// well (e.g 2 x pshufb + 1 x por).
11928 static SDValue
11929 LowerVECTOR_SHUFFLEv16i16(SDValue Op, SelectionDAG &DAG) {
11930   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11931   SDValue V1 = SVOp->getOperand(0);
11932   SDValue V2 = SVOp->getOperand(1);
11933   SDLoc dl(SVOp);
11934
11935   if (V2.getOpcode() != ISD::UNDEF)
11936     return SDValue();
11937
11938   SmallVector<int, 16> MaskVals(SVOp->getMask().begin(), SVOp->getMask().end());
11939   return getPSHUFB(MaskVals, V1, dl, DAG);
11940 }
11941
11942 // v16i8 shuffles - Prefer shuffles in the following order:
11943 // 1. [ssse3] 1 x pshufb
11944 // 2. [ssse3] 2 x pshufb + 1 x por
11945 // 3. [all]   v8i16 shuffle + N x pextrw + rotate + pinsrw
11946 static SDValue LowerVECTOR_SHUFFLEv16i8(ShuffleVectorSDNode *SVOp,
11947                                         const X86Subtarget* Subtarget,
11948                                         SelectionDAG &DAG) {
11949   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
11950   SDValue V1 = SVOp->getOperand(0);
11951   SDValue V2 = SVOp->getOperand(1);
11952   SDLoc dl(SVOp);
11953   ArrayRef<int> MaskVals = SVOp->getMask();
11954
11955   // Promote splats to a larger type which usually leads to more efficient code.
11956   // FIXME: Is this true if pshufb is available?
11957   if (SVOp->isSplat())
11958     return PromoteSplat(SVOp, DAG);
11959
11960   // If we have SSSE3, case 1 is generated when all result bytes come from
11961   // one of  the inputs.  Otherwise, case 2 is generated.  If no SSSE3 is
11962   // present, fall back to case 3.
11963
11964   // If SSSE3, use 1 pshufb instruction per vector with elements in the result.
11965   if (Subtarget->hasSSSE3()) {
11966     SmallVector<SDValue,16> pshufbMask;
11967
11968     // If all result elements are from one input vector, then only translate
11969     // undef mask values to 0x80 (zero out result) in the pshufb mask.
11970     //
11971     // Otherwise, we have elements from both input vectors, and must zero out
11972     // elements that come from V2 in the first mask, and V1 in the second mask
11973     // so that we can OR them together.
11974     for (unsigned i = 0; i != 16; ++i) {
11975       int EltIdx = MaskVals[i];
11976       if (EltIdx < 0 || EltIdx >= 16)
11977         EltIdx = 0x80;
11978       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
11979     }
11980     V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
11981                      DAG.getNode(ISD::BUILD_VECTOR, dl,
11982                                  MVT::v16i8, pshufbMask));
11983
11984     // As PSHUFB will zero elements with negative indices, it's safe to ignore
11985     // the 2nd operand if it's undefined or zero.
11986     if (V2.getOpcode() == ISD::UNDEF ||
11987         ISD::isBuildVectorAllZeros(V2.getNode()))
11988       return V1;
11989
11990     // Calculate the shuffle mask for the second input, shuffle it, and
11991     // OR it with the first shuffled input.
11992     pshufbMask.clear();
11993     for (unsigned i = 0; i != 16; ++i) {
11994       int EltIdx = MaskVals[i];
11995       EltIdx = (EltIdx < 16) ? 0x80 : EltIdx - 16;
11996       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
11997     }
11998     V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
11999                      DAG.getNode(ISD::BUILD_VECTOR, dl,
12000                                  MVT::v16i8, pshufbMask));
12001     return DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
12002   }
12003
12004   // No SSSE3 - Calculate in place words and then fix all out of place words
12005   // With 0-16 extracts & inserts.  Worst case is 16 bytes out of order from
12006   // the 16 different words that comprise the two doublequadword input vectors.
12007   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
12008   V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
12009   SDValue NewV = V1;
12010   for (int i = 0; i != 8; ++i) {
12011     int Elt0 = MaskVals[i*2];
12012     int Elt1 = MaskVals[i*2+1];
12013
12014     // This word of the result is all undef, skip it.
12015     if (Elt0 < 0 && Elt1 < 0)
12016       continue;
12017
12018     // This word of the result is already in the correct place, skip it.
12019     if ((Elt0 == i*2) && (Elt1 == i*2+1))
12020       continue;
12021
12022     SDValue Elt0Src = Elt0 < 16 ? V1 : V2;
12023     SDValue Elt1Src = Elt1 < 16 ? V1 : V2;
12024     SDValue InsElt;
12025
12026     // If Elt0 and Elt1 are defined, are consecutive, and can be load
12027     // using a single extract together, load it and store it.
12028     if ((Elt0 >= 0) && ((Elt0 + 1) == Elt1) && ((Elt0 & 1) == 0)) {
12029       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
12030                            DAG.getIntPtrConstant(Elt1 / 2));
12031       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
12032                         DAG.getIntPtrConstant(i));
12033       continue;
12034     }
12035
12036     // If Elt1 is defined, extract it from the appropriate source.  If the
12037     // source byte is not also odd, shift the extracted word left 8 bits
12038     // otherwise clear the bottom 8 bits if we need to do an or.
12039     if (Elt1 >= 0) {
12040       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
12041                            DAG.getIntPtrConstant(Elt1 / 2));
12042       if ((Elt1 & 1) == 0)
12043         InsElt = DAG.getNode(ISD::SHL, dl, MVT::i16, InsElt,
12044                              DAG.getConstant(8,
12045                                   TLI.getShiftAmountTy(InsElt.getValueType())));
12046       else if (Elt0 >= 0)
12047         InsElt = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt,
12048                              DAG.getConstant(0xFF00, MVT::i16));
12049     }
12050     // If Elt0 is defined, extract it from the appropriate source.  If the
12051     // source byte is not also even, shift the extracted word right 8 bits. If
12052     // Elt1 was also defined, OR the extracted values together before
12053     // inserting them in the result.
12054     if (Elt0 >= 0) {
12055       SDValue InsElt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
12056                                     Elt0Src, DAG.getIntPtrConstant(Elt0 / 2));
12057       if ((Elt0 & 1) != 0)
12058         InsElt0 = DAG.getNode(ISD::SRL, dl, MVT::i16, InsElt0,
12059                               DAG.getConstant(8,
12060                                  TLI.getShiftAmountTy(InsElt0.getValueType())));
12061       else if (Elt1 >= 0)
12062         InsElt0 = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt0,
12063                              DAG.getConstant(0x00FF, MVT::i16));
12064       InsElt = Elt1 >= 0 ? DAG.getNode(ISD::OR, dl, MVT::i16, InsElt, InsElt0)
12065                          : InsElt0;
12066     }
12067     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
12068                        DAG.getIntPtrConstant(i));
12069   }
12070   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, NewV);
12071 }
12072
12073 // v32i8 shuffles - Translate to VPSHUFB if possible.
12074 static
12075 SDValue LowerVECTOR_SHUFFLEv32i8(ShuffleVectorSDNode *SVOp,
12076                                  const X86Subtarget *Subtarget,
12077                                  SelectionDAG &DAG) {
12078   MVT VT = SVOp->getSimpleValueType(0);
12079   SDValue V1 = SVOp->getOperand(0);
12080   SDValue V2 = SVOp->getOperand(1);
12081   SDLoc dl(SVOp);
12082   SmallVector<int, 32> MaskVals(SVOp->getMask().begin(), SVOp->getMask().end());
12083
12084   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
12085   bool V1IsAllZero = ISD::isBuildVectorAllZeros(V1.getNode());
12086   bool V2IsAllZero = ISD::isBuildVectorAllZeros(V2.getNode());
12087
12088   // VPSHUFB may be generated if
12089   // (1) one of input vector is undefined or zeroinitializer.
12090   // The mask value 0x80 puts 0 in the corresponding slot of the vector.
12091   // And (2) the mask indexes don't cross the 128-bit lane.
12092   if (VT != MVT::v32i8 || !Subtarget->hasInt256() ||
12093       (!V2IsUndef && !V2IsAllZero && !V1IsAllZero))
12094     return SDValue();
12095
12096   if (V1IsAllZero && !V2IsAllZero) {
12097     CommuteVectorShuffleMask(MaskVals, 32);
12098     V1 = V2;
12099   }
12100   return getPSHUFB(MaskVals, V1, dl, DAG);
12101 }
12102
12103 /// RewriteAsNarrowerShuffle - Try rewriting v8i16 and v16i8 shuffles as 4 wide
12104 /// ones, or rewriting v4i32 / v4f32 as 2 wide ones if possible. This can be
12105 /// done when every pair / quad of shuffle mask elements point to elements in
12106 /// the right sequence. e.g.
12107 /// vector_shuffle X, Y, <2, 3, | 10, 11, | 0, 1, | 14, 15>
12108 static
12109 SDValue RewriteAsNarrowerShuffle(ShuffleVectorSDNode *SVOp,
12110                                  SelectionDAG &DAG) {
12111   MVT VT = SVOp->getSimpleValueType(0);
12112   SDLoc dl(SVOp);
12113   unsigned NumElems = VT.getVectorNumElements();
12114   MVT NewVT;
12115   unsigned Scale;
12116   switch (VT.SimpleTy) {
12117   default: llvm_unreachable("Unexpected!");
12118   case MVT::v2i64:
12119   case MVT::v2f64:
12120            return SDValue(SVOp, 0);
12121   case MVT::v4f32:  NewVT = MVT::v2f64; Scale = 2; break;
12122   case MVT::v4i32:  NewVT = MVT::v2i64; Scale = 2; break;
12123   case MVT::v8i16:  NewVT = MVT::v4i32; Scale = 2; break;
12124   case MVT::v16i8:  NewVT = MVT::v4i32; Scale = 4; break;
12125   case MVT::v16i16: NewVT = MVT::v8i32; Scale = 2; break;
12126   case MVT::v32i8:  NewVT = MVT::v8i32; Scale = 4; break;
12127   }
12128
12129   SmallVector<int, 8> MaskVec;
12130   for (unsigned i = 0; i != NumElems; i += Scale) {
12131     int StartIdx = -1;
12132     for (unsigned j = 0; j != Scale; ++j) {
12133       int EltIdx = SVOp->getMaskElt(i+j);
12134       if (EltIdx < 0)
12135         continue;
12136       if (StartIdx < 0)
12137         StartIdx = (EltIdx / Scale);
12138       if (EltIdx != (int)(StartIdx*Scale + j))
12139         return SDValue();
12140     }
12141     MaskVec.push_back(StartIdx);
12142   }
12143
12144   SDValue V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(0));
12145   SDValue V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(1));
12146   return DAG.getVectorShuffle(NewVT, dl, V1, V2, &MaskVec[0]);
12147 }
12148
12149 /// getVZextMovL - Return a zero-extending vector move low node.
12150 ///
12151 static SDValue getVZextMovL(MVT VT, MVT OpVT,
12152                             SDValue SrcOp, SelectionDAG &DAG,
12153                             const X86Subtarget *Subtarget, SDLoc dl) {
12154   if (VT == MVT::v2f64 || VT == MVT::v4f32) {
12155     LoadSDNode *LD = nullptr;
12156     if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
12157       LD = dyn_cast<LoadSDNode>(SrcOp);
12158     if (!LD) {
12159       // movssrr and movsdrr do not clear top bits. Try to use movd, movq
12160       // instead.
12161       MVT ExtVT = (OpVT == MVT::v2f64) ? MVT::i64 : MVT::i32;
12162       if ((ExtVT != MVT::i64 || Subtarget->is64Bit()) &&
12163           SrcOp.getOpcode() == ISD::SCALAR_TO_VECTOR &&
12164           SrcOp.getOperand(0).getOpcode() == ISD::BITCAST &&
12165           SrcOp.getOperand(0).getOperand(0).getValueType() == ExtVT) {
12166         // PR2108
12167         OpVT = (OpVT == MVT::v2f64) ? MVT::v2i64 : MVT::v4i32;
12168         return DAG.getNode(ISD::BITCAST, dl, VT,
12169                            DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
12170                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
12171                                                    OpVT,
12172                                                    SrcOp.getOperand(0)
12173                                                           .getOperand(0))));
12174       }
12175     }
12176   }
12177
12178   return DAG.getNode(ISD::BITCAST, dl, VT,
12179                      DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
12180                                  DAG.getNode(ISD::BITCAST, dl,
12181                                              OpVT, SrcOp)));
12182 }
12183
12184 /// LowerVECTOR_SHUFFLE_256 - Handle all 256-bit wide vectors shuffles
12185 /// which could not be matched by any known target speficic shuffle
12186 static SDValue
12187 LowerVECTOR_SHUFFLE_256(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
12188
12189   SDValue NewOp = Compact8x32ShuffleNode(SVOp, DAG);
12190   if (NewOp.getNode())
12191     return NewOp;
12192
12193   MVT VT = SVOp->getSimpleValueType(0);
12194
12195   unsigned NumElems = VT.getVectorNumElements();
12196   unsigned NumLaneElems = NumElems / 2;
12197
12198   SDLoc dl(SVOp);
12199   MVT EltVT = VT.getVectorElementType();
12200   MVT NVT = MVT::getVectorVT(EltVT, NumLaneElems);
12201   SDValue Output[2];
12202
12203   SmallVector<int, 16> Mask;
12204   for (unsigned l = 0; l < 2; ++l) {
12205     // Build a shuffle mask for the output, discovering on the fly which
12206     // input vectors to use as shuffle operands (recorded in InputUsed).
12207     // If building a suitable shuffle vector proves too hard, then bail
12208     // out with UseBuildVector set.
12209     bool UseBuildVector = false;
12210     int InputUsed[2] = { -1, -1 }; // Not yet discovered.
12211     unsigned LaneStart = l * NumLaneElems;
12212     for (unsigned i = 0; i != NumLaneElems; ++i) {
12213       // The mask element.  This indexes into the input.
12214       int Idx = SVOp->getMaskElt(i+LaneStart);
12215       if (Idx < 0) {
12216         // the mask element does not index into any input vector.
12217         Mask.push_back(-1);
12218         continue;
12219       }
12220
12221       // The input vector this mask element indexes into.
12222       int Input = Idx / NumLaneElems;
12223
12224       // Turn the index into an offset from the start of the input vector.
12225       Idx -= Input * NumLaneElems;
12226
12227       // Find or create a shuffle vector operand to hold this input.
12228       unsigned OpNo;
12229       for (OpNo = 0; OpNo < array_lengthof(InputUsed); ++OpNo) {
12230         if (InputUsed[OpNo] == Input)
12231           // This input vector is already an operand.
12232           break;
12233         if (InputUsed[OpNo] < 0) {
12234           // Create a new operand for this input vector.
12235           InputUsed[OpNo] = Input;
12236           break;
12237         }
12238       }
12239
12240       if (OpNo >= array_lengthof(InputUsed)) {
12241         // More than two input vectors used!  Give up on trying to create a
12242         // shuffle vector.  Insert all elements into a BUILD_VECTOR instead.
12243         UseBuildVector = true;
12244         break;
12245       }
12246
12247       // Add the mask index for the new shuffle vector.
12248       Mask.push_back(Idx + OpNo * NumLaneElems);
12249     }
12250
12251     if (UseBuildVector) {
12252       SmallVector<SDValue, 16> SVOps;
12253       for (unsigned i = 0; i != NumLaneElems; ++i) {
12254         // The mask element.  This indexes into the input.
12255         int Idx = SVOp->getMaskElt(i+LaneStart);
12256         if (Idx < 0) {
12257           SVOps.push_back(DAG.getUNDEF(EltVT));
12258           continue;
12259         }
12260
12261         // The input vector this mask element indexes into.
12262         int Input = Idx / NumElems;
12263
12264         // Turn the index into an offset from the start of the input vector.
12265         Idx -= Input * NumElems;
12266
12267         // Extract the vector element by hand.
12268         SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
12269                                     SVOp->getOperand(Input),
12270                                     DAG.getIntPtrConstant(Idx)));
12271       }
12272
12273       // Construct the output using a BUILD_VECTOR.
12274       Output[l] = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, SVOps);
12275     } else if (InputUsed[0] < 0) {
12276       // No input vectors were used! The result is undefined.
12277       Output[l] = DAG.getUNDEF(NVT);
12278     } else {
12279       SDValue Op0 = Extract128BitVector(SVOp->getOperand(InputUsed[0] / 2),
12280                                         (InputUsed[0] % 2) * NumLaneElems,
12281                                         DAG, dl);
12282       // If only one input was used, use an undefined vector for the other.
12283       SDValue Op1 = (InputUsed[1] < 0) ? DAG.getUNDEF(NVT) :
12284         Extract128BitVector(SVOp->getOperand(InputUsed[1] / 2),
12285                             (InputUsed[1] % 2) * NumLaneElems, DAG, dl);
12286       // At least one input vector was used. Create a new shuffle vector.
12287       Output[l] = DAG.getVectorShuffle(NVT, dl, Op0, Op1, &Mask[0]);
12288     }
12289
12290     Mask.clear();
12291   }
12292
12293   // Concatenate the result back
12294   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Output[0], Output[1]);
12295 }
12296
12297 /// LowerVECTOR_SHUFFLE_128v4 - Handle all 128-bit wide vectors with
12298 /// 4 elements, and match them with several different shuffle types.
12299 static SDValue
12300 LowerVECTOR_SHUFFLE_128v4(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
12301   SDValue V1 = SVOp->getOperand(0);
12302   SDValue V2 = SVOp->getOperand(1);
12303   SDLoc dl(SVOp);
12304   MVT VT = SVOp->getSimpleValueType(0);
12305
12306   assert(VT.is128BitVector() && "Unsupported vector size");
12307
12308   std::pair<int, int> Locs[4];
12309   int Mask1[] = { -1, -1, -1, -1 };
12310   SmallVector<int, 8> PermMask(SVOp->getMask().begin(), SVOp->getMask().end());
12311
12312   unsigned NumHi = 0;
12313   unsigned NumLo = 0;
12314   for (unsigned i = 0; i != 4; ++i) {
12315     int Idx = PermMask[i];
12316     if (Idx < 0) {
12317       Locs[i] = std::make_pair(-1, -1);
12318     } else {
12319       assert(Idx < 8 && "Invalid VECTOR_SHUFFLE index!");
12320       if (Idx < 4) {
12321         Locs[i] = std::make_pair(0, NumLo);
12322         Mask1[NumLo] = Idx;
12323         NumLo++;
12324       } else {
12325         Locs[i] = std::make_pair(1, NumHi);
12326         if (2+NumHi < 4)
12327           Mask1[2+NumHi] = Idx;
12328         NumHi++;
12329       }
12330     }
12331   }
12332
12333   if (NumLo <= 2 && NumHi <= 2) {
12334     // If no more than two elements come from either vector. This can be
12335     // implemented with two shuffles. First shuffle gather the elements.
12336     // The second shuffle, which takes the first shuffle as both of its
12337     // vector operands, put the elements into the right order.
12338     V1 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
12339
12340     int Mask2[] = { -1, -1, -1, -1 };
12341
12342     for (unsigned i = 0; i != 4; ++i)
12343       if (Locs[i].first != -1) {
12344         unsigned Idx = (i < 2) ? 0 : 4;
12345         Idx += Locs[i].first * 2 + Locs[i].second;
12346         Mask2[i] = Idx;
12347       }
12348
12349     return DAG.getVectorShuffle(VT, dl, V1, V1, &Mask2[0]);
12350   }
12351
12352   if (NumLo == 3 || NumHi == 3) {
12353     // Otherwise, we must have three elements from one vector, call it X, and
12354     // one element from the other, call it Y.  First, use a shufps to build an
12355     // intermediate vector with the one element from Y and the element from X
12356     // that will be in the same half in the final destination (the indexes don't
12357     // matter). Then, use a shufps to build the final vector, taking the half
12358     // containing the element from Y from the intermediate, and the other half
12359     // from X.
12360     if (NumHi == 3) {
12361       // Normalize it so the 3 elements come from V1.
12362       CommuteVectorShuffleMask(PermMask, 4);
12363       std::swap(V1, V2);
12364     }
12365
12366     // Find the element from V2.
12367     unsigned HiIndex;
12368     for (HiIndex = 0; HiIndex < 3; ++HiIndex) {
12369       int Val = PermMask[HiIndex];
12370       if (Val < 0)
12371         continue;
12372       if (Val >= 4)
12373         break;
12374     }
12375
12376     Mask1[0] = PermMask[HiIndex];
12377     Mask1[1] = -1;
12378     Mask1[2] = PermMask[HiIndex^1];
12379     Mask1[3] = -1;
12380     V2 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
12381
12382     if (HiIndex >= 2) {
12383       Mask1[0] = PermMask[0];
12384       Mask1[1] = PermMask[1];
12385       Mask1[2] = HiIndex & 1 ? 6 : 4;
12386       Mask1[3] = HiIndex & 1 ? 4 : 6;
12387       return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
12388     }
12389
12390     Mask1[0] = HiIndex & 1 ? 2 : 0;
12391     Mask1[1] = HiIndex & 1 ? 0 : 2;
12392     Mask1[2] = PermMask[2];
12393     Mask1[3] = PermMask[3];
12394     if (Mask1[2] >= 0)
12395       Mask1[2] += 4;
12396     if (Mask1[3] >= 0)
12397       Mask1[3] += 4;
12398     return DAG.getVectorShuffle(VT, dl, V2, V1, &Mask1[0]);
12399   }
12400
12401   // Break it into (shuffle shuffle_hi, shuffle_lo).
12402   int LoMask[] = { -1, -1, -1, -1 };
12403   int HiMask[] = { -1, -1, -1, -1 };
12404
12405   int *MaskPtr = LoMask;
12406   unsigned MaskIdx = 0;
12407   unsigned LoIdx = 0;
12408   unsigned HiIdx = 2;
12409   for (unsigned i = 0; i != 4; ++i) {
12410     if (i == 2) {
12411       MaskPtr = HiMask;
12412       MaskIdx = 1;
12413       LoIdx = 0;
12414       HiIdx = 2;
12415     }
12416     int Idx = PermMask[i];
12417     if (Idx < 0) {
12418       Locs[i] = std::make_pair(-1, -1);
12419     } else if (Idx < 4) {
12420       Locs[i] = std::make_pair(MaskIdx, LoIdx);
12421       MaskPtr[LoIdx] = Idx;
12422       LoIdx++;
12423     } else {
12424       Locs[i] = std::make_pair(MaskIdx, HiIdx);
12425       MaskPtr[HiIdx] = Idx;
12426       HiIdx++;
12427     }
12428   }
12429
12430   SDValue LoShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &LoMask[0]);
12431   SDValue HiShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &HiMask[0]);
12432   int MaskOps[] = { -1, -1, -1, -1 };
12433   for (unsigned i = 0; i != 4; ++i)
12434     if (Locs[i].first != -1)
12435       MaskOps[i] = Locs[i].first * 4 + Locs[i].second;
12436   return DAG.getVectorShuffle(VT, dl, LoShuffle, HiShuffle, &MaskOps[0]);
12437 }
12438
12439 static bool MayFoldVectorLoad(SDValue V) {
12440   while (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
12441     V = V.getOperand(0);
12442
12443   if (V.hasOneUse() && V.getOpcode() == ISD::SCALAR_TO_VECTOR)
12444     V = V.getOperand(0);
12445   if (V.hasOneUse() && V.getOpcode() == ISD::BUILD_VECTOR &&
12446       V.getNumOperands() == 2 && V.getOperand(1).getOpcode() == ISD::UNDEF)
12447     // BUILD_VECTOR (load), undef
12448     V = V.getOperand(0);
12449
12450   return MayFoldLoad(V);
12451 }
12452
12453 static
12454 SDValue getMOVDDup(SDValue &Op, SDLoc &dl, SDValue V1, SelectionDAG &DAG) {
12455   MVT VT = Op.getSimpleValueType();
12456
12457   // Canonicalize to v2f64.
12458   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
12459   return DAG.getNode(ISD::BITCAST, dl, VT,
12460                      getTargetShuffleNode(X86ISD::MOVDDUP, dl, MVT::v2f64,
12461                                           V1, DAG));
12462 }
12463
12464 static
12465 SDValue getMOVLowToHigh(SDValue &Op, SDLoc &dl, SelectionDAG &DAG,
12466                         bool HasSSE2) {
12467   SDValue V1 = Op.getOperand(0);
12468   SDValue V2 = Op.getOperand(1);
12469   MVT VT = Op.getSimpleValueType();
12470
12471   assert(VT != MVT::v2i64 && "unsupported shuffle type");
12472
12473   if (HasSSE2 && VT == MVT::v2f64)
12474     return getTargetShuffleNode(X86ISD::MOVLHPD, dl, VT, V1, V2, DAG);
12475
12476   // v4f32 or v4i32: canonicalize to v4f32 (which is legal for SSE1)
12477   return DAG.getNode(ISD::BITCAST, dl, VT,
12478                      getTargetShuffleNode(X86ISD::MOVLHPS, dl, MVT::v4f32,
12479                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V1),
12480                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V2), DAG));
12481 }
12482
12483 static
12484 SDValue getMOVHighToLow(SDValue &Op, SDLoc &dl, SelectionDAG &DAG) {
12485   SDValue V1 = Op.getOperand(0);
12486   SDValue V2 = Op.getOperand(1);
12487   MVT VT = Op.getSimpleValueType();
12488
12489   assert((VT == MVT::v4i32 || VT == MVT::v4f32) &&
12490          "unsupported shuffle type");
12491
12492   if (V2.getOpcode() == ISD::UNDEF)
12493     V2 = V1;
12494
12495   // v4i32 or v4f32
12496   return getTargetShuffleNode(X86ISD::MOVHLPS, dl, VT, V1, V2, DAG);
12497 }
12498
12499 static
12500 SDValue getMOVLP(SDValue &Op, SDLoc &dl, SelectionDAG &DAG, bool HasSSE2) {
12501   SDValue V1 = Op.getOperand(0);
12502   SDValue V2 = Op.getOperand(1);
12503   MVT VT = Op.getSimpleValueType();
12504   unsigned NumElems = VT.getVectorNumElements();
12505
12506   // Use MOVLPS and MOVLPD in case V1 or V2 are loads. During isel, the second
12507   // operand of these instructions is only memory, so check if there's a
12508   // potencial load folding here, otherwise use SHUFPS or MOVSD to match the
12509   // same masks.
12510   bool CanFoldLoad = false;
12511
12512   // Trivial case, when V2 comes from a load.
12513   if (MayFoldVectorLoad(V2))
12514     CanFoldLoad = true;
12515
12516   // When V1 is a load, it can be folded later into a store in isel, example:
12517   //  (store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)), addr:$src1)
12518   //    turns into:
12519   //  (MOVLPSmr addr:$src1, VR128:$src2)
12520   // So, recognize this potential and also use MOVLPS or MOVLPD
12521   else if (MayFoldVectorLoad(V1) && MayFoldIntoStore(Op))
12522     CanFoldLoad = true;
12523
12524   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12525   if (CanFoldLoad) {
12526     if (HasSSE2 && NumElems == 2)
12527       return getTargetShuffleNode(X86ISD::MOVLPD, dl, VT, V1, V2, DAG);
12528
12529     if (NumElems == 4)
12530       // If we don't care about the second element, proceed to use movss.
12531       if (SVOp->getMaskElt(1) != -1)
12532         return getTargetShuffleNode(X86ISD::MOVLPS, dl, VT, V1, V2, DAG);
12533   }
12534
12535   // movl and movlp will both match v2i64, but v2i64 is never matched by
12536   // movl earlier because we make it strict to avoid messing with the movlp load
12537   // folding logic (see the code above getMOVLP call). Match it here then,
12538   // this is horrible, but will stay like this until we move all shuffle
12539   // matching to x86 specific nodes. Note that for the 1st condition all
12540   // types are matched with movsd.
12541   if (HasSSE2) {
12542     // FIXME: isMOVLMask should be checked and matched before getMOVLP,
12543     // as to remove this logic from here, as much as possible
12544     if (NumElems == 2 || !isMOVLMask(SVOp->getMask(), VT))
12545       return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
12546     return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
12547   }
12548
12549   assert(VT != MVT::v4i32 && "unsupported shuffle type");
12550
12551   // Invert the operand order and use SHUFPS to match it.
12552   return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V2, V1,
12553                               getShuffleSHUFImmediate(SVOp), DAG);
12554 }
12555
12556 static SDValue NarrowVectorLoadToElement(LoadSDNode *Load, unsigned Index,
12557                                          SelectionDAG &DAG) {
12558   SDLoc dl(Load);
12559   MVT VT = Load->getSimpleValueType(0);
12560   MVT EVT = VT.getVectorElementType();
12561   SDValue Addr = Load->getOperand(1);
12562   SDValue NewAddr = DAG.getNode(
12563       ISD::ADD, dl, Addr.getSimpleValueType(), Addr,
12564       DAG.getConstant(Index * EVT.getStoreSize(), Addr.getSimpleValueType()));
12565
12566   SDValue NewLoad =
12567       DAG.getLoad(EVT, dl, Load->getChain(), NewAddr,
12568                   DAG.getMachineFunction().getMachineMemOperand(
12569                       Load->getMemOperand(), 0, EVT.getStoreSize()));
12570   return NewLoad;
12571 }
12572
12573 // It is only safe to call this function if isINSERTPSMask is true for
12574 // this shufflevector mask.
12575 static SDValue getINSERTPS(ShuffleVectorSDNode *SVOp, SDLoc &dl,
12576                            SelectionDAG &DAG) {
12577   // Generate an insertps instruction when inserting an f32 from memory onto a
12578   // v4f32 or when copying a member from one v4f32 to another.
12579   // We also use it for transferring i32 from one register to another,
12580   // since it simply copies the same bits.
12581   // If we're transferring an i32 from memory to a specific element in a
12582   // register, we output a generic DAG that will match the PINSRD
12583   // instruction.
12584   MVT VT = SVOp->getSimpleValueType(0);
12585   MVT EVT = VT.getVectorElementType();
12586   SDValue V1 = SVOp->getOperand(0);
12587   SDValue V2 = SVOp->getOperand(1);
12588   auto Mask = SVOp->getMask();
12589   assert((VT == MVT::v4f32 || VT == MVT::v4i32) &&
12590          "unsupported vector type for insertps/pinsrd");
12591
12592   auto FromV1Predicate = [](const int &i) { return i < 4 && i > -1; };
12593   auto FromV2Predicate = [](const int &i) { return i >= 4; };
12594   int FromV1 = std::count_if(Mask.begin(), Mask.end(), FromV1Predicate);
12595
12596   SDValue From;
12597   SDValue To;
12598   unsigned DestIndex;
12599   if (FromV1 == 1) {
12600     From = V1;
12601     To = V2;
12602     DestIndex = std::find_if(Mask.begin(), Mask.end(), FromV1Predicate) -
12603                 Mask.begin();
12604
12605     // If we have 1 element from each vector, we have to check if we're
12606     // changing V1's element's place. If so, we're done. Otherwise, we
12607     // should assume we're changing V2's element's place and behave
12608     // accordingly.
12609     int FromV2 = std::count_if(Mask.begin(), Mask.end(), FromV2Predicate);
12610     assert(DestIndex <= INT32_MAX && "truncated destination index");
12611     if (FromV1 == FromV2 &&
12612         static_cast<int>(DestIndex) == Mask[DestIndex] % 4) {
12613       From = V2;
12614       To = V1;
12615       DestIndex =
12616           std::find_if(Mask.begin(), Mask.end(), FromV2Predicate) - Mask.begin();
12617     }
12618   } else {
12619     assert(std::count_if(Mask.begin(), Mask.end(), FromV2Predicate) == 1 &&
12620            "More than one element from V1 and from V2, or no elements from one "
12621            "of the vectors. This case should not have returned true from "
12622            "isINSERTPSMask");
12623     From = V2;
12624     To = V1;
12625     DestIndex =
12626         std::find_if(Mask.begin(), Mask.end(), FromV2Predicate) - Mask.begin();
12627   }
12628
12629   // Get an index into the source vector in the range [0,4) (the mask is
12630   // in the range [0,8) because it can address V1 and V2)
12631   unsigned SrcIndex = Mask[DestIndex] % 4;
12632   if (MayFoldLoad(From)) {
12633     // Trivial case, when From comes from a load and is only used by the
12634     // shuffle. Make it use insertps from the vector that we need from that
12635     // load.
12636     SDValue NewLoad =
12637         NarrowVectorLoadToElement(cast<LoadSDNode>(From), SrcIndex, DAG);
12638     if (!NewLoad.getNode())
12639       return SDValue();
12640
12641     if (EVT == MVT::f32) {
12642       // Create this as a scalar to vector to match the instruction pattern.
12643       SDValue LoadScalarToVector =
12644           DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, NewLoad);
12645       SDValue InsertpsMask = DAG.getIntPtrConstant(DestIndex << 4);
12646       return DAG.getNode(X86ISD::INSERTPS, dl, VT, To, LoadScalarToVector,
12647                          InsertpsMask);
12648     } else { // EVT == MVT::i32
12649       // If we're getting an i32 from memory, use an INSERT_VECTOR_ELT
12650       // instruction, to match the PINSRD instruction, which loads an i32 to a
12651       // certain vector element.
12652       return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, To, NewLoad,
12653                          DAG.getConstant(DestIndex, MVT::i32));
12654     }
12655   }
12656
12657   // Vector-element-to-vector
12658   SDValue InsertpsMask = DAG.getIntPtrConstant(DestIndex << 4 | SrcIndex << 6);
12659   return DAG.getNode(X86ISD::INSERTPS, dl, VT, To, From, InsertpsMask);
12660 }
12661
12662 // Reduce a vector shuffle to zext.
12663 static SDValue LowerVectorIntExtend(SDValue Op, const X86Subtarget *Subtarget,
12664                                     SelectionDAG &DAG) {
12665   // PMOVZX is only available from SSE41.
12666   if (!Subtarget->hasSSE41())
12667     return SDValue();
12668
12669   MVT VT = Op.getSimpleValueType();
12670
12671   // Only AVX2 support 256-bit vector integer extending.
12672   if (!Subtarget->hasInt256() && VT.is256BitVector())
12673     return SDValue();
12674
12675   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12676   SDLoc DL(Op);
12677   SDValue V1 = Op.getOperand(0);
12678   SDValue V2 = Op.getOperand(1);
12679   unsigned NumElems = VT.getVectorNumElements();
12680
12681   // Extending is an unary operation and the element type of the source vector
12682   // won't be equal to or larger than i64.
12683   if (V2.getOpcode() != ISD::UNDEF || !VT.isInteger() ||
12684       VT.getVectorElementType() == MVT::i64)
12685     return SDValue();
12686
12687   // Find the expansion ratio, e.g. expanding from i8 to i32 has a ratio of 4.
12688   unsigned Shift = 1; // Start from 2, i.e. 1 << 1.
12689   while ((1U << Shift) < NumElems) {
12690     if (SVOp->getMaskElt(1U << Shift) == 1)
12691       break;
12692     Shift += 1;
12693     // The maximal ratio is 8, i.e. from i8 to i64.
12694     if (Shift > 3)
12695       return SDValue();
12696   }
12697
12698   // Check the shuffle mask.
12699   unsigned Mask = (1U << Shift) - 1;
12700   for (unsigned i = 0; i != NumElems; ++i) {
12701     int EltIdx = SVOp->getMaskElt(i);
12702     if ((i & Mask) != 0 && EltIdx != -1)
12703       return SDValue();
12704     if ((i & Mask) == 0 && (unsigned)EltIdx != (i >> Shift))
12705       return SDValue();
12706   }
12707
12708   unsigned NBits = VT.getVectorElementType().getSizeInBits() << Shift;
12709   MVT NeVT = MVT::getIntegerVT(NBits);
12710   MVT NVT = MVT::getVectorVT(NeVT, NumElems >> Shift);
12711
12712   if (!DAG.getTargetLoweringInfo().isTypeLegal(NVT))
12713     return SDValue();
12714
12715   return DAG.getNode(ISD::BITCAST, DL, VT,
12716                      DAG.getNode(X86ISD::VZEXT, DL, NVT, V1));
12717 }
12718
12719 static SDValue NormalizeVectorShuffle(SDValue Op, const X86Subtarget *Subtarget,
12720                                       SelectionDAG &DAG) {
12721   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12722   MVT VT = Op.getSimpleValueType();
12723   SDLoc dl(Op);
12724   SDValue V1 = Op.getOperand(0);
12725   SDValue V2 = Op.getOperand(1);
12726
12727   if (isZeroShuffle(SVOp))
12728     return getZeroVector(VT, Subtarget, DAG, dl);
12729
12730   // Handle splat operations
12731   if (SVOp->isSplat()) {
12732     // Use vbroadcast whenever the splat comes from a foldable load
12733     SDValue Broadcast = LowerVectorBroadcast(Op, Subtarget, DAG);
12734     if (Broadcast.getNode())
12735       return Broadcast;
12736   }
12737
12738   // Check integer expanding shuffles.
12739   SDValue NewOp = LowerVectorIntExtend(Op, Subtarget, DAG);
12740   if (NewOp.getNode())
12741     return NewOp;
12742
12743   // If the shuffle can be profitably rewritten as a narrower shuffle, then
12744   // do it!
12745   if (VT == MVT::v8i16 || VT == MVT::v16i8 || VT == MVT::v16i16 ||
12746       VT == MVT::v32i8) {
12747     SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12748     if (NewOp.getNode())
12749       return DAG.getNode(ISD::BITCAST, dl, VT, NewOp);
12750   } else if (VT.is128BitVector() && Subtarget->hasSSE2()) {
12751     // FIXME: Figure out a cleaner way to do this.
12752     if (ISD::isBuildVectorAllZeros(V2.getNode())) {
12753       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12754       if (NewOp.getNode()) {
12755         MVT NewVT = NewOp.getSimpleValueType();
12756         if (isCommutedMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(),
12757                                NewVT, true, false))
12758           return getVZextMovL(VT, NewVT, NewOp.getOperand(0), DAG, Subtarget,
12759                               dl);
12760       }
12761     } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
12762       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12763       if (NewOp.getNode()) {
12764         MVT NewVT = NewOp.getSimpleValueType();
12765         if (isMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(), NewVT))
12766           return getVZextMovL(VT, NewVT, NewOp.getOperand(1), DAG, Subtarget,
12767                               dl);
12768       }
12769     }
12770   }
12771   return SDValue();
12772 }
12773
12774 SDValue
12775 X86TargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const {
12776   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12777   SDValue V1 = Op.getOperand(0);
12778   SDValue V2 = Op.getOperand(1);
12779   MVT VT = Op.getSimpleValueType();
12780   SDLoc dl(Op);
12781   unsigned NumElems = VT.getVectorNumElements();
12782   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
12783   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
12784   bool V1IsSplat = false;
12785   bool V2IsSplat = false;
12786   bool HasSSE2 = Subtarget->hasSSE2();
12787   bool HasFp256    = Subtarget->hasFp256();
12788   bool HasInt256   = Subtarget->hasInt256();
12789   MachineFunction &MF = DAG.getMachineFunction();
12790   bool OptForSize =
12791       MF.getFunction()->hasFnAttribute(Attribute::OptimizeForSize);
12792
12793   // Check if we should use the experimental vector shuffle lowering. If so,
12794   // delegate completely to that code path.
12795   if (ExperimentalVectorShuffleLowering)
12796     return lowerVectorShuffle(Op, Subtarget, DAG);
12797
12798   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
12799
12800   if (V1IsUndef && V2IsUndef)
12801     return DAG.getUNDEF(VT);
12802
12803   // When we create a shuffle node we put the UNDEF node to second operand,
12804   // but in some cases the first operand may be transformed to UNDEF.
12805   // In this case we should just commute the node.
12806   if (V1IsUndef)
12807     return DAG.getCommutedVectorShuffle(*SVOp);
12808
12809   // Vector shuffle lowering takes 3 steps:
12810   //
12811   // 1) Normalize the input vectors. Here splats, zeroed vectors, profitable
12812   //    narrowing and commutation of operands should be handled.
12813   // 2) Matching of shuffles with known shuffle masks to x86 target specific
12814   //    shuffle nodes.
12815   // 3) Rewriting of unmatched masks into new generic shuffle operations,
12816   //    so the shuffle can be broken into other shuffles and the legalizer can
12817   //    try the lowering again.
12818   //
12819   // The general idea is that no vector_shuffle operation should be left to
12820   // be matched during isel, all of them must be converted to a target specific
12821   // node here.
12822
12823   // Normalize the input vectors. Here splats, zeroed vectors, profitable
12824   // narrowing and commutation of operands should be handled. The actual code
12825   // doesn't include all of those, work in progress...
12826   SDValue NewOp = NormalizeVectorShuffle(Op, Subtarget, DAG);
12827   if (NewOp.getNode())
12828     return NewOp;
12829
12830   SmallVector<int, 8> M(SVOp->getMask().begin(), SVOp->getMask().end());
12831
12832   // NOTE: isPSHUFDMask can also match both masks below (unpckl_undef and
12833   // unpckh_undef). Only use pshufd if speed is more important than size.
12834   if (OptForSize && isUNPCKL_v_undef_Mask(M, VT, HasInt256))
12835     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
12836   if (OptForSize && isUNPCKH_v_undef_Mask(M, VT, HasInt256))
12837     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
12838
12839   if (isMOVDDUPMask(M, VT) && Subtarget->hasSSE3() &&
12840       V2IsUndef && MayFoldVectorLoad(V1))
12841     return getMOVDDup(Op, dl, V1, DAG);
12842
12843   if (isMOVHLPS_v_undef_Mask(M, VT))
12844     return getMOVHighToLow(Op, dl, DAG);
12845
12846   // Use to match splats
12847   if (HasSSE2 && isUNPCKHMask(M, VT, HasInt256) && V2IsUndef &&
12848       (VT == MVT::v2f64 || VT == MVT::v2i64))
12849     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
12850
12851   if (isPSHUFDMask(M, VT)) {
12852     // The actual implementation will match the mask in the if above and then
12853     // during isel it can match several different instructions, not only pshufd
12854     // as its name says, sad but true, emulate the behavior for now...
12855     if (isMOVDDUPMask(M, VT) && ((VT == MVT::v4f32 || VT == MVT::v2i64)))
12856       return getTargetShuffleNode(X86ISD::MOVLHPS, dl, VT, V1, V1, DAG);
12857
12858     unsigned TargetMask = getShuffleSHUFImmediate(SVOp);
12859
12860     if (HasSSE2 && (VT == MVT::v4f32 || VT == MVT::v4i32))
12861       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1, TargetMask, DAG);
12862
12863     if (HasFp256 && (VT == MVT::v4f32 || VT == MVT::v2f64))
12864       return getTargetShuffleNode(X86ISD::VPERMILPI, dl, VT, V1, TargetMask,
12865                                   DAG);
12866
12867     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V1,
12868                                 TargetMask, DAG);
12869   }
12870
12871   if (isPALIGNRMask(M, VT, Subtarget))
12872     return getTargetShuffleNode(X86ISD::PALIGNR, dl, VT, V1, V2,
12873                                 getShufflePALIGNRImmediate(SVOp),
12874                                 DAG);
12875
12876   if (isVALIGNMask(M, VT, Subtarget))
12877     return getTargetShuffleNode(X86ISD::VALIGN, dl, VT, V1, V2,
12878                                 getShuffleVALIGNImmediate(SVOp),
12879                                 DAG);
12880
12881   // Check if this can be converted into a logical shift.
12882   bool isLeft = false;
12883   unsigned ShAmt = 0;
12884   SDValue ShVal;
12885   bool isShift = HasSSE2 && isVectorShift(SVOp, DAG, isLeft, ShVal, ShAmt);
12886   if (isShift && ShVal.hasOneUse()) {
12887     // If the shifted value has multiple uses, it may be cheaper to use
12888     // v_set0 + movlhps or movhlps, etc.
12889     MVT EltVT = VT.getVectorElementType();
12890     ShAmt *= EltVT.getSizeInBits();
12891     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
12892   }
12893
12894   if (isMOVLMask(M, VT)) {
12895     if (ISD::isBuildVectorAllZeros(V1.getNode()))
12896       return getVZextMovL(VT, VT, V2, DAG, Subtarget, dl);
12897     if (!isMOVLPMask(M, VT)) {
12898       if (HasSSE2 && (VT == MVT::v2i64 || VT == MVT::v2f64))
12899         return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
12900
12901       if (VT == MVT::v4i32 || VT == MVT::v4f32)
12902         return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
12903     }
12904   }
12905
12906   // FIXME: fold these into legal mask.
12907   if (isMOVLHPSMask(M, VT) && !isUNPCKLMask(M, VT, HasInt256))
12908     return getMOVLowToHigh(Op, dl, DAG, HasSSE2);
12909
12910   if (isMOVHLPSMask(M, VT))
12911     return getMOVHighToLow(Op, dl, DAG);
12912
12913   if (V2IsUndef && isMOVSHDUPMask(M, VT, Subtarget))
12914     return getTargetShuffleNode(X86ISD::MOVSHDUP, dl, VT, V1, DAG);
12915
12916   if (V2IsUndef && isMOVSLDUPMask(M, VT, Subtarget))
12917     return getTargetShuffleNode(X86ISD::MOVSLDUP, dl, VT, V1, DAG);
12918
12919   if (isMOVLPMask(M, VT))
12920     return getMOVLP(Op, dl, DAG, HasSSE2);
12921
12922   if (ShouldXformToMOVHLPS(M, VT) ||
12923       ShouldXformToMOVLP(V1.getNode(), V2.getNode(), M, VT))
12924     return DAG.getCommutedVectorShuffle(*SVOp);
12925
12926   if (isShift) {
12927     // No better options. Use a vshldq / vsrldq.
12928     MVT EltVT = VT.getVectorElementType();
12929     ShAmt *= EltVT.getSizeInBits();
12930     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
12931   }
12932
12933   bool Commuted = false;
12934   // FIXME: This should also accept a bitcast of a splat?  Be careful, not
12935   // 1,1,1,1 -> v8i16 though.
12936   BitVector UndefElements;
12937   if (auto *BVOp = dyn_cast<BuildVectorSDNode>(V1.getNode()))
12938     if (BVOp->getConstantSplatNode(&UndefElements) && UndefElements.none())
12939       V1IsSplat = true;
12940   if (auto *BVOp = dyn_cast<BuildVectorSDNode>(V2.getNode()))
12941     if (BVOp->getConstantSplatNode(&UndefElements) && UndefElements.none())
12942       V2IsSplat = true;
12943
12944   // Canonicalize the splat or undef, if present, to be on the RHS.
12945   if (!V2IsUndef && V1IsSplat && !V2IsSplat) {
12946     CommuteVectorShuffleMask(M, NumElems);
12947     std::swap(V1, V2);
12948     std::swap(V1IsSplat, V2IsSplat);
12949     Commuted = true;
12950   }
12951
12952   if (isCommutedMOVLMask(M, VT, V2IsSplat, V2IsUndef)) {
12953     // Shuffling low element of v1 into undef, just return v1.
12954     if (V2IsUndef)
12955       return V1;
12956     // If V2 is a splat, the mask may be malformed such as <4,3,3,3>, which
12957     // the instruction selector will not match, so get a canonical MOVL with
12958     // swapped operands to undo the commute.
12959     return getMOVL(DAG, dl, VT, V2, V1);
12960   }
12961
12962   if (isUNPCKLMask(M, VT, HasInt256))
12963     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
12964
12965   if (isUNPCKHMask(M, VT, HasInt256))
12966     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
12967
12968   if (V2IsSplat) {
12969     // Normalize mask so all entries that point to V2 points to its first
12970     // element then try to match unpck{h|l} again. If match, return a
12971     // new vector_shuffle with the corrected mask.p
12972     SmallVector<int, 8> NewMask(M.begin(), M.end());
12973     NormalizeMask(NewMask, NumElems);
12974     if (isUNPCKLMask(NewMask, VT, HasInt256, true))
12975       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
12976     if (isUNPCKHMask(NewMask, VT, HasInt256, true))
12977       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
12978   }
12979
12980   if (Commuted) {
12981     // Commute is back and try unpck* again.
12982     // FIXME: this seems wrong.
12983     CommuteVectorShuffleMask(M, NumElems);
12984     std::swap(V1, V2);
12985     std::swap(V1IsSplat, V2IsSplat);
12986
12987     if (isUNPCKLMask(M, VT, HasInt256))
12988       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
12989
12990     if (isUNPCKHMask(M, VT, HasInt256))
12991       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
12992   }
12993
12994   // Normalize the node to match x86 shuffle ops if needed
12995   if (!V2IsUndef && (isSHUFPMask(M, VT, /* Commuted */ true)))
12996     return DAG.getCommutedVectorShuffle(*SVOp);
12997
12998   // The checks below are all present in isShuffleMaskLegal, but they are
12999   // inlined here right now to enable us to directly emit target specific
13000   // nodes, and remove one by one until they don't return Op anymore.
13001
13002   if (ShuffleVectorSDNode::isSplatMask(&M[0], VT) &&
13003       SVOp->getSplatIndex() == 0 && V2IsUndef) {
13004     if (VT == MVT::v2f64 || VT == MVT::v2i64)
13005       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
13006   }
13007
13008   if (isPSHUFHWMask(M, VT, HasInt256))
13009     return getTargetShuffleNode(X86ISD::PSHUFHW, dl, VT, V1,
13010                                 getShufflePSHUFHWImmediate(SVOp),
13011                                 DAG);
13012
13013   if (isPSHUFLWMask(M, VT, HasInt256))
13014     return getTargetShuffleNode(X86ISD::PSHUFLW, dl, VT, V1,
13015                                 getShufflePSHUFLWImmediate(SVOp),
13016                                 DAG);
13017
13018   unsigned MaskValue;
13019   if (isBlendMask(M, VT, Subtarget->hasSSE41(), HasInt256, &MaskValue))
13020     return LowerVECTOR_SHUFFLEtoBlend(SVOp, MaskValue, Subtarget, DAG);
13021
13022   if (isSHUFPMask(M, VT))
13023     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V2,
13024                                 getShuffleSHUFImmediate(SVOp), DAG);
13025
13026   if (isUNPCKL_v_undef_Mask(M, VT, HasInt256))
13027     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
13028   if (isUNPCKH_v_undef_Mask(M, VT, HasInt256))
13029     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
13030
13031   //===--------------------------------------------------------------------===//
13032   // Generate target specific nodes for 128 or 256-bit shuffles only
13033   // supported in the AVX instruction set.
13034   //
13035
13036   // Handle VMOVDDUPY permutations
13037   if (V2IsUndef && isMOVDDUPYMask(M, VT, HasFp256))
13038     return getTargetShuffleNode(X86ISD::MOVDDUP, dl, VT, V1, DAG);
13039
13040   // Handle VPERMILPS/D* permutations
13041   if (isVPERMILPMask(M, VT)) {
13042     if ((HasInt256 && VT == MVT::v8i32) || VT == MVT::v16i32)
13043       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1,
13044                                   getShuffleSHUFImmediate(SVOp), DAG);
13045     return getTargetShuffleNode(X86ISD::VPERMILPI, dl, VT, V1,
13046                                 getShuffleSHUFImmediate(SVOp), DAG);
13047   }
13048
13049   unsigned Idx;
13050   if (VT.is512BitVector() && isINSERT64x4Mask(M, VT, &Idx))
13051     return Insert256BitVector(V1, Extract256BitVector(V2, 0, DAG, dl),
13052                               Idx*(NumElems/2), DAG, dl);
13053
13054   // Handle VPERM2F128/VPERM2I128 permutations
13055   if (isVPERM2X128Mask(M, VT, HasFp256))
13056     return getTargetShuffleNode(X86ISD::VPERM2X128, dl, VT, V1,
13057                                 V2, getShuffleVPERM2X128Immediate(SVOp), DAG);
13058
13059   if (Subtarget->hasSSE41() && isINSERTPSMask(M, VT))
13060     return getINSERTPS(SVOp, dl, DAG);
13061
13062   unsigned Imm8;
13063   if (V2IsUndef && HasInt256 && isPermImmMask(M, VT, Imm8))
13064     return getTargetShuffleNode(X86ISD::VPERMI, dl, VT, V1, Imm8, DAG);
13065
13066   if ((V2IsUndef && HasInt256 && VT.is256BitVector() && NumElems == 8) ||
13067       VT.is512BitVector()) {
13068     MVT MaskEltVT = MVT::getIntegerVT(VT.getVectorElementType().getSizeInBits());
13069     MVT MaskVectorVT = MVT::getVectorVT(MaskEltVT, NumElems);
13070     SmallVector<SDValue, 16> permclMask;
13071     for (unsigned i = 0; i != NumElems; ++i) {
13072       permclMask.push_back(DAG.getConstant((M[i]>=0) ? M[i] : 0, MaskEltVT));
13073     }
13074
13075     SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, MaskVectorVT, permclMask);
13076     if (V2IsUndef)
13077       // Bitcast is for VPERMPS since mask is v8i32 but node takes v8f32
13078       return DAG.getNode(X86ISD::VPERMV, dl, VT,
13079                           DAG.getNode(ISD::BITCAST, dl, VT, Mask), V1);
13080     return DAG.getNode(X86ISD::VPERMV3, dl, VT, V1,
13081                        DAG.getNode(ISD::BITCAST, dl, VT, Mask), V2);
13082   }
13083
13084   //===--------------------------------------------------------------------===//
13085   // Since no target specific shuffle was selected for this generic one,
13086   // lower it into other known shuffles. FIXME: this isn't true yet, but
13087   // this is the plan.
13088   //
13089
13090   // Handle v8i16 specifically since SSE can do byte extraction and insertion.
13091   if (VT == MVT::v8i16) {
13092     SDValue NewOp = LowerVECTOR_SHUFFLEv8i16(Op, Subtarget, DAG);
13093     if (NewOp.getNode())
13094       return NewOp;
13095   }
13096
13097   if (VT == MVT::v16i16 && HasInt256) {
13098     SDValue NewOp = LowerVECTOR_SHUFFLEv16i16(Op, DAG);
13099     if (NewOp.getNode())
13100       return NewOp;
13101   }
13102
13103   if (VT == MVT::v16i8) {
13104     SDValue NewOp = LowerVECTOR_SHUFFLEv16i8(SVOp, Subtarget, DAG);
13105     if (NewOp.getNode())
13106       return NewOp;
13107   }
13108
13109   if (VT == MVT::v32i8) {
13110     SDValue NewOp = LowerVECTOR_SHUFFLEv32i8(SVOp, Subtarget, DAG);
13111     if (NewOp.getNode())
13112       return NewOp;
13113   }
13114
13115   // Handle all 128-bit wide vectors with 4 elements, and match them with
13116   // several different shuffle types.
13117   if (NumElems == 4 && VT.is128BitVector())
13118     return LowerVECTOR_SHUFFLE_128v4(SVOp, DAG);
13119
13120   // Handle general 256-bit shuffles
13121   if (VT.is256BitVector())
13122     return LowerVECTOR_SHUFFLE_256(SVOp, DAG);
13123
13124   return SDValue();
13125 }
13126
13127 // This function assumes its argument is a BUILD_VECTOR of constants or
13128 // undef SDNodes. i.e: ISD::isBuildVectorOfConstantSDNodes(BuildVector) is
13129 // true.
13130 static bool BUILD_VECTORtoBlendMask(BuildVectorSDNode *BuildVector,
13131                                     unsigned &MaskValue) {
13132   MaskValue = 0;
13133   unsigned NumElems = BuildVector->getNumOperands();
13134   // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
13135   unsigned NumLanes = (NumElems - 1) / 8 + 1;
13136   unsigned NumElemsInLane = NumElems / NumLanes;
13137
13138   // Blend for v16i16 should be symetric for the both lanes.
13139   for (unsigned i = 0; i < NumElemsInLane; ++i) {
13140     SDValue EltCond = BuildVector->getOperand(i);
13141     SDValue SndLaneEltCond =
13142         (NumLanes == 2) ? BuildVector->getOperand(i + NumElemsInLane) : EltCond;
13143
13144     int Lane1Cond = -1, Lane2Cond = -1;
13145     if (isa<ConstantSDNode>(EltCond))
13146       Lane1Cond = !isZero(EltCond);
13147     if (isa<ConstantSDNode>(SndLaneEltCond))
13148       Lane2Cond = !isZero(SndLaneEltCond);
13149
13150     if (Lane1Cond == Lane2Cond || Lane2Cond < 0)
13151       // Lane1Cond != 0, means we want the first argument.
13152       // Lane1Cond == 0, means we want the second argument.
13153       // The encoding of this argument is 0 for the first argument, 1
13154       // for the second. Therefore, invert the condition.
13155       MaskValue |= !Lane1Cond << i;
13156     else if (Lane1Cond < 0)
13157       MaskValue |= !Lane2Cond << i;
13158     else
13159       return false;
13160   }
13161   return true;
13162 }
13163
13164 /// \brief Try to lower a VSELECT instruction to a vector shuffle.
13165 static SDValue lowerVSELECTtoVectorShuffle(SDValue Op,
13166                                            const X86Subtarget *Subtarget,
13167                                            SelectionDAG &DAG) {
13168   SDValue Cond = Op.getOperand(0);
13169   SDValue LHS = Op.getOperand(1);
13170   SDValue RHS = Op.getOperand(2);
13171   SDLoc dl(Op);
13172   MVT VT = Op.getSimpleValueType();
13173
13174   if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
13175     return SDValue();
13176   auto *CondBV = cast<BuildVectorSDNode>(Cond);
13177
13178   // Only non-legal VSELECTs reach this lowering, convert those into generic
13179   // shuffles and re-use the shuffle lowering path for blends.
13180   SmallVector<int, 32> Mask;
13181   for (int i = 0, Size = VT.getVectorNumElements(); i < Size; ++i) {
13182     SDValue CondElt = CondBV->getOperand(i);
13183     Mask.push_back(
13184         isa<ConstantSDNode>(CondElt) ? i + (isZero(CondElt) ? Size : 0) : -1);
13185   }
13186   return DAG.getVectorShuffle(VT, dl, LHS, RHS, Mask);
13187 }
13188
13189 SDValue X86TargetLowering::LowerVSELECT(SDValue Op, SelectionDAG &DAG) const {
13190   // A vselect where all conditions and data are constants can be optimized into
13191   // a single vector load by SelectionDAGLegalize::ExpandBUILD_VECTOR().
13192   if (ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(0).getNode()) &&
13193       ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(1).getNode()) &&
13194       ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(2).getNode()))
13195     return SDValue();
13196
13197   // Try to lower this to a blend-style vector shuffle. This can handle all
13198   // constant condition cases.
13199   SDValue BlendOp = lowerVSELECTtoVectorShuffle(Op, Subtarget, DAG);
13200   if (BlendOp.getNode())
13201     return BlendOp;
13202
13203   // Variable blends are only legal from SSE4.1 onward.
13204   if (!Subtarget->hasSSE41())
13205     return SDValue();
13206
13207   // Some types for vselect were previously set to Expand, not Legal or
13208   // Custom. Return an empty SDValue so we fall-through to Expand, after
13209   // the Custom lowering phase.
13210   MVT VT = Op.getSimpleValueType();
13211   switch (VT.SimpleTy) {
13212   default:
13213     break;
13214   case MVT::v8i16:
13215   case MVT::v16i16:
13216     if (Subtarget->hasBWI() && Subtarget->hasVLX())
13217       break;
13218     return SDValue();
13219   }
13220
13221   // We couldn't create a "Blend with immediate" node.
13222   // This node should still be legal, but we'll have to emit a blendv*
13223   // instruction.
13224   return Op;
13225 }
13226
13227 static SDValue LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG) {
13228   MVT VT = Op.getSimpleValueType();
13229   SDLoc dl(Op);
13230
13231   if (!Op.getOperand(0).getSimpleValueType().is128BitVector())
13232     return SDValue();
13233
13234   if (VT.getSizeInBits() == 8) {
13235     SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
13236                                   Op.getOperand(0), Op.getOperand(1));
13237     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
13238                                   DAG.getValueType(VT));
13239     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
13240   }
13241
13242   if (VT.getSizeInBits() == 16) {
13243     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
13244     // If Idx is 0, it's cheaper to do a move instead of a pextrw.
13245     if (Idx == 0)
13246       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
13247                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
13248                                      DAG.getNode(ISD::BITCAST, dl,
13249                                                  MVT::v4i32,
13250                                                  Op.getOperand(0)),
13251                                      Op.getOperand(1)));
13252     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
13253                                   Op.getOperand(0), Op.getOperand(1));
13254     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
13255                                   DAG.getValueType(VT));
13256     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
13257   }
13258
13259   if (VT == MVT::f32) {
13260     // EXTRACTPS outputs to a GPR32 register which will require a movd to copy
13261     // the result back to FR32 register. It's only worth matching if the
13262     // result has a single use which is a store or a bitcast to i32.  And in
13263     // the case of a store, it's not worth it if the index is a constant 0,
13264     // because a MOVSSmr can be used instead, which is smaller and faster.
13265     if (!Op.hasOneUse())
13266       return SDValue();
13267     SDNode *User = *Op.getNode()->use_begin();
13268     if ((User->getOpcode() != ISD::STORE ||
13269          (isa<ConstantSDNode>(Op.getOperand(1)) &&
13270           cast<ConstantSDNode>(Op.getOperand(1))->isNullValue())) &&
13271         (User->getOpcode() != ISD::BITCAST ||
13272          User->getValueType(0) != MVT::i32))
13273       return SDValue();
13274     SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
13275                                   DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
13276                                               Op.getOperand(0)),
13277                                               Op.getOperand(1));
13278     return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
13279   }
13280
13281   if (VT == MVT::i32 || VT == MVT::i64) {
13282     // ExtractPS/pextrq works with constant index.
13283     if (isa<ConstantSDNode>(Op.getOperand(1)))
13284       return Op;
13285   }
13286   return SDValue();
13287 }
13288
13289 /// Extract one bit from mask vector, like v16i1 or v8i1.
13290 /// AVX-512 feature.
13291 SDValue
13292 X86TargetLowering::ExtractBitFromMaskVector(SDValue Op, SelectionDAG &DAG) const {
13293   SDValue Vec = Op.getOperand(0);
13294   SDLoc dl(Vec);
13295   MVT VecVT = Vec.getSimpleValueType();
13296   SDValue Idx = Op.getOperand(1);
13297   MVT EltVT = Op.getSimpleValueType();
13298
13299   assert((EltVT == MVT::i1) && "Unexpected operands in ExtractBitFromMaskVector");
13300   assert((VecVT.getVectorNumElements() <= 16 || Subtarget->hasBWI()) &&
13301          "Unexpected vector type in ExtractBitFromMaskVector");
13302
13303   // variable index can't be handled in mask registers,
13304   // extend vector to VR512
13305   if (!isa<ConstantSDNode>(Idx)) {
13306     MVT ExtVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
13307     SDValue Ext = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, Vec);
13308     SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
13309                               ExtVT.getVectorElementType(), Ext, Idx);
13310     return DAG.getNode(ISD::TRUNCATE, dl, EltVT, Elt);
13311   }
13312
13313   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13314   const TargetRegisterClass* rc = getRegClassFor(VecVT);
13315   if (!Subtarget->hasDQI() && (VecVT.getVectorNumElements() <= 8))
13316     rc = getRegClassFor(MVT::v16i1);
13317   unsigned MaxSift = rc->getSize()*8 - 1;
13318   Vec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, Vec,
13319                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
13320   Vec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, Vec,
13321                     DAG.getConstant(MaxSift, MVT::i8));
13322   return DAG.getNode(X86ISD::VEXTRACT, dl, MVT::i1, Vec,
13323                        DAG.getIntPtrConstant(0));
13324 }
13325
13326 SDValue
13327 X86TargetLowering::LowerEXTRACT_VECTOR_ELT(SDValue Op,
13328                                            SelectionDAG &DAG) const {
13329   SDLoc dl(Op);
13330   SDValue Vec = Op.getOperand(0);
13331   MVT VecVT = Vec.getSimpleValueType();
13332   SDValue Idx = Op.getOperand(1);
13333
13334   if (Op.getSimpleValueType() == MVT::i1)
13335     return ExtractBitFromMaskVector(Op, DAG);
13336
13337   if (!isa<ConstantSDNode>(Idx)) {
13338     if (VecVT.is512BitVector() ||
13339         (VecVT.is256BitVector() && Subtarget->hasInt256() &&
13340          VecVT.getVectorElementType().getSizeInBits() == 32)) {
13341
13342       MVT MaskEltVT =
13343         MVT::getIntegerVT(VecVT.getVectorElementType().getSizeInBits());
13344       MVT MaskVT = MVT::getVectorVT(MaskEltVT, VecVT.getSizeInBits() /
13345                                     MaskEltVT.getSizeInBits());
13346
13347       Idx = DAG.getZExtOrTrunc(Idx, dl, MaskEltVT);
13348       SDValue Mask = DAG.getNode(X86ISD::VINSERT, dl, MaskVT,
13349                                 getZeroVector(MaskVT, Subtarget, DAG, dl),
13350                                 Idx, DAG.getConstant(0, getPointerTy()));
13351       SDValue Perm = DAG.getNode(X86ISD::VPERMV, dl, VecVT, Mask, Vec);
13352       return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(),
13353                         Perm, DAG.getConstant(0, getPointerTy()));
13354     }
13355     return SDValue();
13356   }
13357
13358   // If this is a 256-bit vector result, first extract the 128-bit vector and
13359   // then extract the element from the 128-bit vector.
13360   if (VecVT.is256BitVector() || VecVT.is512BitVector()) {
13361
13362     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13363     // Get the 128-bit vector.
13364     Vec = Extract128BitVector(Vec, IdxVal, DAG, dl);
13365     MVT EltVT = VecVT.getVectorElementType();
13366
13367     unsigned ElemsPerChunk = 128 / EltVT.getSizeInBits();
13368
13369     //if (IdxVal >= NumElems/2)
13370     //  IdxVal -= NumElems/2;
13371     IdxVal -= (IdxVal/ElemsPerChunk)*ElemsPerChunk;
13372     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
13373                        DAG.getConstant(IdxVal, MVT::i32));
13374   }
13375
13376   assert(VecVT.is128BitVector() && "Unexpected vector length");
13377
13378   if (Subtarget->hasSSE41()) {
13379     SDValue Res = LowerEXTRACT_VECTOR_ELT_SSE4(Op, DAG);
13380     if (Res.getNode())
13381       return Res;
13382   }
13383
13384   MVT VT = Op.getSimpleValueType();
13385   // TODO: handle v16i8.
13386   if (VT.getSizeInBits() == 16) {
13387     SDValue Vec = Op.getOperand(0);
13388     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
13389     if (Idx == 0)
13390       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
13391                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
13392                                      DAG.getNode(ISD::BITCAST, dl,
13393                                                  MVT::v4i32, Vec),
13394                                      Op.getOperand(1)));
13395     // Transform it so it match pextrw which produces a 32-bit result.
13396     MVT EltVT = MVT::i32;
13397     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
13398                                   Op.getOperand(0), Op.getOperand(1));
13399     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
13400                                   DAG.getValueType(VT));
13401     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
13402   }
13403
13404   if (VT.getSizeInBits() == 32) {
13405     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
13406     if (Idx == 0)
13407       return Op;
13408
13409     // SHUFPS the element to the lowest double word, then movss.
13410     int Mask[4] = { static_cast<int>(Idx), -1, -1, -1 };
13411     MVT VVT = Op.getOperand(0).getSimpleValueType();
13412     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
13413                                        DAG.getUNDEF(VVT), Mask);
13414     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
13415                        DAG.getIntPtrConstant(0));
13416   }
13417
13418   if (VT.getSizeInBits() == 64) {
13419     // FIXME: .td only matches this for <2 x f64>, not <2 x i64> on 32b
13420     // FIXME: seems like this should be unnecessary if mov{h,l}pd were taught
13421     //        to match extract_elt for f64.
13422     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
13423     if (Idx == 0)
13424       return Op;
13425
13426     // UNPCKHPD the element to the lowest double word, then movsd.
13427     // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
13428     // to a f64mem, the whole operation is folded into a single MOVHPDmr.
13429     int Mask[2] = { 1, -1 };
13430     MVT VVT = Op.getOperand(0).getSimpleValueType();
13431     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
13432                                        DAG.getUNDEF(VVT), Mask);
13433     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
13434                        DAG.getIntPtrConstant(0));
13435   }
13436
13437   return SDValue();
13438 }
13439
13440 /// Insert one bit to mask vector, like v16i1 or v8i1.
13441 /// AVX-512 feature.
13442 SDValue
13443 X86TargetLowering::InsertBitToMaskVector(SDValue Op, SelectionDAG &DAG) const {
13444   SDLoc dl(Op);
13445   SDValue Vec = Op.getOperand(0);
13446   SDValue Elt = Op.getOperand(1);
13447   SDValue Idx = Op.getOperand(2);
13448   MVT VecVT = Vec.getSimpleValueType();
13449
13450   if (!isa<ConstantSDNode>(Idx)) {
13451     // Non constant index. Extend source and destination,
13452     // insert element and then truncate the result.
13453     MVT ExtVecVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
13454     MVT ExtEltVT = (VecVT == MVT::v8i1 ?  MVT::i64 : MVT::i32);
13455     SDValue ExtOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, ExtVecVT,
13456       DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVecVT, Vec),
13457       DAG.getNode(ISD::ZERO_EXTEND, dl, ExtEltVT, Elt), Idx);
13458     return DAG.getNode(ISD::TRUNCATE, dl, VecVT, ExtOp);
13459   }
13460
13461   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13462   SDValue EltInVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Elt);
13463   if (Vec.getOpcode() == ISD::UNDEF)
13464     return DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
13465                        DAG.getConstant(IdxVal, MVT::i8));
13466   const TargetRegisterClass* rc = getRegClassFor(VecVT);
13467   unsigned MaxSift = rc->getSize()*8 - 1;
13468   EltInVec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
13469                     DAG.getConstant(MaxSift, MVT::i8));
13470   EltInVec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, EltInVec,
13471                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
13472   return DAG.getNode(ISD::OR, dl, VecVT, Vec, EltInVec);
13473 }
13474
13475 SDValue X86TargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op,
13476                                                   SelectionDAG &DAG) const {
13477   MVT VT = Op.getSimpleValueType();
13478   MVT EltVT = VT.getVectorElementType();
13479
13480   if (EltVT == MVT::i1)
13481     return InsertBitToMaskVector(Op, DAG);
13482
13483   SDLoc dl(Op);
13484   SDValue N0 = Op.getOperand(0);
13485   SDValue N1 = Op.getOperand(1);
13486   SDValue N2 = Op.getOperand(2);
13487   if (!isa<ConstantSDNode>(N2))
13488     return SDValue();
13489   auto *N2C = cast<ConstantSDNode>(N2);
13490   unsigned IdxVal = N2C->getZExtValue();
13491
13492   // If the vector is wider than 128 bits, extract the 128-bit subvector, insert
13493   // into that, and then insert the subvector back into the result.
13494   if (VT.is256BitVector() || VT.is512BitVector()) {
13495     // Get the desired 128-bit vector half.
13496     SDValue V = Extract128BitVector(N0, IdxVal, DAG, dl);
13497
13498     // Insert the element into the desired half.
13499     unsigned NumEltsIn128 = 128 / EltVT.getSizeInBits();
13500     unsigned IdxIn128 = IdxVal - (IdxVal / NumEltsIn128) * NumEltsIn128;
13501
13502     V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V, N1,
13503                     DAG.getConstant(IdxIn128, MVT::i32));
13504
13505     // Insert the changed part back to the 256-bit vector
13506     return Insert128BitVector(N0, V, IdxVal, DAG, dl);
13507   }
13508   assert(VT.is128BitVector() && "Only 128-bit vector types should be left!");
13509
13510   if (Subtarget->hasSSE41()) {
13511     if (EltVT.getSizeInBits() == 8 || EltVT.getSizeInBits() == 16) {
13512       unsigned Opc;
13513       if (VT == MVT::v8i16) {
13514         Opc = X86ISD::PINSRW;
13515       } else {
13516         assert(VT == MVT::v16i8);
13517         Opc = X86ISD::PINSRB;
13518       }
13519
13520       // Transform it so it match pinsr{b,w} which expects a GR32 as its second
13521       // argument.
13522       if (N1.getValueType() != MVT::i32)
13523         N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
13524       if (N2.getValueType() != MVT::i32)
13525         N2 = DAG.getIntPtrConstant(IdxVal);
13526       return DAG.getNode(Opc, dl, VT, N0, N1, N2);
13527     }
13528
13529     if (EltVT == MVT::f32) {
13530       // Bits [7:6] of the constant are the source select.  This will always be
13531       //  zero here.  The DAG Combiner may combine an extract_elt index into
13532       //  these
13533       //  bits.  For example (insert (extract, 3), 2) could be matched by
13534       //  putting
13535       //  the '3' into bits [7:6] of X86ISD::INSERTPS.
13536       // Bits [5:4] of the constant are the destination select.  This is the
13537       //  value of the incoming immediate.
13538       // Bits [3:0] of the constant are the zero mask.  The DAG Combiner may
13539       //   combine either bitwise AND or insert of float 0.0 to set these bits.
13540       N2 = DAG.getIntPtrConstant(IdxVal << 4);
13541       // Create this as a scalar to vector..
13542       N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
13543       return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
13544     }
13545
13546     if (EltVT == MVT::i32 || EltVT == MVT::i64) {
13547       // PINSR* works with constant index.
13548       return Op;
13549     }
13550   }
13551
13552   if (EltVT == MVT::i8)
13553     return SDValue();
13554
13555   if (EltVT.getSizeInBits() == 16) {
13556     // Transform it so it match pinsrw which expects a 16-bit value in a GR32
13557     // as its second argument.
13558     if (N1.getValueType() != MVT::i32)
13559       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
13560     if (N2.getValueType() != MVT::i32)
13561       N2 = DAG.getIntPtrConstant(IdxVal);
13562     return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
13563   }
13564   return SDValue();
13565 }
13566
13567 static SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) {
13568   SDLoc dl(Op);
13569   MVT OpVT = Op.getSimpleValueType();
13570
13571   // If this is a 256-bit vector result, first insert into a 128-bit
13572   // vector and then insert into the 256-bit vector.
13573   if (!OpVT.is128BitVector()) {
13574     // Insert into a 128-bit vector.
13575     unsigned SizeFactor = OpVT.getSizeInBits()/128;
13576     MVT VT128 = MVT::getVectorVT(OpVT.getVectorElementType(),
13577                                  OpVT.getVectorNumElements() / SizeFactor);
13578
13579     Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
13580
13581     // Insert the 128-bit vector.
13582     return Insert128BitVector(DAG.getUNDEF(OpVT), Op, 0, DAG, dl);
13583   }
13584
13585   if (OpVT == MVT::v1i64 &&
13586       Op.getOperand(0).getValueType() == MVT::i64)
13587     return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
13588
13589   SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
13590   assert(OpVT.is128BitVector() && "Expected an SSE type!");
13591   return DAG.getNode(ISD::BITCAST, dl, OpVT,
13592                      DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
13593 }
13594
13595 // Lower a node with an EXTRACT_SUBVECTOR opcode.  This may result in
13596 // a simple subregister reference or explicit instructions to grab
13597 // upper bits of a vector.
13598 static SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
13599                                       SelectionDAG &DAG) {
13600   SDLoc dl(Op);
13601   SDValue In =  Op.getOperand(0);
13602   SDValue Idx = Op.getOperand(1);
13603   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13604   MVT ResVT   = Op.getSimpleValueType();
13605   MVT InVT    = In.getSimpleValueType();
13606
13607   if (Subtarget->hasFp256()) {
13608     if (ResVT.is128BitVector() &&
13609         (InVT.is256BitVector() || InVT.is512BitVector()) &&
13610         isa<ConstantSDNode>(Idx)) {
13611       return Extract128BitVector(In, IdxVal, DAG, dl);
13612     }
13613     if (ResVT.is256BitVector() && InVT.is512BitVector() &&
13614         isa<ConstantSDNode>(Idx)) {
13615       return Extract256BitVector(In, IdxVal, DAG, dl);
13616     }
13617   }
13618   return SDValue();
13619 }
13620
13621 // Lower a node with an INSERT_SUBVECTOR opcode.  This may result in a
13622 // simple superregister reference or explicit instructions to insert
13623 // the upper bits of a vector.
13624 static SDValue LowerINSERT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
13625                                      SelectionDAG &DAG) {
13626   if (!Subtarget->hasAVX())
13627     return SDValue();
13628
13629   SDLoc dl(Op);
13630   SDValue Vec = Op.getOperand(0);
13631   SDValue SubVec = Op.getOperand(1);
13632   SDValue Idx = Op.getOperand(2);
13633
13634   if (!isa<ConstantSDNode>(Idx))
13635     return SDValue();
13636
13637   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13638   MVT OpVT = Op.getSimpleValueType();
13639   MVT SubVecVT = SubVec.getSimpleValueType();
13640
13641   // Fold two 16-byte subvector loads into one 32-byte load:
13642   // (insert_subvector (insert_subvector undef, (load addr), 0),
13643   //                   (load addr + 16), Elts/2)
13644   // --> load32 addr
13645   if ((IdxVal == OpVT.getVectorNumElements() / 2) &&
13646       Vec.getOpcode() == ISD::INSERT_SUBVECTOR &&
13647       OpVT.is256BitVector() && SubVecVT.is128BitVector() &&
13648       !Subtarget->isUnalignedMem32Slow()) {
13649     SDValue SubVec2 = Vec.getOperand(1);
13650     if (auto *Idx2 = dyn_cast<ConstantSDNode>(Vec.getOperand(2))) {
13651       if (Idx2->getZExtValue() == 0) {
13652         SDValue Ops[] = { SubVec2, SubVec };
13653         SDValue LD = EltsFromConsecutiveLoads(OpVT, Ops, dl, DAG, false);
13654         if (LD.getNode())
13655           return LD;
13656       }
13657     }
13658   }
13659
13660   if ((OpVT.is256BitVector() || OpVT.is512BitVector()) &&
13661       SubVecVT.is128BitVector())
13662     return Insert128BitVector(Vec, SubVec, IdxVal, DAG, dl);
13663
13664   if (OpVT.is512BitVector() && SubVecVT.is256BitVector())
13665     return Insert256BitVector(Vec, SubVec, IdxVal, DAG, dl);
13666
13667   return SDValue();
13668 }
13669
13670 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
13671 // their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is
13672 // one of the above mentioned nodes. It has to be wrapped because otherwise
13673 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
13674 // be used to form addressing mode. These wrapped nodes will be selected
13675 // into MOV32ri.
13676 SDValue
13677 X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
13678   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
13679
13680   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13681   // global base reg.
13682   unsigned char OpFlag = 0;
13683   unsigned WrapperKind = X86ISD::Wrapper;
13684   CodeModel::Model M = DAG.getTarget().getCodeModel();
13685
13686   if (Subtarget->isPICStyleRIPRel() &&
13687       (M == CodeModel::Small || M == CodeModel::Kernel))
13688     WrapperKind = X86ISD::WrapperRIP;
13689   else if (Subtarget->isPICStyleGOT())
13690     OpFlag = X86II::MO_GOTOFF;
13691   else if (Subtarget->isPICStyleStubPIC())
13692     OpFlag = X86II::MO_PIC_BASE_OFFSET;
13693
13694   SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(), getPointerTy(),
13695                                              CP->getAlignment(),
13696                                              CP->getOffset(), OpFlag);
13697   SDLoc DL(CP);
13698   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13699   // With PIC, the address is actually $g + Offset.
13700   if (OpFlag) {
13701     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13702                          DAG.getNode(X86ISD::GlobalBaseReg,
13703                                      SDLoc(), getPointerTy()),
13704                          Result);
13705   }
13706
13707   return Result;
13708 }
13709
13710 SDValue X86TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
13711   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
13712
13713   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13714   // global base reg.
13715   unsigned char OpFlag = 0;
13716   unsigned WrapperKind = X86ISD::Wrapper;
13717   CodeModel::Model M = DAG.getTarget().getCodeModel();
13718
13719   if (Subtarget->isPICStyleRIPRel() &&
13720       (M == CodeModel::Small || M == CodeModel::Kernel))
13721     WrapperKind = X86ISD::WrapperRIP;
13722   else if (Subtarget->isPICStyleGOT())
13723     OpFlag = X86II::MO_GOTOFF;
13724   else if (Subtarget->isPICStyleStubPIC())
13725     OpFlag = X86II::MO_PIC_BASE_OFFSET;
13726
13727   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy(),
13728                                           OpFlag);
13729   SDLoc DL(JT);
13730   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13731
13732   // With PIC, the address is actually $g + Offset.
13733   if (OpFlag)
13734     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13735                          DAG.getNode(X86ISD::GlobalBaseReg,
13736                                      SDLoc(), getPointerTy()),
13737                          Result);
13738
13739   return Result;
13740 }
13741
13742 SDValue
13743 X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const {
13744   const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
13745
13746   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13747   // global base reg.
13748   unsigned char OpFlag = 0;
13749   unsigned WrapperKind = X86ISD::Wrapper;
13750   CodeModel::Model M = DAG.getTarget().getCodeModel();
13751
13752   if (Subtarget->isPICStyleRIPRel() &&
13753       (M == CodeModel::Small || M == CodeModel::Kernel)) {
13754     if (Subtarget->isTargetDarwin() || Subtarget->isTargetELF())
13755       OpFlag = X86II::MO_GOTPCREL;
13756     WrapperKind = X86ISD::WrapperRIP;
13757   } else if (Subtarget->isPICStyleGOT()) {
13758     OpFlag = X86II::MO_GOT;
13759   } else if (Subtarget->isPICStyleStubPIC()) {
13760     OpFlag = X86II::MO_DARWIN_NONLAZY_PIC_BASE;
13761   } else if (Subtarget->isPICStyleStubNoDynamic()) {
13762     OpFlag = X86II::MO_DARWIN_NONLAZY;
13763   }
13764
13765   SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlag);
13766
13767   SDLoc DL(Op);
13768   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13769
13770   // With PIC, the address is actually $g + Offset.
13771   if (DAG.getTarget().getRelocationModel() == Reloc::PIC_ &&
13772       !Subtarget->is64Bit()) {
13773     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13774                          DAG.getNode(X86ISD::GlobalBaseReg,
13775                                      SDLoc(), getPointerTy()),
13776                          Result);
13777   }
13778
13779   // For symbols that require a load from a stub to get the address, emit the
13780   // load.
13781   if (isGlobalStubReference(OpFlag))
13782     Result = DAG.getLoad(getPointerTy(), DL, DAG.getEntryNode(), Result,
13783                          MachinePointerInfo::getGOT(), false, false, false, 0);
13784
13785   return Result;
13786 }
13787
13788 SDValue
13789 X86TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
13790   // Create the TargetBlockAddressAddress node.
13791   unsigned char OpFlags =
13792     Subtarget->ClassifyBlockAddressReference();
13793   CodeModel::Model M = DAG.getTarget().getCodeModel();
13794   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
13795   int64_t Offset = cast<BlockAddressSDNode>(Op)->getOffset();
13796   SDLoc dl(Op);
13797   SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy(), Offset,
13798                                              OpFlags);
13799
13800   if (Subtarget->isPICStyleRIPRel() &&
13801       (M == CodeModel::Small || M == CodeModel::Kernel))
13802     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
13803   else
13804     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
13805
13806   // With PIC, the address is actually $g + Offset.
13807   if (isGlobalRelativeToPICBase(OpFlags)) {
13808     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
13809                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
13810                          Result);
13811   }
13812
13813   return Result;
13814 }
13815
13816 SDValue
13817 X86TargetLowering::LowerGlobalAddress(const GlobalValue *GV, SDLoc dl,
13818                                       int64_t Offset, SelectionDAG &DAG) const {
13819   // Create the TargetGlobalAddress node, folding in the constant
13820   // offset if it is legal.
13821   unsigned char OpFlags =
13822       Subtarget->ClassifyGlobalReference(GV, DAG.getTarget());
13823   CodeModel::Model M = DAG.getTarget().getCodeModel();
13824   SDValue Result;
13825   if (OpFlags == X86II::MO_NO_FLAG &&
13826       X86::isOffsetSuitableForCodeModel(Offset, M)) {
13827     // A direct static reference to a global.
13828     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
13829     Offset = 0;
13830   } else {
13831     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
13832   }
13833
13834   if (Subtarget->isPICStyleRIPRel() &&
13835       (M == CodeModel::Small || M == CodeModel::Kernel))
13836     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
13837   else
13838     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
13839
13840   // With PIC, the address is actually $g + Offset.
13841   if (isGlobalRelativeToPICBase(OpFlags)) {
13842     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
13843                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
13844                          Result);
13845   }
13846
13847   // For globals that require a load from a stub to get the address, emit the
13848   // load.
13849   if (isGlobalStubReference(OpFlags))
13850     Result = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Result,
13851                          MachinePointerInfo::getGOT(), false, false, false, 0);
13852
13853   // If there was a non-zero offset that we didn't fold, create an explicit
13854   // addition for it.
13855   if (Offset != 0)
13856     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
13857                          DAG.getConstant(Offset, getPointerTy()));
13858
13859   return Result;
13860 }
13861
13862 SDValue
13863 X86TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
13864   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
13865   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
13866   return LowerGlobalAddress(GV, SDLoc(Op), Offset, DAG);
13867 }
13868
13869 static SDValue
13870 GetTLSADDR(SelectionDAG &DAG, SDValue Chain, GlobalAddressSDNode *GA,
13871            SDValue *InFlag, const EVT PtrVT, unsigned ReturnReg,
13872            unsigned char OperandFlags, bool LocalDynamic = false) {
13873   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
13874   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
13875   SDLoc dl(GA);
13876   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
13877                                            GA->getValueType(0),
13878                                            GA->getOffset(),
13879                                            OperandFlags);
13880
13881   X86ISD::NodeType CallType = LocalDynamic ? X86ISD::TLSBASEADDR
13882                                            : X86ISD::TLSADDR;
13883
13884   if (InFlag) {
13885     SDValue Ops[] = { Chain,  TGA, *InFlag };
13886     Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
13887   } else {
13888     SDValue Ops[]  = { Chain, TGA };
13889     Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
13890   }
13891
13892   // TLSADDR will be codegen'ed as call. Inform MFI that function has calls.
13893   MFI->setAdjustsStack(true);
13894   MFI->setHasCalls(true);
13895
13896   SDValue Flag = Chain.getValue(1);
13897   return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Flag);
13898 }
13899
13900 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 32 bit
13901 static SDValue
13902 LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13903                                 const EVT PtrVT) {
13904   SDValue InFlag;
13905   SDLoc dl(GA);  // ? function entry point might be better
13906   SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
13907                                    DAG.getNode(X86ISD::GlobalBaseReg,
13908                                                SDLoc(), PtrVT), InFlag);
13909   InFlag = Chain.getValue(1);
13910
13911   return GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX, X86II::MO_TLSGD);
13912 }
13913
13914 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 64 bit
13915 static SDValue
13916 LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13917                                 const EVT PtrVT) {
13918   return GetTLSADDR(DAG, DAG.getEntryNode(), GA, nullptr, PtrVT,
13919                     X86::RAX, X86II::MO_TLSGD);
13920 }
13921
13922 static SDValue LowerToTLSLocalDynamicModel(GlobalAddressSDNode *GA,
13923                                            SelectionDAG &DAG,
13924                                            const EVT PtrVT,
13925                                            bool is64Bit) {
13926   SDLoc dl(GA);
13927
13928   // Get the start address of the TLS block for this module.
13929   X86MachineFunctionInfo* MFI = DAG.getMachineFunction()
13930       .getInfo<X86MachineFunctionInfo>();
13931   MFI->incNumLocalDynamicTLSAccesses();
13932
13933   SDValue Base;
13934   if (is64Bit) {
13935     Base = GetTLSADDR(DAG, DAG.getEntryNode(), GA, nullptr, PtrVT, X86::RAX,
13936                       X86II::MO_TLSLD, /*LocalDynamic=*/true);
13937   } else {
13938     SDValue InFlag;
13939     SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
13940         DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT), InFlag);
13941     InFlag = Chain.getValue(1);
13942     Base = GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX,
13943                       X86II::MO_TLSLDM, /*LocalDynamic=*/true);
13944   }
13945
13946   // Note: the CleanupLocalDynamicTLSPass will remove redundant computations
13947   // of Base.
13948
13949   // Build x@dtpoff.
13950   unsigned char OperandFlags = X86II::MO_DTPOFF;
13951   unsigned WrapperKind = X86ISD::Wrapper;
13952   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
13953                                            GA->getValueType(0),
13954                                            GA->getOffset(), OperandFlags);
13955   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
13956
13957   // Add x@dtpoff with the base.
13958   return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
13959 }
13960
13961 // Lower ISD::GlobalTLSAddress using the "initial exec" or "local exec" model.
13962 static SDValue LowerToTLSExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13963                                    const EVT PtrVT, TLSModel::Model model,
13964                                    bool is64Bit, bool isPIC) {
13965   SDLoc dl(GA);
13966
13967   // Get the Thread Pointer, which is %gs:0 (32-bit) or %fs:0 (64-bit).
13968   Value *Ptr = Constant::getNullValue(Type::getInt8PtrTy(*DAG.getContext(),
13969                                                          is64Bit ? 257 : 256));
13970
13971   SDValue ThreadPointer =
13972       DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), DAG.getIntPtrConstant(0),
13973                   MachinePointerInfo(Ptr), false, false, false, 0);
13974
13975   unsigned char OperandFlags = 0;
13976   // Most TLS accesses are not RIP relative, even on x86-64.  One exception is
13977   // initialexec.
13978   unsigned WrapperKind = X86ISD::Wrapper;
13979   if (model == TLSModel::LocalExec) {
13980     OperandFlags = is64Bit ? X86II::MO_TPOFF : X86II::MO_NTPOFF;
13981   } else if (model == TLSModel::InitialExec) {
13982     if (is64Bit) {
13983       OperandFlags = X86II::MO_GOTTPOFF;
13984       WrapperKind = X86ISD::WrapperRIP;
13985     } else {
13986       OperandFlags = isPIC ? X86II::MO_GOTNTPOFF : X86II::MO_INDNTPOFF;
13987     }
13988   } else {
13989     llvm_unreachable("Unexpected model");
13990   }
13991
13992   // emit "addl x@ntpoff,%eax" (local exec)
13993   // or "addl x@indntpoff,%eax" (initial exec)
13994   // or "addl x@gotntpoff(%ebx) ,%eax" (initial exec, 32-bit pic)
13995   SDValue TGA =
13996       DAG.getTargetGlobalAddress(GA->getGlobal(), dl, GA->getValueType(0),
13997                                  GA->getOffset(), OperandFlags);
13998   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
13999
14000   if (model == TLSModel::InitialExec) {
14001     if (isPIC && !is64Bit) {
14002       Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
14003                            DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT),
14004                            Offset);
14005     }
14006
14007     Offset = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Offset,
14008                          MachinePointerInfo::getGOT(), false, false, false, 0);
14009   }
14010
14011   // The address of the thread local variable is the add of the thread
14012   // pointer with the offset of the variable.
14013   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
14014 }
14015
14016 SDValue
14017 X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
14018
14019   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
14020   const GlobalValue *GV = GA->getGlobal();
14021
14022   if (Subtarget->isTargetELF()) {
14023     TLSModel::Model model = DAG.getTarget().getTLSModel(GV);
14024
14025     switch (model) {
14026       case TLSModel::GeneralDynamic:
14027         if (Subtarget->is64Bit())
14028           return LowerToTLSGeneralDynamicModel64(GA, DAG, getPointerTy());
14029         return LowerToTLSGeneralDynamicModel32(GA, DAG, getPointerTy());
14030       case TLSModel::LocalDynamic:
14031         return LowerToTLSLocalDynamicModel(GA, DAG, getPointerTy(),
14032                                            Subtarget->is64Bit());
14033       case TLSModel::InitialExec:
14034       case TLSModel::LocalExec:
14035         return LowerToTLSExecModel(
14036             GA, DAG, getPointerTy(), model, Subtarget->is64Bit(),
14037             DAG.getTarget().getRelocationModel() == Reloc::PIC_);
14038     }
14039     llvm_unreachable("Unknown TLS model.");
14040   }
14041
14042   if (Subtarget->isTargetDarwin()) {
14043     // Darwin only has one model of TLS.  Lower to that.
14044     unsigned char OpFlag = 0;
14045     unsigned WrapperKind = Subtarget->isPICStyleRIPRel() ?
14046                            X86ISD::WrapperRIP : X86ISD::Wrapper;
14047
14048     // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
14049     // global base reg.
14050     bool PIC32 = (DAG.getTarget().getRelocationModel() == Reloc::PIC_) &&
14051                  !Subtarget->is64Bit();
14052     if (PIC32)
14053       OpFlag = X86II::MO_TLVP_PIC_BASE;
14054     else
14055       OpFlag = X86II::MO_TLVP;
14056     SDLoc DL(Op);
14057     SDValue Result = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
14058                                                 GA->getValueType(0),
14059                                                 GA->getOffset(), OpFlag);
14060     SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
14061
14062     // With PIC32, the address is actually $g + Offset.
14063     if (PIC32)
14064       Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
14065                            DAG.getNode(X86ISD::GlobalBaseReg,
14066                                        SDLoc(), getPointerTy()),
14067                            Offset);
14068
14069     // Lowering the machine isd will make sure everything is in the right
14070     // location.
14071     SDValue Chain = DAG.getEntryNode();
14072     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
14073     SDValue Args[] = { Chain, Offset };
14074     Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args);
14075
14076     // TLSCALL will be codegen'ed as call. Inform MFI that function has calls.
14077     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
14078     MFI->setAdjustsStack(true);
14079
14080     // And our return value (tls address) is in the standard call return value
14081     // location.
14082     unsigned Reg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
14083     return DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy(),
14084                               Chain.getValue(1));
14085   }
14086
14087   if (Subtarget->isTargetKnownWindowsMSVC() ||
14088       Subtarget->isTargetWindowsGNU()) {
14089     // Just use the implicit TLS architecture
14090     // Need to generate someting similar to:
14091     //   mov     rdx, qword [gs:abs 58H]; Load pointer to ThreadLocalStorage
14092     //                                  ; from TEB
14093     //   mov     ecx, dword [rel _tls_index]: Load index (from C runtime)
14094     //   mov     rcx, qword [rdx+rcx*8]
14095     //   mov     eax, .tls$:tlsvar
14096     //   [rax+rcx] contains the address
14097     // Windows 64bit: gs:0x58
14098     // Windows 32bit: fs:__tls_array
14099
14100     SDLoc dl(GA);
14101     SDValue Chain = DAG.getEntryNode();
14102
14103     // Get the Thread Pointer, which is %fs:__tls_array (32-bit) or
14104     // %gs:0x58 (64-bit). On MinGW, __tls_array is not available, so directly
14105     // use its literal value of 0x2C.
14106     Value *Ptr = Constant::getNullValue(Subtarget->is64Bit()
14107                                         ? Type::getInt8PtrTy(*DAG.getContext(),
14108                                                              256)
14109                                         : Type::getInt32PtrTy(*DAG.getContext(),
14110                                                               257));
14111
14112     SDValue TlsArray =
14113         Subtarget->is64Bit()
14114             ? DAG.getIntPtrConstant(0x58)
14115             : (Subtarget->isTargetWindowsGNU()
14116                    ? DAG.getIntPtrConstant(0x2C)
14117                    : DAG.getExternalSymbol("_tls_array", getPointerTy()));
14118
14119     SDValue ThreadPointer =
14120         DAG.getLoad(getPointerTy(), dl, Chain, TlsArray,
14121                     MachinePointerInfo(Ptr), false, false, false, 0);
14122
14123     // Load the _tls_index variable
14124     SDValue IDX = DAG.getExternalSymbol("_tls_index", getPointerTy());
14125     if (Subtarget->is64Bit())
14126       IDX = DAG.getExtLoad(ISD::ZEXTLOAD, dl, getPointerTy(), Chain,
14127                            IDX, MachinePointerInfo(), MVT::i32,
14128                            false, false, false, 0);
14129     else
14130       IDX = DAG.getLoad(getPointerTy(), dl, Chain, IDX, MachinePointerInfo(),
14131                         false, false, false, 0);
14132
14133     SDValue Scale = DAG.getConstant(Log2_64_Ceil(TD->getPointerSize()),
14134                                     getPointerTy());
14135     IDX = DAG.getNode(ISD::SHL, dl, getPointerTy(), IDX, Scale);
14136
14137     SDValue res = DAG.getNode(ISD::ADD, dl, getPointerTy(), ThreadPointer, IDX);
14138     res = DAG.getLoad(getPointerTy(), dl, Chain, res, MachinePointerInfo(),
14139                       false, false, false, 0);
14140
14141     // Get the offset of start of .tls section
14142     SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
14143                                              GA->getValueType(0),
14144                                              GA->getOffset(), X86II::MO_SECREL);
14145     SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), TGA);
14146
14147     // The address of the thread local variable is the add of the thread
14148     // pointer with the offset of the variable.
14149     return DAG.getNode(ISD::ADD, dl, getPointerTy(), res, Offset);
14150   }
14151
14152   llvm_unreachable("TLS not implemented for this target.");
14153 }
14154
14155 /// LowerShiftParts - Lower SRA_PARTS and friends, which return two i32 values
14156 /// and take a 2 x i32 value to shift plus a shift amount.
14157 static SDValue LowerShiftParts(SDValue Op, SelectionDAG &DAG) {
14158   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
14159   MVT VT = Op.getSimpleValueType();
14160   unsigned VTBits = VT.getSizeInBits();
14161   SDLoc dl(Op);
14162   bool isSRA = Op.getOpcode() == ISD::SRA_PARTS;
14163   SDValue ShOpLo = Op.getOperand(0);
14164   SDValue ShOpHi = Op.getOperand(1);
14165   SDValue ShAmt  = Op.getOperand(2);
14166   // X86ISD::SHLD and X86ISD::SHRD have defined overflow behavior but the
14167   // generic ISD nodes haven't. Insert an AND to be safe, it's optimized away
14168   // during isel.
14169   SDValue SafeShAmt = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
14170                                   DAG.getConstant(VTBits - 1, MVT::i8));
14171   SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
14172                                      DAG.getConstant(VTBits - 1, MVT::i8))
14173                        : DAG.getConstant(0, VT);
14174
14175   SDValue Tmp2, Tmp3;
14176   if (Op.getOpcode() == ISD::SHL_PARTS) {
14177     Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
14178     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, SafeShAmt);
14179   } else {
14180     Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
14181     Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, SafeShAmt);
14182   }
14183
14184   // If the shift amount is larger or equal than the width of a part we can't
14185   // rely on the results of shld/shrd. Insert a test and select the appropriate
14186   // values for large shift amounts.
14187   SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
14188                                 DAG.getConstant(VTBits, MVT::i8));
14189   SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
14190                              AndNode, DAG.getConstant(0, MVT::i8));
14191
14192   SDValue Hi, Lo;
14193   SDValue CC = DAG.getConstant(X86::COND_NE, MVT::i8);
14194   SDValue Ops0[4] = { Tmp2, Tmp3, CC, Cond };
14195   SDValue Ops1[4] = { Tmp3, Tmp1, CC, Cond };
14196
14197   if (Op.getOpcode() == ISD::SHL_PARTS) {
14198     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
14199     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
14200   } else {
14201     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
14202     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
14203   }
14204
14205   SDValue Ops[2] = { Lo, Hi };
14206   return DAG.getMergeValues(Ops, dl);
14207 }
14208
14209 SDValue X86TargetLowering::LowerSINT_TO_FP(SDValue Op,
14210                                            SelectionDAG &DAG) const {
14211   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
14212   SDLoc dl(Op);
14213
14214   if (SrcVT.isVector()) {
14215     if (SrcVT.getVectorElementType() == MVT::i1) {
14216       MVT IntegerVT = MVT::getVectorVT(MVT::i32, SrcVT.getVectorNumElements());
14217       return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
14218                          DAG.getNode(ISD::SIGN_EXTEND, dl, IntegerVT,
14219                                      Op.getOperand(0)));
14220     }
14221     return SDValue();
14222   }
14223
14224   assert(SrcVT <= MVT::i64 && SrcVT >= MVT::i16 &&
14225          "Unknown SINT_TO_FP to lower!");
14226
14227   // These are really Legal; return the operand so the caller accepts it as
14228   // Legal.
14229   if (SrcVT == MVT::i32 && isScalarFPTypeInSSEReg(Op.getValueType()))
14230     return Op;
14231   if (SrcVT == MVT::i64 && isScalarFPTypeInSSEReg(Op.getValueType()) &&
14232       Subtarget->is64Bit()) {
14233     return Op;
14234   }
14235
14236   unsigned Size = SrcVT.getSizeInBits()/8;
14237   MachineFunction &MF = DAG.getMachineFunction();
14238   int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size, false);
14239   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14240   SDValue Chain = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
14241                                StackSlot,
14242                                MachinePointerInfo::getFixedStack(SSFI),
14243                                false, false, 0);
14244   return BuildFILD(Op, SrcVT, Chain, StackSlot, DAG);
14245 }
14246
14247 SDValue X86TargetLowering::BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain,
14248                                      SDValue StackSlot,
14249                                      SelectionDAG &DAG) const {
14250   // Build the FILD
14251   SDLoc DL(Op);
14252   SDVTList Tys;
14253   bool useSSE = isScalarFPTypeInSSEReg(Op.getValueType());
14254   if (useSSE)
14255     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Glue);
14256   else
14257     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
14258
14259   unsigned ByteSize = SrcVT.getSizeInBits()/8;
14260
14261   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(StackSlot);
14262   MachineMemOperand *MMO;
14263   if (FI) {
14264     int SSFI = FI->getIndex();
14265     MMO =
14266       DAG.getMachineFunction()
14267       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14268                             MachineMemOperand::MOLoad, ByteSize, ByteSize);
14269   } else {
14270     MMO = cast<LoadSDNode>(StackSlot)->getMemOperand();
14271     StackSlot = StackSlot.getOperand(1);
14272   }
14273   SDValue Ops[] = { Chain, StackSlot, DAG.getValueType(SrcVT) };
14274   SDValue Result = DAG.getMemIntrinsicNode(useSSE ? X86ISD::FILD_FLAG :
14275                                            X86ISD::FILD, DL,
14276                                            Tys, Ops, SrcVT, MMO);
14277
14278   if (useSSE) {
14279     Chain = Result.getValue(1);
14280     SDValue InFlag = Result.getValue(2);
14281
14282     // FIXME: Currently the FST is flagged to the FILD_FLAG. This
14283     // shouldn't be necessary except that RFP cannot be live across
14284     // multiple blocks. When stackifier is fixed, they can be uncoupled.
14285     MachineFunction &MF = DAG.getMachineFunction();
14286     unsigned SSFISize = Op.getValueType().getSizeInBits()/8;
14287     int SSFI = MF.getFrameInfo()->CreateStackObject(SSFISize, SSFISize, false);
14288     SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14289     Tys = DAG.getVTList(MVT::Other);
14290     SDValue Ops[] = {
14291       Chain, Result, StackSlot, DAG.getValueType(Op.getValueType()), InFlag
14292     };
14293     MachineMemOperand *MMO =
14294       DAG.getMachineFunction()
14295       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14296                             MachineMemOperand::MOStore, SSFISize, SSFISize);
14297
14298     Chain = DAG.getMemIntrinsicNode(X86ISD::FST, DL, Tys,
14299                                     Ops, Op.getValueType(), MMO);
14300     Result = DAG.getLoad(Op.getValueType(), DL, Chain, StackSlot,
14301                          MachinePointerInfo::getFixedStack(SSFI),
14302                          false, false, false, 0);
14303   }
14304
14305   return Result;
14306 }
14307
14308 // LowerUINT_TO_FP_i64 - 64-bit unsigned integer to double expansion.
14309 SDValue X86TargetLowering::LowerUINT_TO_FP_i64(SDValue Op,
14310                                                SelectionDAG &DAG) const {
14311   // This algorithm is not obvious. Here it is what we're trying to output:
14312   /*
14313      movq       %rax,  %xmm0
14314      punpckldq  (c0),  %xmm0  // c0: (uint4){ 0x43300000U, 0x45300000U, 0U, 0U }
14315      subpd      (c1),  %xmm0  // c1: (double2){ 0x1.0p52, 0x1.0p52 * 0x1.0p32 }
14316      #ifdef __SSE3__
14317        haddpd   %xmm0, %xmm0
14318      #else
14319        pshufd   $0x4e, %xmm0, %xmm1
14320        addpd    %xmm1, %xmm0
14321      #endif
14322   */
14323
14324   SDLoc dl(Op);
14325   LLVMContext *Context = DAG.getContext();
14326
14327   // Build some magic constants.
14328   static const uint32_t CV0[] = { 0x43300000, 0x45300000, 0, 0 };
14329   Constant *C0 = ConstantDataVector::get(*Context, CV0);
14330   SDValue CPIdx0 = DAG.getConstantPool(C0, getPointerTy(), 16);
14331
14332   SmallVector<Constant*,2> CV1;
14333   CV1.push_back(
14334     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
14335                                       APInt(64, 0x4330000000000000ULL))));
14336   CV1.push_back(
14337     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
14338                                       APInt(64, 0x4530000000000000ULL))));
14339   Constant *C1 = ConstantVector::get(CV1);
14340   SDValue CPIdx1 = DAG.getConstantPool(C1, getPointerTy(), 16);
14341
14342   // Load the 64-bit value into an XMM register.
14343   SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
14344                             Op.getOperand(0));
14345   SDValue CLod0 = DAG.getLoad(MVT::v4i32, dl, DAG.getEntryNode(), CPIdx0,
14346                               MachinePointerInfo::getConstantPool(),
14347                               false, false, false, 16);
14348   SDValue Unpck1 = getUnpackl(DAG, dl, MVT::v4i32,
14349                               DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, XR1),
14350                               CLod0);
14351
14352   SDValue CLod1 = DAG.getLoad(MVT::v2f64, dl, CLod0.getValue(1), CPIdx1,
14353                               MachinePointerInfo::getConstantPool(),
14354                               false, false, false, 16);
14355   SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck1);
14356   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
14357   SDValue Result;
14358
14359   if (Subtarget->hasSSE3()) {
14360     // FIXME: The 'haddpd' instruction may be slower than 'movhlps + addsd'.
14361     Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
14362   } else {
14363     SDValue S2F = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Sub);
14364     SDValue Shuffle = getTargetShuffleNode(X86ISD::PSHUFD, dl, MVT::v4i32,
14365                                            S2F, 0x4E, DAG);
14366     Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64,
14367                          DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Shuffle),
14368                          Sub);
14369   }
14370
14371   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
14372                      DAG.getIntPtrConstant(0));
14373 }
14374
14375 // LowerUINT_TO_FP_i32 - 32-bit unsigned integer to float expansion.
14376 SDValue X86TargetLowering::LowerUINT_TO_FP_i32(SDValue Op,
14377                                                SelectionDAG &DAG) const {
14378   SDLoc dl(Op);
14379   // FP constant to bias correct the final result.
14380   SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
14381                                    MVT::f64);
14382
14383   // Load the 32-bit value into an XMM register.
14384   SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
14385                              Op.getOperand(0));
14386
14387   // Zero out the upper parts of the register.
14388   Load = getShuffleVectorZeroOrUndef(Load, 0, true, Subtarget, DAG);
14389
14390   Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
14391                      DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
14392                      DAG.getIntPtrConstant(0));
14393
14394   // Or the load with the bias.
14395   SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
14396                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
14397                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
14398                                                    MVT::v2f64, Load)),
14399                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
14400                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
14401                                                    MVT::v2f64, Bias)));
14402   Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
14403                    DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
14404                    DAG.getIntPtrConstant(0));
14405
14406   // Subtract the bias.
14407   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
14408
14409   // Handle final rounding.
14410   EVT DestVT = Op.getValueType();
14411
14412   if (DestVT.bitsLT(MVT::f64))
14413     return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
14414                        DAG.getIntPtrConstant(0));
14415   if (DestVT.bitsGT(MVT::f64))
14416     return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
14417
14418   // Handle final rounding.
14419   return Sub;
14420 }
14421
14422 static SDValue lowerUINT_TO_FP_vXi32(SDValue Op, SelectionDAG &DAG,
14423                                      const X86Subtarget &Subtarget) {
14424   // The algorithm is the following:
14425   // #ifdef __SSE4_1__
14426   //     uint4 lo = _mm_blend_epi16( v, (uint4) 0x4b000000, 0xaa);
14427   //     uint4 hi = _mm_blend_epi16( _mm_srli_epi32(v,16),
14428   //                                 (uint4) 0x53000000, 0xaa);
14429   // #else
14430   //     uint4 lo = (v & (uint4) 0xffff) | (uint4) 0x4b000000;
14431   //     uint4 hi = (v >> 16) | (uint4) 0x53000000;
14432   // #endif
14433   //     float4 fhi = (float4) hi - (0x1.0p39f + 0x1.0p23f);
14434   //     return (float4) lo + fhi;
14435
14436   SDLoc DL(Op);
14437   SDValue V = Op->getOperand(0);
14438   EVT VecIntVT = V.getValueType();
14439   bool Is128 = VecIntVT == MVT::v4i32;
14440   EVT VecFloatVT = Is128 ? MVT::v4f32 : MVT::v8f32;
14441   // If we convert to something else than the supported type, e.g., to v4f64,
14442   // abort early.
14443   if (VecFloatVT != Op->getValueType(0))
14444     return SDValue();
14445
14446   unsigned NumElts = VecIntVT.getVectorNumElements();
14447   assert((VecIntVT == MVT::v4i32 || VecIntVT == MVT::v8i32) &&
14448          "Unsupported custom type");
14449   assert(NumElts <= 8 && "The size of the constant array must be fixed");
14450
14451   // In the #idef/#else code, we have in common:
14452   // - The vector of constants:
14453   // -- 0x4b000000
14454   // -- 0x53000000
14455   // - A shift:
14456   // -- v >> 16
14457
14458   // Create the splat vector for 0x4b000000.
14459   SDValue CstLow = DAG.getConstant(0x4b000000, MVT::i32);
14460   SDValue CstLowArray[] = {CstLow, CstLow, CstLow, CstLow,
14461                            CstLow, CstLow, CstLow, CstLow};
14462   SDValue VecCstLow = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14463                                   makeArrayRef(&CstLowArray[0], NumElts));
14464   // Create the splat vector for 0x53000000.
14465   SDValue CstHigh = DAG.getConstant(0x53000000, MVT::i32);
14466   SDValue CstHighArray[] = {CstHigh, CstHigh, CstHigh, CstHigh,
14467                             CstHigh, CstHigh, CstHigh, CstHigh};
14468   SDValue VecCstHigh = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14469                                    makeArrayRef(&CstHighArray[0], NumElts));
14470
14471   // Create the right shift.
14472   SDValue CstShift = DAG.getConstant(16, MVT::i32);
14473   SDValue CstShiftArray[] = {CstShift, CstShift, CstShift, CstShift,
14474                              CstShift, CstShift, CstShift, CstShift};
14475   SDValue VecCstShift = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14476                                     makeArrayRef(&CstShiftArray[0], NumElts));
14477   SDValue HighShift = DAG.getNode(ISD::SRL, DL, VecIntVT, V, VecCstShift);
14478
14479   SDValue Low, High;
14480   if (Subtarget.hasSSE41()) {
14481     EVT VecI16VT = Is128 ? MVT::v8i16 : MVT::v16i16;
14482     //     uint4 lo = _mm_blend_epi16( v, (uint4) 0x4b000000, 0xaa);
14483     SDValue VecCstLowBitcast =
14484         DAG.getNode(ISD::BITCAST, DL, VecI16VT, VecCstLow);
14485     SDValue VecBitcast = DAG.getNode(ISD::BITCAST, DL, VecI16VT, V);
14486     // Low will be bitcasted right away, so do not bother bitcasting back to its
14487     // original type.
14488     Low = DAG.getNode(X86ISD::BLENDI, DL, VecI16VT, VecBitcast,
14489                       VecCstLowBitcast, DAG.getConstant(0xaa, MVT::i32));
14490     //     uint4 hi = _mm_blend_epi16( _mm_srli_epi32(v,16),
14491     //                                 (uint4) 0x53000000, 0xaa);
14492     SDValue VecCstHighBitcast =
14493         DAG.getNode(ISD::BITCAST, DL, VecI16VT, VecCstHigh);
14494     SDValue VecShiftBitcast =
14495         DAG.getNode(ISD::BITCAST, DL, VecI16VT, HighShift);
14496     // High will be bitcasted right away, so do not bother bitcasting back to
14497     // its original type.
14498     High = DAG.getNode(X86ISD::BLENDI, DL, VecI16VT, VecShiftBitcast,
14499                        VecCstHighBitcast, DAG.getConstant(0xaa, MVT::i32));
14500   } else {
14501     SDValue CstMask = DAG.getConstant(0xffff, MVT::i32);
14502     SDValue VecCstMask = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT, CstMask,
14503                                      CstMask, CstMask, CstMask);
14504     //     uint4 lo = (v & (uint4) 0xffff) | (uint4) 0x4b000000;
14505     SDValue LowAnd = DAG.getNode(ISD::AND, DL, VecIntVT, V, VecCstMask);
14506     Low = DAG.getNode(ISD::OR, DL, VecIntVT, LowAnd, VecCstLow);
14507
14508     //     uint4 hi = (v >> 16) | (uint4) 0x53000000;
14509     High = DAG.getNode(ISD::OR, DL, VecIntVT, HighShift, VecCstHigh);
14510   }
14511
14512   // Create the vector constant for -(0x1.0p39f + 0x1.0p23f).
14513   SDValue CstFAdd = DAG.getConstantFP(
14514       APFloat(APFloat::IEEEsingle, APInt(32, 0xD3000080)), MVT::f32);
14515   SDValue CstFAddArray[] = {CstFAdd, CstFAdd, CstFAdd, CstFAdd,
14516                             CstFAdd, CstFAdd, CstFAdd, CstFAdd};
14517   SDValue VecCstFAdd = DAG.getNode(ISD::BUILD_VECTOR, DL, VecFloatVT,
14518                                    makeArrayRef(&CstFAddArray[0], NumElts));
14519
14520   //     float4 fhi = (float4) hi - (0x1.0p39f + 0x1.0p23f);
14521   SDValue HighBitcast = DAG.getNode(ISD::BITCAST, DL, VecFloatVT, High);
14522   SDValue FHigh =
14523       DAG.getNode(ISD::FADD, DL, VecFloatVT, HighBitcast, VecCstFAdd);
14524   //     return (float4) lo + fhi;
14525   SDValue LowBitcast = DAG.getNode(ISD::BITCAST, DL, VecFloatVT, Low);
14526   return DAG.getNode(ISD::FADD, DL, VecFloatVT, LowBitcast, FHigh);
14527 }
14528
14529 SDValue X86TargetLowering::lowerUINT_TO_FP_vec(SDValue Op,
14530                                                SelectionDAG &DAG) const {
14531   SDValue N0 = Op.getOperand(0);
14532   MVT SVT = N0.getSimpleValueType();
14533   SDLoc dl(Op);
14534
14535   switch (SVT.SimpleTy) {
14536   default:
14537     llvm_unreachable("Custom UINT_TO_FP is not supported!");
14538   case MVT::v4i8:
14539   case MVT::v4i16:
14540   case MVT::v8i8:
14541   case MVT::v8i16: {
14542     MVT NVT = MVT::getVectorVT(MVT::i32, SVT.getVectorNumElements());
14543     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
14544                        DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N0));
14545   }
14546   case MVT::v4i32:
14547   case MVT::v8i32:
14548     return lowerUINT_TO_FP_vXi32(Op, DAG, *Subtarget);
14549   }
14550   llvm_unreachable(nullptr);
14551 }
14552
14553 SDValue X86TargetLowering::LowerUINT_TO_FP(SDValue Op,
14554                                            SelectionDAG &DAG) const {
14555   SDValue N0 = Op.getOperand(0);
14556   SDLoc dl(Op);
14557
14558   if (Op.getValueType().isVector())
14559     return lowerUINT_TO_FP_vec(Op, DAG);
14560
14561   // Since UINT_TO_FP is legal (it's marked custom), dag combiner won't
14562   // optimize it to a SINT_TO_FP when the sign bit is known zero. Perform
14563   // the optimization here.
14564   if (DAG.SignBitIsZero(N0))
14565     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
14566
14567   MVT SrcVT = N0.getSimpleValueType();
14568   MVT DstVT = Op.getSimpleValueType();
14569   if (SrcVT == MVT::i64 && DstVT == MVT::f64 && X86ScalarSSEf64)
14570     return LowerUINT_TO_FP_i64(Op, DAG);
14571   if (SrcVT == MVT::i32 && X86ScalarSSEf64)
14572     return LowerUINT_TO_FP_i32(Op, DAG);
14573   if (Subtarget->is64Bit() && SrcVT == MVT::i64 && DstVT == MVT::f32)
14574     return SDValue();
14575
14576   // Make a 64-bit buffer, and use it to build an FILD.
14577   SDValue StackSlot = DAG.CreateStackTemporary(MVT::i64);
14578   if (SrcVT == MVT::i32) {
14579     SDValue WordOff = DAG.getConstant(4, getPointerTy());
14580     SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
14581                                      getPointerTy(), StackSlot, WordOff);
14582     SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
14583                                   StackSlot, MachinePointerInfo(),
14584                                   false, false, 0);
14585     SDValue Store2 = DAG.getStore(Store1, dl, DAG.getConstant(0, MVT::i32),
14586                                   OffsetSlot, MachinePointerInfo(),
14587                                   false, false, 0);
14588     SDValue Fild = BuildFILD(Op, MVT::i64, Store2, StackSlot, DAG);
14589     return Fild;
14590   }
14591
14592   assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
14593   SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
14594                                StackSlot, MachinePointerInfo(),
14595                                false, false, 0);
14596   // For i64 source, we need to add the appropriate power of 2 if the input
14597   // was negative.  This is the same as the optimization in
14598   // DAGTypeLegalizer::ExpandIntOp_UNIT_TO_FP, and for it to be safe here,
14599   // we must be careful to do the computation in x87 extended precision, not
14600   // in SSE. (The generic code can't know it's OK to do this, or how to.)
14601   int SSFI = cast<FrameIndexSDNode>(StackSlot)->getIndex();
14602   MachineMemOperand *MMO =
14603     DAG.getMachineFunction()
14604     .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14605                           MachineMemOperand::MOLoad, 8, 8);
14606
14607   SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other);
14608   SDValue Ops[] = { Store, StackSlot, DAG.getValueType(MVT::i64) };
14609   SDValue Fild = DAG.getMemIntrinsicNode(X86ISD::FILD, dl, Tys, Ops,
14610                                          MVT::i64, MMO);
14611
14612   APInt FF(32, 0x5F800000ULL);
14613
14614   // Check whether the sign bit is set.
14615   SDValue SignSet = DAG.getSetCC(dl,
14616                                  getSetCCResultType(*DAG.getContext(), MVT::i64),
14617                                  Op.getOperand(0), DAG.getConstant(0, MVT::i64),
14618                                  ISD::SETLT);
14619
14620   // Build a 64 bit pair (0, FF) in the constant pool, with FF in the lo bits.
14621   SDValue FudgePtr = DAG.getConstantPool(
14622                              ConstantInt::get(*DAG.getContext(), FF.zext(64)),
14623                                          getPointerTy());
14624
14625   // Get a pointer to FF if the sign bit was set, or to 0 otherwise.
14626   SDValue Zero = DAG.getIntPtrConstant(0);
14627   SDValue Four = DAG.getIntPtrConstant(4);
14628   SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
14629                                Zero, Four);
14630   FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
14631
14632   // Load the value out, extending it from f32 to f80.
14633   // FIXME: Avoid the extend by constructing the right constant pool?
14634   SDValue Fudge = DAG.getExtLoad(ISD::EXTLOAD, dl, MVT::f80, DAG.getEntryNode(),
14635                                  FudgePtr, MachinePointerInfo::getConstantPool(),
14636                                  MVT::f32, false, false, false, 4);
14637   // Extend everything to 80 bits to force it to be done on x87.
14638   SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
14639   return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
14640 }
14641
14642 std::pair<SDValue,SDValue>
14643 X86TargetLowering:: FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG,
14644                                     bool IsSigned, bool IsReplace) const {
14645   SDLoc DL(Op);
14646
14647   EVT DstTy = Op.getValueType();
14648
14649   if (!IsSigned && !isIntegerTypeFTOL(DstTy)) {
14650     assert(DstTy == MVT::i32 && "Unexpected FP_TO_UINT");
14651     DstTy = MVT::i64;
14652   }
14653
14654   assert(DstTy.getSimpleVT() <= MVT::i64 &&
14655          DstTy.getSimpleVT() >= MVT::i16 &&
14656          "Unknown FP_TO_INT to lower!");
14657
14658   // These are really Legal.
14659   if (DstTy == MVT::i32 &&
14660       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
14661     return std::make_pair(SDValue(), SDValue());
14662   if (Subtarget->is64Bit() &&
14663       DstTy == MVT::i64 &&
14664       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
14665     return std::make_pair(SDValue(), SDValue());
14666
14667   // We lower FP->int64 either into FISTP64 followed by a load from a temporary
14668   // stack slot, or into the FTOL runtime function.
14669   MachineFunction &MF = DAG.getMachineFunction();
14670   unsigned MemSize = DstTy.getSizeInBits()/8;
14671   int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
14672   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14673
14674   unsigned Opc;
14675   if (!IsSigned && isIntegerTypeFTOL(DstTy))
14676     Opc = X86ISD::WIN_FTOL;
14677   else
14678     switch (DstTy.getSimpleVT().SimpleTy) {
14679     default: llvm_unreachable("Invalid FP_TO_SINT to lower!");
14680     case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
14681     case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
14682     case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
14683     }
14684
14685   SDValue Chain = DAG.getEntryNode();
14686   SDValue Value = Op.getOperand(0);
14687   EVT TheVT = Op.getOperand(0).getValueType();
14688   // FIXME This causes a redundant load/store if the SSE-class value is already
14689   // in memory, such as if it is on the callstack.
14690   if (isScalarFPTypeInSSEReg(TheVT)) {
14691     assert(DstTy == MVT::i64 && "Invalid FP_TO_SINT to lower!");
14692     Chain = DAG.getStore(Chain, DL, Value, StackSlot,
14693                          MachinePointerInfo::getFixedStack(SSFI),
14694                          false, false, 0);
14695     SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other);
14696     SDValue Ops[] = {
14697       Chain, StackSlot, DAG.getValueType(TheVT)
14698     };
14699
14700     MachineMemOperand *MMO =
14701       MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14702                               MachineMemOperand::MOLoad, MemSize, MemSize);
14703     Value = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops, DstTy, MMO);
14704     Chain = Value.getValue(1);
14705     SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
14706     StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14707   }
14708
14709   MachineMemOperand *MMO =
14710     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14711                             MachineMemOperand::MOStore, MemSize, MemSize);
14712
14713   if (Opc != X86ISD::WIN_FTOL) {
14714     // Build the FP_TO_INT*_IN_MEM
14715     SDValue Ops[] = { Chain, Value, StackSlot };
14716     SDValue FIST = DAG.getMemIntrinsicNode(Opc, DL, DAG.getVTList(MVT::Other),
14717                                            Ops, DstTy, MMO);
14718     return std::make_pair(FIST, StackSlot);
14719   } else {
14720     SDValue ftol = DAG.getNode(X86ISD::WIN_FTOL, DL,
14721       DAG.getVTList(MVT::Other, MVT::Glue),
14722       Chain, Value);
14723     SDValue eax = DAG.getCopyFromReg(ftol, DL, X86::EAX,
14724       MVT::i32, ftol.getValue(1));
14725     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), DL, X86::EDX,
14726       MVT::i32, eax.getValue(2));
14727     SDValue Ops[] = { eax, edx };
14728     SDValue pair = IsReplace
14729       ? DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops)
14730       : DAG.getMergeValues(Ops, DL);
14731     return std::make_pair(pair, SDValue());
14732   }
14733 }
14734
14735 static SDValue LowerAVXExtend(SDValue Op, SelectionDAG &DAG,
14736                               const X86Subtarget *Subtarget) {
14737   MVT VT = Op->getSimpleValueType(0);
14738   SDValue In = Op->getOperand(0);
14739   MVT InVT = In.getSimpleValueType();
14740   SDLoc dl(Op);
14741
14742   // Optimize vectors in AVX mode:
14743   //
14744   //   v8i16 -> v8i32
14745   //   Use vpunpcklwd for 4 lower elements  v8i16 -> v4i32.
14746   //   Use vpunpckhwd for 4 upper elements  v8i16 -> v4i32.
14747   //   Concat upper and lower parts.
14748   //
14749   //   v4i32 -> v4i64
14750   //   Use vpunpckldq for 4 lower elements  v4i32 -> v2i64.
14751   //   Use vpunpckhdq for 4 upper elements  v4i32 -> v2i64.
14752   //   Concat upper and lower parts.
14753   //
14754
14755   if (((VT != MVT::v16i16) || (InVT != MVT::v16i8)) &&
14756       ((VT != MVT::v8i32) || (InVT != MVT::v8i16)) &&
14757       ((VT != MVT::v4i64) || (InVT != MVT::v4i32)))
14758     return SDValue();
14759
14760   if (Subtarget->hasInt256())
14761     return DAG.getNode(X86ISD::VZEXT, dl, VT, In);
14762
14763   SDValue ZeroVec = getZeroVector(InVT, Subtarget, DAG, dl);
14764   SDValue Undef = DAG.getUNDEF(InVT);
14765   bool NeedZero = Op.getOpcode() == ISD::ZERO_EXTEND;
14766   SDValue OpLo = getUnpackl(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
14767   SDValue OpHi = getUnpackh(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
14768
14769   MVT HVT = MVT::getVectorVT(VT.getVectorElementType(),
14770                              VT.getVectorNumElements()/2);
14771
14772   OpLo = DAG.getNode(ISD::BITCAST, dl, HVT, OpLo);
14773   OpHi = DAG.getNode(ISD::BITCAST, dl, HVT, OpHi);
14774
14775   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
14776 }
14777
14778 static  SDValue LowerZERO_EXTEND_AVX512(SDValue Op,
14779                                         SelectionDAG &DAG) {
14780   MVT VT = Op->getSimpleValueType(0);
14781   SDValue In = Op->getOperand(0);
14782   MVT InVT = In.getSimpleValueType();
14783   SDLoc DL(Op);
14784   unsigned int NumElts = VT.getVectorNumElements();
14785   if (NumElts != 8 && NumElts != 16)
14786     return SDValue();
14787
14788   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1)
14789     return DAG.getNode(X86ISD::VZEXT, DL, VT, In);
14790
14791   EVT ExtVT = (NumElts == 8)? MVT::v8i64 : MVT::v16i32;
14792   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14793   // Now we have only mask extension
14794   assert(InVT.getVectorElementType() == MVT::i1);
14795   SDValue Cst = DAG.getTargetConstant(1, ExtVT.getScalarType());
14796   const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
14797   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
14798   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
14799   SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
14800                            MachinePointerInfo::getConstantPool(),
14801                            false, false, false, Alignment);
14802
14803   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, DL, ExtVT, In, Ld);
14804   if (VT.is512BitVector())
14805     return Brcst;
14806   return DAG.getNode(X86ISD::VTRUNC, DL, VT, Brcst);
14807 }
14808
14809 static SDValue LowerANY_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
14810                                SelectionDAG &DAG) {
14811   if (Subtarget->hasFp256()) {
14812     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
14813     if (Res.getNode())
14814       return Res;
14815   }
14816
14817   return SDValue();
14818 }
14819
14820 static SDValue LowerZERO_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
14821                                 SelectionDAG &DAG) {
14822   SDLoc DL(Op);
14823   MVT VT = Op.getSimpleValueType();
14824   SDValue In = Op.getOperand(0);
14825   MVT SVT = In.getSimpleValueType();
14826
14827   if (VT.is512BitVector() || SVT.getVectorElementType() == MVT::i1)
14828     return LowerZERO_EXTEND_AVX512(Op, DAG);
14829
14830   if (Subtarget->hasFp256()) {
14831     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
14832     if (Res.getNode())
14833       return Res;
14834   }
14835
14836   assert(!VT.is256BitVector() || !SVT.is128BitVector() ||
14837          VT.getVectorNumElements() != SVT.getVectorNumElements());
14838   return SDValue();
14839 }
14840
14841 SDValue X86TargetLowering::LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const {
14842   SDLoc DL(Op);
14843   MVT VT = Op.getSimpleValueType();
14844   SDValue In = Op.getOperand(0);
14845   MVT InVT = In.getSimpleValueType();
14846
14847   if (VT == MVT::i1) {
14848     assert((InVT.isInteger() && (InVT.getSizeInBits() <= 64)) &&
14849            "Invalid scalar TRUNCATE operation");
14850     if (InVT.getSizeInBits() >= 32)
14851       return SDValue();
14852     In = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, In);
14853     return DAG.getNode(ISD::TRUNCATE, DL, VT, In);
14854   }
14855   assert(VT.getVectorNumElements() == InVT.getVectorNumElements() &&
14856          "Invalid TRUNCATE operation");
14857
14858   if (InVT.is512BitVector() || VT.getVectorElementType() == MVT::i1) {
14859     if (VT.getVectorElementType().getSizeInBits() >=8)
14860       return DAG.getNode(X86ISD::VTRUNC, DL, VT, In);
14861
14862     assert(VT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
14863     unsigned NumElts = InVT.getVectorNumElements();
14864     assert ((NumElts == 8 || NumElts == 16) && "Unexpected vector type");
14865     if (InVT.getSizeInBits() < 512) {
14866       MVT ExtVT = (NumElts == 16)? MVT::v16i32 : MVT::v8i64;
14867       In = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, In);
14868       InVT = ExtVT;
14869     }
14870
14871     SDValue Cst = DAG.getTargetConstant(1, InVT.getVectorElementType());
14872     const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
14873     SDValue CP = DAG.getConstantPool(C, getPointerTy());
14874     unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
14875     SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
14876                            MachinePointerInfo::getConstantPool(),
14877                            false, false, false, Alignment);
14878     SDValue OneV = DAG.getNode(X86ISD::VBROADCAST, DL, InVT, Ld);
14879     SDValue And = DAG.getNode(ISD::AND, DL, InVT, OneV, In);
14880     return DAG.getNode(X86ISD::TESTM, DL, VT, And, And);
14881   }
14882
14883   if ((VT == MVT::v4i32) && (InVT == MVT::v4i64)) {
14884     // On AVX2, v4i64 -> v4i32 becomes VPERMD.
14885     if (Subtarget->hasInt256()) {
14886       static const int ShufMask[] = {0, 2, 4, 6, -1, -1, -1, -1};
14887       In = DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, In);
14888       In = DAG.getVectorShuffle(MVT::v8i32, DL, In, DAG.getUNDEF(MVT::v8i32),
14889                                 ShufMask);
14890       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, In,
14891                          DAG.getIntPtrConstant(0));
14892     }
14893
14894     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14895                                DAG.getIntPtrConstant(0));
14896     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14897                                DAG.getIntPtrConstant(2));
14898     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
14899     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
14900     static const int ShufMask[] = {0, 2, 4, 6};
14901     return DAG.getVectorShuffle(VT, DL, OpLo, OpHi, ShufMask);
14902   }
14903
14904   if ((VT == MVT::v8i16) && (InVT == MVT::v8i32)) {
14905     // On AVX2, v8i32 -> v8i16 becomed PSHUFB.
14906     if (Subtarget->hasInt256()) {
14907       In = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, In);
14908
14909       SmallVector<SDValue,32> pshufbMask;
14910       for (unsigned i = 0; i < 2; ++i) {
14911         pshufbMask.push_back(DAG.getConstant(0x0, MVT::i8));
14912         pshufbMask.push_back(DAG.getConstant(0x1, MVT::i8));
14913         pshufbMask.push_back(DAG.getConstant(0x4, MVT::i8));
14914         pshufbMask.push_back(DAG.getConstant(0x5, MVT::i8));
14915         pshufbMask.push_back(DAG.getConstant(0x8, MVT::i8));
14916         pshufbMask.push_back(DAG.getConstant(0x9, MVT::i8));
14917         pshufbMask.push_back(DAG.getConstant(0xc, MVT::i8));
14918         pshufbMask.push_back(DAG.getConstant(0xd, MVT::i8));
14919         for (unsigned j = 0; j < 8; ++j)
14920           pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
14921       }
14922       SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, pshufbMask);
14923       In = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v32i8, In, BV);
14924       In = DAG.getNode(ISD::BITCAST, DL, MVT::v4i64, In);
14925
14926       static const int ShufMask[] = {0,  2,  -1,  -1};
14927       In = DAG.getVectorShuffle(MVT::v4i64, DL,  In, DAG.getUNDEF(MVT::v4i64),
14928                                 &ShufMask[0]);
14929       In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14930                        DAG.getIntPtrConstant(0));
14931       return DAG.getNode(ISD::BITCAST, DL, VT, In);
14932     }
14933
14934     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
14935                                DAG.getIntPtrConstant(0));
14936
14937     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
14938                                DAG.getIntPtrConstant(4));
14939
14940     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpLo);
14941     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpHi);
14942
14943     // The PSHUFB mask:
14944     static const int ShufMask1[] = {0,  1,  4,  5,  8,  9, 12, 13,
14945                                    -1, -1, -1, -1, -1, -1, -1, -1};
14946
14947     SDValue Undef = DAG.getUNDEF(MVT::v16i8);
14948     OpLo = DAG.getVectorShuffle(MVT::v16i8, DL, OpLo, Undef, ShufMask1);
14949     OpHi = DAG.getVectorShuffle(MVT::v16i8, DL, OpHi, Undef, ShufMask1);
14950
14951     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
14952     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
14953
14954     // The MOVLHPS Mask:
14955     static const int ShufMask2[] = {0, 1, 4, 5};
14956     SDValue res = DAG.getVectorShuffle(MVT::v4i32, DL, OpLo, OpHi, ShufMask2);
14957     return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, res);
14958   }
14959
14960   // Handle truncation of V256 to V128 using shuffles.
14961   if (!VT.is128BitVector() || !InVT.is256BitVector())
14962     return SDValue();
14963
14964   assert(Subtarget->hasFp256() && "256-bit vector without AVX!");
14965
14966   unsigned NumElems = VT.getVectorNumElements();
14967   MVT NVT = MVT::getVectorVT(VT.getVectorElementType(), NumElems * 2);
14968
14969   SmallVector<int, 16> MaskVec(NumElems * 2, -1);
14970   // Prepare truncation shuffle mask
14971   for (unsigned i = 0; i != NumElems; ++i)
14972     MaskVec[i] = i * 2;
14973   SDValue V = DAG.getVectorShuffle(NVT, DL,
14974                                    DAG.getNode(ISD::BITCAST, DL, NVT, In),
14975                                    DAG.getUNDEF(NVT), &MaskVec[0]);
14976   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, V,
14977                      DAG.getIntPtrConstant(0));
14978 }
14979
14980 SDValue X86TargetLowering::LowerFP_TO_SINT(SDValue Op,
14981                                            SelectionDAG &DAG) const {
14982   assert(!Op.getSimpleValueType().isVector());
14983
14984   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
14985     /*IsSigned=*/ true, /*IsReplace=*/ false);
14986   SDValue FIST = Vals.first, StackSlot = Vals.second;
14987   // If FP_TO_INTHelper failed, the node is actually supposed to be Legal.
14988   if (!FIST.getNode()) return Op;
14989
14990   if (StackSlot.getNode())
14991     // Load the result.
14992     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
14993                        FIST, StackSlot, MachinePointerInfo(),
14994                        false, false, false, 0);
14995
14996   // The node is the result.
14997   return FIST;
14998 }
14999
15000 SDValue X86TargetLowering::LowerFP_TO_UINT(SDValue Op,
15001                                            SelectionDAG &DAG) const {
15002   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
15003     /*IsSigned=*/ false, /*IsReplace=*/ false);
15004   SDValue FIST = Vals.first, StackSlot = Vals.second;
15005   assert(FIST.getNode() && "Unexpected failure");
15006
15007   if (StackSlot.getNode())
15008     // Load the result.
15009     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
15010                        FIST, StackSlot, MachinePointerInfo(),
15011                        false, false, false, 0);
15012
15013   // The node is the result.
15014   return FIST;
15015 }
15016
15017 static SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) {
15018   SDLoc DL(Op);
15019   MVT VT = Op.getSimpleValueType();
15020   SDValue In = Op.getOperand(0);
15021   MVT SVT = In.getSimpleValueType();
15022
15023   assert(SVT == MVT::v2f32 && "Only customize MVT::v2f32 type legalization!");
15024
15025   return DAG.getNode(X86ISD::VFPEXT, DL, VT,
15026                      DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4f32,
15027                                  In, DAG.getUNDEF(SVT)));
15028 }
15029
15030 /// The only differences between FABS and FNEG are the mask and the logic op.
15031 /// FNEG also has a folding opportunity for FNEG(FABS(x)).
15032 static SDValue LowerFABSorFNEG(SDValue Op, SelectionDAG &DAG) {
15033   assert((Op.getOpcode() == ISD::FABS || Op.getOpcode() == ISD::FNEG) &&
15034          "Wrong opcode for lowering FABS or FNEG.");
15035
15036   bool IsFABS = (Op.getOpcode() == ISD::FABS);
15037
15038   // If this is a FABS and it has an FNEG user, bail out to fold the combination
15039   // into an FNABS. We'll lower the FABS after that if it is still in use.
15040   if (IsFABS)
15041     for (SDNode *User : Op->uses())
15042       if (User->getOpcode() == ISD::FNEG)
15043         return Op;
15044
15045   SDValue Op0 = Op.getOperand(0);
15046   bool IsFNABS = !IsFABS && (Op0.getOpcode() == ISD::FABS);
15047
15048   SDLoc dl(Op);
15049   MVT VT = Op.getSimpleValueType();
15050   // Assume scalar op for initialization; update for vector if needed.
15051   // Note that there are no scalar bitwise logical SSE/AVX instructions, so we
15052   // generate a 16-byte vector constant and logic op even for the scalar case.
15053   // Using a 16-byte mask allows folding the load of the mask with
15054   // the logic op, so it can save (~4 bytes) on code size.
15055   MVT EltVT = VT;
15056   unsigned NumElts = VT == MVT::f64 ? 2 : 4;
15057   // FIXME: Use function attribute "OptimizeForSize" and/or CodeGenOpt::Level to
15058   // decide if we should generate a 16-byte constant mask when we only need 4 or
15059   // 8 bytes for the scalar case.
15060   if (VT.isVector()) {
15061     EltVT = VT.getVectorElementType();
15062     NumElts = VT.getVectorNumElements();
15063   }
15064
15065   unsigned EltBits = EltVT.getSizeInBits();
15066   LLVMContext *Context = DAG.getContext();
15067   // For FABS, mask is 0x7f...; for FNEG, mask is 0x80...
15068   APInt MaskElt =
15069     IsFABS ? APInt::getSignedMaxValue(EltBits) : APInt::getSignBit(EltBits);
15070   Constant *C = ConstantInt::get(*Context, MaskElt);
15071   C = ConstantVector::getSplat(NumElts, C);
15072   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
15073   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy());
15074   unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment();
15075   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
15076                              MachinePointerInfo::getConstantPool(),
15077                              false, false, false, Alignment);
15078
15079   if (VT.isVector()) {
15080     // For a vector, cast operands to a vector type, perform the logic op,
15081     // and cast the result back to the original value type.
15082     MVT VecVT = MVT::getVectorVT(MVT::i64, VT.getSizeInBits() / 64);
15083     SDValue MaskCasted = DAG.getNode(ISD::BITCAST, dl, VecVT, Mask);
15084     SDValue Operand = IsFNABS ?
15085       DAG.getNode(ISD::BITCAST, dl, VecVT, Op0.getOperand(0)) :
15086       DAG.getNode(ISD::BITCAST, dl, VecVT, Op0);
15087     unsigned BitOp = IsFABS ? ISD::AND : IsFNABS ? ISD::OR : ISD::XOR;
15088     return DAG.getNode(ISD::BITCAST, dl, VT,
15089                        DAG.getNode(BitOp, dl, VecVT, Operand, MaskCasted));
15090   }
15091
15092   // If not vector, then scalar.
15093   unsigned BitOp = IsFABS ? X86ISD::FAND : IsFNABS ? X86ISD::FOR : X86ISD::FXOR;
15094   SDValue Operand = IsFNABS ? Op0.getOperand(0) : Op0;
15095   return DAG.getNode(BitOp, dl, VT, Operand, Mask);
15096 }
15097
15098 static SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) {
15099   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
15100   LLVMContext *Context = DAG.getContext();
15101   SDValue Op0 = Op.getOperand(0);
15102   SDValue Op1 = Op.getOperand(1);
15103   SDLoc dl(Op);
15104   MVT VT = Op.getSimpleValueType();
15105   MVT SrcVT = Op1.getSimpleValueType();
15106
15107   // If second operand is smaller, extend it first.
15108   if (SrcVT.bitsLT(VT)) {
15109     Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
15110     SrcVT = VT;
15111   }
15112   // And if it is bigger, shrink it first.
15113   if (SrcVT.bitsGT(VT)) {
15114     Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
15115     SrcVT = VT;
15116   }
15117
15118   // At this point the operands and the result should have the same
15119   // type, and that won't be f80 since that is not custom lowered.
15120
15121   const fltSemantics &Sem =
15122       VT == MVT::f64 ? APFloat::IEEEdouble : APFloat::IEEEsingle;
15123   const unsigned SizeInBits = VT.getSizeInBits();
15124
15125   SmallVector<Constant *, 4> CV(
15126       VT == MVT::f64 ? 2 : 4,
15127       ConstantFP::get(*Context, APFloat(Sem, APInt(SizeInBits, 0))));
15128
15129   // First, clear all bits but the sign bit from the second operand (sign).
15130   CV[0] = ConstantFP::get(*Context,
15131                           APFloat(Sem, APInt::getHighBitsSet(SizeInBits, 1)));
15132   Constant *C = ConstantVector::get(CV);
15133   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
15134   SDValue Mask1 = DAG.getLoad(SrcVT, dl, DAG.getEntryNode(), CPIdx,
15135                               MachinePointerInfo::getConstantPool(),
15136                               false, false, false, 16);
15137   SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
15138
15139   // Next, clear the sign bit from the first operand (magnitude).
15140   // If it's a constant, we can clear it here.
15141   if (ConstantFPSDNode *Op0CN = dyn_cast<ConstantFPSDNode>(Op0)) {
15142     APFloat APF = Op0CN->getValueAPF();
15143     // If the magnitude is a positive zero, the sign bit alone is enough.
15144     if (APF.isPosZero())
15145       return SignBit;
15146     APF.clearSign();
15147     CV[0] = ConstantFP::get(*Context, APF);
15148   } else {
15149     CV[0] = ConstantFP::get(
15150         *Context,
15151         APFloat(Sem, APInt::getLowBitsSet(SizeInBits, SizeInBits - 1)));
15152   }
15153   C = ConstantVector::get(CV);
15154   CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
15155   SDValue Val = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
15156                             MachinePointerInfo::getConstantPool(),
15157                             false, false, false, 16);
15158   // If the magnitude operand wasn't a constant, we need to AND out the sign.
15159   if (!isa<ConstantFPSDNode>(Op0))
15160     Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Val);
15161
15162   // OR the magnitude value with the sign bit.
15163   return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
15164 }
15165
15166 static SDValue LowerFGETSIGN(SDValue Op, SelectionDAG &DAG) {
15167   SDValue N0 = Op.getOperand(0);
15168   SDLoc dl(Op);
15169   MVT VT = Op.getSimpleValueType();
15170
15171   // Lower ISD::FGETSIGN to (AND (X86ISD::FGETSIGNx86 ...) 1).
15172   SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
15173                                   DAG.getConstant(1, VT));
15174   return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
15175 }
15176
15177 // Check whether an OR'd tree is PTEST-able.
15178 static SDValue LowerVectorAllZeroTest(SDValue Op, const X86Subtarget *Subtarget,
15179                                       SelectionDAG &DAG) {
15180   assert(Op.getOpcode() == ISD::OR && "Only check OR'd tree.");
15181
15182   if (!Subtarget->hasSSE41())
15183     return SDValue();
15184
15185   if (!Op->hasOneUse())
15186     return SDValue();
15187
15188   SDNode *N = Op.getNode();
15189   SDLoc DL(N);
15190
15191   SmallVector<SDValue, 8> Opnds;
15192   DenseMap<SDValue, unsigned> VecInMap;
15193   SmallVector<SDValue, 8> VecIns;
15194   EVT VT = MVT::Other;
15195
15196   // Recognize a special case where a vector is casted into wide integer to
15197   // test all 0s.
15198   Opnds.push_back(N->getOperand(0));
15199   Opnds.push_back(N->getOperand(1));
15200
15201   for (unsigned Slot = 0, e = Opnds.size(); Slot < e; ++Slot) {
15202     SmallVectorImpl<SDValue>::const_iterator I = Opnds.begin() + Slot;
15203     // BFS traverse all OR'd operands.
15204     if (I->getOpcode() == ISD::OR) {
15205       Opnds.push_back(I->getOperand(0));
15206       Opnds.push_back(I->getOperand(1));
15207       // Re-evaluate the number of nodes to be traversed.
15208       e += 2; // 2 more nodes (LHS and RHS) are pushed.
15209       continue;
15210     }
15211
15212     // Quit if a non-EXTRACT_VECTOR_ELT
15213     if (I->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
15214       return SDValue();
15215
15216     // Quit if without a constant index.
15217     SDValue Idx = I->getOperand(1);
15218     if (!isa<ConstantSDNode>(Idx))
15219       return SDValue();
15220
15221     SDValue ExtractedFromVec = I->getOperand(0);
15222     DenseMap<SDValue, unsigned>::iterator M = VecInMap.find(ExtractedFromVec);
15223     if (M == VecInMap.end()) {
15224       VT = ExtractedFromVec.getValueType();
15225       // Quit if not 128/256-bit vector.
15226       if (!VT.is128BitVector() && !VT.is256BitVector())
15227         return SDValue();
15228       // Quit if not the same type.
15229       if (VecInMap.begin() != VecInMap.end() &&
15230           VT != VecInMap.begin()->first.getValueType())
15231         return SDValue();
15232       M = VecInMap.insert(std::make_pair(ExtractedFromVec, 0)).first;
15233       VecIns.push_back(ExtractedFromVec);
15234     }
15235     M->second |= 1U << cast<ConstantSDNode>(Idx)->getZExtValue();
15236   }
15237
15238   assert((VT.is128BitVector() || VT.is256BitVector()) &&
15239          "Not extracted from 128-/256-bit vector.");
15240
15241   unsigned FullMask = (1U << VT.getVectorNumElements()) - 1U;
15242
15243   for (DenseMap<SDValue, unsigned>::const_iterator
15244         I = VecInMap.begin(), E = VecInMap.end(); I != E; ++I) {
15245     // Quit if not all elements are used.
15246     if (I->second != FullMask)
15247       return SDValue();
15248   }
15249
15250   EVT TestVT = VT.is128BitVector() ? MVT::v2i64 : MVT::v4i64;
15251
15252   // Cast all vectors into TestVT for PTEST.
15253   for (unsigned i = 0, e = VecIns.size(); i < e; ++i)
15254     VecIns[i] = DAG.getNode(ISD::BITCAST, DL, TestVT, VecIns[i]);
15255
15256   // If more than one full vectors are evaluated, OR them first before PTEST.
15257   for (unsigned Slot = 0, e = VecIns.size(); e - Slot > 1; Slot += 2, e += 1) {
15258     // Each iteration will OR 2 nodes and append the result until there is only
15259     // 1 node left, i.e. the final OR'd value of all vectors.
15260     SDValue LHS = VecIns[Slot];
15261     SDValue RHS = VecIns[Slot + 1];
15262     VecIns.push_back(DAG.getNode(ISD::OR, DL, TestVT, LHS, RHS));
15263   }
15264
15265   return DAG.getNode(X86ISD::PTEST, DL, MVT::i32,
15266                      VecIns.back(), VecIns.back());
15267 }
15268
15269 /// \brief return true if \c Op has a use that doesn't just read flags.
15270 static bool hasNonFlagsUse(SDValue Op) {
15271   for (SDNode::use_iterator UI = Op->use_begin(), UE = Op->use_end(); UI != UE;
15272        ++UI) {
15273     SDNode *User = *UI;
15274     unsigned UOpNo = UI.getOperandNo();
15275     if (User->getOpcode() == ISD::TRUNCATE && User->hasOneUse()) {
15276       // Look pass truncate.
15277       UOpNo = User->use_begin().getOperandNo();
15278       User = *User->use_begin();
15279     }
15280
15281     if (User->getOpcode() != ISD::BRCOND && User->getOpcode() != ISD::SETCC &&
15282         !(User->getOpcode() == ISD::SELECT && UOpNo == 0))
15283       return true;
15284   }
15285   return false;
15286 }
15287
15288 /// Emit nodes that will be selected as "test Op0,Op0", or something
15289 /// equivalent.
15290 SDValue X86TargetLowering::EmitTest(SDValue Op, unsigned X86CC, SDLoc dl,
15291                                     SelectionDAG &DAG) const {
15292   if (Op.getValueType() == MVT::i1) {
15293     SDValue ExtOp = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i8, Op);
15294     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, ExtOp,
15295                        DAG.getConstant(0, MVT::i8));
15296   }
15297   // CF and OF aren't always set the way we want. Determine which
15298   // of these we need.
15299   bool NeedCF = false;
15300   bool NeedOF = false;
15301   switch (X86CC) {
15302   default: break;
15303   case X86::COND_A: case X86::COND_AE:
15304   case X86::COND_B: case X86::COND_BE:
15305     NeedCF = true;
15306     break;
15307   case X86::COND_G: case X86::COND_GE:
15308   case X86::COND_L: case X86::COND_LE:
15309   case X86::COND_O: case X86::COND_NO: {
15310     // Check if we really need to set the
15311     // Overflow flag. If NoSignedWrap is present
15312     // that is not actually needed.
15313     switch (Op->getOpcode()) {
15314     case ISD::ADD:
15315     case ISD::SUB:
15316     case ISD::MUL:
15317     case ISD::SHL: {
15318       const BinaryWithFlagsSDNode *BinNode =
15319           cast<BinaryWithFlagsSDNode>(Op.getNode());
15320       if (BinNode->hasNoSignedWrap())
15321         break;
15322     }
15323     default:
15324       NeedOF = true;
15325       break;
15326     }
15327     break;
15328   }
15329   }
15330   // See if we can use the EFLAGS value from the operand instead of
15331   // doing a separate TEST. TEST always sets OF and CF to 0, so unless
15332   // we prove that the arithmetic won't overflow, we can't use OF or CF.
15333   if (Op.getResNo() != 0 || NeedOF || NeedCF) {
15334     // Emit a CMP with 0, which is the TEST pattern.
15335     //if (Op.getValueType() == MVT::i1)
15336     //  return DAG.getNode(X86ISD::CMP, dl, MVT::i1, Op,
15337     //                     DAG.getConstant(0, MVT::i1));
15338     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
15339                        DAG.getConstant(0, Op.getValueType()));
15340   }
15341   unsigned Opcode = 0;
15342   unsigned NumOperands = 0;
15343
15344   // Truncate operations may prevent the merge of the SETCC instruction
15345   // and the arithmetic instruction before it. Attempt to truncate the operands
15346   // of the arithmetic instruction and use a reduced bit-width instruction.
15347   bool NeedTruncation = false;
15348   SDValue ArithOp = Op;
15349   if (Op->getOpcode() == ISD::TRUNCATE && Op->hasOneUse()) {
15350     SDValue Arith = Op->getOperand(0);
15351     // Both the trunc and the arithmetic op need to have one user each.
15352     if (Arith->hasOneUse())
15353       switch (Arith.getOpcode()) {
15354         default: break;
15355         case ISD::ADD:
15356         case ISD::SUB:
15357         case ISD::AND:
15358         case ISD::OR:
15359         case ISD::XOR: {
15360           NeedTruncation = true;
15361           ArithOp = Arith;
15362         }
15363       }
15364   }
15365
15366   // NOTICE: In the code below we use ArithOp to hold the arithmetic operation
15367   // which may be the result of a CAST.  We use the variable 'Op', which is the
15368   // non-casted variable when we check for possible users.
15369   switch (ArithOp.getOpcode()) {
15370   case ISD::ADD:
15371     // Due to an isel shortcoming, be conservative if this add is likely to be
15372     // selected as part of a load-modify-store instruction. When the root node
15373     // in a match is a store, isel doesn't know how to remap non-chain non-flag
15374     // uses of other nodes in the match, such as the ADD in this case. This
15375     // leads to the ADD being left around and reselected, with the result being
15376     // two adds in the output.  Alas, even if none our users are stores, that
15377     // doesn't prove we're O.K.  Ergo, if we have any parents that aren't
15378     // CopyToReg or SETCC, eschew INC/DEC.  A better fix seems to require
15379     // climbing the DAG back to the root, and it doesn't seem to be worth the
15380     // effort.
15381     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
15382          UE = Op.getNode()->use_end(); UI != UE; ++UI)
15383       if (UI->getOpcode() != ISD::CopyToReg &&
15384           UI->getOpcode() != ISD::SETCC &&
15385           UI->getOpcode() != ISD::STORE)
15386         goto default_case;
15387
15388     if (ConstantSDNode *C =
15389         dyn_cast<ConstantSDNode>(ArithOp.getNode()->getOperand(1))) {
15390       // An add of one will be selected as an INC.
15391       if (C->getAPIntValue() == 1 && !Subtarget->slowIncDec()) {
15392         Opcode = X86ISD::INC;
15393         NumOperands = 1;
15394         break;
15395       }
15396
15397       // An add of negative one (subtract of one) will be selected as a DEC.
15398       if (C->getAPIntValue().isAllOnesValue() && !Subtarget->slowIncDec()) {
15399         Opcode = X86ISD::DEC;
15400         NumOperands = 1;
15401         break;
15402       }
15403     }
15404
15405     // Otherwise use a regular EFLAGS-setting add.
15406     Opcode = X86ISD::ADD;
15407     NumOperands = 2;
15408     break;
15409   case ISD::SHL:
15410   case ISD::SRL:
15411     // If we have a constant logical shift that's only used in a comparison
15412     // against zero turn it into an equivalent AND. This allows turning it into
15413     // a TEST instruction later.
15414     if ((X86CC == X86::COND_E || X86CC == X86::COND_NE) && Op->hasOneUse() &&
15415         isa<ConstantSDNode>(Op->getOperand(1)) && !hasNonFlagsUse(Op)) {
15416       EVT VT = Op.getValueType();
15417       unsigned BitWidth = VT.getSizeInBits();
15418       unsigned ShAmt = Op->getConstantOperandVal(1);
15419       if (ShAmt >= BitWidth) // Avoid undefined shifts.
15420         break;
15421       APInt Mask = ArithOp.getOpcode() == ISD::SRL
15422                        ? APInt::getHighBitsSet(BitWidth, BitWidth - ShAmt)
15423                        : APInt::getLowBitsSet(BitWidth, BitWidth - ShAmt);
15424       if (!Mask.isSignedIntN(32)) // Avoid large immediates.
15425         break;
15426       SDValue New = DAG.getNode(ISD::AND, dl, VT, Op->getOperand(0),
15427                                 DAG.getConstant(Mask, VT));
15428       DAG.ReplaceAllUsesWith(Op, New);
15429       Op = New;
15430     }
15431     break;
15432
15433   case ISD::AND:
15434     // If the primary and result isn't used, don't bother using X86ISD::AND,
15435     // because a TEST instruction will be better.
15436     if (!hasNonFlagsUse(Op))
15437       break;
15438     // FALL THROUGH
15439   case ISD::SUB:
15440   case ISD::OR:
15441   case ISD::XOR:
15442     // Due to the ISEL shortcoming noted above, be conservative if this op is
15443     // likely to be selected as part of a load-modify-store instruction.
15444     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
15445            UE = Op.getNode()->use_end(); UI != UE; ++UI)
15446       if (UI->getOpcode() == ISD::STORE)
15447         goto default_case;
15448
15449     // Otherwise use a regular EFLAGS-setting instruction.
15450     switch (ArithOp.getOpcode()) {
15451     default: llvm_unreachable("unexpected operator!");
15452     case ISD::SUB: Opcode = X86ISD::SUB; break;
15453     case ISD::XOR: Opcode = X86ISD::XOR; break;
15454     case ISD::AND: Opcode = X86ISD::AND; break;
15455     case ISD::OR: {
15456       if (!NeedTruncation && (X86CC == X86::COND_E || X86CC == X86::COND_NE)) {
15457         SDValue EFLAGS = LowerVectorAllZeroTest(Op, Subtarget, DAG);
15458         if (EFLAGS.getNode())
15459           return EFLAGS;
15460       }
15461       Opcode = X86ISD::OR;
15462       break;
15463     }
15464     }
15465
15466     NumOperands = 2;
15467     break;
15468   case X86ISD::ADD:
15469   case X86ISD::SUB:
15470   case X86ISD::INC:
15471   case X86ISD::DEC:
15472   case X86ISD::OR:
15473   case X86ISD::XOR:
15474   case X86ISD::AND:
15475     return SDValue(Op.getNode(), 1);
15476   default:
15477   default_case:
15478     break;
15479   }
15480
15481   // If we found that truncation is beneficial, perform the truncation and
15482   // update 'Op'.
15483   if (NeedTruncation) {
15484     EVT VT = Op.getValueType();
15485     SDValue WideVal = Op->getOperand(0);
15486     EVT WideVT = WideVal.getValueType();
15487     unsigned ConvertedOp = 0;
15488     // Use a target machine opcode to prevent further DAGCombine
15489     // optimizations that may separate the arithmetic operations
15490     // from the setcc node.
15491     switch (WideVal.getOpcode()) {
15492       default: break;
15493       case ISD::ADD: ConvertedOp = X86ISD::ADD; break;
15494       case ISD::SUB: ConvertedOp = X86ISD::SUB; break;
15495       case ISD::AND: ConvertedOp = X86ISD::AND; break;
15496       case ISD::OR:  ConvertedOp = X86ISD::OR;  break;
15497       case ISD::XOR: ConvertedOp = X86ISD::XOR; break;
15498     }
15499
15500     if (ConvertedOp) {
15501       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
15502       if (TLI.isOperationLegal(WideVal.getOpcode(), WideVT)) {
15503         SDValue V0 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(0));
15504         SDValue V1 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(1));
15505         Op = DAG.getNode(ConvertedOp, dl, VT, V0, V1);
15506       }
15507     }
15508   }
15509
15510   if (Opcode == 0)
15511     // Emit a CMP with 0, which is the TEST pattern.
15512     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
15513                        DAG.getConstant(0, Op.getValueType()));
15514
15515   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
15516   SmallVector<SDValue, 4> Ops(Op->op_begin(), Op->op_begin() + NumOperands);
15517
15518   SDValue New = DAG.getNode(Opcode, dl, VTs, Ops);
15519   DAG.ReplaceAllUsesWith(Op, New);
15520   return SDValue(New.getNode(), 1);
15521 }
15522
15523 /// Emit nodes that will be selected as "cmp Op0,Op1", or something
15524 /// equivalent.
15525 SDValue X86TargetLowering::EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC,
15526                                    SDLoc dl, SelectionDAG &DAG) const {
15527   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op1)) {
15528     if (C->getAPIntValue() == 0)
15529       return EmitTest(Op0, X86CC, dl, DAG);
15530
15531      if (Op0.getValueType() == MVT::i1)
15532        llvm_unreachable("Unexpected comparison operation for MVT::i1 operands");
15533   }
15534
15535   if ((Op0.getValueType() == MVT::i8 || Op0.getValueType() == MVT::i16 ||
15536        Op0.getValueType() == MVT::i32 || Op0.getValueType() == MVT::i64)) {
15537     // Do the comparison at i32 if it's smaller, besides the Atom case.
15538     // This avoids subregister aliasing issues. Keep the smaller reference
15539     // if we're optimizing for size, however, as that'll allow better folding
15540     // of memory operations.
15541     if (Op0.getValueType() != MVT::i32 && Op0.getValueType() != MVT::i64 &&
15542         !DAG.getMachineFunction().getFunction()->hasFnAttribute(
15543             Attribute::MinSize) &&
15544         !Subtarget->isAtom()) {
15545       unsigned ExtendOp =
15546           isX86CCUnsigned(X86CC) ? ISD::ZERO_EXTEND : ISD::SIGN_EXTEND;
15547       Op0 = DAG.getNode(ExtendOp, dl, MVT::i32, Op0);
15548       Op1 = DAG.getNode(ExtendOp, dl, MVT::i32, Op1);
15549     }
15550     // Use SUB instead of CMP to enable CSE between SUB and CMP.
15551     SDVTList VTs = DAG.getVTList(Op0.getValueType(), MVT::i32);
15552     SDValue Sub = DAG.getNode(X86ISD::SUB, dl, VTs,
15553                               Op0, Op1);
15554     return SDValue(Sub.getNode(), 1);
15555   }
15556   return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
15557 }
15558
15559 /// Convert a comparison if required by the subtarget.
15560 SDValue X86TargetLowering::ConvertCmpIfNecessary(SDValue Cmp,
15561                                                  SelectionDAG &DAG) const {
15562   // If the subtarget does not support the FUCOMI instruction, floating-point
15563   // comparisons have to be converted.
15564   if (Subtarget->hasCMov() ||
15565       Cmp.getOpcode() != X86ISD::CMP ||
15566       !Cmp.getOperand(0).getValueType().isFloatingPoint() ||
15567       !Cmp.getOperand(1).getValueType().isFloatingPoint())
15568     return Cmp;
15569
15570   // The instruction selector will select an FUCOM instruction instead of
15571   // FUCOMI, which writes the comparison result to FPSW instead of EFLAGS. Hence
15572   // build an SDNode sequence that transfers the result from FPSW into EFLAGS:
15573   // (X86sahf (trunc (srl (X86fp_stsw (trunc (X86cmp ...)), 8))))
15574   SDLoc dl(Cmp);
15575   SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
15576   SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
15577   SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
15578                             DAG.getConstant(8, MVT::i8));
15579   SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
15580   return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
15581 }
15582
15583 /// The minimum architected relative accuracy is 2^-12. We need one
15584 /// Newton-Raphson step to have a good float result (24 bits of precision).
15585 SDValue X86TargetLowering::getRsqrtEstimate(SDValue Op,
15586                                             DAGCombinerInfo &DCI,
15587                                             unsigned &RefinementSteps,
15588                                             bool &UseOneConstNR) const {
15589   // FIXME: We should use instruction latency models to calculate the cost of
15590   // each potential sequence, but this is very hard to do reliably because
15591   // at least Intel's Core* chips have variable timing based on the number of
15592   // significant digits in the divisor and/or sqrt operand.
15593   if (!Subtarget->useSqrtEst())
15594     return SDValue();
15595
15596   EVT VT = Op.getValueType();
15597
15598   // SSE1 has rsqrtss and rsqrtps.
15599   // TODO: Add support for AVX512 (v16f32).
15600   // It is likely not profitable to do this for f64 because a double-precision
15601   // rsqrt estimate with refinement on x86 prior to FMA requires at least 16
15602   // instructions: convert to single, rsqrtss, convert back to double, refine
15603   // (3 steps = at least 13 insts). If an 'rsqrtsd' variant was added to the ISA
15604   // along with FMA, this could be a throughput win.
15605   if ((Subtarget->hasSSE1() && (VT == MVT::f32 || VT == MVT::v4f32)) ||
15606       (Subtarget->hasAVX() && VT == MVT::v8f32)) {
15607     RefinementSteps = 1;
15608     UseOneConstNR = false;
15609     return DCI.DAG.getNode(X86ISD::FRSQRT, SDLoc(Op), VT, Op);
15610   }
15611   return SDValue();
15612 }
15613
15614 /// The minimum architected relative accuracy is 2^-12. We need one
15615 /// Newton-Raphson step to have a good float result (24 bits of precision).
15616 SDValue X86TargetLowering::getRecipEstimate(SDValue Op,
15617                                             DAGCombinerInfo &DCI,
15618                                             unsigned &RefinementSteps) const {
15619   // FIXME: We should use instruction latency models to calculate the cost of
15620   // each potential sequence, but this is very hard to do reliably because
15621   // at least Intel's Core* chips have variable timing based on the number of
15622   // significant digits in the divisor.
15623   if (!Subtarget->useReciprocalEst())
15624     return SDValue();
15625
15626   EVT VT = Op.getValueType();
15627
15628   // SSE1 has rcpss and rcpps. AVX adds a 256-bit variant for rcpps.
15629   // TODO: Add support for AVX512 (v16f32).
15630   // It is likely not profitable to do this for f64 because a double-precision
15631   // reciprocal estimate with refinement on x86 prior to FMA requires
15632   // 15 instructions: convert to single, rcpss, convert back to double, refine
15633   // (3 steps = 12 insts). If an 'rcpsd' variant was added to the ISA
15634   // along with FMA, this could be a throughput win.
15635   if ((Subtarget->hasSSE1() && (VT == MVT::f32 || VT == MVT::v4f32)) ||
15636       (Subtarget->hasAVX() && VT == MVT::v8f32)) {
15637     RefinementSteps = ReciprocalEstimateRefinementSteps;
15638     return DCI.DAG.getNode(X86ISD::FRCP, SDLoc(Op), VT, Op);
15639   }
15640   return SDValue();
15641 }
15642
15643 static bool isAllOnes(SDValue V) {
15644   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
15645   return C && C->isAllOnesValue();
15646 }
15647
15648 /// LowerToBT - Result of 'and' is compared against zero. Turn it into a BT node
15649 /// if it's possible.
15650 SDValue X86TargetLowering::LowerToBT(SDValue And, ISD::CondCode CC,
15651                                      SDLoc dl, SelectionDAG &DAG) const {
15652   SDValue Op0 = And.getOperand(0);
15653   SDValue Op1 = And.getOperand(1);
15654   if (Op0.getOpcode() == ISD::TRUNCATE)
15655     Op0 = Op0.getOperand(0);
15656   if (Op1.getOpcode() == ISD::TRUNCATE)
15657     Op1 = Op1.getOperand(0);
15658
15659   SDValue LHS, RHS;
15660   if (Op1.getOpcode() == ISD::SHL)
15661     std::swap(Op0, Op1);
15662   if (Op0.getOpcode() == ISD::SHL) {
15663     if (ConstantSDNode *And00C = dyn_cast<ConstantSDNode>(Op0.getOperand(0)))
15664       if (And00C->getZExtValue() == 1) {
15665         // If we looked past a truncate, check that it's only truncating away
15666         // known zeros.
15667         unsigned BitWidth = Op0.getValueSizeInBits();
15668         unsigned AndBitWidth = And.getValueSizeInBits();
15669         if (BitWidth > AndBitWidth) {
15670           APInt Zeros, Ones;
15671           DAG.computeKnownBits(Op0, Zeros, Ones);
15672           if (Zeros.countLeadingOnes() < BitWidth - AndBitWidth)
15673             return SDValue();
15674         }
15675         LHS = Op1;
15676         RHS = Op0.getOperand(1);
15677       }
15678   } else if (Op1.getOpcode() == ISD::Constant) {
15679     ConstantSDNode *AndRHS = cast<ConstantSDNode>(Op1);
15680     uint64_t AndRHSVal = AndRHS->getZExtValue();
15681     SDValue AndLHS = Op0;
15682
15683     if (AndRHSVal == 1 && AndLHS.getOpcode() == ISD::SRL) {
15684       LHS = AndLHS.getOperand(0);
15685       RHS = AndLHS.getOperand(1);
15686     }
15687
15688     // Use BT if the immediate can't be encoded in a TEST instruction.
15689     if (!isUInt<32>(AndRHSVal) && isPowerOf2_64(AndRHSVal)) {
15690       LHS = AndLHS;
15691       RHS = DAG.getConstant(Log2_64_Ceil(AndRHSVal), LHS.getValueType());
15692     }
15693   }
15694
15695   if (LHS.getNode()) {
15696     // If LHS is i8, promote it to i32 with any_extend.  There is no i8 BT
15697     // instruction.  Since the shift amount is in-range-or-undefined, we know
15698     // that doing a bittest on the i32 value is ok.  We extend to i32 because
15699     // the encoding for the i16 version is larger than the i32 version.
15700     // Also promote i16 to i32 for performance / code size reason.
15701     if (LHS.getValueType() == MVT::i8 ||
15702         LHS.getValueType() == MVT::i16)
15703       LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
15704
15705     // If the operand types disagree, extend the shift amount to match.  Since
15706     // BT ignores high bits (like shifts) we can use anyextend.
15707     if (LHS.getValueType() != RHS.getValueType())
15708       RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
15709
15710     SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
15711     X86::CondCode Cond = CC == ISD::SETEQ ? X86::COND_AE : X86::COND_B;
15712     return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
15713                        DAG.getConstant(Cond, MVT::i8), BT);
15714   }
15715
15716   return SDValue();
15717 }
15718
15719 /// \brief - Turns an ISD::CondCode into a value suitable for SSE floating point
15720 /// mask CMPs.
15721 static int translateX86FSETCC(ISD::CondCode SetCCOpcode, SDValue &Op0,
15722                               SDValue &Op1) {
15723   unsigned SSECC;
15724   bool Swap = false;
15725
15726   // SSE Condition code mapping:
15727   //  0 - EQ
15728   //  1 - LT
15729   //  2 - LE
15730   //  3 - UNORD
15731   //  4 - NEQ
15732   //  5 - NLT
15733   //  6 - NLE
15734   //  7 - ORD
15735   switch (SetCCOpcode) {
15736   default: llvm_unreachable("Unexpected SETCC condition");
15737   case ISD::SETOEQ:
15738   case ISD::SETEQ:  SSECC = 0; break;
15739   case ISD::SETOGT:
15740   case ISD::SETGT:  Swap = true; // Fallthrough
15741   case ISD::SETLT:
15742   case ISD::SETOLT: SSECC = 1; break;
15743   case ISD::SETOGE:
15744   case ISD::SETGE:  Swap = true; // Fallthrough
15745   case ISD::SETLE:
15746   case ISD::SETOLE: SSECC = 2; break;
15747   case ISD::SETUO:  SSECC = 3; break;
15748   case ISD::SETUNE:
15749   case ISD::SETNE:  SSECC = 4; break;
15750   case ISD::SETULE: Swap = true; // Fallthrough
15751   case ISD::SETUGE: SSECC = 5; break;
15752   case ISD::SETULT: Swap = true; // Fallthrough
15753   case ISD::SETUGT: SSECC = 6; break;
15754   case ISD::SETO:   SSECC = 7; break;
15755   case ISD::SETUEQ:
15756   case ISD::SETONE: SSECC = 8; break;
15757   }
15758   if (Swap)
15759     std::swap(Op0, Op1);
15760
15761   return SSECC;
15762 }
15763
15764 // Lower256IntVSETCC - Break a VSETCC 256-bit integer VSETCC into two new 128
15765 // ones, and then concatenate the result back.
15766 static SDValue Lower256IntVSETCC(SDValue Op, SelectionDAG &DAG) {
15767   MVT VT = Op.getSimpleValueType();
15768
15769   assert(VT.is256BitVector() && Op.getOpcode() == ISD::SETCC &&
15770          "Unsupported value type for operation");
15771
15772   unsigned NumElems = VT.getVectorNumElements();
15773   SDLoc dl(Op);
15774   SDValue CC = Op.getOperand(2);
15775
15776   // Extract the LHS vectors
15777   SDValue LHS = Op.getOperand(0);
15778   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
15779   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
15780
15781   // Extract the RHS vectors
15782   SDValue RHS = Op.getOperand(1);
15783   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
15784   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
15785
15786   // Issue the operation on the smaller types and concatenate the result back
15787   MVT EltVT = VT.getVectorElementType();
15788   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
15789   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
15790                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
15791                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
15792 }
15793
15794 static SDValue LowerIntVSETCC_AVX512(SDValue Op, SelectionDAG &DAG,
15795                                      const X86Subtarget *Subtarget) {
15796   SDValue Op0 = Op.getOperand(0);
15797   SDValue Op1 = Op.getOperand(1);
15798   SDValue CC = Op.getOperand(2);
15799   MVT VT = Op.getSimpleValueType();
15800   SDLoc dl(Op);
15801
15802   assert(Op0.getValueType().getVectorElementType().getSizeInBits() >= 8 &&
15803          Op.getValueType().getScalarType() == MVT::i1 &&
15804          "Cannot set masked compare for this operation");
15805
15806   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
15807   unsigned  Opc = 0;
15808   bool Unsigned = false;
15809   bool Swap = false;
15810   unsigned SSECC;
15811   switch (SetCCOpcode) {
15812   default: llvm_unreachable("Unexpected SETCC condition");
15813   case ISD::SETNE:  SSECC = 4; break;
15814   case ISD::SETEQ:  Opc = X86ISD::PCMPEQM; break;
15815   case ISD::SETUGT: SSECC = 6; Unsigned = true; break;
15816   case ISD::SETLT:  Swap = true; //fall-through
15817   case ISD::SETGT:  Opc = X86ISD::PCMPGTM; break;
15818   case ISD::SETULT: SSECC = 1; Unsigned = true; break;
15819   case ISD::SETUGE: SSECC = 5; Unsigned = true; break; //NLT
15820   case ISD::SETGE:  Swap = true; SSECC = 2; break; // LE + swap
15821   case ISD::SETULE: Unsigned = true; //fall-through
15822   case ISD::SETLE:  SSECC = 2; break;
15823   }
15824
15825   if (Swap)
15826     std::swap(Op0, Op1);
15827   if (Opc)
15828     return DAG.getNode(Opc, dl, VT, Op0, Op1);
15829   Opc = Unsigned ? X86ISD::CMPMU: X86ISD::CMPM;
15830   return DAG.getNode(Opc, dl, VT, Op0, Op1,
15831                      DAG.getConstant(SSECC, MVT::i8));
15832 }
15833
15834 /// \brief Try to turn a VSETULT into a VSETULE by modifying its second
15835 /// operand \p Op1.  If non-trivial (for example because it's not constant)
15836 /// return an empty value.
15837 static SDValue ChangeVSETULTtoVSETULE(SDLoc dl, SDValue Op1, SelectionDAG &DAG)
15838 {
15839   BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Op1.getNode());
15840   if (!BV)
15841     return SDValue();
15842
15843   MVT VT = Op1.getSimpleValueType();
15844   MVT EVT = VT.getVectorElementType();
15845   unsigned n = VT.getVectorNumElements();
15846   SmallVector<SDValue, 8> ULTOp1;
15847
15848   for (unsigned i = 0; i < n; ++i) {
15849     ConstantSDNode *Elt = dyn_cast<ConstantSDNode>(BV->getOperand(i));
15850     if (!Elt || Elt->isOpaque() || Elt->getValueType(0) != EVT)
15851       return SDValue();
15852
15853     // Avoid underflow.
15854     APInt Val = Elt->getAPIntValue();
15855     if (Val == 0)
15856       return SDValue();
15857
15858     ULTOp1.push_back(DAG.getConstant(Val - 1, EVT));
15859   }
15860
15861   return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, ULTOp1);
15862 }
15863
15864 static SDValue LowerVSETCC(SDValue Op, const X86Subtarget *Subtarget,
15865                            SelectionDAG &DAG) {
15866   SDValue Op0 = Op.getOperand(0);
15867   SDValue Op1 = Op.getOperand(1);
15868   SDValue CC = Op.getOperand(2);
15869   MVT VT = Op.getSimpleValueType();
15870   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
15871   bool isFP = Op.getOperand(1).getSimpleValueType().isFloatingPoint();
15872   SDLoc dl(Op);
15873
15874   if (isFP) {
15875 #ifndef NDEBUG
15876     MVT EltVT = Op0.getSimpleValueType().getVectorElementType();
15877     assert(EltVT == MVT::f32 || EltVT == MVT::f64);
15878 #endif
15879
15880     unsigned SSECC = translateX86FSETCC(SetCCOpcode, Op0, Op1);
15881     unsigned Opc = X86ISD::CMPP;
15882     if (Subtarget->hasAVX512() && VT.getVectorElementType() == MVT::i1) {
15883       assert(VT.getVectorNumElements() <= 16);
15884       Opc = X86ISD::CMPM;
15885     }
15886     // In the two special cases we can't handle, emit two comparisons.
15887     if (SSECC == 8) {
15888       unsigned CC0, CC1;
15889       unsigned CombineOpc;
15890       if (SetCCOpcode == ISD::SETUEQ) {
15891         CC0 = 3; CC1 = 0; CombineOpc = ISD::OR;
15892       } else {
15893         assert(SetCCOpcode == ISD::SETONE);
15894         CC0 = 7; CC1 = 4; CombineOpc = ISD::AND;
15895       }
15896
15897       SDValue Cmp0 = DAG.getNode(Opc, dl, VT, Op0, Op1,
15898                                  DAG.getConstant(CC0, MVT::i8));
15899       SDValue Cmp1 = DAG.getNode(Opc, dl, VT, Op0, Op1,
15900                                  DAG.getConstant(CC1, MVT::i8));
15901       return DAG.getNode(CombineOpc, dl, VT, Cmp0, Cmp1);
15902     }
15903     // Handle all other FP comparisons here.
15904     return DAG.getNode(Opc, dl, VT, Op0, Op1,
15905                        DAG.getConstant(SSECC, MVT::i8));
15906   }
15907
15908   // Break 256-bit integer vector compare into smaller ones.
15909   if (VT.is256BitVector() && !Subtarget->hasInt256())
15910     return Lower256IntVSETCC(Op, DAG);
15911
15912   bool MaskResult = (VT.getVectorElementType() == MVT::i1);
15913   EVT OpVT = Op1.getValueType();
15914   if (Subtarget->hasAVX512()) {
15915     if (Op1.getValueType().is512BitVector() ||
15916         (Subtarget->hasBWI() && Subtarget->hasVLX()) ||
15917         (MaskResult && OpVT.getVectorElementType().getSizeInBits() >= 32))
15918       return LowerIntVSETCC_AVX512(Op, DAG, Subtarget);
15919
15920     // In AVX-512 architecture setcc returns mask with i1 elements,
15921     // But there is no compare instruction for i8 and i16 elements in KNL.
15922     // We are not talking about 512-bit operands in this case, these
15923     // types are illegal.
15924     if (MaskResult &&
15925         (OpVT.getVectorElementType().getSizeInBits() < 32 &&
15926          OpVT.getVectorElementType().getSizeInBits() >= 8))
15927       return DAG.getNode(ISD::TRUNCATE, dl, VT,
15928                          DAG.getNode(ISD::SETCC, dl, OpVT, Op0, Op1, CC));
15929   }
15930
15931   // We are handling one of the integer comparisons here.  Since SSE only has
15932   // GT and EQ comparisons for integer, swapping operands and multiple
15933   // operations may be required for some comparisons.
15934   unsigned Opc;
15935   bool Swap = false, Invert = false, FlipSigns = false, MinMax = false;
15936   bool Subus = false;
15937
15938   switch (SetCCOpcode) {
15939   default: llvm_unreachable("Unexpected SETCC condition");
15940   case ISD::SETNE:  Invert = true;
15941   case ISD::SETEQ:  Opc = X86ISD::PCMPEQ; break;
15942   case ISD::SETLT:  Swap = true;
15943   case ISD::SETGT:  Opc = X86ISD::PCMPGT; break;
15944   case ISD::SETGE:  Swap = true;
15945   case ISD::SETLE:  Opc = X86ISD::PCMPGT;
15946                     Invert = true; break;
15947   case ISD::SETULT: Swap = true;
15948   case ISD::SETUGT: Opc = X86ISD::PCMPGT;
15949                     FlipSigns = true; break;
15950   case ISD::SETUGE: Swap = true;
15951   case ISD::SETULE: Opc = X86ISD::PCMPGT;
15952                     FlipSigns = true; Invert = true; break;
15953   }
15954
15955   // Special case: Use min/max operations for SETULE/SETUGE
15956   MVT VET = VT.getVectorElementType();
15957   bool hasMinMax =
15958        (Subtarget->hasSSE41() && (VET >= MVT::i8 && VET <= MVT::i32))
15959     || (Subtarget->hasSSE2()  && (VET == MVT::i8));
15960
15961   if (hasMinMax) {
15962     switch (SetCCOpcode) {
15963     default: break;
15964     case ISD::SETULE: Opc = X86ISD::UMIN; MinMax = true; break;
15965     case ISD::SETUGE: Opc = X86ISD::UMAX; MinMax = true; break;
15966     }
15967
15968     if (MinMax) { Swap = false; Invert = false; FlipSigns = false; }
15969   }
15970
15971   bool hasSubus = Subtarget->hasSSE2() && (VET == MVT::i8 || VET == MVT::i16);
15972   if (!MinMax && hasSubus) {
15973     // As another special case, use PSUBUS[BW] when it's profitable. E.g. for
15974     // Op0 u<= Op1:
15975     //   t = psubus Op0, Op1
15976     //   pcmpeq t, <0..0>
15977     switch (SetCCOpcode) {
15978     default: break;
15979     case ISD::SETULT: {
15980       // If the comparison is against a constant we can turn this into a
15981       // setule.  With psubus, setule does not require a swap.  This is
15982       // beneficial because the constant in the register is no longer
15983       // destructed as the destination so it can be hoisted out of a loop.
15984       // Only do this pre-AVX since vpcmp* is no longer destructive.
15985       if (Subtarget->hasAVX())
15986         break;
15987       SDValue ULEOp1 = ChangeVSETULTtoVSETULE(dl, Op1, DAG);
15988       if (ULEOp1.getNode()) {
15989         Op1 = ULEOp1;
15990         Subus = true; Invert = false; Swap = false;
15991       }
15992       break;
15993     }
15994     // Psubus is better than flip-sign because it requires no inversion.
15995     case ISD::SETUGE: Subus = true; Invert = false; Swap = true;  break;
15996     case ISD::SETULE: Subus = true; Invert = false; Swap = false; break;
15997     }
15998
15999     if (Subus) {
16000       Opc = X86ISD::SUBUS;
16001       FlipSigns = false;
16002     }
16003   }
16004
16005   if (Swap)
16006     std::swap(Op0, Op1);
16007
16008   // Check that the operation in question is available (most are plain SSE2,
16009   // but PCMPGTQ and PCMPEQQ have different requirements).
16010   if (VT == MVT::v2i64) {
16011     if (Opc == X86ISD::PCMPGT && !Subtarget->hasSSE42()) {
16012       assert(Subtarget->hasSSE2() && "Don't know how to lower!");
16013
16014       // First cast everything to the right type.
16015       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
16016       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
16017
16018       // Since SSE has no unsigned integer comparisons, we need to flip the sign
16019       // bits of the inputs before performing those operations. The lower
16020       // compare is always unsigned.
16021       SDValue SB;
16022       if (FlipSigns) {
16023         SB = DAG.getConstant(0x80000000U, MVT::v4i32);
16024       } else {
16025         SDValue Sign = DAG.getConstant(0x80000000U, MVT::i32);
16026         SDValue Zero = DAG.getConstant(0x00000000U, MVT::i32);
16027         SB = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
16028                          Sign, Zero, Sign, Zero);
16029       }
16030       Op0 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op0, SB);
16031       Op1 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op1, SB);
16032
16033       // Emulate PCMPGTQ with (hi1 > hi2) | ((hi1 == hi2) & (lo1 > lo2))
16034       SDValue GT = DAG.getNode(X86ISD::PCMPGT, dl, MVT::v4i32, Op0, Op1);
16035       SDValue EQ = DAG.getNode(X86ISD::PCMPEQ, dl, MVT::v4i32, Op0, Op1);
16036
16037       // Create masks for only the low parts/high parts of the 64 bit integers.
16038       static const int MaskHi[] = { 1, 1, 3, 3 };
16039       static const int MaskLo[] = { 0, 0, 2, 2 };
16040       SDValue EQHi = DAG.getVectorShuffle(MVT::v4i32, dl, EQ, EQ, MaskHi);
16041       SDValue GTLo = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskLo);
16042       SDValue GTHi = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskHi);
16043
16044       SDValue Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, EQHi, GTLo);
16045       Result = DAG.getNode(ISD::OR, dl, MVT::v4i32, Result, GTHi);
16046
16047       if (Invert)
16048         Result = DAG.getNOT(dl, Result, MVT::v4i32);
16049
16050       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
16051     }
16052
16053     if (Opc == X86ISD::PCMPEQ && !Subtarget->hasSSE41()) {
16054       // If pcmpeqq is missing but pcmpeqd is available synthesize pcmpeqq with
16055       // pcmpeqd + pshufd + pand.
16056       assert(Subtarget->hasSSE2() && !FlipSigns && "Don't know how to lower!");
16057
16058       // First cast everything to the right type.
16059       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
16060       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
16061
16062       // Do the compare.
16063       SDValue Result = DAG.getNode(Opc, dl, MVT::v4i32, Op0, Op1);
16064
16065       // Make sure the lower and upper halves are both all-ones.
16066       static const int Mask[] = { 1, 0, 3, 2 };
16067       SDValue Shuf = DAG.getVectorShuffle(MVT::v4i32, dl, Result, Result, Mask);
16068       Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, Result, Shuf);
16069
16070       if (Invert)
16071         Result = DAG.getNOT(dl, Result, MVT::v4i32);
16072
16073       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
16074     }
16075   }
16076
16077   // Since SSE has no unsigned integer comparisons, we need to flip the sign
16078   // bits of the inputs before performing those operations.
16079   if (FlipSigns) {
16080     EVT EltVT = VT.getVectorElementType();
16081     SDValue SB = DAG.getConstant(APInt::getSignBit(EltVT.getSizeInBits()), VT);
16082     Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SB);
16083     Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SB);
16084   }
16085
16086   SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
16087
16088   // If the logical-not of the result is required, perform that now.
16089   if (Invert)
16090     Result = DAG.getNOT(dl, Result, VT);
16091
16092   if (MinMax)
16093     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Op0, Result);
16094
16095   if (Subus)
16096     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Result,
16097                          getZeroVector(VT, Subtarget, DAG, dl));
16098
16099   return Result;
16100 }
16101
16102 SDValue X86TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
16103
16104   MVT VT = Op.getSimpleValueType();
16105
16106   if (VT.isVector()) return LowerVSETCC(Op, Subtarget, DAG);
16107
16108   assert(((!Subtarget->hasAVX512() && VT == MVT::i8) || (VT == MVT::i1))
16109          && "SetCC type must be 8-bit or 1-bit integer");
16110   SDValue Op0 = Op.getOperand(0);
16111   SDValue Op1 = Op.getOperand(1);
16112   SDLoc dl(Op);
16113   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
16114
16115   // Optimize to BT if possible.
16116   // Lower (X & (1 << N)) == 0 to BT(X, N).
16117   // Lower ((X >>u N) & 1) != 0 to BT(X, N).
16118   // Lower ((X >>s N) & 1) != 0 to BT(X, N).
16119   if (Op0.getOpcode() == ISD::AND && Op0.hasOneUse() &&
16120       Op1.getOpcode() == ISD::Constant &&
16121       cast<ConstantSDNode>(Op1)->isNullValue() &&
16122       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
16123     SDValue NewSetCC = LowerToBT(Op0, CC, dl, DAG);
16124     if (NewSetCC.getNode()) {
16125       if (VT == MVT::i1)
16126         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewSetCC);
16127       return NewSetCC;
16128     }
16129   }
16130
16131   // Look for X == 0, X == 1, X != 0, or X != 1.  We can simplify some forms of
16132   // these.
16133   if (Op1.getOpcode() == ISD::Constant &&
16134       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1 ||
16135        cast<ConstantSDNode>(Op1)->isNullValue()) &&
16136       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
16137
16138     // If the input is a setcc, then reuse the input setcc or use a new one with
16139     // the inverted condition.
16140     if (Op0.getOpcode() == X86ISD::SETCC) {
16141       X86::CondCode CCode = (X86::CondCode)Op0.getConstantOperandVal(0);
16142       bool Invert = (CC == ISD::SETNE) ^
16143         cast<ConstantSDNode>(Op1)->isNullValue();
16144       if (!Invert)
16145         return Op0;
16146
16147       CCode = X86::GetOppositeBranchCondition(CCode);
16148       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
16149                                   DAG.getConstant(CCode, MVT::i8),
16150                                   Op0.getOperand(1));
16151       if (VT == MVT::i1)
16152         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
16153       return SetCC;
16154     }
16155   }
16156   if ((Op0.getValueType() == MVT::i1) && (Op1.getOpcode() == ISD::Constant) &&
16157       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1) &&
16158       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
16159
16160     ISD::CondCode NewCC = ISD::getSetCCInverse(CC, true);
16161     return DAG.getSetCC(dl, VT, Op0, DAG.getConstant(0, MVT::i1), NewCC);
16162   }
16163
16164   bool isFP = Op1.getSimpleValueType().isFloatingPoint();
16165   unsigned X86CC = TranslateX86CC(CC, isFP, Op0, Op1, DAG);
16166   if (X86CC == X86::COND_INVALID)
16167     return SDValue();
16168
16169   SDValue EFLAGS = EmitCmp(Op0, Op1, X86CC, dl, DAG);
16170   EFLAGS = ConvertCmpIfNecessary(EFLAGS, DAG);
16171   SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
16172                               DAG.getConstant(X86CC, MVT::i8), EFLAGS);
16173   if (VT == MVT::i1)
16174     return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
16175   return SetCC;
16176 }
16177
16178 // isX86LogicalCmp - Return true if opcode is a X86 logical comparison.
16179 static bool isX86LogicalCmp(SDValue Op) {
16180   unsigned Opc = Op.getNode()->getOpcode();
16181   if (Opc == X86ISD::CMP || Opc == X86ISD::COMI || Opc == X86ISD::UCOMI ||
16182       Opc == X86ISD::SAHF)
16183     return true;
16184   if (Op.getResNo() == 1 &&
16185       (Opc == X86ISD::ADD ||
16186        Opc == X86ISD::SUB ||
16187        Opc == X86ISD::ADC ||
16188        Opc == X86ISD::SBB ||
16189        Opc == X86ISD::SMUL ||
16190        Opc == X86ISD::UMUL ||
16191        Opc == X86ISD::INC ||
16192        Opc == X86ISD::DEC ||
16193        Opc == X86ISD::OR ||
16194        Opc == X86ISD::XOR ||
16195        Opc == X86ISD::AND))
16196     return true;
16197
16198   if (Op.getResNo() == 2 && Opc == X86ISD::UMUL)
16199     return true;
16200
16201   return false;
16202 }
16203
16204 static bool isTruncWithZeroHighBitsInput(SDValue V, SelectionDAG &DAG) {
16205   if (V.getOpcode() != ISD::TRUNCATE)
16206     return false;
16207
16208   SDValue VOp0 = V.getOperand(0);
16209   unsigned InBits = VOp0.getValueSizeInBits();
16210   unsigned Bits = V.getValueSizeInBits();
16211   return DAG.MaskedValueIsZero(VOp0, APInt::getHighBitsSet(InBits,InBits-Bits));
16212 }
16213
16214 SDValue X86TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
16215   bool addTest = true;
16216   SDValue Cond  = Op.getOperand(0);
16217   SDValue Op1 = Op.getOperand(1);
16218   SDValue Op2 = Op.getOperand(2);
16219   SDLoc DL(Op);
16220   EVT VT = Op1.getValueType();
16221   SDValue CC;
16222
16223   // Lower fp selects into a CMP/AND/ANDN/OR sequence when the necessary SSE ops
16224   // are available. Otherwise fp cmovs get lowered into a less efficient branch
16225   // sequence later on.
16226   if (Cond.getOpcode() == ISD::SETCC &&
16227       ((Subtarget->hasSSE2() && (VT == MVT::f32 || VT == MVT::f64)) ||
16228        (Subtarget->hasSSE1() && VT == MVT::f32)) &&
16229       VT == Cond.getOperand(0).getValueType() && Cond->hasOneUse()) {
16230     SDValue CondOp0 = Cond.getOperand(0), CondOp1 = Cond.getOperand(1);
16231     int SSECC = translateX86FSETCC(
16232         cast<CondCodeSDNode>(Cond.getOperand(2))->get(), CondOp0, CondOp1);
16233
16234     if (SSECC != 8) {
16235       if (Subtarget->hasAVX512()) {
16236         SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CondOp0, CondOp1,
16237                                   DAG.getConstant(SSECC, MVT::i8));
16238         return DAG.getNode(X86ISD::SELECT, DL, VT, Cmp, Op1, Op2);
16239       }
16240       SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, VT, CondOp0, CondOp1,
16241                                 DAG.getConstant(SSECC, MVT::i8));
16242       SDValue AndN = DAG.getNode(X86ISD::FANDN, DL, VT, Cmp, Op2);
16243       SDValue And = DAG.getNode(X86ISD::FAND, DL, VT, Cmp, Op1);
16244       return DAG.getNode(X86ISD::FOR, DL, VT, AndN, And);
16245     }
16246   }
16247
16248   if (Cond.getOpcode() == ISD::SETCC) {
16249     SDValue NewCond = LowerSETCC(Cond, DAG);
16250     if (NewCond.getNode())
16251       Cond = NewCond;
16252   }
16253
16254   // (select (x == 0), -1, y) -> (sign_bit (x - 1)) | y
16255   // (select (x == 0), y, -1) -> ~(sign_bit (x - 1)) | y
16256   // (select (x != 0), y, -1) -> (sign_bit (x - 1)) | y
16257   // (select (x != 0), -1, y) -> ~(sign_bit (x - 1)) | y
16258   if (Cond.getOpcode() == X86ISD::SETCC &&
16259       Cond.getOperand(1).getOpcode() == X86ISD::CMP &&
16260       isZero(Cond.getOperand(1).getOperand(1))) {
16261     SDValue Cmp = Cond.getOperand(1);
16262
16263     unsigned CondCode =cast<ConstantSDNode>(Cond.getOperand(0))->getZExtValue();
16264
16265     if ((isAllOnes(Op1) || isAllOnes(Op2)) &&
16266         (CondCode == X86::COND_E || CondCode == X86::COND_NE)) {
16267       SDValue Y = isAllOnes(Op2) ? Op1 : Op2;
16268
16269       SDValue CmpOp0 = Cmp.getOperand(0);
16270       // Apply further optimizations for special cases
16271       // (select (x != 0), -1, 0) -> neg & sbb
16272       // (select (x == 0), 0, -1) -> neg & sbb
16273       if (ConstantSDNode *YC = dyn_cast<ConstantSDNode>(Y))
16274         if (YC->isNullValue() &&
16275             (isAllOnes(Op1) == (CondCode == X86::COND_NE))) {
16276           SDVTList VTs = DAG.getVTList(CmpOp0.getValueType(), MVT::i32);
16277           SDValue Neg = DAG.getNode(X86ISD::SUB, DL, VTs,
16278                                     DAG.getConstant(0, CmpOp0.getValueType()),
16279                                     CmpOp0);
16280           SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
16281                                     DAG.getConstant(X86::COND_B, MVT::i8),
16282                                     SDValue(Neg.getNode(), 1));
16283           return Res;
16284         }
16285
16286       Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
16287                         CmpOp0, DAG.getConstant(1, CmpOp0.getValueType()));
16288       Cmp = ConvertCmpIfNecessary(Cmp, DAG);
16289
16290       SDValue Res =   // Res = 0 or -1.
16291         DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
16292                     DAG.getConstant(X86::COND_B, MVT::i8), Cmp);
16293
16294       if (isAllOnes(Op1) != (CondCode == X86::COND_E))
16295         Res = DAG.getNOT(DL, Res, Res.getValueType());
16296
16297       ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(Op2);
16298       if (!N2C || !N2C->isNullValue())
16299         Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
16300       return Res;
16301     }
16302   }
16303
16304   // Look past (and (setcc_carry (cmp ...)), 1).
16305   if (Cond.getOpcode() == ISD::AND &&
16306       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
16307     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
16308     if (C && C->getAPIntValue() == 1)
16309       Cond = Cond.getOperand(0);
16310   }
16311
16312   // If condition flag is set by a X86ISD::CMP, then use it as the condition
16313   // setting operand in place of the X86ISD::SETCC.
16314   unsigned CondOpcode = Cond.getOpcode();
16315   if (CondOpcode == X86ISD::SETCC ||
16316       CondOpcode == X86ISD::SETCC_CARRY) {
16317     CC = Cond.getOperand(0);
16318
16319     SDValue Cmp = Cond.getOperand(1);
16320     unsigned Opc = Cmp.getOpcode();
16321     MVT VT = Op.getSimpleValueType();
16322
16323     bool IllegalFPCMov = false;
16324     if (VT.isFloatingPoint() && !VT.isVector() &&
16325         !isScalarFPTypeInSSEReg(VT))  // FPStack?
16326       IllegalFPCMov = !hasFPCMov(cast<ConstantSDNode>(CC)->getSExtValue());
16327
16328     if ((isX86LogicalCmp(Cmp) && !IllegalFPCMov) ||
16329         Opc == X86ISD::BT) { // FIXME
16330       Cond = Cmp;
16331       addTest = false;
16332     }
16333   } else if (CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
16334              CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
16335              ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
16336               Cond.getOperand(0).getValueType() != MVT::i8)) {
16337     SDValue LHS = Cond.getOperand(0);
16338     SDValue RHS = Cond.getOperand(1);
16339     unsigned X86Opcode;
16340     unsigned X86Cond;
16341     SDVTList VTs;
16342     switch (CondOpcode) {
16343     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
16344     case ISD::SADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
16345     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
16346     case ISD::SSUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
16347     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
16348     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
16349     default: llvm_unreachable("unexpected overflowing operator");
16350     }
16351     if (CondOpcode == ISD::UMULO)
16352       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
16353                           MVT::i32);
16354     else
16355       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
16356
16357     SDValue X86Op = DAG.getNode(X86Opcode, DL, VTs, LHS, RHS);
16358
16359     if (CondOpcode == ISD::UMULO)
16360       Cond = X86Op.getValue(2);
16361     else
16362       Cond = X86Op.getValue(1);
16363
16364     CC = DAG.getConstant(X86Cond, MVT::i8);
16365     addTest = false;
16366   }
16367
16368   if (addTest) {
16369     // Look pass the truncate if the high bits are known zero.
16370     if (isTruncWithZeroHighBitsInput(Cond, DAG))
16371         Cond = Cond.getOperand(0);
16372
16373     // We know the result of AND is compared against zero. Try to match
16374     // it to BT.
16375     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
16376       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, DL, DAG);
16377       if (NewSetCC.getNode()) {
16378         CC = NewSetCC.getOperand(0);
16379         Cond = NewSetCC.getOperand(1);
16380         addTest = false;
16381       }
16382     }
16383   }
16384
16385   if (addTest) {
16386     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
16387     Cond = EmitTest(Cond, X86::COND_NE, DL, DAG);
16388   }
16389
16390   // a <  b ? -1 :  0 -> RES = ~setcc_carry
16391   // a <  b ?  0 : -1 -> RES = setcc_carry
16392   // a >= b ? -1 :  0 -> RES = setcc_carry
16393   // a >= b ?  0 : -1 -> RES = ~setcc_carry
16394   if (Cond.getOpcode() == X86ISD::SUB) {
16395     Cond = ConvertCmpIfNecessary(Cond, DAG);
16396     unsigned CondCode = cast<ConstantSDNode>(CC)->getZExtValue();
16397
16398     if ((CondCode == X86::COND_AE || CondCode == X86::COND_B) &&
16399         (isAllOnes(Op1) || isAllOnes(Op2)) && (isZero(Op1) || isZero(Op2))) {
16400       SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
16401                                 DAG.getConstant(X86::COND_B, MVT::i8), Cond);
16402       if (isAllOnes(Op1) != (CondCode == X86::COND_B))
16403         return DAG.getNOT(DL, Res, Res.getValueType());
16404       return Res;
16405     }
16406   }
16407
16408   // X86 doesn't have an i8 cmov. If both operands are the result of a truncate
16409   // widen the cmov and push the truncate through. This avoids introducing a new
16410   // branch during isel and doesn't add any extensions.
16411   if (Op.getValueType() == MVT::i8 &&
16412       Op1.getOpcode() == ISD::TRUNCATE && Op2.getOpcode() == ISD::TRUNCATE) {
16413     SDValue T1 = Op1.getOperand(0), T2 = Op2.getOperand(0);
16414     if (T1.getValueType() == T2.getValueType() &&
16415         // Blacklist CopyFromReg to avoid partial register stalls.
16416         T1.getOpcode() != ISD::CopyFromReg && T2.getOpcode()!=ISD::CopyFromReg){
16417       SDVTList VTs = DAG.getVTList(T1.getValueType(), MVT::Glue);
16418       SDValue Cmov = DAG.getNode(X86ISD::CMOV, DL, VTs, T2, T1, CC, Cond);
16419       return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
16420     }
16421   }
16422
16423   // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
16424   // condition is true.
16425   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
16426   SDValue Ops[] = { Op2, Op1, CC, Cond };
16427   return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops);
16428 }
16429
16430 static SDValue LowerSIGN_EXTEND_AVX512(SDValue Op, const X86Subtarget *Subtarget,
16431                                        SelectionDAG &DAG) {
16432   MVT VT = Op->getSimpleValueType(0);
16433   SDValue In = Op->getOperand(0);
16434   MVT InVT = In.getSimpleValueType();
16435   MVT VTElt = VT.getVectorElementType();
16436   MVT InVTElt = InVT.getVectorElementType();
16437   SDLoc dl(Op);
16438
16439   // SKX processor
16440   if ((InVTElt == MVT::i1) &&
16441       (((Subtarget->hasBWI() && Subtarget->hasVLX() &&
16442         VT.getSizeInBits() <= 256 && VTElt.getSizeInBits() <= 16)) ||
16443
16444        ((Subtarget->hasBWI() && VT.is512BitVector() &&
16445         VTElt.getSizeInBits() <= 16)) ||
16446
16447        ((Subtarget->hasDQI() && Subtarget->hasVLX() &&
16448         VT.getSizeInBits() <= 256 && VTElt.getSizeInBits() >= 32)) ||
16449
16450        ((Subtarget->hasDQI() && VT.is512BitVector() &&
16451         VTElt.getSizeInBits() >= 32))))
16452     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16453
16454   unsigned int NumElts = VT.getVectorNumElements();
16455
16456   if (NumElts != 8 && NumElts != 16)
16457     return SDValue();
16458
16459   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1) {
16460     if (In.getOpcode() == X86ISD::VSEXT || In.getOpcode() == X86ISD::VZEXT)
16461       return DAG.getNode(In.getOpcode(), dl, VT, In.getOperand(0));
16462     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16463   }
16464
16465   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16466   assert (InVT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
16467
16468   MVT ExtVT = (NumElts == 8) ? MVT::v8i64 : MVT::v16i32;
16469   Constant *C = ConstantInt::get(*DAG.getContext(),
16470     APInt::getAllOnesValue(ExtVT.getScalarType().getSizeInBits()));
16471
16472   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
16473   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
16474   SDValue Ld = DAG.getLoad(ExtVT.getScalarType(), dl, DAG.getEntryNode(), CP,
16475                           MachinePointerInfo::getConstantPool(),
16476                           false, false, false, Alignment);
16477   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, dl, ExtVT, In, Ld);
16478   if (VT.is512BitVector())
16479     return Brcst;
16480   return DAG.getNode(X86ISD::VTRUNC, dl, VT, Brcst);
16481 }
16482
16483 static SDValue LowerSIGN_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
16484                                 SelectionDAG &DAG) {
16485   MVT VT = Op->getSimpleValueType(0);
16486   SDValue In = Op->getOperand(0);
16487   MVT InVT = In.getSimpleValueType();
16488   SDLoc dl(Op);
16489
16490   if (VT.is512BitVector() || InVT.getVectorElementType() == MVT::i1)
16491     return LowerSIGN_EXTEND_AVX512(Op, Subtarget, DAG);
16492
16493   if ((VT != MVT::v4i64 || InVT != MVT::v4i32) &&
16494       (VT != MVT::v8i32 || InVT != MVT::v8i16) &&
16495       (VT != MVT::v16i16 || InVT != MVT::v16i8))
16496     return SDValue();
16497
16498   if (Subtarget->hasInt256())
16499     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16500
16501   // Optimize vectors in AVX mode
16502   // Sign extend  v8i16 to v8i32 and
16503   //              v4i32 to v4i64
16504   //
16505   // Divide input vector into two parts
16506   // for v4i32 the shuffle mask will be { 0, 1, -1, -1} {2, 3, -1, -1}
16507   // use vpmovsx instruction to extend v4i32 -> v2i64; v8i16 -> v4i32
16508   // concat the vectors to original VT
16509
16510   unsigned NumElems = InVT.getVectorNumElements();
16511   SDValue Undef = DAG.getUNDEF(InVT);
16512
16513   SmallVector<int,8> ShufMask1(NumElems, -1);
16514   for (unsigned i = 0; i != NumElems/2; ++i)
16515     ShufMask1[i] = i;
16516
16517   SDValue OpLo = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask1[0]);
16518
16519   SmallVector<int,8> ShufMask2(NumElems, -1);
16520   for (unsigned i = 0; i != NumElems/2; ++i)
16521     ShufMask2[i] = i + NumElems/2;
16522
16523   SDValue OpHi = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask2[0]);
16524
16525   MVT HalfVT = MVT::getVectorVT(VT.getScalarType(),
16526                                 VT.getVectorNumElements()/2);
16527
16528   OpLo = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpLo);
16529   OpHi = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpHi);
16530
16531   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
16532 }
16533
16534 // Lower vector extended loads using a shuffle. If SSSE3 is not available we
16535 // may emit an illegal shuffle but the expansion is still better than scalar
16536 // code. We generate X86ISD::VSEXT for SEXTLOADs if it's available, otherwise
16537 // we'll emit a shuffle and a arithmetic shift.
16538 // FIXME: Is the expansion actually better than scalar code? It doesn't seem so.
16539 // TODO: It is possible to support ZExt by zeroing the undef values during
16540 // the shuffle phase or after the shuffle.
16541 static SDValue LowerExtendedLoad(SDValue Op, const X86Subtarget *Subtarget,
16542                                  SelectionDAG &DAG) {
16543   MVT RegVT = Op.getSimpleValueType();
16544   assert(RegVT.isVector() && "We only custom lower vector sext loads.");
16545   assert(RegVT.isInteger() &&
16546          "We only custom lower integer vector sext loads.");
16547
16548   // Nothing useful we can do without SSE2 shuffles.
16549   assert(Subtarget->hasSSE2() && "We only custom lower sext loads with SSE2.");
16550
16551   LoadSDNode *Ld = cast<LoadSDNode>(Op.getNode());
16552   SDLoc dl(Ld);
16553   EVT MemVT = Ld->getMemoryVT();
16554   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16555   unsigned RegSz = RegVT.getSizeInBits();
16556
16557   ISD::LoadExtType Ext = Ld->getExtensionType();
16558
16559   assert((Ext == ISD::EXTLOAD || Ext == ISD::SEXTLOAD)
16560          && "Only anyext and sext are currently implemented.");
16561   assert(MemVT != RegVT && "Cannot extend to the same type");
16562   assert(MemVT.isVector() && "Must load a vector from memory");
16563
16564   unsigned NumElems = RegVT.getVectorNumElements();
16565   unsigned MemSz = MemVT.getSizeInBits();
16566   assert(RegSz > MemSz && "Register size must be greater than the mem size");
16567
16568   if (Ext == ISD::SEXTLOAD && RegSz == 256 && !Subtarget->hasInt256()) {
16569     // The only way in which we have a legal 256-bit vector result but not the
16570     // integer 256-bit operations needed to directly lower a sextload is if we
16571     // have AVX1 but not AVX2. In that case, we can always emit a sextload to
16572     // a 128-bit vector and a normal sign_extend to 256-bits that should get
16573     // correctly legalized. We do this late to allow the canonical form of
16574     // sextload to persist throughout the rest of the DAG combiner -- it wants
16575     // to fold together any extensions it can, and so will fuse a sign_extend
16576     // of an sextload into a sextload targeting a wider value.
16577     SDValue Load;
16578     if (MemSz == 128) {
16579       // Just switch this to a normal load.
16580       assert(TLI.isTypeLegal(MemVT) && "If the memory type is a 128-bit type, "
16581                                        "it must be a legal 128-bit vector "
16582                                        "type!");
16583       Load = DAG.getLoad(MemVT, dl, Ld->getChain(), Ld->getBasePtr(),
16584                   Ld->getPointerInfo(), Ld->isVolatile(), Ld->isNonTemporal(),
16585                   Ld->isInvariant(), Ld->getAlignment());
16586     } else {
16587       assert(MemSz < 128 &&
16588              "Can't extend a type wider than 128 bits to a 256 bit vector!");
16589       // Do an sext load to a 128-bit vector type. We want to use the same
16590       // number of elements, but elements half as wide. This will end up being
16591       // recursively lowered by this routine, but will succeed as we definitely
16592       // have all the necessary features if we're using AVX1.
16593       EVT HalfEltVT =
16594           EVT::getIntegerVT(*DAG.getContext(), RegVT.getScalarSizeInBits() / 2);
16595       EVT HalfVecVT = EVT::getVectorVT(*DAG.getContext(), HalfEltVT, NumElems);
16596       Load =
16597           DAG.getExtLoad(Ext, dl, HalfVecVT, Ld->getChain(), Ld->getBasePtr(),
16598                          Ld->getPointerInfo(), MemVT, Ld->isVolatile(),
16599                          Ld->isNonTemporal(), Ld->isInvariant(),
16600                          Ld->getAlignment());
16601     }
16602
16603     // Replace chain users with the new chain.
16604     assert(Load->getNumValues() == 2 && "Loads must carry a chain!");
16605     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), Load.getValue(1));
16606
16607     // Finally, do a normal sign-extend to the desired register.
16608     return DAG.getSExtOrTrunc(Load, dl, RegVT);
16609   }
16610
16611   // All sizes must be a power of two.
16612   assert(isPowerOf2_32(RegSz * MemSz * NumElems) &&
16613          "Non-power-of-two elements are not custom lowered!");
16614
16615   // Attempt to load the original value using scalar loads.
16616   // Find the largest scalar type that divides the total loaded size.
16617   MVT SclrLoadTy = MVT::i8;
16618   for (MVT Tp : MVT::integer_valuetypes()) {
16619     if (TLI.isTypeLegal(Tp) && ((MemSz % Tp.getSizeInBits()) == 0)) {
16620       SclrLoadTy = Tp;
16621     }
16622   }
16623
16624   // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
16625   if (TLI.isTypeLegal(MVT::f64) && SclrLoadTy.getSizeInBits() < 64 &&
16626       (64 <= MemSz))
16627     SclrLoadTy = MVT::f64;
16628
16629   // Calculate the number of scalar loads that we need to perform
16630   // in order to load our vector from memory.
16631   unsigned NumLoads = MemSz / SclrLoadTy.getSizeInBits();
16632
16633   assert((Ext != ISD::SEXTLOAD || NumLoads == 1) &&
16634          "Can only lower sext loads with a single scalar load!");
16635
16636   unsigned loadRegZize = RegSz;
16637   if (Ext == ISD::SEXTLOAD && RegSz == 256)
16638     loadRegZize /= 2;
16639
16640   // Represent our vector as a sequence of elements which are the
16641   // largest scalar that we can load.
16642   EVT LoadUnitVecVT = EVT::getVectorVT(
16643       *DAG.getContext(), SclrLoadTy, loadRegZize / SclrLoadTy.getSizeInBits());
16644
16645   // Represent the data using the same element type that is stored in
16646   // memory. In practice, we ''widen'' MemVT.
16647   EVT WideVecVT =
16648       EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
16649                        loadRegZize / MemVT.getScalarType().getSizeInBits());
16650
16651   assert(WideVecVT.getSizeInBits() == LoadUnitVecVT.getSizeInBits() &&
16652          "Invalid vector type");
16653
16654   // We can't shuffle using an illegal type.
16655   assert(TLI.isTypeLegal(WideVecVT) &&
16656          "We only lower types that form legal widened vector types");
16657
16658   SmallVector<SDValue, 8> Chains;
16659   SDValue Ptr = Ld->getBasePtr();
16660   SDValue Increment =
16661       DAG.getConstant(SclrLoadTy.getSizeInBits() / 8, TLI.getPointerTy());
16662   SDValue Res = DAG.getUNDEF(LoadUnitVecVT);
16663
16664   for (unsigned i = 0; i < NumLoads; ++i) {
16665     // Perform a single load.
16666     SDValue ScalarLoad =
16667         DAG.getLoad(SclrLoadTy, dl, Ld->getChain(), Ptr, Ld->getPointerInfo(),
16668                     Ld->isVolatile(), Ld->isNonTemporal(), Ld->isInvariant(),
16669                     Ld->getAlignment());
16670     Chains.push_back(ScalarLoad.getValue(1));
16671     // Create the first element type using SCALAR_TO_VECTOR in order to avoid
16672     // another round of DAGCombining.
16673     if (i == 0)
16674       Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoadUnitVecVT, ScalarLoad);
16675     else
16676       Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, LoadUnitVecVT, Res,
16677                         ScalarLoad, DAG.getIntPtrConstant(i));
16678
16679     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
16680   }
16681
16682   SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
16683
16684   // Bitcast the loaded value to a vector of the original element type, in
16685   // the size of the target vector type.
16686   SDValue SlicedVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Res);
16687   unsigned SizeRatio = RegSz / MemSz;
16688
16689   if (Ext == ISD::SEXTLOAD) {
16690     // If we have SSE4.1, we can directly emit a VSEXT node.
16691     if (Subtarget->hasSSE41()) {
16692       SDValue Sext = DAG.getNode(X86ISD::VSEXT, dl, RegVT, SlicedVec);
16693       DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16694       return Sext;
16695     }
16696
16697     // Otherwise we'll shuffle the small elements in the high bits of the
16698     // larger type and perform an arithmetic shift. If the shift is not legal
16699     // it's better to scalarize.
16700     assert(TLI.isOperationLegalOrCustom(ISD::SRA, RegVT) &&
16701            "We can't implement a sext load without an arithmetic right shift!");
16702
16703     // Redistribute the loaded elements into the different locations.
16704     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
16705     for (unsigned i = 0; i != NumElems; ++i)
16706       ShuffleVec[i * SizeRatio + SizeRatio - 1] = i;
16707
16708     SDValue Shuff = DAG.getVectorShuffle(
16709         WideVecVT, dl, SlicedVec, DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
16710
16711     Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
16712
16713     // Build the arithmetic shift.
16714     unsigned Amt = RegVT.getVectorElementType().getSizeInBits() -
16715                    MemVT.getVectorElementType().getSizeInBits();
16716     Shuff =
16717         DAG.getNode(ISD::SRA, dl, RegVT, Shuff, DAG.getConstant(Amt, RegVT));
16718
16719     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16720     return Shuff;
16721   }
16722
16723   // Redistribute the loaded elements into the different locations.
16724   SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
16725   for (unsigned i = 0; i != NumElems; ++i)
16726     ShuffleVec[i * SizeRatio] = i;
16727
16728   SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, SlicedVec,
16729                                        DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
16730
16731   // Bitcast to the requested type.
16732   Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
16733   DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16734   return Shuff;
16735 }
16736
16737 // isAndOrOfSingleUseSetCCs - Return true if node is an ISD::AND or
16738 // ISD::OR of two X86ISD::SETCC nodes each of which has no other use apart
16739 // from the AND / OR.
16740 static bool isAndOrOfSetCCs(SDValue Op, unsigned &Opc) {
16741   Opc = Op.getOpcode();
16742   if (Opc != ISD::OR && Opc != ISD::AND)
16743     return false;
16744   return (Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
16745           Op.getOperand(0).hasOneUse() &&
16746           Op.getOperand(1).getOpcode() == X86ISD::SETCC &&
16747           Op.getOperand(1).hasOneUse());
16748 }
16749
16750 // isXor1OfSetCC - Return true if node is an ISD::XOR of a X86ISD::SETCC and
16751 // 1 and that the SETCC node has a single use.
16752 static bool isXor1OfSetCC(SDValue Op) {
16753   if (Op.getOpcode() != ISD::XOR)
16754     return false;
16755   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
16756   if (N1C && N1C->getAPIntValue() == 1) {
16757     return Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
16758       Op.getOperand(0).hasOneUse();
16759   }
16760   return false;
16761 }
16762
16763 SDValue X86TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
16764   bool addTest = true;
16765   SDValue Chain = Op.getOperand(0);
16766   SDValue Cond  = Op.getOperand(1);
16767   SDValue Dest  = Op.getOperand(2);
16768   SDLoc dl(Op);
16769   SDValue CC;
16770   bool Inverted = false;
16771
16772   if (Cond.getOpcode() == ISD::SETCC) {
16773     // Check for setcc([su]{add,sub,mul}o == 0).
16774     if (cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETEQ &&
16775         isa<ConstantSDNode>(Cond.getOperand(1)) &&
16776         cast<ConstantSDNode>(Cond.getOperand(1))->isNullValue() &&
16777         Cond.getOperand(0).getResNo() == 1 &&
16778         (Cond.getOperand(0).getOpcode() == ISD::SADDO ||
16779          Cond.getOperand(0).getOpcode() == ISD::UADDO ||
16780          Cond.getOperand(0).getOpcode() == ISD::SSUBO ||
16781          Cond.getOperand(0).getOpcode() == ISD::USUBO ||
16782          Cond.getOperand(0).getOpcode() == ISD::SMULO ||
16783          Cond.getOperand(0).getOpcode() == ISD::UMULO)) {
16784       Inverted = true;
16785       Cond = Cond.getOperand(0);
16786     } else {
16787       SDValue NewCond = LowerSETCC(Cond, DAG);
16788       if (NewCond.getNode())
16789         Cond = NewCond;
16790     }
16791   }
16792 #if 0
16793   // FIXME: LowerXALUO doesn't handle these!!
16794   else if (Cond.getOpcode() == X86ISD::ADD  ||
16795            Cond.getOpcode() == X86ISD::SUB  ||
16796            Cond.getOpcode() == X86ISD::SMUL ||
16797            Cond.getOpcode() == X86ISD::UMUL)
16798     Cond = LowerXALUO(Cond, DAG);
16799 #endif
16800
16801   // Look pass (and (setcc_carry (cmp ...)), 1).
16802   if (Cond.getOpcode() == ISD::AND &&
16803       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
16804     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
16805     if (C && C->getAPIntValue() == 1)
16806       Cond = Cond.getOperand(0);
16807   }
16808
16809   // If condition flag is set by a X86ISD::CMP, then use it as the condition
16810   // setting operand in place of the X86ISD::SETCC.
16811   unsigned CondOpcode = Cond.getOpcode();
16812   if (CondOpcode == X86ISD::SETCC ||
16813       CondOpcode == X86ISD::SETCC_CARRY) {
16814     CC = Cond.getOperand(0);
16815
16816     SDValue Cmp = Cond.getOperand(1);
16817     unsigned Opc = Cmp.getOpcode();
16818     // FIXME: WHY THE SPECIAL CASING OF LogicalCmp??
16819     if (isX86LogicalCmp(Cmp) || Opc == X86ISD::BT) {
16820       Cond = Cmp;
16821       addTest = false;
16822     } else {
16823       switch (cast<ConstantSDNode>(CC)->getZExtValue()) {
16824       default: break;
16825       case X86::COND_O:
16826       case X86::COND_B:
16827         // These can only come from an arithmetic instruction with overflow,
16828         // e.g. SADDO, UADDO.
16829         Cond = Cond.getNode()->getOperand(1);
16830         addTest = false;
16831         break;
16832       }
16833     }
16834   }
16835   CondOpcode = Cond.getOpcode();
16836   if (CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
16837       CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
16838       ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
16839        Cond.getOperand(0).getValueType() != MVT::i8)) {
16840     SDValue LHS = Cond.getOperand(0);
16841     SDValue RHS = Cond.getOperand(1);
16842     unsigned X86Opcode;
16843     unsigned X86Cond;
16844     SDVTList VTs;
16845     // Keep this in sync with LowerXALUO, otherwise we might create redundant
16846     // instructions that can't be removed afterwards (i.e. X86ISD::ADD and
16847     // X86ISD::INC).
16848     switch (CondOpcode) {
16849     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
16850     case ISD::SADDO:
16851       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
16852         if (C->isOne()) {
16853           X86Opcode = X86ISD::INC; X86Cond = X86::COND_O;
16854           break;
16855         }
16856       X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
16857     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
16858     case ISD::SSUBO:
16859       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
16860         if (C->isOne()) {
16861           X86Opcode = X86ISD::DEC; X86Cond = X86::COND_O;
16862           break;
16863         }
16864       X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
16865     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
16866     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
16867     default: llvm_unreachable("unexpected overflowing operator");
16868     }
16869     if (Inverted)
16870       X86Cond = X86::GetOppositeBranchCondition((X86::CondCode)X86Cond);
16871     if (CondOpcode == ISD::UMULO)
16872       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
16873                           MVT::i32);
16874     else
16875       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
16876
16877     SDValue X86Op = DAG.getNode(X86Opcode, dl, VTs, LHS, RHS);
16878
16879     if (CondOpcode == ISD::UMULO)
16880       Cond = X86Op.getValue(2);
16881     else
16882       Cond = X86Op.getValue(1);
16883
16884     CC = DAG.getConstant(X86Cond, MVT::i8);
16885     addTest = false;
16886   } else {
16887     unsigned CondOpc;
16888     if (Cond.hasOneUse() && isAndOrOfSetCCs(Cond, CondOpc)) {
16889       SDValue Cmp = Cond.getOperand(0).getOperand(1);
16890       if (CondOpc == ISD::OR) {
16891         // Also, recognize the pattern generated by an FCMP_UNE. We can emit
16892         // two branches instead of an explicit OR instruction with a
16893         // separate test.
16894         if (Cmp == Cond.getOperand(1).getOperand(1) &&
16895             isX86LogicalCmp(Cmp)) {
16896           CC = Cond.getOperand(0).getOperand(0);
16897           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16898                               Chain, Dest, CC, Cmp);
16899           CC = Cond.getOperand(1).getOperand(0);
16900           Cond = Cmp;
16901           addTest = false;
16902         }
16903       } else { // ISD::AND
16904         // Also, recognize the pattern generated by an FCMP_OEQ. We can emit
16905         // two branches instead of an explicit AND instruction with a
16906         // separate test. However, we only do this if this block doesn't
16907         // have a fall-through edge, because this requires an explicit
16908         // jmp when the condition is false.
16909         if (Cmp == Cond.getOperand(1).getOperand(1) &&
16910             isX86LogicalCmp(Cmp) &&
16911             Op.getNode()->hasOneUse()) {
16912           X86::CondCode CCode =
16913             (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
16914           CCode = X86::GetOppositeBranchCondition(CCode);
16915           CC = DAG.getConstant(CCode, MVT::i8);
16916           SDNode *User = *Op.getNode()->use_begin();
16917           // Look for an unconditional branch following this conditional branch.
16918           // We need this because we need to reverse the successors in order
16919           // to implement FCMP_OEQ.
16920           if (User->getOpcode() == ISD::BR) {
16921             SDValue FalseBB = User->getOperand(1);
16922             SDNode *NewBR =
16923               DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
16924             assert(NewBR == User);
16925             (void)NewBR;
16926             Dest = FalseBB;
16927
16928             Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16929                                 Chain, Dest, CC, Cmp);
16930             X86::CondCode CCode =
16931               (X86::CondCode)Cond.getOperand(1).getConstantOperandVal(0);
16932             CCode = X86::GetOppositeBranchCondition(CCode);
16933             CC = DAG.getConstant(CCode, MVT::i8);
16934             Cond = Cmp;
16935             addTest = false;
16936           }
16937         }
16938       }
16939     } else if (Cond.hasOneUse() && isXor1OfSetCC(Cond)) {
16940       // Recognize for xorb (setcc), 1 patterns. The xor inverts the condition.
16941       // It should be transformed during dag combiner except when the condition
16942       // is set by a arithmetics with overflow node.
16943       X86::CondCode CCode =
16944         (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
16945       CCode = X86::GetOppositeBranchCondition(CCode);
16946       CC = DAG.getConstant(CCode, MVT::i8);
16947       Cond = Cond.getOperand(0).getOperand(1);
16948       addTest = false;
16949     } else if (Cond.getOpcode() == ISD::SETCC &&
16950                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETOEQ) {
16951       // For FCMP_OEQ, we can emit
16952       // two branches instead of an explicit AND instruction with a
16953       // separate test. However, we only do this if this block doesn't
16954       // have a fall-through edge, because this requires an explicit
16955       // jmp when the condition is false.
16956       if (Op.getNode()->hasOneUse()) {
16957         SDNode *User = *Op.getNode()->use_begin();
16958         // Look for an unconditional branch following this conditional branch.
16959         // We need this because we need to reverse the successors in order
16960         // to implement FCMP_OEQ.
16961         if (User->getOpcode() == ISD::BR) {
16962           SDValue FalseBB = User->getOperand(1);
16963           SDNode *NewBR =
16964             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
16965           assert(NewBR == User);
16966           (void)NewBR;
16967           Dest = FalseBB;
16968
16969           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
16970                                     Cond.getOperand(0), Cond.getOperand(1));
16971           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
16972           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
16973           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16974                               Chain, Dest, CC, Cmp);
16975           CC = DAG.getConstant(X86::COND_P, MVT::i8);
16976           Cond = Cmp;
16977           addTest = false;
16978         }
16979       }
16980     } else if (Cond.getOpcode() == ISD::SETCC &&
16981                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETUNE) {
16982       // For FCMP_UNE, we can emit
16983       // two branches instead of an explicit AND instruction with a
16984       // separate test. However, we only do this if this block doesn't
16985       // have a fall-through edge, because this requires an explicit
16986       // jmp when the condition is false.
16987       if (Op.getNode()->hasOneUse()) {
16988         SDNode *User = *Op.getNode()->use_begin();
16989         // Look for an unconditional branch following this conditional branch.
16990         // We need this because we need to reverse the successors in order
16991         // to implement FCMP_UNE.
16992         if (User->getOpcode() == ISD::BR) {
16993           SDValue FalseBB = User->getOperand(1);
16994           SDNode *NewBR =
16995             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
16996           assert(NewBR == User);
16997           (void)NewBR;
16998
16999           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
17000                                     Cond.getOperand(0), Cond.getOperand(1));
17001           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
17002           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
17003           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
17004                               Chain, Dest, CC, Cmp);
17005           CC = DAG.getConstant(X86::COND_NP, MVT::i8);
17006           Cond = Cmp;
17007           addTest = false;
17008           Dest = FalseBB;
17009         }
17010       }
17011     }
17012   }
17013
17014   if (addTest) {
17015     // Look pass the truncate if the high bits are known zero.
17016     if (isTruncWithZeroHighBitsInput(Cond, DAG))
17017         Cond = Cond.getOperand(0);
17018
17019     // We know the result of AND is compared against zero. Try to match
17020     // it to BT.
17021     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
17022       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, dl, DAG);
17023       if (NewSetCC.getNode()) {
17024         CC = NewSetCC.getOperand(0);
17025         Cond = NewSetCC.getOperand(1);
17026         addTest = false;
17027       }
17028     }
17029   }
17030
17031   if (addTest) {
17032     X86::CondCode X86Cond = Inverted ? X86::COND_E : X86::COND_NE;
17033     CC = DAG.getConstant(X86Cond, MVT::i8);
17034     Cond = EmitTest(Cond, X86Cond, dl, DAG);
17035   }
17036   Cond = ConvertCmpIfNecessary(Cond, DAG);
17037   return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
17038                      Chain, Dest, CC, Cond);
17039 }
17040
17041 // Lower dynamic stack allocation to _alloca call for Cygwin/Mingw targets.
17042 // Calls to _alloca are needed to probe the stack when allocating more than 4k
17043 // bytes in one go. Touching the stack at 4K increments is necessary to ensure
17044 // that the guard pages used by the OS virtual memory manager are allocated in
17045 // correct sequence.
17046 SDValue
17047 X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
17048                                            SelectionDAG &DAG) const {
17049   MachineFunction &MF = DAG.getMachineFunction();
17050   bool SplitStack = MF.shouldSplitStack();
17051   bool Lower = (Subtarget->isOSWindows() && !Subtarget->isTargetMachO()) ||
17052                SplitStack;
17053   SDLoc dl(Op);
17054
17055   if (!Lower) {
17056     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
17057     SDNode* Node = Op.getNode();
17058
17059     unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore();
17060     assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and"
17061         " not tell us which reg is the stack pointer!");
17062     EVT VT = Node->getValueType(0);
17063     SDValue Tmp1 = SDValue(Node, 0);
17064     SDValue Tmp2 = SDValue(Node, 1);
17065     SDValue Tmp3 = Node->getOperand(2);
17066     SDValue Chain = Tmp1.getOperand(0);
17067
17068     // Chain the dynamic stack allocation so that it doesn't modify the stack
17069     // pointer when other instructions are using the stack.
17070     Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true),
17071         SDLoc(Node));
17072
17073     SDValue Size = Tmp2.getOperand(1);
17074     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
17075     Chain = SP.getValue(1);
17076     unsigned Align = cast<ConstantSDNode>(Tmp3)->getZExtValue();
17077     const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
17078     unsigned StackAlign = TFI.getStackAlignment();
17079     Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
17080     if (Align > StackAlign)
17081       Tmp1 = DAG.getNode(ISD::AND, dl, VT, Tmp1,
17082           DAG.getConstant(-(uint64_t)Align, VT));
17083     Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain
17084
17085     Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true),
17086         DAG.getIntPtrConstant(0, true), SDValue(),
17087         SDLoc(Node));
17088
17089     SDValue Ops[2] = { Tmp1, Tmp2 };
17090     return DAG.getMergeValues(Ops, dl);
17091   }
17092
17093   // Get the inputs.
17094   SDValue Chain = Op.getOperand(0);
17095   SDValue Size  = Op.getOperand(1);
17096   unsigned Align = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue();
17097   EVT VT = Op.getNode()->getValueType(0);
17098
17099   bool Is64Bit = Subtarget->is64Bit();
17100   EVT SPTy = getPointerTy();
17101
17102   if (SplitStack) {
17103     MachineRegisterInfo &MRI = MF.getRegInfo();
17104
17105     if (Is64Bit) {
17106       // The 64 bit implementation of segmented stacks needs to clobber both r10
17107       // r11. This makes it impossible to use it along with nested parameters.
17108       const Function *F = MF.getFunction();
17109
17110       for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
17111            I != E; ++I)
17112         if (I->hasNestAttr())
17113           report_fatal_error("Cannot use segmented stacks with functions that "
17114                              "have nested arguments.");
17115     }
17116
17117     const TargetRegisterClass *AddrRegClass =
17118       getRegClassFor(getPointerTy());
17119     unsigned Vreg = MRI.createVirtualRegister(AddrRegClass);
17120     Chain = DAG.getCopyToReg(Chain, dl, Vreg, Size);
17121     SDValue Value = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
17122                                 DAG.getRegister(Vreg, SPTy));
17123     SDValue Ops1[2] = { Value, Chain };
17124     return DAG.getMergeValues(Ops1, dl);
17125   } else {
17126     SDValue Flag;
17127     const unsigned Reg = (Subtarget->isTarget64BitLP64() ? X86::RAX : X86::EAX);
17128
17129     Chain = DAG.getCopyToReg(Chain, dl, Reg, Size, Flag);
17130     Flag = Chain.getValue(1);
17131     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
17132
17133     Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
17134
17135     const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
17136     unsigned SPReg = RegInfo->getStackRegister();
17137     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, SPTy);
17138     Chain = SP.getValue(1);
17139
17140     if (Align) {
17141       SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
17142                        DAG.getConstant(-(uint64_t)Align, VT));
17143       Chain = DAG.getCopyToReg(Chain, dl, SPReg, SP);
17144     }
17145
17146     SDValue Ops1[2] = { SP, Chain };
17147     return DAG.getMergeValues(Ops1, dl);
17148   }
17149 }
17150
17151 SDValue X86TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
17152   MachineFunction &MF = DAG.getMachineFunction();
17153   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
17154
17155   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
17156   SDLoc DL(Op);
17157
17158   if (!Subtarget->is64Bit() || Subtarget->isTargetWin64()) {
17159     // vastart just stores the address of the VarArgsFrameIndex slot into the
17160     // memory location argument.
17161     SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
17162                                    getPointerTy());
17163     return DAG.getStore(Op.getOperand(0), DL, FR, Op.getOperand(1),
17164                         MachinePointerInfo(SV), false, false, 0);
17165   }
17166
17167   // __va_list_tag:
17168   //   gp_offset         (0 - 6 * 8)
17169   //   fp_offset         (48 - 48 + 8 * 16)
17170   //   overflow_arg_area (point to parameters coming in memory).
17171   //   reg_save_area
17172   SmallVector<SDValue, 8> MemOps;
17173   SDValue FIN = Op.getOperand(1);
17174   // Store gp_offset
17175   SDValue Store = DAG.getStore(Op.getOperand(0), DL,
17176                                DAG.getConstant(FuncInfo->getVarArgsGPOffset(),
17177                                                MVT::i32),
17178                                FIN, MachinePointerInfo(SV), false, false, 0);
17179   MemOps.push_back(Store);
17180
17181   // Store fp_offset
17182   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
17183                     FIN, DAG.getIntPtrConstant(4));
17184   Store = DAG.getStore(Op.getOperand(0), DL,
17185                        DAG.getConstant(FuncInfo->getVarArgsFPOffset(),
17186                                        MVT::i32),
17187                        FIN, MachinePointerInfo(SV, 4), false, false, 0);
17188   MemOps.push_back(Store);
17189
17190   // Store ptr to overflow_arg_area
17191   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
17192                     FIN, DAG.getIntPtrConstant(4));
17193   SDValue OVFIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
17194                                     getPointerTy());
17195   Store = DAG.getStore(Op.getOperand(0), DL, OVFIN, FIN,
17196                        MachinePointerInfo(SV, 8),
17197                        false, false, 0);
17198   MemOps.push_back(Store);
17199
17200   // Store ptr to reg_save_area.
17201   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
17202                     FIN, DAG.getIntPtrConstant(8));
17203   SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
17204                                     getPointerTy());
17205   Store = DAG.getStore(Op.getOperand(0), DL, RSFIN, FIN,
17206                        MachinePointerInfo(SV, 16), false, false, 0);
17207   MemOps.push_back(Store);
17208   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
17209 }
17210
17211 SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
17212   assert(Subtarget->is64Bit() &&
17213          "LowerVAARG only handles 64-bit va_arg!");
17214   assert((Subtarget->isTargetLinux() ||
17215           Subtarget->isTargetDarwin()) &&
17216           "Unhandled target in LowerVAARG");
17217   assert(Op.getNode()->getNumOperands() == 4);
17218   SDValue Chain = Op.getOperand(0);
17219   SDValue SrcPtr = Op.getOperand(1);
17220   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
17221   unsigned Align = Op.getConstantOperandVal(3);
17222   SDLoc dl(Op);
17223
17224   EVT ArgVT = Op.getNode()->getValueType(0);
17225   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
17226   uint32_t ArgSize = getDataLayout()->getTypeAllocSize(ArgTy);
17227   uint8_t ArgMode;
17228
17229   // Decide which area this value should be read from.
17230   // TODO: Implement the AMD64 ABI in its entirety. This simple
17231   // selection mechanism works only for the basic types.
17232   if (ArgVT == MVT::f80) {
17233     llvm_unreachable("va_arg for f80 not yet implemented");
17234   } else if (ArgVT.isFloatingPoint() && ArgSize <= 16 /*bytes*/) {
17235     ArgMode = 2;  // Argument passed in XMM register. Use fp_offset.
17236   } else if (ArgVT.isInteger() && ArgSize <= 32 /*bytes*/) {
17237     ArgMode = 1;  // Argument passed in GPR64 register(s). Use gp_offset.
17238   } else {
17239     llvm_unreachable("Unhandled argument type in LowerVAARG");
17240   }
17241
17242   if (ArgMode == 2) {
17243     // Sanity Check: Make sure using fp_offset makes sense.
17244     assert(!DAG.getTarget().Options.UseSoftFloat &&
17245            !(DAG.getMachineFunction().getFunction()->hasFnAttribute(
17246                Attribute::NoImplicitFloat)) &&
17247            Subtarget->hasSSE1());
17248   }
17249
17250   // Insert VAARG_64 node into the DAG
17251   // VAARG_64 returns two values: Variable Argument Address, Chain
17252   SmallVector<SDValue, 11> InstOps;
17253   InstOps.push_back(Chain);
17254   InstOps.push_back(SrcPtr);
17255   InstOps.push_back(DAG.getConstant(ArgSize, MVT::i32));
17256   InstOps.push_back(DAG.getConstant(ArgMode, MVT::i8));
17257   InstOps.push_back(DAG.getConstant(Align, MVT::i32));
17258   SDVTList VTs = DAG.getVTList(getPointerTy(), MVT::Other);
17259   SDValue VAARG = DAG.getMemIntrinsicNode(X86ISD::VAARG_64, dl,
17260                                           VTs, InstOps, MVT::i64,
17261                                           MachinePointerInfo(SV),
17262                                           /*Align=*/0,
17263                                           /*Volatile=*/false,
17264                                           /*ReadMem=*/true,
17265                                           /*WriteMem=*/true);
17266   Chain = VAARG.getValue(1);
17267
17268   // Load the next argument and return it
17269   return DAG.getLoad(ArgVT, dl,
17270                      Chain,
17271                      VAARG,
17272                      MachinePointerInfo(),
17273                      false, false, false, 0);
17274 }
17275
17276 static SDValue LowerVACOPY(SDValue Op, const X86Subtarget *Subtarget,
17277                            SelectionDAG &DAG) {
17278   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
17279   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_copy!");
17280   SDValue Chain = Op.getOperand(0);
17281   SDValue DstPtr = Op.getOperand(1);
17282   SDValue SrcPtr = Op.getOperand(2);
17283   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
17284   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
17285   SDLoc DL(Op);
17286
17287   return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr,
17288                        DAG.getIntPtrConstant(24), 8, /*isVolatile*/false,
17289                        false,
17290                        MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV));
17291 }
17292
17293 // getTargetVShiftByConstNode - Handle vector element shifts where the shift
17294 // amount is a constant. Takes immediate version of shift as input.
17295 static SDValue getTargetVShiftByConstNode(unsigned Opc, SDLoc dl, MVT VT,
17296                                           SDValue SrcOp, uint64_t ShiftAmt,
17297                                           SelectionDAG &DAG) {
17298   MVT ElementType = VT.getVectorElementType();
17299
17300   // Fold this packed shift into its first operand if ShiftAmt is 0.
17301   if (ShiftAmt == 0)
17302     return SrcOp;
17303
17304   // Check for ShiftAmt >= element width
17305   if (ShiftAmt >= ElementType.getSizeInBits()) {
17306     if (Opc == X86ISD::VSRAI)
17307       ShiftAmt = ElementType.getSizeInBits() - 1;
17308     else
17309       return DAG.getConstant(0, VT);
17310   }
17311
17312   assert((Opc == X86ISD::VSHLI || Opc == X86ISD::VSRLI || Opc == X86ISD::VSRAI)
17313          && "Unknown target vector shift-by-constant node");
17314
17315   // Fold this packed vector shift into a build vector if SrcOp is a
17316   // vector of Constants or UNDEFs, and SrcOp valuetype is the same as VT.
17317   if (VT == SrcOp.getSimpleValueType() &&
17318       ISD::isBuildVectorOfConstantSDNodes(SrcOp.getNode())) {
17319     SmallVector<SDValue, 8> Elts;
17320     unsigned NumElts = SrcOp->getNumOperands();
17321     ConstantSDNode *ND;
17322
17323     switch(Opc) {
17324     default: llvm_unreachable(nullptr);
17325     case X86ISD::VSHLI:
17326       for (unsigned i=0; i!=NumElts; ++i) {
17327         SDValue CurrentOp = SrcOp->getOperand(i);
17328         if (CurrentOp->getOpcode() == ISD::UNDEF) {
17329           Elts.push_back(CurrentOp);
17330           continue;
17331         }
17332         ND = cast<ConstantSDNode>(CurrentOp);
17333         const APInt &C = ND->getAPIntValue();
17334         Elts.push_back(DAG.getConstant(C.shl(ShiftAmt), ElementType));
17335       }
17336       break;
17337     case X86ISD::VSRLI:
17338       for (unsigned i=0; i!=NumElts; ++i) {
17339         SDValue CurrentOp = SrcOp->getOperand(i);
17340         if (CurrentOp->getOpcode() == ISD::UNDEF) {
17341           Elts.push_back(CurrentOp);
17342           continue;
17343         }
17344         ND = cast<ConstantSDNode>(CurrentOp);
17345         const APInt &C = ND->getAPIntValue();
17346         Elts.push_back(DAG.getConstant(C.lshr(ShiftAmt), ElementType));
17347       }
17348       break;
17349     case X86ISD::VSRAI:
17350       for (unsigned i=0; i!=NumElts; ++i) {
17351         SDValue CurrentOp = SrcOp->getOperand(i);
17352         if (CurrentOp->getOpcode() == ISD::UNDEF) {
17353           Elts.push_back(CurrentOp);
17354           continue;
17355         }
17356         ND = cast<ConstantSDNode>(CurrentOp);
17357         const APInt &C = ND->getAPIntValue();
17358         Elts.push_back(DAG.getConstant(C.ashr(ShiftAmt), ElementType));
17359       }
17360       break;
17361     }
17362
17363     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
17364   }
17365
17366   return DAG.getNode(Opc, dl, VT, SrcOp, DAG.getConstant(ShiftAmt, MVT::i8));
17367 }
17368
17369 // getTargetVShiftNode - Handle vector element shifts where the shift amount
17370 // may or may not be a constant. Takes immediate version of shift as input.
17371 static SDValue getTargetVShiftNode(unsigned Opc, SDLoc dl, MVT VT,
17372                                    SDValue SrcOp, SDValue ShAmt,
17373                                    SelectionDAG &DAG) {
17374   MVT SVT = ShAmt.getSimpleValueType();
17375   assert((SVT == MVT::i32 || SVT == MVT::i64) && "Unexpected value type!");
17376
17377   // Catch shift-by-constant.
17378   if (ConstantSDNode *CShAmt = dyn_cast<ConstantSDNode>(ShAmt))
17379     return getTargetVShiftByConstNode(Opc, dl, VT, SrcOp,
17380                                       CShAmt->getZExtValue(), DAG);
17381
17382   // Change opcode to non-immediate version
17383   switch (Opc) {
17384     default: llvm_unreachable("Unknown target vector shift node");
17385     case X86ISD::VSHLI: Opc = X86ISD::VSHL; break;
17386     case X86ISD::VSRLI: Opc = X86ISD::VSRL; break;
17387     case X86ISD::VSRAI: Opc = X86ISD::VSRA; break;
17388   }
17389
17390   const X86Subtarget &Subtarget =
17391       static_cast<const X86Subtarget &>(DAG.getSubtarget());
17392   if (Subtarget.hasSSE41() && ShAmt.getOpcode() == ISD::ZERO_EXTEND &&
17393       ShAmt.getOperand(0).getSimpleValueType() == MVT::i16) {
17394     // Let the shuffle legalizer expand this shift amount node.
17395     SDValue Op0 = ShAmt.getOperand(0);
17396     Op0 = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(Op0), MVT::v8i16, Op0);
17397     ShAmt = getShuffleVectorZeroOrUndef(Op0, 0, true, &Subtarget, DAG);
17398   } else {
17399     // Need to build a vector containing shift amount.
17400     // SSE/AVX packed shifts only use the lower 64-bit of the shift count.
17401     SmallVector<SDValue, 4> ShOps;
17402     ShOps.push_back(ShAmt);
17403     if (SVT == MVT::i32) {
17404       ShOps.push_back(DAG.getConstant(0, SVT));
17405       ShOps.push_back(DAG.getUNDEF(SVT));
17406     }
17407     ShOps.push_back(DAG.getUNDEF(SVT));
17408
17409     MVT BVT = SVT == MVT::i32 ? MVT::v4i32 : MVT::v2i64;
17410     ShAmt = DAG.getNode(ISD::BUILD_VECTOR, dl, BVT, ShOps);
17411   }
17412
17413   // The return type has to be a 128-bit type with the same element
17414   // type as the input type.
17415   MVT EltVT = VT.getVectorElementType();
17416   EVT ShVT = MVT::getVectorVT(EltVT, 128/EltVT.getSizeInBits());
17417
17418   ShAmt = DAG.getNode(ISD::BITCAST, dl, ShVT, ShAmt);
17419   return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
17420 }
17421
17422 /// \brief Return (and \p Op, \p Mask) for compare instructions or
17423 /// (vselect \p Mask, \p Op, \p PreservedSrc) for others along with the
17424 /// necessary casting for \p Mask when lowering masking intrinsics.
17425 static SDValue getVectorMaskingNode(SDValue Op, SDValue Mask,
17426                                     SDValue PreservedSrc,
17427                                     const X86Subtarget *Subtarget,
17428                                     SelectionDAG &DAG) {
17429     EVT VT = Op.getValueType();
17430     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(),
17431                                   MVT::i1, VT.getVectorNumElements());
17432     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17433                                      Mask.getValueType().getSizeInBits());
17434     SDLoc dl(Op);
17435
17436     assert(MaskVT.isSimple() && "invalid mask type");
17437
17438     if (isAllOnes(Mask))
17439       return Op;
17440
17441     // In case when MaskVT equals v2i1 or v4i1, low 2 or 4 elements
17442     // are extracted by EXTRACT_SUBVECTOR.
17443     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17444                               DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17445                               DAG.getIntPtrConstant(0));
17446
17447     switch (Op.getOpcode()) {
17448       default: break;
17449       case X86ISD::PCMPEQM:
17450       case X86ISD::PCMPGTM:
17451       case X86ISD::CMPM:
17452       case X86ISD::CMPMU:
17453         return DAG.getNode(ISD::AND, dl, VT, Op, VMask);
17454     }
17455     if (PreservedSrc.getOpcode() == ISD::UNDEF)
17456       PreservedSrc = getZeroVector(VT, Subtarget, DAG, dl);
17457     return DAG.getNode(ISD::VSELECT, dl, VT, VMask, Op, PreservedSrc);
17458 }
17459
17460 /// \brief Creates an SDNode for a predicated scalar operation.
17461 /// \returns (X86vselect \p Mask, \p Op, \p PreservedSrc).
17462 /// The mask is comming as MVT::i8 and it should be truncated
17463 /// to MVT::i1 while lowering masking intrinsics.
17464 /// The main difference between ScalarMaskingNode and VectorMaskingNode is using
17465 /// "X86select" instead of "vselect". We just can't create the "vselect" node for
17466 /// a scalar instruction.
17467 static SDValue getScalarMaskingNode(SDValue Op, SDValue Mask,
17468                                     SDValue PreservedSrc,
17469                                     const X86Subtarget *Subtarget,
17470                                     SelectionDAG &DAG) {
17471     if (isAllOnes(Mask))
17472       return Op;
17473
17474     EVT VT = Op.getValueType();
17475     SDLoc dl(Op);
17476     // The mask should be of type MVT::i1
17477     SDValue IMask = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, Mask);
17478
17479     if (PreservedSrc.getOpcode() == ISD::UNDEF)
17480       PreservedSrc = getZeroVector(VT, Subtarget, DAG, dl);
17481     return DAG.getNode(X86ISD::SELECT, dl, VT, IMask, Op, PreservedSrc);
17482 }
17483
17484 static SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
17485                                        SelectionDAG &DAG) {
17486   SDLoc dl(Op);
17487   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
17488   EVT VT = Op.getValueType();
17489   const IntrinsicData* IntrData = getIntrinsicWithoutChain(IntNo);
17490   if (IntrData) {
17491     switch(IntrData->Type) {
17492     case INTR_TYPE_1OP:
17493       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1));
17494     case INTR_TYPE_2OP:
17495       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1),
17496         Op.getOperand(2));
17497     case INTR_TYPE_3OP:
17498       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1),
17499         Op.getOperand(2), Op.getOperand(3));
17500     case INTR_TYPE_1OP_MASK_RM: {
17501       SDValue Src = Op.getOperand(1);
17502       SDValue Src0 = Op.getOperand(2);
17503       SDValue Mask = Op.getOperand(3);
17504       SDValue RoundingMode = Op.getOperand(4);
17505       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src,
17506                                               RoundingMode),
17507                                   Mask, Src0, Subtarget, DAG);
17508     }
17509     case INTR_TYPE_SCALAR_MASK_RM: {
17510       SDValue Src1 = Op.getOperand(1);
17511       SDValue Src2 = Op.getOperand(2);
17512       SDValue Src0 = Op.getOperand(3);
17513       SDValue Mask = Op.getOperand(4);
17514       // There are 2 kinds of intrinsics in this group:
17515       // (1) With supress-all-exceptions (sae) - 6 operands
17516       // (2) With rounding mode and sae - 7 operands.
17517       if (Op.getNumOperands() == 6) {
17518         SDValue Sae  = Op.getOperand(5);
17519         return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2,
17520                                                 Sae),
17521                                     Mask, Src0, Subtarget, DAG);
17522       }
17523       assert(Op.getNumOperands() == 7 && "Unexpected intrinsic form");
17524       SDValue RoundingMode  = Op.getOperand(5);
17525       SDValue Sae  = Op.getOperand(6);
17526       return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2,
17527                                               RoundingMode, Sae),
17528                                   Mask, Src0, Subtarget, DAG);
17529     }
17530     case INTR_TYPE_2OP_MASK: {
17531       SDValue Src1 = Op.getOperand(1);
17532       SDValue Src2 = Op.getOperand(2);
17533       SDValue PassThru = Op.getOperand(3);
17534       SDValue Mask = Op.getOperand(4);
17535       // We specify 2 possible opcodes for intrinsics with rounding modes.
17536       // First, we check if the intrinsic may have non-default rounding mode,
17537       // (IntrData->Opc1 != 0), then we check the rounding mode operand.
17538       unsigned IntrWithRoundingModeOpcode = IntrData->Opc1;
17539       if (IntrWithRoundingModeOpcode != 0) {
17540         SDValue Rnd = Op.getOperand(5);
17541         unsigned Round = cast<ConstantSDNode>(Rnd)->getZExtValue();
17542         if (Round != X86::STATIC_ROUNDING::CUR_DIRECTION) {
17543           return getVectorMaskingNode(DAG.getNode(IntrWithRoundingModeOpcode,
17544                                       dl, Op.getValueType(),
17545                                       Src1, Src2, Rnd),
17546                                       Mask, PassThru, Subtarget, DAG);
17547         }
17548       }
17549       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT,
17550                                               Src1,Src2),
17551                                   Mask, PassThru, Subtarget, DAG);
17552     }
17553     case FMA_OP_MASK: {
17554       SDValue Src1 = Op.getOperand(1);
17555       SDValue Src2 = Op.getOperand(2);
17556       SDValue Src3 = Op.getOperand(3);
17557       SDValue Mask = Op.getOperand(4);
17558       // We specify 2 possible opcodes for intrinsics with rounding modes.
17559       // First, we check if the intrinsic may have non-default rounding mode,
17560       // (IntrData->Opc1 != 0), then we check the rounding mode operand.
17561       unsigned IntrWithRoundingModeOpcode = IntrData->Opc1;
17562       if (IntrWithRoundingModeOpcode != 0) {
17563         SDValue Rnd = Op.getOperand(5);
17564         if (cast<ConstantSDNode>(Rnd)->getZExtValue() !=
17565             X86::STATIC_ROUNDING::CUR_DIRECTION)
17566           return getVectorMaskingNode(DAG.getNode(IntrWithRoundingModeOpcode,
17567                                                   dl, Op.getValueType(),
17568                                                   Src1, Src2, Src3, Rnd),
17569                                       Mask, Src1, Subtarget, DAG);
17570       }
17571       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0,
17572                                               dl, Op.getValueType(),
17573                                               Src1, Src2, Src3),
17574                                   Mask, Src1, Subtarget, DAG);
17575     }
17576     case CMP_MASK:
17577     case CMP_MASK_CC: {
17578       // Comparison intrinsics with masks.
17579       // Example of transformation:
17580       // (i8 (int_x86_avx512_mask_pcmpeq_q_128
17581       //             (v2i64 %a), (v2i64 %b), (i8 %mask))) ->
17582       // (i8 (bitcast
17583       //   (v8i1 (insert_subvector undef,
17584       //           (v2i1 (and (PCMPEQM %a, %b),
17585       //                      (extract_subvector
17586       //                         (v8i1 (bitcast %mask)), 0))), 0))))
17587       EVT VT = Op.getOperand(1).getValueType();
17588       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17589                                     VT.getVectorNumElements());
17590       SDValue Mask = Op.getOperand((IntrData->Type == CMP_MASK_CC) ? 4 : 3);
17591       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17592                                        Mask.getValueType().getSizeInBits());
17593       SDValue Cmp;
17594       if (IntrData->Type == CMP_MASK_CC) {
17595         Cmp = DAG.getNode(IntrData->Opc0, dl, MaskVT, Op.getOperand(1),
17596                     Op.getOperand(2), Op.getOperand(3));
17597       } else {
17598         assert(IntrData->Type == CMP_MASK && "Unexpected intrinsic type!");
17599         Cmp = DAG.getNode(IntrData->Opc0, dl, MaskVT, Op.getOperand(1),
17600                     Op.getOperand(2));
17601       }
17602       SDValue CmpMask = getVectorMaskingNode(Cmp, Mask,
17603                                              DAG.getTargetConstant(0, MaskVT),
17604                                              Subtarget, DAG);
17605       SDValue Res = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, BitcastVT,
17606                                 DAG.getUNDEF(BitcastVT), CmpMask,
17607                                 DAG.getIntPtrConstant(0));
17608       return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
17609     }
17610     case COMI: { // Comparison intrinsics
17611       ISD::CondCode CC = (ISD::CondCode)IntrData->Opc1;
17612       SDValue LHS = Op.getOperand(1);
17613       SDValue RHS = Op.getOperand(2);
17614       unsigned X86CC = TranslateX86CC(CC, true, LHS, RHS, DAG);
17615       assert(X86CC != X86::COND_INVALID && "Unexpected illegal condition!");
17616       SDValue Cond = DAG.getNode(IntrData->Opc0, dl, MVT::i32, LHS, RHS);
17617       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17618                                   DAG.getConstant(X86CC, MVT::i8), Cond);
17619       return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17620     }
17621     case VSHIFT:
17622       return getTargetVShiftNode(IntrData->Opc0, dl, Op.getSimpleValueType(),
17623                                  Op.getOperand(1), Op.getOperand(2), DAG);
17624     case VSHIFT_MASK:
17625       return getVectorMaskingNode(getTargetVShiftNode(IntrData->Opc0, dl,
17626                                                       Op.getSimpleValueType(),
17627                                                       Op.getOperand(1),
17628                                                       Op.getOperand(2), DAG),
17629                                   Op.getOperand(4), Op.getOperand(3), Subtarget,
17630                                   DAG);
17631     case COMPRESS_EXPAND_IN_REG: {
17632       SDValue Mask = Op.getOperand(3);
17633       SDValue DataToCompress = Op.getOperand(1);
17634       SDValue PassThru = Op.getOperand(2);
17635       if (isAllOnes(Mask)) // return data as is
17636         return Op.getOperand(1);
17637       EVT VT = Op.getValueType();
17638       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17639                                     VT.getVectorNumElements());
17640       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17641                                        Mask.getValueType().getSizeInBits());
17642       SDLoc dl(Op);
17643       SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17644                                   DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17645                                   DAG.getIntPtrConstant(0));
17646
17647       return DAG.getNode(IntrData->Opc0, dl, VT, VMask, DataToCompress,
17648                          PassThru);
17649     }
17650     case BLEND: {
17651       SDValue Mask = Op.getOperand(3);
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       return DAG.getNode(IntrData->Opc0, dl, VT, VMask, Op.getOperand(1),
17662                          Op.getOperand(2));
17663     }
17664     default:
17665       break;
17666     }
17667   }
17668
17669   switch (IntNo) {
17670   default: return SDValue();    // Don't custom lower most intrinsics.
17671
17672   case Intrinsic::x86_avx512_mask_valign_q_512:
17673   case Intrinsic::x86_avx512_mask_valign_d_512:
17674     // Vector source operands are swapped.
17675     return getVectorMaskingNode(DAG.getNode(X86ISD::VALIGN, dl,
17676                                             Op.getValueType(), Op.getOperand(2),
17677                                             Op.getOperand(1),
17678                                             Op.getOperand(3)),
17679                                 Op.getOperand(5), Op.getOperand(4),
17680                                 Subtarget, DAG);
17681
17682   // ptest and testp intrinsics. The intrinsic these come from are designed to
17683   // return an integer value, not just an instruction so lower it to the ptest
17684   // or testp pattern and a setcc for the result.
17685   case Intrinsic::x86_sse41_ptestz:
17686   case Intrinsic::x86_sse41_ptestc:
17687   case Intrinsic::x86_sse41_ptestnzc:
17688   case Intrinsic::x86_avx_ptestz_256:
17689   case Intrinsic::x86_avx_ptestc_256:
17690   case Intrinsic::x86_avx_ptestnzc_256:
17691   case Intrinsic::x86_avx_vtestz_ps:
17692   case Intrinsic::x86_avx_vtestc_ps:
17693   case Intrinsic::x86_avx_vtestnzc_ps:
17694   case Intrinsic::x86_avx_vtestz_pd:
17695   case Intrinsic::x86_avx_vtestc_pd:
17696   case Intrinsic::x86_avx_vtestnzc_pd:
17697   case Intrinsic::x86_avx_vtestz_ps_256:
17698   case Intrinsic::x86_avx_vtestc_ps_256:
17699   case Intrinsic::x86_avx_vtestnzc_ps_256:
17700   case Intrinsic::x86_avx_vtestz_pd_256:
17701   case Intrinsic::x86_avx_vtestc_pd_256:
17702   case Intrinsic::x86_avx_vtestnzc_pd_256: {
17703     bool IsTestPacked = false;
17704     unsigned X86CC;
17705     switch (IntNo) {
17706     default: llvm_unreachable("Bad fallthrough in Intrinsic lowering.");
17707     case Intrinsic::x86_avx_vtestz_ps:
17708     case Intrinsic::x86_avx_vtestz_pd:
17709     case Intrinsic::x86_avx_vtestz_ps_256:
17710     case Intrinsic::x86_avx_vtestz_pd_256:
17711       IsTestPacked = true; // Fallthrough
17712     case Intrinsic::x86_sse41_ptestz:
17713     case Intrinsic::x86_avx_ptestz_256:
17714       // ZF = 1
17715       X86CC = X86::COND_E;
17716       break;
17717     case Intrinsic::x86_avx_vtestc_ps:
17718     case Intrinsic::x86_avx_vtestc_pd:
17719     case Intrinsic::x86_avx_vtestc_ps_256:
17720     case Intrinsic::x86_avx_vtestc_pd_256:
17721       IsTestPacked = true; // Fallthrough
17722     case Intrinsic::x86_sse41_ptestc:
17723     case Intrinsic::x86_avx_ptestc_256:
17724       // CF = 1
17725       X86CC = X86::COND_B;
17726       break;
17727     case Intrinsic::x86_avx_vtestnzc_ps:
17728     case Intrinsic::x86_avx_vtestnzc_pd:
17729     case Intrinsic::x86_avx_vtestnzc_ps_256:
17730     case Intrinsic::x86_avx_vtestnzc_pd_256:
17731       IsTestPacked = true; // Fallthrough
17732     case Intrinsic::x86_sse41_ptestnzc:
17733     case Intrinsic::x86_avx_ptestnzc_256:
17734       // ZF and CF = 0
17735       X86CC = X86::COND_A;
17736       break;
17737     }
17738
17739     SDValue LHS = Op.getOperand(1);
17740     SDValue RHS = Op.getOperand(2);
17741     unsigned TestOpc = IsTestPacked ? X86ISD::TESTP : X86ISD::PTEST;
17742     SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
17743     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
17744     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
17745     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17746   }
17747   case Intrinsic::x86_avx512_kortestz_w:
17748   case Intrinsic::x86_avx512_kortestc_w: {
17749     unsigned X86CC = (IntNo == Intrinsic::x86_avx512_kortestz_w)? X86::COND_E: X86::COND_B;
17750     SDValue LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(1));
17751     SDValue RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(2));
17752     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
17753     SDValue Test = DAG.getNode(X86ISD::KORTEST, dl, MVT::i32, LHS, RHS);
17754     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i1, CC, Test);
17755     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17756   }
17757
17758   case Intrinsic::x86_sse42_pcmpistria128:
17759   case Intrinsic::x86_sse42_pcmpestria128:
17760   case Intrinsic::x86_sse42_pcmpistric128:
17761   case Intrinsic::x86_sse42_pcmpestric128:
17762   case Intrinsic::x86_sse42_pcmpistrio128:
17763   case Intrinsic::x86_sse42_pcmpestrio128:
17764   case Intrinsic::x86_sse42_pcmpistris128:
17765   case Intrinsic::x86_sse42_pcmpestris128:
17766   case Intrinsic::x86_sse42_pcmpistriz128:
17767   case Intrinsic::x86_sse42_pcmpestriz128: {
17768     unsigned Opcode;
17769     unsigned X86CC;
17770     switch (IntNo) {
17771     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
17772     case Intrinsic::x86_sse42_pcmpistria128:
17773       Opcode = X86ISD::PCMPISTRI;
17774       X86CC = X86::COND_A;
17775       break;
17776     case Intrinsic::x86_sse42_pcmpestria128:
17777       Opcode = X86ISD::PCMPESTRI;
17778       X86CC = X86::COND_A;
17779       break;
17780     case Intrinsic::x86_sse42_pcmpistric128:
17781       Opcode = X86ISD::PCMPISTRI;
17782       X86CC = X86::COND_B;
17783       break;
17784     case Intrinsic::x86_sse42_pcmpestric128:
17785       Opcode = X86ISD::PCMPESTRI;
17786       X86CC = X86::COND_B;
17787       break;
17788     case Intrinsic::x86_sse42_pcmpistrio128:
17789       Opcode = X86ISD::PCMPISTRI;
17790       X86CC = X86::COND_O;
17791       break;
17792     case Intrinsic::x86_sse42_pcmpestrio128:
17793       Opcode = X86ISD::PCMPESTRI;
17794       X86CC = X86::COND_O;
17795       break;
17796     case Intrinsic::x86_sse42_pcmpistris128:
17797       Opcode = X86ISD::PCMPISTRI;
17798       X86CC = X86::COND_S;
17799       break;
17800     case Intrinsic::x86_sse42_pcmpestris128:
17801       Opcode = X86ISD::PCMPESTRI;
17802       X86CC = X86::COND_S;
17803       break;
17804     case Intrinsic::x86_sse42_pcmpistriz128:
17805       Opcode = X86ISD::PCMPISTRI;
17806       X86CC = X86::COND_E;
17807       break;
17808     case Intrinsic::x86_sse42_pcmpestriz128:
17809       Opcode = X86ISD::PCMPESTRI;
17810       X86CC = X86::COND_E;
17811       break;
17812     }
17813     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
17814     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
17815     SDValue PCMP = DAG.getNode(Opcode, dl, VTs, NewOps);
17816     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17817                                 DAG.getConstant(X86CC, MVT::i8),
17818                                 SDValue(PCMP.getNode(), 1));
17819     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17820   }
17821
17822   case Intrinsic::x86_sse42_pcmpistri128:
17823   case Intrinsic::x86_sse42_pcmpestri128: {
17824     unsigned Opcode;
17825     if (IntNo == Intrinsic::x86_sse42_pcmpistri128)
17826       Opcode = X86ISD::PCMPISTRI;
17827     else
17828       Opcode = X86ISD::PCMPESTRI;
17829
17830     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
17831     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
17832     return DAG.getNode(Opcode, dl, VTs, NewOps);
17833   }
17834   }
17835 }
17836
17837 static SDValue getGatherNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17838                               SDValue Src, SDValue Mask, SDValue Base,
17839                               SDValue Index, SDValue ScaleOp, SDValue Chain,
17840                               const X86Subtarget * Subtarget) {
17841   SDLoc dl(Op);
17842   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17843   assert(C && "Invalid scale type");
17844   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17845   EVT MaskVT = MVT::getVectorVT(MVT::i1,
17846                              Index.getSimpleValueType().getVectorNumElements());
17847   SDValue MaskInReg;
17848   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17849   if (MaskC)
17850     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17851   else
17852     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17853   SDVTList VTs = DAG.getVTList(Op.getValueType(), MaskVT, MVT::Other);
17854   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17855   SDValue Segment = DAG.getRegister(0, MVT::i32);
17856   if (Src.getOpcode() == ISD::UNDEF)
17857     Src = getZeroVector(Op.getValueType(), Subtarget, DAG, dl);
17858   SDValue Ops[] = {Src, MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
17859   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
17860   SDValue RetOps[] = { SDValue(Res, 0), SDValue(Res, 2) };
17861   return DAG.getMergeValues(RetOps, dl);
17862 }
17863
17864 static SDValue getScatterNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17865                                SDValue Src, SDValue Mask, SDValue Base,
17866                                SDValue Index, SDValue ScaleOp, SDValue Chain) {
17867   SDLoc dl(Op);
17868   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17869   assert(C && "Invalid scale type");
17870   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17871   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17872   SDValue Segment = DAG.getRegister(0, MVT::i32);
17873   EVT MaskVT = MVT::getVectorVT(MVT::i1,
17874                              Index.getSimpleValueType().getVectorNumElements());
17875   SDValue MaskInReg;
17876   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17877   if (MaskC)
17878     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17879   else
17880     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17881   SDVTList VTs = DAG.getVTList(MaskVT, MVT::Other);
17882   SDValue Ops[] = {Base, Scale, Index, Disp, Segment, MaskInReg, Src, Chain};
17883   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
17884   return SDValue(Res, 1);
17885 }
17886
17887 static SDValue getPrefetchNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17888                                SDValue Mask, SDValue Base, SDValue Index,
17889                                SDValue ScaleOp, SDValue Chain) {
17890   SDLoc dl(Op);
17891   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17892   assert(C && "Invalid scale type");
17893   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17894   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17895   SDValue Segment = DAG.getRegister(0, MVT::i32);
17896   EVT MaskVT =
17897     MVT::getVectorVT(MVT::i1, Index.getSimpleValueType().getVectorNumElements());
17898   SDValue MaskInReg;
17899   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17900   if (MaskC)
17901     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17902   else
17903     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17904   //SDVTList VTs = DAG.getVTList(MVT::Other);
17905   SDValue Ops[] = {MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
17906   SDNode *Res = DAG.getMachineNode(Opc, dl, MVT::Other, Ops);
17907   return SDValue(Res, 0);
17908 }
17909
17910 // getReadPerformanceCounter - Handles the lowering of builtin intrinsics that
17911 // read performance monitor counters (x86_rdpmc).
17912 static void getReadPerformanceCounter(SDNode *N, SDLoc DL,
17913                               SelectionDAG &DAG, const X86Subtarget *Subtarget,
17914                               SmallVectorImpl<SDValue> &Results) {
17915   assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
17916   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
17917   SDValue LO, HI;
17918
17919   // The ECX register is used to select the index of the performance counter
17920   // to read.
17921   SDValue Chain = DAG.getCopyToReg(N->getOperand(0), DL, X86::ECX,
17922                                    N->getOperand(2));
17923   SDValue rd = DAG.getNode(X86ISD::RDPMC_DAG, DL, Tys, Chain);
17924
17925   // Reads the content of a 64-bit performance counter and returns it in the
17926   // registers EDX:EAX.
17927   if (Subtarget->is64Bit()) {
17928     LO = DAG.getCopyFromReg(rd, DL, X86::RAX, MVT::i64, rd.getValue(1));
17929     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::RDX, MVT::i64,
17930                             LO.getValue(2));
17931   } else {
17932     LO = DAG.getCopyFromReg(rd, DL, X86::EAX, MVT::i32, rd.getValue(1));
17933     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::EDX, MVT::i32,
17934                             LO.getValue(2));
17935   }
17936   Chain = HI.getValue(1);
17937
17938   if (Subtarget->is64Bit()) {
17939     // The EAX register is loaded with the low-order 32 bits. The EDX register
17940     // is loaded with the supported high-order bits of the counter.
17941     SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
17942                               DAG.getConstant(32, MVT::i8));
17943     Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
17944     Results.push_back(Chain);
17945     return;
17946   }
17947
17948   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
17949   SDValue Ops[] = { LO, HI };
17950   SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
17951   Results.push_back(Pair);
17952   Results.push_back(Chain);
17953 }
17954
17955 // getReadTimeStampCounter - Handles the lowering of builtin intrinsics that
17956 // read the time stamp counter (x86_rdtsc and x86_rdtscp). This function is
17957 // also used to custom lower READCYCLECOUNTER nodes.
17958 static void getReadTimeStampCounter(SDNode *N, SDLoc DL, unsigned Opcode,
17959                               SelectionDAG &DAG, const X86Subtarget *Subtarget,
17960                               SmallVectorImpl<SDValue> &Results) {
17961   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
17962   SDValue rd = DAG.getNode(Opcode, DL, Tys, N->getOperand(0));
17963   SDValue LO, HI;
17964
17965   // The processor's time-stamp counter (a 64-bit MSR) is stored into the
17966   // EDX:EAX registers. EDX is loaded with the high-order 32 bits of the MSR
17967   // and the EAX register is loaded with the low-order 32 bits.
17968   if (Subtarget->is64Bit()) {
17969     LO = DAG.getCopyFromReg(rd, DL, X86::RAX, MVT::i64, rd.getValue(1));
17970     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::RDX, MVT::i64,
17971                             LO.getValue(2));
17972   } else {
17973     LO = DAG.getCopyFromReg(rd, DL, X86::EAX, MVT::i32, rd.getValue(1));
17974     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::EDX, MVT::i32,
17975                             LO.getValue(2));
17976   }
17977   SDValue Chain = HI.getValue(1);
17978
17979   if (Opcode == X86ISD::RDTSCP_DAG) {
17980     assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
17981
17982     // Instruction RDTSCP loads the IA32:TSC_AUX_MSR (address C000_0103H) into
17983     // the ECX register. Add 'ecx' explicitly to the chain.
17984     SDValue ecx = DAG.getCopyFromReg(Chain, DL, X86::ECX, MVT::i32,
17985                                      HI.getValue(2));
17986     // Explicitly store the content of ECX at the location passed in input
17987     // to the 'rdtscp' intrinsic.
17988     Chain = DAG.getStore(ecx.getValue(1), DL, ecx, N->getOperand(2),
17989                          MachinePointerInfo(), false, false, 0);
17990   }
17991
17992   if (Subtarget->is64Bit()) {
17993     // The EDX register is loaded with the high-order 32 bits of the MSR, and
17994     // the EAX register is loaded with the low-order 32 bits.
17995     SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
17996                               DAG.getConstant(32, MVT::i8));
17997     Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
17998     Results.push_back(Chain);
17999     return;
18000   }
18001
18002   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
18003   SDValue Ops[] = { LO, HI };
18004   SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
18005   Results.push_back(Pair);
18006   Results.push_back(Chain);
18007 }
18008
18009 static SDValue LowerREADCYCLECOUNTER(SDValue Op, const X86Subtarget *Subtarget,
18010                                      SelectionDAG &DAG) {
18011   SmallVector<SDValue, 2> Results;
18012   SDLoc DL(Op);
18013   getReadTimeStampCounter(Op.getNode(), DL, X86ISD::RDTSC_DAG, DAG, Subtarget,
18014                           Results);
18015   return DAG.getMergeValues(Results, DL);
18016 }
18017
18018
18019 static SDValue LowerINTRINSIC_W_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
18020                                       SelectionDAG &DAG) {
18021   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
18022
18023   const IntrinsicData* IntrData = getIntrinsicWithChain(IntNo);
18024   if (!IntrData)
18025     return SDValue();
18026
18027   SDLoc dl(Op);
18028   switch(IntrData->Type) {
18029   default:
18030     llvm_unreachable("Unknown Intrinsic Type");
18031     break;
18032   case RDSEED:
18033   case RDRAND: {
18034     // Emit the node with the right value type.
18035     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Glue, MVT::Other);
18036     SDValue Result = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(0));
18037
18038     // If the value returned by RDRAND/RDSEED was valid (CF=1), return 1.
18039     // Otherwise return the value from Rand, which is always 0, casted to i32.
18040     SDValue Ops[] = { DAG.getZExtOrTrunc(Result, dl, Op->getValueType(1)),
18041                       DAG.getConstant(1, Op->getValueType(1)),
18042                       DAG.getConstant(X86::COND_B, MVT::i32),
18043                       SDValue(Result.getNode(), 1) };
18044     SDValue isValid = DAG.getNode(X86ISD::CMOV, dl,
18045                                   DAG.getVTList(Op->getValueType(1), MVT::Glue),
18046                                   Ops);
18047
18048     // Return { result, isValid, chain }.
18049     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
18050                        SDValue(Result.getNode(), 2));
18051   }
18052   case GATHER: {
18053   //gather(v1, mask, index, base, scale);
18054     SDValue Chain = Op.getOperand(0);
18055     SDValue Src   = Op.getOperand(2);
18056     SDValue Base  = Op.getOperand(3);
18057     SDValue Index = Op.getOperand(4);
18058     SDValue Mask  = Op.getOperand(5);
18059     SDValue Scale = Op.getOperand(6);
18060     return getGatherNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index, Scale, Chain,
18061                           Subtarget);
18062   }
18063   case SCATTER: {
18064   //scatter(base, mask, index, v1, scale);
18065     SDValue Chain = Op.getOperand(0);
18066     SDValue Base  = Op.getOperand(2);
18067     SDValue Mask  = Op.getOperand(3);
18068     SDValue Index = Op.getOperand(4);
18069     SDValue Src   = Op.getOperand(5);
18070     SDValue Scale = Op.getOperand(6);
18071     return getScatterNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index, Scale, Chain);
18072   }
18073   case PREFETCH: {
18074     SDValue Hint = Op.getOperand(6);
18075     unsigned HintVal;
18076     if (dyn_cast<ConstantSDNode> (Hint) == nullptr ||
18077         (HintVal = dyn_cast<ConstantSDNode> (Hint)->getZExtValue()) > 1)
18078       llvm_unreachable("Wrong prefetch hint in intrinsic: should be 0 or 1");
18079     unsigned Opcode = (HintVal ? IntrData->Opc1 : IntrData->Opc0);
18080     SDValue Chain = Op.getOperand(0);
18081     SDValue Mask  = Op.getOperand(2);
18082     SDValue Index = Op.getOperand(3);
18083     SDValue Base  = Op.getOperand(4);
18084     SDValue Scale = Op.getOperand(5);
18085     return getPrefetchNode(Opcode, Op, DAG, Mask, Base, Index, Scale, Chain);
18086   }
18087   // Read Time Stamp Counter (RDTSC) and Processor ID (RDTSCP).
18088   case RDTSC: {
18089     SmallVector<SDValue, 2> Results;
18090     getReadTimeStampCounter(Op.getNode(), dl, IntrData->Opc0, DAG, Subtarget, Results);
18091     return DAG.getMergeValues(Results, dl);
18092   }
18093   // Read Performance Monitoring Counters.
18094   case RDPMC: {
18095     SmallVector<SDValue, 2> Results;
18096     getReadPerformanceCounter(Op.getNode(), dl, DAG, Subtarget, Results);
18097     return DAG.getMergeValues(Results, dl);
18098   }
18099   // XTEST intrinsics.
18100   case XTEST: {
18101     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
18102     SDValue InTrans = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(0));
18103     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
18104                                 DAG.getConstant(X86::COND_NE, MVT::i8),
18105                                 InTrans);
18106     SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
18107     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(),
18108                        Ret, SDValue(InTrans.getNode(), 1));
18109   }
18110   // ADC/ADCX/SBB
18111   case ADX: {
18112     SmallVector<SDValue, 2> Results;
18113     SDVTList CFVTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
18114     SDVTList VTs = DAG.getVTList(Op.getOperand(3)->getValueType(0), MVT::Other);
18115     SDValue GenCF = DAG.getNode(X86ISD::ADD, dl, CFVTs, Op.getOperand(2),
18116                                 DAG.getConstant(-1, MVT::i8));
18117     SDValue Res = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(3),
18118                               Op.getOperand(4), GenCF.getValue(1));
18119     SDValue Store = DAG.getStore(Op.getOperand(0), dl, Res.getValue(0),
18120                                  Op.getOperand(5), MachinePointerInfo(),
18121                                  false, false, 0);
18122     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
18123                                 DAG.getConstant(X86::COND_B, MVT::i8),
18124                                 Res.getValue(1));
18125     Results.push_back(SetCC);
18126     Results.push_back(Store);
18127     return DAG.getMergeValues(Results, dl);
18128   }
18129   case COMPRESS_TO_MEM: {
18130     SDLoc dl(Op);
18131     SDValue Mask = Op.getOperand(4);
18132     SDValue DataToCompress = Op.getOperand(3);
18133     SDValue Addr = Op.getOperand(2);
18134     SDValue Chain = Op.getOperand(0);
18135
18136     if (isAllOnes(Mask)) // return just a store
18137       return DAG.getStore(Chain, dl, DataToCompress, Addr,
18138                           MachinePointerInfo(), false, false, 0);
18139
18140     EVT VT = DataToCompress.getValueType();
18141     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
18142                                   VT.getVectorNumElements());
18143     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
18144                                      Mask.getValueType().getSizeInBits());
18145     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
18146                                 DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
18147                                 DAG.getIntPtrConstant(0));
18148
18149     SDValue Compressed =  DAG.getNode(IntrData->Opc0, dl, VT, VMask,
18150                                       DataToCompress, DAG.getUNDEF(VT));
18151     return DAG.getStore(Chain, dl, Compressed, Addr,
18152                         MachinePointerInfo(), false, false, 0);
18153   }
18154   case EXPAND_FROM_MEM: {
18155     SDLoc dl(Op);
18156     SDValue Mask = Op.getOperand(4);
18157     SDValue PathThru = Op.getOperand(3);
18158     SDValue Addr = Op.getOperand(2);
18159     SDValue Chain = Op.getOperand(0);
18160     EVT VT = Op.getValueType();
18161
18162     if (isAllOnes(Mask)) // return just a load
18163       return DAG.getLoad(VT, dl, Chain, Addr, MachinePointerInfo(), false, false,
18164                          false, 0);
18165     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
18166                                   VT.getVectorNumElements());
18167     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
18168                                      Mask.getValueType().getSizeInBits());
18169     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
18170                                 DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
18171                                 DAG.getIntPtrConstant(0));
18172
18173     SDValue DataToExpand = DAG.getLoad(VT, dl, Chain, Addr, MachinePointerInfo(),
18174                                    false, false, false, 0);
18175
18176     SmallVector<SDValue, 2> Results;
18177     Results.push_back(DAG.getNode(IntrData->Opc0, dl, VT, VMask, DataToExpand,
18178                                   PathThru));
18179     Results.push_back(Chain);
18180     return DAG.getMergeValues(Results, dl);
18181   }
18182   }
18183 }
18184
18185 SDValue X86TargetLowering::LowerRETURNADDR(SDValue Op,
18186                                            SelectionDAG &DAG) const {
18187   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
18188   MFI->setReturnAddressIsTaken(true);
18189
18190   if (verifyReturnAddressArgumentIsConstant(Op, DAG))
18191     return SDValue();
18192
18193   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
18194   SDLoc dl(Op);
18195   EVT PtrVT = getPointerTy();
18196
18197   if (Depth > 0) {
18198     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
18199     const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18200     SDValue Offset = DAG.getConstant(RegInfo->getSlotSize(), PtrVT);
18201     return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
18202                        DAG.getNode(ISD::ADD, dl, PtrVT,
18203                                    FrameAddr, Offset),
18204                        MachinePointerInfo(), false, false, false, 0);
18205   }
18206
18207   // Just load the return address.
18208   SDValue RetAddrFI = getReturnAddressFrameIndex(DAG);
18209   return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
18210                      RetAddrFI, MachinePointerInfo(), false, false, false, 0);
18211 }
18212
18213 SDValue X86TargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
18214   MachineFunction &MF = DAG.getMachineFunction();
18215   MachineFrameInfo *MFI = MF.getFrameInfo();
18216   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
18217   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18218   EVT VT = Op.getValueType();
18219
18220   MFI->setFrameAddressIsTaken(true);
18221
18222   if (MF.getTarget().getMCAsmInfo()->usesWindowsCFI()) {
18223     // Depth > 0 makes no sense on targets which use Windows unwind codes.  It
18224     // is not possible to crawl up the stack without looking at the unwind codes
18225     // simultaneously.
18226     int FrameAddrIndex = FuncInfo->getFAIndex();
18227     if (!FrameAddrIndex) {
18228       // Set up a frame object for the return address.
18229       unsigned SlotSize = RegInfo->getSlotSize();
18230       FrameAddrIndex = MF.getFrameInfo()->CreateFixedObject(
18231           SlotSize, /*Offset=*/INT64_MIN, /*IsImmutable=*/false);
18232       FuncInfo->setFAIndex(FrameAddrIndex);
18233     }
18234     return DAG.getFrameIndex(FrameAddrIndex, VT);
18235   }
18236
18237   unsigned FrameReg =
18238       RegInfo->getPtrSizedFrameRegister(DAG.getMachineFunction());
18239   SDLoc dl(Op);  // FIXME probably not meaningful
18240   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
18241   assert(((FrameReg == X86::RBP && VT == MVT::i64) ||
18242           (FrameReg == X86::EBP && VT == MVT::i32)) &&
18243          "Invalid Frame Register!");
18244   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
18245   while (Depth--)
18246     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
18247                             MachinePointerInfo(),
18248                             false, false, false, 0);
18249   return FrameAddr;
18250 }
18251
18252 // FIXME? Maybe this could be a TableGen attribute on some registers and
18253 // this table could be generated automatically from RegInfo.
18254 unsigned X86TargetLowering::getRegisterByName(const char* RegName,
18255                                               EVT VT) const {
18256   unsigned Reg = StringSwitch<unsigned>(RegName)
18257                        .Case("esp", X86::ESP)
18258                        .Case("rsp", X86::RSP)
18259                        .Default(0);
18260   if (Reg)
18261     return Reg;
18262   report_fatal_error("Invalid register name global variable");
18263 }
18264
18265 SDValue X86TargetLowering::LowerFRAME_TO_ARGS_OFFSET(SDValue Op,
18266                                                      SelectionDAG &DAG) const {
18267   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18268   return DAG.getIntPtrConstant(2 * RegInfo->getSlotSize());
18269 }
18270
18271 SDValue X86TargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
18272   SDValue Chain     = Op.getOperand(0);
18273   SDValue Offset    = Op.getOperand(1);
18274   SDValue Handler   = Op.getOperand(2);
18275   SDLoc dl      (Op);
18276
18277   EVT PtrVT = getPointerTy();
18278   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18279   unsigned FrameReg = RegInfo->getFrameRegister(DAG.getMachineFunction());
18280   assert(((FrameReg == X86::RBP && PtrVT == MVT::i64) ||
18281           (FrameReg == X86::EBP && PtrVT == MVT::i32)) &&
18282          "Invalid Frame Register!");
18283   SDValue Frame = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, PtrVT);
18284   unsigned StoreAddrReg = (PtrVT == MVT::i64) ? X86::RCX : X86::ECX;
18285
18286   SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, Frame,
18287                                  DAG.getIntPtrConstant(RegInfo->getSlotSize()));
18288   StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, StoreAddr, Offset);
18289   Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo(),
18290                        false, false, 0);
18291   Chain = DAG.getCopyToReg(Chain, dl, StoreAddrReg, StoreAddr);
18292
18293   return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
18294                      DAG.getRegister(StoreAddrReg, PtrVT));
18295 }
18296
18297 SDValue X86TargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op,
18298                                                SelectionDAG &DAG) const {
18299   SDLoc DL(Op);
18300   return DAG.getNode(X86ISD::EH_SJLJ_SETJMP, DL,
18301                      DAG.getVTList(MVT::i32, MVT::Other),
18302                      Op.getOperand(0), Op.getOperand(1));
18303 }
18304
18305 SDValue X86TargetLowering::lowerEH_SJLJ_LONGJMP(SDValue Op,
18306                                                 SelectionDAG &DAG) const {
18307   SDLoc DL(Op);
18308   return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
18309                      Op.getOperand(0), Op.getOperand(1));
18310 }
18311
18312 static SDValue LowerADJUST_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) {
18313   return Op.getOperand(0);
18314 }
18315
18316 SDValue X86TargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
18317                                                 SelectionDAG &DAG) const {
18318   SDValue Root = Op.getOperand(0);
18319   SDValue Trmp = Op.getOperand(1); // trampoline
18320   SDValue FPtr = Op.getOperand(2); // nested function
18321   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
18322   SDLoc dl (Op);
18323
18324   const Value *TrmpAddr = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
18325   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
18326
18327   if (Subtarget->is64Bit()) {
18328     SDValue OutChains[6];
18329
18330     // Large code-model.
18331     const unsigned char JMP64r  = 0xFF; // 64-bit jmp through register opcode.
18332     const unsigned char MOV64ri = 0xB8; // X86::MOV64ri opcode.
18333
18334     const unsigned char N86R10 = TRI->getEncodingValue(X86::R10) & 0x7;
18335     const unsigned char N86R11 = TRI->getEncodingValue(X86::R11) & 0x7;
18336
18337     const unsigned char REX_WB = 0x40 | 0x08 | 0x01; // REX prefix
18338
18339     // Load the pointer to the nested function into R11.
18340     unsigned OpCode = ((MOV64ri | N86R11) << 8) | REX_WB; // movabsq r11
18341     SDValue Addr = Trmp;
18342     OutChains[0] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
18343                                 Addr, MachinePointerInfo(TrmpAddr),
18344                                 false, false, 0);
18345
18346     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18347                        DAG.getConstant(2, MVT::i64));
18348     OutChains[1] = DAG.getStore(Root, dl, FPtr, Addr,
18349                                 MachinePointerInfo(TrmpAddr, 2),
18350                                 false, false, 2);
18351
18352     // Load the 'nest' parameter value into R10.
18353     // R10 is specified in X86CallingConv.td
18354     OpCode = ((MOV64ri | N86R10) << 8) | REX_WB; // movabsq r10
18355     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18356                        DAG.getConstant(10, MVT::i64));
18357     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
18358                                 Addr, MachinePointerInfo(TrmpAddr, 10),
18359                                 false, false, 0);
18360
18361     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18362                        DAG.getConstant(12, MVT::i64));
18363     OutChains[3] = DAG.getStore(Root, dl, Nest, Addr,
18364                                 MachinePointerInfo(TrmpAddr, 12),
18365                                 false, false, 2);
18366
18367     // Jump to the nested function.
18368     OpCode = (JMP64r << 8) | REX_WB; // jmpq *...
18369     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18370                        DAG.getConstant(20, MVT::i64));
18371     OutChains[4] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
18372                                 Addr, MachinePointerInfo(TrmpAddr, 20),
18373                                 false, false, 0);
18374
18375     unsigned char ModRM = N86R11 | (4 << 3) | (3 << 6); // ...r11
18376     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
18377                        DAG.getConstant(22, MVT::i64));
18378     OutChains[5] = DAG.getStore(Root, dl, DAG.getConstant(ModRM, MVT::i8), Addr,
18379                                 MachinePointerInfo(TrmpAddr, 22),
18380                                 false, false, 0);
18381
18382     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
18383   } else {
18384     const Function *Func =
18385       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
18386     CallingConv::ID CC = Func->getCallingConv();
18387     unsigned NestReg;
18388
18389     switch (CC) {
18390     default:
18391       llvm_unreachable("Unsupported calling convention");
18392     case CallingConv::C:
18393     case CallingConv::X86_StdCall: {
18394       // Pass 'nest' parameter in ECX.
18395       // Must be kept in sync with X86CallingConv.td
18396       NestReg = X86::ECX;
18397
18398       // Check that ECX wasn't needed by an 'inreg' parameter.
18399       FunctionType *FTy = Func->getFunctionType();
18400       const AttributeSet &Attrs = Func->getAttributes();
18401
18402       if (!Attrs.isEmpty() && !Func->isVarArg()) {
18403         unsigned InRegCount = 0;
18404         unsigned Idx = 1;
18405
18406         for (FunctionType::param_iterator I = FTy->param_begin(),
18407              E = FTy->param_end(); I != E; ++I, ++Idx)
18408           if (Attrs.hasAttribute(Idx, Attribute::InReg))
18409             // FIXME: should only count parameters that are lowered to integers.
18410             InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
18411
18412         if (InRegCount > 2) {
18413           report_fatal_error("Nest register in use - reduce number of inreg"
18414                              " parameters!");
18415         }
18416       }
18417       break;
18418     }
18419     case CallingConv::X86_FastCall:
18420     case CallingConv::X86_ThisCall:
18421     case CallingConv::Fast:
18422       // Pass 'nest' parameter in EAX.
18423       // Must be kept in sync with X86CallingConv.td
18424       NestReg = X86::EAX;
18425       break;
18426     }
18427
18428     SDValue OutChains[4];
18429     SDValue Addr, Disp;
18430
18431     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18432                        DAG.getConstant(10, MVT::i32));
18433     Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
18434
18435     // This is storing the opcode for MOV32ri.
18436     const unsigned char MOV32ri = 0xB8; // X86::MOV32ri's opcode byte.
18437     const unsigned char N86Reg = TRI->getEncodingValue(NestReg) & 0x7;
18438     OutChains[0] = DAG.getStore(Root, dl,
18439                                 DAG.getConstant(MOV32ri|N86Reg, MVT::i8),
18440                                 Trmp, MachinePointerInfo(TrmpAddr),
18441                                 false, false, 0);
18442
18443     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18444                        DAG.getConstant(1, MVT::i32));
18445     OutChains[1] = DAG.getStore(Root, dl, Nest, Addr,
18446                                 MachinePointerInfo(TrmpAddr, 1),
18447                                 false, false, 1);
18448
18449     const unsigned char JMP = 0xE9; // jmp <32bit dst> opcode.
18450     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18451                        DAG.getConstant(5, MVT::i32));
18452     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(JMP, MVT::i8), Addr,
18453                                 MachinePointerInfo(TrmpAddr, 5),
18454                                 false, false, 1);
18455
18456     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18457                        DAG.getConstant(6, MVT::i32));
18458     OutChains[3] = DAG.getStore(Root, dl, Disp, Addr,
18459                                 MachinePointerInfo(TrmpAddr, 6),
18460                                 false, false, 1);
18461
18462     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
18463   }
18464 }
18465
18466 SDValue X86TargetLowering::LowerFLT_ROUNDS_(SDValue Op,
18467                                             SelectionDAG &DAG) const {
18468   /*
18469    The rounding mode is in bits 11:10 of FPSR, and has the following
18470    settings:
18471      00 Round to nearest
18472      01 Round to -inf
18473      10 Round to +inf
18474      11 Round to 0
18475
18476   FLT_ROUNDS, on the other hand, expects the following:
18477     -1 Undefined
18478      0 Round to 0
18479      1 Round to nearest
18480      2 Round to +inf
18481      3 Round to -inf
18482
18483   To perform the conversion, we do:
18484     (((((FPSR & 0x800) >> 11) | ((FPSR & 0x400) >> 9)) + 1) & 3)
18485   */
18486
18487   MachineFunction &MF = DAG.getMachineFunction();
18488   const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
18489   unsigned StackAlignment = TFI.getStackAlignment();
18490   MVT VT = Op.getSimpleValueType();
18491   SDLoc DL(Op);
18492
18493   // Save FP Control Word to stack slot
18494   int SSFI = MF.getFrameInfo()->CreateStackObject(2, StackAlignment, false);
18495   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
18496
18497   MachineMemOperand *MMO =
18498    MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
18499                            MachineMemOperand::MOStore, 2, 2);
18500
18501   SDValue Ops[] = { DAG.getEntryNode(), StackSlot };
18502   SDValue Chain = DAG.getMemIntrinsicNode(X86ISD::FNSTCW16m, DL,
18503                                           DAG.getVTList(MVT::Other),
18504                                           Ops, MVT::i16, MMO);
18505
18506   // Load FP Control Word from stack slot
18507   SDValue CWD = DAG.getLoad(MVT::i16, DL, Chain, StackSlot,
18508                             MachinePointerInfo(), false, false, false, 0);
18509
18510   // Transform as necessary
18511   SDValue CWD1 =
18512     DAG.getNode(ISD::SRL, DL, MVT::i16,
18513                 DAG.getNode(ISD::AND, DL, MVT::i16,
18514                             CWD, DAG.getConstant(0x800, MVT::i16)),
18515                 DAG.getConstant(11, MVT::i8));
18516   SDValue CWD2 =
18517     DAG.getNode(ISD::SRL, DL, MVT::i16,
18518                 DAG.getNode(ISD::AND, DL, MVT::i16,
18519                             CWD, DAG.getConstant(0x400, MVT::i16)),
18520                 DAG.getConstant(9, MVT::i8));
18521
18522   SDValue RetVal =
18523     DAG.getNode(ISD::AND, DL, MVT::i16,
18524                 DAG.getNode(ISD::ADD, DL, MVT::i16,
18525                             DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
18526                             DAG.getConstant(1, MVT::i16)),
18527                 DAG.getConstant(3, MVT::i16));
18528
18529   return DAG.getNode((VT.getSizeInBits() < 16 ?
18530                       ISD::TRUNCATE : ISD::ZERO_EXTEND), DL, VT, RetVal);
18531 }
18532
18533 static SDValue LowerCTLZ(SDValue Op, SelectionDAG &DAG) {
18534   MVT VT = Op.getSimpleValueType();
18535   EVT OpVT = VT;
18536   unsigned NumBits = VT.getSizeInBits();
18537   SDLoc dl(Op);
18538
18539   Op = Op.getOperand(0);
18540   if (VT == MVT::i8) {
18541     // Zero extend to i32 since there is not an i8 bsr.
18542     OpVT = MVT::i32;
18543     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
18544   }
18545
18546   // Issue a bsr (scan bits in reverse) which also sets EFLAGS.
18547   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
18548   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
18549
18550   // If src is zero (i.e. bsr sets ZF), returns NumBits.
18551   SDValue Ops[] = {
18552     Op,
18553     DAG.getConstant(NumBits+NumBits-1, OpVT),
18554     DAG.getConstant(X86::COND_E, MVT::i8),
18555     Op.getValue(1)
18556   };
18557   Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops);
18558
18559   // Finally xor with NumBits-1.
18560   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
18561
18562   if (VT == MVT::i8)
18563     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
18564   return Op;
18565 }
18566
18567 static SDValue LowerCTLZ_ZERO_UNDEF(SDValue Op, SelectionDAG &DAG) {
18568   MVT VT = Op.getSimpleValueType();
18569   EVT OpVT = VT;
18570   unsigned NumBits = VT.getSizeInBits();
18571   SDLoc dl(Op);
18572
18573   Op = Op.getOperand(0);
18574   if (VT == MVT::i8) {
18575     // Zero extend to i32 since there is not an i8 bsr.
18576     OpVT = MVT::i32;
18577     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
18578   }
18579
18580   // Issue a bsr (scan bits in reverse).
18581   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
18582   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
18583
18584   // And xor with NumBits-1.
18585   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
18586
18587   if (VT == MVT::i8)
18588     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
18589   return Op;
18590 }
18591
18592 static SDValue LowerCTTZ(SDValue Op, SelectionDAG &DAG) {
18593   MVT VT = Op.getSimpleValueType();
18594   unsigned NumBits = VT.getSizeInBits();
18595   SDLoc dl(Op);
18596   Op = Op.getOperand(0);
18597
18598   // Issue a bsf (scan bits forward) which also sets EFLAGS.
18599   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
18600   Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
18601
18602   // If src is zero (i.e. bsf sets ZF), returns NumBits.
18603   SDValue Ops[] = {
18604     Op,
18605     DAG.getConstant(NumBits, VT),
18606     DAG.getConstant(X86::COND_E, MVT::i8),
18607     Op.getValue(1)
18608   };
18609   return DAG.getNode(X86ISD::CMOV, dl, VT, Ops);
18610 }
18611
18612 // Lower256IntArith - Break a 256-bit integer operation into two new 128-bit
18613 // ones, and then concatenate the result back.
18614 static SDValue Lower256IntArith(SDValue Op, SelectionDAG &DAG) {
18615   MVT VT = Op.getSimpleValueType();
18616
18617   assert(VT.is256BitVector() && VT.isInteger() &&
18618          "Unsupported value type for operation");
18619
18620   unsigned NumElems = VT.getVectorNumElements();
18621   SDLoc dl(Op);
18622
18623   // Extract the LHS vectors
18624   SDValue LHS = Op.getOperand(0);
18625   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
18626   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
18627
18628   // Extract the RHS vectors
18629   SDValue RHS = Op.getOperand(1);
18630   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
18631   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
18632
18633   MVT EltVT = VT.getVectorElementType();
18634   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
18635
18636   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
18637                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
18638                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
18639 }
18640
18641 static SDValue LowerADD(SDValue Op, SelectionDAG &DAG) {
18642   assert(Op.getSimpleValueType().is256BitVector() &&
18643          Op.getSimpleValueType().isInteger() &&
18644          "Only handle AVX 256-bit vector integer operation");
18645   return Lower256IntArith(Op, DAG);
18646 }
18647
18648 static SDValue LowerSUB(SDValue Op, SelectionDAG &DAG) {
18649   assert(Op.getSimpleValueType().is256BitVector() &&
18650          Op.getSimpleValueType().isInteger() &&
18651          "Only handle AVX 256-bit vector integer operation");
18652   return Lower256IntArith(Op, DAG);
18653 }
18654
18655 static SDValue LowerMUL(SDValue Op, const X86Subtarget *Subtarget,
18656                         SelectionDAG &DAG) {
18657   SDLoc dl(Op);
18658   MVT VT = Op.getSimpleValueType();
18659
18660   // Decompose 256-bit ops into smaller 128-bit ops.
18661   if (VT.is256BitVector() && !Subtarget->hasInt256())
18662     return Lower256IntArith(Op, DAG);
18663
18664   SDValue A = Op.getOperand(0);
18665   SDValue B = Op.getOperand(1);
18666
18667   // Lower v4i32 mul as 2x shuffle, 2x pmuludq, 2x shuffle.
18668   if (VT == MVT::v4i32) {
18669     assert(Subtarget->hasSSE2() && !Subtarget->hasSSE41() &&
18670            "Should not custom lower when pmuldq is available!");
18671
18672     // Extract the odd parts.
18673     static const int UnpackMask[] = { 1, -1, 3, -1 };
18674     SDValue Aodds = DAG.getVectorShuffle(VT, dl, A, A, UnpackMask);
18675     SDValue Bodds = DAG.getVectorShuffle(VT, dl, B, B, UnpackMask);
18676
18677     // Multiply the even parts.
18678     SDValue Evens = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, A, B);
18679     // Now multiply odd parts.
18680     SDValue Odds = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, Aodds, Bodds);
18681
18682     Evens = DAG.getNode(ISD::BITCAST, dl, VT, Evens);
18683     Odds = DAG.getNode(ISD::BITCAST, dl, VT, Odds);
18684
18685     // Merge the two vectors back together with a shuffle. This expands into 2
18686     // shuffles.
18687     static const int ShufMask[] = { 0, 4, 2, 6 };
18688     return DAG.getVectorShuffle(VT, dl, Evens, Odds, ShufMask);
18689   }
18690
18691   assert((VT == MVT::v2i64 || VT == MVT::v4i64 || VT == MVT::v8i64) &&
18692          "Only know how to lower V2I64/V4I64/V8I64 multiply");
18693
18694   //  Ahi = psrlqi(a, 32);
18695   //  Bhi = psrlqi(b, 32);
18696   //
18697   //  AloBlo = pmuludq(a, b);
18698   //  AloBhi = pmuludq(a, Bhi);
18699   //  AhiBlo = pmuludq(Ahi, b);
18700
18701   //  AloBhi = psllqi(AloBhi, 32);
18702   //  AhiBlo = psllqi(AhiBlo, 32);
18703   //  return AloBlo + AloBhi + AhiBlo;
18704
18705   SDValue Ahi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, A, 32, DAG);
18706   SDValue Bhi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, B, 32, DAG);
18707
18708   // Bit cast to 32-bit vectors for MULUDQ
18709   EVT MulVT = (VT == MVT::v2i64) ? MVT::v4i32 :
18710                                   (VT == MVT::v4i64) ? MVT::v8i32 : MVT::v16i32;
18711   A = DAG.getNode(ISD::BITCAST, dl, MulVT, A);
18712   B = DAG.getNode(ISD::BITCAST, dl, MulVT, B);
18713   Ahi = DAG.getNode(ISD::BITCAST, dl, MulVT, Ahi);
18714   Bhi = DAG.getNode(ISD::BITCAST, dl, MulVT, Bhi);
18715
18716   SDValue AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
18717   SDValue AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
18718   SDValue AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
18719
18720   AloBhi = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AloBhi, 32, DAG);
18721   AhiBlo = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AhiBlo, 32, DAG);
18722
18723   SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
18724   return DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
18725 }
18726
18727 SDValue X86TargetLowering::LowerWin64_i128OP(SDValue Op, SelectionDAG &DAG) const {
18728   assert(Subtarget->isTargetWin64() && "Unexpected target");
18729   EVT VT = Op.getValueType();
18730   assert(VT.isInteger() && VT.getSizeInBits() == 128 &&
18731          "Unexpected return type for lowering");
18732
18733   RTLIB::Libcall LC;
18734   bool isSigned;
18735   switch (Op->getOpcode()) {
18736   default: llvm_unreachable("Unexpected request for libcall!");
18737   case ISD::SDIV:      isSigned = true;  LC = RTLIB::SDIV_I128;    break;
18738   case ISD::UDIV:      isSigned = false; LC = RTLIB::UDIV_I128;    break;
18739   case ISD::SREM:      isSigned = true;  LC = RTLIB::SREM_I128;    break;
18740   case ISD::UREM:      isSigned = false; LC = RTLIB::UREM_I128;    break;
18741   case ISD::SDIVREM:   isSigned = true;  LC = RTLIB::SDIVREM_I128; break;
18742   case ISD::UDIVREM:   isSigned = false; LC = RTLIB::UDIVREM_I128; break;
18743   }
18744
18745   SDLoc dl(Op);
18746   SDValue InChain = DAG.getEntryNode();
18747
18748   TargetLowering::ArgListTy Args;
18749   TargetLowering::ArgListEntry Entry;
18750   for (unsigned i = 0, e = Op->getNumOperands(); i != e; ++i) {
18751     EVT ArgVT = Op->getOperand(i).getValueType();
18752     assert(ArgVT.isInteger() && ArgVT.getSizeInBits() == 128 &&
18753            "Unexpected argument type for lowering");
18754     SDValue StackPtr = DAG.CreateStackTemporary(ArgVT, 16);
18755     Entry.Node = StackPtr;
18756     InChain = DAG.getStore(InChain, dl, Op->getOperand(i), StackPtr, MachinePointerInfo(),
18757                            false, false, 16);
18758     Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
18759     Entry.Ty = PointerType::get(ArgTy,0);
18760     Entry.isSExt = false;
18761     Entry.isZExt = false;
18762     Args.push_back(Entry);
18763   }
18764
18765   SDValue Callee = DAG.getExternalSymbol(getLibcallName(LC),
18766                                          getPointerTy());
18767
18768   TargetLowering::CallLoweringInfo CLI(DAG);
18769   CLI.setDebugLoc(dl).setChain(InChain)
18770     .setCallee(getLibcallCallingConv(LC),
18771                static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext()),
18772                Callee, std::move(Args), 0)
18773     .setInRegister().setSExtResult(isSigned).setZExtResult(!isSigned);
18774
18775   std::pair<SDValue, SDValue> CallInfo = LowerCallTo(CLI);
18776   return DAG.getNode(ISD::BITCAST, dl, VT, CallInfo.first);
18777 }
18778
18779 static SDValue LowerMUL_LOHI(SDValue Op, const X86Subtarget *Subtarget,
18780                              SelectionDAG &DAG) {
18781   SDValue Op0 = Op.getOperand(0), Op1 = Op.getOperand(1);
18782   EVT VT = Op0.getValueType();
18783   SDLoc dl(Op);
18784
18785   assert((VT == MVT::v4i32 && Subtarget->hasSSE2()) ||
18786          (VT == MVT::v8i32 && Subtarget->hasInt256()));
18787
18788   // PMULxD operations multiply each even value (starting at 0) of LHS with
18789   // the related value of RHS and produce a widen result.
18790   // E.g., PMULUDQ <4 x i32> <a|b|c|d>, <4 x i32> <e|f|g|h>
18791   // => <2 x i64> <ae|cg>
18792   //
18793   // In other word, to have all the results, we need to perform two PMULxD:
18794   // 1. one with the even values.
18795   // 2. one with the odd values.
18796   // To achieve #2, with need to place the odd values at an even position.
18797   //
18798   // Place the odd value at an even position (basically, shift all values 1
18799   // step to the left):
18800   const int Mask[] = {1, -1, 3, -1, 5, -1, 7, -1};
18801   // <a|b|c|d> => <b|undef|d|undef>
18802   SDValue Odd0 = DAG.getVectorShuffle(VT, dl, Op0, Op0, Mask);
18803   // <e|f|g|h> => <f|undef|h|undef>
18804   SDValue Odd1 = DAG.getVectorShuffle(VT, dl, Op1, Op1, Mask);
18805
18806   // Emit two multiplies, one for the lower 2 ints and one for the higher 2
18807   // ints.
18808   MVT MulVT = VT == MVT::v4i32 ? MVT::v2i64 : MVT::v4i64;
18809   bool IsSigned = Op->getOpcode() == ISD::SMUL_LOHI;
18810   unsigned Opcode =
18811       (!IsSigned || !Subtarget->hasSSE41()) ? X86ISD::PMULUDQ : X86ISD::PMULDQ;
18812   // PMULUDQ <4 x i32> <a|b|c|d>, <4 x i32> <e|f|g|h>
18813   // => <2 x i64> <ae|cg>
18814   SDValue Mul1 = DAG.getNode(ISD::BITCAST, dl, VT,
18815                              DAG.getNode(Opcode, dl, MulVT, Op0, Op1));
18816   // PMULUDQ <4 x i32> <b|undef|d|undef>, <4 x i32> <f|undef|h|undef>
18817   // => <2 x i64> <bf|dh>
18818   SDValue Mul2 = DAG.getNode(ISD::BITCAST, dl, VT,
18819                              DAG.getNode(Opcode, dl, MulVT, Odd0, Odd1));
18820
18821   // Shuffle it back into the right order.
18822   SDValue Highs, Lows;
18823   if (VT == MVT::v8i32) {
18824     const int HighMask[] = {1, 9, 3, 11, 5, 13, 7, 15};
18825     Highs = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, HighMask);
18826     const int LowMask[] = {0, 8, 2, 10, 4, 12, 6, 14};
18827     Lows = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, LowMask);
18828   } else {
18829     const int HighMask[] = {1, 5, 3, 7};
18830     Highs = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, HighMask);
18831     const int LowMask[] = {0, 4, 2, 6};
18832     Lows = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, LowMask);
18833   }
18834
18835   // If we have a signed multiply but no PMULDQ fix up the high parts of a
18836   // unsigned multiply.
18837   if (IsSigned && !Subtarget->hasSSE41()) {
18838     SDValue ShAmt =
18839         DAG.getConstant(31, DAG.getTargetLoweringInfo().getShiftAmountTy(VT));
18840     SDValue T1 = DAG.getNode(ISD::AND, dl, VT,
18841                              DAG.getNode(ISD::SRA, dl, VT, Op0, ShAmt), Op1);
18842     SDValue T2 = DAG.getNode(ISD::AND, dl, VT,
18843                              DAG.getNode(ISD::SRA, dl, VT, Op1, ShAmt), Op0);
18844
18845     SDValue Fixup = DAG.getNode(ISD::ADD, dl, VT, T1, T2);
18846     Highs = DAG.getNode(ISD::SUB, dl, VT, Highs, Fixup);
18847   }
18848
18849   // The first result of MUL_LOHI is actually the low value, followed by the
18850   // high value.
18851   SDValue Ops[] = {Lows, Highs};
18852   return DAG.getMergeValues(Ops, dl);
18853 }
18854
18855 static SDValue LowerScalarImmediateShift(SDValue Op, SelectionDAG &DAG,
18856                                          const X86Subtarget *Subtarget) {
18857   MVT VT = Op.getSimpleValueType();
18858   SDLoc dl(Op);
18859   SDValue R = Op.getOperand(0);
18860   SDValue Amt = Op.getOperand(1);
18861
18862   // Optimize shl/srl/sra with constant shift amount.
18863   if (auto *BVAmt = dyn_cast<BuildVectorSDNode>(Amt)) {
18864     if (auto *ShiftConst = BVAmt->getConstantSplatNode()) {
18865       uint64_t ShiftAmt = ShiftConst->getZExtValue();
18866
18867       if (VT == MVT::v2i64 || VT == MVT::v4i32 || VT == MVT::v8i16 ||
18868           (Subtarget->hasInt256() &&
18869            (VT == MVT::v4i64 || VT == MVT::v8i32 || VT == MVT::v16i16)) ||
18870           (Subtarget->hasAVX512() &&
18871            (VT == MVT::v8i64 || VT == MVT::v16i32))) {
18872         if (Op.getOpcode() == ISD::SHL)
18873           return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
18874                                             DAG);
18875         if (Op.getOpcode() == ISD::SRL)
18876           return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
18877                                             DAG);
18878         if (Op.getOpcode() == ISD::SRA && VT != MVT::v2i64 && VT != MVT::v4i64)
18879           return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
18880                                             DAG);
18881       }
18882
18883       if (VT == MVT::v16i8) {
18884         if (Op.getOpcode() == ISD::SHL) {
18885           // Make a large shift.
18886           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl,
18887                                                    MVT::v8i16, R, ShiftAmt,
18888                                                    DAG);
18889           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
18890           // Zero out the rightmost bits.
18891           SmallVector<SDValue, 16> V(16,
18892                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
18893                                                      MVT::i8));
18894           return DAG.getNode(ISD::AND, dl, VT, SHL,
18895                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18896         }
18897         if (Op.getOpcode() == ISD::SRL) {
18898           // Make a large shift.
18899           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl,
18900                                                    MVT::v8i16, R, ShiftAmt,
18901                                                    DAG);
18902           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
18903           // Zero out the leftmost bits.
18904           SmallVector<SDValue, 16> V(16,
18905                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
18906                                                      MVT::i8));
18907           return DAG.getNode(ISD::AND, dl, VT, SRL,
18908                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18909         }
18910         if (Op.getOpcode() == ISD::SRA) {
18911           if (ShiftAmt == 7) {
18912             // R s>> 7  ===  R s< 0
18913             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
18914             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
18915           }
18916
18917           // R s>> a === ((R u>> a) ^ m) - m
18918           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
18919           SmallVector<SDValue, 16> V(16, DAG.getConstant(128 >> ShiftAmt,
18920                                                          MVT::i8));
18921           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
18922           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
18923           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
18924           return Res;
18925         }
18926         llvm_unreachable("Unknown shift opcode.");
18927       }
18928
18929       if (Subtarget->hasInt256() && VT == MVT::v32i8) {
18930         if (Op.getOpcode() == ISD::SHL) {
18931           // Make a large shift.
18932           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl,
18933                                                    MVT::v16i16, R, ShiftAmt,
18934                                                    DAG);
18935           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
18936           // Zero out the rightmost bits.
18937           SmallVector<SDValue, 32> V(32,
18938                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
18939                                                      MVT::i8));
18940           return DAG.getNode(ISD::AND, dl, VT, SHL,
18941                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18942         }
18943         if (Op.getOpcode() == ISD::SRL) {
18944           // Make a large shift.
18945           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl,
18946                                                    MVT::v16i16, R, ShiftAmt,
18947                                                    DAG);
18948           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
18949           // Zero out the leftmost bits.
18950           SmallVector<SDValue, 32> V(32,
18951                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
18952                                                      MVT::i8));
18953           return DAG.getNode(ISD::AND, dl, VT, SRL,
18954                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18955         }
18956         if (Op.getOpcode() == ISD::SRA) {
18957           if (ShiftAmt == 7) {
18958             // R s>> 7  ===  R s< 0
18959             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
18960             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
18961           }
18962
18963           // R s>> a === ((R u>> a) ^ m) - m
18964           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
18965           SmallVector<SDValue, 32> V(32, DAG.getConstant(128 >> ShiftAmt,
18966                                                          MVT::i8));
18967           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
18968           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
18969           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
18970           return Res;
18971         }
18972         llvm_unreachable("Unknown shift opcode.");
18973       }
18974     }
18975   }
18976
18977   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
18978   if (!Subtarget->is64Bit() &&
18979       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64)) &&
18980       Amt.getOpcode() == ISD::BITCAST &&
18981       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
18982     Amt = Amt.getOperand(0);
18983     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
18984                      VT.getVectorNumElements();
18985     unsigned RatioInLog2 = Log2_32_Ceil(Ratio);
18986     uint64_t ShiftAmt = 0;
18987     for (unsigned i = 0; i != Ratio; ++i) {
18988       ConstantSDNode *C = dyn_cast<ConstantSDNode>(Amt.getOperand(i));
18989       if (!C)
18990         return SDValue();
18991       // 6 == Log2(64)
18992       ShiftAmt |= C->getZExtValue() << (i * (1 << (6 - RatioInLog2)));
18993     }
18994     // Check remaining shift amounts.
18995     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
18996       uint64_t ShAmt = 0;
18997       for (unsigned j = 0; j != Ratio; ++j) {
18998         ConstantSDNode *C =
18999           dyn_cast<ConstantSDNode>(Amt.getOperand(i + j));
19000         if (!C)
19001           return SDValue();
19002         // 6 == Log2(64)
19003         ShAmt |= C->getZExtValue() << (j * (1 << (6 - RatioInLog2)));
19004       }
19005       if (ShAmt != ShiftAmt)
19006         return SDValue();
19007     }
19008     switch (Op.getOpcode()) {
19009     default:
19010       llvm_unreachable("Unknown shift opcode!");
19011     case ISD::SHL:
19012       return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
19013                                         DAG);
19014     case ISD::SRL:
19015       return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
19016                                         DAG);
19017     case ISD::SRA:
19018       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
19019                                         DAG);
19020     }
19021   }
19022
19023   return SDValue();
19024 }
19025
19026 static SDValue LowerScalarVariableShift(SDValue Op, SelectionDAG &DAG,
19027                                         const X86Subtarget* Subtarget) {
19028   MVT VT = Op.getSimpleValueType();
19029   SDLoc dl(Op);
19030   SDValue R = Op.getOperand(0);
19031   SDValue Amt = Op.getOperand(1);
19032
19033   if ((VT == MVT::v2i64 && Op.getOpcode() != ISD::SRA) ||
19034       VT == MVT::v4i32 || VT == MVT::v8i16 ||
19035       (Subtarget->hasInt256() &&
19036        ((VT == MVT::v4i64 && Op.getOpcode() != ISD::SRA) ||
19037         VT == MVT::v8i32 || VT == MVT::v16i16)) ||
19038        (Subtarget->hasAVX512() && (VT == MVT::v8i64 || VT == MVT::v16i32))) {
19039     SDValue BaseShAmt;
19040     EVT EltVT = VT.getVectorElementType();
19041
19042     if (BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Amt)) {
19043       // Check if this build_vector node is doing a splat.
19044       // If so, then set BaseShAmt equal to the splat value.
19045       BaseShAmt = BV->getSplatValue();
19046       if (BaseShAmt && BaseShAmt.getOpcode() == ISD::UNDEF)
19047         BaseShAmt = SDValue();
19048     } else {
19049       if (Amt.getOpcode() == ISD::EXTRACT_SUBVECTOR)
19050         Amt = Amt.getOperand(0);
19051
19052       ShuffleVectorSDNode *SVN = dyn_cast<ShuffleVectorSDNode>(Amt);
19053       if (SVN && SVN->isSplat()) {
19054         unsigned SplatIdx = (unsigned)SVN->getSplatIndex();
19055         SDValue InVec = Amt.getOperand(0);
19056         if (InVec.getOpcode() == ISD::BUILD_VECTOR) {
19057           assert((SplatIdx < InVec.getValueType().getVectorNumElements()) &&
19058                  "Unexpected shuffle index found!");
19059           BaseShAmt = InVec.getOperand(SplatIdx);
19060         } else if (InVec.getOpcode() == ISD::INSERT_VECTOR_ELT) {
19061            if (ConstantSDNode *C =
19062                dyn_cast<ConstantSDNode>(InVec.getOperand(2))) {
19063              if (C->getZExtValue() == SplatIdx)
19064                BaseShAmt = InVec.getOperand(1);
19065            }
19066         }
19067
19068         if (!BaseShAmt)
19069           // Avoid introducing an extract element from a shuffle.
19070           BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InVec,
19071                                     DAG.getIntPtrConstant(SplatIdx));
19072       }
19073     }
19074
19075     if (BaseShAmt.getNode()) {
19076       assert(EltVT.bitsLE(MVT::i64) && "Unexpected element type!");
19077       if (EltVT != MVT::i64 && EltVT.bitsGT(MVT::i32))
19078         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, BaseShAmt);
19079       else if (EltVT.bitsLT(MVT::i32))
19080         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
19081
19082       switch (Op.getOpcode()) {
19083       default:
19084         llvm_unreachable("Unknown shift opcode!");
19085       case ISD::SHL:
19086         switch (VT.SimpleTy) {
19087         default: return SDValue();
19088         case MVT::v2i64:
19089         case MVT::v4i32:
19090         case MVT::v8i16:
19091         case MVT::v4i64:
19092         case MVT::v8i32:
19093         case MVT::v16i16:
19094         case MVT::v16i32:
19095         case MVT::v8i64:
19096           return getTargetVShiftNode(X86ISD::VSHLI, dl, VT, R, BaseShAmt, DAG);
19097         }
19098       case ISD::SRA:
19099         switch (VT.SimpleTy) {
19100         default: return SDValue();
19101         case MVT::v4i32:
19102         case MVT::v8i16:
19103         case MVT::v8i32:
19104         case MVT::v16i16:
19105         case MVT::v16i32:
19106         case MVT::v8i64:
19107           return getTargetVShiftNode(X86ISD::VSRAI, dl, VT, R, BaseShAmt, DAG);
19108         }
19109       case ISD::SRL:
19110         switch (VT.SimpleTy) {
19111         default: return SDValue();
19112         case MVT::v2i64:
19113         case MVT::v4i32:
19114         case MVT::v8i16:
19115         case MVT::v4i64:
19116         case MVT::v8i32:
19117         case MVT::v16i16:
19118         case MVT::v16i32:
19119         case MVT::v8i64:
19120           return getTargetVShiftNode(X86ISD::VSRLI, dl, VT, R, BaseShAmt, DAG);
19121         }
19122       }
19123     }
19124   }
19125
19126   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
19127   if (!Subtarget->is64Bit() &&
19128       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64) ||
19129       (Subtarget->hasAVX512() && VT == MVT::v8i64)) &&
19130       Amt.getOpcode() == ISD::BITCAST &&
19131       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
19132     Amt = Amt.getOperand(0);
19133     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
19134                      VT.getVectorNumElements();
19135     std::vector<SDValue> Vals(Ratio);
19136     for (unsigned i = 0; i != Ratio; ++i)
19137       Vals[i] = Amt.getOperand(i);
19138     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
19139       for (unsigned j = 0; j != Ratio; ++j)
19140         if (Vals[j] != Amt.getOperand(i + j))
19141           return SDValue();
19142     }
19143     switch (Op.getOpcode()) {
19144     default:
19145       llvm_unreachable("Unknown shift opcode!");
19146     case ISD::SHL:
19147       return DAG.getNode(X86ISD::VSHL, dl, VT, R, Op.getOperand(1));
19148     case ISD::SRL:
19149       return DAG.getNode(X86ISD::VSRL, dl, VT, R, Op.getOperand(1));
19150     case ISD::SRA:
19151       return DAG.getNode(X86ISD::VSRA, dl, VT, R, Op.getOperand(1));
19152     }
19153   }
19154
19155   return SDValue();
19156 }
19157
19158 static SDValue LowerShift(SDValue Op, const X86Subtarget* Subtarget,
19159                           SelectionDAG &DAG) {
19160   MVT VT = Op.getSimpleValueType();
19161   SDLoc dl(Op);
19162   SDValue R = Op.getOperand(0);
19163   SDValue Amt = Op.getOperand(1);
19164   SDValue V;
19165
19166   assert(VT.isVector() && "Custom lowering only for vector shifts!");
19167   assert(Subtarget->hasSSE2() && "Only custom lower when we have SSE2!");
19168
19169   V = LowerScalarImmediateShift(Op, DAG, Subtarget);
19170   if (V.getNode())
19171     return V;
19172
19173   V = LowerScalarVariableShift(Op, DAG, Subtarget);
19174   if (V.getNode())
19175       return V;
19176
19177   if (Subtarget->hasAVX512() && (VT == MVT::v16i32 || VT == MVT::v8i64))
19178     return Op;
19179   // AVX2 has VPSLLV/VPSRAV/VPSRLV.
19180   if (Subtarget->hasInt256()) {
19181     if (Op.getOpcode() == ISD::SRL &&
19182         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
19183          VT == MVT::v4i64 || VT == MVT::v8i32))
19184       return Op;
19185     if (Op.getOpcode() == ISD::SHL &&
19186         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
19187          VT == MVT::v4i64 || VT == MVT::v8i32))
19188       return Op;
19189     if (Op.getOpcode() == ISD::SRA && (VT == MVT::v4i32 || VT == MVT::v8i32))
19190       return Op;
19191   }
19192
19193   // If possible, lower this packed shift into a vector multiply instead of
19194   // expanding it into a sequence of scalar shifts.
19195   // Do this only if the vector shift count is a constant build_vector.
19196   if (Op.getOpcode() == ISD::SHL &&
19197       (VT == MVT::v8i16 || VT == MVT::v4i32 ||
19198        (Subtarget->hasInt256() && VT == MVT::v16i16)) &&
19199       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
19200     SmallVector<SDValue, 8> Elts;
19201     EVT SVT = VT.getScalarType();
19202     unsigned SVTBits = SVT.getSizeInBits();
19203     const APInt &One = APInt(SVTBits, 1);
19204     unsigned NumElems = VT.getVectorNumElements();
19205
19206     for (unsigned i=0; i !=NumElems; ++i) {
19207       SDValue Op = Amt->getOperand(i);
19208       if (Op->getOpcode() == ISD::UNDEF) {
19209         Elts.push_back(Op);
19210         continue;
19211       }
19212
19213       ConstantSDNode *ND = cast<ConstantSDNode>(Op);
19214       const APInt &C = APInt(SVTBits, ND->getAPIntValue().getZExtValue());
19215       uint64_t ShAmt = C.getZExtValue();
19216       if (ShAmt >= SVTBits) {
19217         Elts.push_back(DAG.getUNDEF(SVT));
19218         continue;
19219       }
19220       Elts.push_back(DAG.getConstant(One.shl(ShAmt), SVT));
19221     }
19222     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
19223     return DAG.getNode(ISD::MUL, dl, VT, R, BV);
19224   }
19225
19226   // Lower SHL with variable shift amount.
19227   if (VT == MVT::v4i32 && Op->getOpcode() == ISD::SHL) {
19228     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, VT));
19229
19230     Op = DAG.getNode(ISD::ADD, dl, VT, Op, DAG.getConstant(0x3f800000U, VT));
19231     Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
19232     Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
19233     return DAG.getNode(ISD::MUL, dl, VT, Op, R);
19234   }
19235
19236   // If possible, lower this shift as a sequence of two shifts by
19237   // constant plus a MOVSS/MOVSD instead of scalarizing it.
19238   // Example:
19239   //   (v4i32 (srl A, (build_vector < X, Y, Y, Y>)))
19240   //
19241   // Could be rewritten as:
19242   //   (v4i32 (MOVSS (srl A, <Y,Y,Y,Y>), (srl A, <X,X,X,X>)))
19243   //
19244   // The advantage is that the two shifts from the example would be
19245   // lowered as X86ISD::VSRLI nodes. This would be cheaper than scalarizing
19246   // the vector shift into four scalar shifts plus four pairs of vector
19247   // insert/extract.
19248   if ((VT == MVT::v8i16 || VT == MVT::v4i32) &&
19249       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
19250     unsigned TargetOpcode = X86ISD::MOVSS;
19251     bool CanBeSimplified;
19252     // The splat value for the first packed shift (the 'X' from the example).
19253     SDValue Amt1 = Amt->getOperand(0);
19254     // The splat value for the second packed shift (the 'Y' from the example).
19255     SDValue Amt2 = (VT == MVT::v4i32) ? Amt->getOperand(1) :
19256                                         Amt->getOperand(2);
19257
19258     // See if it is possible to replace this node with a sequence of
19259     // two shifts followed by a MOVSS/MOVSD
19260     if (VT == MVT::v4i32) {
19261       // Check if it is legal to use a MOVSS.
19262       CanBeSimplified = Amt2 == Amt->getOperand(2) &&
19263                         Amt2 == Amt->getOperand(3);
19264       if (!CanBeSimplified) {
19265         // Otherwise, check if we can still simplify this node using a MOVSD.
19266         CanBeSimplified = Amt1 == Amt->getOperand(1) &&
19267                           Amt->getOperand(2) == Amt->getOperand(3);
19268         TargetOpcode = X86ISD::MOVSD;
19269         Amt2 = Amt->getOperand(2);
19270       }
19271     } else {
19272       // Do similar checks for the case where the machine value type
19273       // is MVT::v8i16.
19274       CanBeSimplified = Amt1 == Amt->getOperand(1);
19275       for (unsigned i=3; i != 8 && CanBeSimplified; ++i)
19276         CanBeSimplified = Amt2 == Amt->getOperand(i);
19277
19278       if (!CanBeSimplified) {
19279         TargetOpcode = X86ISD::MOVSD;
19280         CanBeSimplified = true;
19281         Amt2 = Amt->getOperand(4);
19282         for (unsigned i=0; i != 4 && CanBeSimplified; ++i)
19283           CanBeSimplified = Amt1 == Amt->getOperand(i);
19284         for (unsigned j=4; j != 8 && CanBeSimplified; ++j)
19285           CanBeSimplified = Amt2 == Amt->getOperand(j);
19286       }
19287     }
19288
19289     if (CanBeSimplified && isa<ConstantSDNode>(Amt1) &&
19290         isa<ConstantSDNode>(Amt2)) {
19291       // Replace this node with two shifts followed by a MOVSS/MOVSD.
19292       EVT CastVT = MVT::v4i32;
19293       SDValue Splat1 =
19294         DAG.getConstant(cast<ConstantSDNode>(Amt1)->getAPIntValue(), VT);
19295       SDValue Shift1 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat1);
19296       SDValue Splat2 =
19297         DAG.getConstant(cast<ConstantSDNode>(Amt2)->getAPIntValue(), VT);
19298       SDValue Shift2 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat2);
19299       if (TargetOpcode == X86ISD::MOVSD)
19300         CastVT = MVT::v2i64;
19301       SDValue BitCast1 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift1);
19302       SDValue BitCast2 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift2);
19303       SDValue Result = getTargetShuffleNode(TargetOpcode, dl, CastVT, BitCast2,
19304                                             BitCast1, DAG);
19305       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
19306     }
19307   }
19308
19309   if (VT == MVT::v16i8 && Op->getOpcode() == ISD::SHL) {
19310     assert(Subtarget->hasSSE2() && "Need SSE2 for pslli/pcmpeq.");
19311
19312     // a = a << 5;
19313     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(5, VT));
19314     Op = DAG.getNode(ISD::BITCAST, dl, VT, Op);
19315
19316     // Turn 'a' into a mask suitable for VSELECT
19317     SDValue VSelM = DAG.getConstant(0x80, VT);
19318     SDValue OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
19319     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
19320
19321     SDValue CM1 = DAG.getConstant(0x0f, VT);
19322     SDValue CM2 = DAG.getConstant(0x3f, VT);
19323
19324     // r = VSELECT(r, psllw(r & (char16)15, 4), a);
19325     SDValue M = DAG.getNode(ISD::AND, dl, VT, R, CM1);
19326     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 4, DAG);
19327     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
19328     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
19329
19330     // a += a
19331     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
19332     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
19333     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
19334
19335     // r = VSELECT(r, psllw(r & (char16)63, 2), a);
19336     M = DAG.getNode(ISD::AND, dl, VT, R, CM2);
19337     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 2, DAG);
19338     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
19339     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
19340
19341     // a += a
19342     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
19343     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
19344     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
19345
19346     // return VSELECT(r, r+r, a);
19347     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel,
19348                     DAG.getNode(ISD::ADD, dl, VT, R, R), R);
19349     return R;
19350   }
19351
19352   // It's worth extending once and using the v8i32 shifts for 16-bit types, but
19353   // the extra overheads to get from v16i8 to v8i32 make the existing SSE
19354   // solution better.
19355   if (Subtarget->hasInt256() && VT == MVT::v8i16) {
19356     MVT NewVT = VT == MVT::v8i16 ? MVT::v8i32 : MVT::v16i16;
19357     unsigned ExtOpc =
19358         Op.getOpcode() == ISD::SRA ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
19359     R = DAG.getNode(ExtOpc, dl, NewVT, R);
19360     Amt = DAG.getNode(ISD::ANY_EXTEND, dl, NewVT, Amt);
19361     return DAG.getNode(ISD::TRUNCATE, dl, VT,
19362                        DAG.getNode(Op.getOpcode(), dl, NewVT, R, Amt));
19363     }
19364
19365   // Decompose 256-bit shifts into smaller 128-bit shifts.
19366   if (VT.is256BitVector()) {
19367     unsigned NumElems = VT.getVectorNumElements();
19368     MVT EltVT = VT.getVectorElementType();
19369     EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
19370
19371     // Extract the two vectors
19372     SDValue V1 = Extract128BitVector(R, 0, DAG, dl);
19373     SDValue V2 = Extract128BitVector(R, NumElems/2, DAG, dl);
19374
19375     // Recreate the shift amount vectors
19376     SDValue Amt1, Amt2;
19377     if (Amt.getOpcode() == ISD::BUILD_VECTOR) {
19378       // Constant shift amount
19379       SmallVector<SDValue, 4> Amt1Csts;
19380       SmallVector<SDValue, 4> Amt2Csts;
19381       for (unsigned i = 0; i != NumElems/2; ++i)
19382         Amt1Csts.push_back(Amt->getOperand(i));
19383       for (unsigned i = NumElems/2; i != NumElems; ++i)
19384         Amt2Csts.push_back(Amt->getOperand(i));
19385
19386       Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt1Csts);
19387       Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt2Csts);
19388     } else {
19389       // Variable shift amount
19390       Amt1 = Extract128BitVector(Amt, 0, DAG, dl);
19391       Amt2 = Extract128BitVector(Amt, NumElems/2, DAG, dl);
19392     }
19393
19394     // Issue new vector shifts for the smaller types
19395     V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
19396     V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
19397
19398     // Concatenate the result back
19399     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
19400   }
19401
19402   return SDValue();
19403 }
19404
19405 static SDValue LowerXALUO(SDValue Op, SelectionDAG &DAG) {
19406   // Lower the "add/sub/mul with overflow" instruction into a regular ins plus
19407   // a "setcc" instruction that checks the overflow flag. The "brcond" lowering
19408   // looks for this combo and may remove the "setcc" instruction if the "setcc"
19409   // has only one use.
19410   SDNode *N = Op.getNode();
19411   SDValue LHS = N->getOperand(0);
19412   SDValue RHS = N->getOperand(1);
19413   unsigned BaseOp = 0;
19414   unsigned Cond = 0;
19415   SDLoc DL(Op);
19416   switch (Op.getOpcode()) {
19417   default: llvm_unreachable("Unknown ovf instruction!");
19418   case ISD::SADDO:
19419     // A subtract of one will be selected as a INC. Note that INC doesn't
19420     // set CF, so we can't do this for UADDO.
19421     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
19422       if (C->isOne()) {
19423         BaseOp = X86ISD::INC;
19424         Cond = X86::COND_O;
19425         break;
19426       }
19427     BaseOp = X86ISD::ADD;
19428     Cond = X86::COND_O;
19429     break;
19430   case ISD::UADDO:
19431     BaseOp = X86ISD::ADD;
19432     Cond = X86::COND_B;
19433     break;
19434   case ISD::SSUBO:
19435     // A subtract of one will be selected as a DEC. Note that DEC doesn't
19436     // set CF, so we can't do this for USUBO.
19437     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
19438       if (C->isOne()) {
19439         BaseOp = X86ISD::DEC;
19440         Cond = X86::COND_O;
19441         break;
19442       }
19443     BaseOp = X86ISD::SUB;
19444     Cond = X86::COND_O;
19445     break;
19446   case ISD::USUBO:
19447     BaseOp = X86ISD::SUB;
19448     Cond = X86::COND_B;
19449     break;
19450   case ISD::SMULO:
19451     BaseOp = N->getValueType(0) == MVT::i8 ? X86ISD::SMUL8 : X86ISD::SMUL;
19452     Cond = X86::COND_O;
19453     break;
19454   case ISD::UMULO: { // i64, i8 = umulo lhs, rhs --> i64, i64, i32 umul lhs,rhs
19455     if (N->getValueType(0) == MVT::i8) {
19456       BaseOp = X86ISD::UMUL8;
19457       Cond = X86::COND_O;
19458       break;
19459     }
19460     SDVTList VTs = DAG.getVTList(N->getValueType(0), N->getValueType(0),
19461                                  MVT::i32);
19462     SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
19463
19464     SDValue SetCC =
19465       DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
19466                   DAG.getConstant(X86::COND_O, MVT::i32),
19467                   SDValue(Sum.getNode(), 2));
19468
19469     return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
19470   }
19471   }
19472
19473   // Also sets EFLAGS.
19474   SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::i32);
19475   SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
19476
19477   SDValue SetCC =
19478     DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
19479                 DAG.getConstant(Cond, MVT::i32),
19480                 SDValue(Sum.getNode(), 1));
19481
19482   return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
19483 }
19484
19485 // Sign extension of the low part of vector elements. This may be used either
19486 // when sign extend instructions are not available or if the vector element
19487 // sizes already match the sign-extended size. If the vector elements are in
19488 // their pre-extended size and sign extend instructions are available, that will
19489 // be handled by LowerSIGN_EXTEND.
19490 SDValue X86TargetLowering::LowerSIGN_EXTEND_INREG(SDValue Op,
19491                                                   SelectionDAG &DAG) const {
19492   SDLoc dl(Op);
19493   EVT ExtraVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
19494   MVT VT = Op.getSimpleValueType();
19495
19496   if (!Subtarget->hasSSE2() || !VT.isVector())
19497     return SDValue();
19498
19499   unsigned BitsDiff = VT.getScalarType().getSizeInBits() -
19500                       ExtraVT.getScalarType().getSizeInBits();
19501
19502   switch (VT.SimpleTy) {
19503     default: return SDValue();
19504     case MVT::v8i32:
19505     case MVT::v16i16:
19506       if (!Subtarget->hasFp256())
19507         return SDValue();
19508       if (!Subtarget->hasInt256()) {
19509         // needs to be split
19510         unsigned NumElems = VT.getVectorNumElements();
19511
19512         // Extract the LHS vectors
19513         SDValue LHS = Op.getOperand(0);
19514         SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
19515         SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
19516
19517         MVT EltVT = VT.getVectorElementType();
19518         EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
19519
19520         EVT ExtraEltVT = ExtraVT.getVectorElementType();
19521         unsigned ExtraNumElems = ExtraVT.getVectorNumElements();
19522         ExtraVT = EVT::getVectorVT(*DAG.getContext(), ExtraEltVT,
19523                                    ExtraNumElems/2);
19524         SDValue Extra = DAG.getValueType(ExtraVT);
19525
19526         LHS1 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, Extra);
19527         LHS2 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, Extra);
19528
19529         return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, LHS1, LHS2);
19530       }
19531       // fall through
19532     case MVT::v4i32:
19533     case MVT::v8i16: {
19534       SDValue Op0 = Op.getOperand(0);
19535
19536       // This is a sign extension of some low part of vector elements without
19537       // changing the size of the vector elements themselves:
19538       // Shift-Left + Shift-Right-Algebraic.
19539       SDValue Shl = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, Op0,
19540                                                BitsDiff, DAG);
19541       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, Shl, BitsDiff,
19542                                         DAG);
19543     }
19544   }
19545 }
19546
19547 /// Returns true if the operand type is exactly twice the native width, and
19548 /// the corresponding cmpxchg8b or cmpxchg16b instruction is available.
19549 /// Used to know whether to use cmpxchg8/16b when expanding atomic operations
19550 /// (otherwise we leave them alone to become __sync_fetch_and_... calls).
19551 bool X86TargetLowering::needsCmpXchgNb(const Type *MemType) const {
19552   unsigned OpWidth = MemType->getPrimitiveSizeInBits();
19553
19554   if (OpWidth == 64)
19555     return !Subtarget->is64Bit(); // FIXME this should be Subtarget.hasCmpxchg8b
19556   else if (OpWidth == 128)
19557     return Subtarget->hasCmpxchg16b();
19558   else
19559     return false;
19560 }
19561
19562 bool X86TargetLowering::shouldExpandAtomicStoreInIR(StoreInst *SI) const {
19563   return needsCmpXchgNb(SI->getValueOperand()->getType());
19564 }
19565
19566 // Note: this turns large loads into lock cmpxchg8b/16b.
19567 // FIXME: On 32 bits x86, fild/movq might be faster than lock cmpxchg8b.
19568 bool X86TargetLowering::shouldExpandAtomicLoadInIR(LoadInst *LI) const {
19569   auto PTy = cast<PointerType>(LI->getPointerOperand()->getType());
19570   return needsCmpXchgNb(PTy->getElementType());
19571 }
19572
19573 bool X86TargetLowering::shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const {
19574   unsigned NativeWidth = Subtarget->is64Bit() ? 64 : 32;
19575   const Type *MemType = AI->getType();
19576
19577   // If the operand is too big, we must see if cmpxchg8/16b is available
19578   // and default to library calls otherwise.
19579   if (MemType->getPrimitiveSizeInBits() > NativeWidth)
19580     return needsCmpXchgNb(MemType);
19581
19582   AtomicRMWInst::BinOp Op = AI->getOperation();
19583   switch (Op) {
19584   default:
19585     llvm_unreachable("Unknown atomic operation");
19586   case AtomicRMWInst::Xchg:
19587   case AtomicRMWInst::Add:
19588   case AtomicRMWInst::Sub:
19589     // It's better to use xadd, xsub or xchg for these in all cases.
19590     return false;
19591   case AtomicRMWInst::Or:
19592   case AtomicRMWInst::And:
19593   case AtomicRMWInst::Xor:
19594     // If the atomicrmw's result isn't actually used, we can just add a "lock"
19595     // prefix to a normal instruction for these operations.
19596     return !AI->use_empty();
19597   case AtomicRMWInst::Nand:
19598   case AtomicRMWInst::Max:
19599   case AtomicRMWInst::Min:
19600   case AtomicRMWInst::UMax:
19601   case AtomicRMWInst::UMin:
19602     // These always require a non-trivial set of data operations on x86. We must
19603     // use a cmpxchg loop.
19604     return true;
19605   }
19606 }
19607
19608 static bool hasMFENCE(const X86Subtarget& Subtarget) {
19609   // Use mfence if we have SSE2 or we're on x86-64 (even if we asked for
19610   // no-sse2). There isn't any reason to disable it if the target processor
19611   // supports it.
19612   return Subtarget.hasSSE2() || Subtarget.is64Bit();
19613 }
19614
19615 LoadInst *
19616 X86TargetLowering::lowerIdempotentRMWIntoFencedLoad(AtomicRMWInst *AI) const {
19617   unsigned NativeWidth = Subtarget->is64Bit() ? 64 : 32;
19618   const Type *MemType = AI->getType();
19619   // Accesses larger than the native width are turned into cmpxchg/libcalls, so
19620   // there is no benefit in turning such RMWs into loads, and it is actually
19621   // harmful as it introduces a mfence.
19622   if (MemType->getPrimitiveSizeInBits() > NativeWidth)
19623     return nullptr;
19624
19625   auto Builder = IRBuilder<>(AI);
19626   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
19627   auto SynchScope = AI->getSynchScope();
19628   // We must restrict the ordering to avoid generating loads with Release or
19629   // ReleaseAcquire orderings.
19630   auto Order = AtomicCmpXchgInst::getStrongestFailureOrdering(AI->getOrdering());
19631   auto Ptr = AI->getPointerOperand();
19632
19633   // Before the load we need a fence. Here is an example lifted from
19634   // http://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf showing why a fence
19635   // is required:
19636   // Thread 0:
19637   //   x.store(1, relaxed);
19638   //   r1 = y.fetch_add(0, release);
19639   // Thread 1:
19640   //   y.fetch_add(42, acquire);
19641   //   r2 = x.load(relaxed);
19642   // r1 = r2 = 0 is impossible, but becomes possible if the idempotent rmw is
19643   // lowered to just a load without a fence. A mfence flushes the store buffer,
19644   // making the optimization clearly correct.
19645   // FIXME: it is required if isAtLeastRelease(Order) but it is not clear
19646   // otherwise, we might be able to be more agressive on relaxed idempotent
19647   // rmw. In practice, they do not look useful, so we don't try to be
19648   // especially clever.
19649   if (SynchScope == SingleThread) {
19650     // FIXME: we could just insert an X86ISD::MEMBARRIER here, except we are at
19651     // the IR level, so we must wrap it in an intrinsic.
19652     return nullptr;
19653   } else if (hasMFENCE(*Subtarget)) {
19654     Function *MFence = llvm::Intrinsic::getDeclaration(M,
19655             Intrinsic::x86_sse2_mfence);
19656     Builder.CreateCall(MFence);
19657   } else {
19658     // FIXME: it might make sense to use a locked operation here but on a
19659     // different cache-line to prevent cache-line bouncing. In practice it
19660     // is probably a small win, and x86 processors without mfence are rare
19661     // enough that we do not bother.
19662     return nullptr;
19663   }
19664
19665   // Finally we can emit the atomic load.
19666   LoadInst *Loaded = Builder.CreateAlignedLoad(Ptr,
19667           AI->getType()->getPrimitiveSizeInBits());
19668   Loaded->setAtomic(Order, SynchScope);
19669   AI->replaceAllUsesWith(Loaded);
19670   AI->eraseFromParent();
19671   return Loaded;
19672 }
19673
19674 static SDValue LowerATOMIC_FENCE(SDValue Op, const X86Subtarget *Subtarget,
19675                                  SelectionDAG &DAG) {
19676   SDLoc dl(Op);
19677   AtomicOrdering FenceOrdering = static_cast<AtomicOrdering>(
19678     cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue());
19679   SynchronizationScope FenceScope = static_cast<SynchronizationScope>(
19680     cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue());
19681
19682   // The only fence that needs an instruction is a sequentially-consistent
19683   // cross-thread fence.
19684   if (FenceOrdering == SequentiallyConsistent && FenceScope == CrossThread) {
19685     if (hasMFENCE(*Subtarget))
19686       return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
19687
19688     SDValue Chain = Op.getOperand(0);
19689     SDValue Zero = DAG.getConstant(0, MVT::i32);
19690     SDValue Ops[] = {
19691       DAG.getRegister(X86::ESP, MVT::i32), // Base
19692       DAG.getTargetConstant(1, MVT::i8),   // Scale
19693       DAG.getRegister(0, MVT::i32),        // Index
19694       DAG.getTargetConstant(0, MVT::i32),  // Disp
19695       DAG.getRegister(0, MVT::i32),        // Segment.
19696       Zero,
19697       Chain
19698     };
19699     SDNode *Res = DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops);
19700     return SDValue(Res, 0);
19701   }
19702
19703   // MEMBARRIER is a compiler barrier; it codegens to a no-op.
19704   return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
19705 }
19706
19707 static SDValue LowerCMP_SWAP(SDValue Op, const X86Subtarget *Subtarget,
19708                              SelectionDAG &DAG) {
19709   MVT T = Op.getSimpleValueType();
19710   SDLoc DL(Op);
19711   unsigned Reg = 0;
19712   unsigned size = 0;
19713   switch(T.SimpleTy) {
19714   default: llvm_unreachable("Invalid value type!");
19715   case MVT::i8:  Reg = X86::AL;  size = 1; break;
19716   case MVT::i16: Reg = X86::AX;  size = 2; break;
19717   case MVT::i32: Reg = X86::EAX; size = 4; break;
19718   case MVT::i64:
19719     assert(Subtarget->is64Bit() && "Node not type legal!");
19720     Reg = X86::RAX; size = 8;
19721     break;
19722   }
19723   SDValue cpIn = DAG.getCopyToReg(Op.getOperand(0), DL, Reg,
19724                                   Op.getOperand(2), SDValue());
19725   SDValue Ops[] = { cpIn.getValue(0),
19726                     Op.getOperand(1),
19727                     Op.getOperand(3),
19728                     DAG.getTargetConstant(size, MVT::i8),
19729                     cpIn.getValue(1) };
19730   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
19731   MachineMemOperand *MMO = cast<AtomicSDNode>(Op)->getMemOperand();
19732   SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG_DAG, DL, Tys,
19733                                            Ops, T, MMO);
19734
19735   SDValue cpOut =
19736     DAG.getCopyFromReg(Result.getValue(0), DL, Reg, T, Result.getValue(1));
19737   SDValue EFLAGS = DAG.getCopyFromReg(cpOut.getValue(1), DL, X86::EFLAGS,
19738                                       MVT::i32, cpOut.getValue(2));
19739   SDValue Success = DAG.getNode(X86ISD::SETCC, DL, Op->getValueType(1),
19740                                 DAG.getConstant(X86::COND_E, MVT::i8), EFLAGS);
19741
19742   DAG.ReplaceAllUsesOfValueWith(Op.getValue(0), cpOut);
19743   DAG.ReplaceAllUsesOfValueWith(Op.getValue(1), Success);
19744   DAG.ReplaceAllUsesOfValueWith(Op.getValue(2), EFLAGS.getValue(1));
19745   return SDValue();
19746 }
19747
19748 static SDValue LowerBITCAST(SDValue Op, const X86Subtarget *Subtarget,
19749                             SelectionDAG &DAG) {
19750   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
19751   MVT DstVT = Op.getSimpleValueType();
19752
19753   if (SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 || SrcVT == MVT::v8i8) {
19754     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
19755     if (DstVT != MVT::f64)
19756       // This conversion needs to be expanded.
19757       return SDValue();
19758
19759     SDValue InVec = Op->getOperand(0);
19760     SDLoc dl(Op);
19761     unsigned NumElts = SrcVT.getVectorNumElements();
19762     EVT SVT = SrcVT.getVectorElementType();
19763
19764     // Widen the vector in input in the case of MVT::v2i32.
19765     // Example: from MVT::v2i32 to MVT::v4i32.
19766     SmallVector<SDValue, 16> Elts;
19767     for (unsigned i = 0, e = NumElts; i != e; ++i)
19768       Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT, InVec,
19769                                  DAG.getIntPtrConstant(i)));
19770
19771     // Explicitly mark the extra elements as Undef.
19772     Elts.append(NumElts, DAG.getUNDEF(SVT));
19773
19774     EVT NewVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumElts * 2);
19775     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Elts);
19776     SDValue ToV2F64 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, BV);
19777     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, ToV2F64,
19778                        DAG.getIntPtrConstant(0));
19779   }
19780
19781   assert(Subtarget->is64Bit() && !Subtarget->hasSSE2() &&
19782          Subtarget->hasMMX() && "Unexpected custom BITCAST");
19783   assert((DstVT == MVT::i64 ||
19784           (DstVT.isVector() && DstVT.getSizeInBits()==64)) &&
19785          "Unexpected custom BITCAST");
19786   // i64 <=> MMX conversions are Legal.
19787   if (SrcVT==MVT::i64 && DstVT.isVector())
19788     return Op;
19789   if (DstVT==MVT::i64 && SrcVT.isVector())
19790     return Op;
19791   // MMX <=> MMX conversions are Legal.
19792   if (SrcVT.isVector() && DstVT.isVector())
19793     return Op;
19794   // All other conversions need to be expanded.
19795   return SDValue();
19796 }
19797
19798 static SDValue LowerCTPOP(SDValue Op, const X86Subtarget *Subtarget,
19799                           SelectionDAG &DAG) {
19800   SDNode *Node = Op.getNode();
19801   SDLoc dl(Node);
19802
19803   Op = Op.getOperand(0);
19804   EVT VT = Op.getValueType();
19805   assert((VT.is128BitVector() || VT.is256BitVector()) &&
19806          "CTPOP lowering only implemented for 128/256-bit wide vector types");
19807
19808   unsigned NumElts = VT.getVectorNumElements();
19809   EVT EltVT = VT.getVectorElementType();
19810   unsigned Len = EltVT.getSizeInBits();
19811
19812   // This is the vectorized version of the "best" algorithm from
19813   // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
19814   // with a minor tweak to use a series of adds + shifts instead of vector
19815   // multiplications. Implemented for the v2i64, v4i64, v4i32, v8i32 types:
19816   //
19817   //  v2i64, v4i64, v4i32 => Only profitable w/ popcnt disabled
19818   //  v8i32 => Always profitable
19819   //
19820   // FIXME: There a couple of possible improvements:
19821   //
19822   // 1) Support for i8 and i16 vectors (needs measurements if popcnt enabled).
19823   // 2) Use strategies from http://wm.ite.pl/articles/sse-popcount.html
19824   //
19825   assert(EltVT.isInteger() && (Len == 32 || Len == 64) && Len % 8 == 0 &&
19826          "CTPOP not implemented for this vector element type.");
19827
19828   // X86 canonicalize ANDs to vXi64, generate the appropriate bitcasts to avoid
19829   // extra legalization.
19830   bool NeedsBitcast = EltVT == MVT::i32;
19831   MVT BitcastVT = VT.is256BitVector() ? MVT::v4i64 : MVT::v2i64;
19832
19833   SDValue Cst55 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x55)), EltVT);
19834   SDValue Cst33 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x33)), EltVT);
19835   SDValue Cst0F = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x0F)), EltVT);
19836
19837   // v = v - ((v >> 1) & 0x55555555...)
19838   SmallVector<SDValue, 8> Ones(NumElts, DAG.getConstant(1, EltVT));
19839   SDValue OnesV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ones);
19840   SDValue Srl = DAG.getNode(ISD::SRL, dl, VT, Op, OnesV);
19841   if (NeedsBitcast)
19842     Srl = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Srl);
19843
19844   SmallVector<SDValue, 8> Mask55(NumElts, Cst55);
19845   SDValue M55 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask55);
19846   if (NeedsBitcast)
19847     M55 = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M55);
19848
19849   SDValue And = DAG.getNode(ISD::AND, dl, Srl.getValueType(), Srl, M55);
19850   if (VT != And.getValueType())
19851     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19852   SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, Op, And);
19853
19854   // v = (v & 0x33333333...) + ((v >> 2) & 0x33333333...)
19855   SmallVector<SDValue, 8> Mask33(NumElts, Cst33);
19856   SDValue M33 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask33);
19857   SmallVector<SDValue, 8> Twos(NumElts, DAG.getConstant(2, EltVT));
19858   SDValue TwosV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Twos);
19859
19860   Srl = DAG.getNode(ISD::SRL, dl, VT, Sub, TwosV);
19861   if (NeedsBitcast) {
19862     Srl = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Srl);
19863     M33 = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M33);
19864     Sub = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Sub);
19865   }
19866
19867   SDValue AndRHS = DAG.getNode(ISD::AND, dl, M33.getValueType(), Srl, M33);
19868   SDValue AndLHS = DAG.getNode(ISD::AND, dl, M33.getValueType(), Sub, M33);
19869   if (VT != AndRHS.getValueType()) {
19870     AndRHS = DAG.getNode(ISD::BITCAST, dl, VT, AndRHS);
19871     AndLHS = DAG.getNode(ISD::BITCAST, dl, VT, AndLHS);
19872   }
19873   SDValue Add = DAG.getNode(ISD::ADD, dl, VT, AndLHS, AndRHS);
19874
19875   // v = (v + (v >> 4)) & 0x0F0F0F0F...
19876   SmallVector<SDValue, 8> Fours(NumElts, DAG.getConstant(4, EltVT));
19877   SDValue FoursV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Fours);
19878   Srl = DAG.getNode(ISD::SRL, dl, VT, Add, FoursV);
19879   Add = DAG.getNode(ISD::ADD, dl, VT, Add, Srl);
19880
19881   SmallVector<SDValue, 8> Mask0F(NumElts, Cst0F);
19882   SDValue M0F = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask0F);
19883   if (NeedsBitcast) {
19884     Add = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Add);
19885     M0F = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M0F);
19886   }
19887   And = DAG.getNode(ISD::AND, dl, M0F.getValueType(), Add, M0F);
19888   if (VT != And.getValueType())
19889     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19890
19891   // The algorithm mentioned above uses:
19892   //    v = (v * 0x01010101...) >> (Len - 8)
19893   //
19894   // Change it to use vector adds + vector shifts which yield faster results on
19895   // Haswell than using vector integer multiplication.
19896   //
19897   // For i32 elements:
19898   //    v = v + (v >> 8)
19899   //    v = v + (v >> 16)
19900   //
19901   // For i64 elements:
19902   //    v = v + (v >> 8)
19903   //    v = v + (v >> 16)
19904   //    v = v + (v >> 32)
19905   //
19906   Add = And;
19907   SmallVector<SDValue, 8> Csts;
19908   for (unsigned i = 8; i <= Len/2; i *= 2) {
19909     Csts.assign(NumElts, DAG.getConstant(i, EltVT));
19910     SDValue CstsV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Csts);
19911     Srl = DAG.getNode(ISD::SRL, dl, VT, Add, CstsV);
19912     Add = DAG.getNode(ISD::ADD, dl, VT, Add, Srl);
19913     Csts.clear();
19914   }
19915
19916   // The result is on the least significant 6-bits on i32 and 7-bits on i64.
19917   SDValue Cst3F = DAG.getConstant(APInt(Len, Len == 32 ? 0x3F : 0x7F), EltVT);
19918   SmallVector<SDValue, 8> Cst3FV(NumElts, Cst3F);
19919   SDValue M3F = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Cst3FV);
19920   if (NeedsBitcast) {
19921     Add = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Add);
19922     M3F = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M3F);
19923   }
19924   And = DAG.getNode(ISD::AND, dl, M3F.getValueType(), Add, M3F);
19925   if (VT != And.getValueType())
19926     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19927
19928   return And;
19929 }
19930
19931 static SDValue LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) {
19932   SDNode *Node = Op.getNode();
19933   SDLoc dl(Node);
19934   EVT T = Node->getValueType(0);
19935   SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
19936                               DAG.getConstant(0, T), Node->getOperand(2));
19937   return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, dl,
19938                        cast<AtomicSDNode>(Node)->getMemoryVT(),
19939                        Node->getOperand(0),
19940                        Node->getOperand(1), negOp,
19941                        cast<AtomicSDNode>(Node)->getMemOperand(),
19942                        cast<AtomicSDNode>(Node)->getOrdering(),
19943                        cast<AtomicSDNode>(Node)->getSynchScope());
19944 }
19945
19946 static SDValue LowerATOMIC_STORE(SDValue Op, SelectionDAG &DAG) {
19947   SDNode *Node = Op.getNode();
19948   SDLoc dl(Node);
19949   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
19950
19951   // Convert seq_cst store -> xchg
19952   // Convert wide store -> swap (-> cmpxchg8b/cmpxchg16b)
19953   // FIXME: On 32-bit, store -> fist or movq would be more efficient
19954   //        (The only way to get a 16-byte store is cmpxchg16b)
19955   // FIXME: 16-byte ATOMIC_SWAP isn't actually hooked up at the moment.
19956   if (cast<AtomicSDNode>(Node)->getOrdering() == SequentiallyConsistent ||
19957       !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
19958     SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
19959                                  cast<AtomicSDNode>(Node)->getMemoryVT(),
19960                                  Node->getOperand(0),
19961                                  Node->getOperand(1), Node->getOperand(2),
19962                                  cast<AtomicSDNode>(Node)->getMemOperand(),
19963                                  cast<AtomicSDNode>(Node)->getOrdering(),
19964                                  cast<AtomicSDNode>(Node)->getSynchScope());
19965     return Swap.getValue(1);
19966   }
19967   // Other atomic stores have a simple pattern.
19968   return Op;
19969 }
19970
19971 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
19972   EVT VT = Op.getNode()->getSimpleValueType(0);
19973
19974   // Let legalize expand this if it isn't a legal type yet.
19975   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
19976     return SDValue();
19977
19978   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
19979
19980   unsigned Opc;
19981   bool ExtraOp = false;
19982   switch (Op.getOpcode()) {
19983   default: llvm_unreachable("Invalid code");
19984   case ISD::ADDC: Opc = X86ISD::ADD; break;
19985   case ISD::ADDE: Opc = X86ISD::ADC; ExtraOp = true; break;
19986   case ISD::SUBC: Opc = X86ISD::SUB; break;
19987   case ISD::SUBE: Opc = X86ISD::SBB; ExtraOp = true; break;
19988   }
19989
19990   if (!ExtraOp)
19991     return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
19992                        Op.getOperand(1));
19993   return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
19994                      Op.getOperand(1), Op.getOperand(2));
19995 }
19996
19997 static SDValue LowerFSINCOS(SDValue Op, const X86Subtarget *Subtarget,
19998                             SelectionDAG &DAG) {
19999   assert(Subtarget->isTargetDarwin() && Subtarget->is64Bit());
20000
20001   // For MacOSX, we want to call an alternative entry point: __sincos_stret,
20002   // which returns the values as { float, float } (in XMM0) or
20003   // { double, double } (which is returned in XMM0, XMM1).
20004   SDLoc dl(Op);
20005   SDValue Arg = Op.getOperand(0);
20006   EVT ArgVT = Arg.getValueType();
20007   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
20008
20009   TargetLowering::ArgListTy Args;
20010   TargetLowering::ArgListEntry Entry;
20011
20012   Entry.Node = Arg;
20013   Entry.Ty = ArgTy;
20014   Entry.isSExt = false;
20015   Entry.isZExt = false;
20016   Args.push_back(Entry);
20017
20018   bool isF64 = ArgVT == MVT::f64;
20019   // Only optimize x86_64 for now. i386 is a bit messy. For f32,
20020   // the small struct {f32, f32} is returned in (eax, edx). For f64,
20021   // the results are returned via SRet in memory.
20022   const char *LibcallName =  isF64 ? "__sincos_stret" : "__sincosf_stret";
20023   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20024   SDValue Callee = DAG.getExternalSymbol(LibcallName, TLI.getPointerTy());
20025
20026   Type *RetTy = isF64
20027     ? (Type*)StructType::get(ArgTy, ArgTy, nullptr)
20028     : (Type*)VectorType::get(ArgTy, 4);
20029
20030   TargetLowering::CallLoweringInfo CLI(DAG);
20031   CLI.setDebugLoc(dl).setChain(DAG.getEntryNode())
20032     .setCallee(CallingConv::C, RetTy, Callee, std::move(Args), 0);
20033
20034   std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
20035
20036   if (isF64)
20037     // Returned in xmm0 and xmm1.
20038     return CallResult.first;
20039
20040   // Returned in bits 0:31 and 32:64 xmm0.
20041   SDValue SinVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
20042                                CallResult.first, DAG.getIntPtrConstant(0));
20043   SDValue CosVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
20044                                CallResult.first, DAG.getIntPtrConstant(1));
20045   SDVTList Tys = DAG.getVTList(ArgVT, ArgVT);
20046   return DAG.getNode(ISD::MERGE_VALUES, dl, Tys, SinVal, CosVal);
20047 }
20048
20049 /// LowerOperation - Provide custom lowering hooks for some operations.
20050 ///
20051 SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
20052   switch (Op.getOpcode()) {
20053   default: llvm_unreachable("Should not custom lower this!");
20054   case ISD::SIGN_EXTEND_INREG:  return LowerSIGN_EXTEND_INREG(Op,DAG);
20055   case ISD::ATOMIC_FENCE:       return LowerATOMIC_FENCE(Op, Subtarget, DAG);
20056   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS:
20057     return LowerCMP_SWAP(Op, Subtarget, DAG);
20058   case ISD::CTPOP:              return LowerCTPOP(Op, Subtarget, DAG);
20059   case ISD::ATOMIC_LOAD_SUB:    return LowerLOAD_SUB(Op,DAG);
20060   case ISD::ATOMIC_STORE:       return LowerATOMIC_STORE(Op,DAG);
20061   case ISD::BUILD_VECTOR:       return LowerBUILD_VECTOR(Op, DAG);
20062   case ISD::CONCAT_VECTORS:     return LowerCONCAT_VECTORS(Op, DAG);
20063   case ISD::VECTOR_SHUFFLE:     return LowerVECTOR_SHUFFLE(Op, DAG);
20064   case ISD::VSELECT:            return LowerVSELECT(Op, DAG);
20065   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
20066   case ISD::INSERT_VECTOR_ELT:  return LowerINSERT_VECTOR_ELT(Op, DAG);
20067   case ISD::EXTRACT_SUBVECTOR:  return LowerEXTRACT_SUBVECTOR(Op,Subtarget,DAG);
20068   case ISD::INSERT_SUBVECTOR:   return LowerINSERT_SUBVECTOR(Op, Subtarget,DAG);
20069   case ISD::SCALAR_TO_VECTOR:   return LowerSCALAR_TO_VECTOR(Op, DAG);
20070   case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
20071   case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
20072   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
20073   case ISD::ExternalSymbol:     return LowerExternalSymbol(Op, DAG);
20074   case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
20075   case ISD::SHL_PARTS:
20076   case ISD::SRA_PARTS:
20077   case ISD::SRL_PARTS:          return LowerShiftParts(Op, DAG);
20078   case ISD::SINT_TO_FP:         return LowerSINT_TO_FP(Op, DAG);
20079   case ISD::UINT_TO_FP:         return LowerUINT_TO_FP(Op, DAG);
20080   case ISD::TRUNCATE:           return LowerTRUNCATE(Op, DAG);
20081   case ISD::ZERO_EXTEND:        return LowerZERO_EXTEND(Op, Subtarget, DAG);
20082   case ISD::SIGN_EXTEND:        return LowerSIGN_EXTEND(Op, Subtarget, DAG);
20083   case ISD::ANY_EXTEND:         return LowerANY_EXTEND(Op, Subtarget, DAG);
20084   case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
20085   case ISD::FP_TO_UINT:         return LowerFP_TO_UINT(Op, DAG);
20086   case ISD::FP_EXTEND:          return LowerFP_EXTEND(Op, DAG);
20087   case ISD::LOAD:               return LowerExtendedLoad(Op, Subtarget, DAG);
20088   case ISD::FABS:
20089   case ISD::FNEG:               return LowerFABSorFNEG(Op, DAG);
20090   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
20091   case ISD::FGETSIGN:           return LowerFGETSIGN(Op, DAG);
20092   case ISD::SETCC:              return LowerSETCC(Op, DAG);
20093   case ISD::SELECT:             return LowerSELECT(Op, DAG);
20094   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
20095   case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
20096   case ISD::VASTART:            return LowerVASTART(Op, DAG);
20097   case ISD::VAARG:              return LowerVAARG(Op, DAG);
20098   case ISD::VACOPY:             return LowerVACOPY(Op, Subtarget, DAG);
20099   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, Subtarget, DAG);
20100   case ISD::INTRINSIC_VOID:
20101   case ISD::INTRINSIC_W_CHAIN:  return LowerINTRINSIC_W_CHAIN(Op, Subtarget, DAG);
20102   case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
20103   case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
20104   case ISD::FRAME_TO_ARGS_OFFSET:
20105                                 return LowerFRAME_TO_ARGS_OFFSET(Op, DAG);
20106   case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
20107   case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
20108   case ISD::EH_SJLJ_SETJMP:     return lowerEH_SJLJ_SETJMP(Op, DAG);
20109   case ISD::EH_SJLJ_LONGJMP:    return lowerEH_SJLJ_LONGJMP(Op, DAG);
20110   case ISD::INIT_TRAMPOLINE:    return LowerINIT_TRAMPOLINE(Op, DAG);
20111   case ISD::ADJUST_TRAMPOLINE:  return LowerADJUST_TRAMPOLINE(Op, DAG);
20112   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
20113   case ISD::CTLZ:               return LowerCTLZ(Op, DAG);
20114   case ISD::CTLZ_ZERO_UNDEF:    return LowerCTLZ_ZERO_UNDEF(Op, DAG);
20115   case ISD::CTTZ:               return LowerCTTZ(Op, DAG);
20116   case ISD::MUL:                return LowerMUL(Op, Subtarget, DAG);
20117   case ISD::UMUL_LOHI:
20118   case ISD::SMUL_LOHI:          return LowerMUL_LOHI(Op, Subtarget, DAG);
20119   case ISD::SRA:
20120   case ISD::SRL:
20121   case ISD::SHL:                return LowerShift(Op, Subtarget, DAG);
20122   case ISD::SADDO:
20123   case ISD::UADDO:
20124   case ISD::SSUBO:
20125   case ISD::USUBO:
20126   case ISD::SMULO:
20127   case ISD::UMULO:              return LowerXALUO(Op, DAG);
20128   case ISD::READCYCLECOUNTER:   return LowerREADCYCLECOUNTER(Op, Subtarget,DAG);
20129   case ISD::BITCAST:            return LowerBITCAST(Op, Subtarget, DAG);
20130   case ISD::ADDC:
20131   case ISD::ADDE:
20132   case ISD::SUBC:
20133   case ISD::SUBE:               return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
20134   case ISD::ADD:                return LowerADD(Op, DAG);
20135   case ISD::SUB:                return LowerSUB(Op, DAG);
20136   case ISD::FSINCOS:            return LowerFSINCOS(Op, Subtarget, DAG);
20137   }
20138 }
20139
20140 /// ReplaceNodeResults - Replace a node with an illegal result type
20141 /// with a new node built out of custom code.
20142 void X86TargetLowering::ReplaceNodeResults(SDNode *N,
20143                                            SmallVectorImpl<SDValue>&Results,
20144                                            SelectionDAG &DAG) const {
20145   SDLoc dl(N);
20146   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20147   switch (N->getOpcode()) {
20148   default:
20149     llvm_unreachable("Do not know how to custom type legalize this operation!");
20150   // We might have generated v2f32 FMIN/FMAX operations. Widen them to v4f32.
20151   case X86ISD::FMINC:
20152   case X86ISD::FMIN:
20153   case X86ISD::FMAXC:
20154   case X86ISD::FMAX: {
20155     EVT VT = N->getValueType(0);
20156     if (VT != MVT::v2f32)
20157       llvm_unreachable("Unexpected type (!= v2f32) on FMIN/FMAX.");
20158     SDValue UNDEF = DAG.getUNDEF(VT);
20159     SDValue LHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
20160                               N->getOperand(0), UNDEF);
20161     SDValue RHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
20162                               N->getOperand(1), UNDEF);
20163     Results.push_back(DAG.getNode(N->getOpcode(), dl, MVT::v4f32, LHS, RHS));
20164     return;
20165   }
20166   case ISD::SIGN_EXTEND_INREG:
20167   case ISD::ADDC:
20168   case ISD::ADDE:
20169   case ISD::SUBC:
20170   case ISD::SUBE:
20171     // We don't want to expand or promote these.
20172     return;
20173   case ISD::SDIV:
20174   case ISD::UDIV:
20175   case ISD::SREM:
20176   case ISD::UREM:
20177   case ISD::SDIVREM:
20178   case ISD::UDIVREM: {
20179     SDValue V = LowerWin64_i128OP(SDValue(N,0), DAG);
20180     Results.push_back(V);
20181     return;
20182   }
20183   case ISD::FP_TO_SINT:
20184   case ISD::FP_TO_UINT: {
20185     bool IsSigned = N->getOpcode() == ISD::FP_TO_SINT;
20186
20187     if (!IsSigned && !isIntegerTypeFTOL(SDValue(N, 0).getValueType()))
20188       return;
20189
20190     std::pair<SDValue,SDValue> Vals =
20191         FP_TO_INTHelper(SDValue(N, 0), DAG, IsSigned, /*IsReplace=*/ true);
20192     SDValue FIST = Vals.first, StackSlot = Vals.second;
20193     if (FIST.getNode()) {
20194       EVT VT = N->getValueType(0);
20195       // Return a load from the stack slot.
20196       if (StackSlot.getNode())
20197         Results.push_back(DAG.getLoad(VT, dl, FIST, StackSlot,
20198                                       MachinePointerInfo(),
20199                                       false, false, false, 0));
20200       else
20201         Results.push_back(FIST);
20202     }
20203     return;
20204   }
20205   case ISD::UINT_TO_FP: {
20206     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
20207     if (N->getOperand(0).getValueType() != MVT::v2i32 ||
20208         N->getValueType(0) != MVT::v2f32)
20209       return;
20210     SDValue ZExtIn = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v2i64,
20211                                  N->getOperand(0));
20212     SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
20213                                      MVT::f64);
20214     SDValue VBias = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2f64, Bias, Bias);
20215     SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64, ZExtIn,
20216                              DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, VBias));
20217     Or = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or);
20218     SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, Or, VBias);
20219     Results.push_back(DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, Sub));
20220     return;
20221   }
20222   case ISD::FP_ROUND: {
20223     if (!TLI.isTypeLegal(N->getOperand(0).getValueType()))
20224         return;
20225     SDValue V = DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, N->getOperand(0));
20226     Results.push_back(V);
20227     return;
20228   }
20229   case ISD::INTRINSIC_W_CHAIN: {
20230     unsigned IntNo = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue();
20231     switch (IntNo) {
20232     default : llvm_unreachable("Do not know how to custom type "
20233                                "legalize this intrinsic operation!");
20234     case Intrinsic::x86_rdtsc:
20235       return getReadTimeStampCounter(N, dl, X86ISD::RDTSC_DAG, DAG, Subtarget,
20236                                      Results);
20237     case Intrinsic::x86_rdtscp:
20238       return getReadTimeStampCounter(N, dl, X86ISD::RDTSCP_DAG, DAG, Subtarget,
20239                                      Results);
20240     case Intrinsic::x86_rdpmc:
20241       return getReadPerformanceCounter(N, dl, DAG, Subtarget, Results);
20242     }
20243   }
20244   case ISD::READCYCLECOUNTER: {
20245     return getReadTimeStampCounter(N, dl, X86ISD::RDTSC_DAG, DAG, Subtarget,
20246                                    Results);
20247   }
20248   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: {
20249     EVT T = N->getValueType(0);
20250     assert((T == MVT::i64 || T == MVT::i128) && "can only expand cmpxchg pair");
20251     bool Regs64bit = T == MVT::i128;
20252     EVT HalfT = Regs64bit ? MVT::i64 : MVT::i32;
20253     SDValue cpInL, cpInH;
20254     cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
20255                         DAG.getConstant(0, HalfT));
20256     cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
20257                         DAG.getConstant(1, HalfT));
20258     cpInL = DAG.getCopyToReg(N->getOperand(0), dl,
20259                              Regs64bit ? X86::RAX : X86::EAX,
20260                              cpInL, SDValue());
20261     cpInH = DAG.getCopyToReg(cpInL.getValue(0), dl,
20262                              Regs64bit ? X86::RDX : X86::EDX,
20263                              cpInH, cpInL.getValue(1));
20264     SDValue swapInL, swapInH;
20265     swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
20266                           DAG.getConstant(0, HalfT));
20267     swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
20268                           DAG.getConstant(1, HalfT));
20269     swapInL = DAG.getCopyToReg(cpInH.getValue(0), dl,
20270                                Regs64bit ? X86::RBX : X86::EBX,
20271                                swapInL, cpInH.getValue(1));
20272     swapInH = DAG.getCopyToReg(swapInL.getValue(0), dl,
20273                                Regs64bit ? X86::RCX : X86::ECX,
20274                                swapInH, swapInL.getValue(1));
20275     SDValue Ops[] = { swapInH.getValue(0),
20276                       N->getOperand(1),
20277                       swapInH.getValue(1) };
20278     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
20279     MachineMemOperand *MMO = cast<AtomicSDNode>(N)->getMemOperand();
20280     unsigned Opcode = Regs64bit ? X86ISD::LCMPXCHG16_DAG :
20281                                   X86ISD::LCMPXCHG8_DAG;
20282     SDValue Result = DAG.getMemIntrinsicNode(Opcode, dl, Tys, Ops, T, MMO);
20283     SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), dl,
20284                                         Regs64bit ? X86::RAX : X86::EAX,
20285                                         HalfT, Result.getValue(1));
20286     SDValue cpOutH = DAG.getCopyFromReg(cpOutL.getValue(1), dl,
20287                                         Regs64bit ? X86::RDX : X86::EDX,
20288                                         HalfT, cpOutL.getValue(2));
20289     SDValue OpsF[] = { cpOutL.getValue(0), cpOutH.getValue(0)};
20290
20291     SDValue EFLAGS = DAG.getCopyFromReg(cpOutH.getValue(1), dl, X86::EFLAGS,
20292                                         MVT::i32, cpOutH.getValue(2));
20293     SDValue Success =
20294         DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
20295                     DAG.getConstant(X86::COND_E, MVT::i8), EFLAGS);
20296     Success = DAG.getZExtOrTrunc(Success, dl, N->getValueType(1));
20297
20298     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF));
20299     Results.push_back(Success);
20300     Results.push_back(EFLAGS.getValue(1));
20301     return;
20302   }
20303   case ISD::ATOMIC_SWAP:
20304   case ISD::ATOMIC_LOAD_ADD:
20305   case ISD::ATOMIC_LOAD_SUB:
20306   case ISD::ATOMIC_LOAD_AND:
20307   case ISD::ATOMIC_LOAD_OR:
20308   case ISD::ATOMIC_LOAD_XOR:
20309   case ISD::ATOMIC_LOAD_NAND:
20310   case ISD::ATOMIC_LOAD_MIN:
20311   case ISD::ATOMIC_LOAD_MAX:
20312   case ISD::ATOMIC_LOAD_UMIN:
20313   case ISD::ATOMIC_LOAD_UMAX:
20314   case ISD::ATOMIC_LOAD: {
20315     // Delegate to generic TypeLegalization. Situations we can really handle
20316     // should have already been dealt with by AtomicExpandPass.cpp.
20317     break;
20318   }
20319   case ISD::BITCAST: {
20320     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
20321     EVT DstVT = N->getValueType(0);
20322     EVT SrcVT = N->getOperand(0)->getValueType(0);
20323
20324     if (SrcVT != MVT::f64 ||
20325         (DstVT != MVT::v2i32 && DstVT != MVT::v4i16 && DstVT != MVT::v8i8))
20326       return;
20327
20328     unsigned NumElts = DstVT.getVectorNumElements();
20329     EVT SVT = DstVT.getVectorElementType();
20330     EVT WiderVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumElts * 2);
20331     SDValue Expanded = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
20332                                    MVT::v2f64, N->getOperand(0));
20333     SDValue ToVecInt = DAG.getNode(ISD::BITCAST, dl, WiderVT, Expanded);
20334
20335     if (ExperimentalVectorWideningLegalization) {
20336       // If we are legalizing vectors by widening, we already have the desired
20337       // legal vector type, just return it.
20338       Results.push_back(ToVecInt);
20339       return;
20340     }
20341
20342     SmallVector<SDValue, 8> Elts;
20343     for (unsigned i = 0, e = NumElts; i != e; ++i)
20344       Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT,
20345                                    ToVecInt, DAG.getIntPtrConstant(i)));
20346
20347     Results.push_back(DAG.getNode(ISD::BUILD_VECTOR, dl, DstVT, Elts));
20348   }
20349   }
20350 }
20351
20352 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
20353   switch (Opcode) {
20354   default: return nullptr;
20355   case X86ISD::BSF:                return "X86ISD::BSF";
20356   case X86ISD::BSR:                return "X86ISD::BSR";
20357   case X86ISD::SHLD:               return "X86ISD::SHLD";
20358   case X86ISD::SHRD:               return "X86ISD::SHRD";
20359   case X86ISD::FAND:               return "X86ISD::FAND";
20360   case X86ISD::FANDN:              return "X86ISD::FANDN";
20361   case X86ISD::FOR:                return "X86ISD::FOR";
20362   case X86ISD::FXOR:               return "X86ISD::FXOR";
20363   case X86ISD::FSRL:               return "X86ISD::FSRL";
20364   case X86ISD::FILD:               return "X86ISD::FILD";
20365   case X86ISD::FILD_FLAG:          return "X86ISD::FILD_FLAG";
20366   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
20367   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
20368   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
20369   case X86ISD::FLD:                return "X86ISD::FLD";
20370   case X86ISD::FST:                return "X86ISD::FST";
20371   case X86ISD::CALL:               return "X86ISD::CALL";
20372   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
20373   case X86ISD::RDTSCP_DAG:         return "X86ISD::RDTSCP_DAG";
20374   case X86ISD::RDPMC_DAG:          return "X86ISD::RDPMC_DAG";
20375   case X86ISD::BT:                 return "X86ISD::BT";
20376   case X86ISD::CMP:                return "X86ISD::CMP";
20377   case X86ISD::COMI:               return "X86ISD::COMI";
20378   case X86ISD::UCOMI:              return "X86ISD::UCOMI";
20379   case X86ISD::CMPM:               return "X86ISD::CMPM";
20380   case X86ISD::CMPMU:              return "X86ISD::CMPMU";
20381   case X86ISD::SETCC:              return "X86ISD::SETCC";
20382   case X86ISD::SETCC_CARRY:        return "X86ISD::SETCC_CARRY";
20383   case X86ISD::FSETCC:             return "X86ISD::FSETCC";
20384   case X86ISD::CMOV:               return "X86ISD::CMOV";
20385   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
20386   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
20387   case X86ISD::REP_STOS:           return "X86ISD::REP_STOS";
20388   case X86ISD::REP_MOVS:           return "X86ISD::REP_MOVS";
20389   case X86ISD::GlobalBaseReg:      return "X86ISD::GlobalBaseReg";
20390   case X86ISD::Wrapper:            return "X86ISD::Wrapper";
20391   case X86ISD::WrapperRIP:         return "X86ISD::WrapperRIP";
20392   case X86ISD::PEXTRB:             return "X86ISD::PEXTRB";
20393   case X86ISD::PEXTRW:             return "X86ISD::PEXTRW";
20394   case X86ISD::INSERTPS:           return "X86ISD::INSERTPS";
20395   case X86ISD::PINSRB:             return "X86ISD::PINSRB";
20396   case X86ISD::PINSRW:             return "X86ISD::PINSRW";
20397   case X86ISD::PSHUFB:             return "X86ISD::PSHUFB";
20398   case X86ISD::ANDNP:              return "X86ISD::ANDNP";
20399   case X86ISD::PSIGN:              return "X86ISD::PSIGN";
20400   case X86ISD::BLENDI:             return "X86ISD::BLENDI";
20401   case X86ISD::SHRUNKBLEND:        return "X86ISD::SHRUNKBLEND";
20402   case X86ISD::SUBUS:              return "X86ISD::SUBUS";
20403   case X86ISD::HADD:               return "X86ISD::HADD";
20404   case X86ISD::HSUB:               return "X86ISD::HSUB";
20405   case X86ISD::FHADD:              return "X86ISD::FHADD";
20406   case X86ISD::FHSUB:              return "X86ISD::FHSUB";
20407   case X86ISD::UMAX:               return "X86ISD::UMAX";
20408   case X86ISD::UMIN:               return "X86ISD::UMIN";
20409   case X86ISD::SMAX:               return "X86ISD::SMAX";
20410   case X86ISD::SMIN:               return "X86ISD::SMIN";
20411   case X86ISD::FMAX:               return "X86ISD::FMAX";
20412   case X86ISD::FMIN:               return "X86ISD::FMIN";
20413   case X86ISD::FMAXC:              return "X86ISD::FMAXC";
20414   case X86ISD::FMINC:              return "X86ISD::FMINC";
20415   case X86ISD::FRSQRT:             return "X86ISD::FRSQRT";
20416   case X86ISD::FRCP:               return "X86ISD::FRCP";
20417   case X86ISD::TLSADDR:            return "X86ISD::TLSADDR";
20418   case X86ISD::TLSBASEADDR:        return "X86ISD::TLSBASEADDR";
20419   case X86ISD::TLSCALL:            return "X86ISD::TLSCALL";
20420   case X86ISD::EH_SJLJ_SETJMP:     return "X86ISD::EH_SJLJ_SETJMP";
20421   case X86ISD::EH_SJLJ_LONGJMP:    return "X86ISD::EH_SJLJ_LONGJMP";
20422   case X86ISD::EH_RETURN:          return "X86ISD::EH_RETURN";
20423   case X86ISD::TC_RETURN:          return "X86ISD::TC_RETURN";
20424   case X86ISD::FNSTCW16m:          return "X86ISD::FNSTCW16m";
20425   case X86ISD::FNSTSW16r:          return "X86ISD::FNSTSW16r";
20426   case X86ISD::LCMPXCHG_DAG:       return "X86ISD::LCMPXCHG_DAG";
20427   case X86ISD::LCMPXCHG8_DAG:      return "X86ISD::LCMPXCHG8_DAG";
20428   case X86ISD::LCMPXCHG16_DAG:     return "X86ISD::LCMPXCHG16_DAG";
20429   case X86ISD::VZEXT_MOVL:         return "X86ISD::VZEXT_MOVL";
20430   case X86ISD::VZEXT_LOAD:         return "X86ISD::VZEXT_LOAD";
20431   case X86ISD::VZEXT:              return "X86ISD::VZEXT";
20432   case X86ISD::VSEXT:              return "X86ISD::VSEXT";
20433   case X86ISD::VTRUNC:             return "X86ISD::VTRUNC";
20434   case X86ISD::VTRUNCM:            return "X86ISD::VTRUNCM";
20435   case X86ISD::VINSERT:            return "X86ISD::VINSERT";
20436   case X86ISD::VFPEXT:             return "X86ISD::VFPEXT";
20437   case X86ISD::VFPROUND:           return "X86ISD::VFPROUND";
20438   case X86ISD::VSHLDQ:             return "X86ISD::VSHLDQ";
20439   case X86ISD::VSRLDQ:             return "X86ISD::VSRLDQ";
20440   case X86ISD::VSHL:               return "X86ISD::VSHL";
20441   case X86ISD::VSRL:               return "X86ISD::VSRL";
20442   case X86ISD::VSRA:               return "X86ISD::VSRA";
20443   case X86ISD::VSHLI:              return "X86ISD::VSHLI";
20444   case X86ISD::VSRLI:              return "X86ISD::VSRLI";
20445   case X86ISD::VSRAI:              return "X86ISD::VSRAI";
20446   case X86ISD::CMPP:               return "X86ISD::CMPP";
20447   case X86ISD::PCMPEQ:             return "X86ISD::PCMPEQ";
20448   case X86ISD::PCMPGT:             return "X86ISD::PCMPGT";
20449   case X86ISD::PCMPEQM:            return "X86ISD::PCMPEQM";
20450   case X86ISD::PCMPGTM:            return "X86ISD::PCMPGTM";
20451   case X86ISD::ADD:                return "X86ISD::ADD";
20452   case X86ISD::SUB:                return "X86ISD::SUB";
20453   case X86ISD::ADC:                return "X86ISD::ADC";
20454   case X86ISD::SBB:                return "X86ISD::SBB";
20455   case X86ISD::SMUL:               return "X86ISD::SMUL";
20456   case X86ISD::UMUL:               return "X86ISD::UMUL";
20457   case X86ISD::SMUL8:              return "X86ISD::SMUL8";
20458   case X86ISD::UMUL8:              return "X86ISD::UMUL8";
20459   case X86ISD::SDIVREM8_SEXT_HREG: return "X86ISD::SDIVREM8_SEXT_HREG";
20460   case X86ISD::UDIVREM8_ZEXT_HREG: return "X86ISD::UDIVREM8_ZEXT_HREG";
20461   case X86ISD::INC:                return "X86ISD::INC";
20462   case X86ISD::DEC:                return "X86ISD::DEC";
20463   case X86ISD::OR:                 return "X86ISD::OR";
20464   case X86ISD::XOR:                return "X86ISD::XOR";
20465   case X86ISD::AND:                return "X86ISD::AND";
20466   case X86ISD::BEXTR:              return "X86ISD::BEXTR";
20467   case X86ISD::MUL_IMM:            return "X86ISD::MUL_IMM";
20468   case X86ISD::PTEST:              return "X86ISD::PTEST";
20469   case X86ISD::TESTP:              return "X86ISD::TESTP";
20470   case X86ISD::TESTM:              return "X86ISD::TESTM";
20471   case X86ISD::TESTNM:             return "X86ISD::TESTNM";
20472   case X86ISD::KORTEST:            return "X86ISD::KORTEST";
20473   case X86ISD::PACKSS:             return "X86ISD::PACKSS";
20474   case X86ISD::PACKUS:             return "X86ISD::PACKUS";
20475   case X86ISD::PALIGNR:            return "X86ISD::PALIGNR";
20476   case X86ISD::VALIGN:             return "X86ISD::VALIGN";
20477   case X86ISD::PSHUFD:             return "X86ISD::PSHUFD";
20478   case X86ISD::PSHUFHW:            return "X86ISD::PSHUFHW";
20479   case X86ISD::PSHUFLW:            return "X86ISD::PSHUFLW";
20480   case X86ISD::SHUFP:              return "X86ISD::SHUFP";
20481   case X86ISD::MOVLHPS:            return "X86ISD::MOVLHPS";
20482   case X86ISD::MOVLHPD:            return "X86ISD::MOVLHPD";
20483   case X86ISD::MOVHLPS:            return "X86ISD::MOVHLPS";
20484   case X86ISD::MOVLPS:             return "X86ISD::MOVLPS";
20485   case X86ISD::MOVLPD:             return "X86ISD::MOVLPD";
20486   case X86ISD::MOVDDUP:            return "X86ISD::MOVDDUP";
20487   case X86ISD::MOVSHDUP:           return "X86ISD::MOVSHDUP";
20488   case X86ISD::MOVSLDUP:           return "X86ISD::MOVSLDUP";
20489   case X86ISD::MOVSD:              return "X86ISD::MOVSD";
20490   case X86ISD::MOVSS:              return "X86ISD::MOVSS";
20491   case X86ISD::UNPCKL:             return "X86ISD::UNPCKL";
20492   case X86ISD::UNPCKH:             return "X86ISD::UNPCKH";
20493   case X86ISD::VBROADCAST:         return "X86ISD::VBROADCAST";
20494   case X86ISD::VBROADCASTM:        return "X86ISD::VBROADCASTM";
20495   case X86ISD::VEXTRACT:           return "X86ISD::VEXTRACT";
20496   case X86ISD::VPERMILPI:          return "X86ISD::VPERMILPI";
20497   case X86ISD::VPERM2X128:         return "X86ISD::VPERM2X128";
20498   case X86ISD::VPERMV:             return "X86ISD::VPERMV";
20499   case X86ISD::VPERMV3:            return "X86ISD::VPERMV3";
20500   case X86ISD::VPERMIV3:           return "X86ISD::VPERMIV3";
20501   case X86ISD::VPERMI:             return "X86ISD::VPERMI";
20502   case X86ISD::PMULUDQ:            return "X86ISD::PMULUDQ";
20503   case X86ISD::PMULDQ:             return "X86ISD::PMULDQ";
20504   case X86ISD::VASTART_SAVE_XMM_REGS: return "X86ISD::VASTART_SAVE_XMM_REGS";
20505   case X86ISD::VAARG_64:           return "X86ISD::VAARG_64";
20506   case X86ISD::WIN_ALLOCA:         return "X86ISD::WIN_ALLOCA";
20507   case X86ISD::MEMBARRIER:         return "X86ISD::MEMBARRIER";
20508   case X86ISD::SEG_ALLOCA:         return "X86ISD::SEG_ALLOCA";
20509   case X86ISD::WIN_FTOL:           return "X86ISD::WIN_FTOL";
20510   case X86ISD::SAHF:               return "X86ISD::SAHF";
20511   case X86ISD::RDRAND:             return "X86ISD::RDRAND";
20512   case X86ISD::RDSEED:             return "X86ISD::RDSEED";
20513   case X86ISD::FMADD:              return "X86ISD::FMADD";
20514   case X86ISD::FMSUB:              return "X86ISD::FMSUB";
20515   case X86ISD::FNMADD:             return "X86ISD::FNMADD";
20516   case X86ISD::FNMSUB:             return "X86ISD::FNMSUB";
20517   case X86ISD::FMADDSUB:           return "X86ISD::FMADDSUB";
20518   case X86ISD::FMSUBADD:           return "X86ISD::FMSUBADD";
20519   case X86ISD::PCMPESTRI:          return "X86ISD::PCMPESTRI";
20520   case X86ISD::PCMPISTRI:          return "X86ISD::PCMPISTRI";
20521   case X86ISD::XTEST:              return "X86ISD::XTEST";
20522   case X86ISD::COMPRESS:           return "X86ISD::COMPRESS";
20523   case X86ISD::EXPAND:             return "X86ISD::EXPAND";
20524   case X86ISD::SELECT:             return "X86ISD::SELECT";
20525   case X86ISD::ADDSUB:             return "X86ISD::ADDSUB";
20526   case X86ISD::RCP28:              return "X86ISD::RCP28";
20527   case X86ISD::RSQRT28:            return "X86ISD::RSQRT28";
20528   case X86ISD::FADD_RND:           return "X86ISD::FADD_RND";
20529   case X86ISD::FSUB_RND:           return "X86ISD::FSUB_RND";
20530   case X86ISD::FMUL_RND:           return "X86ISD::FMUL_RND";
20531   case X86ISD::FDIV_RND:           return "X86ISD::FDIV_RND";
20532   }
20533 }
20534
20535 // isLegalAddressingMode - Return true if the addressing mode represented
20536 // by AM is legal for this target, for a load/store of the specified type.
20537 bool X86TargetLowering::isLegalAddressingMode(const AddrMode &AM,
20538                                               Type *Ty) const {
20539   // X86 supports extremely general addressing modes.
20540   CodeModel::Model M = getTargetMachine().getCodeModel();
20541   Reloc::Model R = getTargetMachine().getRelocationModel();
20542
20543   // X86 allows a sign-extended 32-bit immediate field as a displacement.
20544   if (!X86::isOffsetSuitableForCodeModel(AM.BaseOffs, M, AM.BaseGV != nullptr))
20545     return false;
20546
20547   if (AM.BaseGV) {
20548     unsigned GVFlags =
20549       Subtarget->ClassifyGlobalReference(AM.BaseGV, getTargetMachine());
20550
20551     // If a reference to this global requires an extra load, we can't fold it.
20552     if (isGlobalStubReference(GVFlags))
20553       return false;
20554
20555     // If BaseGV requires a register for the PIC base, we cannot also have a
20556     // BaseReg specified.
20557     if (AM.HasBaseReg && isGlobalRelativeToPICBase(GVFlags))
20558       return false;
20559
20560     // If lower 4G is not available, then we must use rip-relative addressing.
20561     if ((M != CodeModel::Small || R != Reloc::Static) &&
20562         Subtarget->is64Bit() && (AM.BaseOffs || AM.Scale > 1))
20563       return false;
20564   }
20565
20566   switch (AM.Scale) {
20567   case 0:
20568   case 1:
20569   case 2:
20570   case 4:
20571   case 8:
20572     // These scales always work.
20573     break;
20574   case 3:
20575   case 5:
20576   case 9:
20577     // These scales are formed with basereg+scalereg.  Only accept if there is
20578     // no basereg yet.
20579     if (AM.HasBaseReg)
20580       return false;
20581     break;
20582   default:  // Other stuff never works.
20583     return false;
20584   }
20585
20586   return true;
20587 }
20588
20589 bool X86TargetLowering::isVectorShiftByScalarCheap(Type *Ty) const {
20590   unsigned Bits = Ty->getScalarSizeInBits();
20591
20592   // 8-bit shifts are always expensive, but versions with a scalar amount aren't
20593   // particularly cheaper than those without.
20594   if (Bits == 8)
20595     return false;
20596
20597   // On AVX2 there are new vpsllv[dq] instructions (and other shifts), that make
20598   // variable shifts just as cheap as scalar ones.
20599   if (Subtarget->hasInt256() && (Bits == 32 || Bits == 64))
20600     return false;
20601
20602   // Otherwise, it's significantly cheaper to shift by a scalar amount than by a
20603   // fully general vector.
20604   return true;
20605 }
20606
20607 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
20608   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
20609     return false;
20610   unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
20611   unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
20612   return NumBits1 > NumBits2;
20613 }
20614
20615 bool X86TargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
20616   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
20617     return false;
20618
20619   if (!isTypeLegal(EVT::getEVT(Ty1)))
20620     return false;
20621
20622   assert(Ty1->getPrimitiveSizeInBits() <= 64 && "i128 is probably not a noop");
20623
20624   // Assuming the caller doesn't have a zeroext or signext return parameter,
20625   // truncation all the way down to i1 is valid.
20626   return true;
20627 }
20628
20629 bool X86TargetLowering::isLegalICmpImmediate(int64_t Imm) const {
20630   return isInt<32>(Imm);
20631 }
20632
20633 bool X86TargetLowering::isLegalAddImmediate(int64_t Imm) const {
20634   // Can also use sub to handle negated immediates.
20635   return isInt<32>(Imm);
20636 }
20637
20638 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
20639   if (!VT1.isInteger() || !VT2.isInteger())
20640     return false;
20641   unsigned NumBits1 = VT1.getSizeInBits();
20642   unsigned NumBits2 = VT2.getSizeInBits();
20643   return NumBits1 > NumBits2;
20644 }
20645
20646 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
20647   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
20648   return Ty1->isIntegerTy(32) && Ty2->isIntegerTy(64) && Subtarget->is64Bit();
20649 }
20650
20651 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
20652   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
20653   return VT1 == MVT::i32 && VT2 == MVT::i64 && Subtarget->is64Bit();
20654 }
20655
20656 bool X86TargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
20657   EVT VT1 = Val.getValueType();
20658   if (isZExtFree(VT1, VT2))
20659     return true;
20660
20661   if (Val.getOpcode() != ISD::LOAD)
20662     return false;
20663
20664   if (!VT1.isSimple() || !VT1.isInteger() ||
20665       !VT2.isSimple() || !VT2.isInteger())
20666     return false;
20667
20668   switch (VT1.getSimpleVT().SimpleTy) {
20669   default: break;
20670   case MVT::i8:
20671   case MVT::i16:
20672   case MVT::i32:
20673     // X86 has 8, 16, and 32-bit zero-extending loads.
20674     return true;
20675   }
20676
20677   return false;
20678 }
20679
20680 bool X86TargetLowering::isVectorLoadExtDesirable(SDValue) const { return true; }
20681
20682 bool
20683 X86TargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
20684   if (!(Subtarget->hasFMA() || Subtarget->hasFMA4()))
20685     return false;
20686
20687   VT = VT.getScalarType();
20688
20689   if (!VT.isSimple())
20690     return false;
20691
20692   switch (VT.getSimpleVT().SimpleTy) {
20693   case MVT::f32:
20694   case MVT::f64:
20695     return true;
20696   default:
20697     break;
20698   }
20699
20700   return false;
20701 }
20702
20703 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
20704   // i16 instructions are longer (0x66 prefix) and potentially slower.
20705   return !(VT1 == MVT::i32 && VT2 == MVT::i16);
20706 }
20707
20708 /// isShuffleMaskLegal - Targets can use this to indicate that they only
20709 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
20710 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
20711 /// are assumed to be legal.
20712 bool
20713 X86TargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
20714                                       EVT VT) const {
20715   if (!VT.isSimple())
20716     return false;
20717
20718   MVT SVT = VT.getSimpleVT();
20719
20720   // Very little shuffling can be done for 64-bit vectors right now.
20721   if (VT.getSizeInBits() == 64)
20722     return false;
20723
20724   // This is an experimental legality test that is tailored to match the
20725   // legality test of the experimental lowering more closely. They are gated
20726   // separately to ease testing of performance differences.
20727   if (ExperimentalVectorShuffleLegality)
20728     // We only care that the types being shuffled are legal. The lowering can
20729     // handle any possible shuffle mask that results.
20730     return isTypeLegal(SVT);
20731
20732   // If this is a single-input shuffle with no 128 bit lane crossings we can
20733   // lower it into pshufb.
20734   if ((SVT.is128BitVector() && Subtarget->hasSSSE3()) ||
20735       (SVT.is256BitVector() && Subtarget->hasInt256())) {
20736     bool isLegal = true;
20737     for (unsigned I = 0, E = M.size(); I != E; ++I) {
20738       if (M[I] >= (int)SVT.getVectorNumElements() ||
20739           ShuffleCrosses128bitLane(SVT, I, M[I])) {
20740         isLegal = false;
20741         break;
20742       }
20743     }
20744     if (isLegal)
20745       return true;
20746   }
20747
20748   // FIXME: blends, shifts.
20749   return (SVT.getVectorNumElements() == 2 ||
20750           ShuffleVectorSDNode::isSplatMask(&M[0], VT) ||
20751           isMOVLMask(M, SVT) ||
20752           isCommutedMOVLMask(M, SVT) ||
20753           isMOVHLPSMask(M, SVT) ||
20754           isSHUFPMask(M, SVT) ||
20755           isSHUFPMask(M, SVT, /* Commuted */ true) ||
20756           isPSHUFDMask(M, SVT) ||
20757           isPSHUFDMask(M, SVT, /* SecondOperand */ true) ||
20758           isPSHUFHWMask(M, SVT, Subtarget->hasInt256()) ||
20759           isPSHUFLWMask(M, SVT, Subtarget->hasInt256()) ||
20760           isPALIGNRMask(M, SVT, Subtarget) ||
20761           isUNPCKLMask(M, SVT, Subtarget->hasInt256()) ||
20762           isUNPCKHMask(M, SVT, Subtarget->hasInt256()) ||
20763           isUNPCKL_v_undef_Mask(M, SVT, Subtarget->hasInt256()) ||
20764           isUNPCKH_v_undef_Mask(M, SVT, Subtarget->hasInt256()) ||
20765           isBlendMask(M, SVT, Subtarget->hasSSE41(), Subtarget->hasInt256()) ||
20766           (Subtarget->hasSSE41() && isINSERTPSMask(M, SVT)));
20767 }
20768
20769 bool
20770 X86TargetLowering::isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
20771                                           EVT VT) const {
20772   if (!VT.isSimple())
20773     return false;
20774
20775   MVT SVT = VT.getSimpleVT();
20776
20777   // This is an experimental legality test that is tailored to match the
20778   // legality test of the experimental lowering more closely. They are gated
20779   // separately to ease testing of performance differences.
20780   if (ExperimentalVectorShuffleLegality)
20781     // The new vector shuffle lowering is very good at managing zero-inputs.
20782     return isShuffleMaskLegal(Mask, VT);
20783
20784   unsigned NumElts = SVT.getVectorNumElements();
20785   // FIXME: This collection of masks seems suspect.
20786   if (NumElts == 2)
20787     return true;
20788   if (NumElts == 4 && SVT.is128BitVector()) {
20789     return (isMOVLMask(Mask, SVT)  ||
20790             isCommutedMOVLMask(Mask, SVT, true) ||
20791             isSHUFPMask(Mask, SVT) ||
20792             isSHUFPMask(Mask, SVT, /* Commuted */ true) ||
20793             isBlendMask(Mask, SVT, Subtarget->hasSSE41(),
20794                         Subtarget->hasInt256()));
20795   }
20796   return false;
20797 }
20798
20799 //===----------------------------------------------------------------------===//
20800 //                           X86 Scheduler Hooks
20801 //===----------------------------------------------------------------------===//
20802
20803 /// Utility function to emit xbegin specifying the start of an RTM region.
20804 static MachineBasicBlock *EmitXBegin(MachineInstr *MI, MachineBasicBlock *MBB,
20805                                      const TargetInstrInfo *TII) {
20806   DebugLoc DL = MI->getDebugLoc();
20807
20808   const BasicBlock *BB = MBB->getBasicBlock();
20809   MachineFunction::iterator I = MBB;
20810   ++I;
20811
20812   // For the v = xbegin(), we generate
20813   //
20814   // thisMBB:
20815   //  xbegin sinkMBB
20816   //
20817   // mainMBB:
20818   //  eax = -1
20819   //
20820   // sinkMBB:
20821   //  v = eax
20822
20823   MachineBasicBlock *thisMBB = MBB;
20824   MachineFunction *MF = MBB->getParent();
20825   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
20826   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
20827   MF->insert(I, mainMBB);
20828   MF->insert(I, sinkMBB);
20829
20830   // Transfer the remainder of BB and its successor edges to sinkMBB.
20831   sinkMBB->splice(sinkMBB->begin(), MBB,
20832                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
20833   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
20834
20835   // thisMBB:
20836   //  xbegin sinkMBB
20837   //  # fallthrough to mainMBB
20838   //  # abortion to sinkMBB
20839   BuildMI(thisMBB, DL, TII->get(X86::XBEGIN_4)).addMBB(sinkMBB);
20840   thisMBB->addSuccessor(mainMBB);
20841   thisMBB->addSuccessor(sinkMBB);
20842
20843   // mainMBB:
20844   //  EAX = -1
20845   BuildMI(mainMBB, DL, TII->get(X86::MOV32ri), X86::EAX).addImm(-1);
20846   mainMBB->addSuccessor(sinkMBB);
20847
20848   // sinkMBB:
20849   // EAX is live into the sinkMBB
20850   sinkMBB->addLiveIn(X86::EAX);
20851   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
20852           TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20853     .addReg(X86::EAX);
20854
20855   MI->eraseFromParent();
20856   return sinkMBB;
20857 }
20858
20859 // FIXME: When we get size specific XMM0 registers, i.e. XMM0_V16I8
20860 // or XMM0_V32I8 in AVX all of this code can be replaced with that
20861 // in the .td file.
20862 static MachineBasicBlock *EmitPCMPSTRM(MachineInstr *MI, MachineBasicBlock *BB,
20863                                        const TargetInstrInfo *TII) {
20864   unsigned Opc;
20865   switch (MI->getOpcode()) {
20866   default: llvm_unreachable("illegal opcode!");
20867   case X86::PCMPISTRM128REG:  Opc = X86::PCMPISTRM128rr;  break;
20868   case X86::VPCMPISTRM128REG: Opc = X86::VPCMPISTRM128rr; break;
20869   case X86::PCMPISTRM128MEM:  Opc = X86::PCMPISTRM128rm;  break;
20870   case X86::VPCMPISTRM128MEM: Opc = X86::VPCMPISTRM128rm; break;
20871   case X86::PCMPESTRM128REG:  Opc = X86::PCMPESTRM128rr;  break;
20872   case X86::VPCMPESTRM128REG: Opc = X86::VPCMPESTRM128rr; break;
20873   case X86::PCMPESTRM128MEM:  Opc = X86::PCMPESTRM128rm;  break;
20874   case X86::VPCMPESTRM128MEM: Opc = X86::VPCMPESTRM128rm; break;
20875   }
20876
20877   DebugLoc dl = MI->getDebugLoc();
20878   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
20879
20880   unsigned NumArgs = MI->getNumOperands();
20881   for (unsigned i = 1; i < NumArgs; ++i) {
20882     MachineOperand &Op = MI->getOperand(i);
20883     if (!(Op.isReg() && Op.isImplicit()))
20884       MIB.addOperand(Op);
20885   }
20886   if (MI->hasOneMemOperand())
20887     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
20888
20889   BuildMI(*BB, MI, dl,
20890     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20891     .addReg(X86::XMM0);
20892
20893   MI->eraseFromParent();
20894   return BB;
20895 }
20896
20897 // FIXME: Custom handling because TableGen doesn't support multiple implicit
20898 // defs in an instruction pattern
20899 static MachineBasicBlock *EmitPCMPSTRI(MachineInstr *MI, MachineBasicBlock *BB,
20900                                        const TargetInstrInfo *TII) {
20901   unsigned Opc;
20902   switch (MI->getOpcode()) {
20903   default: llvm_unreachable("illegal opcode!");
20904   case X86::PCMPISTRIREG:  Opc = X86::PCMPISTRIrr;  break;
20905   case X86::VPCMPISTRIREG: Opc = X86::VPCMPISTRIrr; break;
20906   case X86::PCMPISTRIMEM:  Opc = X86::PCMPISTRIrm;  break;
20907   case X86::VPCMPISTRIMEM: Opc = X86::VPCMPISTRIrm; break;
20908   case X86::PCMPESTRIREG:  Opc = X86::PCMPESTRIrr;  break;
20909   case X86::VPCMPESTRIREG: Opc = X86::VPCMPESTRIrr; break;
20910   case X86::PCMPESTRIMEM:  Opc = X86::PCMPESTRIrm;  break;
20911   case X86::VPCMPESTRIMEM: Opc = X86::VPCMPESTRIrm; break;
20912   }
20913
20914   DebugLoc dl = MI->getDebugLoc();
20915   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
20916
20917   unsigned NumArgs = MI->getNumOperands(); // remove the results
20918   for (unsigned i = 1; i < NumArgs; ++i) {
20919     MachineOperand &Op = MI->getOperand(i);
20920     if (!(Op.isReg() && Op.isImplicit()))
20921       MIB.addOperand(Op);
20922   }
20923   if (MI->hasOneMemOperand())
20924     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
20925
20926   BuildMI(*BB, MI, dl,
20927     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20928     .addReg(X86::ECX);
20929
20930   MI->eraseFromParent();
20931   return BB;
20932 }
20933
20934 static MachineBasicBlock *EmitMonitor(MachineInstr *MI, MachineBasicBlock *BB,
20935                                       const X86Subtarget *Subtarget) {
20936   DebugLoc dl = MI->getDebugLoc();
20937   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
20938   // Address into RAX/EAX, other two args into ECX, EDX.
20939   unsigned MemOpc = Subtarget->is64Bit() ? X86::LEA64r : X86::LEA32r;
20940   unsigned MemReg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
20941   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(MemOpc), MemReg);
20942   for (int i = 0; i < X86::AddrNumOperands; ++i)
20943     MIB.addOperand(MI->getOperand(i));
20944
20945   unsigned ValOps = X86::AddrNumOperands;
20946   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::ECX)
20947     .addReg(MI->getOperand(ValOps).getReg());
20948   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::EDX)
20949     .addReg(MI->getOperand(ValOps+1).getReg());
20950
20951   // The instruction doesn't actually take any operands though.
20952   BuildMI(*BB, MI, dl, TII->get(X86::MONITORrrr));
20953
20954   MI->eraseFromParent(); // The pseudo is gone now.
20955   return BB;
20956 }
20957
20958 MachineBasicBlock *
20959 X86TargetLowering::EmitVAARG64WithCustomInserter(MachineInstr *MI,
20960                                                  MachineBasicBlock *MBB) const {
20961   // Emit va_arg instruction on X86-64.
20962
20963   // Operands to this pseudo-instruction:
20964   // 0  ) Output        : destination address (reg)
20965   // 1-5) Input         : va_list address (addr, i64mem)
20966   // 6  ) ArgSize       : Size (in bytes) of vararg type
20967   // 7  ) ArgMode       : 0=overflow only, 1=use gp_offset, 2=use fp_offset
20968   // 8  ) Align         : Alignment of type
20969   // 9  ) EFLAGS (implicit-def)
20970
20971   assert(MI->getNumOperands() == 10 && "VAARG_64 should have 10 operands!");
20972   assert(X86::AddrNumOperands == 5 && "VAARG_64 assumes 5 address operands");
20973
20974   unsigned DestReg = MI->getOperand(0).getReg();
20975   MachineOperand &Base = MI->getOperand(1);
20976   MachineOperand &Scale = MI->getOperand(2);
20977   MachineOperand &Index = MI->getOperand(3);
20978   MachineOperand &Disp = MI->getOperand(4);
20979   MachineOperand &Segment = MI->getOperand(5);
20980   unsigned ArgSize = MI->getOperand(6).getImm();
20981   unsigned ArgMode = MI->getOperand(7).getImm();
20982   unsigned Align = MI->getOperand(8).getImm();
20983
20984   // Memory Reference
20985   assert(MI->hasOneMemOperand() && "Expected VAARG_64 to have one memoperand");
20986   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
20987   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
20988
20989   // Machine Information
20990   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
20991   MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
20992   const TargetRegisterClass *AddrRegClass = getRegClassFor(MVT::i64);
20993   const TargetRegisterClass *OffsetRegClass = getRegClassFor(MVT::i32);
20994   DebugLoc DL = MI->getDebugLoc();
20995
20996   // struct va_list {
20997   //   i32   gp_offset
20998   //   i32   fp_offset
20999   //   i64   overflow_area (address)
21000   //   i64   reg_save_area (address)
21001   // }
21002   // sizeof(va_list) = 24
21003   // alignment(va_list) = 8
21004
21005   unsigned TotalNumIntRegs = 6;
21006   unsigned TotalNumXMMRegs = 8;
21007   bool UseGPOffset = (ArgMode == 1);
21008   bool UseFPOffset = (ArgMode == 2);
21009   unsigned MaxOffset = TotalNumIntRegs * 8 +
21010                        (UseFPOffset ? TotalNumXMMRegs * 16 : 0);
21011
21012   /* Align ArgSize to a multiple of 8 */
21013   unsigned ArgSizeA8 = (ArgSize + 7) & ~7;
21014   bool NeedsAlign = (Align > 8);
21015
21016   MachineBasicBlock *thisMBB = MBB;
21017   MachineBasicBlock *overflowMBB;
21018   MachineBasicBlock *offsetMBB;
21019   MachineBasicBlock *endMBB;
21020
21021   unsigned OffsetDestReg = 0;    // Argument address computed by offsetMBB
21022   unsigned OverflowDestReg = 0;  // Argument address computed by overflowMBB
21023   unsigned OffsetReg = 0;
21024
21025   if (!UseGPOffset && !UseFPOffset) {
21026     // If we only pull from the overflow region, we don't create a branch.
21027     // We don't need to alter control flow.
21028     OffsetDestReg = 0; // unused
21029     OverflowDestReg = DestReg;
21030
21031     offsetMBB = nullptr;
21032     overflowMBB = thisMBB;
21033     endMBB = thisMBB;
21034   } else {
21035     // First emit code to check if gp_offset (or fp_offset) is below the bound.
21036     // If so, pull the argument from reg_save_area. (branch to offsetMBB)
21037     // If not, pull from overflow_area. (branch to overflowMBB)
21038     //
21039     //       thisMBB
21040     //         |     .
21041     //         |        .
21042     //     offsetMBB   overflowMBB
21043     //         |        .
21044     //         |     .
21045     //        endMBB
21046
21047     // Registers for the PHI in endMBB
21048     OffsetDestReg = MRI.createVirtualRegister(AddrRegClass);
21049     OverflowDestReg = MRI.createVirtualRegister(AddrRegClass);
21050
21051     const BasicBlock *LLVM_BB = MBB->getBasicBlock();
21052     MachineFunction *MF = MBB->getParent();
21053     overflowMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21054     offsetMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21055     endMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21056
21057     MachineFunction::iterator MBBIter = MBB;
21058     ++MBBIter;
21059
21060     // Insert the new basic blocks
21061     MF->insert(MBBIter, offsetMBB);
21062     MF->insert(MBBIter, overflowMBB);
21063     MF->insert(MBBIter, endMBB);
21064
21065     // Transfer the remainder of MBB and its successor edges to endMBB.
21066     endMBB->splice(endMBB->begin(), thisMBB,
21067                    std::next(MachineBasicBlock::iterator(MI)), thisMBB->end());
21068     endMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
21069
21070     // Make offsetMBB and overflowMBB successors of thisMBB
21071     thisMBB->addSuccessor(offsetMBB);
21072     thisMBB->addSuccessor(overflowMBB);
21073
21074     // endMBB is a successor of both offsetMBB and overflowMBB
21075     offsetMBB->addSuccessor(endMBB);
21076     overflowMBB->addSuccessor(endMBB);
21077
21078     // Load the offset value into a register
21079     OffsetReg = MRI.createVirtualRegister(OffsetRegClass);
21080     BuildMI(thisMBB, DL, TII->get(X86::MOV32rm), OffsetReg)
21081       .addOperand(Base)
21082       .addOperand(Scale)
21083       .addOperand(Index)
21084       .addDisp(Disp, UseFPOffset ? 4 : 0)
21085       .addOperand(Segment)
21086       .setMemRefs(MMOBegin, MMOEnd);
21087
21088     // Check if there is enough room left to pull this argument.
21089     BuildMI(thisMBB, DL, TII->get(X86::CMP32ri))
21090       .addReg(OffsetReg)
21091       .addImm(MaxOffset + 8 - ArgSizeA8);
21092
21093     // Branch to "overflowMBB" if offset >= max
21094     // Fall through to "offsetMBB" otherwise
21095     BuildMI(thisMBB, DL, TII->get(X86::GetCondBranchFromCond(X86::COND_AE)))
21096       .addMBB(overflowMBB);
21097   }
21098
21099   // In offsetMBB, emit code to use the reg_save_area.
21100   if (offsetMBB) {
21101     assert(OffsetReg != 0);
21102
21103     // Read the reg_save_area address.
21104     unsigned RegSaveReg = MRI.createVirtualRegister(AddrRegClass);
21105     BuildMI(offsetMBB, DL, TII->get(X86::MOV64rm), RegSaveReg)
21106       .addOperand(Base)
21107       .addOperand(Scale)
21108       .addOperand(Index)
21109       .addDisp(Disp, 16)
21110       .addOperand(Segment)
21111       .setMemRefs(MMOBegin, MMOEnd);
21112
21113     // Zero-extend the offset
21114     unsigned OffsetReg64 = MRI.createVirtualRegister(AddrRegClass);
21115       BuildMI(offsetMBB, DL, TII->get(X86::SUBREG_TO_REG), OffsetReg64)
21116         .addImm(0)
21117         .addReg(OffsetReg)
21118         .addImm(X86::sub_32bit);
21119
21120     // Add the offset to the reg_save_area to get the final address.
21121     BuildMI(offsetMBB, DL, TII->get(X86::ADD64rr), OffsetDestReg)
21122       .addReg(OffsetReg64)
21123       .addReg(RegSaveReg);
21124
21125     // Compute the offset for the next argument
21126     unsigned NextOffsetReg = MRI.createVirtualRegister(OffsetRegClass);
21127     BuildMI(offsetMBB, DL, TII->get(X86::ADD32ri), NextOffsetReg)
21128       .addReg(OffsetReg)
21129       .addImm(UseFPOffset ? 16 : 8);
21130
21131     // Store it back into the va_list.
21132     BuildMI(offsetMBB, DL, TII->get(X86::MOV32mr))
21133       .addOperand(Base)
21134       .addOperand(Scale)
21135       .addOperand(Index)
21136       .addDisp(Disp, UseFPOffset ? 4 : 0)
21137       .addOperand(Segment)
21138       .addReg(NextOffsetReg)
21139       .setMemRefs(MMOBegin, MMOEnd);
21140
21141     // Jump to endMBB
21142     BuildMI(offsetMBB, DL, TII->get(X86::JMP_1))
21143       .addMBB(endMBB);
21144   }
21145
21146   //
21147   // Emit code to use overflow area
21148   //
21149
21150   // Load the overflow_area address into a register.
21151   unsigned OverflowAddrReg = MRI.createVirtualRegister(AddrRegClass);
21152   BuildMI(overflowMBB, DL, TII->get(X86::MOV64rm), OverflowAddrReg)
21153     .addOperand(Base)
21154     .addOperand(Scale)
21155     .addOperand(Index)
21156     .addDisp(Disp, 8)
21157     .addOperand(Segment)
21158     .setMemRefs(MMOBegin, MMOEnd);
21159
21160   // If we need to align it, do so. Otherwise, just copy the address
21161   // to OverflowDestReg.
21162   if (NeedsAlign) {
21163     // Align the overflow address
21164     assert((Align & (Align-1)) == 0 && "Alignment must be a power of 2");
21165     unsigned TmpReg = MRI.createVirtualRegister(AddrRegClass);
21166
21167     // aligned_addr = (addr + (align-1)) & ~(align-1)
21168     BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), TmpReg)
21169       .addReg(OverflowAddrReg)
21170       .addImm(Align-1);
21171
21172     BuildMI(overflowMBB, DL, TII->get(X86::AND64ri32), OverflowDestReg)
21173       .addReg(TmpReg)
21174       .addImm(~(uint64_t)(Align-1));
21175   } else {
21176     BuildMI(overflowMBB, DL, TII->get(TargetOpcode::COPY), OverflowDestReg)
21177       .addReg(OverflowAddrReg);
21178   }
21179
21180   // Compute the next overflow address after this argument.
21181   // (the overflow address should be kept 8-byte aligned)
21182   unsigned NextAddrReg = MRI.createVirtualRegister(AddrRegClass);
21183   BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), NextAddrReg)
21184     .addReg(OverflowDestReg)
21185     .addImm(ArgSizeA8);
21186
21187   // Store the new overflow address.
21188   BuildMI(overflowMBB, DL, TII->get(X86::MOV64mr))
21189     .addOperand(Base)
21190     .addOperand(Scale)
21191     .addOperand(Index)
21192     .addDisp(Disp, 8)
21193     .addOperand(Segment)
21194     .addReg(NextAddrReg)
21195     .setMemRefs(MMOBegin, MMOEnd);
21196
21197   // If we branched, emit the PHI to the front of endMBB.
21198   if (offsetMBB) {
21199     BuildMI(*endMBB, endMBB->begin(), DL,
21200             TII->get(X86::PHI), DestReg)
21201       .addReg(OffsetDestReg).addMBB(offsetMBB)
21202       .addReg(OverflowDestReg).addMBB(overflowMBB);
21203   }
21204
21205   // Erase the pseudo instruction
21206   MI->eraseFromParent();
21207
21208   return endMBB;
21209 }
21210
21211 MachineBasicBlock *
21212 X86TargetLowering::EmitVAStartSaveXMMRegsWithCustomInserter(
21213                                                  MachineInstr *MI,
21214                                                  MachineBasicBlock *MBB) const {
21215   // Emit code to save XMM registers to the stack. The ABI says that the
21216   // number of registers to save is given in %al, so it's theoretically
21217   // possible to do an indirect jump trick to avoid saving all of them,
21218   // however this code takes a simpler approach and just executes all
21219   // of the stores if %al is non-zero. It's less code, and it's probably
21220   // easier on the hardware branch predictor, and stores aren't all that
21221   // expensive anyway.
21222
21223   // Create the new basic blocks. One block contains all the XMM stores,
21224   // and one block is the final destination regardless of whether any
21225   // stores were performed.
21226   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
21227   MachineFunction *F = MBB->getParent();
21228   MachineFunction::iterator MBBIter = MBB;
21229   ++MBBIter;
21230   MachineBasicBlock *XMMSaveMBB = F->CreateMachineBasicBlock(LLVM_BB);
21231   MachineBasicBlock *EndMBB = F->CreateMachineBasicBlock(LLVM_BB);
21232   F->insert(MBBIter, XMMSaveMBB);
21233   F->insert(MBBIter, EndMBB);
21234
21235   // Transfer the remainder of MBB and its successor edges to EndMBB.
21236   EndMBB->splice(EndMBB->begin(), MBB,
21237                  std::next(MachineBasicBlock::iterator(MI)), MBB->end());
21238   EndMBB->transferSuccessorsAndUpdatePHIs(MBB);
21239
21240   // The original block will now fall through to the XMM save block.
21241   MBB->addSuccessor(XMMSaveMBB);
21242   // The XMMSaveMBB will fall through to the end block.
21243   XMMSaveMBB->addSuccessor(EndMBB);
21244
21245   // Now add the instructions.
21246   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21247   DebugLoc DL = MI->getDebugLoc();
21248
21249   unsigned CountReg = MI->getOperand(0).getReg();
21250   int64_t RegSaveFrameIndex = MI->getOperand(1).getImm();
21251   int64_t VarArgsFPOffset = MI->getOperand(2).getImm();
21252
21253   if (!Subtarget->isTargetWin64()) {
21254     // If %al is 0, branch around the XMM save block.
21255     BuildMI(MBB, DL, TII->get(X86::TEST8rr)).addReg(CountReg).addReg(CountReg);
21256     BuildMI(MBB, DL, TII->get(X86::JE_1)).addMBB(EndMBB);
21257     MBB->addSuccessor(EndMBB);
21258   }
21259
21260   // Make sure the last operand is EFLAGS, which gets clobbered by the branch
21261   // that was just emitted, but clearly shouldn't be "saved".
21262   assert((MI->getNumOperands() <= 3 ||
21263           !MI->getOperand(MI->getNumOperands() - 1).isReg() ||
21264           MI->getOperand(MI->getNumOperands() - 1).getReg() == X86::EFLAGS)
21265          && "Expected last argument to be EFLAGS");
21266   unsigned MOVOpc = Subtarget->hasFp256() ? X86::VMOVAPSmr : X86::MOVAPSmr;
21267   // In the XMM save block, save all the XMM argument registers.
21268   for (int i = 3, e = MI->getNumOperands() - 1; i != e; ++i) {
21269     int64_t Offset = (i - 3) * 16 + VarArgsFPOffset;
21270     MachineMemOperand *MMO =
21271       F->getMachineMemOperand(
21272           MachinePointerInfo::getFixedStack(RegSaveFrameIndex, Offset),
21273         MachineMemOperand::MOStore,
21274         /*Size=*/16, /*Align=*/16);
21275     BuildMI(XMMSaveMBB, DL, TII->get(MOVOpc))
21276       .addFrameIndex(RegSaveFrameIndex)
21277       .addImm(/*Scale=*/1)
21278       .addReg(/*IndexReg=*/0)
21279       .addImm(/*Disp=*/Offset)
21280       .addReg(/*Segment=*/0)
21281       .addReg(MI->getOperand(i).getReg())
21282       .addMemOperand(MMO);
21283   }
21284
21285   MI->eraseFromParent();   // The pseudo instruction is gone now.
21286
21287   return EndMBB;
21288 }
21289
21290 // The EFLAGS operand of SelectItr might be missing a kill marker
21291 // because there were multiple uses of EFLAGS, and ISel didn't know
21292 // which to mark. Figure out whether SelectItr should have had a
21293 // kill marker, and set it if it should. Returns the correct kill
21294 // marker value.
21295 static bool checkAndUpdateEFLAGSKill(MachineBasicBlock::iterator SelectItr,
21296                                      MachineBasicBlock* BB,
21297                                      const TargetRegisterInfo* TRI) {
21298   // Scan forward through BB for a use/def of EFLAGS.
21299   MachineBasicBlock::iterator miI(std::next(SelectItr));
21300   for (MachineBasicBlock::iterator miE = BB->end(); miI != miE; ++miI) {
21301     const MachineInstr& mi = *miI;
21302     if (mi.readsRegister(X86::EFLAGS))
21303       return false;
21304     if (mi.definesRegister(X86::EFLAGS))
21305       break; // Should have kill-flag - update below.
21306   }
21307
21308   // If we hit the end of the block, check whether EFLAGS is live into a
21309   // successor.
21310   if (miI == BB->end()) {
21311     for (MachineBasicBlock::succ_iterator sItr = BB->succ_begin(),
21312                                           sEnd = BB->succ_end();
21313          sItr != sEnd; ++sItr) {
21314       MachineBasicBlock* succ = *sItr;
21315       if (succ->isLiveIn(X86::EFLAGS))
21316         return false;
21317     }
21318   }
21319
21320   // We found a def, or hit the end of the basic block and EFLAGS wasn't live
21321   // out. SelectMI should have a kill flag on EFLAGS.
21322   SelectItr->addRegisterKilled(X86::EFLAGS, TRI);
21323   return true;
21324 }
21325
21326 MachineBasicBlock *
21327 X86TargetLowering::EmitLoweredSelect(MachineInstr *MI,
21328                                      MachineBasicBlock *BB) const {
21329   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21330   DebugLoc DL = MI->getDebugLoc();
21331
21332   // To "insert" a SELECT_CC instruction, we actually have to insert the
21333   // diamond control-flow pattern.  The incoming instruction knows the
21334   // destination vreg to set, the condition code register to branch on, the
21335   // true/false values to select between, and a branch opcode to use.
21336   const BasicBlock *LLVM_BB = BB->getBasicBlock();
21337   MachineFunction::iterator It = BB;
21338   ++It;
21339
21340   //  thisMBB:
21341   //  ...
21342   //   TrueVal = ...
21343   //   cmpTY ccX, r1, r2
21344   //   bCC copy1MBB
21345   //   fallthrough --> copy0MBB
21346   MachineBasicBlock *thisMBB = BB;
21347   MachineFunction *F = BB->getParent();
21348   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
21349   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
21350   F->insert(It, copy0MBB);
21351   F->insert(It, sinkMBB);
21352
21353   // If the EFLAGS register isn't dead in the terminator, then claim that it's
21354   // live into the sink and copy blocks.
21355   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
21356   if (!MI->killsRegister(X86::EFLAGS) &&
21357       !checkAndUpdateEFLAGSKill(MI, BB, TRI)) {
21358     copy0MBB->addLiveIn(X86::EFLAGS);
21359     sinkMBB->addLiveIn(X86::EFLAGS);
21360   }
21361
21362   // Transfer the remainder of BB and its successor edges to sinkMBB.
21363   sinkMBB->splice(sinkMBB->begin(), BB,
21364                   std::next(MachineBasicBlock::iterator(MI)), BB->end());
21365   sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
21366
21367   // Add the true and fallthrough blocks as its successors.
21368   BB->addSuccessor(copy0MBB);
21369   BB->addSuccessor(sinkMBB);
21370
21371   // Create the conditional branch instruction.
21372   unsigned Opc =
21373     X86::GetCondBranchFromCond((X86::CondCode)MI->getOperand(3).getImm());
21374   BuildMI(BB, DL, TII->get(Opc)).addMBB(sinkMBB);
21375
21376   //  copy0MBB:
21377   //   %FalseValue = ...
21378   //   # fallthrough to sinkMBB
21379   copy0MBB->addSuccessor(sinkMBB);
21380
21381   //  sinkMBB:
21382   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
21383   //  ...
21384   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
21385           TII->get(X86::PHI), MI->getOperand(0).getReg())
21386     .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
21387     .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
21388
21389   MI->eraseFromParent();   // The pseudo instruction is gone now.
21390   return sinkMBB;
21391 }
21392
21393 MachineBasicBlock *
21394 X86TargetLowering::EmitLoweredSegAlloca(MachineInstr *MI,
21395                                         MachineBasicBlock *BB) const {
21396   MachineFunction *MF = BB->getParent();
21397   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21398   DebugLoc DL = MI->getDebugLoc();
21399   const BasicBlock *LLVM_BB = BB->getBasicBlock();
21400
21401   assert(MF->shouldSplitStack());
21402
21403   const bool Is64Bit = Subtarget->is64Bit();
21404   const bool IsLP64 = Subtarget->isTarget64BitLP64();
21405
21406   const unsigned TlsReg = Is64Bit ? X86::FS : X86::GS;
21407   const unsigned TlsOffset = IsLP64 ? 0x70 : Is64Bit ? 0x40 : 0x30;
21408
21409   // BB:
21410   //  ... [Till the alloca]
21411   // If stacklet is not large enough, jump to mallocMBB
21412   //
21413   // bumpMBB:
21414   //  Allocate by subtracting from RSP
21415   //  Jump to continueMBB
21416   //
21417   // mallocMBB:
21418   //  Allocate by call to runtime
21419   //
21420   // continueMBB:
21421   //  ...
21422   //  [rest of original BB]
21423   //
21424
21425   MachineBasicBlock *mallocMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21426   MachineBasicBlock *bumpMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21427   MachineBasicBlock *continueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21428
21429   MachineRegisterInfo &MRI = MF->getRegInfo();
21430   const TargetRegisterClass *AddrRegClass =
21431     getRegClassFor(getPointerTy());
21432
21433   unsigned mallocPtrVReg = MRI.createVirtualRegister(AddrRegClass),
21434     bumpSPPtrVReg = MRI.createVirtualRegister(AddrRegClass),
21435     tmpSPVReg = MRI.createVirtualRegister(AddrRegClass),
21436     SPLimitVReg = MRI.createVirtualRegister(AddrRegClass),
21437     sizeVReg = MI->getOperand(1).getReg(),
21438     physSPReg = IsLP64 || Subtarget->isTargetNaCl64() ? X86::RSP : X86::ESP;
21439
21440   MachineFunction::iterator MBBIter = BB;
21441   ++MBBIter;
21442
21443   MF->insert(MBBIter, bumpMBB);
21444   MF->insert(MBBIter, mallocMBB);
21445   MF->insert(MBBIter, continueMBB);
21446
21447   continueMBB->splice(continueMBB->begin(), BB,
21448                       std::next(MachineBasicBlock::iterator(MI)), BB->end());
21449   continueMBB->transferSuccessorsAndUpdatePHIs(BB);
21450
21451   // Add code to the main basic block to check if the stack limit has been hit,
21452   // and if so, jump to mallocMBB otherwise to bumpMBB.
21453   BuildMI(BB, DL, TII->get(TargetOpcode::COPY), tmpSPVReg).addReg(physSPReg);
21454   BuildMI(BB, DL, TII->get(IsLP64 ? X86::SUB64rr:X86::SUB32rr), SPLimitVReg)
21455     .addReg(tmpSPVReg).addReg(sizeVReg);
21456   BuildMI(BB, DL, TII->get(IsLP64 ? X86::CMP64mr:X86::CMP32mr))
21457     .addReg(0).addImm(1).addReg(0).addImm(TlsOffset).addReg(TlsReg)
21458     .addReg(SPLimitVReg);
21459   BuildMI(BB, DL, TII->get(X86::JG_1)).addMBB(mallocMBB);
21460
21461   // bumpMBB simply decreases the stack pointer, since we know the current
21462   // stacklet has enough space.
21463   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), physSPReg)
21464     .addReg(SPLimitVReg);
21465   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), bumpSPPtrVReg)
21466     .addReg(SPLimitVReg);
21467   BuildMI(bumpMBB, DL, TII->get(X86::JMP_1)).addMBB(continueMBB);
21468
21469   // Calls into a routine in libgcc to allocate more space from the heap.
21470   const uint32_t *RegMask =
21471       Subtarget->getRegisterInfo()->getCallPreservedMask(CallingConv::C);
21472   if (IsLP64) {
21473     BuildMI(mallocMBB, DL, TII->get(X86::MOV64rr), X86::RDI)
21474       .addReg(sizeVReg);
21475     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
21476       .addExternalSymbol("__morestack_allocate_stack_space")
21477       .addRegMask(RegMask)
21478       .addReg(X86::RDI, RegState::Implicit)
21479       .addReg(X86::RAX, RegState::ImplicitDefine);
21480   } else if (Is64Bit) {
21481     BuildMI(mallocMBB, DL, TII->get(X86::MOV32rr), X86::EDI)
21482       .addReg(sizeVReg);
21483     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
21484       .addExternalSymbol("__morestack_allocate_stack_space")
21485       .addRegMask(RegMask)
21486       .addReg(X86::EDI, RegState::Implicit)
21487       .addReg(X86::EAX, RegState::ImplicitDefine);
21488   } else {
21489     BuildMI(mallocMBB, DL, TII->get(X86::SUB32ri), physSPReg).addReg(physSPReg)
21490       .addImm(12);
21491     BuildMI(mallocMBB, DL, TII->get(X86::PUSH32r)).addReg(sizeVReg);
21492     BuildMI(mallocMBB, DL, TII->get(X86::CALLpcrel32))
21493       .addExternalSymbol("__morestack_allocate_stack_space")
21494       .addRegMask(RegMask)
21495       .addReg(X86::EAX, RegState::ImplicitDefine);
21496   }
21497
21498   if (!Is64Bit)
21499     BuildMI(mallocMBB, DL, TII->get(X86::ADD32ri), physSPReg).addReg(physSPReg)
21500       .addImm(16);
21501
21502   BuildMI(mallocMBB, DL, TII->get(TargetOpcode::COPY), mallocPtrVReg)
21503     .addReg(IsLP64 ? X86::RAX : X86::EAX);
21504   BuildMI(mallocMBB, DL, TII->get(X86::JMP_1)).addMBB(continueMBB);
21505
21506   // Set up the CFG correctly.
21507   BB->addSuccessor(bumpMBB);
21508   BB->addSuccessor(mallocMBB);
21509   mallocMBB->addSuccessor(continueMBB);
21510   bumpMBB->addSuccessor(continueMBB);
21511
21512   // Take care of the PHI nodes.
21513   BuildMI(*continueMBB, continueMBB->begin(), DL, TII->get(X86::PHI),
21514           MI->getOperand(0).getReg())
21515     .addReg(mallocPtrVReg).addMBB(mallocMBB)
21516     .addReg(bumpSPPtrVReg).addMBB(bumpMBB);
21517
21518   // Delete the original pseudo instruction.
21519   MI->eraseFromParent();
21520
21521   // And we're done.
21522   return continueMBB;
21523 }
21524
21525 MachineBasicBlock *
21526 X86TargetLowering::EmitLoweredWinAlloca(MachineInstr *MI,
21527                                         MachineBasicBlock *BB) const {
21528   DebugLoc DL = MI->getDebugLoc();
21529
21530   assert(!Subtarget->isTargetMachO());
21531
21532   X86FrameLowering::emitStackProbeCall(*BB->getParent(), *BB, MI, DL);
21533
21534   MI->eraseFromParent();   // The pseudo instruction is gone now.
21535   return BB;
21536 }
21537
21538 MachineBasicBlock *
21539 X86TargetLowering::EmitLoweredTLSCall(MachineInstr *MI,
21540                                       MachineBasicBlock *BB) const {
21541   // This is pretty easy.  We're taking the value that we received from
21542   // our load from the relocation, sticking it in either RDI (x86-64)
21543   // or EAX and doing an indirect call.  The return value will then
21544   // be in the normal return register.
21545   MachineFunction *F = BB->getParent();
21546   const X86InstrInfo *TII = Subtarget->getInstrInfo();
21547   DebugLoc DL = MI->getDebugLoc();
21548
21549   assert(Subtarget->isTargetDarwin() && "Darwin only instr emitted?");
21550   assert(MI->getOperand(3).isGlobal() && "This should be a global");
21551
21552   // Get a register mask for the lowered call.
21553   // FIXME: The 32-bit calls have non-standard calling conventions. Use a
21554   // proper register mask.
21555   const uint32_t *RegMask =
21556       Subtarget->getRegisterInfo()->getCallPreservedMask(CallingConv::C);
21557   if (Subtarget->is64Bit()) {
21558     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21559                                       TII->get(X86::MOV64rm), X86::RDI)
21560     .addReg(X86::RIP)
21561     .addImm(0).addReg(0)
21562     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21563                       MI->getOperand(3).getTargetFlags())
21564     .addReg(0);
21565     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL64m));
21566     addDirectMem(MIB, X86::RDI);
21567     MIB.addReg(X86::RAX, RegState::ImplicitDefine).addRegMask(RegMask);
21568   } else if (F->getTarget().getRelocationModel() != Reloc::PIC_) {
21569     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21570                                       TII->get(X86::MOV32rm), X86::EAX)
21571     .addReg(0)
21572     .addImm(0).addReg(0)
21573     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21574                       MI->getOperand(3).getTargetFlags())
21575     .addReg(0);
21576     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
21577     addDirectMem(MIB, X86::EAX);
21578     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
21579   } else {
21580     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21581                                       TII->get(X86::MOV32rm), X86::EAX)
21582     .addReg(TII->getGlobalBaseReg(F))
21583     .addImm(0).addReg(0)
21584     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21585                       MI->getOperand(3).getTargetFlags())
21586     .addReg(0);
21587     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
21588     addDirectMem(MIB, X86::EAX);
21589     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
21590   }
21591
21592   MI->eraseFromParent(); // The pseudo instruction is gone now.
21593   return BB;
21594 }
21595
21596 MachineBasicBlock *
21597 X86TargetLowering::emitEHSjLjSetJmp(MachineInstr *MI,
21598                                     MachineBasicBlock *MBB) const {
21599   DebugLoc DL = MI->getDebugLoc();
21600   MachineFunction *MF = MBB->getParent();
21601   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21602   MachineRegisterInfo &MRI = MF->getRegInfo();
21603
21604   const BasicBlock *BB = MBB->getBasicBlock();
21605   MachineFunction::iterator I = MBB;
21606   ++I;
21607
21608   // Memory Reference
21609   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
21610   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
21611
21612   unsigned DstReg;
21613   unsigned MemOpndSlot = 0;
21614
21615   unsigned CurOp = 0;
21616
21617   DstReg = MI->getOperand(CurOp++).getReg();
21618   const TargetRegisterClass *RC = MRI.getRegClass(DstReg);
21619   assert(RC->hasType(MVT::i32) && "Invalid destination!");
21620   unsigned mainDstReg = MRI.createVirtualRegister(RC);
21621   unsigned restoreDstReg = MRI.createVirtualRegister(RC);
21622
21623   MemOpndSlot = CurOp;
21624
21625   MVT PVT = getPointerTy();
21626   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
21627          "Invalid Pointer Size!");
21628
21629   // For v = setjmp(buf), we generate
21630   //
21631   // thisMBB:
21632   //  buf[LabelOffset] = restoreMBB
21633   //  SjLjSetup restoreMBB
21634   //
21635   // mainMBB:
21636   //  v_main = 0
21637   //
21638   // sinkMBB:
21639   //  v = phi(main, restore)
21640   //
21641   // restoreMBB:
21642   //  if base pointer being used, load it from frame
21643   //  v_restore = 1
21644
21645   MachineBasicBlock *thisMBB = MBB;
21646   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
21647   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
21648   MachineBasicBlock *restoreMBB = MF->CreateMachineBasicBlock(BB);
21649   MF->insert(I, mainMBB);
21650   MF->insert(I, sinkMBB);
21651   MF->push_back(restoreMBB);
21652
21653   MachineInstrBuilder MIB;
21654
21655   // Transfer the remainder of BB and its successor edges to sinkMBB.
21656   sinkMBB->splice(sinkMBB->begin(), MBB,
21657                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
21658   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
21659
21660   // thisMBB:
21661   unsigned PtrStoreOpc = 0;
21662   unsigned LabelReg = 0;
21663   const int64_t LabelOffset = 1 * PVT.getStoreSize();
21664   Reloc::Model RM = MF->getTarget().getRelocationModel();
21665   bool UseImmLabel = (MF->getTarget().getCodeModel() == CodeModel::Small) &&
21666                      (RM == Reloc::Static || RM == Reloc::DynamicNoPIC);
21667
21668   // Prepare IP either in reg or imm.
21669   if (!UseImmLabel) {
21670     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mr : X86::MOV32mr;
21671     const TargetRegisterClass *PtrRC = getRegClassFor(PVT);
21672     LabelReg = MRI.createVirtualRegister(PtrRC);
21673     if (Subtarget->is64Bit()) {
21674       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA64r), LabelReg)
21675               .addReg(X86::RIP)
21676               .addImm(0)
21677               .addReg(0)
21678               .addMBB(restoreMBB)
21679               .addReg(0);
21680     } else {
21681       const X86InstrInfo *XII = static_cast<const X86InstrInfo*>(TII);
21682       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA32r), LabelReg)
21683               .addReg(XII->getGlobalBaseReg(MF))
21684               .addImm(0)
21685               .addReg(0)
21686               .addMBB(restoreMBB, Subtarget->ClassifyBlockAddressReference())
21687               .addReg(0);
21688     }
21689   } else
21690     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mi32 : X86::MOV32mi;
21691   // Store IP
21692   MIB = BuildMI(*thisMBB, MI, DL, TII->get(PtrStoreOpc));
21693   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21694     if (i == X86::AddrDisp)
21695       MIB.addDisp(MI->getOperand(MemOpndSlot + i), LabelOffset);
21696     else
21697       MIB.addOperand(MI->getOperand(MemOpndSlot + i));
21698   }
21699   if (!UseImmLabel)
21700     MIB.addReg(LabelReg);
21701   else
21702     MIB.addMBB(restoreMBB);
21703   MIB.setMemRefs(MMOBegin, MMOEnd);
21704   // Setup
21705   MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::EH_SjLj_Setup))
21706           .addMBB(restoreMBB);
21707
21708   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
21709   MIB.addRegMask(RegInfo->getNoPreservedMask());
21710   thisMBB->addSuccessor(mainMBB);
21711   thisMBB->addSuccessor(restoreMBB);
21712
21713   // mainMBB:
21714   //  EAX = 0
21715   BuildMI(mainMBB, DL, TII->get(X86::MOV32r0), mainDstReg);
21716   mainMBB->addSuccessor(sinkMBB);
21717
21718   // sinkMBB:
21719   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
21720           TII->get(X86::PHI), DstReg)
21721     .addReg(mainDstReg).addMBB(mainMBB)
21722     .addReg(restoreDstReg).addMBB(restoreMBB);
21723
21724   // restoreMBB:
21725   if (RegInfo->hasBasePointer(*MF)) {
21726     const bool Uses64BitFramePtr =
21727         Subtarget->isTarget64BitLP64() || Subtarget->isTargetNaCl64();
21728     X86MachineFunctionInfo *X86FI = MF->getInfo<X86MachineFunctionInfo>();
21729     X86FI->setRestoreBasePointer(MF);
21730     unsigned FramePtr = RegInfo->getFrameRegister(*MF);
21731     unsigned BasePtr = RegInfo->getBaseRegister();
21732     unsigned Opm = Uses64BitFramePtr ? X86::MOV64rm : X86::MOV32rm;
21733     addRegOffset(BuildMI(restoreMBB, DL, TII->get(Opm), BasePtr),
21734                  FramePtr, true, X86FI->getRestoreBasePointerOffset())
21735       .setMIFlag(MachineInstr::FrameSetup);
21736   }
21737   BuildMI(restoreMBB, DL, TII->get(X86::MOV32ri), restoreDstReg).addImm(1);
21738   BuildMI(restoreMBB, DL, TII->get(X86::JMP_1)).addMBB(sinkMBB);
21739   restoreMBB->addSuccessor(sinkMBB);
21740
21741   MI->eraseFromParent();
21742   return sinkMBB;
21743 }
21744
21745 MachineBasicBlock *
21746 X86TargetLowering::emitEHSjLjLongJmp(MachineInstr *MI,
21747                                      MachineBasicBlock *MBB) const {
21748   DebugLoc DL = MI->getDebugLoc();
21749   MachineFunction *MF = MBB->getParent();
21750   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21751   MachineRegisterInfo &MRI = MF->getRegInfo();
21752
21753   // Memory Reference
21754   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
21755   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
21756
21757   MVT PVT = getPointerTy();
21758   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
21759          "Invalid Pointer Size!");
21760
21761   const TargetRegisterClass *RC =
21762     (PVT == MVT::i64) ? &X86::GR64RegClass : &X86::GR32RegClass;
21763   unsigned Tmp = MRI.createVirtualRegister(RC);
21764   // Since FP is only updated here but NOT referenced, it's treated as GPR.
21765   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
21766   unsigned FP = (PVT == MVT::i64) ? X86::RBP : X86::EBP;
21767   unsigned SP = RegInfo->getStackRegister();
21768
21769   MachineInstrBuilder MIB;
21770
21771   const int64_t LabelOffset = 1 * PVT.getStoreSize();
21772   const int64_t SPOffset = 2 * PVT.getStoreSize();
21773
21774   unsigned PtrLoadOpc = (PVT == MVT::i64) ? X86::MOV64rm : X86::MOV32rm;
21775   unsigned IJmpOpc = (PVT == MVT::i64) ? X86::JMP64r : X86::JMP32r;
21776
21777   // Reload FP
21778   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), FP);
21779   for (unsigned i = 0; i < X86::AddrNumOperands; ++i)
21780     MIB.addOperand(MI->getOperand(i));
21781   MIB.setMemRefs(MMOBegin, MMOEnd);
21782   // Reload IP
21783   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), Tmp);
21784   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21785     if (i == X86::AddrDisp)
21786       MIB.addDisp(MI->getOperand(i), LabelOffset);
21787     else
21788       MIB.addOperand(MI->getOperand(i));
21789   }
21790   MIB.setMemRefs(MMOBegin, MMOEnd);
21791   // Reload SP
21792   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), SP);
21793   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21794     if (i == X86::AddrDisp)
21795       MIB.addDisp(MI->getOperand(i), SPOffset);
21796     else
21797       MIB.addOperand(MI->getOperand(i));
21798   }
21799   MIB.setMemRefs(MMOBegin, MMOEnd);
21800   // Jump
21801   BuildMI(*MBB, MI, DL, TII->get(IJmpOpc)).addReg(Tmp);
21802
21803   MI->eraseFromParent();
21804   return MBB;
21805 }
21806
21807 // Replace 213-type (isel default) FMA3 instructions with 231-type for
21808 // accumulator loops. Writing back to the accumulator allows the coalescer
21809 // to remove extra copies in the loop.
21810 MachineBasicBlock *
21811 X86TargetLowering::emitFMA3Instr(MachineInstr *MI,
21812                                  MachineBasicBlock *MBB) const {
21813   MachineOperand &AddendOp = MI->getOperand(3);
21814
21815   // Bail out early if the addend isn't a register - we can't switch these.
21816   if (!AddendOp.isReg())
21817     return MBB;
21818
21819   MachineFunction &MF = *MBB->getParent();
21820   MachineRegisterInfo &MRI = MF.getRegInfo();
21821
21822   // Check whether the addend is defined by a PHI:
21823   assert(MRI.hasOneDef(AddendOp.getReg()) && "Multiple defs in SSA?");
21824   MachineInstr &AddendDef = *MRI.def_instr_begin(AddendOp.getReg());
21825   if (!AddendDef.isPHI())
21826     return MBB;
21827
21828   // Look for the following pattern:
21829   // loop:
21830   //   %addend = phi [%entry, 0], [%loop, %result]
21831   //   ...
21832   //   %result<tied1> = FMA213 %m2<tied0>, %m1, %addend
21833
21834   // Replace with:
21835   //   loop:
21836   //   %addend = phi [%entry, 0], [%loop, %result]
21837   //   ...
21838   //   %result<tied1> = FMA231 %addend<tied0>, %m1, %m2
21839
21840   for (unsigned i = 1, e = AddendDef.getNumOperands(); i < e; i += 2) {
21841     assert(AddendDef.getOperand(i).isReg());
21842     MachineOperand PHISrcOp = AddendDef.getOperand(i);
21843     MachineInstr &PHISrcInst = *MRI.def_instr_begin(PHISrcOp.getReg());
21844     if (&PHISrcInst == MI) {
21845       // Found a matching instruction.
21846       unsigned NewFMAOpc = 0;
21847       switch (MI->getOpcode()) {
21848         case X86::VFMADDPDr213r: NewFMAOpc = X86::VFMADDPDr231r; break;
21849         case X86::VFMADDPSr213r: NewFMAOpc = X86::VFMADDPSr231r; break;
21850         case X86::VFMADDSDr213r: NewFMAOpc = X86::VFMADDSDr231r; break;
21851         case X86::VFMADDSSr213r: NewFMAOpc = X86::VFMADDSSr231r; break;
21852         case X86::VFMSUBPDr213r: NewFMAOpc = X86::VFMSUBPDr231r; break;
21853         case X86::VFMSUBPSr213r: NewFMAOpc = X86::VFMSUBPSr231r; break;
21854         case X86::VFMSUBSDr213r: NewFMAOpc = X86::VFMSUBSDr231r; break;
21855         case X86::VFMSUBSSr213r: NewFMAOpc = X86::VFMSUBSSr231r; break;
21856         case X86::VFNMADDPDr213r: NewFMAOpc = X86::VFNMADDPDr231r; break;
21857         case X86::VFNMADDPSr213r: NewFMAOpc = X86::VFNMADDPSr231r; break;
21858         case X86::VFNMADDSDr213r: NewFMAOpc = X86::VFNMADDSDr231r; break;
21859         case X86::VFNMADDSSr213r: NewFMAOpc = X86::VFNMADDSSr231r; break;
21860         case X86::VFNMSUBPDr213r: NewFMAOpc = X86::VFNMSUBPDr231r; break;
21861         case X86::VFNMSUBPSr213r: NewFMAOpc = X86::VFNMSUBPSr231r; break;
21862         case X86::VFNMSUBSDr213r: NewFMAOpc = X86::VFNMSUBSDr231r; break;
21863         case X86::VFNMSUBSSr213r: NewFMAOpc = X86::VFNMSUBSSr231r; break;
21864         case X86::VFMADDSUBPDr213r: NewFMAOpc = X86::VFMADDSUBPDr231r; break;
21865         case X86::VFMADDSUBPSr213r: NewFMAOpc = X86::VFMADDSUBPSr231r; break;
21866         case X86::VFMSUBADDPDr213r: NewFMAOpc = X86::VFMSUBADDPDr231r; break;
21867         case X86::VFMSUBADDPSr213r: NewFMAOpc = X86::VFMSUBADDPSr231r; break;
21868
21869         case X86::VFMADDPDr213rY: NewFMAOpc = X86::VFMADDPDr231rY; break;
21870         case X86::VFMADDPSr213rY: NewFMAOpc = X86::VFMADDPSr231rY; break;
21871         case X86::VFMSUBPDr213rY: NewFMAOpc = X86::VFMSUBPDr231rY; break;
21872         case X86::VFMSUBPSr213rY: NewFMAOpc = X86::VFMSUBPSr231rY; break;
21873         case X86::VFNMADDPDr213rY: NewFMAOpc = X86::VFNMADDPDr231rY; break;
21874         case X86::VFNMADDPSr213rY: NewFMAOpc = X86::VFNMADDPSr231rY; break;
21875         case X86::VFNMSUBPDr213rY: NewFMAOpc = X86::VFNMSUBPDr231rY; break;
21876         case X86::VFNMSUBPSr213rY: NewFMAOpc = X86::VFNMSUBPSr231rY; break;
21877         case X86::VFMADDSUBPDr213rY: NewFMAOpc = X86::VFMADDSUBPDr231rY; break;
21878         case X86::VFMADDSUBPSr213rY: NewFMAOpc = X86::VFMADDSUBPSr231rY; break;
21879         case X86::VFMSUBADDPDr213rY: NewFMAOpc = X86::VFMSUBADDPDr231rY; break;
21880         case X86::VFMSUBADDPSr213rY: NewFMAOpc = X86::VFMSUBADDPSr231rY; break;
21881         default: llvm_unreachable("Unrecognized FMA variant.");
21882       }
21883
21884       const TargetInstrInfo &TII = *Subtarget->getInstrInfo();
21885       MachineInstrBuilder MIB =
21886         BuildMI(MF, MI->getDebugLoc(), TII.get(NewFMAOpc))
21887         .addOperand(MI->getOperand(0))
21888         .addOperand(MI->getOperand(3))
21889         .addOperand(MI->getOperand(2))
21890         .addOperand(MI->getOperand(1));
21891       MBB->insert(MachineBasicBlock::iterator(MI), MIB);
21892       MI->eraseFromParent();
21893     }
21894   }
21895
21896   return MBB;
21897 }
21898
21899 MachineBasicBlock *
21900 X86TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
21901                                                MachineBasicBlock *BB) const {
21902   switch (MI->getOpcode()) {
21903   default: llvm_unreachable("Unexpected instr type to insert");
21904   case X86::TAILJMPd64:
21905   case X86::TAILJMPr64:
21906   case X86::TAILJMPm64:
21907   case X86::TAILJMPd64_REX:
21908   case X86::TAILJMPr64_REX:
21909   case X86::TAILJMPm64_REX:
21910     llvm_unreachable("TAILJMP64 would not be touched here.");
21911   case X86::TCRETURNdi64:
21912   case X86::TCRETURNri64:
21913   case X86::TCRETURNmi64:
21914     return BB;
21915   case X86::WIN_ALLOCA:
21916     return EmitLoweredWinAlloca(MI, BB);
21917   case X86::SEG_ALLOCA_32:
21918   case X86::SEG_ALLOCA_64:
21919     return EmitLoweredSegAlloca(MI, BB);
21920   case X86::TLSCall_32:
21921   case X86::TLSCall_64:
21922     return EmitLoweredTLSCall(MI, BB);
21923   case X86::CMOV_GR8:
21924   case X86::CMOV_FR32:
21925   case X86::CMOV_FR64:
21926   case X86::CMOV_V4F32:
21927   case X86::CMOV_V2F64:
21928   case X86::CMOV_V2I64:
21929   case X86::CMOV_V8F32:
21930   case X86::CMOV_V4F64:
21931   case X86::CMOV_V4I64:
21932   case X86::CMOV_V16F32:
21933   case X86::CMOV_V8F64:
21934   case X86::CMOV_V8I64:
21935   case X86::CMOV_GR16:
21936   case X86::CMOV_GR32:
21937   case X86::CMOV_RFP32:
21938   case X86::CMOV_RFP64:
21939   case X86::CMOV_RFP80:
21940     return EmitLoweredSelect(MI, BB);
21941
21942   case X86::FP32_TO_INT16_IN_MEM:
21943   case X86::FP32_TO_INT32_IN_MEM:
21944   case X86::FP32_TO_INT64_IN_MEM:
21945   case X86::FP64_TO_INT16_IN_MEM:
21946   case X86::FP64_TO_INT32_IN_MEM:
21947   case X86::FP64_TO_INT64_IN_MEM:
21948   case X86::FP80_TO_INT16_IN_MEM:
21949   case X86::FP80_TO_INT32_IN_MEM:
21950   case X86::FP80_TO_INT64_IN_MEM: {
21951     MachineFunction *F = BB->getParent();
21952     const TargetInstrInfo *TII = Subtarget->getInstrInfo();
21953     DebugLoc DL = MI->getDebugLoc();
21954
21955     // Change the floating point control register to use "round towards zero"
21956     // mode when truncating to an integer value.
21957     int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2, false);
21958     addFrameReference(BuildMI(*BB, MI, DL,
21959                               TII->get(X86::FNSTCW16m)), CWFrameIdx);
21960
21961     // Load the old value of the high byte of the control word...
21962     unsigned OldCW =
21963       F->getRegInfo().createVirtualRegister(&X86::GR16RegClass);
21964     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16rm), OldCW),
21965                       CWFrameIdx);
21966
21967     // Set the high part to be round to zero...
21968     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mi)), CWFrameIdx)
21969       .addImm(0xC7F);
21970
21971     // Reload the modified control word now...
21972     addFrameReference(BuildMI(*BB, MI, DL,
21973                               TII->get(X86::FLDCW16m)), CWFrameIdx);
21974
21975     // Restore the memory image of control word to original value
21976     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mr)), CWFrameIdx)
21977       .addReg(OldCW);
21978
21979     // Get the X86 opcode to use.
21980     unsigned Opc;
21981     switch (MI->getOpcode()) {
21982     default: llvm_unreachable("illegal opcode!");
21983     case X86::FP32_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m32; break;
21984     case X86::FP32_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m32; break;
21985     case X86::FP32_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m32; break;
21986     case X86::FP64_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m64; break;
21987     case X86::FP64_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m64; break;
21988     case X86::FP64_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m64; break;
21989     case X86::FP80_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m80; break;
21990     case X86::FP80_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m80; break;
21991     case X86::FP80_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m80; break;
21992     }
21993
21994     X86AddressMode AM;
21995     MachineOperand &Op = MI->getOperand(0);
21996     if (Op.isReg()) {
21997       AM.BaseType = X86AddressMode::RegBase;
21998       AM.Base.Reg = Op.getReg();
21999     } else {
22000       AM.BaseType = X86AddressMode::FrameIndexBase;
22001       AM.Base.FrameIndex = Op.getIndex();
22002     }
22003     Op = MI->getOperand(1);
22004     if (Op.isImm())
22005       AM.Scale = Op.getImm();
22006     Op = MI->getOperand(2);
22007     if (Op.isImm())
22008       AM.IndexReg = Op.getImm();
22009     Op = MI->getOperand(3);
22010     if (Op.isGlobal()) {
22011       AM.GV = Op.getGlobal();
22012     } else {
22013       AM.Disp = Op.getImm();
22014     }
22015     addFullAddress(BuildMI(*BB, MI, DL, TII->get(Opc)), AM)
22016                       .addReg(MI->getOperand(X86::AddrNumOperands).getReg());
22017
22018     // Reload the original control word now.
22019     addFrameReference(BuildMI(*BB, MI, DL,
22020                               TII->get(X86::FLDCW16m)), CWFrameIdx);
22021
22022     MI->eraseFromParent();   // The pseudo instruction is gone now.
22023     return BB;
22024   }
22025     // String/text processing lowering.
22026   case X86::PCMPISTRM128REG:
22027   case X86::VPCMPISTRM128REG:
22028   case X86::PCMPISTRM128MEM:
22029   case X86::VPCMPISTRM128MEM:
22030   case X86::PCMPESTRM128REG:
22031   case X86::VPCMPESTRM128REG:
22032   case X86::PCMPESTRM128MEM:
22033   case X86::VPCMPESTRM128MEM:
22034     assert(Subtarget->hasSSE42() &&
22035            "Target must have SSE4.2 or AVX features enabled");
22036     return EmitPCMPSTRM(MI, BB, Subtarget->getInstrInfo());
22037
22038   // String/text processing lowering.
22039   case X86::PCMPISTRIREG:
22040   case X86::VPCMPISTRIREG:
22041   case X86::PCMPISTRIMEM:
22042   case X86::VPCMPISTRIMEM:
22043   case X86::PCMPESTRIREG:
22044   case X86::VPCMPESTRIREG:
22045   case X86::PCMPESTRIMEM:
22046   case X86::VPCMPESTRIMEM:
22047     assert(Subtarget->hasSSE42() &&
22048            "Target must have SSE4.2 or AVX features enabled");
22049     return EmitPCMPSTRI(MI, BB, Subtarget->getInstrInfo());
22050
22051   // Thread synchronization.
22052   case X86::MONITOR:
22053     return EmitMonitor(MI, BB, Subtarget);
22054
22055   // xbegin
22056   case X86::XBEGIN:
22057     return EmitXBegin(MI, BB, Subtarget->getInstrInfo());
22058
22059   case X86::VASTART_SAVE_XMM_REGS:
22060     return EmitVAStartSaveXMMRegsWithCustomInserter(MI, BB);
22061
22062   case X86::VAARG_64:
22063     return EmitVAARG64WithCustomInserter(MI, BB);
22064
22065   case X86::EH_SjLj_SetJmp32:
22066   case X86::EH_SjLj_SetJmp64:
22067     return emitEHSjLjSetJmp(MI, BB);
22068
22069   case X86::EH_SjLj_LongJmp32:
22070   case X86::EH_SjLj_LongJmp64:
22071     return emitEHSjLjLongJmp(MI, BB);
22072
22073   case TargetOpcode::STATEPOINT:
22074     // As an implementation detail, STATEPOINT shares the STACKMAP format at
22075     // this point in the process.  We diverge later.
22076     return emitPatchPoint(MI, BB);
22077
22078   case TargetOpcode::STACKMAP:
22079   case TargetOpcode::PATCHPOINT:
22080     return emitPatchPoint(MI, BB);
22081
22082   case X86::VFMADDPDr213r:
22083   case X86::VFMADDPSr213r:
22084   case X86::VFMADDSDr213r:
22085   case X86::VFMADDSSr213r:
22086   case X86::VFMSUBPDr213r:
22087   case X86::VFMSUBPSr213r:
22088   case X86::VFMSUBSDr213r:
22089   case X86::VFMSUBSSr213r:
22090   case X86::VFNMADDPDr213r:
22091   case X86::VFNMADDPSr213r:
22092   case X86::VFNMADDSDr213r:
22093   case X86::VFNMADDSSr213r:
22094   case X86::VFNMSUBPDr213r:
22095   case X86::VFNMSUBPSr213r:
22096   case X86::VFNMSUBSDr213r:
22097   case X86::VFNMSUBSSr213r:
22098   case X86::VFMADDSUBPDr213r:
22099   case X86::VFMADDSUBPSr213r:
22100   case X86::VFMSUBADDPDr213r:
22101   case X86::VFMSUBADDPSr213r:
22102   case X86::VFMADDPDr213rY:
22103   case X86::VFMADDPSr213rY:
22104   case X86::VFMSUBPDr213rY:
22105   case X86::VFMSUBPSr213rY:
22106   case X86::VFNMADDPDr213rY:
22107   case X86::VFNMADDPSr213rY:
22108   case X86::VFNMSUBPDr213rY:
22109   case X86::VFNMSUBPSr213rY:
22110   case X86::VFMADDSUBPDr213rY:
22111   case X86::VFMADDSUBPSr213rY:
22112   case X86::VFMSUBADDPDr213rY:
22113   case X86::VFMSUBADDPSr213rY:
22114     return emitFMA3Instr(MI, BB);
22115   }
22116 }
22117
22118 //===----------------------------------------------------------------------===//
22119 //                           X86 Optimization Hooks
22120 //===----------------------------------------------------------------------===//
22121
22122 void X86TargetLowering::computeKnownBitsForTargetNode(const SDValue Op,
22123                                                       APInt &KnownZero,
22124                                                       APInt &KnownOne,
22125                                                       const SelectionDAG &DAG,
22126                                                       unsigned Depth) const {
22127   unsigned BitWidth = KnownZero.getBitWidth();
22128   unsigned Opc = Op.getOpcode();
22129   assert((Opc >= ISD::BUILTIN_OP_END ||
22130           Opc == ISD::INTRINSIC_WO_CHAIN ||
22131           Opc == ISD::INTRINSIC_W_CHAIN ||
22132           Opc == ISD::INTRINSIC_VOID) &&
22133          "Should use MaskedValueIsZero if you don't know whether Op"
22134          " is a target node!");
22135
22136   KnownZero = KnownOne = APInt(BitWidth, 0);   // Don't know anything.
22137   switch (Opc) {
22138   default: break;
22139   case X86ISD::ADD:
22140   case X86ISD::SUB:
22141   case X86ISD::ADC:
22142   case X86ISD::SBB:
22143   case X86ISD::SMUL:
22144   case X86ISD::UMUL:
22145   case X86ISD::INC:
22146   case X86ISD::DEC:
22147   case X86ISD::OR:
22148   case X86ISD::XOR:
22149   case X86ISD::AND:
22150     // These nodes' second result is a boolean.
22151     if (Op.getResNo() == 0)
22152       break;
22153     // Fallthrough
22154   case X86ISD::SETCC:
22155     KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
22156     break;
22157   case ISD::INTRINSIC_WO_CHAIN: {
22158     unsigned IntId = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
22159     unsigned NumLoBits = 0;
22160     switch (IntId) {
22161     default: break;
22162     case Intrinsic::x86_sse_movmsk_ps:
22163     case Intrinsic::x86_avx_movmsk_ps_256:
22164     case Intrinsic::x86_sse2_movmsk_pd:
22165     case Intrinsic::x86_avx_movmsk_pd_256:
22166     case Intrinsic::x86_mmx_pmovmskb:
22167     case Intrinsic::x86_sse2_pmovmskb_128:
22168     case Intrinsic::x86_avx2_pmovmskb: {
22169       // High bits of movmskp{s|d}, pmovmskb are known zero.
22170       switch (IntId) {
22171         default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
22172         case Intrinsic::x86_sse_movmsk_ps:      NumLoBits = 4; break;
22173         case Intrinsic::x86_avx_movmsk_ps_256:  NumLoBits = 8; break;
22174         case Intrinsic::x86_sse2_movmsk_pd:     NumLoBits = 2; break;
22175         case Intrinsic::x86_avx_movmsk_pd_256:  NumLoBits = 4; break;
22176         case Intrinsic::x86_mmx_pmovmskb:       NumLoBits = 8; break;
22177         case Intrinsic::x86_sse2_pmovmskb_128:  NumLoBits = 16; break;
22178         case Intrinsic::x86_avx2_pmovmskb:      NumLoBits = 32; break;
22179       }
22180       KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - NumLoBits);
22181       break;
22182     }
22183     }
22184     break;
22185   }
22186   }
22187 }
22188
22189 unsigned X86TargetLowering::ComputeNumSignBitsForTargetNode(
22190   SDValue Op,
22191   const SelectionDAG &,
22192   unsigned Depth) const {
22193   // SETCC_CARRY sets the dest to ~0 for true or 0 for false.
22194   if (Op.getOpcode() == X86ISD::SETCC_CARRY)
22195     return Op.getValueType().getScalarType().getSizeInBits();
22196
22197   // Fallback case.
22198   return 1;
22199 }
22200
22201 /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
22202 /// node is a GlobalAddress + offset.
22203 bool X86TargetLowering::isGAPlusOffset(SDNode *N,
22204                                        const GlobalValue* &GA,
22205                                        int64_t &Offset) const {
22206   if (N->getOpcode() == X86ISD::Wrapper) {
22207     if (isa<GlobalAddressSDNode>(N->getOperand(0))) {
22208       GA = cast<GlobalAddressSDNode>(N->getOperand(0))->getGlobal();
22209       Offset = cast<GlobalAddressSDNode>(N->getOperand(0))->getOffset();
22210       return true;
22211     }
22212   }
22213   return TargetLowering::isGAPlusOffset(N, GA, Offset);
22214 }
22215
22216 /// isShuffleHigh128VectorInsertLow - Checks whether the shuffle node is the
22217 /// same as extracting the high 128-bit part of 256-bit vector and then
22218 /// inserting the result into the low part of a new 256-bit vector
22219 static bool isShuffleHigh128VectorInsertLow(ShuffleVectorSDNode *SVOp) {
22220   EVT VT = SVOp->getValueType(0);
22221   unsigned NumElems = VT.getVectorNumElements();
22222
22223   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
22224   for (unsigned i = 0, j = NumElems/2; i != NumElems/2; ++i, ++j)
22225     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
22226         SVOp->getMaskElt(j) >= 0)
22227       return false;
22228
22229   return true;
22230 }
22231
22232 /// isShuffleLow128VectorInsertHigh - Checks whether the shuffle node is the
22233 /// same as extracting the low 128-bit part of 256-bit vector and then
22234 /// inserting the result into the high part of a new 256-bit vector
22235 static bool isShuffleLow128VectorInsertHigh(ShuffleVectorSDNode *SVOp) {
22236   EVT VT = SVOp->getValueType(0);
22237   unsigned NumElems = VT.getVectorNumElements();
22238
22239   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
22240   for (unsigned i = NumElems/2, j = 0; i != NumElems; ++i, ++j)
22241     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
22242         SVOp->getMaskElt(j) >= 0)
22243       return false;
22244
22245   return true;
22246 }
22247
22248 /// PerformShuffleCombine256 - Performs shuffle combines for 256-bit vectors.
22249 static SDValue PerformShuffleCombine256(SDNode *N, SelectionDAG &DAG,
22250                                         TargetLowering::DAGCombinerInfo &DCI,
22251                                         const X86Subtarget* Subtarget) {
22252   SDLoc dl(N);
22253   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
22254   SDValue V1 = SVOp->getOperand(0);
22255   SDValue V2 = SVOp->getOperand(1);
22256   EVT VT = SVOp->getValueType(0);
22257   unsigned NumElems = VT.getVectorNumElements();
22258
22259   if (V1.getOpcode() == ISD::CONCAT_VECTORS &&
22260       V2.getOpcode() == ISD::CONCAT_VECTORS) {
22261     //
22262     //                   0,0,0,...
22263     //                      |
22264     //    V      UNDEF    BUILD_VECTOR    UNDEF
22265     //     \      /           \           /
22266     //  CONCAT_VECTOR         CONCAT_VECTOR
22267     //         \                  /
22268     //          \                /
22269     //          RESULT: V + zero extended
22270     //
22271     if (V2.getOperand(0).getOpcode() != ISD::BUILD_VECTOR ||
22272         V2.getOperand(1).getOpcode() != ISD::UNDEF ||
22273         V1.getOperand(1).getOpcode() != ISD::UNDEF)
22274       return SDValue();
22275
22276     if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
22277       return SDValue();
22278
22279     // To match the shuffle mask, the first half of the mask should
22280     // be exactly the first vector, and all the rest a splat with the
22281     // first element of the second one.
22282     for (unsigned i = 0; i != NumElems/2; ++i)
22283       if (!isUndefOrEqual(SVOp->getMaskElt(i), i) ||
22284           !isUndefOrEqual(SVOp->getMaskElt(i+NumElems/2), NumElems))
22285         return SDValue();
22286
22287     // If V1 is coming from a vector load then just fold to a VZEXT_LOAD.
22288     if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(V1.getOperand(0))) {
22289       if (Ld->hasNUsesOfValue(1, 0)) {
22290         SDVTList Tys = DAG.getVTList(MVT::v4i64, MVT::Other);
22291         SDValue Ops[] = { Ld->getChain(), Ld->getBasePtr() };
22292         SDValue ResNode =
22293           DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, dl, Tys, Ops,
22294                                   Ld->getMemoryVT(),
22295                                   Ld->getPointerInfo(),
22296                                   Ld->getAlignment(),
22297                                   false/*isVolatile*/, true/*ReadMem*/,
22298                                   false/*WriteMem*/);
22299
22300         // Make sure the newly-created LOAD is in the same position as Ld in
22301         // terms of dependency. We create a TokenFactor for Ld and ResNode,
22302         // and update uses of Ld's output chain to use the TokenFactor.
22303         if (Ld->hasAnyUseOfValue(1)) {
22304           SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
22305                              SDValue(Ld, 1), SDValue(ResNode.getNode(), 1));
22306           DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), NewChain);
22307           DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(Ld, 1),
22308                                  SDValue(ResNode.getNode(), 1));
22309         }
22310
22311         return DAG.getNode(ISD::BITCAST, dl, VT, ResNode);
22312       }
22313     }
22314
22315     // Emit a zeroed vector and insert the desired subvector on its
22316     // first half.
22317     SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
22318     SDValue InsV = Insert128BitVector(Zeros, V1.getOperand(0), 0, DAG, dl);
22319     return DCI.CombineTo(N, InsV);
22320   }
22321
22322   //===--------------------------------------------------------------------===//
22323   // Combine some shuffles into subvector extracts and inserts:
22324   //
22325
22326   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
22327   if (isShuffleHigh128VectorInsertLow(SVOp)) {
22328     SDValue V = Extract128BitVector(V1, NumElems/2, DAG, dl);
22329     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, 0, DAG, dl);
22330     return DCI.CombineTo(N, InsV);
22331   }
22332
22333   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
22334   if (isShuffleLow128VectorInsertHigh(SVOp)) {
22335     SDValue V = Extract128BitVector(V1, 0, DAG, dl);
22336     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, NumElems/2, DAG, dl);
22337     return DCI.CombineTo(N, InsV);
22338   }
22339
22340   return SDValue();
22341 }
22342
22343 /// \brief Combine an arbitrary chain of shuffles into a single instruction if
22344 /// possible.
22345 ///
22346 /// This is the leaf of the recursive combinine below. When we have found some
22347 /// chain of single-use x86 shuffle instructions and accumulated the combined
22348 /// shuffle mask represented by them, this will try to pattern match that mask
22349 /// into either a single instruction if there is a special purpose instruction
22350 /// for this operation, or into a PSHUFB instruction which is a fully general
22351 /// instruction but should only be used to replace chains over a certain depth.
22352 static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef<int> Mask,
22353                                    int Depth, bool HasPSHUFB, SelectionDAG &DAG,
22354                                    TargetLowering::DAGCombinerInfo &DCI,
22355                                    const X86Subtarget *Subtarget) {
22356   assert(!Mask.empty() && "Cannot combine an empty shuffle mask!");
22357
22358   // Find the operand that enters the chain. Note that multiple uses are OK
22359   // here, we're not going to remove the operand we find.
22360   SDValue Input = Op.getOperand(0);
22361   while (Input.getOpcode() == ISD::BITCAST)
22362     Input = Input.getOperand(0);
22363
22364   MVT VT = Input.getSimpleValueType();
22365   MVT RootVT = Root.getSimpleValueType();
22366   SDLoc DL(Root);
22367
22368   // Just remove no-op shuffle masks.
22369   if (Mask.size() == 1) {
22370     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Input),
22371                   /*AddTo*/ true);
22372     return true;
22373   }
22374
22375   // Use the float domain if the operand type is a floating point type.
22376   bool FloatDomain = VT.isFloatingPoint();
22377
22378   // For floating point shuffles, we don't have free copies in the shuffle
22379   // instructions or the ability to load as part of the instruction, so
22380   // canonicalize their shuffles to UNPCK or MOV variants.
22381   //
22382   // Note that even with AVX we prefer the PSHUFD form of shuffle for integer
22383   // vectors because it can have a load folded into it that UNPCK cannot. This
22384   // doesn't preclude something switching to the shorter encoding post-RA.
22385   if (FloatDomain) {
22386     if (Mask.equals(0, 0) || Mask.equals(1, 1)) {
22387       bool Lo = Mask.equals(0, 0);
22388       unsigned Shuffle;
22389       MVT ShuffleVT;
22390       // Check if we have SSE3 which will let us use MOVDDUP. That instruction
22391       // is no slower than UNPCKLPD but has the option to fold the input operand
22392       // into even an unaligned memory load.
22393       if (Lo && Subtarget->hasSSE3()) {
22394         Shuffle = X86ISD::MOVDDUP;
22395         ShuffleVT = MVT::v2f64;
22396       } else {
22397         // We have MOVLHPS and MOVHLPS throughout SSE and they encode smaller
22398         // than the UNPCK variants.
22399         Shuffle = Lo ? X86ISD::MOVLHPS : X86ISD::MOVHLPS;
22400         ShuffleVT = MVT::v4f32;
22401       }
22402       if (Depth == 1 && Root->getOpcode() == Shuffle)
22403         return false; // Nothing to do!
22404       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22405       DCI.AddToWorklist(Op.getNode());
22406       if (Shuffle == X86ISD::MOVDDUP)
22407         Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op);
22408       else
22409         Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22410       DCI.AddToWorklist(Op.getNode());
22411       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22412                     /*AddTo*/ true);
22413       return true;
22414     }
22415     if (Subtarget->hasSSE3() &&
22416         (Mask.equals(0, 0, 2, 2) || Mask.equals(1, 1, 3, 3))) {
22417       bool Lo = Mask.equals(0, 0, 2, 2);
22418       unsigned Shuffle = Lo ? X86ISD::MOVSLDUP : X86ISD::MOVSHDUP;
22419       MVT ShuffleVT = MVT::v4f32;
22420       if (Depth == 1 && Root->getOpcode() == Shuffle)
22421         return false; // Nothing to do!
22422       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22423       DCI.AddToWorklist(Op.getNode());
22424       Op = DAG.getNode(Shuffle, DL, ShuffleVT, 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 (Mask.equals(0, 0, 1, 1) || Mask.equals(2, 2, 3, 3)) {
22431       bool Lo = Mask.equals(0, 0, 1, 1);
22432       unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
22433       MVT ShuffleVT = MVT::v4f32;
22434       if (Depth == 1 && Root->getOpcode() == Shuffle)
22435         return false; // Nothing to do!
22436       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22437       DCI.AddToWorklist(Op.getNode());
22438       Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22439       DCI.AddToWorklist(Op.getNode());
22440       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22441                     /*AddTo*/ true);
22442       return true;
22443     }
22444   }
22445
22446   // We always canonicalize the 8 x i16 and 16 x i8 shuffles into their UNPCK
22447   // variants as none of these have single-instruction variants that are
22448   // superior to the UNPCK formulation.
22449   if (!FloatDomain &&
22450       (Mask.equals(0, 0, 1, 1, 2, 2, 3, 3) ||
22451        Mask.equals(4, 4, 5, 5, 6, 6, 7, 7) ||
22452        Mask.equals(0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7) ||
22453        Mask.equals(8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15,
22454                    15))) {
22455     bool Lo = Mask[0] == 0;
22456     unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
22457     if (Depth == 1 && Root->getOpcode() == Shuffle)
22458       return false; // Nothing to do!
22459     MVT ShuffleVT;
22460     switch (Mask.size()) {
22461     case 8:
22462       ShuffleVT = MVT::v8i16;
22463       break;
22464     case 16:
22465       ShuffleVT = MVT::v16i8;
22466       break;
22467     default:
22468       llvm_unreachable("Impossible mask size!");
22469     };
22470     Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22471     DCI.AddToWorklist(Op.getNode());
22472     Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22473     DCI.AddToWorklist(Op.getNode());
22474     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22475                   /*AddTo*/ true);
22476     return true;
22477   }
22478
22479   // Don't try to re-form single instruction chains under any circumstances now
22480   // that we've done encoding canonicalization for them.
22481   if (Depth < 2)
22482     return false;
22483
22484   // If we have 3 or more shuffle instructions or a chain involving PSHUFB, we
22485   // can replace them with a single PSHUFB instruction profitably. Intel's
22486   // manuals suggest only using PSHUFB if doing so replacing 5 instructions, but
22487   // in practice PSHUFB tends to be *very* fast so we're more aggressive.
22488   if ((Depth >= 3 || HasPSHUFB) && Subtarget->hasSSSE3()) {
22489     SmallVector<SDValue, 16> PSHUFBMask;
22490     assert(Mask.size() <= 16 && "Can't shuffle elements smaller than bytes!");
22491     int Ratio = 16 / Mask.size();
22492     for (unsigned i = 0; i < 16; ++i) {
22493       if (Mask[i / Ratio] == SM_SentinelUndef) {
22494         PSHUFBMask.push_back(DAG.getUNDEF(MVT::i8));
22495         continue;
22496       }
22497       int M = Mask[i / Ratio] != SM_SentinelZero
22498                   ? Ratio * Mask[i / Ratio] + i % Ratio
22499                   : 255;
22500       PSHUFBMask.push_back(DAG.getConstant(M, MVT::i8));
22501     }
22502     Op = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Input);
22503     DCI.AddToWorklist(Op.getNode());
22504     SDValue PSHUFBMaskOp =
22505         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, PSHUFBMask);
22506     DCI.AddToWorklist(PSHUFBMaskOp.getNode());
22507     Op = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, Op, PSHUFBMaskOp);
22508     DCI.AddToWorklist(Op.getNode());
22509     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22510                   /*AddTo*/ true);
22511     return true;
22512   }
22513
22514   // Failed to find any combines.
22515   return false;
22516 }
22517
22518 /// \brief Fully generic combining of x86 shuffle instructions.
22519 ///
22520 /// This should be the last combine run over the x86 shuffle instructions. Once
22521 /// they have been fully optimized, this will recursively consider all chains
22522 /// of single-use shuffle instructions, build a generic model of the cumulative
22523 /// shuffle operation, and check for simpler instructions which implement this
22524 /// operation. We use this primarily for two purposes:
22525 ///
22526 /// 1) Collapse generic shuffles to specialized single instructions when
22527 ///    equivalent. In most cases, this is just an encoding size win, but
22528 ///    sometimes we will collapse multiple generic shuffles into a single
22529 ///    special-purpose shuffle.
22530 /// 2) Look for sequences of shuffle instructions with 3 or more total
22531 ///    instructions, and replace them with the slightly more expensive SSSE3
22532 ///    PSHUFB instruction if available. We do this as the last combining step
22533 ///    to ensure we avoid using PSHUFB if we can implement the shuffle with
22534 ///    a suitable short sequence of other instructions. The PHUFB will either
22535 ///    use a register or have to read from memory and so is slightly (but only
22536 ///    slightly) more expensive than the other shuffle instructions.
22537 ///
22538 /// Because this is inherently a quadratic operation (for each shuffle in
22539 /// a chain, we recurse up the chain), the depth is limited to 8 instructions.
22540 /// This should never be an issue in practice as the shuffle lowering doesn't
22541 /// produce sequences of more than 8 instructions.
22542 ///
22543 /// FIXME: We will currently miss some cases where the redundant shuffling
22544 /// would simplify under the threshold for PSHUFB formation because of
22545 /// combine-ordering. To fix this, we should do the redundant instruction
22546 /// combining in this recursive walk.
22547 static bool combineX86ShufflesRecursively(SDValue Op, SDValue Root,
22548                                           ArrayRef<int> RootMask,
22549                                           int Depth, bool HasPSHUFB,
22550                                           SelectionDAG &DAG,
22551                                           TargetLowering::DAGCombinerInfo &DCI,
22552                                           const X86Subtarget *Subtarget) {
22553   // Bound the depth of our recursive combine because this is ultimately
22554   // quadratic in nature.
22555   if (Depth > 8)
22556     return false;
22557
22558   // Directly rip through bitcasts to find the underlying operand.
22559   while (Op.getOpcode() == ISD::BITCAST && Op.getOperand(0).hasOneUse())
22560     Op = Op.getOperand(0);
22561
22562   MVT VT = Op.getSimpleValueType();
22563   if (!VT.isVector())
22564     return false; // Bail if we hit a non-vector.
22565   // FIXME: This routine should be taught about 256-bit shuffles, or a 256-bit
22566   // version should be added.
22567   if (VT.getSizeInBits() != 128)
22568     return false;
22569
22570   assert(Root.getSimpleValueType().isVector() &&
22571          "Shuffles operate on vector types!");
22572   assert(VT.getSizeInBits() == Root.getSimpleValueType().getSizeInBits() &&
22573          "Can only combine shuffles of the same vector register size.");
22574
22575   if (!isTargetShuffle(Op.getOpcode()))
22576     return false;
22577   SmallVector<int, 16> OpMask;
22578   bool IsUnary;
22579   bool HaveMask = getTargetShuffleMask(Op.getNode(), VT, OpMask, IsUnary);
22580   // We only can combine unary shuffles which we can decode the mask for.
22581   if (!HaveMask || !IsUnary)
22582     return false;
22583
22584   assert(VT.getVectorNumElements() == OpMask.size() &&
22585          "Different mask size from vector size!");
22586   assert(((RootMask.size() > OpMask.size() &&
22587            RootMask.size() % OpMask.size() == 0) ||
22588           (OpMask.size() > RootMask.size() &&
22589            OpMask.size() % RootMask.size() == 0) ||
22590           OpMask.size() == RootMask.size()) &&
22591          "The smaller number of elements must divide the larger.");
22592   int RootRatio = std::max<int>(1, OpMask.size() / RootMask.size());
22593   int OpRatio = std::max<int>(1, RootMask.size() / OpMask.size());
22594   assert(((RootRatio == 1 && OpRatio == 1) ||
22595           (RootRatio == 1) != (OpRatio == 1)) &&
22596          "Must not have a ratio for both incoming and op masks!");
22597
22598   SmallVector<int, 16> Mask;
22599   Mask.reserve(std::max(OpMask.size(), RootMask.size()));
22600
22601   // Merge this shuffle operation's mask into our accumulated mask. Note that
22602   // this shuffle's mask will be the first applied to the input, followed by the
22603   // root mask to get us all the way to the root value arrangement. The reason
22604   // for this order is that we are recursing up the operation chain.
22605   for (int i = 0, e = std::max(OpMask.size(), RootMask.size()); i < e; ++i) {
22606     int RootIdx = i / RootRatio;
22607     if (RootMask[RootIdx] < 0) {
22608       // This is a zero or undef lane, we're done.
22609       Mask.push_back(RootMask[RootIdx]);
22610       continue;
22611     }
22612
22613     int RootMaskedIdx = RootMask[RootIdx] * RootRatio + i % RootRatio;
22614     int OpIdx = RootMaskedIdx / OpRatio;
22615     if (OpMask[OpIdx] < 0) {
22616       // The incoming lanes are zero or undef, it doesn't matter which ones we
22617       // are using.
22618       Mask.push_back(OpMask[OpIdx]);
22619       continue;
22620     }
22621
22622     // Ok, we have non-zero lanes, map them through.
22623     Mask.push_back(OpMask[OpIdx] * OpRatio +
22624                    RootMaskedIdx % OpRatio);
22625   }
22626
22627   // See if we can recurse into the operand to combine more things.
22628   switch (Op.getOpcode()) {
22629     case X86ISD::PSHUFB:
22630       HasPSHUFB = true;
22631     case X86ISD::PSHUFD:
22632     case X86ISD::PSHUFHW:
22633     case X86ISD::PSHUFLW:
22634       if (Op.getOperand(0).hasOneUse() &&
22635           combineX86ShufflesRecursively(Op.getOperand(0), Root, Mask, Depth + 1,
22636                                         HasPSHUFB, DAG, DCI, Subtarget))
22637         return true;
22638       break;
22639
22640     case X86ISD::UNPCKL:
22641     case X86ISD::UNPCKH:
22642       assert(Op.getOperand(0) == Op.getOperand(1) && "We only combine unary shuffles!");
22643       // We can't check for single use, we have to check that this shuffle is the only user.
22644       if (Op->isOnlyUserOf(Op.getOperand(0).getNode()) &&
22645           combineX86ShufflesRecursively(Op.getOperand(0), Root, Mask, Depth + 1,
22646                                         HasPSHUFB, DAG, DCI, Subtarget))
22647           return true;
22648       break;
22649   }
22650
22651   // Minor canonicalization of the accumulated shuffle mask to make it easier
22652   // to match below. All this does is detect masks with squential pairs of
22653   // elements, and shrink them to the half-width mask. It does this in a loop
22654   // so it will reduce the size of the mask to the minimal width mask which
22655   // performs an equivalent shuffle.
22656   SmallVector<int, 16> WidenedMask;
22657   while (Mask.size() > 1 && canWidenShuffleElements(Mask, WidenedMask)) {
22658     Mask = std::move(WidenedMask);
22659     WidenedMask.clear();
22660   }
22661
22662   return combineX86ShuffleChain(Op, Root, Mask, Depth, HasPSHUFB, DAG, DCI,
22663                                 Subtarget);
22664 }
22665
22666 /// \brief Get the PSHUF-style mask from PSHUF node.
22667 ///
22668 /// This is a very minor wrapper around getTargetShuffleMask to easy forming v4
22669 /// PSHUF-style masks that can be reused with such instructions.
22670 static SmallVector<int, 4> getPSHUFShuffleMask(SDValue N) {
22671   SmallVector<int, 4> Mask;
22672   bool IsUnary;
22673   bool HaveMask = getTargetShuffleMask(N.getNode(), N.getSimpleValueType(), Mask, IsUnary);
22674   (void)HaveMask;
22675   assert(HaveMask);
22676
22677   switch (N.getOpcode()) {
22678   case X86ISD::PSHUFD:
22679     return Mask;
22680   case X86ISD::PSHUFLW:
22681     Mask.resize(4);
22682     return Mask;
22683   case X86ISD::PSHUFHW:
22684     Mask.erase(Mask.begin(), Mask.begin() + 4);
22685     for (int &M : Mask)
22686       M -= 4;
22687     return Mask;
22688   default:
22689     llvm_unreachable("No valid shuffle instruction found!");
22690   }
22691 }
22692
22693 /// \brief Search for a combinable shuffle across a chain ending in pshufd.
22694 ///
22695 /// We walk up the chain and look for a combinable shuffle, skipping over
22696 /// shuffles that we could hoist this shuffle's transformation past without
22697 /// altering anything.
22698 static SDValue
22699 combineRedundantDWordShuffle(SDValue N, MutableArrayRef<int> Mask,
22700                              SelectionDAG &DAG,
22701                              TargetLowering::DAGCombinerInfo &DCI) {
22702   assert(N.getOpcode() == X86ISD::PSHUFD &&
22703          "Called with something other than an x86 128-bit half shuffle!");
22704   SDLoc DL(N);
22705
22706   // Walk up a single-use chain looking for a combinable shuffle. Keep a stack
22707   // of the shuffles in the chain so that we can form a fresh chain to replace
22708   // this one.
22709   SmallVector<SDValue, 8> Chain;
22710   SDValue V = N.getOperand(0);
22711   for (; V.hasOneUse(); V = V.getOperand(0)) {
22712     switch (V.getOpcode()) {
22713     default:
22714       return SDValue(); // Nothing combined!
22715
22716     case ISD::BITCAST:
22717       // Skip bitcasts as we always know the type for the target specific
22718       // instructions.
22719       continue;
22720
22721     case X86ISD::PSHUFD:
22722       // Found another dword shuffle.
22723       break;
22724
22725     case X86ISD::PSHUFLW:
22726       // Check that the low words (being shuffled) are the identity in the
22727       // dword shuffle, and the high words are self-contained.
22728       if (Mask[0] != 0 || Mask[1] != 1 ||
22729           !(Mask[2] >= 2 && Mask[2] < 4 && Mask[3] >= 2 && Mask[3] < 4))
22730         return SDValue();
22731
22732       Chain.push_back(V);
22733       continue;
22734
22735     case X86ISD::PSHUFHW:
22736       // Check that the high words (being shuffled) are the identity in the
22737       // dword shuffle, and the low words are self-contained.
22738       if (Mask[2] != 2 || Mask[3] != 3 ||
22739           !(Mask[0] >= 0 && Mask[0] < 2 && Mask[1] >= 0 && Mask[1] < 2))
22740         return SDValue();
22741
22742       Chain.push_back(V);
22743       continue;
22744
22745     case X86ISD::UNPCKL:
22746     case X86ISD::UNPCKH:
22747       // For either i8 -> i16 or i16 -> i32 unpacks, we can combine a dword
22748       // shuffle into a preceding word shuffle.
22749       if (V.getValueType() != MVT::v16i8 && V.getValueType() != MVT::v8i16)
22750         return SDValue();
22751
22752       // Search for a half-shuffle which we can combine with.
22753       unsigned CombineOp =
22754           V.getOpcode() == X86ISD::UNPCKL ? X86ISD::PSHUFLW : X86ISD::PSHUFHW;
22755       if (V.getOperand(0) != V.getOperand(1) ||
22756           !V->isOnlyUserOf(V.getOperand(0).getNode()))
22757         return SDValue();
22758       Chain.push_back(V);
22759       V = V.getOperand(0);
22760       do {
22761         switch (V.getOpcode()) {
22762         default:
22763           return SDValue(); // Nothing to combine.
22764
22765         case X86ISD::PSHUFLW:
22766         case X86ISD::PSHUFHW:
22767           if (V.getOpcode() == CombineOp)
22768             break;
22769
22770           Chain.push_back(V);
22771
22772           // Fallthrough!
22773         case ISD::BITCAST:
22774           V = V.getOperand(0);
22775           continue;
22776         }
22777         break;
22778       } while (V.hasOneUse());
22779       break;
22780     }
22781     // Break out of the loop if we break out of the switch.
22782     break;
22783   }
22784
22785   if (!V.hasOneUse())
22786     // We fell out of the loop without finding a viable combining instruction.
22787     return SDValue();
22788
22789   // Merge this node's mask and our incoming mask.
22790   SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22791   for (int &M : Mask)
22792     M = VMask[M];
22793   V = DAG.getNode(V.getOpcode(), DL, V.getValueType(), V.getOperand(0),
22794                   getV4X86ShuffleImm8ForMask(Mask, DAG));
22795
22796   // Rebuild the chain around this new shuffle.
22797   while (!Chain.empty()) {
22798     SDValue W = Chain.pop_back_val();
22799
22800     if (V.getValueType() != W.getOperand(0).getValueType())
22801       V = DAG.getNode(ISD::BITCAST, DL, W.getOperand(0).getValueType(), V);
22802
22803     switch (W.getOpcode()) {
22804     default:
22805       llvm_unreachable("Only PSHUF and UNPCK instructions get here!");
22806
22807     case X86ISD::UNPCKL:
22808     case X86ISD::UNPCKH:
22809       V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, V);
22810       break;
22811
22812     case X86ISD::PSHUFD:
22813     case X86ISD::PSHUFLW:
22814     case X86ISD::PSHUFHW:
22815       V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, W.getOperand(1));
22816       break;
22817     }
22818   }
22819   if (V.getValueType() != N.getValueType())
22820     V = DAG.getNode(ISD::BITCAST, DL, N.getValueType(), V);
22821
22822   // Return the new chain to replace N.
22823   return V;
22824 }
22825
22826 /// \brief Search for a combinable shuffle across a chain ending in pshuflw or pshufhw.
22827 ///
22828 /// We walk up the chain, skipping shuffles of the other half and looking
22829 /// through shuffles which switch halves trying to find a shuffle of the same
22830 /// pair of dwords.
22831 static bool combineRedundantHalfShuffle(SDValue N, MutableArrayRef<int> Mask,
22832                                         SelectionDAG &DAG,
22833                                         TargetLowering::DAGCombinerInfo &DCI) {
22834   assert(
22835       (N.getOpcode() == X86ISD::PSHUFLW || N.getOpcode() == X86ISD::PSHUFHW) &&
22836       "Called with something other than an x86 128-bit half shuffle!");
22837   SDLoc DL(N);
22838   unsigned CombineOpcode = N.getOpcode();
22839
22840   // Walk up a single-use chain looking for a combinable shuffle.
22841   SDValue V = N.getOperand(0);
22842   for (; V.hasOneUse(); V = V.getOperand(0)) {
22843     switch (V.getOpcode()) {
22844     default:
22845       return false; // Nothing combined!
22846
22847     case ISD::BITCAST:
22848       // Skip bitcasts as we always know the type for the target specific
22849       // instructions.
22850       continue;
22851
22852     case X86ISD::PSHUFLW:
22853     case X86ISD::PSHUFHW:
22854       if (V.getOpcode() == CombineOpcode)
22855         break;
22856
22857       // Other-half shuffles are no-ops.
22858       continue;
22859     }
22860     // Break out of the loop if we break out of the switch.
22861     break;
22862   }
22863
22864   if (!V.hasOneUse())
22865     // We fell out of the loop without finding a viable combining instruction.
22866     return false;
22867
22868   // Combine away the bottom node as its shuffle will be accumulated into
22869   // a preceding shuffle.
22870   DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
22871
22872   // Record the old value.
22873   SDValue Old = V;
22874
22875   // Merge this node's mask and our incoming mask (adjusted to account for all
22876   // the pshufd instructions encountered).
22877   SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22878   for (int &M : Mask)
22879     M = VMask[M];
22880   V = DAG.getNode(V.getOpcode(), DL, MVT::v8i16, V.getOperand(0),
22881                   getV4X86ShuffleImm8ForMask(Mask, DAG));
22882
22883   // Check that the shuffles didn't cancel each other out. If not, we need to
22884   // combine to the new one.
22885   if (Old != V)
22886     // Replace the combinable shuffle with the combined one, updating all users
22887     // so that we re-evaluate the chain here.
22888     DCI.CombineTo(Old.getNode(), V, /*AddTo*/ true);
22889
22890   return true;
22891 }
22892
22893 /// \brief Try to combine x86 target specific shuffles.
22894 static SDValue PerformTargetShuffleCombine(SDValue N, SelectionDAG &DAG,
22895                                            TargetLowering::DAGCombinerInfo &DCI,
22896                                            const X86Subtarget *Subtarget) {
22897   SDLoc DL(N);
22898   MVT VT = N.getSimpleValueType();
22899   SmallVector<int, 4> Mask;
22900
22901   switch (N.getOpcode()) {
22902   case X86ISD::PSHUFD:
22903   case X86ISD::PSHUFLW:
22904   case X86ISD::PSHUFHW:
22905     Mask = getPSHUFShuffleMask(N);
22906     assert(Mask.size() == 4);
22907     break;
22908   default:
22909     return SDValue();
22910   }
22911
22912   // Nuke no-op shuffles that show up after combining.
22913   if (isNoopShuffleMask(Mask))
22914     return DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
22915
22916   // Look for simplifications involving one or two shuffle instructions.
22917   SDValue V = N.getOperand(0);
22918   switch (N.getOpcode()) {
22919   default:
22920     break;
22921   case X86ISD::PSHUFLW:
22922   case X86ISD::PSHUFHW:
22923     assert(VT == MVT::v8i16);
22924     (void)VT;
22925
22926     if (combineRedundantHalfShuffle(N, Mask, DAG, DCI))
22927       return SDValue(); // We combined away this shuffle, so we're done.
22928
22929     // See if this reduces to a PSHUFD which is no more expensive and can
22930     // combine with more operations. Note that it has to at least flip the
22931     // dwords as otherwise it would have been removed as a no-op.
22932     if (Mask[0] == 2 && Mask[1] == 3 && Mask[2] == 0 && Mask[3] == 1) {
22933       int DMask[] = {0, 1, 2, 3};
22934       int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2;
22935       DMask[DOffset + 0] = DOffset + 1;
22936       DMask[DOffset + 1] = DOffset + 0;
22937       V = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V);
22938       DCI.AddToWorklist(V.getNode());
22939       V = DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V,
22940                       getV4X86ShuffleImm8ForMask(DMask, DAG));
22941       DCI.AddToWorklist(V.getNode());
22942       return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
22943     }
22944
22945     // Look for shuffle patterns which can be implemented as a single unpack.
22946     // FIXME: This doesn't handle the location of the PSHUFD generically, and
22947     // only works when we have a PSHUFD followed by two half-shuffles.
22948     if (Mask[0] == Mask[1] && Mask[2] == Mask[3] &&
22949         (V.getOpcode() == X86ISD::PSHUFLW ||
22950          V.getOpcode() == X86ISD::PSHUFHW) &&
22951         V.getOpcode() != N.getOpcode() &&
22952         V.hasOneUse()) {
22953       SDValue D = V.getOperand(0);
22954       while (D.getOpcode() == ISD::BITCAST && D.hasOneUse())
22955         D = D.getOperand(0);
22956       if (D.getOpcode() == X86ISD::PSHUFD && D.hasOneUse()) {
22957         SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22958         SmallVector<int, 4> DMask = getPSHUFShuffleMask(D);
22959         int NOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 4;
22960         int VOffset = V.getOpcode() == X86ISD::PSHUFLW ? 0 : 4;
22961         int WordMask[8];
22962         for (int i = 0; i < 4; ++i) {
22963           WordMask[i + NOffset] = Mask[i] + NOffset;
22964           WordMask[i + VOffset] = VMask[i] + VOffset;
22965         }
22966         // Map the word mask through the DWord mask.
22967         int MappedMask[8];
22968         for (int i = 0; i < 8; ++i)
22969           MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2;
22970         const int UnpackLoMask[] = {0, 0, 1, 1, 2, 2, 3, 3};
22971         const int UnpackHiMask[] = {4, 4, 5, 5, 6, 6, 7, 7};
22972         if (std::equal(std::begin(MappedMask), std::end(MappedMask),
22973                        std::begin(UnpackLoMask)) ||
22974             std::equal(std::begin(MappedMask), std::end(MappedMask),
22975                        std::begin(UnpackHiMask))) {
22976           // We can replace all three shuffles with an unpack.
22977           V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, D.getOperand(0));
22978           DCI.AddToWorklist(V.getNode());
22979           return DAG.getNode(MappedMask[0] == 0 ? X86ISD::UNPCKL
22980                                                 : X86ISD::UNPCKH,
22981                              DL, MVT::v8i16, V, V);
22982         }
22983       }
22984     }
22985
22986     break;
22987
22988   case X86ISD::PSHUFD:
22989     if (SDValue NewN = combineRedundantDWordShuffle(N, Mask, DAG, DCI))
22990       return NewN;
22991
22992     break;
22993   }
22994
22995   return SDValue();
22996 }
22997
22998 /// \brief Try to combine a shuffle into a target-specific add-sub node.
22999 ///
23000 /// We combine this directly on the abstract vector shuffle nodes so it is
23001 /// easier to generically match. We also insert dummy vector shuffle nodes for
23002 /// the operands which explicitly discard the lanes which are unused by this
23003 /// operation to try to flow through the rest of the combiner the fact that
23004 /// they're unused.
23005 static SDValue combineShuffleToAddSub(SDNode *N, SelectionDAG &DAG) {
23006   SDLoc DL(N);
23007   EVT VT = N->getValueType(0);
23008
23009   // We only handle target-independent shuffles.
23010   // FIXME: It would be easy and harmless to use the target shuffle mask
23011   // extraction tool to support more.
23012   if (N->getOpcode() != ISD::VECTOR_SHUFFLE)
23013     return SDValue();
23014
23015   auto *SVN = cast<ShuffleVectorSDNode>(N);
23016   ArrayRef<int> Mask = SVN->getMask();
23017   SDValue V1 = N->getOperand(0);
23018   SDValue V2 = N->getOperand(1);
23019
23020   // We require the first shuffle operand to be the SUB node, and the second to
23021   // be the ADD node.
23022   // FIXME: We should support the commuted patterns.
23023   if (V1->getOpcode() != ISD::FSUB || V2->getOpcode() != ISD::FADD)
23024     return SDValue();
23025
23026   // If there are other uses of these operations we can't fold them.
23027   if (!V1->hasOneUse() || !V2->hasOneUse())
23028     return SDValue();
23029
23030   // Ensure that both operations have the same operands. Note that we can
23031   // commute the FADD operands.
23032   SDValue LHS = V1->getOperand(0), RHS = V1->getOperand(1);
23033   if ((V2->getOperand(0) != LHS || V2->getOperand(1) != RHS) &&
23034       (V2->getOperand(0) != RHS || V2->getOperand(1) != LHS))
23035     return SDValue();
23036
23037   // We're looking for blends between FADD and FSUB nodes. We insist on these
23038   // nodes being lined up in a specific expected pattern.
23039   if (!(isShuffleEquivalent(V1, V2, Mask, 0, 3) ||
23040         isShuffleEquivalent(V1, V2, Mask, 0, 5, 2, 7) ||
23041         isShuffleEquivalent(V1, V2, Mask, 0, 9, 2, 11, 4, 13, 6, 15)))
23042     return SDValue();
23043
23044   // Only specific types are legal at this point, assert so we notice if and
23045   // when these change.
23046   assert((VT == MVT::v4f32 || VT == MVT::v2f64 || VT == MVT::v8f32 ||
23047           VT == MVT::v4f64) &&
23048          "Unknown vector type encountered!");
23049
23050   return DAG.getNode(X86ISD::ADDSUB, DL, VT, LHS, RHS);
23051 }
23052
23053 /// PerformShuffleCombine - Performs several different shuffle combines.
23054 static SDValue PerformShuffleCombine(SDNode *N, SelectionDAG &DAG,
23055                                      TargetLowering::DAGCombinerInfo &DCI,
23056                                      const X86Subtarget *Subtarget) {
23057   SDLoc dl(N);
23058   SDValue N0 = N->getOperand(0);
23059   SDValue N1 = N->getOperand(1);
23060   EVT VT = N->getValueType(0);
23061
23062   // Don't create instructions with illegal types after legalize types has run.
23063   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23064   if (!DCI.isBeforeLegalize() && !TLI.isTypeLegal(VT.getVectorElementType()))
23065     return SDValue();
23066
23067   // If we have legalized the vector types, look for blends of FADD and FSUB
23068   // nodes that we can fuse into an ADDSUB node.
23069   if (TLI.isTypeLegal(VT) && Subtarget->hasSSE3())
23070     if (SDValue AddSub = combineShuffleToAddSub(N, DAG))
23071       return AddSub;
23072
23073   // Combine 256-bit vector shuffles. This is only profitable when in AVX mode
23074   if (Subtarget->hasFp256() && VT.is256BitVector() &&
23075       N->getOpcode() == ISD::VECTOR_SHUFFLE)
23076     return PerformShuffleCombine256(N, DAG, DCI, Subtarget);
23077
23078   // During Type Legalization, when promoting illegal vector types,
23079   // the backend might introduce new shuffle dag nodes and bitcasts.
23080   //
23081   // This code performs the following transformation:
23082   // fold: (shuffle (bitcast (BINOP A, B)), Undef, <Mask>) ->
23083   //       (shuffle (BINOP (bitcast A), (bitcast B)), Undef, <Mask>)
23084   //
23085   // We do this only if both the bitcast and the BINOP dag nodes have
23086   // one use. Also, perform this transformation only if the new binary
23087   // operation is legal. This is to avoid introducing dag nodes that
23088   // potentially need to be further expanded (or custom lowered) into a
23089   // less optimal sequence of dag nodes.
23090   if (!DCI.isBeforeLegalize() && DCI.isBeforeLegalizeOps() &&
23091       N1.getOpcode() == ISD::UNDEF && N0.hasOneUse() &&
23092       N0.getOpcode() == ISD::BITCAST) {
23093     SDValue BC0 = N0.getOperand(0);
23094     EVT SVT = BC0.getValueType();
23095     unsigned Opcode = BC0.getOpcode();
23096     unsigned NumElts = VT.getVectorNumElements();
23097
23098     if (BC0.hasOneUse() && SVT.isVector() &&
23099         SVT.getVectorNumElements() * 2 == NumElts &&
23100         TLI.isOperationLegal(Opcode, VT)) {
23101       bool CanFold = false;
23102       switch (Opcode) {
23103       default : break;
23104       case ISD::ADD :
23105       case ISD::FADD :
23106       case ISD::SUB :
23107       case ISD::FSUB :
23108       case ISD::MUL :
23109       case ISD::FMUL :
23110         CanFold = true;
23111       }
23112
23113       unsigned SVTNumElts = SVT.getVectorNumElements();
23114       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
23115       for (unsigned i = 0, e = SVTNumElts; i != e && CanFold; ++i)
23116         CanFold = SVOp->getMaskElt(i) == (int)(i * 2);
23117       for (unsigned i = SVTNumElts, e = NumElts; i != e && CanFold; ++i)
23118         CanFold = SVOp->getMaskElt(i) < 0;
23119
23120       if (CanFold) {
23121         SDValue BC00 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(0));
23122         SDValue BC01 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(1));
23123         SDValue NewBinOp = DAG.getNode(BC0.getOpcode(), dl, VT, BC00, BC01);
23124         return DAG.getVectorShuffle(VT, dl, NewBinOp, N1, &SVOp->getMask()[0]);
23125       }
23126     }
23127   }
23128
23129   // Only handle 128 wide vector from here on.
23130   if (!VT.is128BitVector())
23131     return SDValue();
23132
23133   // Combine a vector_shuffle that is equal to build_vector load1, load2, load3,
23134   // load4, <0, 1, 2, 3> into a 128-bit load if the load addresses are
23135   // consecutive, non-overlapping, and in the right order.
23136   SmallVector<SDValue, 16> Elts;
23137   for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
23138     Elts.push_back(getShuffleScalarElt(N, i, DAG, 0));
23139
23140   SDValue LD = EltsFromConsecutiveLoads(VT, Elts, dl, DAG, true);
23141   if (LD.getNode())
23142     return LD;
23143
23144   if (isTargetShuffle(N->getOpcode())) {
23145     SDValue Shuffle =
23146         PerformTargetShuffleCombine(SDValue(N, 0), DAG, DCI, Subtarget);
23147     if (Shuffle.getNode())
23148       return Shuffle;
23149
23150     // Try recursively combining arbitrary sequences of x86 shuffle
23151     // instructions into higher-order shuffles. We do this after combining
23152     // specific PSHUF instruction sequences into their minimal form so that we
23153     // can evaluate how many specialized shuffle instructions are involved in
23154     // a particular chain.
23155     SmallVector<int, 1> NonceMask; // Just a placeholder.
23156     NonceMask.push_back(0);
23157     if (combineX86ShufflesRecursively(SDValue(N, 0), SDValue(N, 0), NonceMask,
23158                                       /*Depth*/ 1, /*HasPSHUFB*/ false, DAG,
23159                                       DCI, Subtarget))
23160       return SDValue(); // This routine will use CombineTo to replace N.
23161   }
23162
23163   return SDValue();
23164 }
23165
23166 /// PerformTruncateCombine - Converts truncate operation to
23167 /// a sequence of vector shuffle operations.
23168 /// It is possible when we truncate 256-bit vector to 128-bit vector
23169 static SDValue PerformTruncateCombine(SDNode *N, SelectionDAG &DAG,
23170                                       TargetLowering::DAGCombinerInfo &DCI,
23171                                       const X86Subtarget *Subtarget)  {
23172   return SDValue();
23173 }
23174
23175 /// XFormVExtractWithShuffleIntoLoad - Check if a vector extract from a target
23176 /// specific shuffle of a load can be folded into a single element load.
23177 /// Similar handling for VECTOR_SHUFFLE is performed by DAGCombiner, but
23178 /// shuffles have been custom lowered so we need to handle those here.
23179 static SDValue XFormVExtractWithShuffleIntoLoad(SDNode *N, SelectionDAG &DAG,
23180                                          TargetLowering::DAGCombinerInfo &DCI) {
23181   if (DCI.isBeforeLegalizeOps())
23182     return SDValue();
23183
23184   SDValue InVec = N->getOperand(0);
23185   SDValue EltNo = N->getOperand(1);
23186
23187   if (!isa<ConstantSDNode>(EltNo))
23188     return SDValue();
23189
23190   EVT OriginalVT = InVec.getValueType();
23191
23192   if (InVec.getOpcode() == ISD::BITCAST) {
23193     // Don't duplicate a load with other uses.
23194     if (!InVec.hasOneUse())
23195       return SDValue();
23196     EVT BCVT = InVec.getOperand(0).getValueType();
23197     if (BCVT.getVectorNumElements() != OriginalVT.getVectorNumElements())
23198       return SDValue();
23199     InVec = InVec.getOperand(0);
23200   }
23201
23202   EVT CurrentVT = InVec.getValueType();
23203
23204   if (!isTargetShuffle(InVec.getOpcode()))
23205     return SDValue();
23206
23207   // Don't duplicate a load with other uses.
23208   if (!InVec.hasOneUse())
23209     return SDValue();
23210
23211   SmallVector<int, 16> ShuffleMask;
23212   bool UnaryShuffle;
23213   if (!getTargetShuffleMask(InVec.getNode(), CurrentVT.getSimpleVT(),
23214                             ShuffleMask, UnaryShuffle))
23215     return SDValue();
23216
23217   // Select the input vector, guarding against out of range extract vector.
23218   unsigned NumElems = CurrentVT.getVectorNumElements();
23219   int Elt = cast<ConstantSDNode>(EltNo)->getZExtValue();
23220   int Idx = (Elt > (int)NumElems) ? -1 : ShuffleMask[Elt];
23221   SDValue LdNode = (Idx < (int)NumElems) ? InVec.getOperand(0)
23222                                          : InVec.getOperand(1);
23223
23224   // If inputs to shuffle are the same for both ops, then allow 2 uses
23225   unsigned AllowedUses = InVec.getNumOperands() > 1 &&
23226                          InVec.getOperand(0) == InVec.getOperand(1) ? 2 : 1;
23227
23228   if (LdNode.getOpcode() == ISD::BITCAST) {
23229     // Don't duplicate a load with other uses.
23230     if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
23231       return SDValue();
23232
23233     AllowedUses = 1; // only allow 1 load use if we have a bitcast
23234     LdNode = LdNode.getOperand(0);
23235   }
23236
23237   if (!ISD::isNormalLoad(LdNode.getNode()))
23238     return SDValue();
23239
23240   LoadSDNode *LN0 = cast<LoadSDNode>(LdNode);
23241
23242   if (!LN0 ||!LN0->hasNUsesOfValue(AllowedUses, 0) || LN0->isVolatile())
23243     return SDValue();
23244
23245   EVT EltVT = N->getValueType(0);
23246   // If there's a bitcast before the shuffle, check if the load type and
23247   // alignment is valid.
23248   unsigned Align = LN0->getAlignment();
23249   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23250   unsigned NewAlign = TLI.getDataLayout()->getABITypeAlignment(
23251       EltVT.getTypeForEVT(*DAG.getContext()));
23252
23253   if (NewAlign > Align || !TLI.isOperationLegalOrCustom(ISD::LOAD, EltVT))
23254     return SDValue();
23255
23256   // All checks match so transform back to vector_shuffle so that DAG combiner
23257   // can finish the job
23258   SDLoc dl(N);
23259
23260   // Create shuffle node taking into account the case that its a unary shuffle
23261   SDValue Shuffle = (UnaryShuffle) ? DAG.getUNDEF(CurrentVT)
23262                                    : InVec.getOperand(1);
23263   Shuffle = DAG.getVectorShuffle(CurrentVT, dl,
23264                                  InVec.getOperand(0), Shuffle,
23265                                  &ShuffleMask[0]);
23266   Shuffle = DAG.getNode(ISD::BITCAST, dl, OriginalVT, Shuffle);
23267   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
23268                      EltNo);
23269 }
23270
23271 /// \brief Detect bitcasts between i32 to x86mmx low word. Since MMX types are
23272 /// special and don't usually play with other vector types, it's better to
23273 /// handle them early to be sure we emit efficient code by avoiding
23274 /// store-load conversions.
23275 static SDValue PerformBITCASTCombine(SDNode *N, SelectionDAG &DAG) {
23276   if (N->getValueType(0) != MVT::x86mmx ||
23277       N->getOperand(0)->getOpcode() != ISD::BUILD_VECTOR ||
23278       N->getOperand(0)->getValueType(0) != MVT::v2i32)
23279     return SDValue();
23280
23281   SDValue V = N->getOperand(0);
23282   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V.getOperand(1));
23283   if (C && C->getZExtValue() == 0 && V.getOperand(0).getValueType() == MVT::i32)
23284     return DAG.getNode(X86ISD::MMX_MOVW2D, SDLoc(V.getOperand(0)),
23285                        N->getValueType(0), V.getOperand(0));
23286
23287   return SDValue();
23288 }
23289
23290 /// PerformEXTRACT_VECTOR_ELTCombine - Detect vector gather/scatter index
23291 /// generation and convert it from being a bunch of shuffles and extracts
23292 /// into a somewhat faster sequence. For i686, the best sequence is apparently
23293 /// storing the value and loading scalars back, while for x64 we should
23294 /// use 64-bit extracts and shifts.
23295 static SDValue PerformEXTRACT_VECTOR_ELTCombine(SDNode *N, SelectionDAG &DAG,
23296                                          TargetLowering::DAGCombinerInfo &DCI) {
23297   SDValue NewOp = XFormVExtractWithShuffleIntoLoad(N, DAG, DCI);
23298   if (NewOp.getNode())
23299     return NewOp;
23300
23301   SDValue InputVector = N->getOperand(0);
23302
23303   // Detect mmx to i32 conversion through a v2i32 elt extract.
23304   if (InputVector.getOpcode() == ISD::BITCAST && InputVector.hasOneUse() &&
23305       N->getValueType(0) == MVT::i32 &&
23306       InputVector.getValueType() == MVT::v2i32) {
23307
23308     // The bitcast source is a direct mmx result.
23309     SDValue MMXSrc = InputVector.getNode()->getOperand(0);
23310     if (MMXSrc.getValueType() == MVT::x86mmx)
23311       return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
23312                          N->getValueType(0),
23313                          InputVector.getNode()->getOperand(0));
23314
23315     // The mmx is indirect: (i64 extract_elt (v1i64 bitcast (x86mmx ...))).
23316     SDValue MMXSrcOp = MMXSrc.getOperand(0);
23317     if (MMXSrc.getOpcode() == ISD::EXTRACT_VECTOR_ELT && MMXSrc.hasOneUse() &&
23318         MMXSrc.getValueType() == MVT::i64 && MMXSrcOp.hasOneUse() &&
23319         MMXSrcOp.getOpcode() == ISD::BITCAST &&
23320         MMXSrcOp.getValueType() == MVT::v1i64 &&
23321         MMXSrcOp.getOperand(0).getValueType() == MVT::x86mmx)
23322       return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
23323                          N->getValueType(0),
23324                          MMXSrcOp.getOperand(0));
23325   }
23326
23327   // Only operate on vectors of 4 elements, where the alternative shuffling
23328   // gets to be more expensive.
23329   if (InputVector.getValueType() != MVT::v4i32)
23330     return SDValue();
23331
23332   // Check whether every use of InputVector is an EXTRACT_VECTOR_ELT with a
23333   // single use which is a sign-extend or zero-extend, and all elements are
23334   // used.
23335   SmallVector<SDNode *, 4> Uses;
23336   unsigned ExtractedElements = 0;
23337   for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
23338        UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
23339     if (UI.getUse().getResNo() != InputVector.getResNo())
23340       return SDValue();
23341
23342     SDNode *Extract = *UI;
23343     if (Extract->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
23344       return SDValue();
23345
23346     if (Extract->getValueType(0) != MVT::i32)
23347       return SDValue();
23348     if (!Extract->hasOneUse())
23349       return SDValue();
23350     if (Extract->use_begin()->getOpcode() != ISD::SIGN_EXTEND &&
23351         Extract->use_begin()->getOpcode() != ISD::ZERO_EXTEND)
23352       return SDValue();
23353     if (!isa<ConstantSDNode>(Extract->getOperand(1)))
23354       return SDValue();
23355
23356     // Record which element was extracted.
23357     ExtractedElements |=
23358       1 << cast<ConstantSDNode>(Extract->getOperand(1))->getZExtValue();
23359
23360     Uses.push_back(Extract);
23361   }
23362
23363   // If not all the elements were used, this may not be worthwhile.
23364   if (ExtractedElements != 15)
23365     return SDValue();
23366
23367   // Ok, we've now decided to do the transformation.
23368   // If 64-bit shifts are legal, use the extract-shift sequence,
23369   // otherwise bounce the vector off the cache.
23370   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23371   SDValue Vals[4];
23372   SDLoc dl(InputVector);
23373
23374   if (TLI.isOperationLegal(ISD::SRA, MVT::i64)) {
23375     SDValue Cst = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, InputVector);
23376     EVT VecIdxTy = DAG.getTargetLoweringInfo().getVectorIdxTy();
23377     SDValue BottomHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Cst,
23378       DAG.getConstant(0, VecIdxTy));
23379     SDValue TopHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Cst,
23380       DAG.getConstant(1, VecIdxTy));
23381
23382     SDValue ShAmt = DAG.getConstant(32,
23383       DAG.getTargetLoweringInfo().getShiftAmountTy(MVT::i64));
23384     Vals[0] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BottomHalf);
23385     Vals[1] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
23386       DAG.getNode(ISD::SRA, dl, MVT::i64, BottomHalf, ShAmt));
23387     Vals[2] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, TopHalf);
23388     Vals[3] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
23389       DAG.getNode(ISD::SRA, dl, MVT::i64, TopHalf, ShAmt));
23390   } else {
23391     // Store the value to a temporary stack slot.
23392     SDValue StackPtr = DAG.CreateStackTemporary(InputVector.getValueType());
23393     SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, InputVector, StackPtr,
23394       MachinePointerInfo(), false, false, 0);
23395
23396     EVT ElementType = InputVector.getValueType().getVectorElementType();
23397     unsigned EltSize = ElementType.getSizeInBits() / 8;
23398
23399     // Replace each use (extract) with a load of the appropriate element.
23400     for (unsigned i = 0; i < 4; ++i) {
23401       uint64_t Offset = EltSize * i;
23402       SDValue OffsetVal = DAG.getConstant(Offset, TLI.getPointerTy());
23403
23404       SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
23405                                        StackPtr, OffsetVal);
23406
23407       // Load the scalar.
23408       Vals[i] = DAG.getLoad(ElementType, dl, Ch,
23409                             ScalarAddr, MachinePointerInfo(),
23410                             false, false, false, 0);
23411
23412     }
23413   }
23414
23415   // Replace the extracts
23416   for (SmallVectorImpl<SDNode *>::iterator UI = Uses.begin(),
23417     UE = Uses.end(); UI != UE; ++UI) {
23418     SDNode *Extract = *UI;
23419
23420     SDValue Idx = Extract->getOperand(1);
23421     uint64_t IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
23422     DAG.ReplaceAllUsesOfValueWith(SDValue(Extract, 0), Vals[IdxVal]);
23423   }
23424
23425   // The replacement was made in place; don't return anything.
23426   return SDValue();
23427 }
23428
23429 /// \brief Matches a VSELECT onto min/max or return 0 if the node doesn't match.
23430 static std::pair<unsigned, bool>
23431 matchIntegerMINMAX(SDValue Cond, EVT VT, SDValue LHS, SDValue RHS,
23432                    SelectionDAG &DAG, const X86Subtarget *Subtarget) {
23433   if (!VT.isVector())
23434     return std::make_pair(0, false);
23435
23436   bool NeedSplit = false;
23437   switch (VT.getSimpleVT().SimpleTy) {
23438   default: return std::make_pair(0, false);
23439   case MVT::v4i64:
23440   case MVT::v2i64:
23441     if (!Subtarget->hasVLX())
23442       return std::make_pair(0, false);
23443     break;
23444   case MVT::v64i8:
23445   case MVT::v32i16:
23446     if (!Subtarget->hasBWI())
23447       return std::make_pair(0, false);
23448     break;
23449   case MVT::v16i32:
23450   case MVT::v8i64:
23451     if (!Subtarget->hasAVX512())
23452       return std::make_pair(0, false);
23453     break;
23454   case MVT::v32i8:
23455   case MVT::v16i16:
23456   case MVT::v8i32:
23457     if (!Subtarget->hasAVX2())
23458       NeedSplit = true;
23459     if (!Subtarget->hasAVX())
23460       return std::make_pair(0, false);
23461     break;
23462   case MVT::v16i8:
23463   case MVT::v8i16:
23464   case MVT::v4i32:
23465     if (!Subtarget->hasSSE2())
23466       return std::make_pair(0, false);
23467   }
23468
23469   // SSE2 has only a small subset of the operations.
23470   bool hasUnsigned = Subtarget->hasSSE41() ||
23471                      (Subtarget->hasSSE2() && VT == MVT::v16i8);
23472   bool hasSigned = Subtarget->hasSSE41() ||
23473                    (Subtarget->hasSSE2() && VT == MVT::v8i16);
23474
23475   ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23476
23477   unsigned Opc = 0;
23478   // Check for x CC y ? x : y.
23479   if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23480       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23481     switch (CC) {
23482     default: break;
23483     case ISD::SETULT:
23484     case ISD::SETULE:
23485       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
23486     case ISD::SETUGT:
23487     case ISD::SETUGE:
23488       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
23489     case ISD::SETLT:
23490     case ISD::SETLE:
23491       Opc = hasSigned ? X86ISD::SMIN : 0; break;
23492     case ISD::SETGT:
23493     case ISD::SETGE:
23494       Opc = hasSigned ? X86ISD::SMAX : 0; break;
23495     }
23496   // Check for x CC y ? y : x -- a min/max with reversed arms.
23497   } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
23498              DAG.isEqualTo(RHS, Cond.getOperand(0))) {
23499     switch (CC) {
23500     default: break;
23501     case ISD::SETULT:
23502     case ISD::SETULE:
23503       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
23504     case ISD::SETUGT:
23505     case ISD::SETUGE:
23506       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
23507     case ISD::SETLT:
23508     case ISD::SETLE:
23509       Opc = hasSigned ? X86ISD::SMAX : 0; break;
23510     case ISD::SETGT:
23511     case ISD::SETGE:
23512       Opc = hasSigned ? X86ISD::SMIN : 0; break;
23513     }
23514   }
23515
23516   return std::make_pair(Opc, NeedSplit);
23517 }
23518
23519 static SDValue
23520 transformVSELECTtoBlendVECTOR_SHUFFLE(SDNode *N, SelectionDAG &DAG,
23521                                       const X86Subtarget *Subtarget) {
23522   SDLoc dl(N);
23523   SDValue Cond = N->getOperand(0);
23524   SDValue LHS = N->getOperand(1);
23525   SDValue RHS = N->getOperand(2);
23526
23527   if (Cond.getOpcode() == ISD::SIGN_EXTEND) {
23528     SDValue CondSrc = Cond->getOperand(0);
23529     if (CondSrc->getOpcode() == ISD::SIGN_EXTEND_INREG)
23530       Cond = CondSrc->getOperand(0);
23531   }
23532
23533   if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
23534     return SDValue();
23535
23536   // A vselect where all conditions and data are constants can be optimized into
23537   // a single vector load by SelectionDAGLegalize::ExpandBUILD_VECTOR().
23538   if (ISD::isBuildVectorOfConstantSDNodes(LHS.getNode()) &&
23539       ISD::isBuildVectorOfConstantSDNodes(RHS.getNode()))
23540     return SDValue();
23541
23542   unsigned MaskValue = 0;
23543   if (!BUILD_VECTORtoBlendMask(cast<BuildVectorSDNode>(Cond), MaskValue))
23544     return SDValue();
23545
23546   MVT VT = N->getSimpleValueType(0);
23547   unsigned NumElems = VT.getVectorNumElements();
23548   SmallVector<int, 8> ShuffleMask(NumElems, -1);
23549   for (unsigned i = 0; i < NumElems; ++i) {
23550     // Be sure we emit undef where we can.
23551     if (Cond.getOperand(i)->getOpcode() == ISD::UNDEF)
23552       ShuffleMask[i] = -1;
23553     else
23554       ShuffleMask[i] = i + NumElems * ((MaskValue >> i) & 1);
23555   }
23556
23557   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23558   if (!TLI.isShuffleMaskLegal(ShuffleMask, VT))
23559     return SDValue();
23560   return DAG.getVectorShuffle(VT, dl, LHS, RHS, &ShuffleMask[0]);
23561 }
23562
23563 /// PerformSELECTCombine - Do target-specific dag combines on SELECT and VSELECT
23564 /// nodes.
23565 static SDValue PerformSELECTCombine(SDNode *N, SelectionDAG &DAG,
23566                                     TargetLowering::DAGCombinerInfo &DCI,
23567                                     const X86Subtarget *Subtarget) {
23568   SDLoc DL(N);
23569   SDValue Cond = N->getOperand(0);
23570   // Get the LHS/RHS of the select.
23571   SDValue LHS = N->getOperand(1);
23572   SDValue RHS = N->getOperand(2);
23573   EVT VT = LHS.getValueType();
23574   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23575
23576   // If we have SSE[12] support, try to form min/max nodes. SSE min/max
23577   // instructions match the semantics of the common C idiom x<y?x:y but not
23578   // x<=y?x:y, because of how they handle negative zero (which can be
23579   // ignored in unsafe-math mode).
23580   // We also try to create v2f32 min/max nodes, which we later widen to v4f32.
23581   if (Cond.getOpcode() == ISD::SETCC && VT.isFloatingPoint() &&
23582       VT != MVT::f80 && (TLI.isTypeLegal(VT) || VT == MVT::v2f32) &&
23583       (Subtarget->hasSSE2() ||
23584        (Subtarget->hasSSE1() && VT.getScalarType() == MVT::f32))) {
23585     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23586
23587     unsigned Opcode = 0;
23588     // Check for x CC y ? x : y.
23589     if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23590         DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23591       switch (CC) {
23592       default: break;
23593       case ISD::SETULT:
23594         // Converting this to a min would handle NaNs incorrectly, and swapping
23595         // the operands would cause it to handle comparisons between positive
23596         // and negative zero incorrectly.
23597         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
23598           if (!DAG.getTarget().Options.UnsafeFPMath &&
23599               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
23600             break;
23601           std::swap(LHS, RHS);
23602         }
23603         Opcode = X86ISD::FMIN;
23604         break;
23605       case ISD::SETOLE:
23606         // Converting this to a min would handle comparisons between positive
23607         // and negative zero incorrectly.
23608         if (!DAG.getTarget().Options.UnsafeFPMath &&
23609             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
23610           break;
23611         Opcode = X86ISD::FMIN;
23612         break;
23613       case ISD::SETULE:
23614         // Converting this to a min would handle both negative zeros and NaNs
23615         // incorrectly, but we can swap the operands to fix both.
23616         std::swap(LHS, RHS);
23617       case ISD::SETOLT:
23618       case ISD::SETLT:
23619       case ISD::SETLE:
23620         Opcode = X86ISD::FMIN;
23621         break;
23622
23623       case ISD::SETOGE:
23624         // Converting this to a max would handle comparisons between positive
23625         // and negative zero incorrectly.
23626         if (!DAG.getTarget().Options.UnsafeFPMath &&
23627             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
23628           break;
23629         Opcode = X86ISD::FMAX;
23630         break;
23631       case ISD::SETUGT:
23632         // Converting this to a max would handle NaNs incorrectly, and swapping
23633         // the operands would cause it to handle comparisons between positive
23634         // and negative zero incorrectly.
23635         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
23636           if (!DAG.getTarget().Options.UnsafeFPMath &&
23637               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
23638             break;
23639           std::swap(LHS, RHS);
23640         }
23641         Opcode = X86ISD::FMAX;
23642         break;
23643       case ISD::SETUGE:
23644         // Converting this to a max would handle both negative zeros and NaNs
23645         // incorrectly, but we can swap the operands to fix both.
23646         std::swap(LHS, RHS);
23647       case ISD::SETOGT:
23648       case ISD::SETGT:
23649       case ISD::SETGE:
23650         Opcode = X86ISD::FMAX;
23651         break;
23652       }
23653     // Check for x CC y ? y : x -- a min/max with reversed arms.
23654     } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
23655                DAG.isEqualTo(RHS, Cond.getOperand(0))) {
23656       switch (CC) {
23657       default: break;
23658       case ISD::SETOGE:
23659         // Converting this to a min would handle comparisons between positive
23660         // and negative zero incorrectly, and swapping the operands would
23661         // cause it to handle NaNs incorrectly.
23662         if (!DAG.getTarget().Options.UnsafeFPMath &&
23663             !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS))) {
23664           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23665             break;
23666           std::swap(LHS, RHS);
23667         }
23668         Opcode = X86ISD::FMIN;
23669         break;
23670       case ISD::SETUGT:
23671         // Converting this to a min would handle NaNs incorrectly.
23672         if (!DAG.getTarget().Options.UnsafeFPMath &&
23673             (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)))
23674           break;
23675         Opcode = X86ISD::FMIN;
23676         break;
23677       case ISD::SETUGE:
23678         // Converting this to a min would handle both negative zeros and NaNs
23679         // incorrectly, but we can swap the operands to fix both.
23680         std::swap(LHS, RHS);
23681       case ISD::SETOGT:
23682       case ISD::SETGT:
23683       case ISD::SETGE:
23684         Opcode = X86ISD::FMIN;
23685         break;
23686
23687       case ISD::SETULT:
23688         // Converting this to a max would handle NaNs incorrectly.
23689         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23690           break;
23691         Opcode = X86ISD::FMAX;
23692         break;
23693       case ISD::SETOLE:
23694         // Converting this to a max would handle comparisons between positive
23695         // and negative zero incorrectly, and swapping the operands would
23696         // cause it to handle NaNs incorrectly.
23697         if (!DAG.getTarget().Options.UnsafeFPMath &&
23698             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS)) {
23699           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23700             break;
23701           std::swap(LHS, RHS);
23702         }
23703         Opcode = X86ISD::FMAX;
23704         break;
23705       case ISD::SETULE:
23706         // Converting this to a max would handle both negative zeros and NaNs
23707         // incorrectly, but we can swap the operands to fix both.
23708         std::swap(LHS, RHS);
23709       case ISD::SETOLT:
23710       case ISD::SETLT:
23711       case ISD::SETLE:
23712         Opcode = X86ISD::FMAX;
23713         break;
23714       }
23715     }
23716
23717     if (Opcode)
23718       return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
23719   }
23720
23721   EVT CondVT = Cond.getValueType();
23722   if (Subtarget->hasAVX512() && VT.isVector() && CondVT.isVector() &&
23723       CondVT.getVectorElementType() == MVT::i1) {
23724     // v16i8 (select v16i1, v16i8, v16i8) does not have a proper
23725     // lowering on KNL. In this case we convert it to
23726     // v16i8 (select v16i8, v16i8, v16i8) and use AVX instruction.
23727     // The same situation for all 128 and 256-bit vectors of i8 and i16.
23728     // Since SKX these selects have a proper lowering.
23729     EVT OpVT = LHS.getValueType();
23730     if ((OpVT.is128BitVector() || OpVT.is256BitVector()) &&
23731         (OpVT.getVectorElementType() == MVT::i8 ||
23732          OpVT.getVectorElementType() == MVT::i16) &&
23733         !(Subtarget->hasBWI() && Subtarget->hasVLX())) {
23734       Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, OpVT, Cond);
23735       DCI.AddToWorklist(Cond.getNode());
23736       return DAG.getNode(N->getOpcode(), DL, OpVT, Cond, LHS, RHS);
23737     }
23738   }
23739   // If this is a select between two integer constants, try to do some
23740   // optimizations.
23741   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(LHS)) {
23742     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(RHS))
23743       // Don't do this for crazy integer types.
23744       if (DAG.getTargetLoweringInfo().isTypeLegal(LHS.getValueType())) {
23745         // If this is efficiently invertible, canonicalize the LHSC/RHSC values
23746         // so that TrueC (the true value) is larger than FalseC.
23747         bool NeedsCondInvert = false;
23748
23749         if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue()) &&
23750             // Efficiently invertible.
23751             (Cond.getOpcode() == ISD::SETCC ||  // setcc -> invertible.
23752              (Cond.getOpcode() == ISD::XOR &&   // xor(X, C) -> invertible.
23753               isa<ConstantSDNode>(Cond.getOperand(1))))) {
23754           NeedsCondInvert = true;
23755           std::swap(TrueC, FalseC);
23756         }
23757
23758         // Optimize C ? 8 : 0 -> zext(C) << 3.  Likewise for any pow2/0.
23759         if (FalseC->getAPIntValue() == 0 &&
23760             TrueC->getAPIntValue().isPowerOf2()) {
23761           if (NeedsCondInvert) // Invert the condition if needed.
23762             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23763                                DAG.getConstant(1, Cond.getValueType()));
23764
23765           // Zero extend the condition if needed.
23766           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
23767
23768           unsigned ShAmt = TrueC->getAPIntValue().logBase2();
23769           return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
23770                              DAG.getConstant(ShAmt, MVT::i8));
23771         }
23772
23773         // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.
23774         if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
23775           if (NeedsCondInvert) // Invert the condition if needed.
23776             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23777                                DAG.getConstant(1, Cond.getValueType()));
23778
23779           // Zero extend the condition if needed.
23780           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
23781                              FalseC->getValueType(0), Cond);
23782           return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
23783                              SDValue(FalseC, 0));
23784         }
23785
23786         // Optimize cases that will turn into an LEA instruction.  This requires
23787         // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
23788         if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
23789           uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
23790           if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
23791
23792           bool isFastMultiplier = false;
23793           if (Diff < 10) {
23794             switch ((unsigned char)Diff) {
23795               default: break;
23796               case 1:  // result = add base, cond
23797               case 2:  // result = lea base(    , cond*2)
23798               case 3:  // result = lea base(cond, cond*2)
23799               case 4:  // result = lea base(    , cond*4)
23800               case 5:  // result = lea base(cond, cond*4)
23801               case 8:  // result = lea base(    , cond*8)
23802               case 9:  // result = lea base(cond, cond*8)
23803                 isFastMultiplier = true;
23804                 break;
23805             }
23806           }
23807
23808           if (isFastMultiplier) {
23809             APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
23810             if (NeedsCondInvert) // Invert the condition if needed.
23811               Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23812                                  DAG.getConstant(1, Cond.getValueType()));
23813
23814             // Zero extend the condition if needed.
23815             Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
23816                                Cond);
23817             // Scale the condition by the difference.
23818             if (Diff != 1)
23819               Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
23820                                  DAG.getConstant(Diff, Cond.getValueType()));
23821
23822             // Add the base if non-zero.
23823             if (FalseC->getAPIntValue() != 0)
23824               Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
23825                                  SDValue(FalseC, 0));
23826             return Cond;
23827           }
23828         }
23829       }
23830   }
23831
23832   // Canonicalize max and min:
23833   // (x > y) ? x : y -> (x >= y) ? x : y
23834   // (x < y) ? x : y -> (x <= y) ? x : y
23835   // This allows use of COND_S / COND_NS (see TranslateX86CC) which eliminates
23836   // the need for an extra compare
23837   // against zero. e.g.
23838   // (x - y) > 0 : (x - y) ? 0 -> (x - y) >= 0 : (x - y) ? 0
23839   // subl   %esi, %edi
23840   // testl  %edi, %edi
23841   // movl   $0, %eax
23842   // cmovgl %edi, %eax
23843   // =>
23844   // xorl   %eax, %eax
23845   // subl   %esi, $edi
23846   // cmovsl %eax, %edi
23847   if (N->getOpcode() == ISD::SELECT && Cond.getOpcode() == ISD::SETCC &&
23848       DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23849       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23850     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23851     switch (CC) {
23852     default: break;
23853     case ISD::SETLT:
23854     case ISD::SETGT: {
23855       ISD::CondCode NewCC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGE;
23856       Cond = DAG.getSetCC(SDLoc(Cond), Cond.getValueType(),
23857                           Cond.getOperand(0), Cond.getOperand(1), NewCC);
23858       return DAG.getNode(ISD::SELECT, DL, VT, Cond, LHS, RHS);
23859     }
23860     }
23861   }
23862
23863   // Early exit check
23864   if (!TLI.isTypeLegal(VT))
23865     return SDValue();
23866
23867   // Match VSELECTs into subs with unsigned saturation.
23868   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC &&
23869       // psubus is available in SSE2 and AVX2 for i8 and i16 vectors.
23870       ((Subtarget->hasSSE2() && (VT == MVT::v16i8 || VT == MVT::v8i16)) ||
23871        (Subtarget->hasAVX2() && (VT == MVT::v32i8 || VT == MVT::v16i16)))) {
23872     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23873
23874     // Check if one of the arms of the VSELECT is a zero vector. If it's on the
23875     // left side invert the predicate to simplify logic below.
23876     SDValue Other;
23877     if (ISD::isBuildVectorAllZeros(LHS.getNode())) {
23878       Other = RHS;
23879       CC = ISD::getSetCCInverse(CC, true);
23880     } else if (ISD::isBuildVectorAllZeros(RHS.getNode())) {
23881       Other = LHS;
23882     }
23883
23884     if (Other.getNode() && Other->getNumOperands() == 2 &&
23885         DAG.isEqualTo(Other->getOperand(0), Cond.getOperand(0))) {
23886       SDValue OpLHS = Other->getOperand(0), OpRHS = Other->getOperand(1);
23887       SDValue CondRHS = Cond->getOperand(1);
23888
23889       // Look for a general sub with unsigned saturation first.
23890       // x >= y ? x-y : 0 --> subus x, y
23891       // x >  y ? x-y : 0 --> subus x, y
23892       if ((CC == ISD::SETUGE || CC == ISD::SETUGT) &&
23893           Other->getOpcode() == ISD::SUB && DAG.isEqualTo(OpRHS, CondRHS))
23894         return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
23895
23896       if (auto *OpRHSBV = dyn_cast<BuildVectorSDNode>(OpRHS))
23897         if (auto *OpRHSConst = OpRHSBV->getConstantSplatNode()) {
23898           if (auto *CondRHSBV = dyn_cast<BuildVectorSDNode>(CondRHS))
23899             if (auto *CondRHSConst = CondRHSBV->getConstantSplatNode())
23900               // If the RHS is a constant we have to reverse the const
23901               // canonicalization.
23902               // x > C-1 ? x+-C : 0 --> subus x, C
23903               if (CC == ISD::SETUGT && Other->getOpcode() == ISD::ADD &&
23904                   CondRHSConst->getAPIntValue() ==
23905                       (-OpRHSConst->getAPIntValue() - 1))
23906                 return DAG.getNode(
23907                     X86ISD::SUBUS, DL, VT, OpLHS,
23908                     DAG.getConstant(-OpRHSConst->getAPIntValue(), VT));
23909
23910           // Another special case: If C was a sign bit, the sub has been
23911           // canonicalized into a xor.
23912           // FIXME: Would it be better to use computeKnownBits to determine
23913           //        whether it's safe to decanonicalize the xor?
23914           // x s< 0 ? x^C : 0 --> subus x, C
23915           if (CC == ISD::SETLT && Other->getOpcode() == ISD::XOR &&
23916               ISD::isBuildVectorAllZeros(CondRHS.getNode()) &&
23917               OpRHSConst->getAPIntValue().isSignBit())
23918             // Note that we have to rebuild the RHS constant here to ensure we
23919             // don't rely on particular values of undef lanes.
23920             return DAG.getNode(
23921                 X86ISD::SUBUS, DL, VT, OpLHS,
23922                 DAG.getConstant(OpRHSConst->getAPIntValue(), VT));
23923         }
23924     }
23925   }
23926
23927   // Try to match a min/max vector operation.
23928   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC) {
23929     std::pair<unsigned, bool> ret = matchIntegerMINMAX(Cond, VT, LHS, RHS, DAG, Subtarget);
23930     unsigned Opc = ret.first;
23931     bool NeedSplit = ret.second;
23932
23933     if (Opc && NeedSplit) {
23934       unsigned NumElems = VT.getVectorNumElements();
23935       // Extract the LHS vectors
23936       SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, DL);
23937       SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, DL);
23938
23939       // Extract the RHS vectors
23940       SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, DL);
23941       SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, DL);
23942
23943       // Create min/max for each subvector
23944       LHS = DAG.getNode(Opc, DL, LHS1.getValueType(), LHS1, RHS1);
23945       RHS = DAG.getNode(Opc, DL, LHS2.getValueType(), LHS2, RHS2);
23946
23947       // Merge the result
23948       return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LHS, RHS);
23949     } else if (Opc)
23950       return DAG.getNode(Opc, DL, VT, LHS, RHS);
23951   }
23952
23953   // Simplify vector selection if condition value type matches vselect
23954   // operand type
23955   if (N->getOpcode() == ISD::VSELECT && CondVT == VT) {
23956     assert(Cond.getValueType().isVector() &&
23957            "vector select expects a vector selector!");
23958
23959     bool TValIsAllOnes = ISD::isBuildVectorAllOnes(LHS.getNode());
23960     bool FValIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
23961
23962     // Try invert the condition if true value is not all 1s and false value
23963     // is not all 0s.
23964     if (!TValIsAllOnes && !FValIsAllZeros &&
23965         // Check if the selector will be produced by CMPP*/PCMP*
23966         Cond.getOpcode() == ISD::SETCC &&
23967         // Check if SETCC has already been promoted
23968         TLI.getSetCCResultType(*DAG.getContext(), VT) == CondVT) {
23969       bool TValIsAllZeros = ISD::isBuildVectorAllZeros(LHS.getNode());
23970       bool FValIsAllOnes = ISD::isBuildVectorAllOnes(RHS.getNode());
23971
23972       if (TValIsAllZeros || FValIsAllOnes) {
23973         SDValue CC = Cond.getOperand(2);
23974         ISD::CondCode NewCC =
23975           ISD::getSetCCInverse(cast<CondCodeSDNode>(CC)->get(),
23976                                Cond.getOperand(0).getValueType().isInteger());
23977         Cond = DAG.getSetCC(DL, CondVT, Cond.getOperand(0), Cond.getOperand(1), NewCC);
23978         std::swap(LHS, RHS);
23979         TValIsAllOnes = FValIsAllOnes;
23980         FValIsAllZeros = TValIsAllZeros;
23981       }
23982     }
23983
23984     if (TValIsAllOnes || FValIsAllZeros) {
23985       SDValue Ret;
23986
23987       if (TValIsAllOnes && FValIsAllZeros)
23988         Ret = Cond;
23989       else if (TValIsAllOnes)
23990         Ret = DAG.getNode(ISD::OR, DL, CondVT, Cond,
23991                           DAG.getNode(ISD::BITCAST, DL, CondVT, RHS));
23992       else if (FValIsAllZeros)
23993         Ret = DAG.getNode(ISD::AND, DL, CondVT, Cond,
23994                           DAG.getNode(ISD::BITCAST, DL, CondVT, LHS));
23995
23996       return DAG.getNode(ISD::BITCAST, DL, VT, Ret);
23997     }
23998   }
23999
24000   // If we know that this node is legal then we know that it is going to be
24001   // matched by one of the SSE/AVX BLEND instructions. These instructions only
24002   // depend on the highest bit in each word. Try to use SimplifyDemandedBits
24003   // to simplify previous instructions.
24004   if (N->getOpcode() == ISD::VSELECT && DCI.isBeforeLegalizeOps() &&
24005       !DCI.isBeforeLegalize() &&
24006       // We explicitly check against SSE4.1, v8i16 and v16i16 because, although
24007       // vselect nodes may be marked as Custom, they might only be legal when
24008       // Cond is a build_vector of constants. This will be taken care in
24009       // a later condition.
24010       (TLI.isOperationLegalOrCustom(ISD::VSELECT, VT) &&
24011        Subtarget->hasSSE41() && VT != MVT::v16i16 && VT != MVT::v8i16) &&
24012       // Don't optimize vector of constants. Those are handled by
24013       // the generic code and all the bits must be properly set for
24014       // the generic optimizer.
24015       !ISD::isBuildVectorOfConstantSDNodes(Cond.getNode())) {
24016     unsigned BitWidth = Cond.getValueType().getScalarType().getSizeInBits();
24017
24018     // Don't optimize vector selects that map to mask-registers.
24019     if (BitWidth == 1)
24020       return SDValue();
24021
24022     assert(BitWidth >= 8 && BitWidth <= 64 && "Invalid mask size");
24023     APInt DemandedMask = APInt::getHighBitsSet(BitWidth, 1);
24024
24025     APInt KnownZero, KnownOne;
24026     TargetLowering::TargetLoweringOpt TLO(DAG, DCI.isBeforeLegalize(),
24027                                           DCI.isBeforeLegalizeOps());
24028     if (TLO.ShrinkDemandedConstant(Cond, DemandedMask) ||
24029         TLI.SimplifyDemandedBits(Cond, DemandedMask, KnownZero, KnownOne,
24030                                  TLO)) {
24031       // If we changed the computation somewhere in the DAG, this change
24032       // will affect all users of Cond.
24033       // Make sure it is fine and update all the nodes so that we do not
24034       // use the generic VSELECT anymore. Otherwise, we may perform
24035       // wrong optimizations as we messed up with the actual expectation
24036       // for the vector boolean values.
24037       if (Cond != TLO.Old) {
24038         // Check all uses of that condition operand to check whether it will be
24039         // consumed by non-BLEND instructions, which may depend on all bits are
24040         // set properly.
24041         for (SDNode::use_iterator I = Cond->use_begin(), E = Cond->use_end();
24042              I != E; ++I)
24043           if (I->getOpcode() != ISD::VSELECT)
24044             // TODO: Add other opcodes eventually lowered into BLEND.
24045             return SDValue();
24046
24047         // Update all the users of the condition, before committing the change,
24048         // so that the VSELECT optimizations that expect the correct vector
24049         // boolean value will not be triggered.
24050         for (SDNode::use_iterator I = Cond->use_begin(), E = Cond->use_end();
24051              I != E; ++I)
24052           DAG.ReplaceAllUsesOfValueWith(
24053               SDValue(*I, 0),
24054               DAG.getNode(X86ISD::SHRUNKBLEND, SDLoc(*I), I->getValueType(0),
24055                           Cond, I->getOperand(1), I->getOperand(2)));
24056         DCI.CommitTargetLoweringOpt(TLO);
24057         return SDValue();
24058       }
24059       // At this point, only Cond is changed. Change the condition
24060       // just for N to keep the opportunity to optimize all other
24061       // users their own way.
24062       DAG.ReplaceAllUsesOfValueWith(
24063           SDValue(N, 0),
24064           DAG.getNode(X86ISD::SHRUNKBLEND, SDLoc(N), N->getValueType(0),
24065                       TLO.New, N->getOperand(1), N->getOperand(2)));
24066       return SDValue();
24067     }
24068   }
24069
24070   // We should generate an X86ISD::BLENDI from a vselect if its argument
24071   // is a sign_extend_inreg of an any_extend of a BUILD_VECTOR of
24072   // constants. This specific pattern gets generated when we split a
24073   // selector for a 512 bit vector in a machine without AVX512 (but with
24074   // 256-bit vectors), during legalization:
24075   //
24076   // (vselect (sign_extend (any_extend (BUILD_VECTOR)) i1) LHS RHS)
24077   //
24078   // Iff we find this pattern and the build_vectors are built from
24079   // constants, we translate the vselect into a shuffle_vector that we
24080   // know will be matched by LowerVECTOR_SHUFFLEtoBlend.
24081   if ((N->getOpcode() == ISD::VSELECT ||
24082        N->getOpcode() == X86ISD::SHRUNKBLEND) &&
24083       !DCI.isBeforeLegalize()) {
24084     SDValue Shuffle = transformVSELECTtoBlendVECTOR_SHUFFLE(N, DAG, Subtarget);
24085     if (Shuffle.getNode())
24086       return Shuffle;
24087   }
24088
24089   return SDValue();
24090 }
24091
24092 // Check whether a boolean test is testing a boolean value generated by
24093 // X86ISD::SETCC. If so, return the operand of that SETCC and proper condition
24094 // code.
24095 //
24096 // Simplify the following patterns:
24097 // (Op (CMP (SETCC Cond EFLAGS) 1) EQ) or
24098 // (Op (CMP (SETCC Cond EFLAGS) 0) NEQ)
24099 // to (Op EFLAGS Cond)
24100 //
24101 // (Op (CMP (SETCC Cond EFLAGS) 0) EQ) or
24102 // (Op (CMP (SETCC Cond EFLAGS) 1) NEQ)
24103 // to (Op EFLAGS !Cond)
24104 //
24105 // where Op could be BRCOND or CMOV.
24106 //
24107 static SDValue checkBoolTestSetCCCombine(SDValue Cmp, X86::CondCode &CC) {
24108   // Quit if not CMP and SUB with its value result used.
24109   if (Cmp.getOpcode() != X86ISD::CMP &&
24110       (Cmp.getOpcode() != X86ISD::SUB || Cmp.getNode()->hasAnyUseOfValue(0)))
24111       return SDValue();
24112
24113   // Quit if not used as a boolean value.
24114   if (CC != X86::COND_E && CC != X86::COND_NE)
24115     return SDValue();
24116
24117   // Check CMP operands. One of them should be 0 or 1 and the other should be
24118   // an SetCC or extended from it.
24119   SDValue Op1 = Cmp.getOperand(0);
24120   SDValue Op2 = Cmp.getOperand(1);
24121
24122   SDValue SetCC;
24123   const ConstantSDNode* C = nullptr;
24124   bool needOppositeCond = (CC == X86::COND_E);
24125   bool checkAgainstTrue = false; // Is it a comparison against 1?
24126
24127   if ((C = dyn_cast<ConstantSDNode>(Op1)))
24128     SetCC = Op2;
24129   else if ((C = dyn_cast<ConstantSDNode>(Op2)))
24130     SetCC = Op1;
24131   else // Quit if all operands are not constants.
24132     return SDValue();
24133
24134   if (C->getZExtValue() == 1) {
24135     needOppositeCond = !needOppositeCond;
24136     checkAgainstTrue = true;
24137   } else if (C->getZExtValue() != 0)
24138     // Quit if the constant is neither 0 or 1.
24139     return SDValue();
24140
24141   bool truncatedToBoolWithAnd = false;
24142   // Skip (zext $x), (trunc $x), or (and $x, 1) node.
24143   while (SetCC.getOpcode() == ISD::ZERO_EXTEND ||
24144          SetCC.getOpcode() == ISD::TRUNCATE ||
24145          SetCC.getOpcode() == ISD::AND) {
24146     if (SetCC.getOpcode() == ISD::AND) {
24147       int OpIdx = -1;
24148       ConstantSDNode *CS;
24149       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(0))) &&
24150           CS->getZExtValue() == 1)
24151         OpIdx = 1;
24152       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(1))) &&
24153           CS->getZExtValue() == 1)
24154         OpIdx = 0;
24155       if (OpIdx == -1)
24156         break;
24157       SetCC = SetCC.getOperand(OpIdx);
24158       truncatedToBoolWithAnd = true;
24159     } else
24160       SetCC = SetCC.getOperand(0);
24161   }
24162
24163   switch (SetCC.getOpcode()) {
24164   case X86ISD::SETCC_CARRY:
24165     // Since SETCC_CARRY gives output based on R = CF ? ~0 : 0, it's unsafe to
24166     // simplify it if the result of SETCC_CARRY is not canonicalized to 0 or 1,
24167     // i.e. it's a comparison against true but the result of SETCC_CARRY is not
24168     // truncated to i1 using 'and'.
24169     if (checkAgainstTrue && !truncatedToBoolWithAnd)
24170       break;
24171     assert(X86::CondCode(SetCC.getConstantOperandVal(0)) == X86::COND_B &&
24172            "Invalid use of SETCC_CARRY!");
24173     // FALL THROUGH
24174   case X86ISD::SETCC:
24175     // Set the condition code or opposite one if necessary.
24176     CC = X86::CondCode(SetCC.getConstantOperandVal(0));
24177     if (needOppositeCond)
24178       CC = X86::GetOppositeBranchCondition(CC);
24179     return SetCC.getOperand(1);
24180   case X86ISD::CMOV: {
24181     // Check whether false/true value has canonical one, i.e. 0 or 1.
24182     ConstantSDNode *FVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(0));
24183     ConstantSDNode *TVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(1));
24184     // Quit if true value is not a constant.
24185     if (!TVal)
24186       return SDValue();
24187     // Quit if false value is not a constant.
24188     if (!FVal) {
24189       SDValue Op = SetCC.getOperand(0);
24190       // Skip 'zext' or 'trunc' node.
24191       if (Op.getOpcode() == ISD::ZERO_EXTEND ||
24192           Op.getOpcode() == ISD::TRUNCATE)
24193         Op = Op.getOperand(0);
24194       // A special case for rdrand/rdseed, where 0 is set if false cond is
24195       // found.
24196       if ((Op.getOpcode() != X86ISD::RDRAND &&
24197            Op.getOpcode() != X86ISD::RDSEED) || Op.getResNo() != 0)
24198         return SDValue();
24199     }
24200     // Quit if false value is not the constant 0 or 1.
24201     bool FValIsFalse = true;
24202     if (FVal && FVal->getZExtValue() != 0) {
24203       if (FVal->getZExtValue() != 1)
24204         return SDValue();
24205       // If FVal is 1, opposite cond is needed.
24206       needOppositeCond = !needOppositeCond;
24207       FValIsFalse = false;
24208     }
24209     // Quit if TVal is not the constant opposite of FVal.
24210     if (FValIsFalse && TVal->getZExtValue() != 1)
24211       return SDValue();
24212     if (!FValIsFalse && TVal->getZExtValue() != 0)
24213       return SDValue();
24214     CC = X86::CondCode(SetCC.getConstantOperandVal(2));
24215     if (needOppositeCond)
24216       CC = X86::GetOppositeBranchCondition(CC);
24217     return SetCC.getOperand(3);
24218   }
24219   }
24220
24221   return SDValue();
24222 }
24223
24224 /// Optimize X86ISD::CMOV [LHS, RHS, CONDCODE (e.g. X86::COND_NE), CONDVAL]
24225 static SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG,
24226                                   TargetLowering::DAGCombinerInfo &DCI,
24227                                   const X86Subtarget *Subtarget) {
24228   SDLoc DL(N);
24229
24230   // If the flag operand isn't dead, don't touch this CMOV.
24231   if (N->getNumValues() == 2 && !SDValue(N, 1).use_empty())
24232     return SDValue();
24233
24234   SDValue FalseOp = N->getOperand(0);
24235   SDValue TrueOp = N->getOperand(1);
24236   X86::CondCode CC = (X86::CondCode)N->getConstantOperandVal(2);
24237   SDValue Cond = N->getOperand(3);
24238
24239   if (CC == X86::COND_E || CC == X86::COND_NE) {
24240     switch (Cond.getOpcode()) {
24241     default: break;
24242     case X86ISD::BSR:
24243     case X86ISD::BSF:
24244       // If operand of BSR / BSF are proven never zero, then ZF cannot be set.
24245       if (DAG.isKnownNeverZero(Cond.getOperand(0)))
24246         return (CC == X86::COND_E) ? FalseOp : TrueOp;
24247     }
24248   }
24249
24250   SDValue Flags;
24251
24252   Flags = checkBoolTestSetCCCombine(Cond, CC);
24253   if (Flags.getNode() &&
24254       // Extra check as FCMOV only supports a subset of X86 cond.
24255       (FalseOp.getValueType() != MVT::f80 || hasFPCMov(CC))) {
24256     SDValue Ops[] = { FalseOp, TrueOp,
24257                       DAG.getConstant(CC, MVT::i8), Flags };
24258     return DAG.getNode(X86ISD::CMOV, DL, N->getVTList(), Ops);
24259   }
24260
24261   // If this is a select between two integer constants, try to do some
24262   // optimizations.  Note that the operands are ordered the opposite of SELECT
24263   // operands.
24264   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(TrueOp)) {
24265     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(FalseOp)) {
24266       // Canonicalize the TrueC/FalseC values so that TrueC (the true value) is
24267       // larger than FalseC (the false value).
24268       if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue())) {
24269         CC = X86::GetOppositeBranchCondition(CC);
24270         std::swap(TrueC, FalseC);
24271         std::swap(TrueOp, FalseOp);
24272       }
24273
24274       // Optimize C ? 8 : 0 -> zext(setcc(C)) << 3.  Likewise for any pow2/0.
24275       // This is efficient for any integer data type (including i8/i16) and
24276       // shift amount.
24277       if (FalseC->getAPIntValue() == 0 && TrueC->getAPIntValue().isPowerOf2()) {
24278         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
24279                            DAG.getConstant(CC, MVT::i8), Cond);
24280
24281         // Zero extend the condition if needed.
24282         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
24283
24284         unsigned ShAmt = TrueC->getAPIntValue().logBase2();
24285         Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
24286                            DAG.getConstant(ShAmt, MVT::i8));
24287         if (N->getNumValues() == 2)  // Dead flag value?
24288           return DCI.CombineTo(N, Cond, SDValue());
24289         return Cond;
24290       }
24291
24292       // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.  This is efficient
24293       // for any integer data type, including i8/i16.
24294       if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
24295         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
24296                            DAG.getConstant(CC, MVT::i8), Cond);
24297
24298         // Zero extend the condition if needed.
24299         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
24300                            FalseC->getValueType(0), Cond);
24301         Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
24302                            SDValue(FalseC, 0));
24303
24304         if (N->getNumValues() == 2)  // Dead flag value?
24305           return DCI.CombineTo(N, Cond, SDValue());
24306         return Cond;
24307       }
24308
24309       // Optimize cases that will turn into an LEA instruction.  This requires
24310       // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
24311       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
24312         uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
24313         if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
24314
24315         bool isFastMultiplier = false;
24316         if (Diff < 10) {
24317           switch ((unsigned char)Diff) {
24318           default: break;
24319           case 1:  // result = add base, cond
24320           case 2:  // result = lea base(    , cond*2)
24321           case 3:  // result = lea base(cond, cond*2)
24322           case 4:  // result = lea base(    , cond*4)
24323           case 5:  // result = lea base(cond, cond*4)
24324           case 8:  // result = lea base(    , cond*8)
24325           case 9:  // result = lea base(cond, cond*8)
24326             isFastMultiplier = true;
24327             break;
24328           }
24329         }
24330
24331         if (isFastMultiplier) {
24332           APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
24333           Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
24334                              DAG.getConstant(CC, MVT::i8), Cond);
24335           // Zero extend the condition if needed.
24336           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
24337                              Cond);
24338           // Scale the condition by the difference.
24339           if (Diff != 1)
24340             Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
24341                                DAG.getConstant(Diff, Cond.getValueType()));
24342
24343           // Add the base if non-zero.
24344           if (FalseC->getAPIntValue() != 0)
24345             Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
24346                                SDValue(FalseC, 0));
24347           if (N->getNumValues() == 2)  // Dead flag value?
24348             return DCI.CombineTo(N, Cond, SDValue());
24349           return Cond;
24350         }
24351       }
24352     }
24353   }
24354
24355   // Handle these cases:
24356   //   (select (x != c), e, c) -> select (x != c), e, x),
24357   //   (select (x == c), c, e) -> select (x == c), x, e)
24358   // where the c is an integer constant, and the "select" is the combination
24359   // of CMOV and CMP.
24360   //
24361   // The rationale for this change is that the conditional-move from a constant
24362   // needs two instructions, however, conditional-move from a register needs
24363   // only one instruction.
24364   //
24365   // CAVEAT: By replacing a constant with a symbolic value, it may obscure
24366   //  some instruction-combining opportunities. This opt needs to be
24367   //  postponed as late as possible.
24368   //
24369   if (!DCI.isBeforeLegalize() && !DCI.isBeforeLegalizeOps()) {
24370     // the DCI.xxxx conditions are provided to postpone the optimization as
24371     // late as possible.
24372
24373     ConstantSDNode *CmpAgainst = nullptr;
24374     if ((Cond.getOpcode() == X86ISD::CMP || Cond.getOpcode() == X86ISD::SUB) &&
24375         (CmpAgainst = dyn_cast<ConstantSDNode>(Cond.getOperand(1))) &&
24376         !isa<ConstantSDNode>(Cond.getOperand(0))) {
24377
24378       if (CC == X86::COND_NE &&
24379           CmpAgainst == dyn_cast<ConstantSDNode>(FalseOp)) {
24380         CC = X86::GetOppositeBranchCondition(CC);
24381         std::swap(TrueOp, FalseOp);
24382       }
24383
24384       if (CC == X86::COND_E &&
24385           CmpAgainst == dyn_cast<ConstantSDNode>(TrueOp)) {
24386         SDValue Ops[] = { FalseOp, Cond.getOperand(0),
24387                           DAG.getConstant(CC, MVT::i8), Cond };
24388         return DAG.getNode(X86ISD::CMOV, DL, N->getVTList (), Ops);
24389       }
24390     }
24391   }
24392
24393   return SDValue();
24394 }
24395
24396 static SDValue PerformINTRINSIC_WO_CHAINCombine(SDNode *N, SelectionDAG &DAG,
24397                                                 const X86Subtarget *Subtarget) {
24398   unsigned IntNo = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
24399   switch (IntNo) {
24400   default: return SDValue();
24401   // SSE/AVX/AVX2 blend intrinsics.
24402   case Intrinsic::x86_avx2_pblendvb:
24403   case Intrinsic::x86_avx2_pblendw:
24404   case Intrinsic::x86_avx2_pblendd_128:
24405   case Intrinsic::x86_avx2_pblendd_256:
24406     // Don't try to simplify this intrinsic if we don't have AVX2.
24407     if (!Subtarget->hasAVX2())
24408       return SDValue();
24409     // FALL-THROUGH
24410   case Intrinsic::x86_avx_blend_pd_256:
24411   case Intrinsic::x86_avx_blend_ps_256:
24412   case Intrinsic::x86_avx_blendv_pd_256:
24413   case Intrinsic::x86_avx_blendv_ps_256:
24414     // Don't try to simplify this intrinsic if we don't have AVX.
24415     if (!Subtarget->hasAVX())
24416       return SDValue();
24417     // FALL-THROUGH
24418   case Intrinsic::x86_sse41_pblendw:
24419   case Intrinsic::x86_sse41_blendpd:
24420   case Intrinsic::x86_sse41_blendps:
24421   case Intrinsic::x86_sse41_blendvps:
24422   case Intrinsic::x86_sse41_blendvpd:
24423   case Intrinsic::x86_sse41_pblendvb: {
24424     SDValue Op0 = N->getOperand(1);
24425     SDValue Op1 = N->getOperand(2);
24426     SDValue Mask = N->getOperand(3);
24427
24428     // Don't try to simplify this intrinsic if we don't have SSE4.1.
24429     if (!Subtarget->hasSSE41())
24430       return SDValue();
24431
24432     // fold (blend A, A, Mask) -> A
24433     if (Op0 == Op1)
24434       return Op0;
24435     // fold (blend A, B, allZeros) -> A
24436     if (ISD::isBuildVectorAllZeros(Mask.getNode()))
24437       return Op0;
24438     // fold (blend A, B, allOnes) -> B
24439     if (ISD::isBuildVectorAllOnes(Mask.getNode()))
24440       return Op1;
24441
24442     // Simplify the case where the mask is a constant i32 value.
24443     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Mask)) {
24444       if (C->isNullValue())
24445         return Op0;
24446       if (C->isAllOnesValue())
24447         return Op1;
24448     }
24449
24450     return SDValue();
24451   }
24452
24453   // Packed SSE2/AVX2 arithmetic shift immediate intrinsics.
24454   case Intrinsic::x86_sse2_psrai_w:
24455   case Intrinsic::x86_sse2_psrai_d:
24456   case Intrinsic::x86_avx2_psrai_w:
24457   case Intrinsic::x86_avx2_psrai_d:
24458   case Intrinsic::x86_sse2_psra_w:
24459   case Intrinsic::x86_sse2_psra_d:
24460   case Intrinsic::x86_avx2_psra_w:
24461   case Intrinsic::x86_avx2_psra_d: {
24462     SDValue Op0 = N->getOperand(1);
24463     SDValue Op1 = N->getOperand(2);
24464     EVT VT = Op0.getValueType();
24465     assert(VT.isVector() && "Expected a vector type!");
24466
24467     if (isa<BuildVectorSDNode>(Op1))
24468       Op1 = Op1.getOperand(0);
24469
24470     if (!isa<ConstantSDNode>(Op1))
24471       return SDValue();
24472
24473     EVT SVT = VT.getVectorElementType();
24474     unsigned SVTBits = SVT.getSizeInBits();
24475
24476     ConstantSDNode *CND = cast<ConstantSDNode>(Op1);
24477     const APInt &C = APInt(SVTBits, CND->getAPIntValue().getZExtValue());
24478     uint64_t ShAmt = C.getZExtValue();
24479
24480     // Don't try to convert this shift into a ISD::SRA if the shift
24481     // count is bigger than or equal to the element size.
24482     if (ShAmt >= SVTBits)
24483       return SDValue();
24484
24485     // Trivial case: if the shift count is zero, then fold this
24486     // into the first operand.
24487     if (ShAmt == 0)
24488       return Op0;
24489
24490     // Replace this packed shift intrinsic with a target independent
24491     // shift dag node.
24492     SDValue Splat = DAG.getConstant(C, VT);
24493     return DAG.getNode(ISD::SRA, SDLoc(N), VT, Op0, Splat);
24494   }
24495   }
24496 }
24497
24498 /// PerformMulCombine - Optimize a single multiply with constant into two
24499 /// in order to implement it with two cheaper instructions, e.g.
24500 /// LEA + SHL, LEA + LEA.
24501 static SDValue PerformMulCombine(SDNode *N, SelectionDAG &DAG,
24502                                  TargetLowering::DAGCombinerInfo &DCI) {
24503   if (DCI.isBeforeLegalize() || DCI.isCalledByLegalizer())
24504     return SDValue();
24505
24506   EVT VT = N->getValueType(0);
24507   if (VT != MVT::i64 && VT != MVT::i32)
24508     return SDValue();
24509
24510   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1));
24511   if (!C)
24512     return SDValue();
24513   uint64_t MulAmt = C->getZExtValue();
24514   if (isPowerOf2_64(MulAmt) || MulAmt == 3 || MulAmt == 5 || MulAmt == 9)
24515     return SDValue();
24516
24517   uint64_t MulAmt1 = 0;
24518   uint64_t MulAmt2 = 0;
24519   if ((MulAmt % 9) == 0) {
24520     MulAmt1 = 9;
24521     MulAmt2 = MulAmt / 9;
24522   } else if ((MulAmt % 5) == 0) {
24523     MulAmt1 = 5;
24524     MulAmt2 = MulAmt / 5;
24525   } else if ((MulAmt % 3) == 0) {
24526     MulAmt1 = 3;
24527     MulAmt2 = MulAmt / 3;
24528   }
24529   if (MulAmt2 &&
24530       (isPowerOf2_64(MulAmt2) || MulAmt2 == 3 || MulAmt2 == 5 || MulAmt2 == 9)){
24531     SDLoc DL(N);
24532
24533     if (isPowerOf2_64(MulAmt2) &&
24534         !(N->hasOneUse() && N->use_begin()->getOpcode() == ISD::ADD))
24535       // If second multiplifer is pow2, issue it first. We want the multiply by
24536       // 3, 5, or 9 to be folded into the addressing mode unless the lone use
24537       // is an add.
24538       std::swap(MulAmt1, MulAmt2);
24539
24540     SDValue NewMul;
24541     if (isPowerOf2_64(MulAmt1))
24542       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
24543                            DAG.getConstant(Log2_64(MulAmt1), MVT::i8));
24544     else
24545       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
24546                            DAG.getConstant(MulAmt1, VT));
24547
24548     if (isPowerOf2_64(MulAmt2))
24549       NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
24550                            DAG.getConstant(Log2_64(MulAmt2), MVT::i8));
24551     else
24552       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
24553                            DAG.getConstant(MulAmt2, VT));
24554
24555     // Do not add new nodes to DAG combiner worklist.
24556     DCI.CombineTo(N, NewMul, false);
24557   }
24558   return SDValue();
24559 }
24560
24561 static SDValue PerformSHLCombine(SDNode *N, SelectionDAG &DAG) {
24562   SDValue N0 = N->getOperand(0);
24563   SDValue N1 = N->getOperand(1);
24564   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
24565   EVT VT = N0.getValueType();
24566
24567   // fold (shl (and (setcc_c), c1), c2) -> (and setcc_c, (c1 << c2))
24568   // since the result of setcc_c is all zero's or all ones.
24569   if (VT.isInteger() && !VT.isVector() &&
24570       N1C && N0.getOpcode() == ISD::AND &&
24571       N0.getOperand(1).getOpcode() == ISD::Constant) {
24572     SDValue N00 = N0.getOperand(0);
24573     if (N00.getOpcode() == X86ISD::SETCC_CARRY ||
24574         ((N00.getOpcode() == ISD::ANY_EXTEND ||
24575           N00.getOpcode() == ISD::ZERO_EXTEND) &&
24576          N00.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY)) {
24577       APInt Mask = cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue();
24578       APInt ShAmt = N1C->getAPIntValue();
24579       Mask = Mask.shl(ShAmt);
24580       if (Mask != 0)
24581         return DAG.getNode(ISD::AND, SDLoc(N), VT,
24582                            N00, DAG.getConstant(Mask, VT));
24583     }
24584   }
24585
24586   // Hardware support for vector shifts is sparse which makes us scalarize the
24587   // vector operations in many cases. Also, on sandybridge ADD is faster than
24588   // shl.
24589   // (shl V, 1) -> add V,V
24590   if (auto *N1BV = dyn_cast<BuildVectorSDNode>(N1))
24591     if (auto *N1SplatC = N1BV->getConstantSplatNode()) {
24592       assert(N0.getValueType().isVector() && "Invalid vector shift type");
24593       // We shift all of the values by one. In many cases we do not have
24594       // hardware support for this operation. This is better expressed as an ADD
24595       // of two values.
24596       if (N1SplatC->getZExtValue() == 1)
24597         return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N0);
24598     }
24599
24600   return SDValue();
24601 }
24602
24603 /// \brief Returns a vector of 0s if the node in input is a vector logical
24604 /// shift by a constant amount which is known to be bigger than or equal
24605 /// to the vector element size in bits.
24606 static SDValue performShiftToAllZeros(SDNode *N, SelectionDAG &DAG,
24607                                       const X86Subtarget *Subtarget) {
24608   EVT VT = N->getValueType(0);
24609
24610   if (VT != MVT::v2i64 && VT != MVT::v4i32 && VT != MVT::v8i16 &&
24611       (!Subtarget->hasInt256() ||
24612        (VT != MVT::v4i64 && VT != MVT::v8i32 && VT != MVT::v16i16)))
24613     return SDValue();
24614
24615   SDValue Amt = N->getOperand(1);
24616   SDLoc DL(N);
24617   if (auto *AmtBV = dyn_cast<BuildVectorSDNode>(Amt))
24618     if (auto *AmtSplat = AmtBV->getConstantSplatNode()) {
24619       APInt ShiftAmt = AmtSplat->getAPIntValue();
24620       unsigned MaxAmount = VT.getVectorElementType().getSizeInBits();
24621
24622       // SSE2/AVX2 logical shifts always return a vector of 0s
24623       // if the shift amount is bigger than or equal to
24624       // the element size. The constant shift amount will be
24625       // encoded as a 8-bit immediate.
24626       if (ShiftAmt.trunc(8).uge(MaxAmount))
24627         return getZeroVector(VT, Subtarget, DAG, DL);
24628     }
24629
24630   return SDValue();
24631 }
24632
24633 /// PerformShiftCombine - Combine shifts.
24634 static SDValue PerformShiftCombine(SDNode* N, SelectionDAG &DAG,
24635                                    TargetLowering::DAGCombinerInfo &DCI,
24636                                    const X86Subtarget *Subtarget) {
24637   if (N->getOpcode() == ISD::SHL) {
24638     SDValue V = PerformSHLCombine(N, DAG);
24639     if (V.getNode()) return V;
24640   }
24641
24642   if (N->getOpcode() != ISD::SRA) {
24643     // Try to fold this logical shift into a zero vector.
24644     SDValue V = performShiftToAllZeros(N, DAG, Subtarget);
24645     if (V.getNode()) return V;
24646   }
24647
24648   return SDValue();
24649 }
24650
24651 // CMPEQCombine - Recognize the distinctive  (AND (setcc ...) (setcc ..))
24652 // where both setccs reference the same FP CMP, and rewrite for CMPEQSS
24653 // and friends.  Likewise for OR -> CMPNEQSS.
24654 static SDValue CMPEQCombine(SDNode *N, SelectionDAG &DAG,
24655                             TargetLowering::DAGCombinerInfo &DCI,
24656                             const X86Subtarget *Subtarget) {
24657   unsigned opcode;
24658
24659   // SSE1 supports CMP{eq|ne}SS, and SSE2 added CMP{eq|ne}SD, but
24660   // we're requiring SSE2 for both.
24661   if (Subtarget->hasSSE2() && isAndOrOfSetCCs(SDValue(N, 0U), opcode)) {
24662     SDValue N0 = N->getOperand(0);
24663     SDValue N1 = N->getOperand(1);
24664     SDValue CMP0 = N0->getOperand(1);
24665     SDValue CMP1 = N1->getOperand(1);
24666     SDLoc DL(N);
24667
24668     // The SETCCs should both refer to the same CMP.
24669     if (CMP0.getOpcode() != X86ISD::CMP || CMP0 != CMP1)
24670       return SDValue();
24671
24672     SDValue CMP00 = CMP0->getOperand(0);
24673     SDValue CMP01 = CMP0->getOperand(1);
24674     EVT     VT    = CMP00.getValueType();
24675
24676     if (VT == MVT::f32 || VT == MVT::f64) {
24677       bool ExpectingFlags = false;
24678       // Check for any users that want flags:
24679       for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end();
24680            !ExpectingFlags && UI != UE; ++UI)
24681         switch (UI->getOpcode()) {
24682         default:
24683         case ISD::BR_CC:
24684         case ISD::BRCOND:
24685         case ISD::SELECT:
24686           ExpectingFlags = true;
24687           break;
24688         case ISD::CopyToReg:
24689         case ISD::SIGN_EXTEND:
24690         case ISD::ZERO_EXTEND:
24691         case ISD::ANY_EXTEND:
24692           break;
24693         }
24694
24695       if (!ExpectingFlags) {
24696         enum X86::CondCode cc0 = (enum X86::CondCode)N0.getConstantOperandVal(0);
24697         enum X86::CondCode cc1 = (enum X86::CondCode)N1.getConstantOperandVal(0);
24698
24699         if (cc1 == X86::COND_E || cc1 == X86::COND_NE) {
24700           X86::CondCode tmp = cc0;
24701           cc0 = cc1;
24702           cc1 = tmp;
24703         }
24704
24705         if ((cc0 == X86::COND_E  && cc1 == X86::COND_NP) ||
24706             (cc0 == X86::COND_NE && cc1 == X86::COND_P)) {
24707           // FIXME: need symbolic constants for these magic numbers.
24708           // See X86ATTInstPrinter.cpp:printSSECC().
24709           unsigned x86cc = (cc0 == X86::COND_E) ? 0 : 4;
24710           if (Subtarget->hasAVX512()) {
24711             SDValue FSetCC = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CMP00,
24712                                          CMP01, DAG.getConstant(x86cc, MVT::i8));
24713             if (N->getValueType(0) != MVT::i1)
24714               return DAG.getNode(ISD::ZERO_EXTEND, DL, N->getValueType(0),
24715                                  FSetCC);
24716             return FSetCC;
24717           }
24718           SDValue OnesOrZeroesF = DAG.getNode(X86ISD::FSETCC, DL,
24719                                               CMP00.getValueType(), CMP00, CMP01,
24720                                               DAG.getConstant(x86cc, MVT::i8));
24721
24722           bool is64BitFP = (CMP00.getValueType() == MVT::f64);
24723           MVT IntVT = is64BitFP ? MVT::i64 : MVT::i32;
24724
24725           if (is64BitFP && !Subtarget->is64Bit()) {
24726             // On a 32-bit target, we cannot bitcast the 64-bit float to a
24727             // 64-bit integer, since that's not a legal type. Since
24728             // OnesOrZeroesF is all ones of all zeroes, we don't need all the
24729             // bits, but can do this little dance to extract the lowest 32 bits
24730             // and work with those going forward.
24731             SDValue Vector64 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64,
24732                                            OnesOrZeroesF);
24733             SDValue Vector32 = DAG.getNode(ISD::BITCAST, DL, MVT::v4f32,
24734                                            Vector64);
24735             OnesOrZeroesF = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32,
24736                                         Vector32, DAG.getIntPtrConstant(0));
24737             IntVT = MVT::i32;
24738           }
24739
24740           SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, IntVT, OnesOrZeroesF);
24741           SDValue ANDed = DAG.getNode(ISD::AND, DL, IntVT, OnesOrZeroesI,
24742                                       DAG.getConstant(1, IntVT));
24743           SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
24744           return OneBitOfTruth;
24745         }
24746       }
24747     }
24748   }
24749   return SDValue();
24750 }
24751
24752 /// CanFoldXORWithAllOnes - Test whether the XOR operand is a AllOnes vector
24753 /// so it can be folded inside ANDNP.
24754 static bool CanFoldXORWithAllOnes(const SDNode *N) {
24755   EVT VT = N->getValueType(0);
24756
24757   // Match direct AllOnes for 128 and 256-bit vectors
24758   if (ISD::isBuildVectorAllOnes(N))
24759     return true;
24760
24761   // Look through a bit convert.
24762   if (N->getOpcode() == ISD::BITCAST)
24763     N = N->getOperand(0).getNode();
24764
24765   // Sometimes the operand may come from a insert_subvector building a 256-bit
24766   // allones vector
24767   if (VT.is256BitVector() &&
24768       N->getOpcode() == ISD::INSERT_SUBVECTOR) {
24769     SDValue V1 = N->getOperand(0);
24770     SDValue V2 = N->getOperand(1);
24771
24772     if (V1.getOpcode() == ISD::INSERT_SUBVECTOR &&
24773         V1.getOperand(0).getOpcode() == ISD::UNDEF &&
24774         ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
24775         ISD::isBuildVectorAllOnes(V2.getNode()))
24776       return true;
24777   }
24778
24779   return false;
24780 }
24781
24782 // On AVX/AVX2 the type v8i1 is legalized to v8i16, which is an XMM sized
24783 // register. In most cases we actually compare or select YMM-sized registers
24784 // and mixing the two types creates horrible code. This method optimizes
24785 // some of the transition sequences.
24786 static SDValue WidenMaskArithmetic(SDNode *N, SelectionDAG &DAG,
24787                                  TargetLowering::DAGCombinerInfo &DCI,
24788                                  const X86Subtarget *Subtarget) {
24789   EVT VT = N->getValueType(0);
24790   if (!VT.is256BitVector())
24791     return SDValue();
24792
24793   assert((N->getOpcode() == ISD::ANY_EXTEND ||
24794           N->getOpcode() == ISD::ZERO_EXTEND ||
24795           N->getOpcode() == ISD::SIGN_EXTEND) && "Invalid Node");
24796
24797   SDValue Narrow = N->getOperand(0);
24798   EVT NarrowVT = Narrow->getValueType(0);
24799   if (!NarrowVT.is128BitVector())
24800     return SDValue();
24801
24802   if (Narrow->getOpcode() != ISD::XOR &&
24803       Narrow->getOpcode() != ISD::AND &&
24804       Narrow->getOpcode() != ISD::OR)
24805     return SDValue();
24806
24807   SDValue N0  = Narrow->getOperand(0);
24808   SDValue N1  = Narrow->getOperand(1);
24809   SDLoc DL(Narrow);
24810
24811   // The Left side has to be a trunc.
24812   if (N0.getOpcode() != ISD::TRUNCATE)
24813     return SDValue();
24814
24815   // The type of the truncated inputs.
24816   EVT WideVT = N0->getOperand(0)->getValueType(0);
24817   if (WideVT != VT)
24818     return SDValue();
24819
24820   // The right side has to be a 'trunc' or a constant vector.
24821   bool RHSTrunc = N1.getOpcode() == ISD::TRUNCATE;
24822   ConstantSDNode *RHSConstSplat = nullptr;
24823   if (auto *RHSBV = dyn_cast<BuildVectorSDNode>(N1))
24824     RHSConstSplat = RHSBV->getConstantSplatNode();
24825   if (!RHSTrunc && !RHSConstSplat)
24826     return SDValue();
24827
24828   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
24829
24830   if (!TLI.isOperationLegalOrPromote(Narrow->getOpcode(), WideVT))
24831     return SDValue();
24832
24833   // Set N0 and N1 to hold the inputs to the new wide operation.
24834   N0 = N0->getOperand(0);
24835   if (RHSConstSplat) {
24836     N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, WideVT.getScalarType(),
24837                      SDValue(RHSConstSplat, 0));
24838     SmallVector<SDValue, 8> C(WideVT.getVectorNumElements(), N1);
24839     N1 = DAG.getNode(ISD::BUILD_VECTOR, DL, WideVT, C);
24840   } else if (RHSTrunc) {
24841     N1 = N1->getOperand(0);
24842   }
24843
24844   // Generate the wide operation.
24845   SDValue Op = DAG.getNode(Narrow->getOpcode(), DL, WideVT, N0, N1);
24846   unsigned Opcode = N->getOpcode();
24847   switch (Opcode) {
24848   case ISD::ANY_EXTEND:
24849     return Op;
24850   case ISD::ZERO_EXTEND: {
24851     unsigned InBits = NarrowVT.getScalarType().getSizeInBits();
24852     APInt Mask = APInt::getAllOnesValue(InBits);
24853     Mask = Mask.zext(VT.getScalarType().getSizeInBits());
24854     return DAG.getNode(ISD::AND, DL, VT,
24855                        Op, DAG.getConstant(Mask, VT));
24856   }
24857   case ISD::SIGN_EXTEND:
24858     return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT,
24859                        Op, DAG.getValueType(NarrowVT));
24860   default:
24861     llvm_unreachable("Unexpected opcode");
24862   }
24863 }
24864
24865 static SDValue VectorZextCombine(SDNode *N, SelectionDAG &DAG,
24866                                  TargetLowering::DAGCombinerInfo &DCI,
24867                                  const X86Subtarget *Subtarget) {
24868   SDValue N0 = N->getOperand(0);
24869   SDValue N1 = N->getOperand(1);
24870   SDLoc DL(N);
24871
24872   // A vector zext_in_reg may be represented as a shuffle,
24873   // feeding into a bitcast (this represents anyext) feeding into
24874   // an and with a mask.
24875   // We'd like to try to combine that into a shuffle with zero
24876   // plus a bitcast, removing the and.
24877   if (N0.getOpcode() != ISD::BITCAST ||
24878       N0.getOperand(0).getOpcode() != ISD::VECTOR_SHUFFLE)
24879     return SDValue();
24880
24881   // The other side of the AND should be a splat of 2^C, where C
24882   // is the number of bits in the source type.
24883   if (N1.getOpcode() == ISD::BITCAST)
24884     N1 = N1.getOperand(0);
24885   if (N1.getOpcode() != ISD::BUILD_VECTOR)
24886     return SDValue();
24887   BuildVectorSDNode *Vector = cast<BuildVectorSDNode>(N1);
24888
24889   ShuffleVectorSDNode *Shuffle = cast<ShuffleVectorSDNode>(N0.getOperand(0));
24890   EVT SrcType = Shuffle->getValueType(0);
24891
24892   // We expect a single-source shuffle
24893   if (Shuffle->getOperand(1)->getOpcode() != ISD::UNDEF)
24894     return SDValue();
24895
24896   unsigned SrcSize = SrcType.getScalarSizeInBits();
24897
24898   APInt SplatValue, SplatUndef;
24899   unsigned SplatBitSize;
24900   bool HasAnyUndefs;
24901   if (!Vector->isConstantSplat(SplatValue, SplatUndef,
24902                                 SplatBitSize, HasAnyUndefs))
24903     return SDValue();
24904
24905   unsigned ResSize = N1.getValueType().getScalarSizeInBits();
24906   // Make sure the splat matches the mask we expect
24907   if (SplatBitSize > ResSize ||
24908       (SplatValue + 1).exactLogBase2() != (int)SrcSize)
24909     return SDValue();
24910
24911   // Make sure the input and output size make sense
24912   if (SrcSize >= ResSize || ResSize % SrcSize)
24913     return SDValue();
24914
24915   // We expect a shuffle of the form <0, u, u, u, 1, u, u, u...>
24916   // The number of u's between each two values depends on the ratio between
24917   // the source and dest type.
24918   unsigned ZextRatio = ResSize / SrcSize;
24919   bool IsZext = true;
24920   for (unsigned i = 0; i < SrcType.getVectorNumElements(); ++i) {
24921     if (i % ZextRatio) {
24922       if (Shuffle->getMaskElt(i) > 0) {
24923         // Expected undef
24924         IsZext = false;
24925         break;
24926       }
24927     } else {
24928       if (Shuffle->getMaskElt(i) != (int)(i / ZextRatio)) {
24929         // Expected element number
24930         IsZext = false;
24931         break;
24932       }
24933     }
24934   }
24935
24936   if (!IsZext)
24937     return SDValue();
24938
24939   // Ok, perform the transformation - replace the shuffle with
24940   // a shuffle of the form <0, k, k, k, 1, k, k, k> with zero
24941   // (instead of undef) where the k elements come from the zero vector.
24942   SmallVector<int, 8> Mask;
24943   unsigned NumElems = SrcType.getVectorNumElements();
24944   for (unsigned i = 0; i < NumElems; ++i)
24945     if (i % ZextRatio)
24946       Mask.push_back(NumElems);
24947     else
24948       Mask.push_back(i / ZextRatio);
24949
24950   SDValue NewShuffle = DAG.getVectorShuffle(Shuffle->getValueType(0), DL,
24951     Shuffle->getOperand(0), DAG.getConstant(0, SrcType), Mask);
24952   return DAG.getNode(ISD::BITCAST, DL,  N0.getValueType(), NewShuffle);
24953 }
24954
24955 static SDValue PerformAndCombine(SDNode *N, SelectionDAG &DAG,
24956                                  TargetLowering::DAGCombinerInfo &DCI,
24957                                  const X86Subtarget *Subtarget) {
24958   if (DCI.isBeforeLegalizeOps())
24959     return SDValue();
24960
24961   SDValue Zext = VectorZextCombine(N, DAG, DCI, Subtarget);
24962   if (Zext.getNode())
24963     return Zext;
24964
24965   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
24966   if (R.getNode())
24967     return R;
24968
24969   EVT VT = N->getValueType(0);
24970   SDValue N0 = N->getOperand(0);
24971   SDValue N1 = N->getOperand(1);
24972   SDLoc DL(N);
24973
24974   // Create BEXTR instructions
24975   // BEXTR is ((X >> imm) & (2**size-1))
24976   if (VT == MVT::i32 || VT == MVT::i64) {
24977     // Check for BEXTR.
24978     if ((Subtarget->hasBMI() || Subtarget->hasTBM()) &&
24979         (N0.getOpcode() == ISD::SRA || N0.getOpcode() == ISD::SRL)) {
24980       ConstantSDNode *MaskNode = dyn_cast<ConstantSDNode>(N1);
24981       ConstantSDNode *ShiftNode = dyn_cast<ConstantSDNode>(N0.getOperand(1));
24982       if (MaskNode && ShiftNode) {
24983         uint64_t Mask = MaskNode->getZExtValue();
24984         uint64_t Shift = ShiftNode->getZExtValue();
24985         if (isMask_64(Mask)) {
24986           uint64_t MaskSize = countPopulation(Mask);
24987           if (Shift + MaskSize <= VT.getSizeInBits())
24988             return DAG.getNode(X86ISD::BEXTR, DL, VT, N0.getOperand(0),
24989                                DAG.getConstant(Shift | (MaskSize << 8), VT));
24990         }
24991       }
24992     } // BEXTR
24993
24994     return SDValue();
24995   }
24996
24997   // Want to form ANDNP nodes:
24998   // 1) In the hopes of then easily combining them with OR and AND nodes
24999   //    to form PBLEND/PSIGN.
25000   // 2) To match ANDN packed intrinsics
25001   if (VT != MVT::v2i64 && VT != MVT::v4i64)
25002     return SDValue();
25003
25004   // Check LHS for vnot
25005   if (N0.getOpcode() == ISD::XOR &&
25006       //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
25007       CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
25008     return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
25009
25010   // Check RHS for vnot
25011   if (N1.getOpcode() == ISD::XOR &&
25012       //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
25013       CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
25014     return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
25015
25016   return SDValue();
25017 }
25018
25019 static SDValue PerformOrCombine(SDNode *N, SelectionDAG &DAG,
25020                                 TargetLowering::DAGCombinerInfo &DCI,
25021                                 const X86Subtarget *Subtarget) {
25022   if (DCI.isBeforeLegalizeOps())
25023     return SDValue();
25024
25025   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
25026   if (R.getNode())
25027     return R;
25028
25029   SDValue N0 = N->getOperand(0);
25030   SDValue N1 = N->getOperand(1);
25031   EVT VT = N->getValueType(0);
25032
25033   // look for psign/blend
25034   if (VT == MVT::v2i64 || VT == MVT::v4i64) {
25035     if (!Subtarget->hasSSSE3() ||
25036         (VT == MVT::v4i64 && !Subtarget->hasInt256()))
25037       return SDValue();
25038
25039     // Canonicalize pandn to RHS
25040     if (N0.getOpcode() == X86ISD::ANDNP)
25041       std::swap(N0, N1);
25042     // or (and (m, y), (pandn m, x))
25043     if (N0.getOpcode() == ISD::AND && N1.getOpcode() == X86ISD::ANDNP) {
25044       SDValue Mask = N1.getOperand(0);
25045       SDValue X    = N1.getOperand(1);
25046       SDValue Y;
25047       if (N0.getOperand(0) == Mask)
25048         Y = N0.getOperand(1);
25049       if (N0.getOperand(1) == Mask)
25050         Y = N0.getOperand(0);
25051
25052       // Check to see if the mask appeared in both the AND and ANDNP and
25053       if (!Y.getNode())
25054         return SDValue();
25055
25056       // Validate that X, Y, and Mask are BIT_CONVERTS, and see through them.
25057       // Look through mask bitcast.
25058       if (Mask.getOpcode() == ISD::BITCAST)
25059         Mask = Mask.getOperand(0);
25060       if (X.getOpcode() == ISD::BITCAST)
25061         X = X.getOperand(0);
25062       if (Y.getOpcode() == ISD::BITCAST)
25063         Y = Y.getOperand(0);
25064
25065       EVT MaskVT = Mask.getValueType();
25066
25067       // Validate that the Mask operand is a vector sra node.
25068       // FIXME: what to do for bytes, since there is a psignb/pblendvb, but
25069       // there is no psrai.b
25070       unsigned EltBits = MaskVT.getVectorElementType().getSizeInBits();
25071       unsigned SraAmt = ~0;
25072       if (Mask.getOpcode() == ISD::SRA) {
25073         if (auto *AmtBV = dyn_cast<BuildVectorSDNode>(Mask.getOperand(1)))
25074           if (auto *AmtConst = AmtBV->getConstantSplatNode())
25075             SraAmt = AmtConst->getZExtValue();
25076       } else if (Mask.getOpcode() == X86ISD::VSRAI) {
25077         SDValue SraC = Mask.getOperand(1);
25078         SraAmt  = cast<ConstantSDNode>(SraC)->getZExtValue();
25079       }
25080       if ((SraAmt + 1) != EltBits)
25081         return SDValue();
25082
25083       SDLoc DL(N);
25084
25085       // Now we know we at least have a plendvb with the mask val.  See if
25086       // we can form a psignb/w/d.
25087       // psign = x.type == y.type == mask.type && y = sub(0, x);
25088       if (Y.getOpcode() == ISD::SUB && Y.getOperand(1) == X &&
25089           ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
25090           X.getValueType() == MaskVT && Y.getValueType() == MaskVT) {
25091         assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
25092                "Unsupported VT for PSIGN");
25093         Mask = DAG.getNode(X86ISD::PSIGN, DL, MaskVT, X, Mask.getOperand(0));
25094         return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
25095       }
25096       // PBLENDVB only available on SSE 4.1
25097       if (!Subtarget->hasSSE41())
25098         return SDValue();
25099
25100       EVT BlendVT = (VT == MVT::v4i64) ? MVT::v32i8 : MVT::v16i8;
25101
25102       X = DAG.getNode(ISD::BITCAST, DL, BlendVT, X);
25103       Y = DAG.getNode(ISD::BITCAST, DL, BlendVT, Y);
25104       Mask = DAG.getNode(ISD::BITCAST, DL, BlendVT, Mask);
25105       Mask = DAG.getNode(ISD::VSELECT, DL, BlendVT, Mask, Y, X);
25106       return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
25107     }
25108   }
25109
25110   if (VT != MVT::i16 && VT != MVT::i32 && VT != MVT::i64)
25111     return SDValue();
25112
25113   // fold (or (x << c) | (y >> (64 - c))) ==> (shld64 x, y, c)
25114   MachineFunction &MF = DAG.getMachineFunction();
25115   bool OptForSize =
25116       MF.getFunction()->hasFnAttribute(Attribute::OptimizeForSize);
25117
25118   // SHLD/SHRD instructions have lower register pressure, but on some
25119   // platforms they have higher latency than the equivalent
25120   // series of shifts/or that would otherwise be generated.
25121   // Don't fold (or (x << c) | (y >> (64 - c))) if SHLD/SHRD instructions
25122   // have higher latencies and we are not optimizing for size.
25123   if (!OptForSize && Subtarget->isSHLDSlow())
25124     return SDValue();
25125
25126   if (N0.getOpcode() == ISD::SRL && N1.getOpcode() == ISD::SHL)
25127     std::swap(N0, N1);
25128   if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
25129     return SDValue();
25130   if (!N0.hasOneUse() || !N1.hasOneUse())
25131     return SDValue();
25132
25133   SDValue ShAmt0 = N0.getOperand(1);
25134   if (ShAmt0.getValueType() != MVT::i8)
25135     return SDValue();
25136   SDValue ShAmt1 = N1.getOperand(1);
25137   if (ShAmt1.getValueType() != MVT::i8)
25138     return SDValue();
25139   if (ShAmt0.getOpcode() == ISD::TRUNCATE)
25140     ShAmt0 = ShAmt0.getOperand(0);
25141   if (ShAmt1.getOpcode() == ISD::TRUNCATE)
25142     ShAmt1 = ShAmt1.getOperand(0);
25143
25144   SDLoc DL(N);
25145   unsigned Opc = X86ISD::SHLD;
25146   SDValue Op0 = N0.getOperand(0);
25147   SDValue Op1 = N1.getOperand(0);
25148   if (ShAmt0.getOpcode() == ISD::SUB) {
25149     Opc = X86ISD::SHRD;
25150     std::swap(Op0, Op1);
25151     std::swap(ShAmt0, ShAmt1);
25152   }
25153
25154   unsigned Bits = VT.getSizeInBits();
25155   if (ShAmt1.getOpcode() == ISD::SUB) {
25156     SDValue Sum = ShAmt1.getOperand(0);
25157     if (ConstantSDNode *SumC = dyn_cast<ConstantSDNode>(Sum)) {
25158       SDValue ShAmt1Op1 = ShAmt1.getOperand(1);
25159       if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
25160         ShAmt1Op1 = ShAmt1Op1.getOperand(0);
25161       if (SumC->getSExtValue() == Bits && ShAmt1Op1 == ShAmt0)
25162         return DAG.getNode(Opc, DL, VT,
25163                            Op0, Op1,
25164                            DAG.getNode(ISD::TRUNCATE, DL,
25165                                        MVT::i8, ShAmt0));
25166     }
25167   } else if (ConstantSDNode *ShAmt1C = dyn_cast<ConstantSDNode>(ShAmt1)) {
25168     ConstantSDNode *ShAmt0C = dyn_cast<ConstantSDNode>(ShAmt0);
25169     if (ShAmt0C &&
25170         ShAmt0C->getSExtValue() + ShAmt1C->getSExtValue() == Bits)
25171       return DAG.getNode(Opc, DL, VT,
25172                          N0.getOperand(0), N1.getOperand(0),
25173                          DAG.getNode(ISD::TRUNCATE, DL,
25174                                        MVT::i8, ShAmt0));
25175   }
25176
25177   return SDValue();
25178 }
25179
25180 // Generate NEG and CMOV for integer abs.
25181 static SDValue performIntegerAbsCombine(SDNode *N, SelectionDAG &DAG) {
25182   EVT VT = N->getValueType(0);
25183
25184   // Since X86 does not have CMOV for 8-bit integer, we don't convert
25185   // 8-bit integer abs to NEG and CMOV.
25186   if (VT.isInteger() && VT.getSizeInBits() == 8)
25187     return SDValue();
25188
25189   SDValue N0 = N->getOperand(0);
25190   SDValue N1 = N->getOperand(1);
25191   SDLoc DL(N);
25192
25193   // Check pattern of XOR(ADD(X,Y), Y) where Y is SRA(X, size(X)-1)
25194   // and change it to SUB and CMOV.
25195   if (VT.isInteger() && N->getOpcode() == ISD::XOR &&
25196       N0.getOpcode() == ISD::ADD &&
25197       N0.getOperand(1) == N1 &&
25198       N1.getOpcode() == ISD::SRA &&
25199       N1.getOperand(0) == N0.getOperand(0))
25200     if (ConstantSDNode *Y1C = dyn_cast<ConstantSDNode>(N1.getOperand(1)))
25201       if (Y1C->getAPIntValue() == VT.getSizeInBits()-1) {
25202         // Generate SUB & CMOV.
25203         SDValue Neg = DAG.getNode(X86ISD::SUB, DL, DAG.getVTList(VT, MVT::i32),
25204                                   DAG.getConstant(0, VT), N0.getOperand(0));
25205
25206         SDValue Ops[] = { N0.getOperand(0), Neg,
25207                           DAG.getConstant(X86::COND_GE, MVT::i8),
25208                           SDValue(Neg.getNode(), 1) };
25209         return DAG.getNode(X86ISD::CMOV, DL, DAG.getVTList(VT, MVT::Glue), Ops);
25210       }
25211   return SDValue();
25212 }
25213
25214 // PerformXorCombine - Attempts to turn XOR nodes into BLSMSK nodes
25215 static SDValue PerformXorCombine(SDNode *N, SelectionDAG &DAG,
25216                                  TargetLowering::DAGCombinerInfo &DCI,
25217                                  const X86Subtarget *Subtarget) {
25218   if (DCI.isBeforeLegalizeOps())
25219     return SDValue();
25220
25221   if (Subtarget->hasCMov()) {
25222     SDValue RV = performIntegerAbsCombine(N, DAG);
25223     if (RV.getNode())
25224       return RV;
25225   }
25226
25227   return SDValue();
25228 }
25229
25230 /// PerformLOADCombine - Do target-specific dag combines on LOAD nodes.
25231 static SDValue PerformLOADCombine(SDNode *N, SelectionDAG &DAG,
25232                                   TargetLowering::DAGCombinerInfo &DCI,
25233                                   const X86Subtarget *Subtarget) {
25234   LoadSDNode *Ld = cast<LoadSDNode>(N);
25235   EVT RegVT = Ld->getValueType(0);
25236   EVT MemVT = Ld->getMemoryVT();
25237   SDLoc dl(Ld);
25238   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25239
25240   // For chips with slow 32-byte unaligned loads, break the 32-byte operation
25241   // into two 16-byte operations.
25242   ISD::LoadExtType Ext = Ld->getExtensionType();
25243   unsigned Alignment = Ld->getAlignment();
25244   bool IsAligned = Alignment == 0 || Alignment >= MemVT.getSizeInBits()/8;
25245   if (RegVT.is256BitVector() && Subtarget->isUnalignedMem32Slow() &&
25246       !DCI.isBeforeLegalizeOps() && !IsAligned && Ext == ISD::NON_EXTLOAD) {
25247     unsigned NumElems = RegVT.getVectorNumElements();
25248     if (NumElems < 2)
25249       return SDValue();
25250
25251     SDValue Ptr = Ld->getBasePtr();
25252     SDValue Increment = DAG.getConstant(16, TLI.getPointerTy());
25253
25254     EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
25255                                   NumElems/2);
25256     SDValue Load1 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
25257                                 Ld->getPointerInfo(), Ld->isVolatile(),
25258                                 Ld->isNonTemporal(), Ld->isInvariant(),
25259                                 Alignment);
25260     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
25261     SDValue Load2 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
25262                                 Ld->getPointerInfo(), Ld->isVolatile(),
25263                                 Ld->isNonTemporal(), Ld->isInvariant(),
25264                                 std::min(16U, Alignment));
25265     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
25266                              Load1.getValue(1),
25267                              Load2.getValue(1));
25268
25269     SDValue NewVec = DAG.getUNDEF(RegVT);
25270     NewVec = Insert128BitVector(NewVec, Load1, 0, DAG, dl);
25271     NewVec = Insert128BitVector(NewVec, Load2, NumElems/2, DAG, dl);
25272     return DCI.CombineTo(N, NewVec, TF, true);
25273   }
25274
25275   return SDValue();
25276 }
25277
25278 /// PerformMLOADCombine - Resolve extending loads
25279 static SDValue PerformMLOADCombine(SDNode *N, SelectionDAG &DAG,
25280                                    TargetLowering::DAGCombinerInfo &DCI,
25281                                    const X86Subtarget *Subtarget) {
25282   MaskedLoadSDNode *Mld = cast<MaskedLoadSDNode>(N);
25283   if (Mld->getExtensionType() != ISD::SEXTLOAD)
25284     return SDValue();
25285
25286   EVT VT = Mld->getValueType(0);
25287   unsigned NumElems = VT.getVectorNumElements();
25288   EVT LdVT = Mld->getMemoryVT();
25289   SDLoc dl(Mld);
25290
25291   assert(LdVT != VT && "Cannot extend to the same type");
25292   unsigned ToSz = VT.getVectorElementType().getSizeInBits();
25293   unsigned FromSz = LdVT.getVectorElementType().getSizeInBits();
25294   // From, To sizes and ElemCount must be pow of two
25295   assert (isPowerOf2_32(NumElems * FromSz * ToSz) &&
25296     "Unexpected size for extending masked load");
25297
25298   unsigned SizeRatio  = ToSz / FromSz;
25299   assert(SizeRatio * NumElems * FromSz == VT.getSizeInBits());
25300
25301   // Create a type on which we perform the shuffle
25302   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
25303           LdVT.getScalarType(), NumElems*SizeRatio);
25304   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
25305
25306   // Convert Src0 value
25307   SDValue WideSrc0 = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mld->getSrc0());
25308   if (Mld->getSrc0().getOpcode() != ISD::UNDEF) {
25309     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
25310     for (unsigned i = 0; i != NumElems; ++i)
25311       ShuffleVec[i] = i * SizeRatio;
25312
25313     // Can't shuffle using an illegal type.
25314     assert (DAG.getTargetLoweringInfo().isTypeLegal(WideVecVT)
25315             && "WideVecVT should be legal");
25316     WideSrc0 = DAG.getVectorShuffle(WideVecVT, dl, WideSrc0,
25317                                     DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
25318   }
25319   // Prepare the new mask
25320   SDValue NewMask;
25321   SDValue Mask = Mld->getMask();
25322   if (Mask.getValueType() == VT) {
25323     // Mask and original value have the same type
25324     NewMask = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mask);
25325     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
25326     for (unsigned i = 0; i != NumElems; ++i)
25327       ShuffleVec[i] = i * SizeRatio;
25328     for (unsigned i = NumElems; i != NumElems*SizeRatio; ++i)
25329       ShuffleVec[i] = NumElems*SizeRatio;
25330     NewMask = DAG.getVectorShuffle(WideVecVT, dl, NewMask,
25331                                    DAG.getConstant(0, WideVecVT),
25332                                    &ShuffleVec[0]);
25333   }
25334   else {
25335     assert(Mask.getValueType().getVectorElementType() == MVT::i1);
25336     unsigned WidenNumElts = NumElems*SizeRatio;
25337     unsigned MaskNumElts = VT.getVectorNumElements();
25338     EVT NewMaskVT = EVT::getVectorVT(*DAG.getContext(),  MVT::i1,
25339                                      WidenNumElts);
25340
25341     unsigned NumConcat = WidenNumElts / MaskNumElts;
25342     SmallVector<SDValue, 16> Ops(NumConcat);
25343     SDValue ZeroVal = DAG.getConstant(0, Mask.getValueType());
25344     Ops[0] = Mask;
25345     for (unsigned i = 1; i != NumConcat; ++i)
25346       Ops[i] = ZeroVal;
25347
25348     NewMask = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewMaskVT, Ops);
25349   }
25350
25351   SDValue WideLd = DAG.getMaskedLoad(WideVecVT, dl, Mld->getChain(),
25352                                      Mld->getBasePtr(), NewMask, WideSrc0,
25353                                      Mld->getMemoryVT(), Mld->getMemOperand(),
25354                                      ISD::NON_EXTLOAD);
25355   SDValue NewVec = DAG.getNode(X86ISD::VSEXT, dl, VT, WideLd);
25356   return DCI.CombineTo(N, NewVec, WideLd.getValue(1), true);
25357
25358 }
25359 /// PerformMSTORECombine - Resolve truncating stores
25360 static SDValue PerformMSTORECombine(SDNode *N, SelectionDAG &DAG,
25361                                     const X86Subtarget *Subtarget) {
25362   MaskedStoreSDNode *Mst = cast<MaskedStoreSDNode>(N);
25363   if (!Mst->isTruncatingStore())
25364     return SDValue();
25365
25366   EVT VT = Mst->getValue().getValueType();
25367   unsigned NumElems = VT.getVectorNumElements();
25368   EVT StVT = Mst->getMemoryVT();
25369   SDLoc dl(Mst);
25370
25371   assert(StVT != VT && "Cannot truncate to the same type");
25372   unsigned FromSz = VT.getVectorElementType().getSizeInBits();
25373   unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
25374
25375   // From, To sizes and ElemCount must be pow of two
25376   assert (isPowerOf2_32(NumElems * FromSz * ToSz) &&
25377     "Unexpected size for truncating masked store");
25378   // We are going to use the original vector elt for storing.
25379   // Accumulated smaller vector elements must be a multiple of the store size.
25380   assert (((NumElems * FromSz) % ToSz) == 0 &&
25381           "Unexpected ratio for truncating masked store");
25382
25383   unsigned SizeRatio  = FromSz / ToSz;
25384   assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
25385
25386   // Create a type on which we perform the shuffle
25387   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
25388           StVT.getScalarType(), NumElems*SizeRatio);
25389
25390   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
25391
25392   SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mst->getValue());
25393   SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
25394   for (unsigned i = 0; i != NumElems; ++i)
25395     ShuffleVec[i] = i * SizeRatio;
25396
25397   // Can't shuffle using an illegal type.
25398   assert (DAG.getTargetLoweringInfo().isTypeLegal(WideVecVT)
25399           && "WideVecVT should be legal");
25400
25401   SDValue TruncatedVal = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
25402                                         DAG.getUNDEF(WideVecVT),
25403                                         &ShuffleVec[0]);
25404
25405   SDValue NewMask;
25406   SDValue Mask = Mst->getMask();
25407   if (Mask.getValueType() == VT) {
25408     // Mask and original value have the same type
25409     NewMask = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mask);
25410     for (unsigned i = 0; i != NumElems; ++i)
25411       ShuffleVec[i] = i * SizeRatio;
25412     for (unsigned i = NumElems; i != NumElems*SizeRatio; ++i)
25413       ShuffleVec[i] = NumElems*SizeRatio;
25414     NewMask = DAG.getVectorShuffle(WideVecVT, dl, NewMask,
25415                                    DAG.getConstant(0, WideVecVT),
25416                                    &ShuffleVec[0]);
25417   }
25418   else {
25419     assert(Mask.getValueType().getVectorElementType() == MVT::i1);
25420     unsigned WidenNumElts = NumElems*SizeRatio;
25421     unsigned MaskNumElts = VT.getVectorNumElements();
25422     EVT NewMaskVT = EVT::getVectorVT(*DAG.getContext(),  MVT::i1,
25423                                      WidenNumElts);
25424
25425     unsigned NumConcat = WidenNumElts / MaskNumElts;
25426     SmallVector<SDValue, 16> Ops(NumConcat);
25427     SDValue ZeroVal = DAG.getConstant(0, Mask.getValueType());
25428     Ops[0] = Mask;
25429     for (unsigned i = 1; i != NumConcat; ++i)
25430       Ops[i] = ZeroVal;
25431
25432     NewMask = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewMaskVT, Ops);
25433   }
25434
25435   return DAG.getMaskedStore(Mst->getChain(), dl, TruncatedVal, Mst->getBasePtr(),
25436                             NewMask, StVT, Mst->getMemOperand(), false);
25437 }
25438 /// PerformSTORECombine - Do target-specific dag combines on STORE nodes.
25439 static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
25440                                    const X86Subtarget *Subtarget) {
25441   StoreSDNode *St = cast<StoreSDNode>(N);
25442   EVT VT = St->getValue().getValueType();
25443   EVT StVT = St->getMemoryVT();
25444   SDLoc dl(St);
25445   SDValue StoredVal = St->getOperand(1);
25446   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25447
25448   // If we are saving a concatenation of two XMM registers and 32-byte stores
25449   // are slow, such as on Sandy Bridge, perform two 16-byte stores.
25450   unsigned Alignment = St->getAlignment();
25451   bool IsAligned = Alignment == 0 || Alignment >= VT.getSizeInBits()/8;
25452   if (VT.is256BitVector() && Subtarget->isUnalignedMem32Slow() &&
25453       StVT == VT && !IsAligned) {
25454     unsigned NumElems = VT.getVectorNumElements();
25455     if (NumElems < 2)
25456       return SDValue();
25457
25458     SDValue Value0 = Extract128BitVector(StoredVal, 0, DAG, dl);
25459     SDValue Value1 = Extract128BitVector(StoredVal, NumElems/2, DAG, dl);
25460
25461     SDValue Stride = DAG.getConstant(16, TLI.getPointerTy());
25462     SDValue Ptr0 = St->getBasePtr();
25463     SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
25464
25465     SDValue Ch0 = DAG.getStore(St->getChain(), dl, Value0, Ptr0,
25466                                 St->getPointerInfo(), St->isVolatile(),
25467                                 St->isNonTemporal(), Alignment);
25468     SDValue Ch1 = DAG.getStore(St->getChain(), dl, Value1, Ptr1,
25469                                 St->getPointerInfo(), St->isVolatile(),
25470                                 St->isNonTemporal(),
25471                                 std::min(16U, Alignment));
25472     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
25473   }
25474
25475   // Optimize trunc store (of multiple scalars) to shuffle and store.
25476   // First, pack all of the elements in one place. Next, store to memory
25477   // in fewer chunks.
25478   if (St->isTruncatingStore() && VT.isVector()) {
25479     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25480     unsigned NumElems = VT.getVectorNumElements();
25481     assert(StVT != VT && "Cannot truncate to the same type");
25482     unsigned FromSz = VT.getVectorElementType().getSizeInBits();
25483     unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
25484
25485     // From, To sizes and ElemCount must be pow of two
25486     if (!isPowerOf2_32(NumElems * FromSz * ToSz)) return SDValue();
25487     // We are going to use the original vector elt for storing.
25488     // Accumulated smaller vector elements must be a multiple of the store size.
25489     if (0 != (NumElems * FromSz) % ToSz) return SDValue();
25490
25491     unsigned SizeRatio  = FromSz / ToSz;
25492
25493     assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
25494
25495     // Create a type on which we perform the shuffle
25496     EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
25497             StVT.getScalarType(), NumElems*SizeRatio);
25498
25499     assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
25500
25501     SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
25502     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
25503     for (unsigned i = 0; i != NumElems; ++i)
25504       ShuffleVec[i] = i * SizeRatio;
25505
25506     // Can't shuffle using an illegal type.
25507     if (!TLI.isTypeLegal(WideVecVT))
25508       return SDValue();
25509
25510     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
25511                                          DAG.getUNDEF(WideVecVT),
25512                                          &ShuffleVec[0]);
25513     // At this point all of the data is stored at the bottom of the
25514     // register. We now need to save it to mem.
25515
25516     // Find the largest store unit
25517     MVT StoreType = MVT::i8;
25518     for (MVT Tp : MVT::integer_valuetypes()) {
25519       if (TLI.isTypeLegal(Tp) && Tp.getSizeInBits() <= NumElems * ToSz)
25520         StoreType = Tp;
25521     }
25522
25523     // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
25524     if (TLI.isTypeLegal(MVT::f64) && StoreType.getSizeInBits() < 64 &&
25525         (64 <= NumElems * ToSz))
25526       StoreType = MVT::f64;
25527
25528     // Bitcast the original vector into a vector of store-size units
25529     EVT StoreVecVT = EVT::getVectorVT(*DAG.getContext(),
25530             StoreType, VT.getSizeInBits()/StoreType.getSizeInBits());
25531     assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
25532     SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
25533     SmallVector<SDValue, 8> Chains;
25534     SDValue Increment = DAG.getConstant(StoreType.getSizeInBits()/8,
25535                                         TLI.getPointerTy());
25536     SDValue Ptr = St->getBasePtr();
25537
25538     // Perform one or more big stores into memory.
25539     for (unsigned i=0, e=(ToSz*NumElems)/StoreType.getSizeInBits(); i!=e; ++i) {
25540       SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
25541                                    StoreType, ShuffWide,
25542                                    DAG.getIntPtrConstant(i));
25543       SDValue Ch = DAG.getStore(St->getChain(), dl, SubVec, Ptr,
25544                                 St->getPointerInfo(), St->isVolatile(),
25545                                 St->isNonTemporal(), St->getAlignment());
25546       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
25547       Chains.push_back(Ch);
25548     }
25549
25550     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
25551   }
25552
25553   // Turn load->store of MMX types into GPR load/stores.  This avoids clobbering
25554   // the FP state in cases where an emms may be missing.
25555   // A preferable solution to the general problem is to figure out the right
25556   // places to insert EMMS.  This qualifies as a quick hack.
25557
25558   // Similarly, turn load->store of i64 into double load/stores in 32-bit mode.
25559   if (VT.getSizeInBits() != 64)
25560     return SDValue();
25561
25562   const Function *F = DAG.getMachineFunction().getFunction();
25563   bool NoImplicitFloatOps = F->hasFnAttribute(Attribute::NoImplicitFloat);
25564   bool F64IsLegal = !DAG.getTarget().Options.UseSoftFloat && !NoImplicitFloatOps
25565                      && Subtarget->hasSSE2();
25566   if ((VT.isVector() ||
25567        (VT == MVT::i64 && F64IsLegal && !Subtarget->is64Bit())) &&
25568       isa<LoadSDNode>(St->getValue()) &&
25569       !cast<LoadSDNode>(St->getValue())->isVolatile() &&
25570       St->getChain().hasOneUse() && !St->isVolatile()) {
25571     SDNode* LdVal = St->getValue().getNode();
25572     LoadSDNode *Ld = nullptr;
25573     int TokenFactorIndex = -1;
25574     SmallVector<SDValue, 8> Ops;
25575     SDNode* ChainVal = St->getChain().getNode();
25576     // Must be a store of a load.  We currently handle two cases:  the load
25577     // is a direct child, and it's under an intervening TokenFactor.  It is
25578     // possible to dig deeper under nested TokenFactors.
25579     if (ChainVal == LdVal)
25580       Ld = cast<LoadSDNode>(St->getChain());
25581     else if (St->getValue().hasOneUse() &&
25582              ChainVal->getOpcode() == ISD::TokenFactor) {
25583       for (unsigned i = 0, e = ChainVal->getNumOperands(); i != e; ++i) {
25584         if (ChainVal->getOperand(i).getNode() == LdVal) {
25585           TokenFactorIndex = i;
25586           Ld = cast<LoadSDNode>(St->getValue());
25587         } else
25588           Ops.push_back(ChainVal->getOperand(i));
25589       }
25590     }
25591
25592     if (!Ld || !ISD::isNormalLoad(Ld))
25593       return SDValue();
25594
25595     // If this is not the MMX case, i.e. we are just turning i64 load/store
25596     // into f64 load/store, avoid the transformation if there are multiple
25597     // uses of the loaded value.
25598     if (!VT.isVector() && !Ld->hasNUsesOfValue(1, 0))
25599       return SDValue();
25600
25601     SDLoc LdDL(Ld);
25602     SDLoc StDL(N);
25603     // If we are a 64-bit capable x86, lower to a single movq load/store pair.
25604     // Otherwise, if it's legal to use f64 SSE instructions, use f64 load/store
25605     // pair instead.
25606     if (Subtarget->is64Bit() || F64IsLegal) {
25607       EVT LdVT = Subtarget->is64Bit() ? MVT::i64 : MVT::f64;
25608       SDValue NewLd = DAG.getLoad(LdVT, LdDL, Ld->getChain(), Ld->getBasePtr(),
25609                                   Ld->getPointerInfo(), Ld->isVolatile(),
25610                                   Ld->isNonTemporal(), Ld->isInvariant(),
25611                                   Ld->getAlignment());
25612       SDValue NewChain = NewLd.getValue(1);
25613       if (TokenFactorIndex != -1) {
25614         Ops.push_back(NewChain);
25615         NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
25616       }
25617       return DAG.getStore(NewChain, StDL, NewLd, St->getBasePtr(),
25618                           St->getPointerInfo(),
25619                           St->isVolatile(), St->isNonTemporal(),
25620                           St->getAlignment());
25621     }
25622
25623     // Otherwise, lower to two pairs of 32-bit loads / stores.
25624     SDValue LoAddr = Ld->getBasePtr();
25625     SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
25626                                  DAG.getConstant(4, MVT::i32));
25627
25628     SDValue LoLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), LoAddr,
25629                                Ld->getPointerInfo(),
25630                                Ld->isVolatile(), Ld->isNonTemporal(),
25631                                Ld->isInvariant(), Ld->getAlignment());
25632     SDValue HiLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), HiAddr,
25633                                Ld->getPointerInfo().getWithOffset(4),
25634                                Ld->isVolatile(), Ld->isNonTemporal(),
25635                                Ld->isInvariant(),
25636                                MinAlign(Ld->getAlignment(), 4));
25637
25638     SDValue NewChain = LoLd.getValue(1);
25639     if (TokenFactorIndex != -1) {
25640       Ops.push_back(LoLd);
25641       Ops.push_back(HiLd);
25642       NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
25643     }
25644
25645     LoAddr = St->getBasePtr();
25646     HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
25647                          DAG.getConstant(4, MVT::i32));
25648
25649     SDValue LoSt = DAG.getStore(NewChain, StDL, LoLd, LoAddr,
25650                                 St->getPointerInfo(),
25651                                 St->isVolatile(), St->isNonTemporal(),
25652                                 St->getAlignment());
25653     SDValue HiSt = DAG.getStore(NewChain, StDL, HiLd, HiAddr,
25654                                 St->getPointerInfo().getWithOffset(4),
25655                                 St->isVolatile(),
25656                                 St->isNonTemporal(),
25657                                 MinAlign(St->getAlignment(), 4));
25658     return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
25659   }
25660   return SDValue();
25661 }
25662
25663 /// Return 'true' if this vector operation is "horizontal"
25664 /// and return the operands for the horizontal operation in LHS and RHS.  A
25665 /// horizontal operation performs the binary operation on successive elements
25666 /// of its first operand, then on successive elements of its second operand,
25667 /// returning the resulting values in a vector.  For example, if
25668 ///   A = < float a0, float a1, float a2, float a3 >
25669 /// and
25670 ///   B = < float b0, float b1, float b2, float b3 >
25671 /// then the result of doing a horizontal operation on A and B is
25672 ///   A horizontal-op B = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >.
25673 /// In short, LHS and RHS are inspected to see if LHS op RHS is of the form
25674 /// A horizontal-op B, for some already available A and B, and if so then LHS is
25675 /// set to A, RHS to B, and the routine returns 'true'.
25676 /// Note that the binary operation should have the property that if one of the
25677 /// operands is UNDEF then the result is UNDEF.
25678 static bool isHorizontalBinOp(SDValue &LHS, SDValue &RHS, bool IsCommutative) {
25679   // Look for the following pattern: if
25680   //   A = < float a0, float a1, float a2, float a3 >
25681   //   B = < float b0, float b1, float b2, float b3 >
25682   // and
25683   //   LHS = VECTOR_SHUFFLE A, B, <0, 2, 4, 6>
25684   //   RHS = VECTOR_SHUFFLE A, B, <1, 3, 5, 7>
25685   // then LHS op RHS = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >
25686   // which is A horizontal-op B.
25687
25688   // At least one of the operands should be a vector shuffle.
25689   if (LHS.getOpcode() != ISD::VECTOR_SHUFFLE &&
25690       RHS.getOpcode() != ISD::VECTOR_SHUFFLE)
25691     return false;
25692
25693   MVT VT = LHS.getSimpleValueType();
25694
25695   assert((VT.is128BitVector() || VT.is256BitVector()) &&
25696          "Unsupported vector type for horizontal add/sub");
25697
25698   // Handle 128 and 256-bit vector lengths. AVX defines horizontal add/sub to
25699   // operate independently on 128-bit lanes.
25700   unsigned NumElts = VT.getVectorNumElements();
25701   unsigned NumLanes = VT.getSizeInBits()/128;
25702   unsigned NumLaneElts = NumElts / NumLanes;
25703   assert((NumLaneElts % 2 == 0) &&
25704          "Vector type should have an even number of elements in each lane");
25705   unsigned HalfLaneElts = NumLaneElts/2;
25706
25707   // View LHS in the form
25708   //   LHS = VECTOR_SHUFFLE A, B, LMask
25709   // If LHS is not a shuffle then pretend it is the shuffle
25710   //   LHS = VECTOR_SHUFFLE LHS, undef, <0, 1, ..., N-1>
25711   // NOTE: in what follows a default initialized SDValue represents an UNDEF of
25712   // type VT.
25713   SDValue A, B;
25714   SmallVector<int, 16> LMask(NumElts);
25715   if (LHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
25716     if (LHS.getOperand(0).getOpcode() != ISD::UNDEF)
25717       A = LHS.getOperand(0);
25718     if (LHS.getOperand(1).getOpcode() != ISD::UNDEF)
25719       B = LHS.getOperand(1);
25720     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(LHS.getNode())->getMask();
25721     std::copy(Mask.begin(), Mask.end(), LMask.begin());
25722   } else {
25723     if (LHS.getOpcode() != ISD::UNDEF)
25724       A = LHS;
25725     for (unsigned i = 0; i != NumElts; ++i)
25726       LMask[i] = i;
25727   }
25728
25729   // Likewise, view RHS in the form
25730   //   RHS = VECTOR_SHUFFLE C, D, RMask
25731   SDValue C, D;
25732   SmallVector<int, 16> RMask(NumElts);
25733   if (RHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
25734     if (RHS.getOperand(0).getOpcode() != ISD::UNDEF)
25735       C = RHS.getOperand(0);
25736     if (RHS.getOperand(1).getOpcode() != ISD::UNDEF)
25737       D = RHS.getOperand(1);
25738     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(RHS.getNode())->getMask();
25739     std::copy(Mask.begin(), Mask.end(), RMask.begin());
25740   } else {
25741     if (RHS.getOpcode() != ISD::UNDEF)
25742       C = RHS;
25743     for (unsigned i = 0; i != NumElts; ++i)
25744       RMask[i] = i;
25745   }
25746
25747   // Check that the shuffles are both shuffling the same vectors.
25748   if (!(A == C && B == D) && !(A == D && B == C))
25749     return false;
25750
25751   // If everything is UNDEF then bail out: it would be better to fold to UNDEF.
25752   if (!A.getNode() && !B.getNode())
25753     return false;
25754
25755   // If A and B occur in reverse order in RHS, then "swap" them (which means
25756   // rewriting the mask).
25757   if (A != C)
25758     CommuteVectorShuffleMask(RMask, NumElts);
25759
25760   // At this point LHS and RHS are equivalent to
25761   //   LHS = VECTOR_SHUFFLE A, B, LMask
25762   //   RHS = VECTOR_SHUFFLE A, B, RMask
25763   // Check that the masks correspond to performing a horizontal operation.
25764   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
25765     for (unsigned i = 0; i != NumLaneElts; ++i) {
25766       int LIdx = LMask[i+l], RIdx = RMask[i+l];
25767
25768       // Ignore any UNDEF components.
25769       if (LIdx < 0 || RIdx < 0 ||
25770           (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
25771           (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
25772         continue;
25773
25774       // Check that successive elements are being operated on.  If not, this is
25775       // not a horizontal operation.
25776       unsigned Src = (i/HalfLaneElts); // each lane is split between srcs
25777       int Index = 2*(i%HalfLaneElts) + NumElts*Src + l;
25778       if (!(LIdx == Index && RIdx == Index + 1) &&
25779           !(IsCommutative && LIdx == Index + 1 && RIdx == Index))
25780         return false;
25781     }
25782   }
25783
25784   LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
25785   RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
25786   return true;
25787 }
25788
25789 /// Do target-specific dag combines on floating point adds.
25790 static SDValue PerformFADDCombine(SDNode *N, SelectionDAG &DAG,
25791                                   const X86Subtarget *Subtarget) {
25792   EVT VT = N->getValueType(0);
25793   SDValue LHS = N->getOperand(0);
25794   SDValue RHS = N->getOperand(1);
25795
25796   // Try to synthesize horizontal adds from adds of shuffles.
25797   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
25798        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
25799       isHorizontalBinOp(LHS, RHS, true))
25800     return DAG.getNode(X86ISD::FHADD, SDLoc(N), VT, LHS, RHS);
25801   return SDValue();
25802 }
25803
25804 /// Do target-specific dag combines on floating point subs.
25805 static SDValue PerformFSUBCombine(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 subs from subs 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, false))
25815     return DAG.getNode(X86ISD::FHSUB, SDLoc(N), VT, LHS, RHS);
25816   return SDValue();
25817 }
25818
25819 /// Do target-specific dag combines on X86ISD::FOR and X86ISD::FXOR nodes.
25820 static SDValue PerformFORCombine(SDNode *N, SelectionDAG &DAG) {
25821   assert(N->getOpcode() == X86ISD::FOR || N->getOpcode() == X86ISD::FXOR);
25822
25823   // F[X]OR(0.0, x) -> x
25824   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25825     if (C->getValueAPF().isPosZero())
25826       return N->getOperand(1);
25827
25828   // F[X]OR(x, 0.0) -> x
25829   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
25830     if (C->getValueAPF().isPosZero())
25831       return N->getOperand(0);
25832   return SDValue();
25833 }
25834
25835 /// Do target-specific dag combines on X86ISD::FMIN and X86ISD::FMAX nodes.
25836 static SDValue PerformFMinFMaxCombine(SDNode *N, SelectionDAG &DAG) {
25837   assert(N->getOpcode() == X86ISD::FMIN || N->getOpcode() == X86ISD::FMAX);
25838
25839   // Only perform optimizations if UnsafeMath is used.
25840   if (!DAG.getTarget().Options.UnsafeFPMath)
25841     return SDValue();
25842
25843   // If we run in unsafe-math mode, then convert the FMAX and FMIN nodes
25844   // into FMINC and FMAXC, which are Commutative operations.
25845   unsigned NewOp = 0;
25846   switch (N->getOpcode()) {
25847     default: llvm_unreachable("unknown opcode");
25848     case X86ISD::FMIN:  NewOp = X86ISD::FMINC; break;
25849     case X86ISD::FMAX:  NewOp = X86ISD::FMAXC; break;
25850   }
25851
25852   return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
25853                      N->getOperand(0), N->getOperand(1));
25854 }
25855
25856 /// Do target-specific dag combines on X86ISD::FAND nodes.
25857 static SDValue PerformFANDCombine(SDNode *N, SelectionDAG &DAG) {
25858   // FAND(0.0, x) -> 0.0
25859   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25860     if (C->getValueAPF().isPosZero())
25861       return N->getOperand(0);
25862
25863   // FAND(x, 0.0) -> 0.0
25864   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
25865     if (C->getValueAPF().isPosZero())
25866       return N->getOperand(1);
25867
25868   return SDValue();
25869 }
25870
25871 /// Do target-specific dag combines on X86ISD::FANDN nodes
25872 static SDValue PerformFANDNCombine(SDNode *N, SelectionDAG &DAG) {
25873   // FANDN(0.0, x) -> x
25874   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25875     if (C->getValueAPF().isPosZero())
25876       return N->getOperand(1);
25877
25878   // FANDN(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 static SDValue PerformBTCombine(SDNode *N,
25887                                 SelectionDAG &DAG,
25888                                 TargetLowering::DAGCombinerInfo &DCI) {
25889   // BT ignores high bits in the bit index operand.
25890   SDValue Op1 = N->getOperand(1);
25891   if (Op1.hasOneUse()) {
25892     unsigned BitWidth = Op1.getValueSizeInBits();
25893     APInt DemandedMask = APInt::getLowBitsSet(BitWidth, Log2_32(BitWidth));
25894     APInt KnownZero, KnownOne;
25895     TargetLowering::TargetLoweringOpt TLO(DAG, !DCI.isBeforeLegalize(),
25896                                           !DCI.isBeforeLegalizeOps());
25897     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25898     if (TLO.ShrinkDemandedConstant(Op1, DemandedMask) ||
25899         TLI.SimplifyDemandedBits(Op1, DemandedMask, KnownZero, KnownOne, TLO))
25900       DCI.CommitTargetLoweringOpt(TLO);
25901   }
25902   return SDValue();
25903 }
25904
25905 static SDValue PerformVZEXT_MOVLCombine(SDNode *N, SelectionDAG &DAG) {
25906   SDValue Op = N->getOperand(0);
25907   if (Op.getOpcode() == ISD::BITCAST)
25908     Op = Op.getOperand(0);
25909   EVT VT = N->getValueType(0), OpVT = Op.getValueType();
25910   if (Op.getOpcode() == X86ISD::VZEXT_LOAD &&
25911       VT.getVectorElementType().getSizeInBits() ==
25912       OpVT.getVectorElementType().getSizeInBits()) {
25913     return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
25914   }
25915   return SDValue();
25916 }
25917
25918 static SDValue PerformSIGN_EXTEND_INREGCombine(SDNode *N, SelectionDAG &DAG,
25919                                                const X86Subtarget *Subtarget) {
25920   EVT VT = N->getValueType(0);
25921   if (!VT.isVector())
25922     return SDValue();
25923
25924   SDValue N0 = N->getOperand(0);
25925   SDValue N1 = N->getOperand(1);
25926   EVT ExtraVT = cast<VTSDNode>(N1)->getVT();
25927   SDLoc dl(N);
25928
25929   // The SIGN_EXTEND_INREG to v4i64 is expensive operation on the
25930   // both SSE and AVX2 since there is no sign-extended shift right
25931   // operation on a vector with 64-bit elements.
25932   //(sext_in_reg (v4i64 anyext (v4i32 x )), ExtraVT) ->
25933   // (v4i64 sext (v4i32 sext_in_reg (v4i32 x , ExtraVT)))
25934   if (VT == MVT::v4i64 && (N0.getOpcode() == ISD::ANY_EXTEND ||
25935       N0.getOpcode() == ISD::SIGN_EXTEND)) {
25936     SDValue N00 = N0.getOperand(0);
25937
25938     // EXTLOAD has a better solution on AVX2,
25939     // it may be replaced with X86ISD::VSEXT node.
25940     if (N00.getOpcode() == ISD::LOAD && Subtarget->hasInt256())
25941       if (!ISD::isNormalLoad(N00.getNode()))
25942         return SDValue();
25943
25944     if (N00.getValueType() == MVT::v4i32 && ExtraVT.getSizeInBits() < 128) {
25945         SDValue Tmp = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32,
25946                                   N00, N1);
25947       return DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i64, Tmp);
25948     }
25949   }
25950   return SDValue();
25951 }
25952
25953 static SDValue PerformSExtCombine(SDNode *N, SelectionDAG &DAG,
25954                                   TargetLowering::DAGCombinerInfo &DCI,
25955                                   const X86Subtarget *Subtarget) {
25956   SDValue N0 = N->getOperand(0);
25957   EVT VT = N->getValueType(0);
25958
25959   // (i8,i32 sext (sdivrem (i8 x, i8 y)) ->
25960   // (i8,i32 (sdivrem_sext_hreg (i8 x, i8 y)
25961   // This exposes the sext to the sdivrem lowering, so that it directly extends
25962   // from AH (which we otherwise need to do contortions to access).
25963   if (N0.getOpcode() == ISD::SDIVREM && N0.getResNo() == 1 &&
25964       N0.getValueType() == MVT::i8 && VT == MVT::i32) {
25965     SDLoc dl(N);
25966     SDVTList NodeTys = DAG.getVTList(MVT::i8, VT);
25967     SDValue R = DAG.getNode(X86ISD::SDIVREM8_SEXT_HREG, dl, NodeTys,
25968                             N0.getOperand(0), N0.getOperand(1));
25969     DAG.ReplaceAllUsesOfValueWith(N0.getValue(0), R.getValue(0));
25970     return R.getValue(1);
25971   }
25972
25973   if (!DCI.isBeforeLegalizeOps())
25974     return SDValue();
25975
25976   if (!Subtarget->hasFp256())
25977     return SDValue();
25978
25979   if (VT.isVector() && VT.getSizeInBits() == 256) {
25980     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
25981     if (R.getNode())
25982       return R;
25983   }
25984
25985   return SDValue();
25986 }
25987
25988 static SDValue PerformFMACombine(SDNode *N, SelectionDAG &DAG,
25989                                  const X86Subtarget* Subtarget) {
25990   SDLoc dl(N);
25991   EVT VT = N->getValueType(0);
25992
25993   // Let legalize expand this if it isn't a legal type yet.
25994   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
25995     return SDValue();
25996
25997   EVT ScalarVT = VT.getScalarType();
25998   if ((ScalarVT != MVT::f32 && ScalarVT != MVT::f64) ||
25999       (!Subtarget->hasFMA() && !Subtarget->hasFMA4()))
26000     return SDValue();
26001
26002   SDValue A = N->getOperand(0);
26003   SDValue B = N->getOperand(1);
26004   SDValue C = N->getOperand(2);
26005
26006   bool NegA = (A.getOpcode() == ISD::FNEG);
26007   bool NegB = (B.getOpcode() == ISD::FNEG);
26008   bool NegC = (C.getOpcode() == ISD::FNEG);
26009
26010   // Negative multiplication when NegA xor NegB
26011   bool NegMul = (NegA != NegB);
26012   if (NegA)
26013     A = A.getOperand(0);
26014   if (NegB)
26015     B = B.getOperand(0);
26016   if (NegC)
26017     C = C.getOperand(0);
26018
26019   unsigned Opcode;
26020   if (!NegMul)
26021     Opcode = (!NegC) ? X86ISD::FMADD : X86ISD::FMSUB;
26022   else
26023     Opcode = (!NegC) ? X86ISD::FNMADD : X86ISD::FNMSUB;
26024
26025   return DAG.getNode(Opcode, dl, VT, A, B, C);
26026 }
26027
26028 static SDValue PerformZExtCombine(SDNode *N, SelectionDAG &DAG,
26029                                   TargetLowering::DAGCombinerInfo &DCI,
26030                                   const X86Subtarget *Subtarget) {
26031   // (i32 zext (and (i8  x86isd::setcc_carry), 1)) ->
26032   //           (and (i32 x86isd::setcc_carry), 1)
26033   // This eliminates the zext. This transformation is necessary because
26034   // ISD::SETCC is always legalized to i8.
26035   SDLoc dl(N);
26036   SDValue N0 = N->getOperand(0);
26037   EVT VT = N->getValueType(0);
26038
26039   if (N0.getOpcode() == ISD::AND &&
26040       N0.hasOneUse() &&
26041       N0.getOperand(0).hasOneUse()) {
26042     SDValue N00 = N0.getOperand(0);
26043     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
26044       ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
26045       if (!C || C->getZExtValue() != 1)
26046         return SDValue();
26047       return DAG.getNode(ISD::AND, dl, VT,
26048                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
26049                                      N00.getOperand(0), N00.getOperand(1)),
26050                          DAG.getConstant(1, VT));
26051     }
26052   }
26053
26054   if (N0.getOpcode() == ISD::TRUNCATE &&
26055       N0.hasOneUse() &&
26056       N0.getOperand(0).hasOneUse()) {
26057     SDValue N00 = N0.getOperand(0);
26058     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
26059       return DAG.getNode(ISD::AND, dl, VT,
26060                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
26061                                      N00.getOperand(0), N00.getOperand(1)),
26062                          DAG.getConstant(1, VT));
26063     }
26064   }
26065   if (VT.is256BitVector()) {
26066     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
26067     if (R.getNode())
26068       return R;
26069   }
26070
26071   // (i8,i32 zext (udivrem (i8 x, i8 y)) ->
26072   // (i8,i32 (udivrem_zext_hreg (i8 x, i8 y)
26073   // This exposes the zext to the udivrem lowering, so that it directly extends
26074   // from AH (which we otherwise need to do contortions to access).
26075   if (N0.getOpcode() == ISD::UDIVREM &&
26076       N0.getResNo() == 1 && N0.getValueType() == MVT::i8 &&
26077       (VT == MVT::i32 || VT == MVT::i64)) {
26078     SDVTList NodeTys = DAG.getVTList(MVT::i8, VT);
26079     SDValue R = DAG.getNode(X86ISD::UDIVREM8_ZEXT_HREG, dl, NodeTys,
26080                             N0.getOperand(0), N0.getOperand(1));
26081     DAG.ReplaceAllUsesOfValueWith(N0.getValue(0), R.getValue(0));
26082     return R.getValue(1);
26083   }
26084
26085   return SDValue();
26086 }
26087
26088 // Optimize x == -y --> x+y == 0
26089 //          x != -y --> x+y != 0
26090 static SDValue PerformISDSETCCCombine(SDNode *N, SelectionDAG &DAG,
26091                                       const X86Subtarget* Subtarget) {
26092   ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
26093   SDValue LHS = N->getOperand(0);
26094   SDValue RHS = N->getOperand(1);
26095   EVT VT = N->getValueType(0);
26096   SDLoc DL(N);
26097
26098   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && LHS.getOpcode() == ISD::SUB)
26099     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHS.getOperand(0)))
26100       if (C->getAPIntValue() == 0 && LHS.hasOneUse()) {
26101         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
26102                                    LHS.getValueType(), RHS, LHS.getOperand(1));
26103         return DAG.getSetCC(SDLoc(N), N->getValueType(0),
26104                             addV, DAG.getConstant(0, addV.getValueType()), CC);
26105       }
26106   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && RHS.getOpcode() == ISD::SUB)
26107     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS.getOperand(0)))
26108       if (C->getAPIntValue() == 0 && RHS.hasOneUse()) {
26109         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
26110                                    RHS.getValueType(), LHS, RHS.getOperand(1));
26111         return DAG.getSetCC(SDLoc(N), N->getValueType(0),
26112                             addV, DAG.getConstant(0, addV.getValueType()), CC);
26113       }
26114
26115   if (VT.getScalarType() == MVT::i1) {
26116     bool IsSEXT0 = (LHS.getOpcode() == ISD::SIGN_EXTEND) &&
26117       (LHS.getOperand(0).getValueType().getScalarType() ==  MVT::i1);
26118     bool IsVZero0 = ISD::isBuildVectorAllZeros(LHS.getNode());
26119     if (!IsSEXT0 && !IsVZero0)
26120       return SDValue();
26121     bool IsSEXT1 = (RHS.getOpcode() == ISD::SIGN_EXTEND) &&
26122       (RHS.getOperand(0).getValueType().getScalarType() ==  MVT::i1);
26123     bool IsVZero1 = ISD::isBuildVectorAllZeros(RHS.getNode());
26124
26125     if (!IsSEXT1 && !IsVZero1)
26126       return SDValue();
26127
26128     if (IsSEXT0 && IsVZero1) {
26129       assert(VT == LHS.getOperand(0).getValueType() && "Uexpected operand type");
26130       if (CC == ISD::SETEQ)
26131         return DAG.getNOT(DL, LHS.getOperand(0), VT);
26132       return LHS.getOperand(0);
26133     }
26134     if (IsSEXT1 && IsVZero0) {
26135       assert(VT == RHS.getOperand(0).getValueType() && "Uexpected operand type");
26136       if (CC == ISD::SETEQ)
26137         return DAG.getNOT(DL, RHS.getOperand(0), VT);
26138       return RHS.getOperand(0);
26139     }
26140   }
26141
26142   return SDValue();
26143 }
26144
26145 static SDValue PerformINSERTPSCombine(SDNode *N, SelectionDAG &DAG,
26146                                       const X86Subtarget *Subtarget) {
26147   SDLoc dl(N);
26148   MVT VT = N->getOperand(1)->getSimpleValueType(0);
26149   assert((VT == MVT::v4f32 || VT == MVT::v4i32) &&
26150          "X86insertps is only defined for v4x32");
26151
26152   SDValue Ld = N->getOperand(1);
26153   if (MayFoldLoad(Ld)) {
26154     // Extract the countS bits from the immediate so we can get the proper
26155     // address when narrowing the vector load to a specific element.
26156     // When the second source op is a memory address, interps doesn't use
26157     // countS and just gets an f32 from that address.
26158     unsigned DestIndex =
26159         cast<ConstantSDNode>(N->getOperand(2))->getZExtValue() >> 6;
26160     Ld = NarrowVectorLoadToElement(cast<LoadSDNode>(Ld), DestIndex, DAG);
26161   } else
26162     return SDValue();
26163
26164   // Create this as a scalar to vector to match the instruction pattern.
26165   SDValue LoadScalarToVector = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Ld);
26166   // countS bits are ignored when loading from memory on insertps, which
26167   // means we don't need to explicitly set them to 0.
26168   return DAG.getNode(X86ISD::INSERTPS, dl, VT, N->getOperand(0),
26169                      LoadScalarToVector, N->getOperand(2));
26170 }
26171
26172 // Helper function of PerformSETCCCombine. It is to materialize "setb reg"
26173 // as "sbb reg,reg", since it can be extended without zext and produces
26174 // an all-ones bit which is more useful than 0/1 in some cases.
26175 static SDValue MaterializeSETB(SDLoc DL, SDValue EFLAGS, SelectionDAG &DAG,
26176                                MVT VT) {
26177   if (VT == MVT::i8)
26178     return DAG.getNode(ISD::AND, DL, VT,
26179                        DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
26180                                    DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS),
26181                        DAG.getConstant(1, VT));
26182   assert (VT == MVT::i1 && "Unexpected type for SECCC node");
26183   return DAG.getNode(ISD::TRUNCATE, DL, MVT::i1,
26184                      DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
26185                                  DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS));
26186 }
26187
26188 // Optimize  RES = X86ISD::SETCC CONDCODE, EFLAG_INPUT
26189 static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG &DAG,
26190                                    TargetLowering::DAGCombinerInfo &DCI,
26191                                    const X86Subtarget *Subtarget) {
26192   SDLoc DL(N);
26193   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(0));
26194   SDValue EFLAGS = N->getOperand(1);
26195
26196   if (CC == X86::COND_A) {
26197     // Try to convert COND_A into COND_B in an attempt to facilitate
26198     // materializing "setb reg".
26199     //
26200     // Do not flip "e > c", where "c" is a constant, because Cmp instruction
26201     // cannot take an immediate as its first operand.
26202     //
26203     if (EFLAGS.getOpcode() == X86ISD::SUB && EFLAGS.hasOneUse() &&
26204         EFLAGS.getValueType().isInteger() &&
26205         !isa<ConstantSDNode>(EFLAGS.getOperand(1))) {
26206       SDValue NewSub = DAG.getNode(X86ISD::SUB, SDLoc(EFLAGS),
26207                                    EFLAGS.getNode()->getVTList(),
26208                                    EFLAGS.getOperand(1), EFLAGS.getOperand(0));
26209       SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
26210       return MaterializeSETB(DL, NewEFLAGS, DAG, N->getSimpleValueType(0));
26211     }
26212   }
26213
26214   // Materialize "setb reg" as "sbb reg,reg", since it can be extended without
26215   // a zext and produces an all-ones bit which is more useful than 0/1 in some
26216   // cases.
26217   if (CC == X86::COND_B)
26218     return MaterializeSETB(DL, EFLAGS, DAG, N->getSimpleValueType(0));
26219
26220   SDValue Flags;
26221
26222   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
26223   if (Flags.getNode()) {
26224     SDValue Cond = DAG.getConstant(CC, MVT::i8);
26225     return DAG.getNode(X86ISD::SETCC, DL, N->getVTList(), Cond, Flags);
26226   }
26227
26228   return SDValue();
26229 }
26230
26231 // Optimize branch condition evaluation.
26232 //
26233 static SDValue PerformBrCondCombine(SDNode *N, SelectionDAG &DAG,
26234                                     TargetLowering::DAGCombinerInfo &DCI,
26235                                     const X86Subtarget *Subtarget) {
26236   SDLoc DL(N);
26237   SDValue Chain = N->getOperand(0);
26238   SDValue Dest = N->getOperand(1);
26239   SDValue EFLAGS = N->getOperand(3);
26240   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(2));
26241
26242   SDValue Flags;
26243
26244   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
26245   if (Flags.getNode()) {
26246     SDValue Cond = DAG.getConstant(CC, MVT::i8);
26247     return DAG.getNode(X86ISD::BRCOND, DL, N->getVTList(), Chain, Dest, Cond,
26248                        Flags);
26249   }
26250
26251   return SDValue();
26252 }
26253
26254 static SDValue performVectorCompareAndMaskUnaryOpCombine(SDNode *N,
26255                                                          SelectionDAG &DAG) {
26256   // Take advantage of vector comparisons producing 0 or -1 in each lane to
26257   // optimize away operation when it's from a constant.
26258   //
26259   // The general transformation is:
26260   //    UNARYOP(AND(VECTOR_CMP(x,y), constant)) -->
26261   //       AND(VECTOR_CMP(x,y), constant2)
26262   //    constant2 = UNARYOP(constant)
26263
26264   // Early exit if this isn't a vector operation, the operand of the
26265   // unary operation isn't a bitwise AND, or if the sizes of the operations
26266   // aren't the same.
26267   EVT VT = N->getValueType(0);
26268   if (!VT.isVector() || N->getOperand(0)->getOpcode() != ISD::AND ||
26269       N->getOperand(0)->getOperand(0)->getOpcode() != ISD::SETCC ||
26270       VT.getSizeInBits() != N->getOperand(0)->getValueType(0).getSizeInBits())
26271     return SDValue();
26272
26273   // Now check that the other operand of the AND is a constant. We could
26274   // make the transformation for non-constant splats as well, but it's unclear
26275   // that would be a benefit as it would not eliminate any operations, just
26276   // perform one more step in scalar code before moving to the vector unit.
26277   if (BuildVectorSDNode *BV =
26278           dyn_cast<BuildVectorSDNode>(N->getOperand(0)->getOperand(1))) {
26279     // Bail out if the vector isn't a constant.
26280     if (!BV->isConstant())
26281       return SDValue();
26282
26283     // Everything checks out. Build up the new and improved node.
26284     SDLoc DL(N);
26285     EVT IntVT = BV->getValueType(0);
26286     // Create a new constant of the appropriate type for the transformed
26287     // DAG.
26288     SDValue SourceConst = DAG.getNode(N->getOpcode(), DL, VT, SDValue(BV, 0));
26289     // The AND node needs bitcasts to/from an integer vector type around it.
26290     SDValue MaskConst = DAG.getNode(ISD::BITCAST, DL, IntVT, SourceConst);
26291     SDValue NewAnd = DAG.getNode(ISD::AND, DL, IntVT,
26292                                  N->getOperand(0)->getOperand(0), MaskConst);
26293     SDValue Res = DAG.getNode(ISD::BITCAST, DL, VT, NewAnd);
26294     return Res;
26295   }
26296
26297   return SDValue();
26298 }
26299
26300 static SDValue PerformSINT_TO_FPCombine(SDNode *N, SelectionDAG &DAG,
26301                                         const X86Subtarget *Subtarget) {
26302   // First try to optimize away the conversion entirely when it's
26303   // conditionally from a constant. Vectors only.
26304   SDValue Res = performVectorCompareAndMaskUnaryOpCombine(N, DAG);
26305   if (Res != SDValue())
26306     return Res;
26307
26308   // Now move on to more general possibilities.
26309   SDValue Op0 = N->getOperand(0);
26310   EVT InVT = Op0->getValueType(0);
26311
26312   // SINT_TO_FP(v4i8) -> SINT_TO_FP(SEXT(v4i8 to v4i32))
26313   if (InVT == MVT::v8i8 || InVT == MVT::v4i8) {
26314     SDLoc dl(N);
26315     MVT DstVT = InVT == MVT::v4i8 ? MVT::v4i32 : MVT::v8i32;
26316     SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
26317     return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
26318   }
26319
26320   // Transform (SINT_TO_FP (i64 ...)) into an x87 operation if we have
26321   // a 32-bit target where SSE doesn't support i64->FP operations.
26322   if (Op0.getOpcode() == ISD::LOAD) {
26323     LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
26324     EVT VT = Ld->getValueType(0);
26325     if (!Ld->isVolatile() && !N->getValueType(0).isVector() &&
26326         ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
26327         !Subtarget->is64Bit() && VT == MVT::i64) {
26328       SDValue FILDChain = Subtarget->getTargetLowering()->BuildFILD(
26329           SDValue(N, 0), Ld->getValueType(0), Ld->getChain(), Op0, DAG);
26330       DAG.ReplaceAllUsesOfValueWith(Op0.getValue(1), FILDChain.getValue(1));
26331       return FILDChain;
26332     }
26333   }
26334   return SDValue();
26335 }
26336
26337 // Optimize RES, EFLAGS = X86ISD::ADC LHS, RHS, EFLAGS
26338 static SDValue PerformADCCombine(SDNode *N, SelectionDAG &DAG,
26339                                  X86TargetLowering::DAGCombinerInfo &DCI) {
26340   // If the LHS and RHS of the ADC node are zero, then it can't overflow and
26341   // the result is either zero or one (depending on the input carry bit).
26342   // Strength reduce this down to a "set on carry" aka SETCC_CARRY&1.
26343   if (X86::isZeroNode(N->getOperand(0)) &&
26344       X86::isZeroNode(N->getOperand(1)) &&
26345       // We don't have a good way to replace an EFLAGS use, so only do this when
26346       // dead right now.
26347       SDValue(N, 1).use_empty()) {
26348     SDLoc DL(N);
26349     EVT VT = N->getValueType(0);
26350     SDValue CarryOut = DAG.getConstant(0, N->getValueType(1));
26351     SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
26352                                DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
26353                                            DAG.getConstant(X86::COND_B,MVT::i8),
26354                                            N->getOperand(2)),
26355                                DAG.getConstant(1, VT));
26356     return DCI.CombineTo(N, Res1, CarryOut);
26357   }
26358
26359   return SDValue();
26360 }
26361
26362 // fold (add Y, (sete  X, 0)) -> adc  0, Y
26363 //      (add Y, (setne X, 0)) -> sbb -1, Y
26364 //      (sub (sete  X, 0), Y) -> sbb  0, Y
26365 //      (sub (setne X, 0), Y) -> adc -1, Y
26366 static SDValue OptimizeConditionalInDecrement(SDNode *N, SelectionDAG &DAG) {
26367   SDLoc DL(N);
26368
26369   // Look through ZExts.
26370   SDValue Ext = N->getOperand(N->getOpcode() == ISD::SUB ? 1 : 0);
26371   if (Ext.getOpcode() != ISD::ZERO_EXTEND || !Ext.hasOneUse())
26372     return SDValue();
26373
26374   SDValue SetCC = Ext.getOperand(0);
26375   if (SetCC.getOpcode() != X86ISD::SETCC || !SetCC.hasOneUse())
26376     return SDValue();
26377
26378   X86::CondCode CC = (X86::CondCode)SetCC.getConstantOperandVal(0);
26379   if (CC != X86::COND_E && CC != X86::COND_NE)
26380     return SDValue();
26381
26382   SDValue Cmp = SetCC.getOperand(1);
26383   if (Cmp.getOpcode() != X86ISD::CMP || !Cmp.hasOneUse() ||
26384       !X86::isZeroNode(Cmp.getOperand(1)) ||
26385       !Cmp.getOperand(0).getValueType().isInteger())
26386     return SDValue();
26387
26388   SDValue CmpOp0 = Cmp.getOperand(0);
26389   SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
26390                                DAG.getConstant(1, CmpOp0.getValueType()));
26391
26392   SDValue OtherVal = N->getOperand(N->getOpcode() == ISD::SUB ? 0 : 1);
26393   if (CC == X86::COND_NE)
26394     return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
26395                        DL, OtherVal.getValueType(), OtherVal,
26396                        DAG.getConstant(-1ULL, OtherVal.getValueType()), NewCmp);
26397   return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
26398                      DL, OtherVal.getValueType(), OtherVal,
26399                      DAG.getConstant(0, OtherVal.getValueType()), NewCmp);
26400 }
26401
26402 /// PerformADDCombine - Do target-specific dag combines on integer adds.
26403 static SDValue PerformAddCombine(SDNode *N, SelectionDAG &DAG,
26404                                  const X86Subtarget *Subtarget) {
26405   EVT VT = N->getValueType(0);
26406   SDValue Op0 = N->getOperand(0);
26407   SDValue Op1 = N->getOperand(1);
26408
26409   // Try to synthesize horizontal adds from adds of shuffles.
26410   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
26411        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
26412       isHorizontalBinOp(Op0, Op1, true))
26413     return DAG.getNode(X86ISD::HADD, SDLoc(N), VT, Op0, Op1);
26414
26415   return OptimizeConditionalInDecrement(N, DAG);
26416 }
26417
26418 static SDValue PerformSubCombine(SDNode *N, SelectionDAG &DAG,
26419                                  const X86Subtarget *Subtarget) {
26420   SDValue Op0 = N->getOperand(0);
26421   SDValue Op1 = N->getOperand(1);
26422
26423   // X86 can't encode an immediate LHS of a sub. See if we can push the
26424   // negation into a preceding instruction.
26425   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op0)) {
26426     // If the RHS of the sub is a XOR with one use and a constant, invert the
26427     // immediate. Then add one to the LHS of the sub so we can turn
26428     // X-Y -> X+~Y+1, saving one register.
26429     if (Op1->hasOneUse() && Op1.getOpcode() == ISD::XOR &&
26430         isa<ConstantSDNode>(Op1.getOperand(1))) {
26431       APInt XorC = cast<ConstantSDNode>(Op1.getOperand(1))->getAPIntValue();
26432       EVT VT = Op0.getValueType();
26433       SDValue NewXor = DAG.getNode(ISD::XOR, SDLoc(Op1), VT,
26434                                    Op1.getOperand(0),
26435                                    DAG.getConstant(~XorC, VT));
26436       return DAG.getNode(ISD::ADD, SDLoc(N), VT, NewXor,
26437                          DAG.getConstant(C->getAPIntValue()+1, VT));
26438     }
26439   }
26440
26441   // Try to synthesize horizontal adds from adds of shuffles.
26442   EVT VT = N->getValueType(0);
26443   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
26444        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
26445       isHorizontalBinOp(Op0, Op1, true))
26446     return DAG.getNode(X86ISD::HSUB, SDLoc(N), VT, Op0, Op1);
26447
26448   return OptimizeConditionalInDecrement(N, DAG);
26449 }
26450
26451 /// performVZEXTCombine - Performs build vector combines
26452 static SDValue performVZEXTCombine(SDNode *N, SelectionDAG &DAG,
26453                                    TargetLowering::DAGCombinerInfo &DCI,
26454                                    const X86Subtarget *Subtarget) {
26455   SDLoc DL(N);
26456   MVT VT = N->getSimpleValueType(0);
26457   SDValue Op = N->getOperand(0);
26458   MVT OpVT = Op.getSimpleValueType();
26459   MVT OpEltVT = OpVT.getVectorElementType();
26460   unsigned InputBits = OpEltVT.getSizeInBits() * VT.getVectorNumElements();
26461
26462   // (vzext (bitcast (vzext (x)) -> (vzext x)
26463   SDValue V = Op;
26464   while (V.getOpcode() == ISD::BITCAST)
26465     V = V.getOperand(0);
26466
26467   if (V != Op && V.getOpcode() == X86ISD::VZEXT) {
26468     MVT InnerVT = V.getSimpleValueType();
26469     MVT InnerEltVT = InnerVT.getVectorElementType();
26470
26471     // If the element sizes match exactly, we can just do one larger vzext. This
26472     // is always an exact type match as vzext operates on integer types.
26473     if (OpEltVT == InnerEltVT) {
26474       assert(OpVT == InnerVT && "Types must match for vzext!");
26475       return DAG.getNode(X86ISD::VZEXT, DL, VT, V.getOperand(0));
26476     }
26477
26478     // The only other way we can combine them is if only a single element of the
26479     // inner vzext is used in the input to the outer vzext.
26480     if (InnerEltVT.getSizeInBits() < InputBits)
26481       return SDValue();
26482
26483     // In this case, the inner vzext is completely dead because we're going to
26484     // only look at bits inside of the low element. Just do the outer vzext on
26485     // a bitcast of the input to the inner.
26486     return DAG.getNode(X86ISD::VZEXT, DL, VT,
26487                        DAG.getNode(ISD::BITCAST, DL, OpVT, V));
26488   }
26489
26490   // Check if we can bypass extracting and re-inserting an element of an input
26491   // vector. Essentialy:
26492   // (bitcast (sclr2vec (ext_vec_elt x))) -> (bitcast x)
26493   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR &&
26494       V.getOperand(0).getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
26495       V.getOperand(0).getSimpleValueType().getSizeInBits() == InputBits) {
26496     SDValue ExtractedV = V.getOperand(0);
26497     SDValue OrigV = ExtractedV.getOperand(0);
26498     if (auto *ExtractIdx = dyn_cast<ConstantSDNode>(ExtractedV.getOperand(1)))
26499       if (ExtractIdx->getZExtValue() == 0) {
26500         MVT OrigVT = OrigV.getSimpleValueType();
26501         // Extract a subvector if necessary...
26502         if (OrigVT.getSizeInBits() > OpVT.getSizeInBits()) {
26503           int Ratio = OrigVT.getSizeInBits() / OpVT.getSizeInBits();
26504           OrigVT = MVT::getVectorVT(OrigVT.getVectorElementType(),
26505                                     OrigVT.getVectorNumElements() / Ratio);
26506           OrigV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigVT, OrigV,
26507                               DAG.getIntPtrConstant(0));
26508         }
26509         Op = DAG.getNode(ISD::BITCAST, DL, OpVT, OrigV);
26510         return DAG.getNode(X86ISD::VZEXT, DL, VT, Op);
26511       }
26512   }
26513
26514   return SDValue();
26515 }
26516
26517 SDValue X86TargetLowering::PerformDAGCombine(SDNode *N,
26518                                              DAGCombinerInfo &DCI) const {
26519   SelectionDAG &DAG = DCI.DAG;
26520   switch (N->getOpcode()) {
26521   default: break;
26522   case ISD::EXTRACT_VECTOR_ELT:
26523     return PerformEXTRACT_VECTOR_ELTCombine(N, DAG, DCI);
26524   case ISD::VSELECT:
26525   case ISD::SELECT:
26526   case X86ISD::SHRUNKBLEND:
26527     return PerformSELECTCombine(N, DAG, DCI, Subtarget);
26528   case ISD::BITCAST:        return PerformBITCASTCombine(N, DAG);
26529   case X86ISD::CMOV:        return PerformCMOVCombine(N, DAG, DCI, Subtarget);
26530   case ISD::ADD:            return PerformAddCombine(N, DAG, Subtarget);
26531   case ISD::SUB:            return PerformSubCombine(N, DAG, Subtarget);
26532   case X86ISD::ADC:         return PerformADCCombine(N, DAG, DCI);
26533   case ISD::MUL:            return PerformMulCombine(N, DAG, DCI);
26534   case ISD::SHL:
26535   case ISD::SRA:
26536   case ISD::SRL:            return PerformShiftCombine(N, DAG, DCI, Subtarget);
26537   case ISD::AND:            return PerformAndCombine(N, DAG, DCI, Subtarget);
26538   case ISD::OR:             return PerformOrCombine(N, DAG, DCI, Subtarget);
26539   case ISD::XOR:            return PerformXorCombine(N, DAG, DCI, Subtarget);
26540   case ISD::LOAD:           return PerformLOADCombine(N, DAG, DCI, Subtarget);
26541   case ISD::MLOAD:          return PerformMLOADCombine(N, DAG, DCI, Subtarget);
26542   case ISD::STORE:          return PerformSTORECombine(N, DAG, Subtarget);
26543   case ISD::MSTORE:         return PerformMSTORECombine(N, DAG, Subtarget);
26544   case ISD::SINT_TO_FP:     return PerformSINT_TO_FPCombine(N, DAG, Subtarget);
26545   case ISD::FADD:           return PerformFADDCombine(N, DAG, Subtarget);
26546   case ISD::FSUB:           return PerformFSUBCombine(N, DAG, Subtarget);
26547   case X86ISD::FXOR:
26548   case X86ISD::FOR:         return PerformFORCombine(N, DAG);
26549   case X86ISD::FMIN:
26550   case X86ISD::FMAX:        return PerformFMinFMaxCombine(N, DAG);
26551   case X86ISD::FAND:        return PerformFANDCombine(N, DAG);
26552   case X86ISD::FANDN:       return PerformFANDNCombine(N, DAG);
26553   case X86ISD::BT:          return PerformBTCombine(N, DAG, DCI);
26554   case X86ISD::VZEXT_MOVL:  return PerformVZEXT_MOVLCombine(N, DAG);
26555   case ISD::ANY_EXTEND:
26556   case ISD::ZERO_EXTEND:    return PerformZExtCombine(N, DAG, DCI, Subtarget);
26557   case ISD::SIGN_EXTEND:    return PerformSExtCombine(N, DAG, DCI, Subtarget);
26558   case ISD::SIGN_EXTEND_INREG:
26559     return PerformSIGN_EXTEND_INREGCombine(N, DAG, Subtarget);
26560   case ISD::TRUNCATE:       return PerformTruncateCombine(N, DAG,DCI,Subtarget);
26561   case ISD::SETCC:          return PerformISDSETCCCombine(N, DAG, Subtarget);
26562   case X86ISD::SETCC:       return PerformSETCCCombine(N, DAG, DCI, Subtarget);
26563   case X86ISD::BRCOND:      return PerformBrCondCombine(N, DAG, DCI, Subtarget);
26564   case X86ISD::VZEXT:       return performVZEXTCombine(N, DAG, DCI, Subtarget);
26565   case X86ISD::SHUFP:       // Handle all target specific shuffles
26566   case X86ISD::PALIGNR:
26567   case X86ISD::UNPCKH:
26568   case X86ISD::UNPCKL:
26569   case X86ISD::MOVHLPS:
26570   case X86ISD::MOVLHPS:
26571   case X86ISD::PSHUFB:
26572   case X86ISD::PSHUFD:
26573   case X86ISD::PSHUFHW:
26574   case X86ISD::PSHUFLW:
26575   case X86ISD::MOVSS:
26576   case X86ISD::MOVSD:
26577   case X86ISD::VPERMILPI:
26578   case X86ISD::VPERM2X128:
26579   case ISD::VECTOR_SHUFFLE: return PerformShuffleCombine(N, DAG, DCI,Subtarget);
26580   case ISD::FMA:            return PerformFMACombine(N, DAG, Subtarget);
26581   case ISD::INTRINSIC_WO_CHAIN:
26582     return PerformINTRINSIC_WO_CHAINCombine(N, DAG, Subtarget);
26583   case X86ISD::INSERTPS: {
26584     if (getTargetMachine().getOptLevel() > CodeGenOpt::None)
26585       return PerformINSERTPSCombine(N, DAG, Subtarget);
26586     break;
26587   }
26588   case ISD::BUILD_VECTOR: return PerformBUILD_VECTORCombine(N, DAG, Subtarget);
26589   }
26590
26591   return SDValue();
26592 }
26593
26594 /// isTypeDesirableForOp - Return true if the target has native support for
26595 /// the specified value type and it is 'desirable' to use the type for the
26596 /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
26597 /// instruction encodings are longer and some i16 instructions are slow.
26598 bool X86TargetLowering::isTypeDesirableForOp(unsigned Opc, EVT VT) const {
26599   if (!isTypeLegal(VT))
26600     return false;
26601   if (VT != MVT::i16)
26602     return true;
26603
26604   switch (Opc) {
26605   default:
26606     return true;
26607   case ISD::LOAD:
26608   case ISD::SIGN_EXTEND:
26609   case ISD::ZERO_EXTEND:
26610   case ISD::ANY_EXTEND:
26611   case ISD::SHL:
26612   case ISD::SRL:
26613   case ISD::SUB:
26614   case ISD::ADD:
26615   case ISD::MUL:
26616   case ISD::AND:
26617   case ISD::OR:
26618   case ISD::XOR:
26619     return false;
26620   }
26621 }
26622
26623 /// IsDesirableToPromoteOp - This method query the target whether it is
26624 /// beneficial for dag combiner to promote the specified node. If true, it
26625 /// should return the desired promotion type by reference.
26626 bool X86TargetLowering::IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
26627   EVT VT = Op.getValueType();
26628   if (VT != MVT::i16)
26629     return false;
26630
26631   bool Promote = false;
26632   bool Commute = false;
26633   switch (Op.getOpcode()) {
26634   default: break;
26635   case ISD::LOAD: {
26636     LoadSDNode *LD = cast<LoadSDNode>(Op);
26637     // If the non-extending load has a single use and it's not live out, then it
26638     // might be folded.
26639     if (LD->getExtensionType() == ISD::NON_EXTLOAD /*&&
26640                                                      Op.hasOneUse()*/) {
26641       for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
26642              UE = Op.getNode()->use_end(); UI != UE; ++UI) {
26643         // The only case where we'd want to promote LOAD (rather then it being
26644         // promoted as an operand is when it's only use is liveout.
26645         if (UI->getOpcode() != ISD::CopyToReg)
26646           return false;
26647       }
26648     }
26649     Promote = true;
26650     break;
26651   }
26652   case ISD::SIGN_EXTEND:
26653   case ISD::ZERO_EXTEND:
26654   case ISD::ANY_EXTEND:
26655     Promote = true;
26656     break;
26657   case ISD::SHL:
26658   case ISD::SRL: {
26659     SDValue N0 = Op.getOperand(0);
26660     // Look out for (store (shl (load), x)).
26661     if (MayFoldLoad(N0) && MayFoldIntoStore(Op))
26662       return false;
26663     Promote = true;
26664     break;
26665   }
26666   case ISD::ADD:
26667   case ISD::MUL:
26668   case ISD::AND:
26669   case ISD::OR:
26670   case ISD::XOR:
26671     Commute = true;
26672     // fallthrough
26673   case ISD::SUB: {
26674     SDValue N0 = Op.getOperand(0);
26675     SDValue N1 = Op.getOperand(1);
26676     if (!Commute && MayFoldLoad(N1))
26677       return false;
26678     // Avoid disabling potential load folding opportunities.
26679     if (MayFoldLoad(N0) && (!isa<ConstantSDNode>(N1) || MayFoldIntoStore(Op)))
26680       return false;
26681     if (MayFoldLoad(N1) && (!isa<ConstantSDNode>(N0) || MayFoldIntoStore(Op)))
26682       return false;
26683     Promote = true;
26684   }
26685   }
26686
26687   PVT = MVT::i32;
26688   return Promote;
26689 }
26690
26691 //===----------------------------------------------------------------------===//
26692 //                           X86 Inline Assembly Support
26693 //===----------------------------------------------------------------------===//
26694
26695 namespace {
26696   // Helper to match a string separated by whitespace.
26697   bool matchAsmImpl(StringRef s, ArrayRef<const StringRef *> args) {
26698     s = s.substr(s.find_first_not_of(" \t")); // Skip leading whitespace.
26699
26700     for (unsigned i = 0, e = args.size(); i != e; ++i) {
26701       StringRef piece(*args[i]);
26702       if (!s.startswith(piece)) // Check if the piece matches.
26703         return false;
26704
26705       s = s.substr(piece.size());
26706       StringRef::size_type pos = s.find_first_not_of(" \t");
26707       if (pos == 0) // We matched a prefix.
26708         return false;
26709
26710       s = s.substr(pos);
26711     }
26712
26713     return s.empty();
26714   }
26715   const VariadicFunction1<bool, StringRef, StringRef, matchAsmImpl> matchAsm={};
26716 }
26717
26718 static bool clobbersFlagRegisters(const SmallVector<StringRef, 4> &AsmPieces) {
26719
26720   if (AsmPieces.size() == 3 || AsmPieces.size() == 4) {
26721     if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{cc}") &&
26722         std::count(AsmPieces.begin(), AsmPieces.end(), "~{flags}") &&
26723         std::count(AsmPieces.begin(), AsmPieces.end(), "~{fpsr}")) {
26724
26725       if (AsmPieces.size() == 3)
26726         return true;
26727       else if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{dirflag}"))
26728         return true;
26729     }
26730   }
26731   return false;
26732 }
26733
26734 bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const {
26735   InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
26736
26737   std::string AsmStr = IA->getAsmString();
26738
26739   IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
26740   if (!Ty || Ty->getBitWidth() % 16 != 0)
26741     return false;
26742
26743   // TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
26744   SmallVector<StringRef, 4> AsmPieces;
26745   SplitString(AsmStr, AsmPieces, ";\n");
26746
26747   switch (AsmPieces.size()) {
26748   default: return false;
26749   case 1:
26750     // FIXME: this should verify that we are targeting a 486 or better.  If not,
26751     // we will turn this bswap into something that will be lowered to logical
26752     // ops instead of emitting the bswap asm.  For now, we don't support 486 or
26753     // lower so don't worry about this.
26754     // bswap $0
26755     if (matchAsm(AsmPieces[0], "bswap", "$0") ||
26756         matchAsm(AsmPieces[0], "bswapl", "$0") ||
26757         matchAsm(AsmPieces[0], "bswapq", "$0") ||
26758         matchAsm(AsmPieces[0], "bswap", "${0:q}") ||
26759         matchAsm(AsmPieces[0], "bswapl", "${0:q}") ||
26760         matchAsm(AsmPieces[0], "bswapq", "${0:q}")) {
26761       // No need to check constraints, nothing other than the equivalent of
26762       // "=r,0" would be valid here.
26763       return IntrinsicLowering::LowerToByteSwap(CI);
26764     }
26765
26766     // rorw $$8, ${0:w}  -->  llvm.bswap.i16
26767     if (CI->getType()->isIntegerTy(16) &&
26768         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
26769         (matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") ||
26770          matchAsm(AsmPieces[0], "rolw", "$$8,", "${0:w}"))) {
26771       AsmPieces.clear();
26772       const std::string &ConstraintsStr = IA->getConstraintString();
26773       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
26774       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
26775       if (clobbersFlagRegisters(AsmPieces))
26776         return IntrinsicLowering::LowerToByteSwap(CI);
26777     }
26778     break;
26779   case 3:
26780     if (CI->getType()->isIntegerTy(32) &&
26781         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
26782         matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") &&
26783         matchAsm(AsmPieces[1], "rorl", "$$16,", "$0") &&
26784         matchAsm(AsmPieces[2], "rorw", "$$8,", "${0:w}")) {
26785       AsmPieces.clear();
26786       const std::string &ConstraintsStr = IA->getConstraintString();
26787       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
26788       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
26789       if (clobbersFlagRegisters(AsmPieces))
26790         return IntrinsicLowering::LowerToByteSwap(CI);
26791     }
26792
26793     if (CI->getType()->isIntegerTy(64)) {
26794       InlineAsm::ConstraintInfoVector Constraints = IA->ParseConstraints();
26795       if (Constraints.size() >= 2 &&
26796           Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
26797           Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {
26798         // bswap %eax / bswap %edx / xchgl %eax, %edx  -> llvm.bswap.i64
26799         if (matchAsm(AsmPieces[0], "bswap", "%eax") &&
26800             matchAsm(AsmPieces[1], "bswap", "%edx") &&
26801             matchAsm(AsmPieces[2], "xchgl", "%eax,", "%edx"))
26802           return IntrinsicLowering::LowerToByteSwap(CI);
26803       }
26804     }
26805     break;
26806   }
26807   return false;
26808 }
26809
26810 /// getConstraintType - Given a constraint letter, return the type of
26811 /// constraint it is for this target.
26812 X86TargetLowering::ConstraintType
26813 X86TargetLowering::getConstraintType(const std::string &Constraint) const {
26814   if (Constraint.size() == 1) {
26815     switch (Constraint[0]) {
26816     case 'R':
26817     case 'q':
26818     case 'Q':
26819     case 'f':
26820     case 't':
26821     case 'u':
26822     case 'y':
26823     case 'x':
26824     case 'Y':
26825     case 'l':
26826       return C_RegisterClass;
26827     case 'a':
26828     case 'b':
26829     case 'c':
26830     case 'd':
26831     case 'S':
26832     case 'D':
26833     case 'A':
26834       return C_Register;
26835     case 'I':
26836     case 'J':
26837     case 'K':
26838     case 'L':
26839     case 'M':
26840     case 'N':
26841     case 'G':
26842     case 'C':
26843     case 'e':
26844     case 'Z':
26845       return C_Other;
26846     default:
26847       break;
26848     }
26849   }
26850   return TargetLowering::getConstraintType(Constraint);
26851 }
26852
26853 /// Examine constraint type and operand type and determine a weight value.
26854 /// This object must already have been set up with the operand type
26855 /// and the current alternative constraint selected.
26856 TargetLowering::ConstraintWeight
26857   X86TargetLowering::getSingleConstraintMatchWeight(
26858     AsmOperandInfo &info, const char *constraint) const {
26859   ConstraintWeight weight = CW_Invalid;
26860   Value *CallOperandVal = info.CallOperandVal;
26861     // If we don't have a value, we can't do a match,
26862     // but allow it at the lowest weight.
26863   if (!CallOperandVal)
26864     return CW_Default;
26865   Type *type = CallOperandVal->getType();
26866   // Look at the constraint type.
26867   switch (*constraint) {
26868   default:
26869     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
26870   case 'R':
26871   case 'q':
26872   case 'Q':
26873   case 'a':
26874   case 'b':
26875   case 'c':
26876   case 'd':
26877   case 'S':
26878   case 'D':
26879   case 'A':
26880     if (CallOperandVal->getType()->isIntegerTy())
26881       weight = CW_SpecificReg;
26882     break;
26883   case 'f':
26884   case 't':
26885   case 'u':
26886     if (type->isFloatingPointTy())
26887       weight = CW_SpecificReg;
26888     break;
26889   case 'y':
26890     if (type->isX86_MMXTy() && Subtarget->hasMMX())
26891       weight = CW_SpecificReg;
26892     break;
26893   case 'x':
26894   case 'Y':
26895     if (((type->getPrimitiveSizeInBits() == 128) && Subtarget->hasSSE1()) ||
26896         ((type->getPrimitiveSizeInBits() == 256) && Subtarget->hasFp256()))
26897       weight = CW_Register;
26898     break;
26899   case 'I':
26900     if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
26901       if (C->getZExtValue() <= 31)
26902         weight = CW_Constant;
26903     }
26904     break;
26905   case 'J':
26906     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26907       if (C->getZExtValue() <= 63)
26908         weight = CW_Constant;
26909     }
26910     break;
26911   case 'K':
26912     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26913       if ((C->getSExtValue() >= -0x80) && (C->getSExtValue() <= 0x7f))
26914         weight = CW_Constant;
26915     }
26916     break;
26917   case 'L':
26918     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26919       if ((C->getZExtValue() == 0xff) || (C->getZExtValue() == 0xffff))
26920         weight = CW_Constant;
26921     }
26922     break;
26923   case 'M':
26924     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26925       if (C->getZExtValue() <= 3)
26926         weight = CW_Constant;
26927     }
26928     break;
26929   case 'N':
26930     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26931       if (C->getZExtValue() <= 0xff)
26932         weight = CW_Constant;
26933     }
26934     break;
26935   case 'G':
26936   case 'C':
26937     if (dyn_cast<ConstantFP>(CallOperandVal)) {
26938       weight = CW_Constant;
26939     }
26940     break;
26941   case 'e':
26942     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26943       if ((C->getSExtValue() >= -0x80000000LL) &&
26944           (C->getSExtValue() <= 0x7fffffffLL))
26945         weight = CW_Constant;
26946     }
26947     break;
26948   case 'Z':
26949     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26950       if (C->getZExtValue() <= 0xffffffff)
26951         weight = CW_Constant;
26952     }
26953     break;
26954   }
26955   return weight;
26956 }
26957
26958 /// LowerXConstraint - try to replace an X constraint, which matches anything,
26959 /// with another that has more specific requirements based on the type of the
26960 /// corresponding operand.
26961 const char *X86TargetLowering::
26962 LowerXConstraint(EVT ConstraintVT) const {
26963   // FP X constraints get lowered to SSE1/2 registers if available, otherwise
26964   // 'f' like normal targets.
26965   if (ConstraintVT.isFloatingPoint()) {
26966     if (Subtarget->hasSSE2())
26967       return "Y";
26968     if (Subtarget->hasSSE1())
26969       return "x";
26970   }
26971
26972   return TargetLowering::LowerXConstraint(ConstraintVT);
26973 }
26974
26975 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
26976 /// vector.  If it is invalid, don't add anything to Ops.
26977 void X86TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
26978                                                      std::string &Constraint,
26979                                                      std::vector<SDValue>&Ops,
26980                                                      SelectionDAG &DAG) const {
26981   SDValue Result;
26982
26983   // Only support length 1 constraints for now.
26984   if (Constraint.length() > 1) return;
26985
26986   char ConstraintLetter = Constraint[0];
26987   switch (ConstraintLetter) {
26988   default: break;
26989   case 'I':
26990     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26991       if (C->getZExtValue() <= 31) {
26992         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
26993         break;
26994       }
26995     }
26996     return;
26997   case 'J':
26998     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26999       if (C->getZExtValue() <= 63) {
27000         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27001         break;
27002       }
27003     }
27004     return;
27005   case 'K':
27006     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27007       if (isInt<8>(C->getSExtValue())) {
27008         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27009         break;
27010       }
27011     }
27012     return;
27013   case 'L':
27014     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27015       if (C->getZExtValue() == 0xff || C->getZExtValue() == 0xffff ||
27016           (Subtarget->is64Bit() && C->getZExtValue() == 0xffffffff)) {
27017         Result = DAG.getTargetConstant(C->getSExtValue(), Op.getValueType());
27018         break;
27019       }
27020     }
27021     return;
27022   case 'M':
27023     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27024       if (C->getZExtValue() <= 3) {
27025         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27026         break;
27027       }
27028     }
27029     return;
27030   case 'N':
27031     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27032       if (C->getZExtValue() <= 255) {
27033         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27034         break;
27035       }
27036     }
27037     return;
27038   case 'O':
27039     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27040       if (C->getZExtValue() <= 127) {
27041         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27042         break;
27043       }
27044     }
27045     return;
27046   case 'e': {
27047     // 32-bit signed value
27048     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27049       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
27050                                            C->getSExtValue())) {
27051         // Widen to 64 bits here to get it sign extended.
27052         Result = DAG.getTargetConstant(C->getSExtValue(), MVT::i64);
27053         break;
27054       }
27055     // FIXME gcc accepts some relocatable values here too, but only in certain
27056     // memory models; it's complicated.
27057     }
27058     return;
27059   }
27060   case 'Z': {
27061     // 32-bit unsigned value
27062     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
27063       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
27064                                            C->getZExtValue())) {
27065         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
27066         break;
27067       }
27068     }
27069     // FIXME gcc accepts some relocatable values here too, but only in certain
27070     // memory models; it's complicated.
27071     return;
27072   }
27073   case 'i': {
27074     // Literal immediates are always ok.
27075     if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op)) {
27076       // Widen to 64 bits here to get it sign extended.
27077       Result = DAG.getTargetConstant(CST->getSExtValue(), MVT::i64);
27078       break;
27079     }
27080
27081     // In any sort of PIC mode addresses need to be computed at runtime by
27082     // adding in a register or some sort of table lookup.  These can't
27083     // be used as immediates.
27084     if (Subtarget->isPICStyleGOT() || Subtarget->isPICStyleStubPIC())
27085       return;
27086
27087     // If we are in non-pic codegen mode, we allow the address of a global (with
27088     // an optional displacement) to be used with 'i'.
27089     GlobalAddressSDNode *GA = nullptr;
27090     int64_t Offset = 0;
27091
27092     // Match either (GA), (GA+C), (GA+C1+C2), etc.
27093     while (1) {
27094       if ((GA = dyn_cast<GlobalAddressSDNode>(Op))) {
27095         Offset += GA->getOffset();
27096         break;
27097       } else if (Op.getOpcode() == ISD::ADD) {
27098         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
27099           Offset += C->getZExtValue();
27100           Op = Op.getOperand(0);
27101           continue;
27102         }
27103       } else if (Op.getOpcode() == ISD::SUB) {
27104         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
27105           Offset += -C->getZExtValue();
27106           Op = Op.getOperand(0);
27107           continue;
27108         }
27109       }
27110
27111       // Otherwise, this isn't something we can handle, reject it.
27112       return;
27113     }
27114
27115     const GlobalValue *GV = GA->getGlobal();
27116     // If we require an extra load to get this address, as in PIC mode, we
27117     // can't accept it.
27118     if (isGlobalStubReference(
27119             Subtarget->ClassifyGlobalReference(GV, DAG.getTarget())))
27120       return;
27121
27122     Result = DAG.getTargetGlobalAddress(GV, SDLoc(Op),
27123                                         GA->getValueType(0), Offset);
27124     break;
27125   }
27126   }
27127
27128   if (Result.getNode()) {
27129     Ops.push_back(Result);
27130     return;
27131   }
27132   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
27133 }
27134
27135 std::pair<unsigned, const TargetRegisterClass*>
27136 X86TargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
27137                                                 MVT VT) const {
27138   // First, see if this is a constraint that directly corresponds to an LLVM
27139   // register class.
27140   if (Constraint.size() == 1) {
27141     // GCC Constraint Letters
27142     switch (Constraint[0]) {
27143     default: break;
27144       // TODO: Slight differences here in allocation order and leaving
27145       // RIP in the class. Do they matter any more here than they do
27146       // in the normal allocation?
27147     case 'q':   // GENERAL_REGS in 64-bit mode, Q_REGS in 32-bit mode.
27148       if (Subtarget->is64Bit()) {
27149         if (VT == MVT::i32 || VT == MVT::f32)
27150           return std::make_pair(0U, &X86::GR32RegClass);
27151         if (VT == MVT::i16)
27152           return std::make_pair(0U, &X86::GR16RegClass);
27153         if (VT == MVT::i8 || VT == MVT::i1)
27154           return std::make_pair(0U, &X86::GR8RegClass);
27155         if (VT == MVT::i64 || VT == MVT::f64)
27156           return std::make_pair(0U, &X86::GR64RegClass);
27157         break;
27158       }
27159       // 32-bit fallthrough
27160     case 'Q':   // Q_REGS
27161       if (VT == MVT::i32 || VT == MVT::f32)
27162         return std::make_pair(0U, &X86::GR32_ABCDRegClass);
27163       if (VT == MVT::i16)
27164         return std::make_pair(0U, &X86::GR16_ABCDRegClass);
27165       if (VT == MVT::i8 || VT == MVT::i1)
27166         return std::make_pair(0U, &X86::GR8_ABCD_LRegClass);
27167       if (VT == MVT::i64)
27168         return std::make_pair(0U, &X86::GR64_ABCDRegClass);
27169       break;
27170     case 'r':   // GENERAL_REGS
27171     case 'l':   // INDEX_REGS
27172       if (VT == MVT::i8 || VT == MVT::i1)
27173         return std::make_pair(0U, &X86::GR8RegClass);
27174       if (VT == MVT::i16)
27175         return std::make_pair(0U, &X86::GR16RegClass);
27176       if (VT == MVT::i32 || VT == MVT::f32 || !Subtarget->is64Bit())
27177         return std::make_pair(0U, &X86::GR32RegClass);
27178       return std::make_pair(0U, &X86::GR64RegClass);
27179     case 'R':   // LEGACY_REGS
27180       if (VT == MVT::i8 || VT == MVT::i1)
27181         return std::make_pair(0U, &X86::GR8_NOREXRegClass);
27182       if (VT == MVT::i16)
27183         return std::make_pair(0U, &X86::GR16_NOREXRegClass);
27184       if (VT == MVT::i32 || !Subtarget->is64Bit())
27185         return std::make_pair(0U, &X86::GR32_NOREXRegClass);
27186       return std::make_pair(0U, &X86::GR64_NOREXRegClass);
27187     case 'f':  // FP Stack registers.
27188       // If SSE is enabled for this VT, use f80 to ensure the isel moves the
27189       // value to the correct fpstack register class.
27190       if (VT == MVT::f32 && !isScalarFPTypeInSSEReg(VT))
27191         return std::make_pair(0U, &X86::RFP32RegClass);
27192       if (VT == MVT::f64 && !isScalarFPTypeInSSEReg(VT))
27193         return std::make_pair(0U, &X86::RFP64RegClass);
27194       return std::make_pair(0U, &X86::RFP80RegClass);
27195     case 'y':   // MMX_REGS if MMX allowed.
27196       if (!Subtarget->hasMMX()) break;
27197       return std::make_pair(0U, &X86::VR64RegClass);
27198     case 'Y':   // SSE_REGS if SSE2 allowed
27199       if (!Subtarget->hasSSE2()) break;
27200       // FALL THROUGH.
27201     case 'x':   // SSE_REGS if SSE1 allowed or AVX_REGS if AVX allowed
27202       if (!Subtarget->hasSSE1()) break;
27203
27204       switch (VT.SimpleTy) {
27205       default: break;
27206       // Scalar SSE types.
27207       case MVT::f32:
27208       case MVT::i32:
27209         return std::make_pair(0U, &X86::FR32RegClass);
27210       case MVT::f64:
27211       case MVT::i64:
27212         return std::make_pair(0U, &X86::FR64RegClass);
27213       // Vector types.
27214       case MVT::v16i8:
27215       case MVT::v8i16:
27216       case MVT::v4i32:
27217       case MVT::v2i64:
27218       case MVT::v4f32:
27219       case MVT::v2f64:
27220         return std::make_pair(0U, &X86::VR128RegClass);
27221       // AVX types.
27222       case MVT::v32i8:
27223       case MVT::v16i16:
27224       case MVT::v8i32:
27225       case MVT::v4i64:
27226       case MVT::v8f32:
27227       case MVT::v4f64:
27228         return std::make_pair(0U, &X86::VR256RegClass);
27229       case MVT::v8f64:
27230       case MVT::v16f32:
27231       case MVT::v16i32:
27232       case MVT::v8i64:
27233         return std::make_pair(0U, &X86::VR512RegClass);
27234       }
27235       break;
27236     }
27237   }
27238
27239   // Use the default implementation in TargetLowering to convert the register
27240   // constraint into a member of a register class.
27241   std::pair<unsigned, const TargetRegisterClass*> Res;
27242   Res = TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
27243
27244   // Not found as a standard register?
27245   if (!Res.second) {
27246     // Map st(0) -> st(7) -> ST0
27247     if (Constraint.size() == 7 && Constraint[0] == '{' &&
27248         tolower(Constraint[1]) == 's' &&
27249         tolower(Constraint[2]) == 't' &&
27250         Constraint[3] == '(' &&
27251         (Constraint[4] >= '0' && Constraint[4] <= '7') &&
27252         Constraint[5] == ')' &&
27253         Constraint[6] == '}') {
27254
27255       Res.first = X86::FP0+Constraint[4]-'0';
27256       Res.second = &X86::RFP80RegClass;
27257       return Res;
27258     }
27259
27260     // GCC allows "st(0)" to be called just plain "st".
27261     if (StringRef("{st}").equals_lower(Constraint)) {
27262       Res.first = X86::FP0;
27263       Res.second = &X86::RFP80RegClass;
27264       return Res;
27265     }
27266
27267     // flags -> EFLAGS
27268     if (StringRef("{flags}").equals_lower(Constraint)) {
27269       Res.first = X86::EFLAGS;
27270       Res.second = &X86::CCRRegClass;
27271       return Res;
27272     }
27273
27274     // 'A' means EAX + EDX.
27275     if (Constraint == "A") {
27276       Res.first = X86::EAX;
27277       Res.second = &X86::GR32_ADRegClass;
27278       return Res;
27279     }
27280     return Res;
27281   }
27282
27283   // Otherwise, check to see if this is a register class of the wrong value
27284   // type.  For example, we want to map "{ax},i32" -> {eax}, we don't want it to
27285   // turn into {ax},{dx}.
27286   if (Res.second->hasType(VT))
27287     return Res;   // Correct type already, nothing to do.
27288
27289   // All of the single-register GCC register classes map their values onto
27290   // 16-bit register pieces "ax","dx","cx","bx","si","di","bp","sp".  If we
27291   // really want an 8-bit or 32-bit register, map to the appropriate register
27292   // class and return the appropriate register.
27293   if (Res.second == &X86::GR16RegClass) {
27294     if (VT == MVT::i8 || VT == MVT::i1) {
27295       unsigned DestReg = 0;
27296       switch (Res.first) {
27297       default: break;
27298       case X86::AX: DestReg = X86::AL; break;
27299       case X86::DX: DestReg = X86::DL; break;
27300       case X86::CX: DestReg = X86::CL; break;
27301       case X86::BX: DestReg = X86::BL; break;
27302       }
27303       if (DestReg) {
27304         Res.first = DestReg;
27305         Res.second = &X86::GR8RegClass;
27306       }
27307     } else if (VT == MVT::i32 || VT == MVT::f32) {
27308       unsigned DestReg = 0;
27309       switch (Res.first) {
27310       default: break;
27311       case X86::AX: DestReg = X86::EAX; break;
27312       case X86::DX: DestReg = X86::EDX; break;
27313       case X86::CX: DestReg = X86::ECX; break;
27314       case X86::BX: DestReg = X86::EBX; break;
27315       case X86::SI: DestReg = X86::ESI; break;
27316       case X86::DI: DestReg = X86::EDI; break;
27317       case X86::BP: DestReg = X86::EBP; break;
27318       case X86::SP: DestReg = X86::ESP; break;
27319       }
27320       if (DestReg) {
27321         Res.first = DestReg;
27322         Res.second = &X86::GR32RegClass;
27323       }
27324     } else if (VT == MVT::i64 || VT == MVT::f64) {
27325       unsigned DestReg = 0;
27326       switch (Res.first) {
27327       default: break;
27328       case X86::AX: DestReg = X86::RAX; break;
27329       case X86::DX: DestReg = X86::RDX; break;
27330       case X86::CX: DestReg = X86::RCX; break;
27331       case X86::BX: DestReg = X86::RBX; break;
27332       case X86::SI: DestReg = X86::RSI; break;
27333       case X86::DI: DestReg = X86::RDI; break;
27334       case X86::BP: DestReg = X86::RBP; break;
27335       case X86::SP: DestReg = X86::RSP; break;
27336       }
27337       if (DestReg) {
27338         Res.first = DestReg;
27339         Res.second = &X86::GR64RegClass;
27340       }
27341     }
27342   } else if (Res.second == &X86::FR32RegClass ||
27343              Res.second == &X86::FR64RegClass ||
27344              Res.second == &X86::VR128RegClass ||
27345              Res.second == &X86::VR256RegClass ||
27346              Res.second == &X86::FR32XRegClass ||
27347              Res.second == &X86::FR64XRegClass ||
27348              Res.second == &X86::VR128XRegClass ||
27349              Res.second == &X86::VR256XRegClass ||
27350              Res.second == &X86::VR512RegClass) {
27351     // Handle references to XMM physical registers that got mapped into the
27352     // wrong class.  This can happen with constraints like {xmm0} where the
27353     // target independent register mapper will just pick the first match it can
27354     // find, ignoring the required type.
27355
27356     if (VT == MVT::f32 || VT == MVT::i32)
27357       Res.second = &X86::FR32RegClass;
27358     else if (VT == MVT::f64 || VT == MVT::i64)
27359       Res.second = &X86::FR64RegClass;
27360     else if (X86::VR128RegClass.hasType(VT))
27361       Res.second = &X86::VR128RegClass;
27362     else if (X86::VR256RegClass.hasType(VT))
27363       Res.second = &X86::VR256RegClass;
27364     else if (X86::VR512RegClass.hasType(VT))
27365       Res.second = &X86::VR512RegClass;
27366   }
27367
27368   return Res;
27369 }
27370
27371 int X86TargetLowering::getScalingFactorCost(const AddrMode &AM,
27372                                             Type *Ty) const {
27373   // Scaling factors are not free at all.
27374   // An indexed folded instruction, i.e., inst (reg1, reg2, scale),
27375   // will take 2 allocations in the out of order engine instead of 1
27376   // for plain addressing mode, i.e. inst (reg1).
27377   // E.g.,
27378   // vaddps (%rsi,%drx), %ymm0, %ymm1
27379   // Requires two allocations (one for the load, one for the computation)
27380   // whereas:
27381   // vaddps (%rsi), %ymm0, %ymm1
27382   // Requires just 1 allocation, i.e., freeing allocations for other operations
27383   // and having less micro operations to execute.
27384   //
27385   // For some X86 architectures, this is even worse because for instance for
27386   // stores, the complex addressing mode forces the instruction to use the
27387   // "load" ports instead of the dedicated "store" port.
27388   // E.g., on Haswell:
27389   // vmovaps %ymm1, (%r8, %rdi) can use port 2 or 3.
27390   // vmovaps %ymm1, (%r8) can use port 2, 3, or 7.
27391   if (isLegalAddressingMode(AM, Ty))
27392     // Scale represents reg2 * scale, thus account for 1
27393     // as soon as we use a second register.
27394     return AM.Scale != 0;
27395   return -1;
27396 }
27397
27398 bool X86TargetLowering::isTargetFTOL() const {
27399   return Subtarget->isTargetKnownWindowsMSVC() && !Subtarget->is64Bit();
27400 }