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 "X86InstrBuilder.h"
  19 #include "X86MachineFunctionInfo.h"
  20 #include "X86TargetMachine.h"
  21 #include "X86TargetObjectFile.h"
  22 #include "llvm/ADT/SmallBitVector.h"
  23 #include "llvm/ADT/SmallSet.h"
  24 #include "llvm/ADT/Statistic.h"
  25 #include "llvm/ADT/StringExtras.h"
  26 #include "llvm/ADT/StringSwitch.h"
  27 #include "llvm/ADT/VariadicFunction.h"
  28 #include "llvm/CodeGen/IntrinsicLowering.h"
  29 #include "llvm/CodeGen/MachineFrameInfo.h"
  30 #include "llvm/CodeGen/MachineFunction.h"
  31 #include "llvm/CodeGen/MachineInstrBuilder.h"
  32 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  33 #include "llvm/CodeGen/MachineModuleInfo.h"
  34 #include "llvm/CodeGen/MachineRegisterInfo.h"
  35 #include "llvm/IR/CallSite.h"
  36 #include "llvm/IR/CallingConv.h"
  37 #include "llvm/IR/Constants.h"
  38 #include "llvm/IR/DerivedTypes.h"
  39 #include "llvm/IR/Function.h"
  40 #include "llvm/IR/GlobalAlias.h"
  41 #include "llvm/IR/GlobalVariable.h"
  42 #include "llvm/IR/Instructions.h"
  43 #include "llvm/IR/Intrinsics.h"
  44 #include "llvm/MC/MCAsmInfo.h"
  45 #include "llvm/MC/MCContext.h"
  46 #include "llvm/MC/MCExpr.h"
  47 #include "llvm/MC/MCSymbol.h"
  48 #include "llvm/Support/CommandLine.h"
  49 #include "llvm/Support/Debug.h"
  50 #include "llvm/Support/ErrorHandling.h"
  51 #include "llvm/Support/MathExtras.h"
  52 #include "llvm/Target/TargetOptions.h"
  53 #include "X86IntrinsicsInfo.h"
  54 #include <bitset>
  55 #include <numeric>
  56 #include <cctype>
  57 using namespace llvm;
  58
  59 #define DEBUG_TYPE "x86-isel"
  60
  61 STATISTIC(NumTailCalls, "Number of tail calls");
  62
  63 static cl::opt<bool> ExperimentalVectorWideningLegalization(
  64     "x86-experimental-vector-widening-legalization", cl::init(false),
  65     cl::desc("Enable an experimental vector type legalization through widening "
  66              "rather than promotion."),
  67     cl::Hidden);
  68
  69 static cl::opt<bool> ExperimentalVectorShuffleLowering(
  70     "x86-experimental-vector-shuffle-lowering", cl::init(true),
  71     cl::desc("Enable an experimental vector shuffle lowering code path."),
  72     cl::Hidden);
  73
  74 static cl::opt<bool> ExperimentalVectorShuffleLegality(
  75     "x86-experimental-vector-shuffle-legality", cl::init(false),
  76     cl::desc("Enable experimental shuffle legality based on the experimental "
  77              "shuffle lowering. Should only be used with the experimental "
  78              "shuffle lowering."),
  79     cl::Hidden);
  80
  81 static cl::opt<int> ReciprocalEstimateRefinementSteps(
  82     "x86-recip-refinement-steps", cl::init(1),
  83     cl::desc("Specify the number of Newton-Raphson iterations applied to the "
  84              "result of the hardware reciprocal estimate instruction."),
  85     cl::NotHidden);
  86
  87 // Forward declarations.
  88 static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1,
  89                        SDValue V2);
  90
  91 static SDValue ExtractSubVector(SDValue Vec, unsigned IdxVal,
  92                                 SelectionDAG &DAG, SDLoc dl,
  93                                 unsigned vectorWidth) {
  94   assert((vectorWidth == 128 || vectorWidth == 256) &&
  95          "Unsupported vector width");
  96   EVT VT = Vec.getValueType();
  97   EVT ElVT = VT.getVectorElementType();
  98   unsigned Factor = VT.getSizeInBits()/vectorWidth;
  99   EVT ResultVT = EVT::getVectorVT(*DAG.getContext(), ElVT,
 100                                   VT.getVectorNumElements()/Factor);
 101
 102   // Extract from UNDEF is UNDEF.
 103   if (Vec.getOpcode() == ISD::UNDEF)
 104     return DAG.getUNDEF(ResultVT);
 105
 106   // Extract the relevant vectorWidth bits.  Generate an EXTRACT_SUBVECTOR
 107   unsigned ElemsPerChunk = vectorWidth / ElVT.getSizeInBits();
 108
 109   // This is the index of the first element of the vectorWidth-bit chunk
 110   // we want.
 111   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits()) / vectorWidth)
 112                                * ElemsPerChunk);
 113
 114   // If the input is a buildvector just emit a smaller one.
 115   if (Vec.getOpcode() == ISD::BUILD_VECTOR)
 116     return DAG.getNode(ISD::BUILD_VECTOR, dl, ResultVT,
 117                        makeArrayRef(Vec->op_begin() + NormalizedIdxVal,
 118                                     ElemsPerChunk));
 119
 120   SDValue VecIdx = DAG.getIntPtrConstant(NormalizedIdxVal);
 121   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec, VecIdx);
 122 }
 123
 124 /// Generate a DAG to grab 128-bits from a vector > 128 bits.  This
 125 /// sets things up to match to an AVX VEXTRACTF128 / VEXTRACTI128
 126 /// or AVX-512 VEXTRACTF32x4 / VEXTRACTI32x4
 127 /// instructions or a simple subregister reference. Idx is an index in the
 128 /// 128 bits we want.  It need not be aligned to a 128-bit boundary.  That makes
 129 /// lowering EXTRACT_VECTOR_ELT operations easier.
 130 static SDValue Extract128BitVector(SDValue Vec, unsigned IdxVal,
 131                                    SelectionDAG &DAG, SDLoc dl) {
 132   assert((Vec.getValueType().is256BitVector() ||
 133           Vec.getValueType().is512BitVector()) && "Unexpected vector size!");
 134   return ExtractSubVector(Vec, IdxVal, DAG, dl, 128);
 135 }
 136
 137 /// Generate a DAG to grab 256-bits from a 512-bit vector.
 138 static SDValue Extract256BitVector(SDValue Vec, unsigned IdxVal,
 139                                    SelectionDAG &DAG, SDLoc dl) {
 140   assert(Vec.getValueType().is512BitVector() && "Unexpected vector size!");
 141   return ExtractSubVector(Vec, IdxVal, DAG, dl, 256);
 142 }
 143
 144 static SDValue InsertSubVector(SDValue Result, SDValue Vec,
 145                                unsigned IdxVal, SelectionDAG &DAG,
 146                                SDLoc dl, unsigned vectorWidth) {
 147   assert((vectorWidth == 128 || vectorWidth == 256) &&
 148          "Unsupported vector width");
 149   // Inserting UNDEF is Result
 150   if (Vec.getOpcode() == ISD::UNDEF)
 151     return Result;
 152   EVT VT = Vec.getValueType();
 153   EVT ElVT = VT.getVectorElementType();
 154   EVT ResultVT = Result.getValueType();
 155
 156   // Insert the relevant vectorWidth bits.
 157   unsigned ElemsPerChunk = vectorWidth/ElVT.getSizeInBits();
 158
 159   // This is the index of the first element of the vectorWidth-bit chunk
 160   // we want.
 161   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits())/vectorWidth)
 162                                * ElemsPerChunk);
 163
 164   SDValue VecIdx = DAG.getIntPtrConstant(NormalizedIdxVal);
 165   return DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec, VecIdx);
 166 }
 167
 168 /// Generate a DAG to put 128-bits into a vector > 128 bits.  This
 169 /// sets things up to match to an AVX VINSERTF128/VINSERTI128 or
 170 /// AVX-512 VINSERTF32x4/VINSERTI32x4 instructions or a
 171 /// simple superregister reference.  Idx is an index in the 128 bits
 172 /// we want.  It need not be aligned to a 128-bit boundary.  That makes
 173 /// lowering INSERT_VECTOR_ELT operations easier.
 174 static SDValue Insert128BitVector(SDValue Result, SDValue Vec, unsigned IdxVal,
 175                                   SelectionDAG &DAG,SDLoc dl) {
 176   assert(Vec.getValueType().is128BitVector() && "Unexpected vector size!");
 177   return InsertSubVector(Result, Vec, IdxVal, DAG, dl, 128);
 178 }
 179
 180 static SDValue Insert256BitVector(SDValue Result, SDValue Vec, unsigned IdxVal,
 181                                   SelectionDAG &DAG, SDLoc dl) {
 182   assert(Vec.getValueType().is256BitVector() && "Unexpected vector size!");
 183   return InsertSubVector(Result, Vec, IdxVal, DAG, dl, 256);
 184 }
 185
 186 /// Concat two 128-bit vectors into a 256 bit vector using VINSERTF128
 187 /// instructions. This is used because creating CONCAT_VECTOR nodes of
 188 /// BUILD_VECTORS returns a larger BUILD_VECTOR while we're trying to lower
 189 /// large BUILD_VECTORS.
 190 static SDValue Concat128BitVectors(SDValue V1, SDValue V2, EVT VT,
 191                                    unsigned NumElems, SelectionDAG &DAG,
 192                                    SDLoc dl) {
 193   SDValue V = Insert128BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
 194   return Insert128BitVector(V, V2, NumElems/2, DAG, dl);
 195 }
 196
 197 static SDValue Concat256BitVectors(SDValue V1, SDValue V2, EVT VT,
 198                                    unsigned NumElems, SelectionDAG &DAG,
 199                                    SDLoc dl) {
 200   SDValue V = Insert256BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
 201   return Insert256BitVector(V, V2, NumElems/2, DAG, dl);
 202 }
 203
 204 // FIXME: This should stop caching the target machine as soon as
 205 // we can remove resetOperationActions et al.
 206 X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM)
 207     : TargetLowering(TM) {
 208   Subtarget = &TM.getSubtarget<X86Subtarget>();
 209   X86ScalarSSEf64 = Subtarget->hasSSE2();
 210   X86ScalarSSEf32 = Subtarget->hasSSE1();
 211   TD = getDataLayout();
 212
 213   resetOperationActions();
 214 }
 215
 216 void X86TargetLowering::resetOperationActions() {
 217   const TargetMachine &TM = getTargetMachine();
 218   static bool FirstTimeThrough = true;
 219
 220   // If none of the target options have changed, then we don't need to reset the
 221   // operation actions.
 222   if (!FirstTimeThrough && TO == TM.Options) return;
 223
 224   if (!FirstTimeThrough) {
 225     // Reinitialize the actions.
 226     initActions();
 227     FirstTimeThrough = false;
 228   }
 229
 230   TO = TM.Options;
 231
 232   // Set up the TargetLowering object.
 233   static const MVT IntVTs[] = { MVT::i8, MVT::i16, MVT::i32, MVT::i64 };
 234
 235   // X86 is weird. It always uses i8 for shift amounts and setcc results.
 236   setBooleanContents(ZeroOrOneBooleanContent);
 237   // X86-SSE is even stranger. It uses -1 or 0 for vector masks.
 238   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
 239
 240   // For 64-bit, since we have so many registers, use the ILP scheduler.
 241   // For 32-bit, use the register pressure specific scheduling.
 242   // For Atom, always use ILP scheduling.
 243   if (Subtarget->isAtom())
 244     setSchedulingPreference(Sched::ILP);
 245   else if (Subtarget->is64Bit())
 246     setSchedulingPreference(Sched::ILP);
 247   else
 248     setSchedulingPreference(Sched::RegPressure);
 249   const X86RegisterInfo *RegInfo =
 250       TM.getSubtarget<X86Subtarget>().getRegisterInfo();
 251   setStackPointerRegisterToSaveRestore(RegInfo->getStackRegister());
 252
 253   // Bypass expensive divides on Atom when compiling with O2.
 254   if (TM.getOptLevel() >= CodeGenOpt::Default) {
 255     if (Subtarget->hasSlowDivide32())
 256       addBypassSlowDiv(32, 8);
 257     if (Subtarget->hasSlowDivide64() && Subtarget->is64Bit())
 258       addBypassSlowDiv(64, 16);
 259   }
 260
 261   if (Subtarget->isTargetKnownWindowsMSVC()) {
 262     // Setup Windows compiler runtime calls.
 263     setLibcallName(RTLIB::SDIV_I64, "_alldiv");
 264     setLibcallName(RTLIB::UDIV_I64, "_aulldiv");
 265     setLibcallName(RTLIB::SREM_I64, "_allrem");
 266     setLibcallName(RTLIB::UREM_I64, "_aullrem");
 267     setLibcallName(RTLIB::MUL_I64, "_allmul");
 268     setLibcallCallingConv(RTLIB::SDIV_I64, CallingConv::X86_StdCall);
 269     setLibcallCallingConv(RTLIB::UDIV_I64, CallingConv::X86_StdCall);
 270     setLibcallCallingConv(RTLIB::SREM_I64, CallingConv::X86_StdCall);
 271     setLibcallCallingConv(RTLIB::UREM_I64, CallingConv::X86_StdCall);
 272     setLibcallCallingConv(RTLIB::MUL_I64, CallingConv::X86_StdCall);
 273
 274     // The _ftol2 runtime function has an unusual calling conv, which
 275     // is modeled by a special pseudo-instruction.
 276     setLibcallName(RTLIB::FPTOUINT_F64_I64, nullptr);
 277     setLibcallName(RTLIB::FPTOUINT_F32_I64, nullptr);
 278     setLibcallName(RTLIB::FPTOUINT_F64_I32, nullptr);
 279     setLibcallName(RTLIB::FPTOUINT_F32_I32, nullptr);
 280   }
 281
 282   if (Subtarget->isTargetDarwin()) {
 283     // Darwin should use _setjmp/_longjmp instead of setjmp/longjmp.
 284     setUseUnderscoreSetJmp(false);
 285     setUseUnderscoreLongJmp(false);
 286   } else if (Subtarget->isTargetWindowsGNU()) {
 287     // MS runtime is weird: it exports _setjmp, but longjmp!
 288     setUseUnderscoreSetJmp(true);
 289     setUseUnderscoreLongJmp(false);
 290   } else {
 291     setUseUnderscoreSetJmp(true);
 292     setUseUnderscoreLongJmp(true);
 293   }
 294
 295   // Set up the register classes.
 296   addRegisterClass(MVT::i8, &X86::GR8RegClass);
 297   addRegisterClass(MVT::i16, &X86::GR16RegClass);
 298   addRegisterClass(MVT::i32, &X86::GR32RegClass);
 299   if (Subtarget->is64Bit())
 300     addRegisterClass(MVT::i64, &X86::GR64RegClass);
 301
 302   for (MVT VT : MVT::integer_valuetypes())
 303     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
 304
 305   // We don't accept any truncstore of integer registers.
 306   setTruncStoreAction(MVT::i64, MVT::i32, Expand);
 307   setTruncStoreAction(MVT::i64, MVT::i16, Expand);
 308   setTruncStoreAction(MVT::i64, MVT::i8 , Expand);
 309   setTruncStoreAction(MVT::i32, MVT::i16, Expand);
 310   setTruncStoreAction(MVT::i32, MVT::i8 , Expand);
 311   setTruncStoreAction(MVT::i16, MVT::i8,  Expand);
 312
 313   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
 314
 315   // SETOEQ and SETUNE require checking two conditions.
 316   setCondCodeAction(ISD::SETOEQ, MVT::f32, Expand);
 317   setCondCodeAction(ISD::SETOEQ, MVT::f64, Expand);
 318   setCondCodeAction(ISD::SETOEQ, MVT::f80, Expand);
 319   setCondCodeAction(ISD::SETUNE, MVT::f32, Expand);
 320   setCondCodeAction(ISD::SETUNE, MVT::f64, Expand);
 321   setCondCodeAction(ISD::SETUNE, MVT::f80, Expand);
 322
 323   // Promote all UINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have this
 324   // operation.
 325   setOperationAction(ISD::UINT_TO_FP       , MVT::i1   , Promote);
 326   setOperationAction(ISD::UINT_TO_FP       , MVT::i8   , Promote);
 327   setOperationAction(ISD::UINT_TO_FP       , MVT::i16  , Promote);
 328
 329   if (Subtarget->is64Bit()) {
 330     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Promote);
 331     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
 332   } else if (!TM.Options.UseSoftFloat) {
 333     // We have an algorithm for SSE2->double, and we turn this into a
 334     // 64-bit FILD followed by conditional FADD for other targets.
 335     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
 336     // We have an algorithm for SSE2, and we turn this into a 64-bit
 337     // FILD for other targets.
 338     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Custom);
 339   }
 340
 341   // Promote i1/i8 SINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have
 342   // this operation.
 343   setOperationAction(ISD::SINT_TO_FP       , MVT::i1   , Promote);
 344   setOperationAction(ISD::SINT_TO_FP       , MVT::i8   , Promote);
 345
 346   if (!TM.Options.UseSoftFloat) {
 347     // SSE has no i16 to fp conversion, only i32
 348     if (X86ScalarSSEf32) {
 349       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 350       // f32 and f64 cases are Legal, f80 case is not
 351       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 352     } else {
 353       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Custom);
 354       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 355     }
 356   } else {
 357     setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 358     setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Promote);
 359   }
 360
 361   // In 32-bit mode these are custom lowered.  In 64-bit mode F32 and F64
 362   // are Legal, f80 is custom lowered.
 363   setOperationAction(ISD::FP_TO_SINT     , MVT::i64  , Custom);
 364   setOperationAction(ISD::SINT_TO_FP     , MVT::i64  , Custom);
 365
 366   // Promote i1/i8 FP_TO_SINT to larger FP_TO_SINTS's, as X86 doesn't have
 367   // this operation.
 368   setOperationAction(ISD::FP_TO_SINT       , MVT::i1   , Promote);
 369   setOperationAction(ISD::FP_TO_SINT       , MVT::i8   , Promote);
 370
 371   if (X86ScalarSSEf32) {
 372     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Promote);
 373     // f32 and f64 cases are Legal, f80 case is not
 374     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 375   } else {
 376     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Custom);
 377     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 378   }
 379
 380   // Handle FP_TO_UINT by promoting the destination to a larger signed
 381   // conversion.
 382   setOperationAction(ISD::FP_TO_UINT       , MVT::i1   , Promote);
 383   setOperationAction(ISD::FP_TO_UINT       , MVT::i8   , Promote);
 384   setOperationAction(ISD::FP_TO_UINT       , MVT::i16  , Promote);
 385
 386   if (Subtarget->is64Bit()) {
 387     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Expand);
 388     setOperationAction(ISD::FP_TO_UINT     , MVT::i32  , Promote);
 389   } else if (!TM.Options.UseSoftFloat) {
 390     // Since AVX is a superset of SSE3, only check for SSE here.
 391     if (Subtarget->hasSSE1() && !Subtarget->hasSSE3())
 392       // Expand FP_TO_UINT into a select.
 393       // FIXME: We would like to use a Custom expander here eventually to do
 394       // the optimal thing for SSE vs. the default expansion in the legalizer.
 395       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Expand);
 396     else
 397       // With SSE3 we can use fisttpll to convert to a signed i64; without
 398       // SSE, we're stuck with a fistpll.
 399       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Custom);
 400   }
 401
 402   if (isTargetFTOL()) {
 403     // Use the _ftol2 runtime function, which has a pseudo-instruction
 404     // to handle its weird calling convention.
 405     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Custom);
 406   }
 407
 408   // TODO: when we have SSE, these could be more efficient, by using movd/movq.
 409   if (!X86ScalarSSEf64) {
 410     setOperationAction(ISD::BITCAST        , MVT::f32  , Expand);
 411     setOperationAction(ISD::BITCAST        , MVT::i32  , Expand);
 412     if (Subtarget->is64Bit()) {
 413       setOperationAction(ISD::BITCAST      , MVT::f64  , Expand);
 414       // Without SSE, i64->f64 goes through memory.
 415       setOperationAction(ISD::BITCAST      , MVT::i64  , Expand);
 416     }
 417   }
 418
 419   // Scalar integer divide and remainder are lowered to use operations that
 420   // produce two results, to match the available instructions. This exposes
 421   // the two-result form to trivial CSE, which is able to combine x/y and x%y
 422   // into a single instruction.
 423   //
 424   // Scalar integer multiply-high is also lowered to use two-result
 425   // operations, to match the available instructions. However, plain multiply
 426   // (low) operations are left as Legal, as there are single-result
 427   // instructions for this in x86. Using the two-result multiply instructions
 428   // when both high and low results are needed must be arranged by dagcombine.
 429   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
 430     MVT VT = IntVTs[i];
 431     setOperationAction(ISD::MULHS, VT, Expand);
 432     setOperationAction(ISD::MULHU, VT, Expand);
 433     setOperationAction(ISD::SDIV, VT, Expand);
 434     setOperationAction(ISD::UDIV, VT, Expand);
 435     setOperationAction(ISD::SREM, VT, Expand);
 436     setOperationAction(ISD::UREM, VT, Expand);
 437
 438     // Add/Sub overflow ops with MVT::Glues are lowered to EFLAGS dependences.
 439     setOperationAction(ISD::ADDC, VT, Custom);
 440     setOperationAction(ISD::ADDE, VT, Custom);
 441     setOperationAction(ISD::SUBC, VT, Custom);
 442     setOperationAction(ISD::SUBE, VT, Custom);
 443   }
 444
 445   setOperationAction(ISD::BR_JT            , MVT::Other, Expand);
 446   setOperationAction(ISD::BRCOND           , MVT::Other, Custom);
 447   setOperationAction(ISD::BR_CC            , MVT::f32,   Expand);
 448   setOperationAction(ISD::BR_CC            , MVT::f64,   Expand);
 449   setOperationAction(ISD::BR_CC            , MVT::f80,   Expand);
 450   setOperationAction(ISD::BR_CC            , MVT::i8,    Expand);
 451   setOperationAction(ISD::BR_CC            , MVT::i16,   Expand);
 452   setOperationAction(ISD::BR_CC            , MVT::i32,   Expand);
 453   setOperationAction(ISD::BR_CC            , MVT::i64,   Expand);
 454   setOperationAction(ISD::SELECT_CC        , MVT::f32,   Expand);
 455   setOperationAction(ISD::SELECT_CC        , MVT::f64,   Expand);
 456   setOperationAction(ISD::SELECT_CC        , MVT::f80,   Expand);
 457   setOperationAction(ISD::SELECT_CC        , MVT::i8,    Expand);
 458   setOperationAction(ISD::SELECT_CC        , MVT::i16,   Expand);
 459   setOperationAction(ISD::SELECT_CC        , MVT::i32,   Expand);
 460   setOperationAction(ISD::SELECT_CC        , MVT::i64,   Expand);
 461   if (Subtarget->is64Bit())
 462     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i32, Legal);
 463   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16  , Legal);
 464   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8   , Legal);
 465   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1   , Expand);
 466   setOperationAction(ISD::FP_ROUND_INREG   , MVT::f32  , Expand);
 467   setOperationAction(ISD::FREM             , MVT::f32  , Expand);
 468   setOperationAction(ISD::FREM             , MVT::f64  , Expand);
 469   setOperationAction(ISD::FREM             , MVT::f80  , Expand);
 470   setOperationAction(ISD::FLT_ROUNDS_      , MVT::i32  , Custom);
 471
 472   // Promote the i8 variants and force them on up to i32 which has a shorter
 473   // encoding.
 474   setOperationAction(ISD::CTTZ             , MVT::i8   , Promote);
 475   AddPromotedToType (ISD::CTTZ             , MVT::i8   , MVT::i32);
 476   setOperationAction(ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , Promote);
 477   AddPromotedToType (ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , MVT::i32);
 478   if (Subtarget->hasBMI()) {
 479     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i16  , Expand);
 480     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i32  , Expand);
 481     if (Subtarget->is64Bit())
 482       setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i64, Expand);
 483   } else {
 484     setOperationAction(ISD::CTTZ           , MVT::i16  , Custom);
 485     setOperationAction(ISD::CTTZ           , MVT::i32  , Custom);
 486     if (Subtarget->is64Bit())
 487       setOperationAction(ISD::CTTZ         , MVT::i64  , Custom);
 488   }
 489
 490   if (Subtarget->hasLZCNT()) {
 491     // When promoting the i8 variants, force them to i32 for a shorter
 492     // encoding.
 493     setOperationAction(ISD::CTLZ           , MVT::i8   , Promote);
 494     AddPromotedToType (ISD::CTLZ           , MVT::i8   , MVT::i32);
 495     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Promote);
 496     AddPromotedToType (ISD::CTLZ_ZERO_UNDEF, MVT::i8   , MVT::i32);
 497     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Expand);
 498     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Expand);
 499     if (Subtarget->is64Bit())
 500       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Expand);
 501   } else {
 502     setOperationAction(ISD::CTLZ           , MVT::i8   , Custom);
 503     setOperationAction(ISD::CTLZ           , MVT::i16  , Custom);
 504     setOperationAction(ISD::CTLZ           , MVT::i32  , Custom);
 505     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Custom);
 506     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Custom);
 507     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Custom);
 508     if (Subtarget->is64Bit()) {
 509       setOperationAction(ISD::CTLZ         , MVT::i64  , Custom);
 510       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Custom);
 511     }
 512   }
 513
 514   // Special handling for half-precision floating point conversions.
 515   // If we don't have F16C support, then lower half float conversions
 516   // into library calls.
 517   if (TM.Options.UseSoftFloat || !Subtarget->hasF16C()) {
 518     setOperationAction(ISD::FP16_TO_FP, MVT::f32, Expand);
 519     setOperationAction(ISD::FP_TO_FP16, MVT::f32, Expand);
 520   }
 521
 522   // There's never any support for operations beyond MVT::f32.
 523   setOperationAction(ISD::FP16_TO_FP, MVT::f64, Expand);
 524   setOperationAction(ISD::FP16_TO_FP, MVT::f80, Expand);
 525   setOperationAction(ISD::FP_TO_FP16, MVT::f64, Expand);
 526   setOperationAction(ISD::FP_TO_FP16, MVT::f80, Expand);
 527
 528   setLoadExtAction(ISD::EXTLOAD, MVT::f32, MVT::f16, Expand);
 529   setLoadExtAction(ISD::EXTLOAD, MVT::f64, MVT::f16, Expand);
 530   setLoadExtAction(ISD::EXTLOAD, MVT::f80, MVT::f16, Expand);
 531   setTruncStoreAction(MVT::f32, MVT::f16, Expand);
 532   setTruncStoreAction(MVT::f64, MVT::f16, Expand);
 533   setTruncStoreAction(MVT::f80, MVT::f16, Expand);
 534
 535   if (Subtarget->hasPOPCNT()) {
 536     setOperationAction(ISD::CTPOP          , MVT::i8   , Promote);
 537   } else {
 538     setOperationAction(ISD::CTPOP          , MVT::i8   , Expand);
 539     setOperationAction(ISD::CTPOP          , MVT::i16  , Expand);
 540     setOperationAction(ISD::CTPOP          , MVT::i32  , Expand);
 541     if (Subtarget->is64Bit())
 542       setOperationAction(ISD::CTPOP        , MVT::i64  , Expand);
 543   }
 544
 545   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
 546
 547   if (!Subtarget->hasMOVBE())
 548     setOperationAction(ISD::BSWAP          , MVT::i16  , Expand);
 549
 550   // These should be promoted to a larger select which is supported.
 551   setOperationAction(ISD::SELECT          , MVT::i1   , Promote);
 552   // X86 wants to expand cmov itself.
 553   setOperationAction(ISD::SELECT          , MVT::i8   , Custom);
 554   setOperationAction(ISD::SELECT          , MVT::i16  , Custom);
 555   setOperationAction(ISD::SELECT          , MVT::i32  , Custom);
 556   setOperationAction(ISD::SELECT          , MVT::f32  , Custom);
 557   setOperationAction(ISD::SELECT          , MVT::f64  , Custom);
 558   setOperationAction(ISD::SELECT          , MVT::f80  , Custom);
 559   setOperationAction(ISD::SETCC           , MVT::i8   , Custom);
 560   setOperationAction(ISD::SETCC           , MVT::i16  , Custom);
 561   setOperationAction(ISD::SETCC           , MVT::i32  , Custom);
 562   setOperationAction(ISD::SETCC           , MVT::f32  , Custom);
 563   setOperationAction(ISD::SETCC           , MVT::f64  , Custom);
 564   setOperationAction(ISD::SETCC           , MVT::f80  , Custom);
 565   if (Subtarget->is64Bit()) {
 566     setOperationAction(ISD::SELECT        , MVT::i64  , Custom);
 567     setOperationAction(ISD::SETCC         , MVT::i64  , Custom);
 568   }
 569   setOperationAction(ISD::EH_RETURN       , MVT::Other, Custom);
 570   // NOTE: EH_SJLJ_SETJMP/_LONGJMP supported here is NOT intended to support
 571   // SjLj exception handling but a light-weight setjmp/longjmp replacement to
 572   // support continuation, user-level threading, and etc.. As a result, no
 573   // other SjLj exception interfaces are implemented and please don't build
 574   // your own exception handling based on them.
 575   // LLVM/Clang supports zero-cost DWARF exception handling.
 576   setOperationAction(ISD::EH_SJLJ_SETJMP, MVT::i32, Custom);
 577   setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
 578
 579   // Darwin ABI issue.
 580   setOperationAction(ISD::ConstantPool    , MVT::i32  , Custom);
 581   setOperationAction(ISD::JumpTable       , MVT::i32  , Custom);
 582   setOperationAction(ISD::GlobalAddress   , MVT::i32  , Custom);
 583   setOperationAction(ISD::GlobalTLSAddress, MVT::i32  , Custom);
 584   if (Subtarget->is64Bit())
 585     setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
 586   setOperationAction(ISD::ExternalSymbol  , MVT::i32  , Custom);
 587   setOperationAction(ISD::BlockAddress    , MVT::i32  , Custom);
 588   if (Subtarget->is64Bit()) {
 589     setOperationAction(ISD::ConstantPool  , MVT::i64  , Custom);
 590     setOperationAction(ISD::JumpTable     , MVT::i64  , Custom);
 591     setOperationAction(ISD::GlobalAddress , MVT::i64  , Custom);
 592     setOperationAction(ISD::ExternalSymbol, MVT::i64  , Custom);
 593     setOperationAction(ISD::BlockAddress  , MVT::i64  , Custom);
 594   }
 595   // 64-bit addm sub, shl, sra, srl (iff 32-bit x86)
 596   setOperationAction(ISD::SHL_PARTS       , MVT::i32  , Custom);
 597   setOperationAction(ISD::SRA_PARTS       , MVT::i32  , Custom);
 598   setOperationAction(ISD::SRL_PARTS       , MVT::i32  , Custom);
 599   if (Subtarget->is64Bit()) {
 600     setOperationAction(ISD::SHL_PARTS     , MVT::i64  , Custom);
 601     setOperationAction(ISD::SRA_PARTS     , MVT::i64  , Custom);
 602     setOperationAction(ISD::SRL_PARTS     , MVT::i64  , Custom);
 603   }
 604
 605   if (Subtarget->hasSSE1())
 606     setOperationAction(ISD::PREFETCH      , MVT::Other, Legal);
 607
 608   setOperationAction(ISD::ATOMIC_FENCE  , MVT::Other, Custom);
 609
 610   // Expand certain atomics
 611   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
 612     MVT VT = IntVTs[i];
 613     setOperationAction(ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, VT, Custom);
 614     setOperationAction(ISD::ATOMIC_LOAD_SUB, VT, Custom);
 615     setOperationAction(ISD::ATOMIC_STORE, VT, Custom);
 616   }
 617
 618   if (Subtarget->hasCmpxchg16b()) {
 619     setOperationAction(ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, MVT::i128, Custom);
 620   }
 621
 622   // FIXME - use subtarget debug flags
 623   if (!Subtarget->isTargetDarwin() && !Subtarget->isTargetELF() &&
 624       !Subtarget->isTargetCygMing() && !Subtarget->isTargetWin64()) {
 625     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
 626   }
 627
 628   if (Subtarget->is64Bit()) {
 629     setExceptionPointerRegister(X86::RAX);
 630     setExceptionSelectorRegister(X86::RDX);
 631   } else {
 632     setExceptionPointerRegister(X86::EAX);
 633     setExceptionSelectorRegister(X86::EDX);
 634   }
 635   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i32, Custom);
 636   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i64, Custom);
 637
 638   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
 639   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
 640
 641   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 642   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Legal);
 643
 644   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
 645   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
 646   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
 647   if (Subtarget->is64Bit() && !Subtarget->isTargetWin64()) {
 648     // TargetInfo::X86_64ABIBuiltinVaList
 649     setOperationAction(ISD::VAARG           , MVT::Other, Custom);
 650     setOperationAction(ISD::VACOPY          , MVT::Other, Custom);
 651   } else {
 652     // TargetInfo::CharPtrBuiltinVaList
 653     setOperationAction(ISD::VAARG           , MVT::Other, Expand);
 654     setOperationAction(ISD::VACOPY          , MVT::Other, Expand);
 655   }
 656
 657   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
 658   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
 659
 660   setOperationAction(ISD::DYNAMIC_STACKALLOC, getPointerTy(), Custom);
 661
 662   if (!TM.Options.UseSoftFloat && X86ScalarSSEf64) {
 663     // f32 and f64 use SSE.
 664     // Set up the FP register classes.
 665     addRegisterClass(MVT::f32, &X86::FR32RegClass);
 666     addRegisterClass(MVT::f64, &X86::FR64RegClass);
 667
 668     // Use ANDPD to simulate FABS.
 669     setOperationAction(ISD::FABS , MVT::f64, Custom);
 670     setOperationAction(ISD::FABS , MVT::f32, Custom);
 671
 672     // Use XORP to simulate FNEG.
 673     setOperationAction(ISD::FNEG , MVT::f64, Custom);
 674     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 675
 676     // Use ANDPD and ORPD to simulate FCOPYSIGN.
 677     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
 678     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 679
 680     // Lower this to FGETSIGNx86 plus an AND.
 681     setOperationAction(ISD::FGETSIGN, MVT::i64, Custom);
 682     setOperationAction(ISD::FGETSIGN, MVT::i32, Custom);
 683
 684     // We don't support sin/cos/fmod
 685     setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 686     setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 687     setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 688     setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 689     setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 690     setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 691
 692     // Expand FP immediates into loads from the stack, except for the special
 693     // cases we handle.
 694     addLegalFPImmediate(APFloat(+0.0)); // xorpd
 695     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 696   } else if (!TM.Options.UseSoftFloat && X86ScalarSSEf32) {
 697     // Use SSE for f32, x87 for f64.
 698     // Set up the FP register classes.
 699     addRegisterClass(MVT::f32, &X86::FR32RegClass);
 700     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
 701
 702     // Use ANDPS to simulate FABS.
 703     setOperationAction(ISD::FABS , MVT::f32, Custom);
 704
 705     // Use XORP to simulate FNEG.
 706     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 707
 708     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 709
 710     // Use ANDPS and ORPS to simulate FCOPYSIGN.
 711     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 712     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 713
 714     // We don't support sin/cos/fmod
 715     setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 716     setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 717     setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 718
 719     // Special cases we handle for FP constants.
 720     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 721     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 722     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 723     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 724     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 725
 726     if (!TM.Options.UnsafeFPMath) {
 727       setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 728       setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 729       setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 730     }
 731   } else if (!TM.Options.UseSoftFloat) {
 732     // f32 and f64 in x87.
 733     // Set up the FP register classes.
 734     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
 735     addRegisterClass(MVT::f32, &X86::RFP32RegClass);
 736
 737     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 738     setOperationAction(ISD::UNDEF,     MVT::f32, Expand);
 739     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 740     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
 741
 742     if (!TM.Options.UnsafeFPMath) {
 743       setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 744       setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 745       setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 746       setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 747       setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 748       setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 749     }
 750     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 751     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 752     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 753     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 754     addLegalFPImmediate(APFloat(+0.0f)); // FLD0
 755     addLegalFPImmediate(APFloat(+1.0f)); // FLD1
 756     addLegalFPImmediate(APFloat(-0.0f)); // FLD0/FCHS
 757     addLegalFPImmediate(APFloat(-1.0f)); // FLD1/FCHS
 758   }
 759
 760   // We don't support FMA.
 761   setOperationAction(ISD::FMA, MVT::f64, Expand);
 762   setOperationAction(ISD::FMA, MVT::f32, Expand);
 763
 764   // Long double always uses X87.
 765   if (!TM.Options.UseSoftFloat) {
 766     addRegisterClass(MVT::f80, &X86::RFP80RegClass);
 767     setOperationAction(ISD::UNDEF,     MVT::f80, Expand);
 768     setOperationAction(ISD::FCOPYSIGN, MVT::f80, Expand);
 769     {
 770       APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended);
 771       addLegalFPImmediate(TmpFlt);  // FLD0
 772       TmpFlt.changeSign();
 773       addLegalFPImmediate(TmpFlt);  // FLD0/FCHS
 774
 775       bool ignored;
 776       APFloat TmpFlt2(+1.0);
 777       TmpFlt2.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
 778                       &ignored);
 779       addLegalFPImmediate(TmpFlt2);  // FLD1
 780       TmpFlt2.changeSign();
 781       addLegalFPImmediate(TmpFlt2);  // FLD1/FCHS
 782     }
 783
 784     if (!TM.Options.UnsafeFPMath) {
 785       setOperationAction(ISD::FSIN   , MVT::f80, Expand);
 786       setOperationAction(ISD::FCOS   , MVT::f80, Expand);
 787       setOperationAction(ISD::FSINCOS, MVT::f80, Expand);
 788     }
 789
 790     setOperationAction(ISD::FFLOOR, MVT::f80, Expand);
 791     setOperationAction(ISD::FCEIL,  MVT::f80, Expand);
 792     setOperationAction(ISD::FTRUNC, MVT::f80, Expand);
 793     setOperationAction(ISD::FRINT,  MVT::f80, Expand);
 794     setOperationAction(ISD::FNEARBYINT, MVT::f80, Expand);
 795     setOperationAction(ISD::FMA, MVT::f80, Expand);
 796   }
 797
 798   // Always use a library call for pow.
 799   setOperationAction(ISD::FPOW             , MVT::f32  , Expand);
 800   setOperationAction(ISD::FPOW             , MVT::f64  , Expand);
 801   setOperationAction(ISD::FPOW             , MVT::f80  , Expand);
 802
 803   setOperationAction(ISD::FLOG, MVT::f80, Expand);
 804   setOperationAction(ISD::FLOG2, MVT::f80, Expand);
 805   setOperationAction(ISD::FLOG10, MVT::f80, Expand);
 806   setOperationAction(ISD::FEXP, MVT::f80, Expand);
 807   setOperationAction(ISD::FEXP2, MVT::f80, Expand);
 808   setOperationAction(ISD::FMINNUM, MVT::f80, Expand);
 809   setOperationAction(ISD::FMAXNUM, MVT::f80, Expand);
 810
 811   // First set operation action for all vector types to either promote
 812   // (for widening) or expand (for scalarization). Then we will selectively
 813   // turn on ones that can be effectively codegen'd.
 814   for (MVT VT : MVT::vector_valuetypes()) {
 815     setOperationAction(ISD::ADD , VT, Expand);
 816     setOperationAction(ISD::SUB , VT, Expand);
 817     setOperationAction(ISD::FADD, VT, Expand);
 818     setOperationAction(ISD::FNEG, VT, Expand);
 819     setOperationAction(ISD::FSUB, VT, Expand);
 820     setOperationAction(ISD::MUL , VT, Expand);
 821     setOperationAction(ISD::FMUL, VT, Expand);
 822     setOperationAction(ISD::SDIV, VT, Expand);
 823     setOperationAction(ISD::UDIV, VT, Expand);
 824     setOperationAction(ISD::FDIV, VT, Expand);
 825     setOperationAction(ISD::SREM, VT, Expand);
 826     setOperationAction(ISD::UREM, VT, Expand);
 827     setOperationAction(ISD::LOAD, VT, Expand);
 828     setOperationAction(ISD::VECTOR_SHUFFLE, VT, Expand);
 829     setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT,Expand);
 830     setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Expand);
 831     setOperationAction(ISD::EXTRACT_SUBVECTOR, VT,Expand);
 832     setOperationAction(ISD::INSERT_SUBVECTOR, VT,Expand);
 833     setOperationAction(ISD::FABS, VT, Expand);
 834     setOperationAction(ISD::FSIN, VT, Expand);
 835     setOperationAction(ISD::FSINCOS, VT, Expand);
 836     setOperationAction(ISD::FCOS, VT, Expand);
 837     setOperationAction(ISD::FSINCOS, VT, Expand);
 838     setOperationAction(ISD::FREM, VT, Expand);
 839     setOperationAction(ISD::FMA,  VT, Expand);
 840     setOperationAction(ISD::FPOWI, VT, Expand);
 841     setOperationAction(ISD::FSQRT, VT, Expand);
 842     setOperationAction(ISD::FCOPYSIGN, VT, Expand);
 843     setOperationAction(ISD::FFLOOR, VT, Expand);
 844     setOperationAction(ISD::FCEIL, VT, Expand);
 845     setOperationAction(ISD::FTRUNC, VT, Expand);
 846     setOperationAction(ISD::FRINT, VT, Expand);
 847     setOperationAction(ISD::FNEARBYINT, VT, Expand);
 848     setOperationAction(ISD::SMUL_LOHI, VT, Expand);
 849     setOperationAction(ISD::MULHS, VT, Expand);
 850     setOperationAction(ISD::UMUL_LOHI, VT, Expand);
 851     setOperationAction(ISD::MULHU, VT, Expand);
 852     setOperationAction(ISD::SDIVREM, VT, Expand);
 853     setOperationAction(ISD::UDIVREM, VT, Expand);
 854     setOperationAction(ISD::FPOW, VT, Expand);
 855     setOperationAction(ISD::CTPOP, VT, Expand);
 856     setOperationAction(ISD::CTTZ, VT, Expand);
 857     setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Expand);
 858     setOperationAction(ISD::CTLZ, VT, Expand);
 859     setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Expand);
 860     setOperationAction(ISD::SHL, VT, Expand);
 861     setOperationAction(ISD::SRA, VT, Expand);
 862     setOperationAction(ISD::SRL, VT, Expand);
 863     setOperationAction(ISD::ROTL, VT, Expand);
 864     setOperationAction(ISD::ROTR, VT, Expand);
 865     setOperationAction(ISD::BSWAP, VT, Expand);
 866     setOperationAction(ISD::SETCC, VT, Expand);
 867     setOperationAction(ISD::FLOG, VT, Expand);
 868     setOperationAction(ISD::FLOG2, VT, Expand);
 869     setOperationAction(ISD::FLOG10, VT, Expand);
 870     setOperationAction(ISD::FEXP, VT, Expand);
 871     setOperationAction(ISD::FEXP2, VT, Expand);
 872     setOperationAction(ISD::FP_TO_UINT, VT, Expand);
 873     setOperationAction(ISD::FP_TO_SINT, VT, Expand);
 874     setOperationAction(ISD::UINT_TO_FP, VT, Expand);
 875     setOperationAction(ISD::SINT_TO_FP, VT, Expand);
 876     setOperationAction(ISD::SIGN_EXTEND_INREG, VT,Expand);
 877     setOperationAction(ISD::TRUNCATE, VT, Expand);
 878     setOperationAction(ISD::SIGN_EXTEND, VT, Expand);
 879     setOperationAction(ISD::ZERO_EXTEND, VT, Expand);
 880     setOperationAction(ISD::ANY_EXTEND, VT, Expand);
 881     setOperationAction(ISD::VSELECT, VT, Expand);
 882     setOperationAction(ISD::SELECT_CC, VT, Expand);
 883     for (MVT InnerVT : MVT::vector_valuetypes()) {
 884       setTruncStoreAction(InnerVT, VT, Expand);
 885
 886       setLoadExtAction(ISD::SEXTLOAD, InnerVT, VT, Expand);
 887       setLoadExtAction(ISD::ZEXTLOAD, InnerVT, VT, Expand);
 888
 889       // N.b. ISD::EXTLOAD legality is basically ignored except for i1-like
 890       // types, we have to deal with them whether we ask for Expansion or not.
 891       // Setting Expand causes its own optimisation problems though, so leave
 892       // them legal.
 893       if (VT.getVectorElementType() == MVT::i1)
 894         setLoadExtAction(ISD::EXTLOAD, InnerVT, VT, Expand);
 895     }
 896   }
 897
 898   // FIXME: In order to prevent SSE instructions being expanded to MMX ones
 899   // with -msoft-float, disable use of MMX as well.
 900   if (!TM.Options.UseSoftFloat && Subtarget->hasMMX()) {
 901     addRegisterClass(MVT::x86mmx, &X86::VR64RegClass);
 902     // No operations on x86mmx supported, everything uses intrinsics.
 903   }
 904
 905   // MMX-sized vectors (other than x86mmx) are expected to be expanded
 906   // into smaller operations.
 907   setOperationAction(ISD::MULHS,              MVT::v8i8,  Expand);
 908   setOperationAction(ISD::MULHS,              MVT::v4i16, Expand);
 909   setOperationAction(ISD::MULHS,              MVT::v2i32, Expand);
 910   setOperationAction(ISD::MULHS,              MVT::v1i64, Expand);
 911   setOperationAction(ISD::AND,                MVT::v8i8,  Expand);
 912   setOperationAction(ISD::AND,                MVT::v4i16, Expand);
 913   setOperationAction(ISD::AND,                MVT::v2i32, Expand);
 914   setOperationAction(ISD::AND,                MVT::v1i64, Expand);
 915   setOperationAction(ISD::OR,                 MVT::v8i8,  Expand);
 916   setOperationAction(ISD::OR,                 MVT::v4i16, Expand);
 917   setOperationAction(ISD::OR,                 MVT::v2i32, Expand);
 918   setOperationAction(ISD::OR,                 MVT::v1i64, Expand);
 919   setOperationAction(ISD::XOR,                MVT::v8i8,  Expand);
 920   setOperationAction(ISD::XOR,                MVT::v4i16, Expand);
 921   setOperationAction(ISD::XOR,                MVT::v2i32, Expand);
 922   setOperationAction(ISD::XOR,                MVT::v1i64, Expand);
 923   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i8,  Expand);
 924   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v4i16, Expand);
 925   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v2i32, Expand);
 926   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v1i64, Expand);
 927   setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v1i64, Expand);
 928   setOperationAction(ISD::SELECT,             MVT::v8i8,  Expand);
 929   setOperationAction(ISD::SELECT,             MVT::v4i16, Expand);
 930   setOperationAction(ISD::SELECT,             MVT::v2i32, Expand);
 931   setOperationAction(ISD::SELECT,             MVT::v1i64, Expand);
 932   setOperationAction(ISD::BITCAST,            MVT::v8i8,  Expand);
 933   setOperationAction(ISD::BITCAST,            MVT::v4i16, Expand);
 934   setOperationAction(ISD::BITCAST,            MVT::v2i32, Expand);
 935   setOperationAction(ISD::BITCAST,            MVT::v1i64, Expand);
 936
 937   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE1()) {
 938     addRegisterClass(MVT::v4f32, &X86::VR128RegClass);
 939
 940     setOperationAction(ISD::FADD,               MVT::v4f32, Legal);
 941     setOperationAction(ISD::FSUB,               MVT::v4f32, Legal);
 942     setOperationAction(ISD::FMUL,               MVT::v4f32, Legal);
 943     setOperationAction(ISD::FDIV,               MVT::v4f32, Legal);
 944     setOperationAction(ISD::FSQRT,              MVT::v4f32, Legal);
 945     setOperationAction(ISD::FNEG,               MVT::v4f32, Custom);
 946     setOperationAction(ISD::FABS,               MVT::v4f32, Custom);
 947     setOperationAction(ISD::LOAD,               MVT::v4f32, Legal);
 948     setOperationAction(ISD::BUILD_VECTOR,       MVT::v4f32, Custom);
 949     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v4f32, Custom);
 950     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
 951     setOperationAction(ISD::SELECT,             MVT::v4f32, Custom);
 952     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i32, Custom);
 953   }
 954
 955   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE2()) {
 956     addRegisterClass(MVT::v2f64, &X86::VR128RegClass);
 957
 958     // FIXME: Unfortunately, -soft-float and -no-implicit-float mean XMM
 959     // registers cannot be used even for integer operations.
 960     addRegisterClass(MVT::v16i8, &X86::VR128RegClass);
 961     addRegisterClass(MVT::v8i16, &X86::VR128RegClass);
 962     addRegisterClass(MVT::v4i32, &X86::VR128RegClass);
 963     addRegisterClass(MVT::v2i64, &X86::VR128RegClass);
 964
 965     setOperationAction(ISD::ADD,                MVT::v16i8, Legal);
 966     setOperationAction(ISD::ADD,                MVT::v8i16, Legal);
 967     setOperationAction(ISD::ADD,                MVT::v4i32, Legal);
 968     setOperationAction(ISD::ADD,                MVT::v2i64, Legal);
 969     setOperationAction(ISD::MUL,                MVT::v4i32, Custom);
 970     setOperationAction(ISD::MUL,                MVT::v2i64, Custom);
 971     setOperationAction(ISD::UMUL_LOHI,          MVT::v4i32, Custom);
 972     setOperationAction(ISD::SMUL_LOHI,          MVT::v4i32, Custom);
 973     setOperationAction(ISD::MULHU,              MVT::v8i16, Legal);
 974     setOperationAction(ISD::MULHS,              MVT::v8i16, Legal);
 975     setOperationAction(ISD::SUB,                MVT::v16i8, Legal);
 976     setOperationAction(ISD::SUB,                MVT::v8i16, Legal);
 977     setOperationAction(ISD::SUB,                MVT::v4i32, Legal);
 978     setOperationAction(ISD::SUB,                MVT::v2i64, Legal);
 979     setOperationAction(ISD::MUL,                MVT::v8i16, Legal);
 980     setOperationAction(ISD::FADD,               MVT::v2f64, Legal);
 981     setOperationAction(ISD::FSUB,               MVT::v2f64, Legal);
 982     setOperationAction(ISD::FMUL,               MVT::v2f64, Legal);
 983     setOperationAction(ISD::FDIV,               MVT::v2f64, Legal);
 984     setOperationAction(ISD::FSQRT,              MVT::v2f64, Legal);
 985     setOperationAction(ISD::FNEG,               MVT::v2f64, Custom);
 986     setOperationAction(ISD::FABS,               MVT::v2f64, Custom);
 987
 988     setOperationAction(ISD::SETCC,              MVT::v2i64, Custom);
 989     setOperationAction(ISD::SETCC,              MVT::v16i8, Custom);
 990     setOperationAction(ISD::SETCC,              MVT::v8i16, Custom);
 991     setOperationAction(ISD::SETCC,              MVT::v4i32, Custom);
 992
 993     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v16i8, Custom);
 994     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i16, Custom);
 995     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
 996     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
 997     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
 998
 999     // Only provide customized ctpop vector bit twiddling for vector types we
1000     // know to perform better than using the popcnt instructions on each vector
1001     // element. If popcnt isn't supported, always provide the custom version.
1002     if (!Subtarget->hasPOPCNT()) {
1003       setOperationAction(ISD::CTPOP,            MVT::v4i32, Custom);
1004       setOperationAction(ISD::CTPOP,            MVT::v2i64, Custom);
1005     }
1006
1007     // Custom lower build_vector, vector_shuffle, and extract_vector_elt.
1008     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
1009       MVT VT = (MVT::SimpleValueType)i;
1010       // Do not attempt to custom lower non-power-of-2 vectors
1011       if (!isPowerOf2_32(VT.getVectorNumElements()))
1012         continue;
1013       // Do not attempt to custom lower non-128-bit vectors
1014       if (!VT.is128BitVector())
1015         continue;
1016       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
1017       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
1018       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
1019     }
1020
1021     // We support custom legalizing of sext and anyext loads for specific
1022     // memory vector types which we can load as a scalar (or sequence of
1023     // scalars) and extend in-register to a legal 128-bit vector type. For sext
1024     // loads these must work with a single scalar load.
1025     for (MVT VT : MVT::integer_vector_valuetypes()) {
1026       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v4i8, Custom);
1027       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v4i16, Custom);
1028       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v8i8, Custom);
1029       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i8, Custom);
1030       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i16, Custom);
1031       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i32, Custom);
1032       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4i8, Custom);
1033       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4i16, Custom);
1034       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v8i8, Custom);
1035     }
1036
1037     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2f64, Custom);
1038     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2i64, Custom);
1039     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2f64, Custom);
1040     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2i64, Custom);
1041     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2f64, Custom);
1042     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Custom);
1043
1044     if (Subtarget->is64Bit()) {
1045       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
1046       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
1047     }
1048
1049     // Promote v16i8, v8i16, v4i32 load, select, and, or, xor to v2i64.
1050     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
1051       MVT VT = (MVT::SimpleValueType)i;
1052
1053       // Do not attempt to promote non-128-bit vectors
1054       if (!VT.is128BitVector())
1055         continue;
1056
1057       setOperationAction(ISD::AND,    VT, Promote);
1058       AddPromotedToType (ISD::AND,    VT, MVT::v2i64);
1059       setOperationAction(ISD::OR,     VT, Promote);
1060       AddPromotedToType (ISD::OR,     VT, MVT::v2i64);
1061       setOperationAction(ISD::XOR,    VT, Promote);
1062       AddPromotedToType (ISD::XOR,    VT, MVT::v2i64);
1063       setOperationAction(ISD::LOAD,   VT, Promote);
1064       AddPromotedToType (ISD::LOAD,   VT, MVT::v2i64);
1065       setOperationAction(ISD::SELECT, VT, Promote);
1066       AddPromotedToType (ISD::SELECT, VT, MVT::v2i64);
1067     }
1068
1069     // Custom lower v2i64 and v2f64 selects.
1070     setOperationAction(ISD::LOAD,               MVT::v2f64, Legal);
1071     setOperationAction(ISD::LOAD,               MVT::v2i64, Legal);
1072     setOperationAction(ISD::SELECT,             MVT::v2f64, Custom);
1073     setOperationAction(ISD::SELECT,             MVT::v2i64, Custom);
1074
1075     setOperationAction(ISD::FP_TO_SINT,         MVT::v4i32, Legal);
1076     setOperationAction(ISD::SINT_TO_FP,         MVT::v4i32, Legal);
1077
1078     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i8,  Custom);
1079     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i16, Custom);
1080     // As there is no 64-bit GPR available, we need build a special custom
1081     // sequence to convert from v2i32 to v2f32.
1082     if (!Subtarget->is64Bit())
1083       setOperationAction(ISD::UINT_TO_FP,       MVT::v2f32, Custom);
1084
1085     setOperationAction(ISD::FP_EXTEND,          MVT::v2f32, Custom);
1086     setOperationAction(ISD::FP_ROUND,           MVT::v2f32, Custom);
1087
1088     for (MVT VT : MVT::fp_vector_valuetypes())
1089       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2f32, Legal);
1090
1091     setOperationAction(ISD::BITCAST,            MVT::v2i32, Custom);
1092     setOperationAction(ISD::BITCAST,            MVT::v4i16, Custom);
1093     setOperationAction(ISD::BITCAST,            MVT::v8i8,  Custom);
1094   }
1095
1096   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE41()) {
1097     setOperationAction(ISD::FFLOOR,             MVT::f32,   Legal);
1098     setOperationAction(ISD::FCEIL,              MVT::f32,   Legal);
1099     setOperationAction(ISD::FTRUNC,             MVT::f32,   Legal);
1100     setOperationAction(ISD::FRINT,              MVT::f32,   Legal);
1101     setOperationAction(ISD::FNEARBYINT,         MVT::f32,   Legal);
1102     setOperationAction(ISD::FFLOOR,             MVT::f64,   Legal);
1103     setOperationAction(ISD::FCEIL,              MVT::f64,   Legal);
1104     setOperationAction(ISD::FTRUNC,             MVT::f64,   Legal);
1105     setOperationAction(ISD::FRINT,              MVT::f64,   Legal);
1106     setOperationAction(ISD::FNEARBYINT,         MVT::f64,   Legal);
1107
1108     setOperationAction(ISD::FFLOOR,             MVT::v4f32, Legal);
1109     setOperationAction(ISD::FCEIL,              MVT::v4f32, Legal);
1110     setOperationAction(ISD::FTRUNC,             MVT::v4f32, Legal);
1111     setOperationAction(ISD::FRINT,              MVT::v4f32, Legal);
1112     setOperationAction(ISD::FNEARBYINT,         MVT::v4f32, Legal);
1113     setOperationAction(ISD::FFLOOR,             MVT::v2f64, Legal);
1114     setOperationAction(ISD::FCEIL,              MVT::v2f64, Legal);
1115     setOperationAction(ISD::FTRUNC,             MVT::v2f64, Legal);
1116     setOperationAction(ISD::FRINT,              MVT::v2f64, Legal);
1117     setOperationAction(ISD::FNEARBYINT,         MVT::v2f64, Legal);
1118
1119     // FIXME: Do we need to handle scalar-to-vector here?
1120     setOperationAction(ISD::MUL,                MVT::v4i32, Legal);
1121
1122     setOperationAction(ISD::VSELECT,            MVT::v2f64, Custom);
1123     setOperationAction(ISD::VSELECT,            MVT::v2i64, Custom);
1124     setOperationAction(ISD::VSELECT,            MVT::v4i32, Custom);
1125     setOperationAction(ISD::VSELECT,            MVT::v4f32, Custom);
1126     setOperationAction(ISD::VSELECT,            MVT::v8i16, Custom);
1127     // There is no BLENDI for byte vectors. We don't need to custom lower
1128     // some vselects for now.
1129     setOperationAction(ISD::VSELECT,            MVT::v16i8, Legal);
1130
1131     // SSE41 brings specific instructions for doing vector sign extend even in
1132     // cases where we don't have SRA.
1133     for (MVT VT : MVT::integer_vector_valuetypes()) {
1134       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i8, Custom);
1135       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i16, Custom);
1136       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i32, Custom);
1137     }
1138
1139     // SSE41 also has vector sign/zero extending loads, PMOV[SZ]X
1140     setLoadExtAction(ISD::SEXTLOAD, MVT::v8i16, MVT::v8i8,  Legal);
1141     setLoadExtAction(ISD::SEXTLOAD, MVT::v4i32, MVT::v4i8,  Legal);
1142     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i8,  Legal);
1143     setLoadExtAction(ISD::SEXTLOAD, MVT::v4i32, MVT::v4i16, Legal);
1144     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i16, Legal);
1145     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i32, Legal);
1146
1147     setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i16, MVT::v8i8,  Legal);
1148     setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i32, MVT::v4i8,  Legal);
1149     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i8,  Legal);
1150     setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i32, MVT::v4i16, Legal);
1151     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i16, Legal);
1152     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i32, Legal);
1153
1154     // i8 and i16 vectors are custom because the source register and source
1155     // source memory operand types are not the same width.  f32 vectors are
1156     // custom since the immediate controlling the insert encodes additional
1157     // information.
1158     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i8, Custom);
1159     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
1160     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
1161     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
1162
1163     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i8, Custom);
1164     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i16, Custom);
1165     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4i32, Custom);
1166     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
1167
1168     // FIXME: these should be Legal, but that's only for the case where
1169     // the index is constant.  For now custom expand to deal with that.
1170     if (Subtarget->is64Bit()) {
1171       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
1172       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
1173     }
1174   }
1175
1176   if (Subtarget->hasSSE2()) {
1177     setOperationAction(ISD::SRL,               MVT::v8i16, Custom);
1178     setOperationAction(ISD::SRL,               MVT::v16i8, Custom);
1179
1180     setOperationAction(ISD::SHL,               MVT::v8i16, Custom);
1181     setOperationAction(ISD::SHL,               MVT::v16i8, Custom);
1182
1183     setOperationAction(ISD::SRA,               MVT::v8i16, Custom);
1184     setOperationAction(ISD::SRA,               MVT::v16i8, Custom);
1185
1186     // In the customized shift lowering, the legal cases in AVX2 will be
1187     // recognized.
1188     setOperationAction(ISD::SRL,               MVT::v2i64, Custom);
1189     setOperationAction(ISD::SRL,               MVT::v4i32, Custom);
1190
1191     setOperationAction(ISD::SHL,               MVT::v2i64, Custom);
1192     setOperationAction(ISD::SHL,               MVT::v4i32, Custom);
1193
1194     setOperationAction(ISD::SRA,               MVT::v4i32, Custom);
1195   }
1196
1197   if (!TM.Options.UseSoftFloat && Subtarget->hasFp256()) {
1198     addRegisterClass(MVT::v32i8,  &X86::VR256RegClass);
1199     addRegisterClass(MVT::v16i16, &X86::VR256RegClass);
1200     addRegisterClass(MVT::v8i32,  &X86::VR256RegClass);
1201     addRegisterClass(MVT::v8f32,  &X86::VR256RegClass);
1202     addRegisterClass(MVT::v4i64,  &X86::VR256RegClass);
1203     addRegisterClass(MVT::v4f64,  &X86::VR256RegClass);
1204
1205     setOperationAction(ISD::LOAD,               MVT::v8f32, Legal);
1206     setOperationAction(ISD::LOAD,               MVT::v4f64, Legal);
1207     setOperationAction(ISD::LOAD,               MVT::v4i64, Legal);
1208
1209     setOperationAction(ISD::FADD,               MVT::v8f32, Legal);
1210     setOperationAction(ISD::FSUB,               MVT::v8f32, Legal);
1211     setOperationAction(ISD::FMUL,               MVT::v8f32, Legal);
1212     setOperationAction(ISD::FDIV,               MVT::v8f32, Legal);
1213     setOperationAction(ISD::FSQRT,              MVT::v8f32, Legal);
1214     setOperationAction(ISD::FFLOOR,             MVT::v8f32, Legal);
1215     setOperationAction(ISD::FCEIL,              MVT::v8f32, Legal);
1216     setOperationAction(ISD::FTRUNC,             MVT::v8f32, Legal);
1217     setOperationAction(ISD::FRINT,              MVT::v8f32, Legal);
1218     setOperationAction(ISD::FNEARBYINT,         MVT::v8f32, Legal);
1219     setOperationAction(ISD::FNEG,               MVT::v8f32, Custom);
1220     setOperationAction(ISD::FABS,               MVT::v8f32, Custom);
1221
1222     setOperationAction(ISD::FADD,               MVT::v4f64, Legal);
1223     setOperationAction(ISD::FSUB,               MVT::v4f64, Legal);
1224     setOperationAction(ISD::FMUL,               MVT::v4f64, Legal);
1225     setOperationAction(ISD::FDIV,               MVT::v4f64, Legal);
1226     setOperationAction(ISD::FSQRT,              MVT::v4f64, Legal);
1227     setOperationAction(ISD::FFLOOR,             MVT::v4f64, Legal);
1228     setOperationAction(ISD::FCEIL,              MVT::v4f64, Legal);
1229     setOperationAction(ISD::FTRUNC,             MVT::v4f64, Legal);
1230     setOperationAction(ISD::FRINT,              MVT::v4f64, Legal);
1231     setOperationAction(ISD::FNEARBYINT,         MVT::v4f64, Legal);
1232     setOperationAction(ISD::FNEG,               MVT::v4f64, Custom);
1233     setOperationAction(ISD::FABS,               MVT::v4f64, Custom);
1234
1235     // (fp_to_int:v8i16 (v8f32 ..)) requires the result type to be promoted
1236     // even though v8i16 is a legal type.
1237     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i16, Promote);
1238     setOperationAction(ISD::FP_TO_UINT,         MVT::v8i16, Promote);
1239     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i32, Legal);
1240
1241     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i16, Promote);
1242     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i32, Legal);
1243     setOperationAction(ISD::FP_ROUND,           MVT::v4f32, Legal);
1244
1245     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i8,  Custom);
1246     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i16, Custom);
1247
1248     for (MVT VT : MVT::fp_vector_valuetypes())
1249       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4f32, Legal);
1250
1251     setOperationAction(ISD::SRL,               MVT::v16i16, Custom);
1252     setOperationAction(ISD::SRL,               MVT::v32i8, Custom);
1253
1254     setOperationAction(ISD::SHL,               MVT::v16i16, Custom);
1255     setOperationAction(ISD::SHL,               MVT::v32i8, Custom);
1256
1257     setOperationAction(ISD::SRA,               MVT::v16i16, Custom);
1258     setOperationAction(ISD::SRA,               MVT::v32i8, Custom);
1259
1260     setOperationAction(ISD::SETCC,             MVT::v32i8, Custom);
1261     setOperationAction(ISD::SETCC,             MVT::v16i16, Custom);
1262     setOperationAction(ISD::SETCC,             MVT::v8i32, Custom);
1263     setOperationAction(ISD::SETCC,             MVT::v4i64, Custom);
1264
1265     setOperationAction(ISD::SELECT,            MVT::v4f64, Custom);
1266     setOperationAction(ISD::SELECT,            MVT::v4i64, Custom);
1267     setOperationAction(ISD::SELECT,            MVT::v8f32, Custom);
1268
1269     setOperationAction(ISD::VSELECT,           MVT::v4f64, Custom);
1270     setOperationAction(ISD::VSELECT,           MVT::v4i64, Custom);
1271     setOperationAction(ISD::VSELECT,           MVT::v8i32, Custom);
1272     setOperationAction(ISD::VSELECT,           MVT::v8f32, Custom);
1273
1274     setOperationAction(ISD::SIGN_EXTEND,       MVT::v4i64, Custom);
1275     setOperationAction(ISD::SIGN_EXTEND,       MVT::v8i32, Custom);
1276     setOperationAction(ISD::SIGN_EXTEND,       MVT::v16i16, Custom);
1277     setOperationAction(ISD::ZERO_EXTEND,       MVT::v4i64, Custom);
1278     setOperationAction(ISD::ZERO_EXTEND,       MVT::v8i32, Custom);
1279     setOperationAction(ISD::ZERO_EXTEND,       MVT::v16i16, Custom);
1280     setOperationAction(ISD::ANY_EXTEND,        MVT::v4i64, Custom);
1281     setOperationAction(ISD::ANY_EXTEND,        MVT::v8i32, Custom);
1282     setOperationAction(ISD::ANY_EXTEND,        MVT::v16i16, Custom);
1283     setOperationAction(ISD::TRUNCATE,          MVT::v16i8, Custom);
1284     setOperationAction(ISD::TRUNCATE,          MVT::v8i16, Custom);
1285     setOperationAction(ISD::TRUNCATE,          MVT::v4i32, Custom);
1286
1287     if (Subtarget->hasFMA() || Subtarget->hasFMA4()) {
1288       setOperationAction(ISD::FMA,             MVT::v8f32, Legal);
1289       setOperationAction(ISD::FMA,             MVT::v4f64, Legal);
1290       setOperationAction(ISD::FMA,             MVT::v4f32, Legal);
1291       setOperationAction(ISD::FMA,             MVT::v2f64, Legal);
1292       setOperationAction(ISD::FMA,             MVT::f32, Legal);
1293       setOperationAction(ISD::FMA,             MVT::f64, Legal);
1294     }
1295
1296     if (Subtarget->hasInt256()) {
1297       setOperationAction(ISD::ADD,             MVT::v4i64, Legal);
1298       setOperationAction(ISD::ADD,             MVT::v8i32, Legal);
1299       setOperationAction(ISD::ADD,             MVT::v16i16, Legal);
1300       setOperationAction(ISD::ADD,             MVT::v32i8, Legal);
1301
1302       setOperationAction(ISD::SUB,             MVT::v4i64, Legal);
1303       setOperationAction(ISD::SUB,             MVT::v8i32, Legal);
1304       setOperationAction(ISD::SUB,             MVT::v16i16, Legal);
1305       setOperationAction(ISD::SUB,             MVT::v32i8, Legal);
1306
1307       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1308       setOperationAction(ISD::MUL,             MVT::v8i32, Legal);
1309       setOperationAction(ISD::MUL,             MVT::v16i16, Legal);
1310       // Don't lower v32i8 because there is no 128-bit byte mul
1311
1312       setOperationAction(ISD::UMUL_LOHI,       MVT::v8i32, Custom);
1313       setOperationAction(ISD::SMUL_LOHI,       MVT::v8i32, Custom);
1314       setOperationAction(ISD::MULHU,           MVT::v16i16, Legal);
1315       setOperationAction(ISD::MULHS,           MVT::v16i16, Legal);
1316
1317       setOperationAction(ISD::VSELECT,         MVT::v16i16, Custom);
1318       setOperationAction(ISD::VSELECT,         MVT::v32i8, Legal);
1319
1320       // The custom lowering for UINT_TO_FP for v8i32 becomes interesting
1321       // when we have a 256bit-wide blend with immediate.
1322       setOperationAction(ISD::UINT_TO_FP, MVT::v8i32, Custom);
1323
1324       // Only provide customized ctpop vector bit twiddling for vector types we
1325       // know to perform better than using the popcnt instructions on each
1326       // vector element. If popcnt isn't supported, always provide the custom
1327       // version.
1328       if (!Subtarget->hasPOPCNT())
1329         setOperationAction(ISD::CTPOP,           MVT::v4i64, Custom);
1330
1331       // Custom CTPOP always performs better on natively supported v8i32
1332       setOperationAction(ISD::CTPOP,             MVT::v8i32, Custom);
1333
1334       // AVX2 also has wider vector sign/zero extending loads, VPMOV[SZ]X
1335       setLoadExtAction(ISD::SEXTLOAD, MVT::v16i16, MVT::v16i8, Legal);
1336       setLoadExtAction(ISD::SEXTLOAD, MVT::v8i32,  MVT::v8i8,  Legal);
1337       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i8,  Legal);
1338       setLoadExtAction(ISD::SEXTLOAD, MVT::v8i32,  MVT::v8i16, Legal);
1339       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i16, Legal);
1340       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i32, Legal);
1341
1342       setLoadExtAction(ISD::ZEXTLOAD, MVT::v16i16, MVT::v16i8, Legal);
1343       setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i32,  MVT::v8i8,  Legal);
1344       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i8,  Legal);
1345       setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i32,  MVT::v8i16, Legal);
1346       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i16, Legal);
1347       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i32, Legal);
1348     } else {
1349       setOperationAction(ISD::ADD,             MVT::v4i64, Custom);
1350       setOperationAction(ISD::ADD,             MVT::v8i32, Custom);
1351       setOperationAction(ISD::ADD,             MVT::v16i16, Custom);
1352       setOperationAction(ISD::ADD,             MVT::v32i8, Custom);
1353
1354       setOperationAction(ISD::SUB,             MVT::v4i64, Custom);
1355       setOperationAction(ISD::SUB,             MVT::v8i32, Custom);
1356       setOperationAction(ISD::SUB,             MVT::v16i16, Custom);
1357       setOperationAction(ISD::SUB,             MVT::v32i8, Custom);
1358
1359       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1360       setOperationAction(ISD::MUL,             MVT::v8i32, Custom);
1361       setOperationAction(ISD::MUL,             MVT::v16i16, Custom);
1362       // Don't lower v32i8 because there is no 128-bit byte mul
1363     }
1364
1365     // In the customized shift lowering, the legal cases in AVX2 will be
1366     // recognized.
1367     setOperationAction(ISD::SRL,               MVT::v4i64, Custom);
1368     setOperationAction(ISD::SRL,               MVT::v8i32, Custom);
1369
1370     setOperationAction(ISD::SHL,               MVT::v4i64, Custom);
1371     setOperationAction(ISD::SHL,               MVT::v8i32, Custom);
1372
1373     setOperationAction(ISD::SRA,               MVT::v8i32, Custom);
1374
1375     // Custom lower several nodes for 256-bit types.
1376     for (MVT VT : MVT::vector_valuetypes()) {
1377       if (VT.getScalarSizeInBits() >= 32) {
1378         setOperationAction(ISD::MLOAD,  VT, Legal);
1379         setOperationAction(ISD::MSTORE, VT, Legal);
1380       }
1381       // Extract subvector is special because the value type
1382       // (result) is 128-bit but the source is 256-bit wide.
1383       if (VT.is128BitVector()) {
1384         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Custom);
1385       }
1386       // Do not attempt to custom lower other non-256-bit vectors
1387       if (!VT.is256BitVector())
1388         continue;
1389
1390       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
1391       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
1392       setOperationAction(ISD::INSERT_VECTOR_ELT,  VT, Custom);
1393       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
1394       setOperationAction(ISD::SCALAR_TO_VECTOR,   VT, Custom);
1395       setOperationAction(ISD::INSERT_SUBVECTOR,   VT, Custom);
1396       setOperationAction(ISD::CONCAT_VECTORS,     VT, Custom);
1397     }
1398
1399     // Promote v32i8, v16i16, v8i32 select, and, or, xor to v4i64.
1400     for (int i = MVT::v32i8; i != MVT::v4i64; ++i) {
1401       MVT VT = (MVT::SimpleValueType)i;
1402
1403       // Do not attempt to promote non-256-bit vectors
1404       if (!VT.is256BitVector())
1405         continue;
1406
1407       setOperationAction(ISD::AND,    VT, Promote);
1408       AddPromotedToType (ISD::AND,    VT, MVT::v4i64);
1409       setOperationAction(ISD::OR,     VT, Promote);
1410       AddPromotedToType (ISD::OR,     VT, MVT::v4i64);
1411       setOperationAction(ISD::XOR,    VT, Promote);
1412       AddPromotedToType (ISD::XOR,    VT, MVT::v4i64);
1413       setOperationAction(ISD::LOAD,   VT, Promote);
1414       AddPromotedToType (ISD::LOAD,   VT, MVT::v4i64);
1415       setOperationAction(ISD::SELECT, VT, Promote);
1416       AddPromotedToType (ISD::SELECT, VT, MVT::v4i64);
1417     }
1418   }
1419
1420   if (!TM.Options.UseSoftFloat && Subtarget->hasAVX512()) {
1421     addRegisterClass(MVT::v16i32, &X86::VR512RegClass);
1422     addRegisterClass(MVT::v16f32, &X86::VR512RegClass);
1423     addRegisterClass(MVT::v8i64,  &X86::VR512RegClass);
1424     addRegisterClass(MVT::v8f64,  &X86::VR512RegClass);
1425
1426     addRegisterClass(MVT::i1,     &X86::VK1RegClass);
1427     addRegisterClass(MVT::v8i1,   &X86::VK8RegClass);
1428     addRegisterClass(MVT::v16i1,  &X86::VK16RegClass);
1429
1430     for (MVT VT : MVT::fp_vector_valuetypes())
1431       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v8f32, Legal);
1432
1433     setOperationAction(ISD::BR_CC,              MVT::i1,    Expand);
1434     setOperationAction(ISD::SETCC,              MVT::i1,    Custom);
1435     setOperationAction(ISD::XOR,                MVT::i1,    Legal);
1436     setOperationAction(ISD::OR,                 MVT::i1,    Legal);
1437     setOperationAction(ISD::AND,                MVT::i1,    Legal);
1438     setOperationAction(ISD::LOAD,               MVT::v16f32, Legal);
1439     setOperationAction(ISD::LOAD,               MVT::v8f64, Legal);
1440     setOperationAction(ISD::LOAD,               MVT::v8i64, Legal);
1441     setOperationAction(ISD::LOAD,               MVT::v16i32, Legal);
1442     setOperationAction(ISD::LOAD,               MVT::v16i1, Legal);
1443
1444     setOperationAction(ISD::FADD,               MVT::v16f32, Legal);
1445     setOperationAction(ISD::FSUB,               MVT::v16f32, Legal);
1446     setOperationAction(ISD::FMUL,               MVT::v16f32, Legal);
1447     setOperationAction(ISD::FDIV,               MVT::v16f32, Legal);
1448     setOperationAction(ISD::FSQRT,              MVT::v16f32, Legal);
1449     setOperationAction(ISD::FNEG,               MVT::v16f32, Custom);
1450
1451     setOperationAction(ISD::FADD,               MVT::v8f64, Legal);
1452     setOperationAction(ISD::FSUB,               MVT::v8f64, Legal);
1453     setOperationAction(ISD::FMUL,               MVT::v8f64, Legal);
1454     setOperationAction(ISD::FDIV,               MVT::v8f64, Legal);
1455     setOperationAction(ISD::FSQRT,              MVT::v8f64, Legal);
1456     setOperationAction(ISD::FNEG,               MVT::v8f64, Custom);
1457     setOperationAction(ISD::FMA,                MVT::v8f64, Legal);
1458     setOperationAction(ISD::FMA,                MVT::v16f32, Legal);
1459
1460     setOperationAction(ISD::FP_TO_SINT,         MVT::i32, Legal);
1461     setOperationAction(ISD::FP_TO_UINT,         MVT::i32, Legal);
1462     setOperationAction(ISD::SINT_TO_FP,         MVT::i32, Legal);
1463     setOperationAction(ISD::UINT_TO_FP,         MVT::i32, Legal);
1464     if (Subtarget->is64Bit()) {
1465       setOperationAction(ISD::FP_TO_UINT,       MVT::i64, Legal);
1466       setOperationAction(ISD::FP_TO_SINT,       MVT::i64, Legal);
1467       setOperationAction(ISD::SINT_TO_FP,       MVT::i64, Legal);
1468       setOperationAction(ISD::UINT_TO_FP,       MVT::i64, Legal);
1469     }
1470     setOperationAction(ISD::FP_TO_SINT,         MVT::v16i32, Legal);
1471     setOperationAction(ISD::FP_TO_UINT,         MVT::v16i32, Legal);
1472     setOperationAction(ISD::FP_TO_UINT,         MVT::v8i32, Legal);
1473     setOperationAction(ISD::FP_TO_UINT,         MVT::v4i32, Legal);
1474     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i32, Legal);
1475     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i1,   Custom);
1476     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i1,  Custom);
1477     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i8,  Promote);
1478     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i16, Promote);
1479     setOperationAction(ISD::UINT_TO_FP,         MVT::v16i32, Legal);
1480     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i32, Legal);
1481     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i32, Legal);
1482     setOperationAction(ISD::FP_ROUND,           MVT::v8f32, Legal);
1483     setOperationAction(ISD::FP_EXTEND,          MVT::v8f32, Legal);
1484
1485     setOperationAction(ISD::TRUNCATE,           MVT::i1, Custom);
1486     setOperationAction(ISD::TRUNCATE,           MVT::v16i8, Custom);
1487     setOperationAction(ISD::TRUNCATE,           MVT::v8i32, Custom);
1488     setOperationAction(ISD::TRUNCATE,           MVT::v8i1, Custom);
1489     setOperationAction(ISD::TRUNCATE,           MVT::v16i1, Custom);
1490     setOperationAction(ISD::TRUNCATE,           MVT::v16i16, Custom);
1491     setOperationAction(ISD::ZERO_EXTEND,        MVT::v16i32, Custom);
1492     setOperationAction(ISD::ZERO_EXTEND,        MVT::v8i64, Custom);
1493     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i32, Custom);
1494     setOperationAction(ISD::SIGN_EXTEND,        MVT::v8i64, Custom);
1495     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i8, Custom);
1496     setOperationAction(ISD::SIGN_EXTEND,        MVT::v8i16, Custom);
1497     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i16, Custom);
1498
1499     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8f64,  Custom);
1500     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i64,  Custom);
1501     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16f32,  Custom);
1502     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i32,  Custom);
1503     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i1,    Custom);
1504     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i1, Legal);
1505
1506     setOperationAction(ISD::SETCC,              MVT::v16i1, Custom);
1507     setOperationAction(ISD::SETCC,              MVT::v8i1, Custom);
1508
1509     setOperationAction(ISD::MUL,              MVT::v8i64, Custom);
1510
1511     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i1,  Custom);
1512     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i1, Custom);
1513     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i1, Custom);
1514     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i1, Custom);
1515     setOperationAction(ISD::BUILD_VECTOR,       MVT::v8i1, Custom);
1516     setOperationAction(ISD::BUILD_VECTOR,       MVT::v16i1, Custom);
1517     setOperationAction(ISD::SELECT,             MVT::v8f64, Custom);
1518     setOperationAction(ISD::SELECT,             MVT::v8i64, Custom);
1519     setOperationAction(ISD::SELECT,             MVT::v16f32, Custom);
1520
1521     setOperationAction(ISD::ADD,                MVT::v8i64, Legal);
1522     setOperationAction(ISD::ADD,                MVT::v16i32, Legal);
1523
1524     setOperationAction(ISD::SUB,                MVT::v8i64, Legal);
1525     setOperationAction(ISD::SUB,                MVT::v16i32, Legal);
1526
1527     setOperationAction(ISD::MUL,                MVT::v16i32, Legal);
1528
1529     setOperationAction(ISD::SRL,                MVT::v8i64, Custom);
1530     setOperationAction(ISD::SRL,                MVT::v16i32, Custom);
1531
1532     setOperationAction(ISD::SHL,                MVT::v8i64, Custom);
1533     setOperationAction(ISD::SHL,                MVT::v16i32, Custom);
1534
1535     setOperationAction(ISD::SRA,                MVT::v8i64, Custom);
1536     setOperationAction(ISD::SRA,                MVT::v16i32, Custom);
1537
1538     setOperationAction(ISD::AND,                MVT::v8i64, Legal);
1539     setOperationAction(ISD::OR,                 MVT::v8i64, Legal);
1540     setOperationAction(ISD::XOR,                MVT::v8i64, Legal);
1541     setOperationAction(ISD::AND,                MVT::v16i32, Legal);
1542     setOperationAction(ISD::OR,                 MVT::v16i32, Legal);
1543     setOperationAction(ISD::XOR,                MVT::v16i32, Legal);
1544
1545     if (Subtarget->hasCDI()) {
1546       setOperationAction(ISD::CTLZ,             MVT::v8i64, Legal);
1547       setOperationAction(ISD::CTLZ,             MVT::v16i32, Legal);
1548     }
1549
1550     // Custom lower several nodes.
1551     for (MVT VT : MVT::vector_valuetypes()) {
1552       unsigned EltSize = VT.getVectorElementType().getSizeInBits();
1553       // Extract subvector is special because the value type
1554       // (result) is 256/128-bit but the source is 512-bit wide.
1555       if (VT.is128BitVector() || VT.is256BitVector()) {
1556         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Custom);
1557       }
1558       if (VT.getVectorElementType() == MVT::i1)
1559         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Legal);
1560
1561       // Do not attempt to custom lower other non-512-bit vectors
1562       if (!VT.is512BitVector())
1563         continue;
1564
1565       if ( EltSize >= 32) {
1566         setOperationAction(ISD::VECTOR_SHUFFLE,      VT, Custom);
1567         setOperationAction(ISD::INSERT_VECTOR_ELT,   VT, Custom);
1568         setOperationAction(ISD::BUILD_VECTOR,        VT, Custom);
1569         setOperationAction(ISD::VSELECT,             VT, Legal);
1570         setOperationAction(ISD::EXTRACT_VECTOR_ELT,  VT, Custom);
1571         setOperationAction(ISD::SCALAR_TO_VECTOR,    VT, Custom);
1572         setOperationAction(ISD::INSERT_SUBVECTOR,    VT, Custom);
1573         setOperationAction(ISD::MLOAD,               VT, Legal);
1574         setOperationAction(ISD::MSTORE,              VT, Legal);
1575       }
1576     }
1577     for (int i = MVT::v32i8; i != MVT::v8i64; ++i) {
1578       MVT VT = (MVT::SimpleValueType)i;
1579
1580       // Do not attempt to promote non-512-bit vectors.
1581       if (!VT.is512BitVector())
1582         continue;
1583
1584       setOperationAction(ISD::SELECT, VT, Promote);
1585       AddPromotedToType (ISD::SELECT, VT, MVT::v8i64);
1586     }
1587   }// has  AVX-512
1588
1589   if (!TM.Options.UseSoftFloat && Subtarget->hasBWI()) {
1590     addRegisterClass(MVT::v32i16, &X86::VR512RegClass);
1591     addRegisterClass(MVT::v64i8,  &X86::VR512RegClass);
1592
1593     addRegisterClass(MVT::v32i1,  &X86::VK32RegClass);
1594     addRegisterClass(MVT::v64i1,  &X86::VK64RegClass);
1595
1596     setOperationAction(ISD::LOAD,               MVT::v32i16, Legal);
1597     setOperationAction(ISD::LOAD,               MVT::v64i8, Legal);
1598     setOperationAction(ISD::SETCC,              MVT::v32i1, Custom);
1599     setOperationAction(ISD::SETCC,              MVT::v64i1, Custom);
1600     setOperationAction(ISD::ADD,                MVT::v32i16, Legal);
1601     setOperationAction(ISD::ADD,                MVT::v64i8, Legal);
1602     setOperationAction(ISD::SUB,                MVT::v32i16, Legal);
1603     setOperationAction(ISD::SUB,                MVT::v64i8, Legal);
1604     setOperationAction(ISD::MUL,                MVT::v32i16, Legal);
1605
1606     for (int i = MVT::v32i8; i != MVT::v8i64; ++i) {
1607       const MVT VT = (MVT::SimpleValueType)i;
1608
1609       const unsigned EltSize = VT.getVectorElementType().getSizeInBits();
1610
1611       // Do not attempt to promote non-512-bit vectors.
1612       if (!VT.is512BitVector())
1613         continue;
1614
1615       if (EltSize < 32) {
1616         setOperationAction(ISD::BUILD_VECTOR,        VT, Custom);
1617         setOperationAction(ISD::VSELECT,             VT, Legal);
1618       }
1619     }
1620   }
1621
1622   if (!TM.Options.UseSoftFloat && Subtarget->hasVLX()) {
1623     addRegisterClass(MVT::v4i1,   &X86::VK4RegClass);
1624     addRegisterClass(MVT::v2i1,   &X86::VK2RegClass);
1625
1626     setOperationAction(ISD::SETCC,              MVT::v4i1, Custom);
1627     setOperationAction(ISD::SETCC,              MVT::v2i1, Custom);
1628     setOperationAction(ISD::INSERT_SUBVECTOR,   MVT::v8i1, Legal);
1629
1630     setOperationAction(ISD::AND,                MVT::v8i32, Legal);
1631     setOperationAction(ISD::OR,                 MVT::v8i32, Legal);
1632     setOperationAction(ISD::XOR,                MVT::v8i32, Legal);
1633     setOperationAction(ISD::AND,                MVT::v4i32, Legal);
1634     setOperationAction(ISD::OR,                 MVT::v4i32, Legal);
1635     setOperationAction(ISD::XOR,                MVT::v4i32, Legal);
1636   }
1637
1638   // SIGN_EXTEND_INREGs are evaluated by the extend type. Handle the expansion
1639   // of this type with custom code.
1640   for (MVT VT : MVT::vector_valuetypes())
1641     setOperationAction(ISD::SIGN_EXTEND_INREG, VT, Custom);
1642
1643   // We want to custom lower some of our intrinsics.
1644   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
1645   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
1646   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
1647   if (!Subtarget->is64Bit())
1648     setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::i64, Custom);
1649
1650   // Only custom-lower 64-bit SADDO and friends on 64-bit because we don't
1651   // handle type legalization for these operations here.
1652   //
1653   // FIXME: We really should do custom legalization for addition and
1654   // subtraction on x86-32 once PR3203 is fixed.  We really can't do much better
1655   // than generic legalization for 64-bit multiplication-with-overflow, though.
1656   for (unsigned i = 0, e = 3+Subtarget->is64Bit(); i != e; ++i) {
1657     // Add/Sub/Mul with overflow operations are custom lowered.
1658     MVT VT = IntVTs[i];
1659     setOperationAction(ISD::SADDO, VT, Custom);
1660     setOperationAction(ISD::UADDO, VT, Custom);
1661     setOperationAction(ISD::SSUBO, VT, Custom);
1662     setOperationAction(ISD::USUBO, VT, Custom);
1663     setOperationAction(ISD::SMULO, VT, Custom);
1664     setOperationAction(ISD::UMULO, VT, Custom);
1665   }
1666
1667
1668   if (!Subtarget->is64Bit()) {
1669     // These libcalls are not available in 32-bit.
1670     setLibcallName(RTLIB::SHL_I128, nullptr);
1671     setLibcallName(RTLIB::SRL_I128, nullptr);
1672     setLibcallName(RTLIB::SRA_I128, nullptr);
1673   }
1674
1675   // Combine sin / cos into one node or libcall if possible.
1676   if (Subtarget->hasSinCos()) {
1677     setLibcallName(RTLIB::SINCOS_F32, "sincosf");
1678     setLibcallName(RTLIB::SINCOS_F64, "sincos");
1679     if (Subtarget->isTargetDarwin()) {
1680       // For MacOSX, we don't want the normal expansion of a libcall to sincos.
1681       // We want to issue a libcall to __sincos_stret to avoid memory traffic.
1682       setOperationAction(ISD::FSINCOS, MVT::f64, Custom);
1683       setOperationAction(ISD::FSINCOS, MVT::f32, Custom);
1684     }
1685   }
1686
1687   if (Subtarget->isTargetWin64()) {
1688     setOperationAction(ISD::SDIV, MVT::i128, Custom);
1689     setOperationAction(ISD::UDIV, MVT::i128, Custom);
1690     setOperationAction(ISD::SREM, MVT::i128, Custom);
1691     setOperationAction(ISD::UREM, MVT::i128, Custom);
1692     setOperationAction(ISD::SDIVREM, MVT::i128, Custom);
1693     setOperationAction(ISD::UDIVREM, MVT::i128, Custom);
1694   }
1695
1696   // We have target-specific dag combine patterns for the following nodes:
1697   setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
1698   setTargetDAGCombine(ISD::EXTRACT_VECTOR_ELT);
1699   setTargetDAGCombine(ISD::VSELECT);
1700   setTargetDAGCombine(ISD::SELECT);
1701   setTargetDAGCombine(ISD::SHL);
1702   setTargetDAGCombine(ISD::SRA);
1703   setTargetDAGCombine(ISD::SRL);
1704   setTargetDAGCombine(ISD::OR);
1705   setTargetDAGCombine(ISD::AND);
1706   setTargetDAGCombine(ISD::ADD);
1707   setTargetDAGCombine(ISD::FADD);
1708   setTargetDAGCombine(ISD::FSUB);
1709   setTargetDAGCombine(ISD::FMA);
1710   setTargetDAGCombine(ISD::SUB);
1711   setTargetDAGCombine(ISD::LOAD);
1712   setTargetDAGCombine(ISD::MLOAD);
1713   setTargetDAGCombine(ISD::STORE);
1714   setTargetDAGCombine(ISD::MSTORE);
1715   setTargetDAGCombine(ISD::ZERO_EXTEND);
1716   setTargetDAGCombine(ISD::ANY_EXTEND);
1717   setTargetDAGCombine(ISD::SIGN_EXTEND);
1718   setTargetDAGCombine(ISD::SIGN_EXTEND_INREG);
1719   setTargetDAGCombine(ISD::TRUNCATE);
1720   setTargetDAGCombine(ISD::SINT_TO_FP);
1721   setTargetDAGCombine(ISD::SETCC);
1722   setTargetDAGCombine(ISD::INTRINSIC_WO_CHAIN);
1723   setTargetDAGCombine(ISD::BUILD_VECTOR);
1724   if (Subtarget->is64Bit())
1725     setTargetDAGCombine(ISD::MUL);
1726   setTargetDAGCombine(ISD::XOR);
1727
1728   computeRegisterProperties();
1729
1730   // On Darwin, -Os means optimize for size without hurting performance,
1731   // do not reduce the limit.
1732   MaxStoresPerMemset = 16; // For @llvm.memset -> sequence of stores
1733   MaxStoresPerMemsetOptSize = Subtarget->isTargetDarwin() ? 16 : 8;
1734   MaxStoresPerMemcpy = 8; // For @llvm.memcpy -> sequence of stores
1735   MaxStoresPerMemcpyOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1736   MaxStoresPerMemmove = 8; // For @llvm.memmove -> sequence of stores
1737   MaxStoresPerMemmoveOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1738   setPrefLoopAlignment(4); // 2^4 bytes.
1739
1740   // Predictable cmov don't hurt on atom because it's in-order.
1741   PredictableSelectIsExpensive = !Subtarget->isAtom();
1742   EnableExtLdPromotion = true;
1743   setPrefFunctionAlignment(4); // 2^4 bytes.
1744
1745   verifyIntrinsicTables();
1746 }
1747
1748 // This has so far only been implemented for 64-bit MachO.
1749 bool X86TargetLowering::useLoadStackGuardNode() const {
1750   return Subtarget->isTargetMachO() && Subtarget->is64Bit();
1751 }
1752
1753 TargetLoweringBase::LegalizeTypeAction
1754 X86TargetLowering::getPreferredVectorAction(EVT VT) const {
1755   if (ExperimentalVectorWideningLegalization &&
1756       VT.getVectorNumElements() != 1 &&
1757       VT.getVectorElementType().getSimpleVT() != MVT::i1)
1758     return TypeWidenVector;
1759
1760   return TargetLoweringBase::getPreferredVectorAction(VT);
1761 }
1762
1763 EVT X86TargetLowering::getSetCCResultType(LLVMContext &, EVT VT) const {
1764   if (!VT.isVector())
1765     return Subtarget->hasAVX512() ? MVT::i1: MVT::i8;
1766
1767   const unsigned NumElts = VT.getVectorNumElements();
1768   const EVT EltVT = VT.getVectorElementType();
1769   if (VT.is512BitVector()) {
1770     if (Subtarget->hasAVX512())
1771       if (EltVT == MVT::i32 || EltVT == MVT::i64 ||
1772           EltVT == MVT::f32 || EltVT == MVT::f64)
1773         switch(NumElts) {
1774         case  8: return MVT::v8i1;
1775         case 16: return MVT::v16i1;
1776       }
1777     if (Subtarget->hasBWI())
1778       if (EltVT == MVT::i8 || EltVT == MVT::i16)
1779         switch(NumElts) {
1780         case 32: return MVT::v32i1;
1781         case 64: return MVT::v64i1;
1782       }
1783   }
1784
1785   if (VT.is256BitVector() || VT.is128BitVector()) {
1786     if (Subtarget->hasVLX())
1787       if (EltVT == MVT::i32 || EltVT == MVT::i64 ||
1788           EltVT == MVT::f32 || EltVT == MVT::f64)
1789         switch(NumElts) {
1790         case 2: return MVT::v2i1;
1791         case 4: return MVT::v4i1;
1792         case 8: return MVT::v8i1;
1793       }
1794     if (Subtarget->hasBWI() && Subtarget->hasVLX())
1795       if (EltVT == MVT::i8 || EltVT == MVT::i16)
1796         switch(NumElts) {
1797         case  8: return MVT::v8i1;
1798         case 16: return MVT::v16i1;
1799         case 32: return MVT::v32i1;
1800       }
1801   }
1802
1803   return VT.changeVectorElementTypeToInteger();
1804 }
1805
1806 /// Helper for getByValTypeAlignment to determine
1807 /// the desired ByVal argument alignment.
1808 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign) {
1809   if (MaxAlign == 16)
1810     return;
1811   if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
1812     if (VTy->getBitWidth() == 128)
1813       MaxAlign = 16;
1814   } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
1815     unsigned EltAlign = 0;
1816     getMaxByValAlign(ATy->getElementType(), EltAlign);
1817     if (EltAlign > MaxAlign)
1818       MaxAlign = EltAlign;
1819   } else if (StructType *STy = dyn_cast<StructType>(Ty)) {
1820     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1821       unsigned EltAlign = 0;
1822       getMaxByValAlign(STy->getElementType(i), EltAlign);
1823       if (EltAlign > MaxAlign)
1824         MaxAlign = EltAlign;
1825       if (MaxAlign == 16)
1826         break;
1827     }
1828   }
1829 }
1830
1831 /// Return the desired alignment for ByVal aggregate
1832 /// function arguments in the caller parameter area. For X86, aggregates
1833 /// that contain SSE vectors are placed at 16-byte boundaries while the rest
1834 /// are at 4-byte boundaries.
1835 unsigned X86TargetLowering::getByValTypeAlignment(Type *Ty) const {
1836   if (Subtarget->is64Bit()) {
1837     // Max of 8 and alignment of type.
1838     unsigned TyAlign = TD->getABITypeAlignment(Ty);
1839     if (TyAlign > 8)
1840       return TyAlign;
1841     return 8;
1842   }
1843
1844   unsigned Align = 4;
1845   if (Subtarget->hasSSE1())
1846     getMaxByValAlign(Ty, Align);
1847   return Align;
1848 }
1849
1850 /// Returns the target specific optimal type for load
1851 /// and store operations as a result of memset, memcpy, and memmove
1852 /// lowering. If DstAlign is zero that means it's safe to destination
1853 /// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
1854 /// means there isn't a need to check it against alignment requirement,
1855 /// probably because the source does not need to be loaded. If 'IsMemset' is
1856 /// true, that means it's expanding a memset. If 'ZeroMemset' is true, that
1857 /// means it's a memset of zero. 'MemcpyStrSrc' indicates whether the memcpy
1858 /// source is constant so it does not need to be loaded.
1859 /// It returns EVT::Other if the type should be determined using generic
1860 /// target-independent logic.
1861 EVT
1862 X86TargetLowering::getOptimalMemOpType(uint64_t Size,
1863                                        unsigned DstAlign, unsigned SrcAlign,
1864                                        bool IsMemset, bool ZeroMemset,
1865                                        bool MemcpyStrSrc,
1866                                        MachineFunction &MF) const {
1867   const Function *F = MF.getFunction();
1868   if ((!IsMemset || ZeroMemset) &&
1869       !F->getAttributes().hasAttribute(AttributeSet::FunctionIndex,
1870                                        Attribute::NoImplicitFloat)) {
1871     if (Size >= 16 &&
1872         (Subtarget->isUnalignedMemAccessFast() ||
1873          ((DstAlign == 0 || DstAlign >= 16) &&
1874           (SrcAlign == 0 || SrcAlign >= 16)))) {
1875       if (Size >= 32) {
1876         if (Subtarget->hasInt256())
1877           return MVT::v8i32;
1878         if (Subtarget->hasFp256())
1879           return MVT::v8f32;
1880       }
1881       if (Subtarget->hasSSE2())
1882         return MVT::v4i32;
1883       if (Subtarget->hasSSE1())
1884         return MVT::v4f32;
1885     } else if (!MemcpyStrSrc && Size >= 8 &&
1886                !Subtarget->is64Bit() &&
1887                Subtarget->hasSSE2()) {
1888       // Do not use f64 to lower memcpy if source is string constant. It's
1889       // better to use i32 to avoid the loads.
1890       return MVT::f64;
1891     }
1892   }
1893   if (Subtarget->is64Bit() && Size >= 8)
1894     return MVT::i64;
1895   return MVT::i32;
1896 }
1897
1898 bool X86TargetLowering::isSafeMemOpType(MVT VT) const {
1899   if (VT == MVT::f32)
1900     return X86ScalarSSEf32;
1901   else if (VT == MVT::f64)
1902     return X86ScalarSSEf64;
1903   return true;
1904 }
1905
1906 bool
1907 X86TargetLowering::allowsMisalignedMemoryAccesses(EVT VT,
1908                                                   unsigned,
1909                                                   unsigned,
1910                                                   bool *Fast) const {
1911   if (Fast)
1912     *Fast = Subtarget->isUnalignedMemAccessFast();
1913   return true;
1914 }
1915
1916 /// Return the entry encoding for a jump table in the
1917 /// current function.  The returned value is a member of the
1918 /// MachineJumpTableInfo::JTEntryKind enum.
1919 unsigned X86TargetLowering::getJumpTableEncoding() const {
1920   // In GOT pic mode, each entry in the jump table is emitted as a @GOTOFF
1921   // symbol.
1922   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1923       Subtarget->isPICStyleGOT())
1924     return MachineJumpTableInfo::EK_Custom32;
1925
1926   // Otherwise, use the normal jump table encoding heuristics.
1927   return TargetLowering::getJumpTableEncoding();
1928 }
1929
1930 const MCExpr *
1931 X86TargetLowering::LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
1932                                              const MachineBasicBlock *MBB,
1933                                              unsigned uid,MCContext &Ctx) const{
1934   assert(MBB->getParent()->getTarget().getRelocationModel() == Reloc::PIC_ &&
1935          Subtarget->isPICStyleGOT());
1936   // In 32-bit ELF systems, our jump table entries are formed with @GOTOFF
1937   // entries.
1938   return MCSymbolRefExpr::Create(MBB->getSymbol(),
1939                                  MCSymbolRefExpr::VK_GOTOFF, Ctx);
1940 }
1941
1942 /// Returns relocation base for the given PIC jumptable.
1943 SDValue X86TargetLowering::getPICJumpTableRelocBase(SDValue Table,
1944                                                     SelectionDAG &DAG) const {
1945   if (!Subtarget->is64Bit())
1946     // This doesn't have SDLoc associated with it, but is not really the
1947     // same as a Register.
1948     return DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy());
1949   return Table;
1950 }
1951
1952 /// This returns the relocation base for the given PIC jumptable,
1953 /// the same as getPICJumpTableRelocBase, but as an MCExpr.
1954 const MCExpr *X86TargetLowering::
1955 getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI,
1956                              MCContext &Ctx) const {
1957   // X86-64 uses RIP relative addressing based on the jump table label.
1958   if (Subtarget->isPICStyleRIPRel())
1959     return TargetLowering::getPICJumpTableRelocBaseExpr(MF, JTI, Ctx);
1960
1961   // Otherwise, the reference is relative to the PIC base.
1962   return MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx);
1963 }
1964
1965 // FIXME: Why this routine is here? Move to RegInfo!
1966 std::pair<const TargetRegisterClass*, uint8_t>
1967 X86TargetLowering::findRepresentativeClass(MVT VT) const{
1968   const TargetRegisterClass *RRC = nullptr;
1969   uint8_t Cost = 1;
1970   switch (VT.SimpleTy) {
1971   default:
1972     return TargetLowering::findRepresentativeClass(VT);
1973   case MVT::i8: case MVT::i16: case MVT::i32: case MVT::i64:
1974     RRC = Subtarget->is64Bit() ? &X86::GR64RegClass : &X86::GR32RegClass;
1975     break;
1976   case MVT::x86mmx:
1977     RRC = &X86::VR64RegClass;
1978     break;
1979   case MVT::f32: case MVT::f64:
1980   case MVT::v16i8: case MVT::v8i16: case MVT::v4i32: case MVT::v2i64:
1981   case MVT::v4f32: case MVT::v2f64:
1982   case MVT::v32i8: case MVT::v8i32: case MVT::v4i64: case MVT::v8f32:
1983   case MVT::v4f64:
1984     RRC = &X86::VR128RegClass;
1985     break;
1986   }
1987   return std::make_pair(RRC, Cost);
1988 }
1989
1990 bool X86TargetLowering::getStackCookieLocation(unsigned &AddressSpace,
1991                                                unsigned &Offset) const {
1992   if (!Subtarget->isTargetLinux())
1993     return false;
1994
1995   if (Subtarget->is64Bit()) {
1996     // %fs:0x28, unless we're using a Kernel code model, in which case it's %gs:
1997     Offset = 0x28;
1998     if (getTargetMachine().getCodeModel() == CodeModel::Kernel)
1999       AddressSpace = 256;
2000     else
2001       AddressSpace = 257;
2002   } else {
2003     // %gs:0x14 on i386
2004     Offset = 0x14;
2005     AddressSpace = 256;
2006   }
2007   return true;
2008 }
2009
2010 bool X86TargetLowering::isNoopAddrSpaceCast(unsigned SrcAS,
2011                                             unsigned DestAS) const {
2012   assert(SrcAS != DestAS && "Expected different address spaces!");
2013
2014   return SrcAS < 256 && DestAS < 256;
2015 }
2016
2017 //===----------------------------------------------------------------------===//
2018 //               Return Value Calling Convention Implementation
2019 //===----------------------------------------------------------------------===//
2020
2021 #include "X86GenCallingConv.inc"
2022
2023 bool
2024 X86TargetLowering::CanLowerReturn(CallingConv::ID CallConv,
2025                                   MachineFunction &MF, bool isVarArg,
2026                         const SmallVectorImpl<ISD::OutputArg> &Outs,
2027                         LLVMContext &Context) const {
2028   SmallVector<CCValAssign, 16> RVLocs;
2029   CCState CCInfo(CallConv, isVarArg, MF, RVLocs, Context);
2030   return CCInfo.CheckReturn(Outs, RetCC_X86);
2031 }
2032
2033 const MCPhysReg *X86TargetLowering::getScratchRegisters(CallingConv::ID) const {
2034   static const MCPhysReg ScratchRegs[] = { X86::R11, 0 };
2035   return ScratchRegs;
2036 }
2037
2038 SDValue
2039 X86TargetLowering::LowerReturn(SDValue Chain,
2040                                CallingConv::ID CallConv, bool isVarArg,
2041                                const SmallVectorImpl<ISD::OutputArg> &Outs,
2042                                const SmallVectorImpl<SDValue> &OutVals,
2043                                SDLoc dl, SelectionDAG &DAG) const {
2044   MachineFunction &MF = DAG.getMachineFunction();
2045   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2046
2047   SmallVector<CCValAssign, 16> RVLocs;
2048   CCState CCInfo(CallConv, isVarArg, MF, RVLocs, *DAG.getContext());
2049   CCInfo.AnalyzeReturn(Outs, RetCC_X86);
2050
2051   SDValue Flag;
2052   SmallVector<SDValue, 6> RetOps;
2053   RetOps.push_back(Chain); // Operand #0 = Chain (updated below)
2054   // Operand #1 = Bytes To Pop
2055   RetOps.push_back(DAG.getTargetConstant(FuncInfo->getBytesToPopOnReturn(),
2056                    MVT::i16));
2057
2058   // Copy the result values into the output registers.
2059   for (unsigned i = 0; i != RVLocs.size(); ++i) {
2060     CCValAssign &VA = RVLocs[i];
2061     assert(VA.isRegLoc() && "Can only return in registers!");
2062     SDValue ValToCopy = OutVals[i];
2063     EVT ValVT = ValToCopy.getValueType();
2064
2065     // Promote values to the appropriate types.
2066     if (VA.getLocInfo() == CCValAssign::SExt)
2067       ValToCopy = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), ValToCopy);
2068     else if (VA.getLocInfo() == CCValAssign::ZExt)
2069       ValToCopy = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), ValToCopy);
2070     else if (VA.getLocInfo() == CCValAssign::AExt)
2071       ValToCopy = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), ValToCopy);
2072     else if (VA.getLocInfo() == CCValAssign::BCvt)
2073       ValToCopy = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), ValToCopy);
2074
2075     assert(VA.getLocInfo() != CCValAssign::FPExt &&
2076            "Unexpected FP-extend for return value.");
2077
2078     // If this is x86-64, and we disabled SSE, we can't return FP values,
2079     // or SSE or MMX vectors.
2080     if ((ValVT == MVT::f32 || ValVT == MVT::f64 ||
2081          VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) &&
2082           (Subtarget->is64Bit() && !Subtarget->hasSSE1())) {
2083       report_fatal_error("SSE register return with SSE disabled");
2084     }
2085     // Likewise we can't return F64 values with SSE1 only.  gcc does so, but
2086     // llvm-gcc has never done it right and no one has noticed, so this
2087     // should be OK for now.
2088     if (ValVT == MVT::f64 &&
2089         (Subtarget->is64Bit() && !Subtarget->hasSSE2()))
2090       report_fatal_error("SSE2 register return with SSE2 disabled");
2091
2092     // Returns in ST0/ST1 are handled specially: these are pushed as operands to
2093     // the RET instruction and handled by the FP Stackifier.
2094     if (VA.getLocReg() == X86::FP0 ||
2095         VA.getLocReg() == X86::FP1) {
2096       // If this is a copy from an xmm register to ST(0), use an FPExtend to
2097       // change the value to the FP stack register class.
2098       if (isScalarFPTypeInSSEReg(VA.getValVT()))
2099         ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
2100       RetOps.push_back(ValToCopy);
2101       // Don't emit a copytoreg.
2102       continue;
2103     }
2104
2105     // 64-bit vector (MMX) values are returned in XMM0 / XMM1 except for v1i64
2106     // which is returned in RAX / RDX.
2107     if (Subtarget->is64Bit()) {
2108       if (ValVT == MVT::x86mmx) {
2109         if (VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) {
2110           ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ValToCopy);
2111           ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
2112                                   ValToCopy);
2113           // If we don't have SSE2 available, convert to v4f32 so the generated
2114           // register is legal.
2115           if (!Subtarget->hasSSE2())
2116             ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32,ValToCopy);
2117         }
2118       }
2119     }
2120
2121     Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), ValToCopy, Flag);
2122     Flag = Chain.getValue(1);
2123     RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2124   }
2125
2126   // The x86-64 ABIs require that for returning structs by value we copy
2127   // the sret argument into %rax/%eax (depending on ABI) for the return.
2128   // Win32 requires us to put the sret argument to %eax as well.
2129   // We saved the argument into a virtual register in the entry block,
2130   // so now we copy the value out and into %rax/%eax.
2131   if (DAG.getMachineFunction().getFunction()->hasStructRetAttr() &&
2132       (Subtarget->is64Bit() || Subtarget->isTargetKnownWindowsMSVC())) {
2133     MachineFunction &MF = DAG.getMachineFunction();
2134     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2135     unsigned Reg = FuncInfo->getSRetReturnReg();
2136     assert(Reg &&
2137            "SRetReturnReg should have been set in LowerFormalArguments().");
2138     SDValue Val = DAG.getCopyFromReg(Chain, dl, Reg, getPointerTy());
2139
2140     unsigned RetValReg
2141         = (Subtarget->is64Bit() && !Subtarget->isTarget64BitILP32()) ?
2142           X86::RAX : X86::EAX;
2143     Chain = DAG.getCopyToReg(Chain, dl, RetValReg, Val, Flag);
2144     Flag = Chain.getValue(1);
2145
2146     // RAX/EAX now acts like a return value.
2147     RetOps.push_back(DAG.getRegister(RetValReg, getPointerTy()));
2148   }
2149
2150   RetOps[0] = Chain;  // Update chain.
2151
2152   // Add the flag if we have it.
2153   if (Flag.getNode())
2154     RetOps.push_back(Flag);
2155
2156   return DAG.getNode(X86ISD::RET_FLAG, dl, MVT::Other, RetOps);
2157 }
2158
2159 bool X86TargetLowering::isUsedByReturnOnly(SDNode *N, SDValue &Chain) const {
2160   if (N->getNumValues() != 1)
2161     return false;
2162   if (!N->hasNUsesOfValue(1, 0))
2163     return false;
2164
2165   SDValue TCChain = Chain;
2166   SDNode *Copy = *N->use_begin();
2167   if (Copy->getOpcode() == ISD::CopyToReg) {
2168     // If the copy has a glue operand, we conservatively assume it isn't safe to
2169     // perform a tail call.
2170     if (Copy->getOperand(Copy->getNumOperands()-1).getValueType() == MVT::Glue)
2171       return false;
2172     TCChain = Copy->getOperand(0);
2173   } else if (Copy->getOpcode() != ISD::FP_EXTEND)
2174     return false;
2175
2176   bool HasRet = false;
2177   for (SDNode::use_iterator UI = Copy->use_begin(), UE = Copy->use_end();
2178        UI != UE; ++UI) {
2179     if (UI->getOpcode() != X86ISD::RET_FLAG)
2180       return false;
2181     // If we are returning more than one value, we can definitely
2182     // not make a tail call see PR19530
2183     if (UI->getNumOperands() > 4)
2184       return false;
2185     if (UI->getNumOperands() == 4 &&
2186         UI->getOperand(UI->getNumOperands()-1).getValueType() != MVT::Glue)
2187       return false;
2188     HasRet = true;
2189   }
2190
2191   if (!HasRet)
2192     return false;
2193
2194   Chain = TCChain;
2195   return true;
2196 }
2197
2198 EVT
2199 X86TargetLowering::getTypeForExtArgOrReturn(LLVMContext &Context, EVT VT,
2200                                             ISD::NodeType ExtendKind) const {
2201   MVT ReturnMVT;
2202   // TODO: Is this also valid on 32-bit?
2203   if (Subtarget->is64Bit() && VT == MVT::i1 && ExtendKind == ISD::ZERO_EXTEND)
2204     ReturnMVT = MVT::i8;
2205   else
2206     ReturnMVT = MVT::i32;
2207
2208   EVT MinVT = getRegisterType(Context, ReturnMVT);
2209   return VT.bitsLT(MinVT) ? MinVT : VT;
2210 }
2211
2212 /// Lower the result values of a call into the
2213 /// appropriate copies out of appropriate physical registers.
2214 ///
2215 SDValue
2216 X86TargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
2217                                    CallingConv::ID CallConv, bool isVarArg,
2218                                    const SmallVectorImpl<ISD::InputArg> &Ins,
2219                                    SDLoc dl, SelectionDAG &DAG,
2220                                    SmallVectorImpl<SDValue> &InVals) const {
2221
2222   // Assign locations to each value returned by this call.
2223   SmallVector<CCValAssign, 16> RVLocs;
2224   bool Is64Bit = Subtarget->is64Bit();
2225   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
2226                  *DAG.getContext());
2227   CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
2228
2229   // Copy all of the result registers out of their specified physreg.
2230   for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
2231     CCValAssign &VA = RVLocs[i];
2232     EVT CopyVT = VA.getValVT();
2233
2234     // If this is x86-64, and we disabled SSE, we can't return FP values
2235     if ((CopyVT == MVT::f32 || CopyVT == MVT::f64) &&
2236         ((Is64Bit || Ins[i].Flags.isInReg()) && !Subtarget->hasSSE1())) {
2237       report_fatal_error("SSE register return with SSE disabled");
2238     }
2239
2240     // If we prefer to use the value in xmm registers, copy it out as f80 and
2241     // use a truncate to move it from fp stack reg to xmm reg.
2242     if ((VA.getLocReg() == X86::FP0 || VA.getLocReg() == X86::FP1) &&
2243         isScalarFPTypeInSSEReg(VA.getValVT()))
2244       CopyVT = MVT::f80;
2245
2246     Chain = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(),
2247                                CopyVT, InFlag).getValue(1);
2248     SDValue Val = Chain.getValue(0);
2249
2250     if (CopyVT != VA.getValVT())
2251       Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
2252                         // This truncation won't change the value.
2253                         DAG.getIntPtrConstant(1));
2254
2255     InFlag = Chain.getValue(2);
2256     InVals.push_back(Val);
2257   }
2258
2259   return Chain;
2260 }
2261
2262 //===----------------------------------------------------------------------===//
2263 //                C & StdCall & Fast Calling Convention implementation
2264 //===----------------------------------------------------------------------===//
2265 //  StdCall calling convention seems to be standard for many Windows' API
2266 //  routines and around. It differs from C calling convention just a little:
2267 //  callee should clean up the stack, not caller. Symbols should be also
2268 //  decorated in some fancy way :) It doesn't support any vector arguments.
2269 //  For info on fast calling convention see Fast Calling Convention (tail call)
2270 //  implementation LowerX86_32FastCCCallTo.
2271
2272 /// CallIsStructReturn - Determines whether a call uses struct return
2273 /// semantics.
2274 enum StructReturnType {
2275   NotStructReturn,
2276   RegStructReturn,
2277   StackStructReturn
2278 };
2279 static StructReturnType
2280 callIsStructReturn(const SmallVectorImpl<ISD::OutputArg> &Outs) {
2281   if (Outs.empty())
2282     return NotStructReturn;
2283
2284   const ISD::ArgFlagsTy &Flags = Outs[0].Flags;
2285   if (!Flags.isSRet())
2286     return NotStructReturn;
2287   if (Flags.isInReg())
2288     return RegStructReturn;
2289   return StackStructReturn;
2290 }
2291
2292 /// Determines whether a function uses struct return semantics.
2293 static StructReturnType
2294 argsAreStructReturn(const SmallVectorImpl<ISD::InputArg> &Ins) {
2295   if (Ins.empty())
2296     return NotStructReturn;
2297
2298   const ISD::ArgFlagsTy &Flags = Ins[0].Flags;
2299   if (!Flags.isSRet())
2300     return NotStructReturn;
2301   if (Flags.isInReg())
2302     return RegStructReturn;
2303   return StackStructReturn;
2304 }
2305
2306 /// Make a copy of an aggregate at address specified by "Src" to address
2307 /// "Dst" with size and alignment information specified by the specific
2308 /// parameter attribute. The copy will be passed as a byval function parameter.
2309 static SDValue
2310 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
2311                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
2312                           SDLoc dl) {
2313   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
2314
2315   return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
2316                        /*isVolatile*/false, /*AlwaysInline=*/true,
2317                        MachinePointerInfo(), MachinePointerInfo());
2318 }
2319
2320 /// Return true if the calling convention is one that
2321 /// supports tail call optimization.
2322 static bool IsTailCallConvention(CallingConv::ID CC) {
2323   return (CC == CallingConv::Fast || CC == CallingConv::GHC ||
2324           CC == CallingConv::HiPE);
2325 }
2326
2327 /// \brief Return true if the calling convention is a C calling convention.
2328 static bool IsCCallConvention(CallingConv::ID CC) {
2329   return (CC == CallingConv::C || CC == CallingConv::X86_64_Win64 ||
2330           CC == CallingConv::X86_64_SysV);
2331 }
2332
2333 bool X86TargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
2334   if (!CI->isTailCall() || getTargetMachine().Options.DisableTailCalls)
2335     return false;
2336
2337   CallSite CS(CI);
2338   CallingConv::ID CalleeCC = CS.getCallingConv();
2339   if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
2340     return false;
2341
2342   return true;
2343 }
2344
2345 /// Return true if the function is being made into
2346 /// a tailcall target by changing its ABI.
2347 static bool FuncIsMadeTailCallSafe(CallingConv::ID CC,
2348                                    bool GuaranteedTailCallOpt) {
2349   return GuaranteedTailCallOpt && IsTailCallConvention(CC);
2350 }
2351
2352 SDValue
2353 X86TargetLowering::LowerMemArgument(SDValue Chain,
2354                                     CallingConv::ID CallConv,
2355                                     const SmallVectorImpl<ISD::InputArg> &Ins,
2356                                     SDLoc dl, SelectionDAG &DAG,
2357                                     const CCValAssign &VA,
2358                                     MachineFrameInfo *MFI,
2359                                     unsigned i) const {
2360   // Create the nodes corresponding to a load from this parameter slot.
2361   ISD::ArgFlagsTy Flags = Ins[i].Flags;
2362   bool AlwaysUseMutable = FuncIsMadeTailCallSafe(
2363       CallConv, DAG.getTarget().Options.GuaranteedTailCallOpt);
2364   bool isImmutable = !AlwaysUseMutable && !Flags.isByVal();
2365   EVT ValVT;
2366
2367   // If value is passed by pointer we have address passed instead of the value
2368   // itself.
2369   if (VA.getLocInfo() == CCValAssign::Indirect)
2370     ValVT = VA.getLocVT();
2371   else
2372     ValVT = VA.getValVT();
2373
2374   // FIXME: For now, all byval parameter objects are marked mutable. This can be
2375   // changed with more analysis.
2376   // In case of tail call optimization mark all arguments mutable. Since they
2377   // could be overwritten by lowering of arguments in case of a tail call.
2378   if (Flags.isByVal()) {
2379     unsigned Bytes = Flags.getByValSize();
2380     if (Bytes == 0) Bytes = 1; // Don't create zero-sized stack objects.
2381     int FI = MFI->CreateFixedObject(Bytes, VA.getLocMemOffset(), isImmutable);
2382     return DAG.getFrameIndex(FI, getPointerTy());
2383   } else {
2384     int FI = MFI->CreateFixedObject(ValVT.getSizeInBits()/8,
2385                                     VA.getLocMemOffset(), isImmutable);
2386     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2387     return DAG.getLoad(ValVT, dl, Chain, FIN,
2388                        MachinePointerInfo::getFixedStack(FI),
2389                        false, false, false, 0);
2390   }
2391 }
2392
2393 // FIXME: Get this from tablegen.
2394 static ArrayRef<MCPhysReg> get64BitArgumentGPRs(CallingConv::ID CallConv,
2395                                                 const X86Subtarget *Subtarget) {
2396   assert(Subtarget->is64Bit());
2397
2398   if (Subtarget->isCallingConvWin64(CallConv)) {
2399     static const MCPhysReg GPR64ArgRegsWin64[] = {
2400       X86::RCX, X86::RDX, X86::R8,  X86::R9
2401     };
2402     return makeArrayRef(std::begin(GPR64ArgRegsWin64), std::end(GPR64ArgRegsWin64));
2403   }
2404
2405   static const MCPhysReg GPR64ArgRegs64Bit[] = {
2406     X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
2407   };
2408   return makeArrayRef(std::begin(GPR64ArgRegs64Bit), std::end(GPR64ArgRegs64Bit));
2409 }
2410
2411 // FIXME: Get this from tablegen.
2412 static ArrayRef<MCPhysReg> get64BitArgumentXMMs(MachineFunction &MF,
2413                                                 CallingConv::ID CallConv,
2414                                                 const X86Subtarget *Subtarget) {
2415   assert(Subtarget->is64Bit());
2416   if (Subtarget->isCallingConvWin64(CallConv)) {
2417     // The XMM registers which might contain var arg parameters are shadowed
2418     // in their paired GPR.  So we only need to save the GPR to their home
2419     // slots.
2420     // TODO: __vectorcall will change this.
2421     return None;
2422   }
2423
2424   const Function *Fn = MF.getFunction();
2425   bool NoImplicitFloatOps = Fn->getAttributes().
2426       hasAttribute(AttributeSet::FunctionIndex, Attribute::NoImplicitFloat);
2427   assert(!(MF.getTarget().Options.UseSoftFloat && NoImplicitFloatOps) &&
2428          "SSE register cannot be used when SSE is disabled!");
2429   if (MF.getTarget().Options.UseSoftFloat || NoImplicitFloatOps ||
2430       !Subtarget->hasSSE1())
2431     // Kernel mode asks for SSE to be disabled, so there are no XMM argument
2432     // registers.
2433     return None;
2434
2435   static const MCPhysReg XMMArgRegs64Bit[] = {
2436     X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
2437     X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
2438   };
2439   return makeArrayRef(std::begin(XMMArgRegs64Bit), std::end(XMMArgRegs64Bit));
2440 }
2441
2442 SDValue
2443 X86TargetLowering::LowerFormalArguments(SDValue Chain,
2444                                         CallingConv::ID CallConv,
2445                                         bool isVarArg,
2446                                       const SmallVectorImpl<ISD::InputArg> &Ins,
2447                                         SDLoc dl,
2448                                         SelectionDAG &DAG,
2449                                         SmallVectorImpl<SDValue> &InVals)
2450                                           const {
2451   MachineFunction &MF = DAG.getMachineFunction();
2452   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2453
2454   const Function* Fn = MF.getFunction();
2455   if (Fn->hasExternalLinkage() &&
2456       Subtarget->isTargetCygMing() &&
2457       Fn->getName() == "main")
2458     FuncInfo->setForceFramePointer(true);
2459
2460   MachineFrameInfo *MFI = MF.getFrameInfo();
2461   bool Is64Bit = Subtarget->is64Bit();
2462   bool IsWin64 = Subtarget->isCallingConvWin64(CallConv);
2463
2464   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2465          "Var args not supported with calling convention fastcc, ghc or hipe");
2466
2467   // Assign locations to all of the incoming arguments.
2468   SmallVector<CCValAssign, 16> ArgLocs;
2469   CCState CCInfo(CallConv, isVarArg, MF, ArgLocs, *DAG.getContext());
2470
2471   // Allocate shadow area for Win64
2472   if (IsWin64)
2473     CCInfo.AllocateStack(32, 8);
2474
2475   CCInfo.AnalyzeFormalArguments(Ins, CC_X86);
2476
2477   unsigned LastVal = ~0U;
2478   SDValue ArgValue;
2479   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2480     CCValAssign &VA = ArgLocs[i];
2481     // TODO: If an arg is passed in two places (e.g. reg and stack), skip later
2482     // places.
2483     assert(VA.getValNo() != LastVal &&
2484            "Don't support value assigned to multiple locs yet");
2485     (void)LastVal;
2486     LastVal = VA.getValNo();
2487
2488     if (VA.isRegLoc()) {
2489       EVT RegVT = VA.getLocVT();
2490       const TargetRegisterClass *RC;
2491       if (RegVT == MVT::i32)
2492         RC = &X86::GR32RegClass;
2493       else if (Is64Bit && RegVT == MVT::i64)
2494         RC = &X86::GR64RegClass;
2495       else if (RegVT == MVT::f32)
2496         RC = &X86::FR32RegClass;
2497       else if (RegVT == MVT::f64)
2498         RC = &X86::FR64RegClass;
2499       else if (RegVT.is512BitVector())
2500         RC = &X86::VR512RegClass;
2501       else if (RegVT.is256BitVector())
2502         RC = &X86::VR256RegClass;
2503       else if (RegVT.is128BitVector())
2504         RC = &X86::VR128RegClass;
2505       else if (RegVT == MVT::x86mmx)
2506         RC = &X86::VR64RegClass;
2507       else if (RegVT == MVT::i1)
2508         RC = &X86::VK1RegClass;
2509       else if (RegVT == MVT::v8i1)
2510         RC = &X86::VK8RegClass;
2511       else if (RegVT == MVT::v16i1)
2512         RC = &X86::VK16RegClass;
2513       else if (RegVT == MVT::v32i1)
2514         RC = &X86::VK32RegClass;
2515       else if (RegVT == MVT::v64i1)
2516         RC = &X86::VK64RegClass;
2517       else
2518         llvm_unreachable("Unknown argument type!");
2519
2520       unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
2521       ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
2522
2523       // If this is an 8 or 16-bit value, it is really passed promoted to 32
2524       // bits.  Insert an assert[sz]ext to capture this, then truncate to the
2525       // right size.
2526       if (VA.getLocInfo() == CCValAssign::SExt)
2527         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
2528                                DAG.getValueType(VA.getValVT()));
2529       else if (VA.getLocInfo() == CCValAssign::ZExt)
2530         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
2531                                DAG.getValueType(VA.getValVT()));
2532       else if (VA.getLocInfo() == CCValAssign::BCvt)
2533         ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
2534
2535       if (VA.isExtInLoc()) {
2536         // Handle MMX values passed in XMM regs.
2537         if (RegVT.isVector())
2538           ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(), ArgValue);
2539         else
2540           ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
2541       }
2542     } else {
2543       assert(VA.isMemLoc());
2544       ArgValue = LowerMemArgument(Chain, CallConv, Ins, dl, DAG, VA, MFI, i);
2545     }
2546
2547     // If value is passed via pointer - do a load.
2548     if (VA.getLocInfo() == CCValAssign::Indirect)
2549       ArgValue = DAG.getLoad(VA.getValVT(), dl, Chain, ArgValue,
2550                              MachinePointerInfo(), false, false, false, 0);
2551
2552     InVals.push_back(ArgValue);
2553   }
2554
2555   if (Subtarget->is64Bit() || Subtarget->isTargetKnownWindowsMSVC()) {
2556     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2557       // The x86-64 ABIs require that for returning structs by value we copy
2558       // the sret argument into %rax/%eax (depending on ABI) for the return.
2559       // Win32 requires us to put the sret argument to %eax as well.
2560       // Save the argument into a virtual register so that we can access it
2561       // from the return points.
2562       if (Ins[i].Flags.isSRet()) {
2563         unsigned Reg = FuncInfo->getSRetReturnReg();
2564         if (!Reg) {
2565           MVT PtrTy = getPointerTy();
2566           Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(PtrTy));
2567           FuncInfo->setSRetReturnReg(Reg);
2568         }
2569         SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[i]);
2570         Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
2571         break;
2572       }
2573     }
2574   }
2575
2576   unsigned StackSize = CCInfo.getNextStackOffset();
2577   // Align stack specially for tail calls.
2578   if (FuncIsMadeTailCallSafe(CallConv,
2579                              MF.getTarget().Options.GuaranteedTailCallOpt))
2580     StackSize = GetAlignedArgumentStackSize(StackSize, DAG);
2581
2582   // If the function takes variable number of arguments, make a frame index for
2583   // the start of the first vararg value... for expansion of llvm.va_start. We
2584   // can skip this if there are no va_start calls.
2585   if (MFI->hasVAStart() &&
2586       (Is64Bit || (CallConv != CallingConv::X86_FastCall &&
2587                    CallConv != CallingConv::X86_ThisCall))) {
2588     FuncInfo->setVarArgsFrameIndex(
2589         MFI->CreateFixedObject(1, StackSize, true));
2590   }
2591
2592   // Figure out if XMM registers are in use.
2593   assert(!(MF.getTarget().Options.UseSoftFloat &&
2594            Fn->getAttributes().hasAttribute(AttributeSet::FunctionIndex,
2595                                             Attribute::NoImplicitFloat)) &&
2596          "SSE register cannot be used when SSE is disabled!");
2597
2598   // 64-bit calling conventions support varargs and register parameters, so we
2599   // have to do extra work to spill them in the prologue.
2600   if (Is64Bit && isVarArg && MFI->hasVAStart()) {
2601     // Find the first unallocated argument registers.
2602     ArrayRef<MCPhysReg> ArgGPRs = get64BitArgumentGPRs(CallConv, Subtarget);
2603     ArrayRef<MCPhysReg> ArgXMMs = get64BitArgumentXMMs(MF, CallConv, Subtarget);
2604     unsigned NumIntRegs =
2605         CCInfo.getFirstUnallocated(ArgGPRs.data(), ArgGPRs.size());
2606     unsigned NumXMMRegs =
2607         CCInfo.getFirstUnallocated(ArgXMMs.data(), ArgXMMs.size());
2608     assert(!(NumXMMRegs && !Subtarget->hasSSE1()) &&
2609            "SSE register cannot be used when SSE is disabled!");
2610
2611     // Gather all the live in physical registers.
2612     SmallVector<SDValue, 6> LiveGPRs;
2613     SmallVector<SDValue, 8> LiveXMMRegs;
2614     SDValue ALVal;
2615     for (MCPhysReg Reg : ArgGPRs.slice(NumIntRegs)) {
2616       unsigned GPR = MF.addLiveIn(Reg, &X86::GR64RegClass);
2617       LiveGPRs.push_back(
2618           DAG.getCopyFromReg(Chain, dl, GPR, MVT::i64));
2619     }
2620     if (!ArgXMMs.empty()) {
2621       unsigned AL = MF.addLiveIn(X86::AL, &X86::GR8RegClass);
2622       ALVal = DAG.getCopyFromReg(Chain, dl, AL, MVT::i8);
2623       for (MCPhysReg Reg : ArgXMMs.slice(NumXMMRegs)) {
2624         unsigned XMMReg = MF.addLiveIn(Reg, &X86::VR128RegClass);
2625         LiveXMMRegs.push_back(
2626             DAG.getCopyFromReg(Chain, dl, XMMReg, MVT::v4f32));
2627       }
2628     }
2629
2630     if (IsWin64) {
2631       const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();
2632       // Get to the caller-allocated home save location.  Add 8 to account
2633       // for the return address.
2634       int HomeOffset = TFI.getOffsetOfLocalArea() + 8;
2635       FuncInfo->setRegSaveFrameIndex(
2636           MFI->CreateFixedObject(1, NumIntRegs * 8 + HomeOffset, false));
2637       // Fixup to set vararg frame on shadow area (4 x i64).
2638       if (NumIntRegs < 4)
2639         FuncInfo->setVarArgsFrameIndex(FuncInfo->getRegSaveFrameIndex());
2640     } else {
2641       // For X86-64, if there are vararg parameters that are passed via
2642       // registers, then we must store them to their spots on the stack so
2643       // they may be loaded by deferencing the result of va_next.
2644       FuncInfo->setVarArgsGPOffset(NumIntRegs * 8);
2645       FuncInfo->setVarArgsFPOffset(ArgGPRs.size() * 8 + NumXMMRegs * 16);
2646       FuncInfo->setRegSaveFrameIndex(MFI->CreateStackObject(
2647           ArgGPRs.size() * 8 + ArgXMMs.size() * 16, 16, false));
2648     }
2649
2650     // Store the integer parameter registers.
2651     SmallVector<SDValue, 8> MemOps;
2652     SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
2653                                       getPointerTy());
2654     unsigned Offset = FuncInfo->getVarArgsGPOffset();
2655     for (SDValue Val : LiveGPRs) {
2656       SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), RSFIN,
2657                                 DAG.getIntPtrConstant(Offset));
2658       SDValue Store =
2659         DAG.getStore(Val.getValue(1), dl, Val, FIN,
2660                      MachinePointerInfo::getFixedStack(
2661                        FuncInfo->getRegSaveFrameIndex(), Offset),
2662                      false, false, 0);
2663       MemOps.push_back(Store);
2664       Offset += 8;
2665     }
2666
2667     if (!ArgXMMs.empty() && NumXMMRegs != ArgXMMs.size()) {
2668       // Now store the XMM (fp + vector) parameter registers.
2669       SmallVector<SDValue, 12> SaveXMMOps;
2670       SaveXMMOps.push_back(Chain);
2671       SaveXMMOps.push_back(ALVal);
2672       SaveXMMOps.push_back(DAG.getIntPtrConstant(
2673                              FuncInfo->getRegSaveFrameIndex()));
2674       SaveXMMOps.push_back(DAG.getIntPtrConstant(
2675                              FuncInfo->getVarArgsFPOffset()));
2676       SaveXMMOps.insert(SaveXMMOps.end(), LiveXMMRegs.begin(),
2677                         LiveXMMRegs.end());
2678       MemOps.push_back(DAG.getNode(X86ISD::VASTART_SAVE_XMM_REGS, dl,
2679                                    MVT::Other, SaveXMMOps));
2680     }
2681
2682     if (!MemOps.empty())
2683       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
2684   }
2685
2686   if (isVarArg && MFI->hasMustTailInVarArgFunc()) {
2687     // Find the largest legal vector type.
2688     MVT VecVT = MVT::Other;
2689     // FIXME: Only some x86_32 calling conventions support AVX512.
2690     if (Subtarget->hasAVX512() &&
2691         (Is64Bit || (CallConv == CallingConv::X86_VectorCall ||
2692                      CallConv == CallingConv::Intel_OCL_BI)))
2693       VecVT = MVT::v16f32;
2694     else if (Subtarget->hasAVX())
2695       VecVT = MVT::v8f32;
2696     else if (Subtarget->hasSSE2())
2697       VecVT = MVT::v4f32;
2698
2699     // We forward some GPRs and some vector types.
2700     SmallVector<MVT, 2> RegParmTypes;
2701     MVT IntVT = Is64Bit ? MVT::i64 : MVT::i32;
2702     RegParmTypes.push_back(IntVT);
2703     if (VecVT != MVT::Other)
2704       RegParmTypes.push_back(VecVT);
2705
2706     // Compute the set of forwarded registers. The rest are scratch.
2707     SmallVectorImpl<ForwardedRegister> &Forwards =
2708         FuncInfo->getForwardedMustTailRegParms();
2709     CCInfo.analyzeMustTailForwardedRegisters(Forwards, RegParmTypes, CC_X86);
2710
2711     // Conservatively forward AL on x86_64, since it might be used for varargs.
2712     if (Is64Bit && !CCInfo.isAllocated(X86::AL)) {
2713       unsigned ALVReg = MF.addLiveIn(X86::AL, &X86::GR8RegClass);
2714       Forwards.push_back(ForwardedRegister(ALVReg, X86::AL, MVT::i8));
2715     }
2716
2717     // Copy all forwards from physical to virtual registers.
2718     for (ForwardedRegister &F : Forwards) {
2719       // FIXME: Can we use a less constrained schedule?
2720       SDValue RegVal = DAG.getCopyFromReg(Chain, dl, F.VReg, F.VT);
2721       F.VReg = MF.getRegInfo().createVirtualRegister(getRegClassFor(F.VT));
2722       Chain = DAG.getCopyToReg(Chain, dl, F.VReg, RegVal);
2723     }
2724   }
2725
2726   // Some CCs need callee pop.
2727   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
2728                        MF.getTarget().Options.GuaranteedTailCallOpt)) {
2729     FuncInfo->setBytesToPopOnReturn(StackSize); // Callee pops everything.
2730   } else {
2731     FuncInfo->setBytesToPopOnReturn(0); // Callee pops nothing.
2732     // If this is an sret function, the return should pop the hidden pointer.
2733     if (!Is64Bit && !IsTailCallConvention(CallConv) &&
2734         !Subtarget->getTargetTriple().isOSMSVCRT() &&
2735         argsAreStructReturn(Ins) == StackStructReturn)
2736       FuncInfo->setBytesToPopOnReturn(4);
2737   }
2738
2739   if (!Is64Bit) {
2740     // RegSaveFrameIndex is X86-64 only.
2741     FuncInfo->setRegSaveFrameIndex(0xAAAAAAA);
2742     if (CallConv == CallingConv::X86_FastCall ||
2743         CallConv == CallingConv::X86_ThisCall)
2744       // fastcc functions can't have varargs.
2745       FuncInfo->setVarArgsFrameIndex(0xAAAAAAA);
2746   }
2747
2748   FuncInfo->setArgumentStackSize(StackSize);
2749
2750   return Chain;
2751 }
2752
2753 SDValue
2754 X86TargetLowering::LowerMemOpCallTo(SDValue Chain,
2755                                     SDValue StackPtr, SDValue Arg,
2756                                     SDLoc dl, SelectionDAG &DAG,
2757                                     const CCValAssign &VA,
2758                                     ISD::ArgFlagsTy Flags) const {
2759   unsigned LocMemOffset = VA.getLocMemOffset();
2760   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
2761   PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
2762   if (Flags.isByVal())
2763     return CreateCopyOfByValArgument(Arg, PtrOff, Chain, Flags, DAG, dl);
2764
2765   return DAG.getStore(Chain, dl, Arg, PtrOff,
2766                       MachinePointerInfo::getStack(LocMemOffset),
2767                       false, false, 0);
2768 }
2769
2770 /// Emit a load of return address if tail call
2771 /// optimization is performed and it is required.
2772 SDValue
2773 X86TargetLowering::EmitTailCallLoadRetAddr(SelectionDAG &DAG,
2774                                            SDValue &OutRetAddr, SDValue Chain,
2775                                            bool IsTailCall, bool Is64Bit,
2776                                            int FPDiff, SDLoc dl) const {
2777   // Adjust the Return address stack slot.
2778   EVT VT = getPointerTy();
2779   OutRetAddr = getReturnAddressFrameIndex(DAG);
2780
2781   // Load the "old" Return address.
2782   OutRetAddr = DAG.getLoad(VT, dl, Chain, OutRetAddr, MachinePointerInfo(),
2783                            false, false, false, 0);
2784   return SDValue(OutRetAddr.getNode(), 1);
2785 }
2786
2787 /// Emit a store of the return address if tail call
2788 /// optimization is performed and it is required (FPDiff!=0).
2789 static SDValue EmitTailCallStoreRetAddr(SelectionDAG &DAG, MachineFunction &MF,
2790                                         SDValue Chain, SDValue RetAddrFrIdx,
2791                                         EVT PtrVT, unsigned SlotSize,
2792                                         int FPDiff, SDLoc dl) {
2793   // Store the return address to the appropriate stack slot.
2794   if (!FPDiff) return Chain;
2795   // Calculate the new stack slot for the return address.
2796   int NewReturnAddrFI =
2797     MF.getFrameInfo()->CreateFixedObject(SlotSize, (int64_t)FPDiff - SlotSize,
2798                                          false);
2799   SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, PtrVT);
2800   Chain = DAG.getStore(Chain, dl, RetAddrFrIdx, NewRetAddrFrIdx,
2801                        MachinePointerInfo::getFixedStack(NewReturnAddrFI),
2802                        false, false, 0);
2803   return Chain;
2804 }
2805
2806 SDValue
2807 X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
2808                              SmallVectorImpl<SDValue> &InVals) const {
2809   SelectionDAG &DAG                     = CLI.DAG;
2810   SDLoc &dl                             = CLI.DL;
2811   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
2812   SmallVectorImpl<SDValue> &OutVals     = CLI.OutVals;
2813   SmallVectorImpl<ISD::InputArg> &Ins   = CLI.Ins;
2814   SDValue Chain                         = CLI.Chain;
2815   SDValue Callee                        = CLI.Callee;
2816   CallingConv::ID CallConv              = CLI.CallConv;
2817   bool &isTailCall                      = CLI.IsTailCall;
2818   bool isVarArg                         = CLI.IsVarArg;
2819
2820   MachineFunction &MF = DAG.getMachineFunction();
2821   bool Is64Bit        = Subtarget->is64Bit();
2822   bool IsWin64        = Subtarget->isCallingConvWin64(CallConv);
2823   StructReturnType SR = callIsStructReturn(Outs);
2824   bool IsSibcall      = false;
2825   X86MachineFunctionInfo *X86Info = MF.getInfo<X86MachineFunctionInfo>();
2826
2827   if (MF.getTarget().Options.DisableTailCalls)
2828     isTailCall = false;
2829
2830   bool IsMustTail = CLI.CS && CLI.CS->isMustTailCall();
2831   if (IsMustTail) {
2832     // Force this to be a tail call.  The verifier rules are enough to ensure
2833     // that we can lower this successfully without moving the return address
2834     // around.
2835     isTailCall = true;
2836   } else if (isTailCall) {
2837     // Check if it's really possible to do a tail call.
2838     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
2839                     isVarArg, SR != NotStructReturn,
2840                     MF.getFunction()->hasStructRetAttr(), CLI.RetTy,
2841                     Outs, OutVals, Ins, DAG);
2842
2843     // Sibcalls are automatically detected tailcalls which do not require
2844     // ABI changes.
2845     if (!MF.getTarget().Options.GuaranteedTailCallOpt && isTailCall)
2846       IsSibcall = true;
2847
2848     if (isTailCall)
2849       ++NumTailCalls;
2850   }
2851
2852   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2853          "Var args not supported with calling convention fastcc, ghc or hipe");
2854
2855   // Analyze operands of the call, assigning locations to each operand.
2856   SmallVector<CCValAssign, 16> ArgLocs;
2857   CCState CCInfo(CallConv, isVarArg, MF, ArgLocs, *DAG.getContext());
2858
2859   // Allocate shadow area for Win64
2860   if (IsWin64)
2861     CCInfo.AllocateStack(32, 8);
2862
2863   CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2864
2865   // Get a count of how many bytes are to be pushed on the stack.
2866   unsigned NumBytes = CCInfo.getNextStackOffset();
2867   if (IsSibcall)
2868     // This is a sibcall. The memory operands are available in caller's
2869     // own caller's stack.
2870     NumBytes = 0;
2871   else if (MF.getTarget().Options.GuaranteedTailCallOpt &&
2872            IsTailCallConvention(CallConv))
2873     NumBytes = GetAlignedArgumentStackSize(NumBytes, DAG);
2874
2875   int FPDiff = 0;
2876   if (isTailCall && !IsSibcall && !IsMustTail) {
2877     // Lower arguments at fp - stackoffset + fpdiff.
2878     unsigned NumBytesCallerPushed = X86Info->getBytesToPopOnReturn();
2879
2880     FPDiff = NumBytesCallerPushed - NumBytes;
2881
2882     // Set the delta of movement of the returnaddr stackslot.
2883     // But only set if delta is greater than previous delta.
2884     if (FPDiff < X86Info->getTCReturnAddrDelta())
2885       X86Info->setTCReturnAddrDelta(FPDiff);
2886   }
2887
2888   unsigned NumBytesToPush = NumBytes;
2889   unsigned NumBytesToPop = NumBytes;
2890
2891   // If we have an inalloca argument, all stack space has already been allocated
2892   // for us and be right at the top of the stack.  We don't support multiple
2893   // arguments passed in memory when using inalloca.
2894   if (!Outs.empty() && Outs.back().Flags.isInAlloca()) {
2895     NumBytesToPush = 0;
2896     if (!ArgLocs.back().isMemLoc())
2897       report_fatal_error("cannot use inalloca attribute on a register "
2898                          "parameter");
2899     if (ArgLocs.back().getLocMemOffset() != 0)
2900       report_fatal_error("any parameter with the inalloca attribute must be "
2901                          "the only memory argument");
2902   }
2903
2904   if (!IsSibcall)
2905     Chain = DAG.getCALLSEQ_START(
2906         Chain, DAG.getIntPtrConstant(NumBytesToPush, true), dl);
2907
2908   SDValue RetAddrFrIdx;
2909   // Load return address for tail calls.
2910   if (isTailCall && FPDiff)
2911     Chain = EmitTailCallLoadRetAddr(DAG, RetAddrFrIdx, Chain, isTailCall,
2912                                     Is64Bit, FPDiff, dl);
2913
2914   SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
2915   SmallVector<SDValue, 8> MemOpChains;
2916   SDValue StackPtr;
2917
2918   // Walk the register/memloc assignments, inserting copies/loads.  In the case
2919   // of tail call optimization arguments are handle later.
2920   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
2921       DAG.getSubtarget().getRegisterInfo());
2922   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2923     // Skip inalloca arguments, they have already been written.
2924     ISD::ArgFlagsTy Flags = Outs[i].Flags;
2925     if (Flags.isInAlloca())
2926       continue;
2927
2928     CCValAssign &VA = ArgLocs[i];
2929     EVT RegVT = VA.getLocVT();
2930     SDValue Arg = OutVals[i];
2931     bool isByVal = Flags.isByVal();
2932
2933     // Promote the value if needed.
2934     switch (VA.getLocInfo()) {
2935     default: llvm_unreachable("Unknown loc info!");
2936     case CCValAssign::Full: break;
2937     case CCValAssign::SExt:
2938       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
2939       break;
2940     case CCValAssign::ZExt:
2941       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
2942       break;
2943     case CCValAssign::AExt:
2944       if (RegVT.is128BitVector()) {
2945         // Special case: passing MMX values in XMM registers.
2946         Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
2947         Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
2948         Arg = getMOVL(DAG, dl, MVT::v2i64, DAG.getUNDEF(MVT::v2i64), Arg);
2949       } else
2950         Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
2951       break;
2952     case CCValAssign::BCvt:
2953       Arg = DAG.getNode(ISD::BITCAST, dl, RegVT, Arg);
2954       break;
2955     case CCValAssign::Indirect: {
2956       // Store the argument.
2957       SDValue SpillSlot = DAG.CreateStackTemporary(VA.getValVT());
2958       int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
2959       Chain = DAG.getStore(Chain, dl, Arg, SpillSlot,
2960                            MachinePointerInfo::getFixedStack(FI),
2961                            false, false, 0);
2962       Arg = SpillSlot;
2963       break;
2964     }
2965     }
2966
2967     if (VA.isRegLoc()) {
2968       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
2969       if (isVarArg && IsWin64) {
2970         // Win64 ABI requires argument XMM reg to be copied to the corresponding
2971         // shadow reg if callee is a varargs function.
2972         unsigned ShadowReg = 0;
2973         switch (VA.getLocReg()) {
2974         case X86::XMM0: ShadowReg = X86::RCX; break;
2975         case X86::XMM1: ShadowReg = X86::RDX; break;
2976         case X86::XMM2: ShadowReg = X86::R8; break;
2977         case X86::XMM3: ShadowReg = X86::R9; break;
2978         }
2979         if (ShadowReg)
2980           RegsToPass.push_back(std::make_pair(ShadowReg, Arg));
2981       }
2982     } else if (!IsSibcall && (!isTailCall || isByVal)) {
2983       assert(VA.isMemLoc());
2984       if (!StackPtr.getNode())
2985         StackPtr = DAG.getCopyFromReg(Chain, dl, RegInfo->getStackRegister(),
2986                                       getPointerTy());
2987       MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Arg,
2988                                              dl, DAG, VA, Flags));
2989     }
2990   }
2991
2992   if (!MemOpChains.empty())
2993     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
2994
2995   if (Subtarget->isPICStyleGOT()) {
2996     // ELF / PIC requires GOT in the EBX register before function calls via PLT
2997     // GOT pointer.
2998     if (!isTailCall) {
2999       RegsToPass.push_back(std::make_pair(unsigned(X86::EBX),
3000                DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy())));
3001     } else {
3002       // If we are tail calling and generating PIC/GOT style code load the
3003       // address of the callee into ECX. The value in ecx is used as target of
3004       // the tail jump. This is done to circumvent the ebx/callee-saved problem
3005       // for tail calls on PIC/GOT architectures. Normally we would just put the
3006       // address of GOT into ebx and then call target@PLT. But for tail calls
3007       // ebx would be restored (since ebx is callee saved) before jumping to the
3008       // target@PLT.
3009
3010       // Note: The actual moving to ECX is done further down.
3011       GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
3012       if (G && !G->getGlobal()->hasHiddenVisibility() &&
3013           !G->getGlobal()->hasProtectedVisibility())
3014         Callee = LowerGlobalAddress(Callee, DAG);
3015       else if (isa<ExternalSymbolSDNode>(Callee))
3016         Callee = LowerExternalSymbol(Callee, DAG);
3017     }
3018   }
3019
3020   if (Is64Bit && isVarArg && !IsWin64 && !IsMustTail) {
3021     // From AMD64 ABI document:
3022     // For calls that may call functions that use varargs or stdargs
3023     // (prototype-less calls or calls to functions containing ellipsis (...) in
3024     // the declaration) %al is used as hidden argument to specify the number
3025     // of SSE registers used. The contents of %al do not need to match exactly
3026     // the number of registers, but must be an ubound on the number of SSE
3027     // registers used and is in the range 0 - 8 inclusive.
3028
3029     // Count the number of XMM registers allocated.
3030     static const MCPhysReg XMMArgRegs[] = {
3031       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
3032       X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
3033     };
3034     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs, 8);
3035     assert((Subtarget->hasSSE1() || !NumXMMRegs)
3036            && "SSE registers cannot be used when SSE is disabled");
3037
3038     RegsToPass.push_back(std::make_pair(unsigned(X86::AL),
3039                                         DAG.getConstant(NumXMMRegs, MVT::i8)));
3040   }
3041
3042   if (isVarArg && IsMustTail) {
3043     const auto &Forwards = X86Info->getForwardedMustTailRegParms();
3044     for (const auto &F : Forwards) {
3045       SDValue Val = DAG.getCopyFromReg(Chain, dl, F.VReg, F.VT);
3046       RegsToPass.push_back(std::make_pair(unsigned(F.PReg), Val));
3047     }
3048   }
3049
3050   // For tail calls lower the arguments to the 'real' stack slots.  Sibcalls
3051   // don't need this because the eligibility check rejects calls that require
3052   // shuffling arguments passed in memory.
3053   if (!IsSibcall && isTailCall) {
3054     // Force all the incoming stack arguments to be loaded from the stack
3055     // before any new outgoing arguments are stored to the stack, because the
3056     // outgoing stack slots may alias the incoming argument stack slots, and
3057     // the alias isn't otherwise explicit. This is slightly more conservative
3058     // than necessary, because it means that each store effectively depends
3059     // on every argument instead of just those arguments it would clobber.
3060     SDValue ArgChain = DAG.getStackArgumentTokenFactor(Chain);
3061
3062     SmallVector<SDValue, 8> MemOpChains2;
3063     SDValue FIN;
3064     int FI = 0;
3065     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3066       CCValAssign &VA = ArgLocs[i];
3067       if (VA.isRegLoc())
3068         continue;
3069       assert(VA.isMemLoc());
3070       SDValue Arg = OutVals[i];
3071       ISD::ArgFlagsTy Flags = Outs[i].Flags;
3072       // Skip inalloca arguments.  They don't require any work.
3073       if (Flags.isInAlloca())
3074         continue;
3075       // Create frame index.
3076       int32_t Offset = VA.getLocMemOffset()+FPDiff;
3077       uint32_t OpSize = (VA.getLocVT().getSizeInBits()+7)/8;
3078       FI = MF.getFrameInfo()->CreateFixedObject(OpSize, Offset, true);
3079       FIN = DAG.getFrameIndex(FI, getPointerTy());
3080
3081       if (Flags.isByVal()) {
3082         // Copy relative to framepointer.
3083         SDValue Source = DAG.getIntPtrConstant(VA.getLocMemOffset());
3084         if (!StackPtr.getNode())
3085           StackPtr = DAG.getCopyFromReg(Chain, dl,
3086                                         RegInfo->getStackRegister(),
3087                                         getPointerTy());
3088         Source = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, Source);
3089
3090         MemOpChains2.push_back(CreateCopyOfByValArgument(Source, FIN,
3091                                                          ArgChain,
3092                                                          Flags, DAG, dl));
3093       } else {
3094         // Store relative to framepointer.
3095         MemOpChains2.push_back(
3096           DAG.getStore(ArgChain, dl, Arg, FIN,
3097                        MachinePointerInfo::getFixedStack(FI),
3098                        false, false, 0));
3099       }
3100     }
3101
3102     if (!MemOpChains2.empty())
3103       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains2);
3104
3105     // Store the return address to the appropriate stack slot.
3106     Chain = EmitTailCallStoreRetAddr(DAG, MF, Chain, RetAddrFrIdx,
3107                                      getPointerTy(), RegInfo->getSlotSize(),
3108                                      FPDiff, dl);
3109   }
3110
3111   // Build a sequence of copy-to-reg nodes chained together with token chain
3112   // and flag operands which copy the outgoing args into registers.
3113   SDValue InFlag;
3114   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
3115     Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
3116                              RegsToPass[i].second, InFlag);
3117     InFlag = Chain.getValue(1);
3118   }
3119
3120   if (DAG.getTarget().getCodeModel() == CodeModel::Large) {
3121     assert(Is64Bit && "Large code model is only legal in 64-bit mode.");
3122     // In the 64-bit large code model, we have to make all calls
3123     // through a register, since the call instruction's 32-bit
3124     // pc-relative offset may not be large enough to hold the whole
3125     // address.
3126   } else if (Callee->getOpcode() == ISD::GlobalAddress) {
3127     // If the callee is a GlobalAddress node (quite common, every direct call
3128     // is) turn it into a TargetGlobalAddress node so that legalize doesn't hack
3129     // it.
3130     GlobalAddressSDNode* G = cast<GlobalAddressSDNode>(Callee);
3131
3132     // We should use extra load for direct calls to dllimported functions in
3133     // non-JIT mode.
3134     const GlobalValue *GV = G->getGlobal();
3135     if (!GV->hasDLLImportStorageClass()) {
3136       unsigned char OpFlags = 0;
3137       bool ExtraLoad = false;
3138       unsigned WrapperKind = ISD::DELETED_NODE;
3139
3140       // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
3141       // external symbols most go through the PLT in PIC mode.  If the symbol
3142       // has hidden or protected visibility, or if it is static or local, then
3143       // we don't need to use the PLT - we can directly call it.
3144       if (Subtarget->isTargetELF() &&
3145           DAG.getTarget().getRelocationModel() == Reloc::PIC_ &&
3146           GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
3147         OpFlags = X86II::MO_PLT;
3148       } else if (Subtarget->isPICStyleStubAny() &&
3149                  (GV->isDeclaration() || GV->isWeakForLinker()) &&
3150                  (!Subtarget->getTargetTriple().isMacOSX() ||
3151                   Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
3152         // PC-relative references to external symbols should go through $stub,
3153         // unless we're building with the leopard linker or later, which
3154         // automatically synthesizes these stubs.
3155         OpFlags = X86II::MO_DARWIN_STUB;
3156       } else if (Subtarget->isPICStyleRIPRel() &&
3157                  isa<Function>(GV) &&
3158                  cast<Function>(GV)->getAttributes().
3159                    hasAttribute(AttributeSet::FunctionIndex,
3160                                 Attribute::NonLazyBind)) {
3161         // If the function is marked as non-lazy, generate an indirect call
3162         // which loads from the GOT directly. This avoids runtime overhead
3163         // at the cost of eager binding (and one extra byte of encoding).
3164         OpFlags = X86II::MO_GOTPCREL;
3165         WrapperKind = X86ISD::WrapperRIP;
3166         ExtraLoad = true;
3167       }
3168
3169       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(),
3170                                           G->getOffset(), OpFlags);
3171
3172       // Add a wrapper if needed.
3173       if (WrapperKind != ISD::DELETED_NODE)
3174         Callee = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Callee);
3175       // Add extra indirection if needed.
3176       if (ExtraLoad)
3177         Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Callee,
3178                              MachinePointerInfo::getGOT(),
3179                              false, false, false, 0);
3180     }
3181   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
3182     unsigned char OpFlags = 0;
3183
3184     // On ELF targets, in either X86-64 or X86-32 mode, direct calls to
3185     // external symbols should go through the PLT.
3186     if (Subtarget->isTargetELF() &&
3187         DAG.getTarget().getRelocationModel() == Reloc::PIC_) {
3188       OpFlags = X86II::MO_PLT;
3189     } else if (Subtarget->isPICStyleStubAny() &&
3190                (!Subtarget->getTargetTriple().isMacOSX() ||
3191                 Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
3192       // PC-relative references to external symbols should go through $stub,
3193       // unless we're building with the leopard linker or later, which
3194       // automatically synthesizes these stubs.
3195       OpFlags = X86II::MO_DARWIN_STUB;
3196     }
3197
3198     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy(),
3199                                          OpFlags);
3200   } else if (Subtarget->isTarget64BitILP32() && Callee->getValueType(0) == MVT::i32) {
3201     // Zero-extend the 32-bit Callee address into a 64-bit according to x32 ABI
3202     Callee = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Callee);
3203   }
3204
3205   // Returns a chain & a flag for retval copy to use.
3206   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
3207   SmallVector<SDValue, 8> Ops;
3208
3209   if (!IsSibcall && isTailCall) {
3210     Chain = DAG.getCALLSEQ_END(Chain,
3211                                DAG.getIntPtrConstant(NumBytesToPop, true),
3212                                DAG.getIntPtrConstant(0, true), InFlag, dl);
3213     InFlag = Chain.getValue(1);
3214   }
3215
3216   Ops.push_back(Chain);
3217   Ops.push_back(Callee);
3218
3219   if (isTailCall)
3220     Ops.push_back(DAG.getConstant(FPDiff, MVT::i32));
3221
3222   // Add argument registers to the end of the list so that they are known live
3223   // into the call.
3224   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
3225     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
3226                                   RegsToPass[i].second.getValueType()));
3227
3228   // Add a register mask operand representing the call-preserved registers.
3229   const TargetRegisterInfo *TRI = DAG.getSubtarget().getRegisterInfo();
3230   const uint32_t *Mask = TRI->getCallPreservedMask(CallConv);
3231   assert(Mask && "Missing call preserved mask for calling convention");
3232   Ops.push_back(DAG.getRegisterMask(Mask));
3233
3234   if (InFlag.getNode())
3235     Ops.push_back(InFlag);
3236
3237   if (isTailCall) {
3238     // We used to do:
3239     //// If this is the first return lowered for this function, add the regs
3240     //// to the liveout set for the function.
3241     // This isn't right, although it's probably harmless on x86; liveouts
3242     // should be computed from returns not tail calls.  Consider a void
3243     // function making a tail call to a function returning int.
3244     return DAG.getNode(X86ISD::TC_RETURN, dl, NodeTys, Ops);
3245   }
3246
3247   Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, Ops);
3248   InFlag = Chain.getValue(1);
3249
3250   // Create the CALLSEQ_END node.
3251   unsigned NumBytesForCalleeToPop;
3252   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
3253                        DAG.getTarget().Options.GuaranteedTailCallOpt))
3254     NumBytesForCalleeToPop = NumBytes;    // Callee pops everything
3255   else if (!Is64Bit && !IsTailCallConvention(CallConv) &&
3256            !Subtarget->getTargetTriple().isOSMSVCRT() &&
3257            SR == StackStructReturn)
3258     // If this is a call to a struct-return function, the callee
3259     // pops the hidden struct pointer, so we have to push it back.
3260     // This is common for Darwin/X86, Linux & Mingw32 targets.
3261     // For MSVC Win32 targets, the caller pops the hidden struct pointer.
3262     NumBytesForCalleeToPop = 4;
3263   else
3264     NumBytesForCalleeToPop = 0;  // Callee pops nothing.
3265
3266   // Returns a flag for retval copy to use.
3267   if (!IsSibcall) {
3268     Chain = DAG.getCALLSEQ_END(Chain,
3269                                DAG.getIntPtrConstant(NumBytesToPop, true),
3270                                DAG.getIntPtrConstant(NumBytesForCalleeToPop,
3271                                                      true),
3272                                InFlag, dl);
3273     InFlag = Chain.getValue(1);
3274   }
3275
3276   // Handle result values, copying them out of physregs into vregs that we
3277   // return.
3278   return LowerCallResult(Chain, InFlag, CallConv, isVarArg,
3279                          Ins, dl, DAG, InVals);
3280 }
3281
3282 //===----------------------------------------------------------------------===//
3283 //                Fast Calling Convention (tail call) implementation
3284 //===----------------------------------------------------------------------===//
3285
3286 //  Like std call, callee cleans arguments, convention except that ECX is
3287 //  reserved for storing the tail called function address. Only 2 registers are
3288 //  free for argument passing (inreg). Tail call optimization is performed
3289 //  provided:
3290 //                * tailcallopt is enabled
3291 //                * caller/callee are fastcc
3292 //  On X86_64 architecture with GOT-style position independent code only local
3293 //  (within module) calls are supported at the moment.
3294 //  To keep the stack aligned according to platform abi the function
3295 //  GetAlignedArgumentStackSize ensures that argument delta is always multiples
3296 //  of stack alignment. (Dynamic linkers need this - darwin's dyld for example)
3297 //  If a tail called function callee has more arguments than the caller the
3298 //  caller needs to make sure that there is room to move the RETADDR to. This is
3299 //  achieved by reserving an area the size of the argument delta right after the
3300 //  original RETADDR, but before the saved framepointer or the spilled registers
3301 //  e.g. caller(arg1, arg2) calls callee(arg1, arg2,arg3,arg4)
3302 //  stack layout:
3303 //    arg1
3304 //    arg2
3305 //    RETADDR
3306 //    [ new RETADDR
3307 //      move area ]
3308 //    (possible EBP)
3309 //    ESI
3310 //    EDI
3311 //    local1 ..
3312
3313 /// GetAlignedArgumentStackSize - Make the stack size align e.g 16n + 12 aligned
3314 /// for a 16 byte align requirement.
3315 unsigned
3316 X86TargetLowering::GetAlignedArgumentStackSize(unsigned StackSize,
3317                                                SelectionDAG& DAG) const {
3318   MachineFunction &MF = DAG.getMachineFunction();
3319   const TargetMachine &TM = MF.getTarget();
3320   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
3321       TM.getSubtargetImpl()->getRegisterInfo());
3322   const TargetFrameLowering &TFI = *TM.getSubtargetImpl()->getFrameLowering();
3323   unsigned StackAlignment = TFI.getStackAlignment();
3324   uint64_t AlignMask = StackAlignment - 1;
3325   int64_t Offset = StackSize;
3326   unsigned SlotSize = RegInfo->getSlotSize();
3327   if ( (Offset & AlignMask) <= (StackAlignment - SlotSize) ) {
3328     // Number smaller than 12 so just add the difference.
3329     Offset += ((StackAlignment - SlotSize) - (Offset & AlignMask));
3330   } else {
3331     // Mask out lower bits, add stackalignment once plus the 12 bytes.
3332     Offset = ((~AlignMask) & Offset) + StackAlignment +
3333       (StackAlignment-SlotSize);
3334   }
3335   return Offset;
3336 }
3337
3338 /// MatchingStackOffset - Return true if the given stack call argument is
3339 /// already available in the same position (relatively) of the caller's
3340 /// incoming argument stack.
3341 static
3342 bool MatchingStackOffset(SDValue Arg, unsigned Offset, ISD::ArgFlagsTy Flags,
3343                          MachineFrameInfo *MFI, const MachineRegisterInfo *MRI,
3344                          const X86InstrInfo *TII) {
3345   unsigned Bytes = Arg.getValueType().getSizeInBits() / 8;
3346   int FI = INT_MAX;
3347   if (Arg.getOpcode() == ISD::CopyFromReg) {
3348     unsigned VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
3349     if (!TargetRegisterInfo::isVirtualRegister(VR))
3350       return false;
3351     MachineInstr *Def = MRI->getVRegDef(VR);
3352     if (!Def)
3353       return false;
3354     if (!Flags.isByVal()) {
3355       if (!TII->isLoadFromStackSlot(Def, FI))
3356         return false;
3357     } else {
3358       unsigned Opcode = Def->getOpcode();
3359       if ((Opcode == X86::LEA32r || Opcode == X86::LEA64r) &&
3360           Def->getOperand(1).isFI()) {
3361         FI = Def->getOperand(1).getIndex();
3362         Bytes = Flags.getByValSize();
3363       } else
3364         return false;
3365     }
3366   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
3367     if (Flags.isByVal())
3368       // ByVal argument is passed in as a pointer but it's now being
3369       // dereferenced. e.g.
3370       // define @foo(%struct.X* %A) {
3371       //   tail call @bar(%struct.X* byval %A)
3372       // }
3373       return false;
3374     SDValue Ptr = Ld->getBasePtr();
3375     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr);
3376     if (!FINode)
3377       return false;
3378     FI = FINode->getIndex();
3379   } else if (Arg.getOpcode() == ISD::FrameIndex && Flags.isByVal()) {
3380     FrameIndexSDNode *FINode = cast<FrameIndexSDNode>(Arg);
3381     FI = FINode->getIndex();
3382     Bytes = Flags.getByValSize();
3383   } else
3384     return false;
3385
3386   assert(FI != INT_MAX);
3387   if (!MFI->isFixedObjectIndex(FI))
3388     return false;
3389   return Offset == MFI->getObjectOffset(FI) && Bytes == MFI->getObjectSize(FI);
3390 }
3391
3392 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
3393 /// for tail call optimization. Targets which want to do tail call
3394 /// optimization should implement this function.
3395 bool
3396 X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
3397                                                      CallingConv::ID CalleeCC,
3398                                                      bool isVarArg,
3399                                                      bool isCalleeStructRet,
3400                                                      bool isCallerStructRet,
3401                                                      Type *RetTy,
3402                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
3403                                     const SmallVectorImpl<SDValue> &OutVals,
3404                                     const SmallVectorImpl<ISD::InputArg> &Ins,
3405                                                      SelectionDAG &DAG) const {
3406   if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
3407     return false;
3408
3409   // If -tailcallopt is specified, make fastcc functions tail-callable.
3410   const MachineFunction &MF = DAG.getMachineFunction();
3411   const Function *CallerF = MF.getFunction();
3412
3413   // If the function return type is x86_fp80 and the callee return type is not,
3414   // then the FP_EXTEND of the call result is not a nop. It's not safe to
3415   // perform a tailcall optimization here.
3416   if (CallerF->getReturnType()->isX86_FP80Ty() && !RetTy->isX86_FP80Ty())
3417     return false;
3418
3419   CallingConv::ID CallerCC = CallerF->getCallingConv();
3420   bool CCMatch = CallerCC == CalleeCC;
3421   bool IsCalleeWin64 = Subtarget->isCallingConvWin64(CalleeCC);
3422   bool IsCallerWin64 = Subtarget->isCallingConvWin64(CallerCC);
3423
3424   if (DAG.getTarget().Options.GuaranteedTailCallOpt) {
3425     if (IsTailCallConvention(CalleeCC) && CCMatch)
3426       return true;
3427     return false;
3428   }
3429
3430   // Look for obvious safe cases to perform tail call optimization that do not
3431   // require ABI changes. This is what gcc calls sibcall.
3432
3433   // Can't do sibcall if stack needs to be dynamically re-aligned. PEI needs to
3434   // emit a special epilogue.
3435   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
3436       DAG.getSubtarget().getRegisterInfo());
3437   if (RegInfo->needsStackRealignment(MF))
3438     return false;
3439
3440   // Also avoid sibcall optimization if either caller or callee uses struct
3441   // return semantics.
3442   if (isCalleeStructRet || isCallerStructRet)
3443     return false;
3444
3445   // An stdcall/thiscall caller is expected to clean up its arguments; the
3446   // callee isn't going to do that.
3447   // FIXME: this is more restrictive than needed. We could produce a tailcall
3448   // when the stack adjustment matches. For example, with a thiscall that takes
3449   // only one argument.
3450   if (!CCMatch && (CallerCC == CallingConv::X86_StdCall ||
3451                    CallerCC == CallingConv::X86_ThisCall))
3452     return false;
3453
3454   // Do not sibcall optimize vararg calls unless all arguments are passed via
3455   // registers.
3456   if (isVarArg && !Outs.empty()) {
3457
3458     // Optimizing for varargs on Win64 is unlikely to be safe without
3459     // additional testing.
3460     if (IsCalleeWin64 || IsCallerWin64)
3461       return false;
3462
3463     SmallVector<CCValAssign, 16> ArgLocs;
3464     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(), ArgLocs,
3465                    *DAG.getContext());
3466
3467     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
3468     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i)
3469       if (!ArgLocs[i].isRegLoc())
3470         return false;
3471   }
3472
3473   // If the call result is in ST0 / ST1, it needs to be popped off the x87
3474   // stack.  Therefore, if it's not used by the call it is not safe to optimize
3475   // this into a sibcall.
3476   bool Unused = false;
3477   for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
3478     if (!Ins[i].Used) {
3479       Unused = true;
3480       break;
3481     }
3482   }
3483   if (Unused) {
3484     SmallVector<CCValAssign, 16> RVLocs;
3485     CCState CCInfo(CalleeCC, false, DAG.getMachineFunction(), RVLocs,
3486                    *DAG.getContext());
3487     CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
3488     for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
3489       CCValAssign &VA = RVLocs[i];
3490       if (VA.getLocReg() == X86::FP0 || VA.getLocReg() == X86::FP1)
3491         return false;
3492     }
3493   }
3494
3495   // If the calling conventions do not match, then we'd better make sure the
3496   // results are returned in the same way as what the caller expects.
3497   if (!CCMatch) {
3498     SmallVector<CCValAssign, 16> RVLocs1;
3499     CCState CCInfo1(CalleeCC, false, DAG.getMachineFunction(), RVLocs1,
3500                     *DAG.getContext());
3501     CCInfo1.AnalyzeCallResult(Ins, RetCC_X86);
3502
3503     SmallVector<CCValAssign, 16> RVLocs2;
3504     CCState CCInfo2(CallerCC, false, DAG.getMachineFunction(), RVLocs2,
3505                     *DAG.getContext());
3506     CCInfo2.AnalyzeCallResult(Ins, RetCC_X86);
3507
3508     if (RVLocs1.size() != RVLocs2.size())
3509       return false;
3510     for (unsigned i = 0, e = RVLocs1.size(); i != e; ++i) {
3511       if (RVLocs1[i].isRegLoc() != RVLocs2[i].isRegLoc())
3512         return false;
3513       if (RVLocs1[i].getLocInfo() != RVLocs2[i].getLocInfo())
3514         return false;
3515       if (RVLocs1[i].isRegLoc()) {
3516         if (RVLocs1[i].getLocReg() != RVLocs2[i].getLocReg())
3517           return false;
3518       } else {
3519         if (RVLocs1[i].getLocMemOffset() != RVLocs2[i].getLocMemOffset())
3520           return false;
3521       }
3522     }
3523   }
3524
3525   // If the callee takes no arguments then go on to check the results of the
3526   // call.
3527   if (!Outs.empty()) {
3528     // Check if stack adjustment is needed. For now, do not do this if any
3529     // argument is passed on the stack.
3530     SmallVector<CCValAssign, 16> ArgLocs;
3531     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(), ArgLocs,
3532                    *DAG.getContext());
3533
3534     // Allocate shadow area for Win64
3535     if (IsCalleeWin64)
3536       CCInfo.AllocateStack(32, 8);
3537
3538     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
3539     if (CCInfo.getNextStackOffset()) {
3540       MachineFunction &MF = DAG.getMachineFunction();
3541       if (MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn())
3542         return false;
3543
3544       // Check if the arguments are already laid out in the right way as
3545       // the caller's fixed stack objects.
3546       MachineFrameInfo *MFI = MF.getFrameInfo();
3547       const MachineRegisterInfo *MRI = &MF.getRegInfo();
3548       const X86InstrInfo *TII =
3549           static_cast<const X86InstrInfo *>(DAG.getSubtarget().getInstrInfo());
3550       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3551         CCValAssign &VA = ArgLocs[i];
3552         SDValue Arg = OutVals[i];
3553         ISD::ArgFlagsTy Flags = Outs[i].Flags;
3554         if (VA.getLocInfo() == CCValAssign::Indirect)
3555           return false;
3556         if (!VA.isRegLoc()) {
3557           if (!MatchingStackOffset(Arg, VA.getLocMemOffset(), Flags,
3558                                    MFI, MRI, TII))
3559             return false;
3560         }
3561       }
3562     }
3563
3564     // If the tailcall address may be in a register, then make sure it's
3565     // possible to register allocate for it. In 32-bit, the call address can
3566     // only target EAX, EDX, or ECX since the tail call must be scheduled after
3567     // callee-saved registers are restored. These happen to be the same
3568     // registers used to pass 'inreg' arguments so watch out for those.
3569     if (!Subtarget->is64Bit() &&
3570         ((!isa<GlobalAddressSDNode>(Callee) &&
3571           !isa<ExternalSymbolSDNode>(Callee)) ||
3572          DAG.getTarget().getRelocationModel() == Reloc::PIC_)) {
3573       unsigned NumInRegs = 0;
3574       // In PIC we need an extra register to formulate the address computation
3575       // for the callee.
3576       unsigned MaxInRegs =
3577         (DAG.getTarget().getRelocationModel() == Reloc::PIC_) ? 2 : 3;
3578
3579       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3580         CCValAssign &VA = ArgLocs[i];
3581         if (!VA.isRegLoc())
3582           continue;
3583         unsigned Reg = VA.getLocReg();
3584         switch (Reg) {
3585         default: break;
3586         case X86::EAX: case X86::EDX: case X86::ECX:
3587           if (++NumInRegs == MaxInRegs)
3588             return false;
3589           break;
3590         }
3591       }
3592     }
3593   }
3594
3595   return true;
3596 }
3597
3598 FastISel *
3599 X86TargetLowering::createFastISel(FunctionLoweringInfo &funcInfo,
3600                                   const TargetLibraryInfo *libInfo) const {
3601   return X86::createFastISel(funcInfo, libInfo);
3602 }
3603
3604 //===----------------------------------------------------------------------===//
3605 //                           Other Lowering Hooks
3606 //===----------------------------------------------------------------------===//
3607
3608 static bool MayFoldLoad(SDValue Op) {
3609   return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
3610 }
3611
3612 static bool MayFoldIntoStore(SDValue Op) {
3613   return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
3614 }
3615
3616 static bool isTargetShuffle(unsigned Opcode) {
3617   switch(Opcode) {
3618   default: return false;
3619   case X86ISD::BLENDI:
3620   case X86ISD::PSHUFB:
3621   case X86ISD::PSHUFD:
3622   case X86ISD::PSHUFHW:
3623   case X86ISD::PSHUFLW:
3624   case X86ISD::SHUFP:
3625   case X86ISD::PALIGNR:
3626   case X86ISD::MOVLHPS:
3627   case X86ISD::MOVLHPD:
3628   case X86ISD::MOVHLPS:
3629   case X86ISD::MOVLPS:
3630   case X86ISD::MOVLPD:
3631   case X86ISD::MOVSHDUP:
3632   case X86ISD::MOVSLDUP:
3633   case X86ISD::MOVDDUP:
3634   case X86ISD::MOVSS:
3635   case X86ISD::MOVSD:
3636   case X86ISD::UNPCKL:
3637   case X86ISD::UNPCKH:
3638   case X86ISD::VPERMILPI:
3639   case X86ISD::VPERM2X128:
3640   case X86ISD::VPERMI:
3641     return true;
3642   }
3643 }
3644
3645 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3646                                     SDValue V1, SelectionDAG &DAG) {
3647   switch(Opc) {
3648   default: llvm_unreachable("Unknown x86 shuffle node");
3649   case X86ISD::MOVSHDUP:
3650   case X86ISD::MOVSLDUP:
3651   case X86ISD::MOVDDUP:
3652     return DAG.getNode(Opc, dl, VT, V1);
3653   }
3654 }
3655
3656 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3657                                     SDValue V1, unsigned TargetMask,
3658                                     SelectionDAG &DAG) {
3659   switch(Opc) {
3660   default: llvm_unreachable("Unknown x86 shuffle node");
3661   case X86ISD::PSHUFD:
3662   case X86ISD::PSHUFHW:
3663   case X86ISD::PSHUFLW:
3664   case X86ISD::VPERMILPI:
3665   case X86ISD::VPERMI:
3666     return DAG.getNode(Opc, dl, VT, V1, DAG.getConstant(TargetMask, MVT::i8));
3667   }
3668 }
3669
3670 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3671                                     SDValue V1, SDValue V2, unsigned TargetMask,
3672                                     SelectionDAG &DAG) {
3673   switch(Opc) {
3674   default: llvm_unreachable("Unknown x86 shuffle node");
3675   case X86ISD::PALIGNR:
3676   case X86ISD::VALIGN:
3677   case X86ISD::SHUFP:
3678   case X86ISD::VPERM2X128:
3679     return DAG.getNode(Opc, dl, VT, V1, V2,
3680                        DAG.getConstant(TargetMask, MVT::i8));
3681   }
3682 }
3683
3684 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3685                                     SDValue V1, SDValue V2, SelectionDAG &DAG) {
3686   switch(Opc) {
3687   default: llvm_unreachable("Unknown x86 shuffle node");
3688   case X86ISD::MOVLHPS:
3689   case X86ISD::MOVLHPD:
3690   case X86ISD::MOVHLPS:
3691   case X86ISD::MOVLPS:
3692   case X86ISD::MOVLPD:
3693   case X86ISD::MOVSS:
3694   case X86ISD::MOVSD:
3695   case X86ISD::UNPCKL:
3696   case X86ISD::UNPCKH:
3697     return DAG.getNode(Opc, dl, VT, V1, V2);
3698   }
3699 }
3700
3701 SDValue X86TargetLowering::getReturnAddressFrameIndex(SelectionDAG &DAG) const {
3702   MachineFunction &MF = DAG.getMachineFunction();
3703   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
3704       DAG.getSubtarget().getRegisterInfo());
3705   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
3706   int ReturnAddrIndex = FuncInfo->getRAIndex();
3707
3708   if (ReturnAddrIndex == 0) {
3709     // Set up a frame object for the return address.
3710     unsigned SlotSize = RegInfo->getSlotSize();
3711     ReturnAddrIndex = MF.getFrameInfo()->CreateFixedObject(SlotSize,
3712                                                            -(int64_t)SlotSize,
3713                                                            false);
3714     FuncInfo->setRAIndex(ReturnAddrIndex);
3715   }
3716
3717   return DAG.getFrameIndex(ReturnAddrIndex, getPointerTy());
3718 }
3719
3720 bool X86::isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
3721                                        bool hasSymbolicDisplacement) {
3722   // Offset should fit into 32 bit immediate field.
3723   if (!isInt<32>(Offset))
3724     return false;
3725
3726   // If we don't have a symbolic displacement - we don't have any extra
3727   // restrictions.
3728   if (!hasSymbolicDisplacement)
3729     return true;
3730
3731   // FIXME: Some tweaks might be needed for medium code model.
3732   if (M != CodeModel::Small && M != CodeModel::Kernel)
3733     return false;
3734
3735   // For small code model we assume that latest object is 16MB before end of 31
3736   // bits boundary. We may also accept pretty large negative constants knowing
3737   // that all objects are in the positive half of address space.
3738   if (M == CodeModel::Small && Offset < 16*1024*1024)
3739     return true;
3740
3741   // For kernel code model we know that all object resist in the negative half
3742   // of 32bits address space. We may not accept negative offsets, since they may
3743   // be just off and we may accept pretty large positive ones.
3744   if (M == CodeModel::Kernel && Offset >= 0)
3745     return true;
3746
3747   return false;
3748 }
3749
3750 /// isCalleePop - Determines whether the callee is required to pop its
3751 /// own arguments. Callee pop is necessary to support tail calls.
3752 bool X86::isCalleePop(CallingConv::ID CallingConv,
3753                       bool is64Bit, bool IsVarArg, bool TailCallOpt) {
3754   switch (CallingConv) {
3755   default:
3756     return false;
3757   case CallingConv::X86_StdCall:
3758   case CallingConv::X86_FastCall:
3759   case CallingConv::X86_ThisCall:
3760     return !is64Bit;
3761   case CallingConv::Fast:
3762   case CallingConv::GHC:
3763   case CallingConv::HiPE:
3764     if (IsVarArg)
3765       return false;
3766     return TailCallOpt;
3767   }
3768 }
3769
3770 /// \brief Return true if the condition is an unsigned comparison operation.
3771 static bool isX86CCUnsigned(unsigned X86CC) {
3772   switch (X86CC) {
3773   default: llvm_unreachable("Invalid integer condition!");
3774   case X86::COND_E:     return true;
3775   case X86::COND_G:     return false;
3776   case X86::COND_GE:    return false;
3777   case X86::COND_L:     return false;
3778   case X86::COND_LE:    return false;
3779   case X86::COND_NE:    return true;
3780   case X86::COND_B:     return true;
3781   case X86::COND_A:     return true;
3782   case X86::COND_BE:    return true;
3783   case X86::COND_AE:    return true;
3784   }
3785   llvm_unreachable("covered switch fell through?!");
3786 }
3787
3788 /// TranslateX86CC - do a one to one translation of a ISD::CondCode to the X86
3789 /// specific condition code, returning the condition code and the LHS/RHS of the
3790 /// comparison to make.
3791 static unsigned TranslateX86CC(ISD::CondCode SetCCOpcode, bool isFP,
3792                                SDValue &LHS, SDValue &RHS, SelectionDAG &DAG) {
3793   if (!isFP) {
3794     if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS)) {
3795       if (SetCCOpcode == ISD::SETGT && RHSC->isAllOnesValue()) {
3796         // X > -1   -> X == 0, jump !sign.
3797         RHS = DAG.getConstant(0, RHS.getValueType());
3798         return X86::COND_NS;
3799       }
3800       if (SetCCOpcode == ISD::SETLT && RHSC->isNullValue()) {
3801         // X < 0   -> X == 0, jump on sign.
3802         return X86::COND_S;
3803       }
3804       if (SetCCOpcode == ISD::SETLT && RHSC->getZExtValue() == 1) {
3805         // X < 1   -> X <= 0
3806         RHS = DAG.getConstant(0, RHS.getValueType());
3807         return X86::COND_LE;
3808       }
3809     }
3810
3811     switch (SetCCOpcode) {
3812     default: llvm_unreachable("Invalid integer condition!");
3813     case ISD::SETEQ:  return X86::COND_E;
3814     case ISD::SETGT:  return X86::COND_G;
3815     case ISD::SETGE:  return X86::COND_GE;
3816     case ISD::SETLT:  return X86::COND_L;
3817     case ISD::SETLE:  return X86::COND_LE;
3818     case ISD::SETNE:  return X86::COND_NE;
3819     case ISD::SETULT: return X86::COND_B;
3820     case ISD::SETUGT: return X86::COND_A;
3821     case ISD::SETULE: return X86::COND_BE;
3822     case ISD::SETUGE: return X86::COND_AE;
3823     }
3824   }
3825
3826   // First determine if it is required or is profitable to flip the operands.
3827
3828   // If LHS is a foldable load, but RHS is not, flip the condition.
3829   if (ISD::isNON_EXTLoad(LHS.getNode()) &&
3830       !ISD::isNON_EXTLoad(RHS.getNode())) {
3831     SetCCOpcode = getSetCCSwappedOperands(SetCCOpcode);
3832     std::swap(LHS, RHS);
3833   }
3834
3835   switch (SetCCOpcode) {
3836   default: break;
3837   case ISD::SETOLT:
3838   case ISD::SETOLE:
3839   case ISD::SETUGT:
3840   case ISD::SETUGE:
3841     std::swap(LHS, RHS);
3842     break;
3843   }
3844
3845   // On a floating point condition, the flags are set as follows:
3846   // ZF  PF  CF   op
3847   //  0 | 0 | 0 | X > Y
3848   //  0 | 0 | 1 | X < Y
3849   //  1 | 0 | 0 | X == Y
3850   //  1 | 1 | 1 | unordered
3851   switch (SetCCOpcode) {
3852   default: llvm_unreachable("Condcode should be pre-legalized away");
3853   case ISD::SETUEQ:
3854   case ISD::SETEQ:   return X86::COND_E;
3855   case ISD::SETOLT:              // flipped
3856   case ISD::SETOGT:
3857   case ISD::SETGT:   return X86::COND_A;
3858   case ISD::SETOLE:              // flipped
3859   case ISD::SETOGE:
3860   case ISD::SETGE:   return X86::COND_AE;
3861   case ISD::SETUGT:              // flipped
3862   case ISD::SETULT:
3863   case ISD::SETLT:   return X86::COND_B;
3864   case ISD::SETUGE:              // flipped
3865   case ISD::SETULE:
3866   case ISD::SETLE:   return X86::COND_BE;
3867   case ISD::SETONE:
3868   case ISD::SETNE:   return X86::COND_NE;
3869   case ISD::SETUO:   return X86::COND_P;
3870   case ISD::SETO:    return X86::COND_NP;
3871   case ISD::SETOEQ:
3872   case ISD::SETUNE:  return X86::COND_INVALID;
3873   }
3874 }
3875
3876 /// hasFPCMov - is there a floating point cmov for the specific X86 condition
3877 /// code. Current x86 isa includes the following FP cmov instructions:
3878 /// fcmovb, fcomvbe, fcomve, fcmovu, fcmovae, fcmova, fcmovne, fcmovnu.
3879 static bool hasFPCMov(unsigned X86CC) {
3880   switch (X86CC) {
3881   default:
3882     return false;
3883   case X86::COND_B:
3884   case X86::COND_BE:
3885   case X86::COND_E:
3886   case X86::COND_P:
3887   case X86::COND_A:
3888   case X86::COND_AE:
3889   case X86::COND_NE:
3890   case X86::COND_NP:
3891     return true;
3892   }
3893 }
3894
3895 /// isFPImmLegal - Returns true if the target can instruction select the
3896 /// specified FP immediate natively. If false, the legalizer will
3897 /// materialize the FP immediate as a load from a constant pool.
3898 bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
3899   for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) {
3900     if (Imm.bitwiseIsEqual(LegalFPImmediates[i]))
3901       return true;
3902   }
3903   return false;
3904 }
3905
3906 bool X86TargetLowering::shouldReduceLoadWidth(SDNode *Load,
3907                                               ISD::LoadExtType ExtTy,
3908                                               EVT NewVT) const {
3909   // "ELF Handling for Thread-Local Storage" specifies that R_X86_64_GOTTPOFF
3910   // relocation target a movq or addq instruction: don't let the load shrink.
3911   SDValue BasePtr = cast<LoadSDNode>(Load)->getBasePtr();
3912   if (BasePtr.getOpcode() == X86ISD::WrapperRIP)
3913     if (const auto *GA = dyn_cast<GlobalAddressSDNode>(BasePtr.getOperand(0)))
3914       return GA->getTargetFlags() != X86II::MO_GOTTPOFF;
3915   return true;
3916 }
3917
3918 /// \brief Returns true if it is beneficial to convert a load of a constant
3919 /// to just the constant itself.
3920 bool X86TargetLowering::shouldConvertConstantLoadToIntImm(const APInt &Imm,
3921                                                           Type *Ty) const {
3922   assert(Ty->isIntegerTy());
3923
3924   unsigned BitSize = Ty->getPrimitiveSizeInBits();
3925   if (BitSize == 0 || BitSize > 64)
3926     return false;
3927   return true;
3928 }
3929
3930 bool X86TargetLowering::isExtractSubvectorCheap(EVT ResVT,
3931                                                 unsigned Index) const {
3932   if (!isOperationLegalOrCustom(ISD::EXTRACT_SUBVECTOR, ResVT))
3933     return false;
3934
3935   return (Index == 0 || Index == ResVT.getVectorNumElements());
3936 }
3937
3938 bool X86TargetLowering::isCheapToSpeculateCttz() const {
3939   // Speculate cttz only if we can directly use TZCNT.
3940   return Subtarget->hasBMI();
3941 }
3942
3943 bool X86TargetLowering::isCheapToSpeculateCtlz() const {
3944   // Speculate ctlz only if we can directly use LZCNT.
3945   return Subtarget->hasLZCNT();
3946 }
3947
3948 /// isUndefOrInRange - Return true if Val is undef or if its value falls within
3949 /// the specified range (L, H].
3950 static bool isUndefOrInRange(int Val, int Low, int Hi) {
3951   return (Val < 0) || (Val >= Low && Val < Hi);
3952 }
3953
3954 /// isUndefOrEqual - Val is either less than zero (undef) or equal to the
3955 /// specified value.
3956 static bool isUndefOrEqual(int Val, int CmpVal) {
3957   return (Val < 0 || Val == CmpVal);
3958 }
3959
3960 /// isSequentialOrUndefInRange - Return true if every element in Mask, beginning
3961 /// from position Pos and ending in Pos+Size, falls within the specified
3962 /// sequential range (Low, Low+Size]. or is undef.
3963 static bool isSequentialOrUndefInRange(ArrayRef<int> Mask,
3964                                        unsigned Pos, unsigned Size, int Low) {
3965   for (unsigned i = Pos, e = Pos+Size; i != e; ++i, ++Low)
3966     if (!isUndefOrEqual(Mask[i], Low))
3967       return false;
3968   return true;
3969 }
3970
3971 /// isPSHUFDMask - Return true if the node specifies a shuffle of elements that
3972 /// is suitable for input to PSHUFD. That is, it doesn't reference the other
3973 /// operand - by default will match for first operand.
3974 static bool isPSHUFDMask(ArrayRef<int> Mask, MVT VT,
3975                          bool TestSecondOperand = false) {
3976   if (VT != MVT::v4f32 && VT != MVT::v4i32 &&
3977       VT != MVT::v2f64 && VT != MVT::v2i64)
3978     return false;
3979
3980   unsigned NumElems = VT.getVectorNumElements();
3981   unsigned Lo = TestSecondOperand ? NumElems : 0;
3982   unsigned Hi = Lo + NumElems;
3983
3984   for (unsigned i = 0; i < NumElems; ++i)
3985     if (!isUndefOrInRange(Mask[i], (int)Lo, (int)Hi))
3986       return false;
3987
3988   return true;
3989 }
3990
3991 /// isPSHUFHWMask - Return true if the node specifies a shuffle of elements that
3992 /// is suitable for input to PSHUFHW.
3993 static bool isPSHUFHWMask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
3994   if (VT != MVT::v8i16 && (!HasInt256 || VT != MVT::v16i16))
3995     return false;
3996
3997   // Lower quadword copied in order or undef.
3998   if (!isSequentialOrUndefInRange(Mask, 0, 4, 0))
3999     return false;
4000
4001   // Upper quadword shuffled.
4002   for (unsigned i = 4; i != 8; ++i)
4003     if (!isUndefOrInRange(Mask[i], 4, 8))
4004       return false;
4005
4006   if (VT == MVT::v16i16) {
4007     // Lower quadword copied in order or undef.
4008     if (!isSequentialOrUndefInRange(Mask, 8, 4, 8))
4009       return false;
4010
4011     // Upper quadword shuffled.
4012     for (unsigned i = 12; i != 16; ++i)
4013       if (!isUndefOrInRange(Mask[i], 12, 16))
4014         return false;
4015   }
4016
4017   return true;
4018 }
4019
4020 /// isPSHUFLWMask - Return true if the node specifies a shuffle of elements that
4021 /// is suitable for input to PSHUFLW.
4022 static bool isPSHUFLWMask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
4023   if (VT != MVT::v8i16 && (!HasInt256 || VT != MVT::v16i16))
4024     return false;
4025
4026   // Upper quadword copied in order.
4027   if (!isSequentialOrUndefInRange(Mask, 4, 4, 4))
4028     return false;
4029
4030   // Lower quadword shuffled.
4031   for (unsigned i = 0; i != 4; ++i)
4032     if (!isUndefOrInRange(Mask[i], 0, 4))
4033       return false;
4034
4035   if (VT == MVT::v16i16) {
4036     // Upper quadword copied in order.
4037     if (!isSequentialOrUndefInRange(Mask, 12, 4, 12))
4038       return false;
4039
4040     // Lower quadword shuffled.
4041     for (unsigned i = 8; i != 12; ++i)
4042       if (!isUndefOrInRange(Mask[i], 8, 12))
4043         return false;
4044   }
4045
4046   return true;
4047 }
4048
4049 /// \brief Return true if the mask specifies a shuffle of elements that is
4050 /// suitable for input to intralane (palignr) or interlane (valign) vector
4051 /// right-shift.
4052 static bool isAlignrMask(ArrayRef<int> Mask, MVT VT, bool InterLane) {
4053   unsigned NumElts = VT.getVectorNumElements();
4054   unsigned NumLanes = InterLane ? 1: VT.getSizeInBits()/128;
4055   unsigned NumLaneElts = NumElts/NumLanes;
4056
4057   // Do not handle 64-bit element shuffles with palignr.
4058   if (NumLaneElts == 2)
4059     return false;
4060
4061   for (unsigned l = 0; l != NumElts; l+=NumLaneElts) {
4062     unsigned i;
4063     for (i = 0; i != NumLaneElts; ++i) {
4064       if (Mask[i+l] >= 0)
4065         break;
4066     }
4067
4068     // Lane is all undef, go to next lane
4069     if (i == NumLaneElts)
4070       continue;
4071
4072     int Start = Mask[i+l];
4073
4074     // Make sure its in this lane in one of the sources
4075     if (!isUndefOrInRange(Start, l, l+NumLaneElts) &&
4076         !isUndefOrInRange(Start, l+NumElts, l+NumElts+NumLaneElts))
4077       return false;
4078
4079     // If not lane 0, then we must match lane 0
4080     if (l != 0 && Mask[i] >= 0 && !isUndefOrEqual(Start, Mask[i]+l))
4081       return false;
4082
4083     // Correct second source to be contiguous with first source
4084     if (Start >= (int)NumElts)
4085       Start -= NumElts - NumLaneElts;
4086
4087     // Make sure we're shifting in the right direction.
4088     if (Start <= (int)(i+l))
4089       return false;
4090
4091     Start -= i;
4092
4093     // Check the rest of the elements to see if they are consecutive.
4094     for (++i; i != NumLaneElts; ++i) {
4095       int Idx = Mask[i+l];
4096
4097       // Make sure its in this lane
4098       if (!isUndefOrInRange(Idx, l, l+NumLaneElts) &&
4099           !isUndefOrInRange(Idx, l+NumElts, l+NumElts+NumLaneElts))
4100         return false;
4101
4102       // If not lane 0, then we must match lane 0
4103       if (l != 0 && Mask[i] >= 0 && !isUndefOrEqual(Idx, Mask[i]+l))
4104         return false;
4105
4106       if (Idx >= (int)NumElts)
4107         Idx -= NumElts - NumLaneElts;
4108
4109       if (!isUndefOrEqual(Idx, Start+i))
4110         return false;
4111
4112     }
4113   }
4114
4115   return true;
4116 }
4117
4118 /// \brief Return true if the node specifies a shuffle of elements that is
4119 /// suitable for input to PALIGNR.
4120 static bool isPALIGNRMask(ArrayRef<int> Mask, MVT VT,
4121                           const X86Subtarget *Subtarget) {
4122   if ((VT.is128BitVector() && !Subtarget->hasSSSE3()) ||
4123       (VT.is256BitVector() && !Subtarget->hasInt256()) ||
4124       VT.is512BitVector())
4125     // FIXME: Add AVX512BW.
4126     return false;
4127
4128   return isAlignrMask(Mask, VT, false);
4129 }
4130
4131 /// \brief Return true if the node specifies a shuffle of elements that is
4132 /// suitable for input to VALIGN.
4133 static bool isVALIGNMask(ArrayRef<int> Mask, MVT VT,
4134                           const X86Subtarget *Subtarget) {
4135   // FIXME: Add AVX512VL.
4136   if (!VT.is512BitVector() || !Subtarget->hasAVX512())
4137     return false;
4138   return isAlignrMask(Mask, VT, true);
4139 }
4140
4141 /// CommuteVectorShuffleMask - Change values in a shuffle permute mask assuming
4142 /// the two vector operands have swapped position.
4143 static void CommuteVectorShuffleMask(SmallVectorImpl<int> &Mask,
4144                                      unsigned NumElems) {
4145   for (unsigned i = 0; i != NumElems; ++i) {
4146     int idx = Mask[i];
4147     if (idx < 0)
4148       continue;
4149     else if (idx < (int)NumElems)
4150       Mask[i] = idx + NumElems;
4151     else
4152       Mask[i] = idx - NumElems;
4153   }
4154 }
4155
4156 /// isSHUFPMask - Return true if the specified VECTOR_SHUFFLE operand
4157 /// specifies a shuffle of elements that is suitable for input to 128/256-bit
4158 /// SHUFPS and SHUFPD. If Commuted is true, then it checks for sources to be
4159 /// reverse of what x86 shuffles want.
4160 static bool isSHUFPMask(ArrayRef<int> Mask, MVT VT, bool Commuted = false) {
4161
4162   unsigned NumElems = VT.getVectorNumElements();
4163   unsigned NumLanes = VT.getSizeInBits()/128;
4164   unsigned NumLaneElems = NumElems/NumLanes;
4165
4166   if (NumLaneElems != 2 && NumLaneElems != 4)
4167     return false;
4168
4169   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
4170   bool symetricMaskRequired =
4171     (VT.getSizeInBits() >= 256) && (EltSize == 32);
4172
4173   // VSHUFPSY divides the resulting vector into 4 chunks.
4174   // The sources are also splitted into 4 chunks, and each destination
4175   // chunk must come from a different source chunk.
4176   //
4177   //  SRC1 =>   X7    X6    X5    X4    X3    X2    X1    X0
4178   //  SRC2 =>   Y7    Y6    Y5    Y4    Y3    Y2    Y1    Y9
4179   //
4180   //  DST  =>  Y7..Y4,   Y7..Y4,   X7..X4,   X7..X4,
4181   //           Y3..Y0,   Y3..Y0,   X3..X0,   X3..X0
4182   //
4183   // VSHUFPDY divides the resulting vector into 4 chunks.
4184   // The sources are also splitted into 4 chunks, and each destination
4185   // chunk must come from a different source chunk.
4186   //
4187   //  SRC1 =>      X3       X2       X1       X0
4188   //  SRC2 =>      Y3       Y2       Y1       Y0
4189   //
4190   //  DST  =>  Y3..Y2,  X3..X2,  Y1..Y0,  X1..X0
4191   //
4192   SmallVector<int, 4> MaskVal(NumLaneElems, -1);
4193   unsigned HalfLaneElems = NumLaneElems/2;
4194   for (unsigned l = 0; l != NumElems; l += NumLaneElems) {
4195     for (unsigned i = 0; i != NumLaneElems; ++i) {
4196       int Idx = Mask[i+l];
4197       unsigned RngStart = l + ((Commuted == (i<HalfLaneElems)) ? NumElems : 0);
4198       if (!isUndefOrInRange(Idx, RngStart, RngStart+NumLaneElems))
4199         return false;
4200       // For VSHUFPSY, the mask of the second half must be the same as the
4201       // first but with the appropriate offsets. This works in the same way as
4202       // VPERMILPS works with masks.
4203       if (!symetricMaskRequired || Idx < 0)
4204         continue;
4205       if (MaskVal[i] < 0) {
4206         MaskVal[i] = Idx - l;
4207         continue;
4208       }
4209       if ((signed)(Idx - l) != MaskVal[i])
4210         return false;
4211     }
4212   }
4213
4214   return true;
4215 }
4216
4217 /// isMOVHLPSMask - Return true if the specified VECTOR_SHUFFLE operand
4218 /// specifies a shuffle of elements that is suitable for input to MOVHLPS.
4219 static bool isMOVHLPSMask(ArrayRef<int> Mask, MVT VT) {
4220   if (!VT.is128BitVector())
4221     return false;
4222
4223   unsigned NumElems = VT.getVectorNumElements();
4224
4225   if (NumElems != 4)
4226     return false;
4227
4228   // Expect bit0 == 6, bit1 == 7, bit2 == 2, bit3 == 3
4229   return isUndefOrEqual(Mask[0], 6) &&
4230          isUndefOrEqual(Mask[1], 7) &&
4231          isUndefOrEqual(Mask[2], 2) &&
4232          isUndefOrEqual(Mask[3], 3);
4233 }
4234
4235 /// isMOVHLPS_v_undef_Mask - Special case of isMOVHLPSMask for canonical form
4236 /// of vector_shuffle v, v, <2, 3, 2, 3>, i.e. vector_shuffle v, undef,
4237 /// <2, 3, 2, 3>
4238 static bool isMOVHLPS_v_undef_Mask(ArrayRef<int> Mask, MVT VT) {
4239   if (!VT.is128BitVector())
4240     return false;
4241
4242   unsigned NumElems = VT.getVectorNumElements();
4243
4244   if (NumElems != 4)
4245     return false;
4246
4247   return isUndefOrEqual(Mask[0], 2) &&
4248          isUndefOrEqual(Mask[1], 3) &&
4249          isUndefOrEqual(Mask[2], 2) &&
4250          isUndefOrEqual(Mask[3], 3);
4251 }
4252
4253 /// isMOVLPMask - Return true if the specified VECTOR_SHUFFLE operand
4254 /// specifies a shuffle of elements that is suitable for input to MOVLP{S|D}.
4255 static bool isMOVLPMask(ArrayRef<int> Mask, MVT VT) {
4256   if (!VT.is128BitVector())
4257     return false;
4258
4259   unsigned NumElems = VT.getVectorNumElements();
4260
4261   if (NumElems != 2 && NumElems != 4)
4262     return false;
4263
4264   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4265     if (!isUndefOrEqual(Mask[i], i + NumElems))
4266       return false;
4267
4268   for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
4269     if (!isUndefOrEqual(Mask[i], i))
4270       return false;
4271
4272   return true;
4273 }
4274
4275 /// isMOVLHPSMask - Return true if the specified VECTOR_SHUFFLE operand
4276 /// specifies a shuffle of elements that is suitable for input to MOVLHPS.
4277 static bool isMOVLHPSMask(ArrayRef<int> Mask, MVT VT) {
4278   if (!VT.is128BitVector())
4279     return false;
4280
4281   unsigned NumElems = VT.getVectorNumElements();
4282
4283   if (NumElems != 2 && NumElems != 4)
4284     return false;
4285
4286   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4287     if (!isUndefOrEqual(Mask[i], i))
4288       return false;
4289
4290   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4291     if (!isUndefOrEqual(Mask[i + e], i + NumElems))
4292       return false;
4293
4294   return true;
4295 }
4296
4297 /// isINSERTPSMask - Return true if the specified VECTOR_SHUFFLE operand
4298 /// specifies a shuffle of elements that is suitable for input to INSERTPS.
4299 /// i. e: If all but one element come from the same vector.
4300 static bool isINSERTPSMask(ArrayRef<int> Mask, MVT VT) {
4301   // TODO: Deal with AVX's VINSERTPS
4302   if (!VT.is128BitVector() || (VT != MVT::v4f32 && VT != MVT::v4i32))
4303     return false;
4304
4305   unsigned CorrectPosV1 = 0;
4306   unsigned CorrectPosV2 = 0;
4307   for (int i = 0, e = (int)VT.getVectorNumElements(); i != e; ++i) {
4308     if (Mask[i] == -1) {
4309       ++CorrectPosV1;
4310       ++CorrectPosV2;
4311       continue;
4312     }
4313
4314     if (Mask[i] == i)
4315       ++CorrectPosV1;
4316     else if (Mask[i] == i + 4)
4317       ++CorrectPosV2;
4318   }
4319
4320   if (CorrectPosV1 == 3 || CorrectPosV2 == 3)
4321     // We have 3 elements (undefs count as elements from any vector) from one
4322     // vector, and one from another.
4323     return true;
4324
4325   return false;
4326 }
4327
4328 //
4329 // Some special combinations that can be optimized.
4330 //
4331 static
4332 SDValue Compact8x32ShuffleNode(ShuffleVectorSDNode *SVOp,
4333                                SelectionDAG &DAG) {
4334   MVT VT = SVOp->getSimpleValueType(0);
4335   SDLoc dl(SVOp);
4336
4337   if (VT != MVT::v8i32 && VT != MVT::v8f32)
4338     return SDValue();
4339
4340   ArrayRef<int> Mask = SVOp->getMask();
4341
4342   // These are the special masks that may be optimized.
4343   static const int MaskToOptimizeEven[] = {0, 8, 2, 10, 4, 12, 6, 14};
4344   static const int MaskToOptimizeOdd[]  = {1, 9, 3, 11, 5, 13, 7, 15};
4345   bool MatchEvenMask = true;
4346   bool MatchOddMask  = true;
4347   for (int i=0; i<8; ++i) {
4348     if (!isUndefOrEqual(Mask[i], MaskToOptimizeEven[i]))
4349       MatchEvenMask = false;
4350     if (!isUndefOrEqual(Mask[i], MaskToOptimizeOdd[i]))
4351       MatchOddMask = false;
4352   }
4353
4354   if (!MatchEvenMask && !MatchOddMask)
4355     return SDValue();
4356
4357   SDValue UndefNode = DAG.getNode(ISD::UNDEF, dl, VT);
4358
4359   SDValue Op0 = SVOp->getOperand(0);
4360   SDValue Op1 = SVOp->getOperand(1);
4361
4362   if (MatchEvenMask) {
4363     // Shift the second operand right to 32 bits.
4364     static const int ShiftRightMask[] = {-1, 0, -1, 2, -1, 4, -1, 6 };
4365     Op1 = DAG.getVectorShuffle(VT, dl, Op1, UndefNode, ShiftRightMask);
4366   } else {
4367     // Shift the first operand left to 32 bits.
4368     static const int ShiftLeftMask[] = {1, -1, 3, -1, 5, -1, 7, -1 };
4369     Op0 = DAG.getVectorShuffle(VT, dl, Op0, UndefNode, ShiftLeftMask);
4370   }
4371   static const int BlendMask[] = {0, 9, 2, 11, 4, 13, 6, 15};
4372   return DAG.getVectorShuffle(VT, dl, Op0, Op1, BlendMask);
4373 }
4374
4375 /// isUNPCKLMask - Return true if the specified VECTOR_SHUFFLE operand
4376 /// specifies a shuffle of elements that is suitable for input to UNPCKL.
4377 static bool isUNPCKLMask(ArrayRef<int> Mask, MVT VT,
4378                          bool HasInt256, bool V2IsSplat = false) {
4379
4380   assert(VT.getSizeInBits() >= 128 &&
4381          "Unsupported vector type for unpckl");
4382
4383   unsigned NumElts = VT.getVectorNumElements();
4384   if (VT.is256BitVector() && NumElts != 4 && NumElts != 8 &&
4385       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4386     return false;
4387
4388   assert((!VT.is512BitVector() || VT.getScalarType().getSizeInBits() >= 32) &&
4389          "Unsupported vector type for unpckh");
4390
4391   // AVX defines UNPCK* to operate independently on 128-bit lanes.
4392   unsigned NumLanes = VT.getSizeInBits()/128;
4393   unsigned NumLaneElts = NumElts/NumLanes;
4394
4395   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4396     for (unsigned i = 0, j = l; i != NumLaneElts; i += 2, ++j) {
4397       int BitI  = Mask[l+i];
4398       int BitI1 = Mask[l+i+1];
4399       if (!isUndefOrEqual(BitI, j))
4400         return false;
4401       if (V2IsSplat) {
4402         if (!isUndefOrEqual(BitI1, NumElts))
4403           return false;
4404       } else {
4405         if (!isUndefOrEqual(BitI1, j + NumElts))
4406           return false;
4407       }
4408     }
4409   }
4410
4411   return true;
4412 }
4413
4414 /// isUNPCKHMask - Return true if the specified VECTOR_SHUFFLE operand
4415 /// specifies a shuffle of elements that is suitable for input to UNPCKH.
4416 static bool isUNPCKHMask(ArrayRef<int> Mask, MVT VT,
4417                          bool HasInt256, bool V2IsSplat = false) {
4418   assert(VT.getSizeInBits() >= 128 &&
4419          "Unsupported vector type for unpckh");
4420
4421   unsigned NumElts = VT.getVectorNumElements();
4422   if (VT.is256BitVector() && NumElts != 4 && NumElts != 8 &&
4423       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4424     return false;
4425
4426   assert((!VT.is512BitVector() || VT.getScalarType().getSizeInBits() >= 32) &&
4427          "Unsupported vector type for unpckh");
4428
4429   // AVX defines UNPCK* to operate independently on 128-bit lanes.
4430   unsigned NumLanes = VT.getSizeInBits()/128;
4431   unsigned NumLaneElts = NumElts/NumLanes;
4432
4433   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4434     for (unsigned i = 0, j = l+NumLaneElts/2; i != NumLaneElts; i += 2, ++j) {
4435       int BitI  = Mask[l+i];
4436       int BitI1 = Mask[l+i+1];
4437       if (!isUndefOrEqual(BitI, j))
4438         return false;
4439       if (V2IsSplat) {
4440         if (isUndefOrEqual(BitI1, NumElts))
4441           return false;
4442       } else {
4443         if (!isUndefOrEqual(BitI1, j+NumElts))
4444           return false;
4445       }
4446     }
4447   }
4448   return true;
4449 }
4450
4451 /// isUNPCKL_v_undef_Mask - Special case of isUNPCKLMask for canonical form
4452 /// of vector_shuffle v, v, <0, 4, 1, 5>, i.e. vector_shuffle v, undef,
4453 /// <0, 0, 1, 1>
4454 static bool isUNPCKL_v_undef_Mask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
4455   unsigned NumElts = VT.getVectorNumElements();
4456   bool Is256BitVec = VT.is256BitVector();
4457
4458   if (VT.is512BitVector())
4459     return false;
4460   assert((VT.is128BitVector() || VT.is256BitVector()) &&
4461          "Unsupported vector type for unpckh");
4462
4463   if (Is256BitVec && NumElts != 4 && NumElts != 8 &&
4464       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4465     return false;
4466
4467   // For 256-bit i64/f64, use MOVDDUPY instead, so reject the matching pattern
4468   // FIXME: Need a better way to get rid of this, there's no latency difference
4469   // between UNPCKLPD and MOVDDUP, the later should always be checked first and
4470   // the former later. We should also remove the "_undef" special mask.
4471   if (NumElts == 4 && Is256BitVec)
4472     return false;
4473
4474   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
4475   // independently on 128-bit lanes.
4476   unsigned NumLanes = VT.getSizeInBits()/128;
4477   unsigned NumLaneElts = NumElts/NumLanes;
4478
4479   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4480     for (unsigned i = 0, j = l; i != NumLaneElts; i += 2, ++j) {
4481       int BitI  = Mask[l+i];
4482       int BitI1 = Mask[l+i+1];
4483
4484       if (!isUndefOrEqual(BitI, j))
4485         return false;
4486       if (!isUndefOrEqual(BitI1, j))
4487         return false;
4488     }
4489   }
4490
4491   return true;
4492 }
4493
4494 /// isUNPCKH_v_undef_Mask - Special case of isUNPCKHMask for canonical form
4495 /// of vector_shuffle v, v, <2, 6, 3, 7>, i.e. vector_shuffle v, undef,
4496 /// <2, 2, 3, 3>
4497 static bool isUNPCKH_v_undef_Mask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
4498   unsigned NumElts = VT.getVectorNumElements();
4499
4500   if (VT.is512BitVector())
4501     return false;
4502
4503   assert((VT.is128BitVector() || VT.is256BitVector()) &&
4504          "Unsupported vector type for unpckh");
4505
4506   if (VT.is256BitVector() && NumElts != 4 && NumElts != 8 &&
4507       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4508     return false;
4509
4510   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
4511   // independently on 128-bit lanes.
4512   unsigned NumLanes = VT.getSizeInBits()/128;
4513   unsigned NumLaneElts = NumElts/NumLanes;
4514
4515   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4516     for (unsigned i = 0, j = l+NumLaneElts/2; i != NumLaneElts; i += 2, ++j) {
4517       int BitI  = Mask[l+i];
4518       int BitI1 = Mask[l+i+1];
4519       if (!isUndefOrEqual(BitI, j))
4520         return false;
4521       if (!isUndefOrEqual(BitI1, j))
4522         return false;
4523     }
4524   }
4525   return true;
4526 }
4527
4528 // Match for INSERTI64x4 INSERTF64x4 instructions (src0[0], src1[0]) or
4529 // (src1[0], src0[1]), manipulation with 256-bit sub-vectors
4530 static bool isINSERT64x4Mask(ArrayRef<int> Mask, MVT VT, unsigned int *Imm) {
4531   if (!VT.is512BitVector())
4532     return false;
4533
4534   unsigned NumElts = VT.getVectorNumElements();
4535   unsigned HalfSize = NumElts/2;
4536   if (isSequentialOrUndefInRange(Mask, 0, HalfSize, 0)) {
4537     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, NumElts)) {
4538       *Imm = 1;
4539       return true;
4540     }
4541   }
4542   if (isSequentialOrUndefInRange(Mask, 0, HalfSize, NumElts)) {
4543     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, HalfSize)) {
4544       *Imm = 0;
4545       return true;
4546     }
4547   }
4548   return false;
4549 }
4550
4551 /// isMOVLMask - Return true if the specified VECTOR_SHUFFLE operand
4552 /// specifies a shuffle of elements that is suitable for input to MOVSS,
4553 /// MOVSD, and MOVD, i.e. setting the lowest element.
4554 static bool isMOVLMask(ArrayRef<int> Mask, EVT VT) {
4555   if (VT.getVectorElementType().getSizeInBits() < 32)
4556     return false;
4557   if (!VT.is128BitVector())
4558     return false;
4559
4560   unsigned NumElts = VT.getVectorNumElements();
4561
4562   if (!isUndefOrEqual(Mask[0], NumElts))
4563     return false;
4564
4565   for (unsigned i = 1; i != NumElts; ++i)
4566     if (!isUndefOrEqual(Mask[i], i))
4567       return false;
4568
4569   return true;
4570 }
4571
4572 /// isVPERM2X128Mask - Match 256-bit shuffles where the elements are considered
4573 /// as permutations between 128-bit chunks or halves. As an example: this
4574 /// shuffle bellow:
4575 ///   vector_shuffle <4, 5, 6, 7, 12, 13, 14, 15>
4576 /// The first half comes from the second half of V1 and the second half from the
4577 /// the second half of V2.
4578 static bool isVPERM2X128Mask(ArrayRef<int> Mask, MVT VT, bool HasFp256) {
4579   if (!HasFp256 || !VT.is256BitVector())
4580     return false;
4581
4582   // The shuffle result is divided into half A and half B. In total the two
4583   // sources have 4 halves, namely: C, D, E, F. The final values of A and
4584   // B must come from C, D, E or F.
4585   unsigned HalfSize = VT.getVectorNumElements()/2;
4586   bool MatchA = false, MatchB = false;
4587
4588   // Check if A comes from one of C, D, E, F.
4589   for (unsigned Half = 0; Half != 4; ++Half) {
4590     if (isSequentialOrUndefInRange(Mask, 0, HalfSize, Half*HalfSize)) {
4591       MatchA = true;
4592       break;
4593     }
4594   }
4595
4596   // Check if B comes from one of C, D, E, F.
4597   for (unsigned Half = 0; Half != 4; ++Half) {
4598     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, Half*HalfSize)) {
4599       MatchB = true;
4600       break;
4601     }
4602   }
4603
4604   return MatchA && MatchB;
4605 }
4606
4607 /// getShuffleVPERM2X128Immediate - Return the appropriate immediate to shuffle
4608 /// the specified VECTOR_MASK mask with VPERM2F128/VPERM2I128 instructions.
4609 static unsigned getShuffleVPERM2X128Immediate(ShuffleVectorSDNode *SVOp) {
4610   MVT VT = SVOp->getSimpleValueType(0);
4611
4612   unsigned HalfSize = VT.getVectorNumElements()/2;
4613
4614   unsigned FstHalf = 0, SndHalf = 0;
4615   for (unsigned i = 0; i < HalfSize; ++i) {
4616     if (SVOp->getMaskElt(i) > 0) {
4617       FstHalf = SVOp->getMaskElt(i)/HalfSize;
4618       break;
4619     }
4620   }
4621   for (unsigned i = HalfSize; i < HalfSize*2; ++i) {
4622     if (SVOp->getMaskElt(i) > 0) {
4623       SndHalf = SVOp->getMaskElt(i)/HalfSize;
4624       break;
4625     }
4626   }
4627
4628   return (FstHalf | (SndHalf << 4));
4629 }
4630
4631 // Symetric in-lane mask. Each lane has 4 elements (for imm8)
4632 static bool isPermImmMask(ArrayRef<int> Mask, MVT VT, unsigned& Imm8) {
4633   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
4634   if (EltSize < 32)
4635     return false;
4636
4637   unsigned NumElts = VT.getVectorNumElements();
4638   Imm8 = 0;
4639   if (VT.is128BitVector() || (VT.is256BitVector() && EltSize == 64)) {
4640     for (unsigned i = 0; i != NumElts; ++i) {
4641       if (Mask[i] < 0)
4642         continue;
4643       Imm8 |= Mask[i] << (i*2);
4644     }
4645     return true;
4646   }
4647
4648   unsigned LaneSize = 4;
4649   SmallVector<int, 4> MaskVal(LaneSize, -1);
4650
4651   for (unsigned l = 0; l != NumElts; l += LaneSize) {
4652     for (unsigned i = 0; i != LaneSize; ++i) {
4653       if (!isUndefOrInRange(Mask[i+l], l, l+LaneSize))
4654         return false;
4655       if (Mask[i+l] < 0)
4656         continue;
4657       if (MaskVal[i] < 0) {
4658         MaskVal[i] = Mask[i+l] - l;
4659         Imm8 |= MaskVal[i] << (i*2);
4660         continue;
4661       }
4662       if (Mask[i+l] != (signed)(MaskVal[i]+l))
4663         return false;
4664     }
4665   }
4666   return true;
4667 }
4668
4669 /// isVPERMILPMask - Return true if the specified VECTOR_SHUFFLE operand
4670 /// specifies a shuffle of elements that is suitable for input to VPERMILPD*.
4671 /// Note that VPERMIL mask matching is different depending whether theunderlying
4672 /// type is 32 or 64. In the VPERMILPS the high half of the mask should point
4673 /// to the same elements of the low, but to the higher half of the source.
4674 /// In VPERMILPD the two lanes could be shuffled independently of each other
4675 /// with the same restriction that lanes can't be crossed. Also handles PSHUFDY.
4676 static bool isVPERMILPMask(ArrayRef<int> Mask, MVT VT) {
4677   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
4678   if (VT.getSizeInBits() < 256 || EltSize < 32)
4679     return false;
4680   bool symetricMaskRequired = (EltSize == 32);
4681   unsigned NumElts = VT.getVectorNumElements();
4682
4683   unsigned NumLanes = VT.getSizeInBits()/128;
4684   unsigned LaneSize = NumElts/NumLanes;
4685   // 2 or 4 elements in one lane
4686
4687   SmallVector<int, 4> ExpectedMaskVal(LaneSize, -1);
4688   for (unsigned l = 0; l != NumElts; l += LaneSize) {
4689     for (unsigned i = 0; i != LaneSize; ++i) {
4690       if (!isUndefOrInRange(Mask[i+l], l, l+LaneSize))
4691         return false;
4692       if (symetricMaskRequired) {
4693         if (ExpectedMaskVal[i] < 0 && Mask[i+l] >= 0) {
4694           ExpectedMaskVal[i] = Mask[i+l] - l;
4695           continue;
4696         }
4697         if (!isUndefOrEqual(Mask[i+l], ExpectedMaskVal[i]+l))
4698           return false;
4699       }
4700     }
4701   }
4702   return true;
4703 }
4704
4705 /// isCommutedMOVLMask - Returns true if the shuffle mask is except the reverse
4706 /// of what x86 movss want. X86 movs requires the lowest  element to be lowest
4707 /// element of vector 2 and the other elements to come from vector 1 in order.
4708 static bool isCommutedMOVLMask(ArrayRef<int> Mask, MVT VT,
4709                                bool V2IsSplat = false, bool V2IsUndef = false) {
4710   if (!VT.is128BitVector())
4711     return false;
4712
4713   unsigned NumOps = VT.getVectorNumElements();
4714   if (NumOps != 2 && NumOps != 4 && NumOps != 8 && NumOps != 16)
4715     return false;
4716
4717   if (!isUndefOrEqual(Mask[0], 0))
4718     return false;
4719
4720   for (unsigned i = 1; i != NumOps; ++i)
4721     if (!(isUndefOrEqual(Mask[i], i+NumOps) ||
4722           (V2IsUndef && isUndefOrInRange(Mask[i], NumOps, NumOps*2)) ||
4723           (V2IsSplat && isUndefOrEqual(Mask[i], NumOps))))
4724       return false;
4725
4726   return true;
4727 }
4728
4729 /// isMOVSHDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4730 /// specifies a shuffle of elements that is suitable for input to MOVSHDUP.
4731 /// Masks to match: <1, 1, 3, 3> or <1, 1, 3, 3, 5, 5, 7, 7>
4732 static bool isMOVSHDUPMask(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+1" is the value the indexed mask element must have
4745   for (unsigned i = 0; i != NumElems; i += 2)
4746     if (!isUndefOrEqual(Mask[i], i+1) ||
4747         !isUndefOrEqual(Mask[i+1], i+1))
4748       return false;
4749
4750   return true;
4751 }
4752
4753 /// isMOVSLDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4754 /// specifies a shuffle of elements that is suitable for input to MOVSLDUP.
4755 /// Masks to match: <0, 0, 2, 2> or <0, 0, 2, 2, 4, 4, 6, 6>
4756 static bool isMOVSLDUPMask(ArrayRef<int> Mask, MVT VT,
4757                            const X86Subtarget *Subtarget) {
4758   if (!Subtarget->hasSSE3())
4759     return false;
4760
4761   unsigned NumElems = VT.getVectorNumElements();
4762
4763   if ((VT.is128BitVector() && NumElems != 4) ||
4764       (VT.is256BitVector() && NumElems != 8) ||
4765       (VT.is512BitVector() && NumElems != 16))
4766     return false;
4767
4768   // "i" is the value the indexed mask element must have
4769   for (unsigned i = 0; i != NumElems; i += 2)
4770     if (!isUndefOrEqual(Mask[i], i) ||
4771         !isUndefOrEqual(Mask[i+1], i))
4772       return false;
4773
4774   return true;
4775 }
4776
4777 /// isMOVDDUPYMask - Return true if the specified VECTOR_SHUFFLE operand
4778 /// specifies a shuffle of elements that is suitable for input to 256-bit
4779 /// version of MOVDDUP.
4780 static bool isMOVDDUPYMask(ArrayRef<int> Mask, MVT VT, bool HasFp256) {
4781   if (!HasFp256 || !VT.is256BitVector())
4782     return false;
4783
4784   unsigned NumElts = VT.getVectorNumElements();
4785   if (NumElts != 4)
4786     return false;
4787
4788   for (unsigned i = 0; i != NumElts/2; ++i)
4789     if (!isUndefOrEqual(Mask[i], 0))
4790       return false;
4791   for (unsigned i = NumElts/2; i != NumElts; ++i)
4792     if (!isUndefOrEqual(Mask[i], NumElts/2))
4793       return false;
4794   return true;
4795 }
4796
4797 /// isMOVDDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4798 /// specifies a shuffle of elements that is suitable for input to 128-bit
4799 /// version of MOVDDUP.
4800 static bool isMOVDDUPMask(ArrayRef<int> Mask, MVT VT) {
4801   if (!VT.is128BitVector())
4802     return false;
4803
4804   unsigned e = VT.getVectorNumElements() / 2;
4805   for (unsigned i = 0; i != e; ++i)
4806     if (!isUndefOrEqual(Mask[i], i))
4807       return false;
4808   for (unsigned i = 0; i != e; ++i)
4809     if (!isUndefOrEqual(Mask[e+i], i))
4810       return false;
4811   return true;
4812 }
4813
4814 /// isVEXTRACTIndex - Return true if the specified
4815 /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
4816 /// suitable for instruction that extract 128 or 256 bit vectors
4817 static bool isVEXTRACTIndex(SDNode *N, unsigned vecWidth) {
4818   assert((vecWidth == 128 || vecWidth == 256) && "Unexpected vector width");
4819   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4820     return false;
4821
4822   // The index should be aligned on a vecWidth-bit boundary.
4823   uint64_t Index =
4824     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4825
4826   MVT VT = N->getSimpleValueType(0);
4827   unsigned ElSize = VT.getVectorElementType().getSizeInBits();
4828   bool Result = (Index * ElSize) % vecWidth == 0;
4829
4830   return Result;
4831 }
4832
4833 /// isVINSERTIndex - Return true if the specified INSERT_SUBVECTOR
4834 /// operand specifies a subvector insert that is suitable for input to
4835 /// insertion of 128 or 256-bit subvectors
4836 static bool isVINSERTIndex(SDNode *N, unsigned vecWidth) {
4837   assert((vecWidth == 128 || vecWidth == 256) && "Unexpected vector width");
4838   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4839     return false;
4840   // The index should be aligned on a vecWidth-bit boundary.
4841   uint64_t Index =
4842     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4843
4844   MVT VT = N->getSimpleValueType(0);
4845   unsigned ElSize = VT.getVectorElementType().getSizeInBits();
4846   bool Result = (Index * ElSize) % vecWidth == 0;
4847
4848   return Result;
4849 }
4850
4851 bool X86::isVINSERT128Index(SDNode *N) {
4852   return isVINSERTIndex(N, 128);
4853 }
4854
4855 bool X86::isVINSERT256Index(SDNode *N) {
4856   return isVINSERTIndex(N, 256);
4857 }
4858
4859 bool X86::isVEXTRACT128Index(SDNode *N) {
4860   return isVEXTRACTIndex(N, 128);
4861 }
4862
4863 bool X86::isVEXTRACT256Index(SDNode *N) {
4864   return isVEXTRACTIndex(N, 256);
4865 }
4866
4867 /// getShuffleSHUFImmediate - Return the appropriate immediate to shuffle
4868 /// the specified VECTOR_SHUFFLE mask with PSHUF* and SHUFP* instructions.
4869 /// Handles 128-bit and 256-bit.
4870 static unsigned getShuffleSHUFImmediate(ShuffleVectorSDNode *N) {
4871   MVT VT = N->getSimpleValueType(0);
4872
4873   assert((VT.getSizeInBits() >= 128) &&
4874          "Unsupported vector type for PSHUF/SHUFP");
4875
4876   // Handle 128 and 256-bit vector lengths. AVX defines PSHUF/SHUFP to operate
4877   // independently on 128-bit lanes.
4878   unsigned NumElts = VT.getVectorNumElements();
4879   unsigned NumLanes = VT.getSizeInBits()/128;
4880   unsigned NumLaneElts = NumElts/NumLanes;
4881
4882   assert((NumLaneElts == 2 || NumLaneElts == 4 || NumLaneElts == 8) &&
4883          "Only supports 2, 4 or 8 elements per lane");
4884
4885   unsigned Shift = (NumLaneElts >= 4) ? 1 : 0;
4886   unsigned Mask = 0;
4887   for (unsigned i = 0; i != NumElts; ++i) {
4888     int Elt = N->getMaskElt(i);
4889     if (Elt < 0) continue;
4890     Elt &= NumLaneElts - 1;
4891     unsigned ShAmt = (i << Shift) % 8;
4892     Mask |= Elt << ShAmt;
4893   }
4894
4895   return Mask;
4896 }
4897
4898 /// getShufflePSHUFHWImmediate - Return the appropriate immediate to shuffle
4899 /// the specified VECTOR_SHUFFLE mask with the PSHUFHW instruction.
4900 static unsigned getShufflePSHUFHWImmediate(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 last 4.
4911     for (unsigned i = 0; i < 4; ++i) {
4912       int Elt = N->getMaskElt(l+i+4);
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 /// getShufflePSHUFLWImmediate - Return the appropriate immediate to shuffle
4923 /// the specified VECTOR_SHUFFLE mask with the PSHUFLW instruction.
4924 static unsigned getShufflePSHUFLWImmediate(ShuffleVectorSDNode *N) {
4925   MVT VT = N->getSimpleValueType(0);
4926
4927   assert((VT == MVT::v8i16 || VT == MVT::v16i16) &&
4928          "Unsupported vector type for PSHUFHW");
4929
4930   unsigned NumElts = VT.getVectorNumElements();
4931
4932   unsigned Mask = 0;
4933   for (unsigned l = 0; l != NumElts; l += 8) {
4934     // 8 nodes per lane, but we only care about the first 4.
4935     for (unsigned i = 0; i < 4; ++i) {
4936       int Elt = N->getMaskElt(l+i);
4937       if (Elt < 0) continue;
4938       Elt &= 0x3; // only 2-bits
4939       Mask |= Elt << (i * 2);
4940     }
4941   }
4942
4943   return Mask;
4944 }
4945
4946 /// \brief Return the appropriate immediate to shuffle the specified
4947 /// VECTOR_SHUFFLE mask with the PALIGNR (if InterLane is false) or with
4948 /// VALIGN (if Interlane is true) instructions.
4949 static unsigned getShuffleAlignrImmediate(ShuffleVectorSDNode *SVOp,
4950                                            bool InterLane) {
4951   MVT VT = SVOp->getSimpleValueType(0);
4952   unsigned EltSize = InterLane ? 1 :
4953     VT.getVectorElementType().getSizeInBits() >> 3;
4954
4955   unsigned NumElts = VT.getVectorNumElements();
4956   unsigned NumLanes = VT.is512BitVector() ? 1 : VT.getSizeInBits()/128;
4957   unsigned NumLaneElts = NumElts/NumLanes;
4958
4959   int Val = 0;
4960   unsigned i;
4961   for (i = 0; i != NumElts; ++i) {
4962     Val = SVOp->getMaskElt(i);
4963     if (Val >= 0)
4964       break;
4965   }
4966   if (Val >= (int)NumElts)
4967     Val -= NumElts - NumLaneElts;
4968
4969   assert(Val - i > 0 && "PALIGNR imm should be positive");
4970   return (Val - i) * EltSize;
4971 }
4972
4973 /// \brief Return the appropriate immediate to shuffle the specified
4974 /// VECTOR_SHUFFLE mask with the PALIGNR instruction.
4975 static unsigned getShufflePALIGNRImmediate(ShuffleVectorSDNode *SVOp) {
4976   return getShuffleAlignrImmediate(SVOp, false);
4977 }
4978
4979 /// \brief Return the appropriate immediate to shuffle the specified
4980 /// VECTOR_SHUFFLE mask with the VALIGN instruction.
4981 static unsigned getShuffleVALIGNImmediate(ShuffleVectorSDNode *SVOp) {
4982   return getShuffleAlignrImmediate(SVOp, true);
4983 }
4984
4985
4986 static unsigned getExtractVEXTRACTImmediate(SDNode *N, unsigned vecWidth) {
4987   assert((vecWidth == 128 || vecWidth == 256) && "Unsupported vector width");
4988   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4989     llvm_unreachable("Illegal extract subvector for VEXTRACT");
4990
4991   uint64_t Index =
4992     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4993
4994   MVT VecVT = N->getOperand(0).getSimpleValueType();
4995   MVT ElVT = VecVT.getVectorElementType();
4996
4997   unsigned NumElemsPerChunk = vecWidth / ElVT.getSizeInBits();
4998   return Index / NumElemsPerChunk;
4999 }
5000
5001 static unsigned getInsertVINSERTImmediate(SDNode *N, unsigned vecWidth) {
5002   assert((vecWidth == 128 || vecWidth == 256) && "Unsupported vector width");
5003   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
5004     llvm_unreachable("Illegal insert subvector for VINSERT");
5005
5006   uint64_t Index =
5007     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
5008
5009   MVT VecVT = N->getSimpleValueType(0);
5010   MVT ElVT = VecVT.getVectorElementType();
5011
5012   unsigned NumElemsPerChunk = vecWidth / ElVT.getSizeInBits();
5013   return Index / NumElemsPerChunk;
5014 }
5015
5016 /// getExtractVEXTRACT128Immediate - Return the appropriate immediate
5017 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF128
5018 /// and VINSERTI128 instructions.
5019 unsigned X86::getExtractVEXTRACT128Immediate(SDNode *N) {
5020   return getExtractVEXTRACTImmediate(N, 128);
5021 }
5022
5023 /// getExtractVEXTRACT256Immediate - Return the appropriate immediate
5024 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF64x4
5025 /// and VINSERTI64x4 instructions.
5026 unsigned X86::getExtractVEXTRACT256Immediate(SDNode *N) {
5027   return getExtractVEXTRACTImmediate(N, 256);
5028 }
5029
5030 /// getInsertVINSERT128Immediate - Return the appropriate immediate
5031 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF128
5032 /// and VINSERTI128 instructions.
5033 unsigned X86::getInsertVINSERT128Immediate(SDNode *N) {
5034   return getInsertVINSERTImmediate(N, 128);
5035 }
5036
5037 /// getInsertVINSERT256Immediate - Return the appropriate immediate
5038 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF46x4
5039 /// and VINSERTI64x4 instructions.
5040 unsigned X86::getInsertVINSERT256Immediate(SDNode *N) {
5041   return getInsertVINSERTImmediate(N, 256);
5042 }
5043
5044 /// isZero - Returns true if Elt is a constant integer zero
5045 static bool isZero(SDValue V) {
5046   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
5047   return C && C->isNullValue();
5048 }
5049
5050 /// isZeroNode - Returns true if Elt is a constant zero or a floating point
5051 /// constant +0.0.
5052 bool X86::isZeroNode(SDValue Elt) {
5053   if (isZero(Elt))
5054     return true;
5055   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Elt))
5056     return CFP->getValueAPF().isPosZero();
5057   return false;
5058 }
5059
5060 /// ShouldXformToMOVHLPS - Return true if the node should be transformed to
5061 /// match movhlps. The lower half elements should come from upper half of
5062 /// V1 (and in order), and the upper half elements should come from the upper
5063 /// half of V2 (and in order).
5064 static bool ShouldXformToMOVHLPS(ArrayRef<int> Mask, MVT VT) {
5065   if (!VT.is128BitVector())
5066     return false;
5067   if (VT.getVectorNumElements() != 4)
5068     return false;
5069   for (unsigned i = 0, e = 2; i != e; ++i)
5070     if (!isUndefOrEqual(Mask[i], i+2))
5071       return false;
5072   for (unsigned i = 2; i != 4; ++i)
5073     if (!isUndefOrEqual(Mask[i], i+4))
5074       return false;
5075   return true;
5076 }
5077
5078 /// isScalarLoadToVector - Returns true if the node is a scalar load that
5079 /// is promoted to a vector. It also returns the LoadSDNode by reference if
5080 /// required.
5081 static bool isScalarLoadToVector(SDNode *N, LoadSDNode **LD = nullptr) {
5082   if (N->getOpcode() != ISD::SCALAR_TO_VECTOR)
5083     return false;
5084   N = N->getOperand(0).getNode();
5085   if (!ISD::isNON_EXTLoad(N))
5086     return false;
5087   if (LD)
5088     *LD = cast<LoadSDNode>(N);
5089   return true;
5090 }
5091
5092 // Test whether the given value is a vector value which will be legalized
5093 // into a load.
5094 static bool WillBeConstantPoolLoad(SDNode *N) {
5095   if (N->getOpcode() != ISD::BUILD_VECTOR)
5096     return false;
5097
5098   // Check for any non-constant elements.
5099   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
5100     switch (N->getOperand(i).getNode()->getOpcode()) {
5101     case ISD::UNDEF:
5102     case ISD::ConstantFP:
5103     case ISD::Constant:
5104       break;
5105     default:
5106       return false;
5107     }
5108
5109   // Vectors of all-zeros and all-ones are materialized with special
5110   // instructions rather than being loaded.
5111   return !ISD::isBuildVectorAllZeros(N) &&
5112          !ISD::isBuildVectorAllOnes(N);
5113 }
5114
5115 /// ShouldXformToMOVLP{S|D} - Return true if the node should be transformed to
5116 /// match movlp{s|d}. The lower half elements should come from lower half of
5117 /// V1 (and in order), and the upper half elements should come from the upper
5118 /// half of V2 (and in order). And since V1 will become the source of the
5119 /// MOVLP, it must be either a vector load or a scalar load to vector.
5120 static bool ShouldXformToMOVLP(SDNode *V1, SDNode *V2,
5121                                ArrayRef<int> Mask, MVT VT) {
5122   if (!VT.is128BitVector())
5123     return false;
5124
5125   if (!ISD::isNON_EXTLoad(V1) && !isScalarLoadToVector(V1))
5126     return false;
5127   // Is V2 is a vector load, don't do this transformation. We will try to use
5128   // load folding shufps op.
5129   if (ISD::isNON_EXTLoad(V2) || WillBeConstantPoolLoad(V2))
5130     return false;
5131
5132   unsigned NumElems = VT.getVectorNumElements();
5133
5134   if (NumElems != 2 && NumElems != 4)
5135     return false;
5136   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
5137     if (!isUndefOrEqual(Mask[i], i))
5138       return false;
5139   for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
5140     if (!isUndefOrEqual(Mask[i], i+NumElems))
5141       return false;
5142   return true;
5143 }
5144
5145 /// isZeroShuffle - Returns true if N is a VECTOR_SHUFFLE that can be resolved
5146 /// to an zero vector.
5147 /// FIXME: move to dag combiner / method on ShuffleVectorSDNode
5148 static bool isZeroShuffle(ShuffleVectorSDNode *N) {
5149   SDValue V1 = N->getOperand(0);
5150   SDValue V2 = N->getOperand(1);
5151   unsigned NumElems = N->getValueType(0).getVectorNumElements();
5152   for (unsigned i = 0; i != NumElems; ++i) {
5153     int Idx = N->getMaskElt(i);
5154     if (Idx >= (int)NumElems) {
5155       unsigned Opc = V2.getOpcode();
5156       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V2.getNode()))
5157         continue;
5158       if (Opc != ISD::BUILD_VECTOR ||
5159           !X86::isZeroNode(V2.getOperand(Idx-NumElems)))
5160         return false;
5161     } else if (Idx >= 0) {
5162       unsigned Opc = V1.getOpcode();
5163       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V1.getNode()))
5164         continue;
5165       if (Opc != ISD::BUILD_VECTOR ||
5166           !X86::isZeroNode(V1.getOperand(Idx)))
5167         return false;
5168     }
5169   }
5170   return true;
5171 }
5172
5173 /// getZeroVector - Returns a vector of specified type with all zero elements.
5174 ///
5175 static SDValue getZeroVector(EVT VT, const X86Subtarget *Subtarget,
5176                              SelectionDAG &DAG, SDLoc dl) {
5177   assert(VT.isVector() && "Expected a vector type");
5178
5179   // Always build SSE zero vectors as <4 x i32> bitcasted
5180   // to their dest type. This ensures they get CSE'd.
5181   SDValue Vec;
5182   if (VT.is128BitVector()) {  // SSE
5183     if (Subtarget->hasSSE2()) {  // SSE2
5184       SDValue Cst = DAG.getConstant(0, MVT::i32);
5185       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
5186     } else { // SSE1
5187       SDValue Cst = DAG.getConstantFP(+0.0, MVT::f32);
5188       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4f32, Cst, Cst, Cst, Cst);
5189     }
5190   } else if (VT.is256BitVector()) { // AVX
5191     if (Subtarget->hasInt256()) { // AVX2
5192       SDValue Cst = DAG.getConstant(0, MVT::i32);
5193       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5194       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops);
5195     } else {
5196       // 256-bit logic and arithmetic instructions in AVX are all
5197       // floating-point, no support for integer ops. Emit fp zeroed vectors.
5198       SDValue Cst = DAG.getConstantFP(+0.0, MVT::f32);
5199       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5200       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8f32, Ops);
5201     }
5202   } else if (VT.is512BitVector()) { // AVX-512
5203       SDValue Cst = DAG.getConstant(0, MVT::i32);
5204       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst,
5205                         Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5206       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v16i32, Ops);
5207   } else if (VT.getScalarType() == MVT::i1) {
5208     assert(VT.getVectorNumElements() <= 16 && "Unexpected vector type");
5209     SDValue Cst = DAG.getConstant(0, MVT::i1);
5210     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Cst);
5211     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
5212   } else
5213     llvm_unreachable("Unexpected vector type");
5214
5215   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
5216 }
5217
5218 /// getOnesVector - Returns a vector of specified type with all bits set.
5219 /// Always build ones vectors as <4 x i32> or <8 x i32>. For 256-bit types with
5220 /// no AVX2 supprt, use two <4 x i32> inserted in a <8 x i32> appropriately.
5221 /// Then bitcast to their original type, ensuring they get CSE'd.
5222 static SDValue getOnesVector(MVT VT, bool HasInt256, SelectionDAG &DAG,
5223                              SDLoc dl) {
5224   assert(VT.isVector() && "Expected a vector type");
5225
5226   SDValue Cst = DAG.getConstant(~0U, MVT::i32);
5227   SDValue Vec;
5228   if (VT.is256BitVector()) {
5229     if (HasInt256) { // AVX2
5230       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5231       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops);
5232     } else { // AVX
5233       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
5234       Vec = Concat128BitVectors(Vec, Vec, MVT::v8i32, 8, DAG, dl);
5235     }
5236   } else if (VT.is128BitVector()) {
5237     Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
5238   } else
5239     llvm_unreachable("Unexpected vector type");
5240
5241   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
5242 }
5243
5244 /// NormalizeMask - V2 is a splat, modify the mask (if needed) so all elements
5245 /// that point to V2 points to its first element.
5246 static void NormalizeMask(SmallVectorImpl<int> &Mask, unsigned NumElems) {
5247   for (unsigned i = 0; i != NumElems; ++i) {
5248     if (Mask[i] > (int)NumElems) {
5249       Mask[i] = NumElems;
5250     }
5251   }
5252 }
5253
5254 /// getMOVLMask - Returns a vector_shuffle mask for an movs{s|d}, movd
5255 /// operation of specified width.
5256 static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1,
5257                        SDValue V2) {
5258   unsigned NumElems = VT.getVectorNumElements();
5259   SmallVector<int, 8> Mask;
5260   Mask.push_back(NumElems);
5261   for (unsigned i = 1; i != NumElems; ++i)
5262     Mask.push_back(i);
5263   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
5264 }
5265
5266 /// getUnpackl - Returns a vector_shuffle node for an unpackl operation.
5267 static SDValue getUnpackl(SelectionDAG &DAG, SDLoc dl, MVT VT, SDValue V1,
5268                           SDValue V2) {
5269   unsigned NumElems = VT.getVectorNumElements();
5270   SmallVector<int, 8> Mask;
5271   for (unsigned i = 0, e = NumElems/2; i != e; ++i) {
5272     Mask.push_back(i);
5273     Mask.push_back(i + NumElems);
5274   }
5275   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
5276 }
5277
5278 /// getUnpackh - Returns a vector_shuffle node for an unpackh operation.
5279 static SDValue getUnpackh(SelectionDAG &DAG, SDLoc dl, MVT VT, SDValue V1,
5280                           SDValue V2) {
5281   unsigned NumElems = VT.getVectorNumElements();
5282   SmallVector<int, 8> Mask;
5283   for (unsigned i = 0, Half = NumElems/2; i != Half; ++i) {
5284     Mask.push_back(i + Half);
5285     Mask.push_back(i + NumElems + Half);
5286   }
5287   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
5288 }
5289
5290 // PromoteSplati8i16 - All i16 and i8 vector types can't be used directly by
5291 // a generic shuffle instruction because the target has no such instructions.
5292 // Generate shuffles which repeat i16 and i8 several times until they can be
5293 // represented by v4f32 and then be manipulated by target suported shuffles.
5294 static SDValue PromoteSplati8i16(SDValue V, SelectionDAG &DAG, int &EltNo) {
5295   MVT VT = V.getSimpleValueType();
5296   int NumElems = VT.getVectorNumElements();
5297   SDLoc dl(V);
5298
5299   while (NumElems > 4) {
5300     if (EltNo < NumElems/2) {
5301       V = getUnpackl(DAG, dl, VT, V, V);
5302     } else {
5303       V = getUnpackh(DAG, dl, VT, V, V);
5304       EltNo -= NumElems/2;
5305     }
5306     NumElems >>= 1;
5307   }
5308   return V;
5309 }
5310
5311 /// getLegalSplat - Generate a legal splat with supported x86 shuffles
5312 static SDValue getLegalSplat(SelectionDAG &DAG, SDValue V, int EltNo) {
5313   MVT VT = V.getSimpleValueType();
5314   SDLoc dl(V);
5315
5316   if (VT.is128BitVector()) {
5317     V = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V);
5318     int SplatMask[4] = { EltNo, EltNo, EltNo, EltNo };
5319     V = DAG.getVectorShuffle(MVT::v4f32, dl, V, DAG.getUNDEF(MVT::v4f32),
5320                              &SplatMask[0]);
5321   } else if (VT.is256BitVector()) {
5322     // To use VPERMILPS to splat scalars, the second half of indicies must
5323     // refer to the higher part, which is a duplication of the lower one,
5324     // because VPERMILPS can only handle in-lane permutations.
5325     int SplatMask[8] = { EltNo, EltNo, EltNo, EltNo,
5326                          EltNo+4, EltNo+4, EltNo+4, EltNo+4 };
5327
5328     V = DAG.getNode(ISD::BITCAST, dl, MVT::v8f32, V);
5329     V = DAG.getVectorShuffle(MVT::v8f32, dl, V, DAG.getUNDEF(MVT::v8f32),
5330                              &SplatMask[0]);
5331   } else
5332     llvm_unreachable("Vector size not supported");
5333
5334   return DAG.getNode(ISD::BITCAST, dl, VT, V);
5335 }
5336
5337 /// PromoteSplat - Splat is promoted to target supported vector shuffles.
5338 static SDValue PromoteSplat(ShuffleVectorSDNode *SV, SelectionDAG &DAG) {
5339   MVT SrcVT = SV->getSimpleValueType(0);
5340   SDValue V1 = SV->getOperand(0);
5341   SDLoc dl(SV);
5342
5343   int EltNo = SV->getSplatIndex();
5344   int NumElems = SrcVT.getVectorNumElements();
5345   bool Is256BitVec = SrcVT.is256BitVector();
5346
5347   assert(((SrcVT.is128BitVector() && NumElems > 4) || Is256BitVec) &&
5348          "Unknown how to promote splat for type");
5349
5350   // Extract the 128-bit part containing the splat element and update
5351   // the splat element index when it refers to the higher register.
5352   if (Is256BitVec) {
5353     V1 = Extract128BitVector(V1, EltNo, DAG, dl);
5354     if (EltNo >= NumElems/2)
5355       EltNo -= NumElems/2;
5356   }
5357
5358   // All i16 and i8 vector types can't be used directly by a generic shuffle
5359   // instruction because the target has no such instruction. Generate shuffles
5360   // which repeat i16 and i8 several times until they fit in i32, and then can
5361   // be manipulated by target suported shuffles.
5362   MVT EltVT = SrcVT.getVectorElementType();
5363   if (EltVT == MVT::i8 || EltVT == MVT::i16)
5364     V1 = PromoteSplati8i16(V1, DAG, EltNo);
5365
5366   // Recreate the 256-bit vector and place the same 128-bit vector
5367   // into the low and high part. This is necessary because we want
5368   // to use VPERM* to shuffle the vectors
5369   if (Is256BitVec) {
5370     V1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, SrcVT, V1, V1);
5371   }
5372
5373   return getLegalSplat(DAG, V1, EltNo);
5374 }
5375
5376 /// getShuffleVectorZeroOrUndef - Return a vector_shuffle of the specified
5377 /// vector of zero or undef vector.  This produces a shuffle where the low
5378 /// element of V2 is swizzled into the zero/undef vector, landing at element
5379 /// Idx.  This produces a shuffle mask like 4,1,2,3 (idx=0) or  0,1,2,4 (idx=3).
5380 static SDValue getShuffleVectorZeroOrUndef(SDValue V2, unsigned Idx,
5381                                            bool IsZero,
5382                                            const X86Subtarget *Subtarget,
5383                                            SelectionDAG &DAG) {
5384   MVT VT = V2.getSimpleValueType();
5385   SDValue V1 = IsZero
5386     ? getZeroVector(VT, Subtarget, DAG, SDLoc(V2)) : DAG.getUNDEF(VT);
5387   unsigned NumElems = VT.getVectorNumElements();
5388   SmallVector<int, 16> MaskVec;
5389   for (unsigned i = 0; i != NumElems; ++i)
5390     // If this is the insertion idx, put the low elt of V2 here.
5391     MaskVec.push_back(i == Idx ? NumElems : i);
5392   return DAG.getVectorShuffle(VT, SDLoc(V2), V1, V2, &MaskVec[0]);
5393 }
5394
5395 /// getTargetShuffleMask - Calculates the shuffle mask corresponding to the
5396 /// target specific opcode. Returns true if the Mask could be calculated. Sets
5397 /// IsUnary to true if only uses one source. Note that this will set IsUnary for
5398 /// shuffles which use a single input multiple times, and in those cases it will
5399 /// adjust the mask to only have indices within that single input.
5400 static bool getTargetShuffleMask(SDNode *N, MVT VT,
5401                                  SmallVectorImpl<int> &Mask, bool &IsUnary) {
5402   unsigned NumElems = VT.getVectorNumElements();
5403   SDValue ImmN;
5404
5405   IsUnary = false;
5406   bool IsFakeUnary = false;
5407   switch(N->getOpcode()) {
5408   case X86ISD::BLENDI:
5409     ImmN = N->getOperand(N->getNumOperands()-1);
5410     DecodeBLENDMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5411     break;
5412   case X86ISD::SHUFP:
5413     ImmN = N->getOperand(N->getNumOperands()-1);
5414     DecodeSHUFPMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5415     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5416     break;
5417   case X86ISD::UNPCKH:
5418     DecodeUNPCKHMask(VT, Mask);
5419     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5420     break;
5421   case X86ISD::UNPCKL:
5422     DecodeUNPCKLMask(VT, Mask);
5423     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5424     break;
5425   case X86ISD::MOVHLPS:
5426     DecodeMOVHLPSMask(NumElems, Mask);
5427     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5428     break;
5429   case X86ISD::MOVLHPS:
5430     DecodeMOVLHPSMask(NumElems, Mask);
5431     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
5432     break;
5433   case X86ISD::PALIGNR:
5434     ImmN = N->getOperand(N->getNumOperands()-1);
5435     DecodePALIGNRMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5436     break;
5437   case X86ISD::PSHUFD:
5438   case X86ISD::VPERMILPI:
5439     ImmN = N->getOperand(N->getNumOperands()-1);
5440     DecodePSHUFMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5441     IsUnary = true;
5442     break;
5443   case X86ISD::PSHUFHW:
5444     ImmN = N->getOperand(N->getNumOperands()-1);
5445     DecodePSHUFHWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5446     IsUnary = true;
5447     break;
5448   case X86ISD::PSHUFLW:
5449     ImmN = N->getOperand(N->getNumOperands()-1);
5450     DecodePSHUFLWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5451     IsUnary = true;
5452     break;
5453   case X86ISD::PSHUFB: {
5454     IsUnary = true;
5455     SDValue MaskNode = N->getOperand(1);
5456     while (MaskNode->getOpcode() == ISD::BITCAST)
5457       MaskNode = MaskNode->getOperand(0);
5458
5459     if (MaskNode->getOpcode() == ISD::BUILD_VECTOR) {
5460       // If we have a build-vector, then things are easy.
5461       EVT VT = MaskNode.getValueType();
5462       assert(VT.isVector() &&
5463              "Can't produce a non-vector with a build_vector!");
5464       if (!VT.isInteger())
5465         return false;
5466
5467       int NumBytesPerElement = VT.getVectorElementType().getSizeInBits() / 8;
5468
5469       SmallVector<uint64_t, 32> RawMask;
5470       for (int i = 0, e = MaskNode->getNumOperands(); i < e; ++i) {
5471         SDValue Op = MaskNode->getOperand(i);
5472         if (Op->getOpcode() == ISD::UNDEF) {
5473           RawMask.push_back((uint64_t)SM_SentinelUndef);
5474           continue;
5475         }
5476         auto *CN = dyn_cast<ConstantSDNode>(Op.getNode());
5477         if (!CN)
5478           return false;
5479         APInt MaskElement = CN->getAPIntValue();
5480
5481         // We now have to decode the element which could be any integer size and
5482         // extract each byte of it.
5483         for (int j = 0; j < NumBytesPerElement; ++j) {
5484           // Note that this is x86 and so always little endian: the low byte is
5485           // the first byte of the mask.
5486           RawMask.push_back(MaskElement.getLoBits(8).getZExtValue());
5487           MaskElement = MaskElement.lshr(8);
5488         }
5489       }
5490       DecodePSHUFBMask(RawMask, Mask);
5491       break;
5492     }
5493
5494     auto *MaskLoad = dyn_cast<LoadSDNode>(MaskNode);
5495     if (!MaskLoad)
5496       return false;
5497
5498     SDValue Ptr = MaskLoad->getBasePtr();
5499     if (Ptr->getOpcode() == X86ISD::Wrapper)
5500       Ptr = Ptr->getOperand(0);
5501
5502     auto *MaskCP = dyn_cast<ConstantPoolSDNode>(Ptr);
5503     if (!MaskCP || MaskCP->isMachineConstantPoolEntry())
5504       return false;
5505
5506     if (auto *C = dyn_cast<Constant>(MaskCP->getConstVal())) {
5507       DecodePSHUFBMask(C, Mask);
5508       break;
5509     }
5510
5511     return false;
5512   }
5513   case X86ISD::VPERMI:
5514     ImmN = N->getOperand(N->getNumOperands()-1);
5515     DecodeVPERMMask(cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5516     IsUnary = true;
5517     break;
5518   case X86ISD::MOVSS:
5519   case X86ISD::MOVSD: {
5520     // The index 0 always comes from the first element of the second source,
5521     // this is why MOVSS and MOVSD are used in the first place. The other
5522     // elements come from the other positions of the first source vector
5523     Mask.push_back(NumElems);
5524     for (unsigned i = 1; i != NumElems; ++i) {
5525       Mask.push_back(i);
5526     }
5527     break;
5528   }
5529   case X86ISD::VPERM2X128:
5530     ImmN = N->getOperand(N->getNumOperands()-1);
5531     DecodeVPERM2X128Mask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5532     if (Mask.empty()) return false;
5533     break;
5534   case X86ISD::MOVSLDUP:
5535     DecodeMOVSLDUPMask(VT, Mask);
5536     IsUnary = true;
5537     break;
5538   case X86ISD::MOVSHDUP:
5539     DecodeMOVSHDUPMask(VT, Mask);
5540     IsUnary = true;
5541     break;
5542   case X86ISD::MOVDDUP:
5543     DecodeMOVDDUPMask(VT, Mask);
5544     IsUnary = true;
5545     break;
5546   case X86ISD::MOVLHPD:
5547   case X86ISD::MOVLPD:
5548   case X86ISD::MOVLPS:
5549     // Not yet implemented
5550     return false;
5551   default: llvm_unreachable("unknown target shuffle node");
5552   }
5553
5554   // If we have a fake unary shuffle, the shuffle mask is spread across two
5555   // inputs that are actually the same node. Re-map the mask to always point
5556   // into the first input.
5557   if (IsFakeUnary)
5558     for (int &M : Mask)
5559       if (M >= (int)Mask.size())
5560         M -= Mask.size();
5561
5562   return true;
5563 }
5564
5565 /// getShuffleScalarElt - Returns the scalar element that will make up the ith
5566 /// element of the result of the vector shuffle.
5567 static SDValue getShuffleScalarElt(SDNode *N, unsigned Index, SelectionDAG &DAG,
5568                                    unsigned Depth) {
5569   if (Depth == 6)
5570     return SDValue();  // Limit search depth.
5571
5572   SDValue V = SDValue(N, 0);
5573   EVT VT = V.getValueType();
5574   unsigned Opcode = V.getOpcode();
5575
5576   // Recurse into ISD::VECTOR_SHUFFLE node to find scalars.
5577   if (const ShuffleVectorSDNode *SV = dyn_cast<ShuffleVectorSDNode>(N)) {
5578     int Elt = SV->getMaskElt(Index);
5579
5580     if (Elt < 0)
5581       return DAG.getUNDEF(VT.getVectorElementType());
5582
5583     unsigned NumElems = VT.getVectorNumElements();
5584     SDValue NewV = (Elt < (int)NumElems) ? SV->getOperand(0)
5585                                          : SV->getOperand(1);
5586     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
5587   }
5588
5589   // Recurse into target specific vector shuffles to find scalars.
5590   if (isTargetShuffle(Opcode)) {
5591     MVT ShufVT = V.getSimpleValueType();
5592     unsigned NumElems = ShufVT.getVectorNumElements();
5593     SmallVector<int, 16> ShuffleMask;
5594     bool IsUnary;
5595
5596     if (!getTargetShuffleMask(N, ShufVT, ShuffleMask, IsUnary))
5597       return SDValue();
5598
5599     int Elt = ShuffleMask[Index];
5600     if (Elt < 0)
5601       return DAG.getUNDEF(ShufVT.getVectorElementType());
5602
5603     SDValue NewV = (Elt < (int)NumElems) ? N->getOperand(0)
5604                                          : N->getOperand(1);
5605     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
5606                                Depth+1);
5607   }
5608
5609   // Actual nodes that may contain scalar elements
5610   if (Opcode == ISD::BITCAST) {
5611     V = V.getOperand(0);
5612     EVT SrcVT = V.getValueType();
5613     unsigned NumElems = VT.getVectorNumElements();
5614
5615     if (!SrcVT.isVector() || SrcVT.getVectorNumElements() != NumElems)
5616       return SDValue();
5617   }
5618
5619   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR)
5620     return (Index == 0) ? V.getOperand(0)
5621                         : DAG.getUNDEF(VT.getVectorElementType());
5622
5623   if (V.getOpcode() == ISD::BUILD_VECTOR)
5624     return V.getOperand(Index);
5625
5626   return SDValue();
5627 }
5628
5629 /// getNumOfConsecutiveZeros - Return the number of elements of a vector
5630 /// shuffle operation which come from a consecutively from a zero. The
5631 /// search can start in two different directions, from left or right.
5632 /// We count undefs as zeros until PreferredNum is reached.
5633 static unsigned getNumOfConsecutiveZeros(ShuffleVectorSDNode *SVOp,
5634                                          unsigned NumElems, bool ZerosFromLeft,
5635                                          SelectionDAG &DAG,
5636                                          unsigned PreferredNum = -1U) {
5637   unsigned NumZeros = 0;
5638   for (unsigned i = 0; i != NumElems; ++i) {
5639     unsigned Index = ZerosFromLeft ? i : NumElems - i - 1;
5640     SDValue Elt = getShuffleScalarElt(SVOp, Index, DAG, 0);
5641     if (!Elt.getNode())
5642       break;
5643
5644     if (X86::isZeroNode(Elt))
5645       ++NumZeros;
5646     else if (Elt.getOpcode() == ISD::UNDEF) // Undef as zero up to PreferredNum.
5647       NumZeros = std::min(NumZeros + 1, PreferredNum);
5648     else
5649       break;
5650   }
5651
5652   return NumZeros;
5653 }
5654
5655 /// isShuffleMaskConsecutive - Check if the shuffle mask indicies [MaskI, MaskE)
5656 /// correspond consecutively to elements from one of the vector operands,
5657 /// starting from its index OpIdx. Also tell OpNum which source vector operand.
5658 static
5659 bool isShuffleMaskConsecutive(ShuffleVectorSDNode *SVOp,
5660                               unsigned MaskI, unsigned MaskE, unsigned OpIdx,
5661                               unsigned NumElems, unsigned &OpNum) {
5662   bool SeenV1 = false;
5663   bool SeenV2 = false;
5664
5665   for (unsigned i = MaskI; i != MaskE; ++i, ++OpIdx) {
5666     int Idx = SVOp->getMaskElt(i);
5667     // Ignore undef indicies
5668     if (Idx < 0)
5669       continue;
5670
5671     if (Idx < (int)NumElems)
5672       SeenV1 = true;
5673     else
5674       SeenV2 = true;
5675
5676     // Only accept consecutive elements from the same vector
5677     if ((Idx % NumElems != OpIdx) || (SeenV1 && SeenV2))
5678       return false;
5679   }
5680
5681   OpNum = SeenV1 ? 0 : 1;
5682   return true;
5683 }
5684
5685 /// isVectorShiftRight - Returns true if the shuffle can be implemented as a
5686 /// logical left shift of a vector.
5687 static bool isVectorShiftRight(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5688                                bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5689   unsigned NumElems =
5690     SVOp->getSimpleValueType(0).getVectorNumElements();
5691   unsigned NumZeros = getNumOfConsecutiveZeros(
5692       SVOp, NumElems, false /* check zeros from right */, DAG,
5693       SVOp->getMaskElt(0));
5694   unsigned OpSrc;
5695
5696   if (!NumZeros)
5697     return false;
5698
5699   // Considering the elements in the mask that are not consecutive zeros,
5700   // check if they consecutively come from only one of the source vectors.
5701   //
5702   //               V1 = {X, A, B, C}     0
5703   //                         \  \  \    /
5704   //   vector_shuffle V1, V2 <1, 2, 3, X>
5705   //
5706   if (!isShuffleMaskConsecutive(SVOp,
5707             0,                   // Mask Start Index
5708             NumElems-NumZeros,   // Mask End Index(exclusive)
5709             NumZeros,            // Where to start looking in the src vector
5710             NumElems,            // Number of elements in vector
5711             OpSrc))              // Which source operand ?
5712     return false;
5713
5714   isLeft = false;
5715   ShAmt = NumZeros;
5716   ShVal = SVOp->getOperand(OpSrc);
5717   return true;
5718 }
5719
5720 /// isVectorShiftLeft - Returns true if the shuffle can be implemented as a
5721 /// logical left shift of a vector.
5722 static bool isVectorShiftLeft(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5723                               bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5724   unsigned NumElems =
5725     SVOp->getSimpleValueType(0).getVectorNumElements();
5726   unsigned NumZeros = getNumOfConsecutiveZeros(
5727       SVOp, NumElems, true /* check zeros from left */, DAG,
5728       NumElems - SVOp->getMaskElt(NumElems - 1) - 1);
5729   unsigned OpSrc;
5730
5731   if (!NumZeros)
5732     return false;
5733
5734   // Considering the elements in the mask that are not consecutive zeros,
5735   // check if they consecutively come from only one of the source vectors.
5736   //
5737   //                           0    { A, B, X, X } = V2
5738   //                          / \    /  /
5739   //   vector_shuffle V1, V2 <X, X, 4, 5>
5740   //
5741   if (!isShuffleMaskConsecutive(SVOp,
5742             NumZeros,     // Mask Start Index
5743             NumElems,     // Mask End Index(exclusive)
5744             0,            // Where to start looking in the src vector
5745             NumElems,     // Number of elements in vector
5746             OpSrc))       // Which source operand ?
5747     return false;
5748
5749   isLeft = true;
5750   ShAmt = NumZeros;
5751   ShVal = SVOp->getOperand(OpSrc);
5752   return true;
5753 }
5754
5755 /// isVectorShift - Returns true if the shuffle can be implemented as a
5756 /// logical left or right shift of a vector.
5757 static bool isVectorShift(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5758                           bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5759   // Although the logic below support any bitwidth size, there are no
5760   // shift instructions which handle more than 128-bit vectors.
5761   if (!SVOp->getSimpleValueType(0).is128BitVector())
5762     return false;
5763
5764   if (isVectorShiftLeft(SVOp, DAG, isLeft, ShVal, ShAmt) ||
5765       isVectorShiftRight(SVOp, DAG, isLeft, ShVal, ShAmt))
5766     return true;
5767
5768   return false;
5769 }
5770
5771 /// LowerBuildVectorv16i8 - Custom lower build_vector of v16i8.
5772 ///
5773 static SDValue LowerBuildVectorv16i8(SDValue Op, unsigned NonZeros,
5774                                        unsigned NumNonZero, unsigned NumZero,
5775                                        SelectionDAG &DAG,
5776                                        const X86Subtarget* Subtarget,
5777                                        const TargetLowering &TLI) {
5778   if (NumNonZero > 8)
5779     return SDValue();
5780
5781   SDLoc dl(Op);
5782   SDValue V;
5783   bool First = true;
5784   for (unsigned i = 0; i < 16; ++i) {
5785     bool ThisIsNonZero = (NonZeros & (1 << i)) != 0;
5786     if (ThisIsNonZero && First) {
5787       if (NumZero)
5788         V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
5789       else
5790         V = DAG.getUNDEF(MVT::v8i16);
5791       First = false;
5792     }
5793
5794     if ((i & 1) != 0) {
5795       SDValue ThisElt, LastElt;
5796       bool LastIsNonZero = (NonZeros & (1 << (i-1))) != 0;
5797       if (LastIsNonZero) {
5798         LastElt = DAG.getNode(ISD::ZERO_EXTEND, dl,
5799                               MVT::i16, Op.getOperand(i-1));
5800       }
5801       if (ThisIsNonZero) {
5802         ThisElt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Op.getOperand(i));
5803         ThisElt = DAG.getNode(ISD::SHL, dl, MVT::i16,
5804                               ThisElt, DAG.getConstant(8, MVT::i8));
5805         if (LastIsNonZero)
5806           ThisElt = DAG.getNode(ISD::OR, dl, MVT::i16, ThisElt, LastElt);
5807       } else
5808         ThisElt = LastElt;
5809
5810       if (ThisElt.getNode())
5811         V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, V, ThisElt,
5812                         DAG.getIntPtrConstant(i/2));
5813     }
5814   }
5815
5816   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V);
5817 }
5818
5819 /// LowerBuildVectorv8i16 - Custom lower build_vector of v8i16.
5820 ///
5821 static SDValue LowerBuildVectorv8i16(SDValue Op, unsigned NonZeros,
5822                                      unsigned NumNonZero, unsigned NumZero,
5823                                      SelectionDAG &DAG,
5824                                      const X86Subtarget* Subtarget,
5825                                      const TargetLowering &TLI) {
5826   if (NumNonZero > 4)
5827     return SDValue();
5828
5829   SDLoc dl(Op);
5830   SDValue V;
5831   bool First = true;
5832   for (unsigned i = 0; i < 8; ++i) {
5833     bool isNonZero = (NonZeros & (1 << i)) != 0;
5834     if (isNonZero) {
5835       if (First) {
5836         if (NumZero)
5837           V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
5838         else
5839           V = DAG.getUNDEF(MVT::v8i16);
5840         First = false;
5841       }
5842       V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
5843                       MVT::v8i16, V, Op.getOperand(i),
5844                       DAG.getIntPtrConstant(i));
5845     }
5846   }
5847
5848   return V;
5849 }
5850
5851 /// LowerBuildVectorv4x32 - Custom lower build_vector of v4i32 or v4f32.
5852 static SDValue LowerBuildVectorv4x32(SDValue Op, SelectionDAG &DAG,
5853                                      const X86Subtarget *Subtarget,
5854                                      const TargetLowering &TLI) {
5855   // Find all zeroable elements.
5856   bool Zeroable[4];
5857   for (int i=0; i < 4; ++i) {
5858     SDValue Elt = Op->getOperand(i);
5859     Zeroable[i] = (Elt.getOpcode() == ISD::UNDEF || X86::isZeroNode(Elt));
5860   }
5861   assert(std::count_if(&Zeroable[0], &Zeroable[4],
5862                        [](bool M) { return !M; }) > 1 &&
5863          "We expect at least two non-zero elements!");
5864
5865   // We only know how to deal with build_vector nodes where elements are either
5866   // zeroable or extract_vector_elt with constant index.
5867   SDValue FirstNonZero;
5868   unsigned FirstNonZeroIdx;
5869   for (unsigned i=0; i < 4; ++i) {
5870     if (Zeroable[i])
5871       continue;
5872     SDValue Elt = Op->getOperand(i);
5873     if (Elt.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
5874         !isa<ConstantSDNode>(Elt.getOperand(1)))
5875       return SDValue();
5876     // Make sure that this node is extracting from a 128-bit vector.
5877     MVT VT = Elt.getOperand(0).getSimpleValueType();
5878     if (!VT.is128BitVector())
5879       return SDValue();
5880     if (!FirstNonZero.getNode()) {
5881       FirstNonZero = Elt;
5882       FirstNonZeroIdx = i;
5883     }
5884   }
5885
5886   assert(FirstNonZero.getNode() && "Unexpected build vector of all zeros!");
5887   SDValue V1 = FirstNonZero.getOperand(0);
5888   MVT VT = V1.getSimpleValueType();
5889
5890   // See if this build_vector can be lowered as a blend with zero.
5891   SDValue Elt;
5892   unsigned EltMaskIdx, EltIdx;
5893   int Mask[4];
5894   for (EltIdx = 0; EltIdx < 4; ++EltIdx) {
5895     if (Zeroable[EltIdx]) {
5896       // The zero vector will be on the right hand side.
5897       Mask[EltIdx] = EltIdx+4;
5898       continue;
5899     }
5900
5901     Elt = Op->getOperand(EltIdx);
5902     // By construction, Elt is a EXTRACT_VECTOR_ELT with constant index.
5903     EltMaskIdx = cast<ConstantSDNode>(Elt.getOperand(1))->getZExtValue();
5904     if (Elt.getOperand(0) != V1 || EltMaskIdx != EltIdx)
5905       break;
5906     Mask[EltIdx] = EltIdx;
5907   }
5908
5909   if (EltIdx == 4) {
5910     // Let the shuffle legalizer deal with blend operations.
5911     SDValue VZero = getZeroVector(VT, Subtarget, DAG, SDLoc(Op));
5912     if (V1.getSimpleValueType() != VT)
5913       V1 = DAG.getNode(ISD::BITCAST, SDLoc(V1), VT, V1);
5914     return DAG.getVectorShuffle(VT, SDLoc(V1), V1, VZero, &Mask[0]);
5915   }
5916
5917   // See if we can lower this build_vector to a INSERTPS.
5918   if (!Subtarget->hasSSE41())
5919     return SDValue();
5920
5921   SDValue V2 = Elt.getOperand(0);
5922   if (Elt == FirstNonZero && EltIdx == FirstNonZeroIdx)
5923     V1 = SDValue();
5924
5925   bool CanFold = true;
5926   for (unsigned i = EltIdx + 1; i < 4 && CanFold; ++i) {
5927     if (Zeroable[i])
5928       continue;
5929
5930     SDValue Current = Op->getOperand(i);
5931     SDValue SrcVector = Current->getOperand(0);
5932     if (!V1.getNode())
5933       V1 = SrcVector;
5934     CanFold = SrcVector == V1 &&
5935       cast<ConstantSDNode>(Current.getOperand(1))->getZExtValue() == i;
5936   }
5937
5938   if (!CanFold)
5939     return SDValue();
5940
5941   assert(V1.getNode() && "Expected at least two non-zero elements!");
5942   if (V1.getSimpleValueType() != MVT::v4f32)
5943     V1 = DAG.getNode(ISD::BITCAST, SDLoc(V1), MVT::v4f32, V1);
5944   if (V2.getSimpleValueType() != MVT::v4f32)
5945     V2 = DAG.getNode(ISD::BITCAST, SDLoc(V2), MVT::v4f32, V2);
5946
5947   // Ok, we can emit an INSERTPS instruction.
5948   unsigned ZMask = 0;
5949   for (int i = 0; i < 4; ++i)
5950     if (Zeroable[i])
5951       ZMask |= 1 << i;
5952
5953   unsigned InsertPSMask = EltMaskIdx << 6 | EltIdx << 4 | ZMask;
5954   assert((InsertPSMask & ~0xFFu) == 0 && "Invalid mask!");
5955   SDValue Result = DAG.getNode(X86ISD::INSERTPS, SDLoc(Op), MVT::v4f32, V1, V2,
5956                                DAG.getIntPtrConstant(InsertPSMask));
5957   return DAG.getNode(ISD::BITCAST, SDLoc(Op), VT, Result);
5958 }
5959
5960 /// getVShift - Return a vector logical shift node.
5961 ///
5962 static SDValue getVShift(bool isLeft, EVT VT, SDValue SrcOp,
5963                          unsigned NumBits, SelectionDAG &DAG,
5964                          const TargetLowering &TLI, SDLoc dl) {
5965   assert(VT.is128BitVector() && "Unknown type for VShift");
5966   EVT ShVT = MVT::v2i64;
5967   unsigned Opc = isLeft ? X86ISD::VSHLDQ : X86ISD::VSRLDQ;
5968   SrcOp = DAG.getNode(ISD::BITCAST, dl, ShVT, SrcOp);
5969   return DAG.getNode(ISD::BITCAST, dl, VT,
5970                      DAG.getNode(Opc, dl, ShVT, SrcOp,
5971                              DAG.getConstant(NumBits,
5972                                   TLI.getScalarShiftAmountTy(SrcOp.getValueType()))));
5973 }
5974
5975 static SDValue
5976 LowerAsSplatVectorLoad(SDValue SrcOp, MVT VT, SDLoc dl, SelectionDAG &DAG) {
5977
5978   // Check if the scalar load can be widened into a vector load. And if
5979   // the address is "base + cst" see if the cst can be "absorbed" into
5980   // the shuffle mask.
5981   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(SrcOp)) {
5982     SDValue Ptr = LD->getBasePtr();
5983     if (!ISD::isNormalLoad(LD) || LD->isVolatile())
5984       return SDValue();
5985     EVT PVT = LD->getValueType(0);
5986     if (PVT != MVT::i32 && PVT != MVT::f32)
5987       return SDValue();
5988
5989     int FI = -1;
5990     int64_t Offset = 0;
5991     if (FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr)) {
5992       FI = FINode->getIndex();
5993       Offset = 0;
5994     } else if (DAG.isBaseWithConstantOffset(Ptr) &&
5995                isa<FrameIndexSDNode>(Ptr.getOperand(0))) {
5996       FI = cast<FrameIndexSDNode>(Ptr.getOperand(0))->getIndex();
5997       Offset = Ptr.getConstantOperandVal(1);
5998       Ptr = Ptr.getOperand(0);
5999     } else {
6000       return SDValue();
6001     }
6002
6003     // FIXME: 256-bit vector instructions don't require a strict alignment,
6004     // improve this code to support it better.
6005     unsigned RequiredAlign = VT.getSizeInBits()/8;
6006     SDValue Chain = LD->getChain();
6007     // Make sure the stack object alignment is at least 16 or 32.
6008     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
6009     if (DAG.InferPtrAlignment(Ptr) < RequiredAlign) {
6010       if (MFI->isFixedObjectIndex(FI)) {
6011         // Can't change the alignment. FIXME: It's possible to compute
6012         // the exact stack offset and reference FI + adjust offset instead.
6013         // If someone *really* cares about this. That's the way to implement it.
6014         return SDValue();
6015       } else {
6016         MFI->setObjectAlignment(FI, RequiredAlign);
6017       }
6018     }
6019
6020     // (Offset % 16 or 32) must be multiple of 4. Then address is then
6021     // Ptr + (Offset & ~15).
6022     if (Offset < 0)
6023       return SDValue();
6024     if ((Offset % RequiredAlign) & 3)
6025       return SDValue();
6026     int64_t StartOffset = Offset & ~(RequiredAlign-1);
6027     if (StartOffset)
6028       Ptr = DAG.getNode(ISD::ADD, SDLoc(Ptr), Ptr.getValueType(),
6029                         Ptr,DAG.getConstant(StartOffset, Ptr.getValueType()));
6030
6031     int EltNo = (Offset - StartOffset) >> 2;
6032     unsigned NumElems = VT.getVectorNumElements();
6033
6034     EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
6035     SDValue V1 = DAG.getLoad(NVT, dl, Chain, Ptr,
6036                              LD->getPointerInfo().getWithOffset(StartOffset),
6037                              false, false, false, 0);
6038
6039     SmallVector<int, 8> Mask;
6040     for (unsigned i = 0; i != NumElems; ++i)
6041       Mask.push_back(EltNo);
6042
6043     return DAG.getVectorShuffle(NVT, dl, V1, DAG.getUNDEF(NVT), &Mask[0]);
6044   }
6045
6046   return SDValue();
6047 }
6048
6049 /// EltsFromConsecutiveLoads - Given the initializing elements 'Elts' of a
6050 /// vector of type 'VT', see if the elements can be replaced by a single large
6051 /// load which has the same value as a build_vector whose operands are 'elts'.
6052 ///
6053 /// Example: <load i32 *a, load i32 *a+4, undef, undef> -> zextload a
6054 ///
6055 /// FIXME: we'd also like to handle the case where the last elements are zero
6056 /// rather than undef via VZEXT_LOAD, but we do not detect that case today.
6057 /// There's even a handy isZeroNode for that purpose.
6058 static SDValue EltsFromConsecutiveLoads(EVT VT, SmallVectorImpl<SDValue> &Elts,
6059                                         SDLoc &DL, SelectionDAG &DAG,
6060                                         bool isAfterLegalize) {
6061   EVT EltVT = VT.getVectorElementType();
6062   unsigned NumElems = Elts.size();
6063
6064   LoadSDNode *LDBase = nullptr;
6065   unsigned LastLoadedElt = -1U;
6066
6067   // For each element in the initializer, see if we've found a load or an undef.
6068   // If we don't find an initial load element, or later load elements are
6069   // non-consecutive, bail out.
6070   for (unsigned i = 0; i < NumElems; ++i) {
6071     SDValue Elt = Elts[i];
6072
6073     if (!Elt.getNode() ||
6074         (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
6075       return SDValue();
6076     if (!LDBase) {
6077       if (Elt.getNode()->getOpcode() == ISD::UNDEF)
6078         return SDValue();
6079       LDBase = cast<LoadSDNode>(Elt.getNode());
6080       LastLoadedElt = i;
6081       continue;
6082     }
6083     if (Elt.getOpcode() == ISD::UNDEF)
6084       continue;
6085
6086     LoadSDNode *LD = cast<LoadSDNode>(Elt);
6087     if (!DAG.isConsecutiveLoad(LD, LDBase, EltVT.getSizeInBits()/8, i))
6088       return SDValue();
6089     LastLoadedElt = i;
6090   }
6091
6092   // If we have found an entire vector of loads and undefs, then return a large
6093   // load of the entire vector width starting at the base pointer.  If we found
6094   // consecutive loads for the low half, generate a vzext_load node.
6095   if (LastLoadedElt == NumElems - 1) {
6096
6097     if (isAfterLegalize &&
6098         !DAG.getTargetLoweringInfo().isOperationLegal(ISD::LOAD, VT))
6099       return SDValue();
6100
6101     SDValue NewLd = SDValue();
6102
6103     NewLd = DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
6104                         LDBase->getPointerInfo(), LDBase->isVolatile(),
6105                         LDBase->isNonTemporal(), LDBase->isInvariant(),
6106                         LDBase->getAlignment());
6107
6108     if (LDBase->hasAnyUseOfValue(1)) {
6109       SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
6110                                      SDValue(LDBase, 1),
6111                                      SDValue(NewLd.getNode(), 1));
6112       DAG.ReplaceAllUsesOfValueWith(SDValue(LDBase, 1), NewChain);
6113       DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
6114                              SDValue(NewLd.getNode(), 1));
6115     }
6116
6117     return NewLd;
6118   }
6119
6120   //TODO: The code below fires only for for loading the low v2i32 / v2f32
6121   //of a v4i32 / v4f32. It's probably worth generalizing.
6122   if (NumElems == 4 && LastLoadedElt == 1 && (EltVT.getSizeInBits() == 32) &&
6123       DAG.getTargetLoweringInfo().isTypeLegal(MVT::v2i64)) {
6124     SDVTList Tys = DAG.getVTList(MVT::v2i64, MVT::Other);
6125     SDValue Ops[] = { LDBase->getChain(), LDBase->getBasePtr() };
6126     SDValue ResNode =
6127         DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, DL, Tys, Ops, MVT::i64,
6128                                 LDBase->getPointerInfo(),
6129                                 LDBase->getAlignment(),
6130                                 false/*isVolatile*/, true/*ReadMem*/,
6131                                 false/*WriteMem*/);
6132
6133     // Make sure the newly-created LOAD is in the same position as LDBase in
6134     // terms of dependency. We create a TokenFactor for LDBase and ResNode, and
6135     // update uses of LDBase's output chain to use the TokenFactor.
6136     if (LDBase->hasAnyUseOfValue(1)) {
6137       SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
6138                              SDValue(LDBase, 1), SDValue(ResNode.getNode(), 1));
6139       DAG.ReplaceAllUsesOfValueWith(SDValue(LDBase, 1), NewChain);
6140       DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
6141                              SDValue(ResNode.getNode(), 1));
6142     }
6143
6144     return DAG.getNode(ISD::BITCAST, DL, VT, ResNode);
6145   }
6146   return SDValue();
6147 }
6148
6149 /// LowerVectorBroadcast - Attempt to use the vbroadcast instruction
6150 /// to generate a splat value for the following cases:
6151 /// 1. A splat BUILD_VECTOR which uses a single scalar load, or a constant.
6152 /// 2. A splat shuffle which uses a scalar_to_vector node which comes from
6153 /// a scalar load, or a constant.
6154 /// The VBROADCAST node is returned when a pattern is found,
6155 /// or SDValue() otherwise.
6156 static SDValue LowerVectorBroadcast(SDValue Op, const X86Subtarget* Subtarget,
6157                                     SelectionDAG &DAG) {
6158   // VBROADCAST requires AVX.
6159   // TODO: Splats could be generated for non-AVX CPUs using SSE
6160   // instructions, but there's less potential gain for only 128-bit vectors.
6161   if (!Subtarget->hasAVX())
6162     return SDValue();
6163
6164   MVT VT = Op.getSimpleValueType();
6165   SDLoc dl(Op);
6166
6167   assert((VT.is128BitVector() || VT.is256BitVector() || VT.is512BitVector()) &&
6168          "Unsupported vector type for broadcast.");
6169
6170   SDValue Ld;
6171   bool ConstSplatVal;
6172
6173   switch (Op.getOpcode()) {
6174     default:
6175       // Unknown pattern found.
6176       return SDValue();
6177
6178     case ISD::BUILD_VECTOR: {
6179       auto *BVOp = cast<BuildVectorSDNode>(Op.getNode());
6180       BitVector UndefElements;
6181       SDValue Splat = BVOp->getSplatValue(&UndefElements);
6182
6183       // We need a splat of a single value to use broadcast, and it doesn't
6184       // make any sense if the value is only in one element of the vector.
6185       if (!Splat || (VT.getVectorNumElements() - UndefElements.count()) <= 1)
6186         return SDValue();
6187
6188       Ld = Splat;
6189       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
6190                        Ld.getOpcode() == ISD::ConstantFP);
6191
6192       // Make sure that all of the users of a non-constant load are from the
6193       // BUILD_VECTOR node.
6194       if (!ConstSplatVal && !BVOp->isOnlyUserOf(Ld.getNode()))
6195         return SDValue();
6196       break;
6197     }
6198
6199     case ISD::VECTOR_SHUFFLE: {
6200       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6201
6202       // Shuffles must have a splat mask where the first element is
6203       // broadcasted.
6204       if ((!SVOp->isSplat()) || SVOp->getMaskElt(0) != 0)
6205         return SDValue();
6206
6207       SDValue Sc = Op.getOperand(0);
6208       if (Sc.getOpcode() != ISD::SCALAR_TO_VECTOR &&
6209           Sc.getOpcode() != ISD::BUILD_VECTOR) {
6210
6211         if (!Subtarget->hasInt256())
6212           return SDValue();
6213
6214         // Use the register form of the broadcast instruction available on AVX2.
6215         if (VT.getSizeInBits() >= 256)
6216           Sc = Extract128BitVector(Sc, 0, DAG, dl);
6217         return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Sc);
6218       }
6219
6220       Ld = Sc.getOperand(0);
6221       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
6222                        Ld.getOpcode() == ISD::ConstantFP);
6223
6224       // The scalar_to_vector node and the suspected
6225       // load node must have exactly one user.
6226       // Constants may have multiple users.
6227
6228       // AVX-512 has register version of the broadcast
6229       bool hasRegVer = Subtarget->hasAVX512() && VT.is512BitVector() &&
6230         Ld.getValueType().getSizeInBits() >= 32;
6231       if (!ConstSplatVal && ((!Sc.hasOneUse() || !Ld.hasOneUse()) &&
6232           !hasRegVer))
6233         return SDValue();
6234       break;
6235     }
6236   }
6237
6238   unsigned ScalarSize = Ld.getValueType().getSizeInBits();
6239   bool IsGE256 = (VT.getSizeInBits() >= 256);
6240
6241   // When optimizing for size, generate up to 5 extra bytes for a broadcast
6242   // instruction to save 8 or more bytes of constant pool data.
6243   // TODO: If multiple splats are generated to load the same constant,
6244   // it may be detrimental to overall size. There needs to be a way to detect
6245   // that condition to know if this is truly a size win.
6246   const Function *F = DAG.getMachineFunction().getFunction();
6247   bool OptForSize = F->getAttributes().
6248     hasAttribute(AttributeSet::FunctionIndex, Attribute::OptimizeForSize);
6249
6250   // Handle broadcasting a single constant scalar from the constant pool
6251   // into a vector.
6252   // On Sandybridge (no AVX2), it is still better to load a constant vector
6253   // from the constant pool and not to broadcast it from a scalar.
6254   // But override that restriction when optimizing for size.
6255   // TODO: Check if splatting is recommended for other AVX-capable CPUs.
6256   if (ConstSplatVal && (Subtarget->hasAVX2() || OptForSize)) {
6257     EVT CVT = Ld.getValueType();
6258     assert(!CVT.isVector() && "Must not broadcast a vector type");
6259
6260     // Splat f32, i32, v4f64, v4i64 in all cases with AVX2.
6261     // For size optimization, also splat v2f64 and v2i64, and for size opt
6262     // with AVX2, also splat i8 and i16.
6263     // With pattern matching, the VBROADCAST node may become a VMOVDDUP.
6264     if (ScalarSize == 32 || (IsGE256 && ScalarSize == 64) ||
6265         (OptForSize && (ScalarSize == 64 || Subtarget->hasAVX2()))) {
6266       const Constant *C = nullptr;
6267       if (ConstantSDNode *CI = dyn_cast<ConstantSDNode>(Ld))
6268         C = CI->getConstantIntValue();
6269       else if (ConstantFPSDNode *CF = dyn_cast<ConstantFPSDNode>(Ld))
6270         C = CF->getConstantFPValue();
6271
6272       assert(C && "Invalid constant type");
6273
6274       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
6275       SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
6276       unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
6277       Ld = DAG.getLoad(CVT, dl, DAG.getEntryNode(), CP,
6278                        MachinePointerInfo::getConstantPool(),
6279                        false, false, false, Alignment);
6280
6281       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
6282     }
6283   }
6284
6285   bool IsLoad = ISD::isNormalLoad(Ld.getNode());
6286
6287   // Handle AVX2 in-register broadcasts.
6288   if (!IsLoad && Subtarget->hasInt256() &&
6289       (ScalarSize == 32 || (IsGE256 && ScalarSize == 64)))
6290     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
6291
6292   // The scalar source must be a normal load.
6293   if (!IsLoad)
6294     return SDValue();
6295
6296   if (ScalarSize == 32 || (IsGE256 && ScalarSize == 64) ||
6297       (Subtarget->hasVLX() && ScalarSize == 64))
6298     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
6299
6300   // The integer check is needed for the 64-bit into 128-bit so it doesn't match
6301   // double since there is no vbroadcastsd xmm
6302   if (Subtarget->hasInt256() && Ld.getValueType().isInteger()) {
6303     if (ScalarSize == 8 || ScalarSize == 16 || ScalarSize == 64)
6304       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
6305   }
6306
6307   // Unsupported broadcast.
6308   return SDValue();
6309 }
6310
6311 /// \brief For an EXTRACT_VECTOR_ELT with a constant index return the real
6312 /// underlying vector and index.
6313 ///
6314 /// Modifies \p ExtractedFromVec to the real vector and returns the real
6315 /// index.
6316 static int getUnderlyingExtractedFromVec(SDValue &ExtractedFromVec,
6317                                          SDValue ExtIdx) {
6318   int Idx = cast<ConstantSDNode>(ExtIdx)->getZExtValue();
6319   if (!isa<ShuffleVectorSDNode>(ExtractedFromVec))
6320     return Idx;
6321
6322   // For 256-bit vectors, LowerEXTRACT_VECTOR_ELT_SSE4 may have already
6323   // lowered this:
6324   //   (extract_vector_elt (v8f32 %vreg1), Constant<6>)
6325   // to:
6326   //   (extract_vector_elt (vector_shuffle<2,u,u,u>
6327   //                           (extract_subvector (v8f32 %vreg0), Constant<4>),
6328   //                           undef)
6329   //                       Constant<0>)
6330   // In this case the vector is the extract_subvector expression and the index
6331   // is 2, as specified by the shuffle.
6332   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(ExtractedFromVec);
6333   SDValue ShuffleVec = SVOp->getOperand(0);
6334   MVT ShuffleVecVT = ShuffleVec.getSimpleValueType();
6335   assert(ShuffleVecVT.getVectorElementType() ==
6336          ExtractedFromVec.getSimpleValueType().getVectorElementType());
6337
6338   int ShuffleIdx = SVOp->getMaskElt(Idx);
6339   if (isUndefOrInRange(ShuffleIdx, 0, ShuffleVecVT.getVectorNumElements())) {
6340     ExtractedFromVec = ShuffleVec;
6341     return ShuffleIdx;
6342   }
6343   return Idx;
6344 }
6345
6346 static SDValue buildFromShuffleMostly(SDValue Op, SelectionDAG &DAG) {
6347   MVT VT = Op.getSimpleValueType();
6348
6349   // Skip if insert_vec_elt is not supported.
6350   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
6351   if (!TLI.isOperationLegalOrCustom(ISD::INSERT_VECTOR_ELT, VT))
6352     return SDValue();
6353
6354   SDLoc DL(Op);
6355   unsigned NumElems = Op.getNumOperands();
6356
6357   SDValue VecIn1;
6358   SDValue VecIn2;
6359   SmallVector<unsigned, 4> InsertIndices;
6360   SmallVector<int, 8> Mask(NumElems, -1);
6361
6362   for (unsigned i = 0; i != NumElems; ++i) {
6363     unsigned Opc = Op.getOperand(i).getOpcode();
6364
6365     if (Opc == ISD::UNDEF)
6366       continue;
6367
6368     if (Opc != ISD::EXTRACT_VECTOR_ELT) {
6369       // Quit if more than 1 elements need inserting.
6370       if (InsertIndices.size() > 1)
6371         return SDValue();
6372
6373       InsertIndices.push_back(i);
6374       continue;
6375     }
6376
6377     SDValue ExtractedFromVec = Op.getOperand(i).getOperand(0);
6378     SDValue ExtIdx = Op.getOperand(i).getOperand(1);
6379     // Quit if non-constant index.
6380     if (!isa<ConstantSDNode>(ExtIdx))
6381       return SDValue();
6382     int Idx = getUnderlyingExtractedFromVec(ExtractedFromVec, ExtIdx);
6383
6384     // Quit if extracted from vector of different type.
6385     if (ExtractedFromVec.getValueType() != VT)
6386       return SDValue();
6387
6388     if (!VecIn1.getNode())
6389       VecIn1 = ExtractedFromVec;
6390     else if (VecIn1 != ExtractedFromVec) {
6391       if (!VecIn2.getNode())
6392         VecIn2 = ExtractedFromVec;
6393       else if (VecIn2 != ExtractedFromVec)
6394         // Quit if more than 2 vectors to shuffle
6395         return SDValue();
6396     }
6397
6398     if (ExtractedFromVec == VecIn1)
6399       Mask[i] = Idx;
6400     else if (ExtractedFromVec == VecIn2)
6401       Mask[i] = Idx + NumElems;
6402   }
6403
6404   if (!VecIn1.getNode())
6405     return SDValue();
6406
6407   VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
6408   SDValue NV = DAG.getVectorShuffle(VT, DL, VecIn1, VecIn2, &Mask[0]);
6409   for (unsigned i = 0, e = InsertIndices.size(); i != e; ++i) {
6410     unsigned Idx = InsertIndices[i];
6411     NV = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, NV, Op.getOperand(Idx),
6412                      DAG.getIntPtrConstant(Idx));
6413   }
6414
6415   return NV;
6416 }
6417
6418 // Lower BUILD_VECTOR operation for v8i1 and v16i1 types.
6419 SDValue
6420 X86TargetLowering::LowerBUILD_VECTORvXi1(SDValue Op, SelectionDAG &DAG) const {
6421
6422   MVT VT = Op.getSimpleValueType();
6423   assert((VT.getVectorElementType() == MVT::i1) && (VT.getSizeInBits() <= 16) &&
6424          "Unexpected type in LowerBUILD_VECTORvXi1!");
6425
6426   SDLoc dl(Op);
6427   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
6428     SDValue Cst = DAG.getTargetConstant(0, MVT::i1);
6429     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Cst);
6430     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
6431   }
6432
6433   if (ISD::isBuildVectorAllOnes(Op.getNode())) {
6434     SDValue Cst = DAG.getTargetConstant(1, MVT::i1);
6435     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Cst);
6436     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
6437   }
6438
6439   bool AllContants = true;
6440   uint64_t Immediate = 0;
6441   int NonConstIdx = -1;
6442   bool IsSplat = true;
6443   unsigned NumNonConsts = 0;
6444   unsigned NumConsts = 0;
6445   for (unsigned idx = 0, e = Op.getNumOperands(); idx < e; ++idx) {
6446     SDValue In = Op.getOperand(idx);
6447     if (In.getOpcode() == ISD::UNDEF)
6448       continue;
6449     if (!isa<ConstantSDNode>(In)) {
6450       AllContants = false;
6451       NonConstIdx = idx;
6452       NumNonConsts++;
6453     } else {
6454       NumConsts++;
6455       if (cast<ConstantSDNode>(In)->getZExtValue())
6456       Immediate |= (1ULL << idx);
6457     }
6458     if (In != Op.getOperand(0))
6459       IsSplat = false;
6460   }
6461
6462   if (AllContants) {
6463     SDValue FullMask = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1,
6464       DAG.getConstant(Immediate, MVT::i16));
6465     return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, FullMask,
6466                        DAG.getIntPtrConstant(0));
6467   }
6468
6469   if (NumNonConsts == 1 && NonConstIdx != 0) {
6470     SDValue DstVec;
6471     if (NumConsts) {
6472       SDValue VecAsImm = DAG.getConstant(Immediate,
6473                                          MVT::getIntegerVT(VT.getSizeInBits()));
6474       DstVec = DAG.getNode(ISD::BITCAST, dl, VT, VecAsImm);
6475     }
6476     else
6477       DstVec = DAG.getUNDEF(VT);
6478     return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, DstVec,
6479                        Op.getOperand(NonConstIdx),
6480                        DAG.getIntPtrConstant(NonConstIdx));
6481   }
6482   if (!IsSplat && (NonConstIdx != 0))
6483     llvm_unreachable("Unsupported BUILD_VECTOR operation");
6484   MVT SelectVT = (VT == MVT::v16i1)? MVT::i16 : MVT::i8;
6485   SDValue Select;
6486   if (IsSplat)
6487     Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
6488                           DAG.getConstant(-1, SelectVT),
6489                           DAG.getConstant(0, SelectVT));
6490   else
6491     Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
6492                          DAG.getConstant((Immediate | 1), SelectVT),
6493                          DAG.getConstant(Immediate, SelectVT));
6494   return DAG.getNode(ISD::BITCAST, dl, VT, Select);
6495 }
6496
6497 /// \brief Return true if \p N implements a horizontal binop and return the
6498 /// operands for the horizontal binop into V0 and V1.
6499 ///
6500 /// This is a helper function of PerformBUILD_VECTORCombine.
6501 /// This function checks that the build_vector \p N in input implements a
6502 /// horizontal operation. Parameter \p Opcode defines the kind of horizontal
6503 /// operation to match.
6504 /// For example, if \p Opcode is equal to ISD::ADD, then this function
6505 /// checks if \p N implements a horizontal arithmetic add; if instead \p Opcode
6506 /// is equal to ISD::SUB, then this function checks if this is a horizontal
6507 /// arithmetic sub.
6508 ///
6509 /// This function only analyzes elements of \p N whose indices are
6510 /// in range [BaseIdx, LastIdx).
6511 static bool isHorizontalBinOp(const BuildVectorSDNode *N, unsigned Opcode,
6512                               SelectionDAG &DAG,
6513                               unsigned BaseIdx, unsigned LastIdx,
6514                               SDValue &V0, SDValue &V1) {
6515   EVT VT = N->getValueType(0);
6516
6517   assert(BaseIdx * 2 <= LastIdx && "Invalid Indices in input!");
6518   assert(VT.isVector() && VT.getVectorNumElements() >= LastIdx &&
6519          "Invalid Vector in input!");
6520
6521   bool IsCommutable = (Opcode == ISD::ADD || Opcode == ISD::FADD);
6522   bool CanFold = true;
6523   unsigned ExpectedVExtractIdx = BaseIdx;
6524   unsigned NumElts = LastIdx - BaseIdx;
6525   V0 = DAG.getUNDEF(VT);
6526   V1 = DAG.getUNDEF(VT);
6527
6528   // Check if N implements a horizontal binop.
6529   for (unsigned i = 0, e = NumElts; i != e && CanFold; ++i) {
6530     SDValue Op = N->getOperand(i + BaseIdx);
6531
6532     // Skip UNDEFs.
6533     if (Op->getOpcode() == ISD::UNDEF) {
6534       // Update the expected vector extract index.
6535       if (i * 2 == NumElts)
6536         ExpectedVExtractIdx = BaseIdx;
6537       ExpectedVExtractIdx += 2;
6538       continue;
6539     }
6540
6541     CanFold = Op->getOpcode() == Opcode && Op->hasOneUse();
6542
6543     if (!CanFold)
6544       break;
6545
6546     SDValue Op0 = Op.getOperand(0);
6547     SDValue Op1 = Op.getOperand(1);
6548
6549     // Try to match the following pattern:
6550     // (BINOP (extract_vector_elt A, I), (extract_vector_elt A, I+1))
6551     CanFold = (Op0.getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
6552         Op1.getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
6553         Op0.getOperand(0) == Op1.getOperand(0) &&
6554         isa<ConstantSDNode>(Op0.getOperand(1)) &&
6555         isa<ConstantSDNode>(Op1.getOperand(1)));
6556     if (!CanFold)
6557       break;
6558
6559     unsigned I0 = cast<ConstantSDNode>(Op0.getOperand(1))->getZExtValue();
6560     unsigned I1 = cast<ConstantSDNode>(Op1.getOperand(1))->getZExtValue();
6561
6562     if (i * 2 < NumElts) {
6563       if (V0.getOpcode() == ISD::UNDEF)
6564         V0 = Op0.getOperand(0);
6565     } else {
6566       if (V1.getOpcode() == ISD::UNDEF)
6567         V1 = Op0.getOperand(0);
6568       if (i * 2 == NumElts)
6569         ExpectedVExtractIdx = BaseIdx;
6570     }
6571
6572     SDValue Expected = (i * 2 < NumElts) ? V0 : V1;
6573     if (I0 == ExpectedVExtractIdx)
6574       CanFold = I1 == I0 + 1 && Op0.getOperand(0) == Expected;
6575     else if (IsCommutable && I1 == ExpectedVExtractIdx) {
6576       // Try to match the following dag sequence:
6577       // (BINOP (extract_vector_elt A, I+1), (extract_vector_elt A, I))
6578       CanFold = I0 == I1 + 1 && Op1.getOperand(0) == Expected;
6579     } else
6580       CanFold = false;
6581
6582     ExpectedVExtractIdx += 2;
6583   }
6584
6585   return CanFold;
6586 }
6587
6588 /// \brief Emit a sequence of two 128-bit horizontal add/sub followed by
6589 /// a concat_vector.
6590 ///
6591 /// This is a helper function of PerformBUILD_VECTORCombine.
6592 /// This function expects two 256-bit vectors called V0 and V1.
6593 /// At first, each vector is split into two separate 128-bit vectors.
6594 /// Then, the resulting 128-bit vectors are used to implement two
6595 /// horizontal binary operations.
6596 ///
6597 /// The kind of horizontal binary operation is defined by \p X86Opcode.
6598 ///
6599 /// \p Mode specifies how the 128-bit parts of V0 and V1 are passed in input to
6600 /// the two new horizontal binop.
6601 /// When Mode is set, the first horizontal binop dag node would take as input
6602 /// the lower 128-bit of V0 and the upper 128-bit of V0. The second
6603 /// horizontal binop dag node would take as input the lower 128-bit of V1
6604 /// and the upper 128-bit of V1.
6605 ///   Example:
6606 ///     HADD V0_LO, V0_HI
6607 ///     HADD V1_LO, V1_HI
6608 ///
6609 /// Otherwise, the first horizontal binop dag node takes as input the lower
6610 /// 128-bit of V0 and the lower 128-bit of V1, and the second horizontal binop
6611 /// dag node takes the the upper 128-bit of V0 and the upper 128-bit of V1.
6612 ///   Example:
6613 ///     HADD V0_LO, V1_LO
6614 ///     HADD V0_HI, V1_HI
6615 ///
6616 /// If \p isUndefLO is set, then the algorithm propagates UNDEF to the lower
6617 /// 128-bits of the result. If \p isUndefHI is set, then UNDEF is propagated to
6618 /// the upper 128-bits of the result.
6619 static SDValue ExpandHorizontalBinOp(const SDValue &V0, const SDValue &V1,
6620                                      SDLoc DL, SelectionDAG &DAG,
6621                                      unsigned X86Opcode, bool Mode,
6622                                      bool isUndefLO, bool isUndefHI) {
6623   EVT VT = V0.getValueType();
6624   assert(VT.is256BitVector() && VT == V1.getValueType() &&
6625          "Invalid nodes in input!");
6626
6627   unsigned NumElts = VT.getVectorNumElements();
6628   SDValue V0_LO = Extract128BitVector(V0, 0, DAG, DL);
6629   SDValue V0_HI = Extract128BitVector(V0, NumElts/2, DAG, DL);
6630   SDValue V1_LO = Extract128BitVector(V1, 0, DAG, DL);
6631   SDValue V1_HI = Extract128BitVector(V1, NumElts/2, DAG, DL);
6632   EVT NewVT = V0_LO.getValueType();
6633
6634   SDValue LO = DAG.getUNDEF(NewVT);
6635   SDValue HI = DAG.getUNDEF(NewVT);
6636
6637   if (Mode) {
6638     // Don't emit a horizontal binop if the result is expected to be UNDEF.
6639     if (!isUndefLO && V0->getOpcode() != ISD::UNDEF)
6640       LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V0_HI);
6641     if (!isUndefHI && V1->getOpcode() != ISD::UNDEF)
6642       HI = DAG.getNode(X86Opcode, DL, NewVT, V1_LO, V1_HI);
6643   } else {
6644     // Don't emit a horizontal binop if the result is expected to be UNDEF.
6645     if (!isUndefLO && (V0_LO->getOpcode() != ISD::UNDEF ||
6646                        V1_LO->getOpcode() != ISD::UNDEF))
6647       LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V1_LO);
6648
6649     if (!isUndefHI && (V0_HI->getOpcode() != ISD::UNDEF ||
6650                        V1_HI->getOpcode() != ISD::UNDEF))
6651       HI = DAG.getNode(X86Opcode, DL, NewVT, V0_HI, V1_HI);
6652   }
6653
6654   return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LO, HI);
6655 }
6656
6657 /// \brief Try to fold a build_vector that performs an 'addsub' into the
6658 /// sequence of 'vadd + vsub + blendi'.
6659 static SDValue matchAddSub(const BuildVectorSDNode *BV, SelectionDAG &DAG,
6660                            const X86Subtarget *Subtarget) {
6661   SDLoc DL(BV);
6662   EVT VT = BV->getValueType(0);
6663   unsigned NumElts = VT.getVectorNumElements();
6664   SDValue InVec0 = DAG.getUNDEF(VT);
6665   SDValue InVec1 = DAG.getUNDEF(VT);
6666
6667   assert((VT == MVT::v8f32 || VT == MVT::v4f64 || VT == MVT::v4f32 ||
6668           VT == MVT::v2f64) && "build_vector with an invalid type found!");
6669
6670   // Odd-numbered elements in the input build vector are obtained from
6671   // adding two integer/float elements.
6672   // Even-numbered elements in the input build vector are obtained from
6673   // subtracting two integer/float elements.
6674   unsigned ExpectedOpcode = ISD::FSUB;
6675   unsigned NextExpectedOpcode = ISD::FADD;
6676   bool AddFound = false;
6677   bool SubFound = false;
6678
6679   for (unsigned i = 0, e = NumElts; i != e; i++) {
6680     SDValue Op = BV->getOperand(i);
6681
6682     // Skip 'undef' values.
6683     unsigned Opcode = Op.getOpcode();
6684     if (Opcode == ISD::UNDEF) {
6685       std::swap(ExpectedOpcode, NextExpectedOpcode);
6686       continue;
6687     }
6688
6689     // Early exit if we found an unexpected opcode.
6690     if (Opcode != ExpectedOpcode)
6691       return SDValue();
6692
6693     SDValue Op0 = Op.getOperand(0);
6694     SDValue Op1 = Op.getOperand(1);
6695
6696     // Try to match the following pattern:
6697     // (BINOP (extract_vector_elt A, i), (extract_vector_elt B, i))
6698     // Early exit if we cannot match that sequence.
6699     if (Op0.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
6700         Op1.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
6701         !isa<ConstantSDNode>(Op0.getOperand(1)) ||
6702         !isa<ConstantSDNode>(Op1.getOperand(1)) ||
6703         Op0.getOperand(1) != Op1.getOperand(1))
6704       return SDValue();
6705
6706     unsigned I0 = cast<ConstantSDNode>(Op0.getOperand(1))->getZExtValue();
6707     if (I0 != i)
6708       return SDValue();
6709
6710     // We found a valid add/sub node. Update the information accordingly.
6711     if (i & 1)
6712       AddFound = true;
6713     else
6714       SubFound = true;
6715
6716     // Update InVec0 and InVec1.
6717     if (InVec0.getOpcode() == ISD::UNDEF)
6718       InVec0 = Op0.getOperand(0);
6719     if (InVec1.getOpcode() == ISD::UNDEF)
6720       InVec1 = Op1.getOperand(0);
6721
6722     // Make sure that operands in input to each add/sub node always
6723     // come from a same pair of vectors.
6724     if (InVec0 != Op0.getOperand(0)) {
6725       if (ExpectedOpcode == ISD::FSUB)
6726         return SDValue();
6727
6728       // FADD is commutable. Try to commute the operands
6729       // and then test again.
6730       std::swap(Op0, Op1);
6731       if (InVec0 != Op0.getOperand(0))
6732         return SDValue();
6733     }
6734
6735     if (InVec1 != Op1.getOperand(0))
6736       return SDValue();
6737
6738     // Update the pair of expected opcodes.
6739     std::swap(ExpectedOpcode, NextExpectedOpcode);
6740   }
6741
6742   // Don't try to fold this build_vector into an ADDSUB if the inputs are undef.
6743   if (AddFound && SubFound && InVec0.getOpcode() != ISD::UNDEF &&
6744       InVec1.getOpcode() != ISD::UNDEF)
6745     return DAG.getNode(X86ISD::ADDSUB, DL, VT, InVec0, InVec1);
6746
6747   return SDValue();
6748 }
6749
6750 static SDValue PerformBUILD_VECTORCombine(SDNode *N, SelectionDAG &DAG,
6751                                           const X86Subtarget *Subtarget) {
6752   SDLoc DL(N);
6753   EVT VT = N->getValueType(0);
6754   unsigned NumElts = VT.getVectorNumElements();
6755   BuildVectorSDNode *BV = cast<BuildVectorSDNode>(N);
6756   SDValue InVec0, InVec1;
6757
6758   // Try to match an ADDSUB.
6759   if ((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
6760       (Subtarget->hasAVX() && (VT == MVT::v8f32 || VT == MVT::v4f64))) {
6761     SDValue Value = matchAddSub(BV, DAG, Subtarget);
6762     if (Value.getNode())
6763       return Value;
6764   }
6765
6766   // Try to match horizontal ADD/SUB.
6767   unsigned NumUndefsLO = 0;
6768   unsigned NumUndefsHI = 0;
6769   unsigned Half = NumElts/2;
6770
6771   // Count the number of UNDEF operands in the build_vector in input.
6772   for (unsigned i = 0, e = Half; i != e; ++i)
6773     if (BV->getOperand(i)->getOpcode() == ISD::UNDEF)
6774       NumUndefsLO++;
6775
6776   for (unsigned i = Half, e = NumElts; i != e; ++i)
6777     if (BV->getOperand(i)->getOpcode() == ISD::UNDEF)
6778       NumUndefsHI++;
6779
6780   // Early exit if this is either a build_vector of all UNDEFs or all the
6781   // operands but one are UNDEF.
6782   if (NumUndefsLO + NumUndefsHI + 1 >= NumElts)
6783     return SDValue();
6784
6785   if ((VT == MVT::v4f32 || VT == MVT::v2f64) && Subtarget->hasSSE3()) {
6786     // Try to match an SSE3 float HADD/HSUB.
6787     if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, NumElts, InVec0, InVec1))
6788       return DAG.getNode(X86ISD::FHADD, DL, VT, InVec0, InVec1);
6789
6790     if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, NumElts, InVec0, InVec1))
6791       return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
6792   } else if ((VT == MVT::v4i32 || VT == MVT::v8i16) && Subtarget->hasSSSE3()) {
6793     // Try to match an SSSE3 integer HADD/HSUB.
6794     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, NumElts, InVec0, InVec1))
6795       return DAG.getNode(X86ISD::HADD, DL, VT, InVec0, InVec1);
6796
6797     if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, NumElts, InVec0, InVec1))
6798       return DAG.getNode(X86ISD::HSUB, DL, VT, InVec0, InVec1);
6799   }
6800
6801   if (!Subtarget->hasAVX())
6802     return SDValue();
6803
6804   if ((VT == MVT::v8f32 || VT == MVT::v4f64)) {
6805     // Try to match an AVX horizontal add/sub of packed single/double
6806     // precision floating point values from 256-bit vectors.
6807     SDValue InVec2, InVec3;
6808     if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, Half, InVec0, InVec1) &&
6809         isHorizontalBinOp(BV, ISD::FADD, DAG, Half, NumElts, InVec2, InVec3) &&
6810         ((InVec0.getOpcode() == ISD::UNDEF ||
6811           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
6812         ((InVec1.getOpcode() == ISD::UNDEF ||
6813           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
6814       return DAG.getNode(X86ISD::FHADD, DL, VT, InVec0, InVec1);
6815
6816     if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, Half, InVec0, InVec1) &&
6817         isHorizontalBinOp(BV, ISD::FSUB, DAG, Half, NumElts, InVec2, InVec3) &&
6818         ((InVec0.getOpcode() == ISD::UNDEF ||
6819           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
6820         ((InVec1.getOpcode() == ISD::UNDEF ||
6821           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
6822       return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
6823   } else if (VT == MVT::v8i32 || VT == MVT::v16i16) {
6824     // Try to match an AVX2 horizontal add/sub of signed integers.
6825     SDValue InVec2, InVec3;
6826     unsigned X86Opcode;
6827     bool CanFold = true;
6828
6829     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, Half, InVec0, InVec1) &&
6830         isHorizontalBinOp(BV, ISD::ADD, DAG, Half, NumElts, InVec2, InVec3) &&
6831         ((InVec0.getOpcode() == ISD::UNDEF ||
6832           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
6833         ((InVec1.getOpcode() == ISD::UNDEF ||
6834           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
6835       X86Opcode = X86ISD::HADD;
6836     else if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, Half, InVec0, InVec1) &&
6837         isHorizontalBinOp(BV, ISD::SUB, DAG, Half, NumElts, InVec2, InVec3) &&
6838         ((InVec0.getOpcode() == ISD::UNDEF ||
6839           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
6840         ((InVec1.getOpcode() == ISD::UNDEF ||
6841           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
6842       X86Opcode = X86ISD::HSUB;
6843     else
6844       CanFold = false;
6845
6846     if (CanFold) {
6847       // Fold this build_vector into a single horizontal add/sub.
6848       // Do this only if the target has AVX2.
6849       if (Subtarget->hasAVX2())
6850         return DAG.getNode(X86Opcode, DL, VT, InVec0, InVec1);
6851
6852       // Do not try to expand this build_vector into a pair of horizontal
6853       // add/sub if we can emit a pair of scalar add/sub.
6854       if (NumUndefsLO + 1 == Half || NumUndefsHI + 1 == Half)
6855         return SDValue();
6856
6857       // Convert this build_vector into a pair of horizontal binop followed by
6858       // a concat vector.
6859       bool isUndefLO = NumUndefsLO == Half;
6860       bool isUndefHI = NumUndefsHI == Half;
6861       return ExpandHorizontalBinOp(InVec0, InVec1, DL, DAG, X86Opcode, false,
6862                                    isUndefLO, isUndefHI);
6863     }
6864   }
6865
6866   if ((VT == MVT::v8f32 || VT == MVT::v4f64 || VT == MVT::v8i32 ||
6867        VT == MVT::v16i16) && Subtarget->hasAVX()) {
6868     unsigned X86Opcode;
6869     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, NumElts, InVec0, InVec1))
6870       X86Opcode = X86ISD::HADD;
6871     else if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, NumElts, InVec0, InVec1))
6872       X86Opcode = X86ISD::HSUB;
6873     else if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, NumElts, InVec0, InVec1))
6874       X86Opcode = X86ISD::FHADD;
6875     else if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, NumElts, InVec0, InVec1))
6876       X86Opcode = X86ISD::FHSUB;
6877     else
6878       return SDValue();
6879
6880     // Don't try to expand this build_vector into a pair of horizontal add/sub
6881     // if we can simply emit a pair of scalar add/sub.
6882     if (NumUndefsLO + 1 == Half || NumUndefsHI + 1 == Half)
6883       return SDValue();
6884
6885     // Convert this build_vector into two horizontal add/sub followed by
6886     // a concat vector.
6887     bool isUndefLO = NumUndefsLO == Half;
6888     bool isUndefHI = NumUndefsHI == Half;
6889     return ExpandHorizontalBinOp(InVec0, InVec1, DL, DAG, X86Opcode, true,
6890                                  isUndefLO, isUndefHI);
6891   }
6892
6893   return SDValue();
6894 }
6895
6896 SDValue
6897 X86TargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const {
6898   SDLoc dl(Op);
6899
6900   MVT VT = Op.getSimpleValueType();
6901   MVT ExtVT = VT.getVectorElementType();
6902   unsigned NumElems = Op.getNumOperands();
6903
6904   // Generate vectors for predicate vectors.
6905   if (VT.getScalarType() == MVT::i1 && Subtarget->hasAVX512())
6906     return LowerBUILD_VECTORvXi1(Op, DAG);
6907
6908   // Vectors containing all zeros can be matched by pxor and xorps later
6909   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
6910     // Canonicalize this to <4 x i32> to 1) ensure the zero vectors are CSE'd
6911     // and 2) ensure that i64 scalars are eliminated on x86-32 hosts.
6912     if (VT == MVT::v4i32 || VT == MVT::v8i32 || VT == MVT::v16i32)
6913       return Op;
6914
6915     return getZeroVector(VT, Subtarget, DAG, dl);
6916   }
6917
6918   // Vectors containing all ones can be matched by pcmpeqd on 128-bit width
6919   // vectors or broken into v4i32 operations on 256-bit vectors. AVX2 can use
6920   // vpcmpeqd on 256-bit vectors.
6921   if (Subtarget->hasSSE2() && ISD::isBuildVectorAllOnes(Op.getNode())) {
6922     if (VT == MVT::v4i32 || (VT == MVT::v8i32 && Subtarget->hasInt256()))
6923       return Op;
6924
6925     if (!VT.is512BitVector())
6926       return getOnesVector(VT, Subtarget->hasInt256(), DAG, dl);
6927   }
6928
6929   SDValue Broadcast = LowerVectorBroadcast(Op, Subtarget, DAG);
6930   if (Broadcast.getNode())
6931     return Broadcast;
6932
6933   unsigned EVTBits = ExtVT.getSizeInBits();
6934
6935   unsigned NumZero  = 0;
6936   unsigned NumNonZero = 0;
6937   unsigned NonZeros = 0;
6938   bool IsAllConstants = true;
6939   SmallSet<SDValue, 8> Values;
6940   for (unsigned i = 0; i < NumElems; ++i) {
6941     SDValue Elt = Op.getOperand(i);
6942     if (Elt.getOpcode() == ISD::UNDEF)
6943       continue;
6944     Values.insert(Elt);
6945     if (Elt.getOpcode() != ISD::Constant &&
6946         Elt.getOpcode() != ISD::ConstantFP)
6947       IsAllConstants = false;
6948     if (X86::isZeroNode(Elt))
6949       NumZero++;
6950     else {
6951       NonZeros |= (1 << i);
6952       NumNonZero++;
6953     }
6954   }
6955
6956   // All undef vector. Return an UNDEF.  All zero vectors were handled above.
6957   if (NumNonZero == 0)
6958     return DAG.getUNDEF(VT);
6959
6960   // Special case for single non-zero, non-undef, element.
6961   if (NumNonZero == 1) {
6962     unsigned Idx = countTrailingZeros(NonZeros);
6963     SDValue Item = Op.getOperand(Idx);
6964
6965     // If this is an insertion of an i64 value on x86-32, and if the top bits of
6966     // the value are obviously zero, truncate the value to i32 and do the
6967     // insertion that way.  Only do this if the value is non-constant or if the
6968     // value is a constant being inserted into element 0.  It is cheaper to do
6969     // a constant pool load than it is to do a movd + shuffle.
6970     if (ExtVT == MVT::i64 && !Subtarget->is64Bit() &&
6971         (!IsAllConstants || Idx == 0)) {
6972       if (DAG.MaskedValueIsZero(Item, APInt::getBitsSet(64, 32, 64))) {
6973         // Handle SSE only.
6974         assert(VT == MVT::v2i64 && "Expected an SSE value type!");
6975         EVT VecVT = MVT::v4i32;
6976         unsigned VecElts = 4;
6977
6978         // Truncate the value (which may itself be a constant) to i32, and
6979         // convert it to a vector with movd (S2V+shuffle to zero extend).
6980         Item = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Item);
6981         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Item);
6982
6983         // If using the new shuffle lowering, just directly insert this.
6984         if (ExperimentalVectorShuffleLowering)
6985           return DAG.getNode(
6986               ISD::BITCAST, dl, VT,
6987               getShuffleVectorZeroOrUndef(Item, Idx * 2, true, Subtarget, DAG));
6988
6989         Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
6990
6991         // Now we have our 32-bit value zero extended in the low element of
6992         // a vector.  If Idx != 0, swizzle it into place.
6993         if (Idx != 0) {
6994           SmallVector<int, 4> Mask;
6995           Mask.push_back(Idx);
6996           for (unsigned i = 1; i != VecElts; ++i)
6997             Mask.push_back(i);
6998           Item = DAG.getVectorShuffle(VecVT, dl, Item, DAG.getUNDEF(VecVT),
6999                                       &Mask[0]);
7000         }
7001         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
7002       }
7003     }
7004
7005     // If we have a constant or non-constant insertion into the low element of
7006     // a vector, we can do this with SCALAR_TO_VECTOR + shuffle of zero into
7007     // the rest of the elements.  This will be matched as movd/movq/movss/movsd
7008     // depending on what the source datatype is.
7009     if (Idx == 0) {
7010       if (NumZero == 0)
7011         return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
7012
7013       if (ExtVT == MVT::i32 || ExtVT == MVT::f32 || ExtVT == MVT::f64 ||
7014           (ExtVT == MVT::i64 && Subtarget->is64Bit())) {
7015         if (VT.is256BitVector() || VT.is512BitVector()) {
7016           SDValue ZeroVec = getZeroVector(VT, Subtarget, DAG, dl);
7017           return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, ZeroVec,
7018                              Item, DAG.getIntPtrConstant(0));
7019         }
7020         assert(VT.is128BitVector() && "Expected an SSE value type!");
7021         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
7022         // Turn it into a MOVL (i.e. movss, movsd, or movd) to a zero vector.
7023         return getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
7024       }
7025
7026       if (ExtVT == MVT::i16 || ExtVT == MVT::i8) {
7027         Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
7028         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Item);
7029         if (VT.is256BitVector()) {
7030           SDValue ZeroVec = getZeroVector(MVT::v8i32, Subtarget, DAG, dl);
7031           Item = Insert128BitVector(ZeroVec, Item, 0, DAG, dl);
7032         } else {
7033           assert(VT.is128BitVector() && "Expected an SSE value type!");
7034           Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
7035         }
7036         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
7037       }
7038     }
7039
7040     // Is it a vector logical left shift?
7041     if (NumElems == 2 && Idx == 1 &&
7042         X86::isZeroNode(Op.getOperand(0)) &&
7043         !X86::isZeroNode(Op.getOperand(1))) {
7044       unsigned NumBits = VT.getSizeInBits();
7045       return getVShift(true, VT,
7046                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
7047                                    VT, Op.getOperand(1)),
7048                        NumBits/2, DAG, *this, dl);
7049     }
7050
7051     if (IsAllConstants) // Otherwise, it's better to do a constpool load.
7052       return SDValue();
7053
7054     // Otherwise, if this is a vector with i32 or f32 elements, and the element
7055     // is a non-constant being inserted into an element other than the low one,
7056     // we can't use a constant pool load.  Instead, use SCALAR_TO_VECTOR (aka
7057     // movd/movss) to move this into the low element, then shuffle it into
7058     // place.
7059     if (EVTBits == 32) {
7060       Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
7061
7062       // If using the new shuffle lowering, just directly insert this.
7063       if (ExperimentalVectorShuffleLowering)
7064         return getShuffleVectorZeroOrUndef(Item, Idx, NumZero > 0, Subtarget, DAG);
7065
7066       // Turn it into a shuffle of zero and zero-extended scalar to vector.
7067       Item = getShuffleVectorZeroOrUndef(Item, 0, NumZero > 0, Subtarget, DAG);
7068       SmallVector<int, 8> MaskVec;
7069       for (unsigned i = 0; i != NumElems; ++i)
7070         MaskVec.push_back(i == Idx ? 0 : 1);
7071       return DAG.getVectorShuffle(VT, dl, Item, DAG.getUNDEF(VT), &MaskVec[0]);
7072     }
7073   }
7074
7075   // Splat is obviously ok. Let legalizer expand it to a shuffle.
7076   if (Values.size() == 1) {
7077     if (EVTBits == 32) {
7078       // Instead of a shuffle like this:
7079       // shuffle (scalar_to_vector (load (ptr + 4))), undef, <0, 0, 0, 0>
7080       // Check if it's possible to issue this instead.
7081       // shuffle (vload ptr)), undef, <1, 1, 1, 1>
7082       unsigned Idx = countTrailingZeros(NonZeros);
7083       SDValue Item = Op.getOperand(Idx);
7084       if (Op.getNode()->isOnlyUserOf(Item.getNode()))
7085         return LowerAsSplatVectorLoad(Item, VT, dl, DAG);
7086     }
7087     return SDValue();
7088   }
7089
7090   // A vector full of immediates; various special cases are already
7091   // handled, so this is best done with a single constant-pool load.
7092   if (IsAllConstants)
7093     return SDValue();
7094
7095   // For AVX-length vectors, see if we can use a vector load to get all of the
7096   // elements, otherwise build the individual 128-bit pieces and use
7097   // shuffles to put them in place.
7098   if (VT.is256BitVector() || VT.is512BitVector()) {
7099     SmallVector<SDValue, 64> V;
7100     for (unsigned i = 0; i != NumElems; ++i)
7101       V.push_back(Op.getOperand(i));
7102
7103     // Check for a build vector of consecutive loads.
7104     if (SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG, false))
7105       return LD;
7106
7107     EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElems/2);
7108
7109     // Build both the lower and upper subvector.
7110     SDValue Lower = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT,
7111                                 makeArrayRef(&V[0], NumElems/2));
7112     SDValue Upper = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT,
7113                                 makeArrayRef(&V[NumElems / 2], NumElems/2));
7114
7115     // Recreate the wider vector with the lower and upper part.
7116     if (VT.is256BitVector())
7117       return Concat128BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
7118     return Concat256BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
7119   }
7120
7121   // Let legalizer expand 2-wide build_vectors.
7122   if (EVTBits == 64) {
7123     if (NumNonZero == 1) {
7124       // One half is zero or undef.
7125       unsigned Idx = countTrailingZeros(NonZeros);
7126       SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
7127                                  Op.getOperand(Idx));
7128       return getShuffleVectorZeroOrUndef(V2, Idx, true, Subtarget, DAG);
7129     }
7130     return SDValue();
7131   }
7132
7133   // If element VT is < 32 bits, convert it to inserts into a zero vector.
7134   if (EVTBits == 8 && NumElems == 16) {
7135     SDValue V = LowerBuildVectorv16i8(Op, NonZeros,NumNonZero,NumZero, DAG,
7136                                         Subtarget, *this);
7137     if (V.getNode()) return V;
7138   }
7139
7140   if (EVTBits == 16 && NumElems == 8) {
7141     SDValue V = LowerBuildVectorv8i16(Op, NonZeros,NumNonZero,NumZero, DAG,
7142                                       Subtarget, *this);
7143     if (V.getNode()) return V;
7144   }
7145
7146   // If element VT is == 32 bits and has 4 elems, try to generate an INSERTPS
7147   if (EVTBits == 32 && NumElems == 4) {
7148     SDValue V = LowerBuildVectorv4x32(Op, DAG, Subtarget, *this);
7149     if (V.getNode())
7150       return V;
7151   }
7152
7153   // If element VT is == 32 bits, turn it into a number of shuffles.
7154   SmallVector<SDValue, 8> V(NumElems);
7155   if (NumElems == 4 && NumZero > 0) {
7156     for (unsigned i = 0; i < 4; ++i) {
7157       bool isZero = !(NonZeros & (1 << i));
7158       if (isZero)
7159         V[i] = getZeroVector(VT, Subtarget, DAG, dl);
7160       else
7161         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
7162     }
7163
7164     for (unsigned i = 0; i < 2; ++i) {
7165       switch ((NonZeros & (0x3 << i*2)) >> (i*2)) {
7166         default: break;
7167         case 0:
7168           V[i] = V[i*2];  // Must be a zero vector.
7169           break;
7170         case 1:
7171           V[i] = getMOVL(DAG, dl, VT, V[i*2+1], V[i*2]);
7172           break;
7173         case 2:
7174           V[i] = getMOVL(DAG, dl, VT, V[i*2], V[i*2+1]);
7175           break;
7176         case 3:
7177           V[i] = getUnpackl(DAG, dl, VT, V[i*2], V[i*2+1]);
7178           break;
7179       }
7180     }
7181
7182     bool Reverse1 = (NonZeros & 0x3) == 2;
7183     bool Reverse2 = ((NonZeros & (0x3 << 2)) >> 2) == 2;
7184     int MaskVec[] = {
7185       Reverse1 ? 1 : 0,
7186       Reverse1 ? 0 : 1,
7187       static_cast<int>(Reverse2 ? NumElems+1 : NumElems),
7188       static_cast<int>(Reverse2 ? NumElems   : NumElems+1)
7189     };
7190     return DAG.getVectorShuffle(VT, dl, V[0], V[1], &MaskVec[0]);
7191   }
7192
7193   if (Values.size() > 1 && VT.is128BitVector()) {
7194     // Check for a build vector of consecutive loads.
7195     for (unsigned i = 0; i < NumElems; ++i)
7196       V[i] = Op.getOperand(i);
7197
7198     // Check for elements which are consecutive loads.
7199     SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG, false);
7200     if (LD.getNode())
7201       return LD;
7202
7203     // Check for a build vector from mostly shuffle plus few inserting.
7204     SDValue Sh = buildFromShuffleMostly(Op, DAG);
7205     if (Sh.getNode())
7206       return Sh;
7207
7208     // For SSE 4.1, use insertps to put the high elements into the low element.
7209     if (getSubtarget()->hasSSE41()) {
7210       SDValue Result;
7211       if (Op.getOperand(0).getOpcode() != ISD::UNDEF)
7212         Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
7213       else
7214         Result = DAG.getUNDEF(VT);
7215
7216       for (unsigned i = 1; i < NumElems; ++i) {
7217         if (Op.getOperand(i).getOpcode() == ISD::UNDEF) continue;
7218         Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
7219                              Op.getOperand(i), DAG.getIntPtrConstant(i));
7220       }
7221       return Result;
7222     }
7223
7224     // Otherwise, expand into a number of unpckl*, start by extending each of
7225     // our (non-undef) elements to the full vector width with the element in the
7226     // bottom slot of the vector (which generates no code for SSE).
7227     for (unsigned i = 0; i < NumElems; ++i) {
7228       if (Op.getOperand(i).getOpcode() != ISD::UNDEF)
7229         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
7230       else
7231         V[i] = DAG.getUNDEF(VT);
7232     }
7233
7234     // Next, we iteratively mix elements, e.g. for v4f32:
7235     //   Step 1: unpcklps 0, 2 ==> X: <?, ?, 2, 0>
7236     //         : unpcklps 1, 3 ==> Y: <?, ?, 3, 1>
7237     //   Step 2: unpcklps X, Y ==>    <3, 2, 1, 0>
7238     unsigned EltStride = NumElems >> 1;
7239     while (EltStride != 0) {
7240       for (unsigned i = 0; i < EltStride; ++i) {
7241         // If V[i+EltStride] is undef and this is the first round of mixing,
7242         // then it is safe to just drop this shuffle: V[i] is already in the
7243         // right place, the one element (since it's the first round) being
7244         // inserted as undef can be dropped.  This isn't safe for successive
7245         // rounds because they will permute elements within both vectors.
7246         if (V[i+EltStride].getOpcode() == ISD::UNDEF &&
7247             EltStride == NumElems/2)
7248           continue;
7249
7250         V[i] = getUnpackl(DAG, dl, VT, V[i], V[i + EltStride]);
7251       }
7252       EltStride >>= 1;
7253     }
7254     return V[0];
7255   }
7256   return SDValue();
7257 }
7258
7259 // LowerAVXCONCAT_VECTORS - 256-bit AVX can use the vinsertf128 instruction
7260 // to create 256-bit vectors from two other 128-bit ones.
7261 static SDValue LowerAVXCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
7262   SDLoc dl(Op);
7263   MVT ResVT = Op.getSimpleValueType();
7264
7265   assert((ResVT.is256BitVector() ||
7266           ResVT.is512BitVector()) && "Value type must be 256-/512-bit wide");
7267
7268   SDValue V1 = Op.getOperand(0);
7269   SDValue V2 = Op.getOperand(1);
7270   unsigned NumElems = ResVT.getVectorNumElements();
7271   if(ResVT.is256BitVector())
7272     return Concat128BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
7273
7274   if (Op.getNumOperands() == 4) {
7275     MVT HalfVT = MVT::getVectorVT(ResVT.getScalarType(),
7276                                 ResVT.getVectorNumElements()/2);
7277     SDValue V3 = Op.getOperand(2);
7278     SDValue V4 = Op.getOperand(3);
7279     return Concat256BitVectors(Concat128BitVectors(V1, V2, HalfVT, NumElems/2, DAG, dl),
7280       Concat128BitVectors(V3, V4, HalfVT, NumElems/2, DAG, dl), ResVT, NumElems, DAG, dl);
7281   }
7282   return Concat256BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
7283 }
7284
7285 static SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
7286   MVT LLVM_ATTRIBUTE_UNUSED VT = Op.getSimpleValueType();
7287   assert((VT.is256BitVector() && Op.getNumOperands() == 2) ||
7288          (VT.is512BitVector() && (Op.getNumOperands() == 2 ||
7289           Op.getNumOperands() == 4)));
7290
7291   // AVX can use the vinsertf128 instruction to create 256-bit vectors
7292   // from two other 128-bit ones.
7293
7294   // 512-bit vector may contain 2 256-bit vectors or 4 128-bit vectors
7295   return LowerAVXCONCAT_VECTORS(Op, DAG);
7296 }
7297
7298
7299 //===----------------------------------------------------------------------===//
7300 // Vector shuffle lowering
7301 //
7302 // This is an experimental code path for lowering vector shuffles on x86. It is
7303 // designed to handle arbitrary vector shuffles and blends, gracefully
7304 // degrading performance as necessary. It works hard to recognize idiomatic
7305 // shuffles and lower them to optimal instruction patterns without leaving
7306 // a framework that allows reasonably efficient handling of all vector shuffle
7307 // patterns.
7308 //===----------------------------------------------------------------------===//
7309
7310 /// \brief Tiny helper function to identify a no-op mask.
7311 ///
7312 /// This is a somewhat boring predicate function. It checks whether the mask
7313 /// array input, which is assumed to be a single-input shuffle mask of the kind
7314 /// used by the X86 shuffle instructions (not a fully general
7315 /// ShuffleVectorSDNode mask) requires any shuffles to occur. Both undef and an
7316 /// in-place shuffle are 'no-op's.
7317 static bool isNoopShuffleMask(ArrayRef<int> Mask) {
7318   for (int i = 0, Size = Mask.size(); i < Size; ++i)
7319     if (Mask[i] != -1 && Mask[i] != i)
7320       return false;
7321   return true;
7322 }
7323
7324 /// \brief Helper function to classify a mask as a single-input mask.
7325 ///
7326 /// This isn't a generic single-input test because in the vector shuffle
7327 /// lowering we canonicalize single inputs to be the first input operand. This
7328 /// means we can more quickly test for a single input by only checking whether
7329 /// an input from the second operand exists. We also assume that the size of
7330 /// mask corresponds to the size of the input vectors which isn't true in the
7331 /// fully general case.
7332 static bool isSingleInputShuffleMask(ArrayRef<int> Mask) {
7333   for (int M : Mask)
7334     if (M >= (int)Mask.size())
7335       return false;
7336   return true;
7337 }
7338
7339 /// \brief Test whether there are elements crossing 128-bit lanes in this
7340 /// shuffle mask.
7341 ///
7342 /// X86 divides up its shuffles into in-lane and cross-lane shuffle operations
7343 /// and we routinely test for these.
7344 static bool is128BitLaneCrossingShuffleMask(MVT VT, ArrayRef<int> Mask) {
7345   int LaneSize = 128 / VT.getScalarSizeInBits();
7346   int Size = Mask.size();
7347   for (int i = 0; i < Size; ++i)
7348     if (Mask[i] >= 0 && (Mask[i] % Size) / LaneSize != i / LaneSize)
7349       return true;
7350   return false;
7351 }
7352
7353 /// \brief Test whether a shuffle mask is equivalent within each 128-bit lane.
7354 ///
7355 /// This checks a shuffle mask to see if it is performing the same
7356 /// 128-bit lane-relative shuffle in each 128-bit lane. This trivially implies
7357 /// that it is also not lane-crossing. It may however involve a blend from the
7358 /// same lane of a second vector.
7359 ///
7360 /// The specific repeated shuffle mask is populated in \p RepeatedMask, as it is
7361 /// non-trivial to compute in the face of undef lanes. The representation is
7362 /// *not* suitable for use with existing 128-bit shuffles as it will contain
7363 /// entries from both V1 and V2 inputs to the wider mask.
7364 static bool
7365 is128BitLaneRepeatedShuffleMask(MVT VT, ArrayRef<int> Mask,
7366                                 SmallVectorImpl<int> &RepeatedMask) {
7367   int LaneSize = 128 / VT.getScalarSizeInBits();
7368   RepeatedMask.resize(LaneSize, -1);
7369   int Size = Mask.size();
7370   for (int i = 0; i < Size; ++i) {
7371     if (Mask[i] < 0)
7372       continue;
7373     if ((Mask[i] % Size) / LaneSize != i / LaneSize)
7374       // This entry crosses lanes, so there is no way to model this shuffle.
7375       return false;
7376
7377     // Ok, handle the in-lane shuffles by detecting if and when they repeat.
7378     if (RepeatedMask[i % LaneSize] == -1)
7379       // This is the first non-undef entry in this slot of a 128-bit lane.
7380       RepeatedMask[i % LaneSize] =
7381           Mask[i] < Size ? Mask[i] % LaneSize : Mask[i] % LaneSize + Size;
7382     else if (RepeatedMask[i % LaneSize] + (i / LaneSize) * LaneSize != Mask[i])
7383       // Found a mismatch with the repeated mask.
7384       return false;
7385   }
7386   return true;
7387 }
7388
7389 // Hide this symbol with an anonymous namespace instead of 'static' so that MSVC
7390 // 2013 will allow us to use it as a non-type template parameter.
7391 namespace {
7392
7393 /// \brief Implementation of the \c isShuffleEquivalent variadic functor.
7394 ///
7395 /// See its documentation for details.
7396 bool isShuffleEquivalentImpl(ArrayRef<int> Mask, ArrayRef<const int *> Args) {
7397   if (Mask.size() != Args.size())
7398     return false;
7399   for (int i = 0, e = Mask.size(); i < e; ++i) {
7400     assert(*Args[i] >= 0 && "Arguments must be positive integers!");
7401     if (Mask[i] != -1 && Mask[i] != *Args[i])
7402       return false;
7403   }
7404   return true;
7405 }
7406
7407 } // namespace
7408
7409 /// \brief Checks whether a shuffle mask is equivalent to an explicit list of
7410 /// arguments.
7411 ///
7412 /// This is a fast way to test a shuffle mask against a fixed pattern:
7413 ///
7414 ///   if (isShuffleEquivalent(Mask, 3, 2, 1, 0)) { ... }
7415 ///
7416 /// It returns true if the mask is exactly as wide as the argument list, and
7417 /// each element of the mask is either -1 (signifying undef) or the value given
7418 /// in the argument.
7419 static const VariadicFunction1<
7420     bool, ArrayRef<int>, int, isShuffleEquivalentImpl> isShuffleEquivalent = {};
7421
7422 /// \brief Get a 4-lane 8-bit shuffle immediate for a mask.
7423 ///
7424 /// This helper function produces an 8-bit shuffle immediate corresponding to
7425 /// the ubiquitous shuffle encoding scheme used in x86 instructions for
7426 /// shuffling 4 lanes. It can be used with most of the PSHUF instructions for
7427 /// example.
7428 ///
7429 /// NB: We rely heavily on "undef" masks preserving the input lane.
7430 static SDValue getV4X86ShuffleImm8ForMask(ArrayRef<int> Mask,
7431                                           SelectionDAG &DAG) {
7432   assert(Mask.size() == 4 && "Only 4-lane shuffle masks");
7433   assert(Mask[0] >= -1 && Mask[0] < 4 && "Out of bound mask element!");
7434   assert(Mask[1] >= -1 && Mask[1] < 4 && "Out of bound mask element!");
7435   assert(Mask[2] >= -1 && Mask[2] < 4 && "Out of bound mask element!");
7436   assert(Mask[3] >= -1 && Mask[3] < 4 && "Out of bound mask element!");
7437
7438   unsigned Imm = 0;
7439   Imm |= (Mask[0] == -1 ? 0 : Mask[0]) << 0;
7440   Imm |= (Mask[1] == -1 ? 1 : Mask[1]) << 2;
7441   Imm |= (Mask[2] == -1 ? 2 : Mask[2]) << 4;
7442   Imm |= (Mask[3] == -1 ? 3 : Mask[3]) << 6;
7443   return DAG.getConstant(Imm, MVT::i8);
7444 }
7445
7446 /// \brief Try to emit a blend instruction for a shuffle.
7447 ///
7448 /// This doesn't do any checks for the availability of instructions for blending
7449 /// these values. It relies on the availability of the X86ISD::BLENDI pattern to
7450 /// be matched in the backend with the type given. What it does check for is
7451 /// that the shuffle mask is in fact a blend.
7452 static SDValue lowerVectorShuffleAsBlend(SDLoc DL, MVT VT, SDValue V1,
7453                                          SDValue V2, ArrayRef<int> Mask,
7454                                          const X86Subtarget *Subtarget,
7455                                          SelectionDAG &DAG) {
7456
7457   unsigned BlendMask = 0;
7458   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
7459     if (Mask[i] >= Size) {
7460       if (Mask[i] != i + Size)
7461         return SDValue(); // Shuffled V2 input!
7462       BlendMask |= 1u << i;
7463       continue;
7464     }
7465     if (Mask[i] >= 0 && Mask[i] != i)
7466       return SDValue(); // Shuffled V1 input!
7467   }
7468   switch (VT.SimpleTy) {
7469   case MVT::v2f64:
7470   case MVT::v4f32:
7471   case MVT::v4f64:
7472   case MVT::v8f32:
7473     return DAG.getNode(X86ISD::BLENDI, DL, VT, V1, V2,
7474                        DAG.getConstant(BlendMask, MVT::i8));
7475
7476   case MVT::v4i64:
7477   case MVT::v8i32:
7478     assert(Subtarget->hasAVX2() && "256-bit integer blends require AVX2!");
7479     // FALLTHROUGH
7480   case MVT::v2i64:
7481   case MVT::v4i32:
7482     // If we have AVX2 it is faster to use VPBLENDD when the shuffle fits into
7483     // that instruction.
7484     if (Subtarget->hasAVX2()) {
7485       // Scale the blend by the number of 32-bit dwords per element.
7486       int Scale =  VT.getScalarSizeInBits() / 32;
7487       BlendMask = 0;
7488       for (int i = 0, Size = Mask.size(); i < Size; ++i)
7489         if (Mask[i] >= Size)
7490           for (int j = 0; j < Scale; ++j)
7491             BlendMask |= 1u << (i * Scale + j);
7492
7493       MVT BlendVT = VT.getSizeInBits() > 128 ? MVT::v8i32 : MVT::v4i32;
7494       V1 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V1);
7495       V2 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V2);
7496       return DAG.getNode(ISD::BITCAST, DL, VT,
7497                          DAG.getNode(X86ISD::BLENDI, DL, BlendVT, V1, V2,
7498                                      DAG.getConstant(BlendMask, MVT::i8)));
7499     }
7500     // FALLTHROUGH
7501   case MVT::v8i16: {
7502     // For integer shuffles we need to expand the mask and cast the inputs to
7503     // v8i16s prior to blending.
7504     int Scale = 8 / VT.getVectorNumElements();
7505     BlendMask = 0;
7506     for (int i = 0, Size = Mask.size(); i < Size; ++i)
7507       if (Mask[i] >= Size)
7508         for (int j = 0; j < Scale; ++j)
7509           BlendMask |= 1u << (i * Scale + j);
7510
7511     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1);
7512     V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V2);
7513     return DAG.getNode(ISD::BITCAST, DL, VT,
7514                        DAG.getNode(X86ISD::BLENDI, DL, MVT::v8i16, V1, V2,
7515                                    DAG.getConstant(BlendMask, MVT::i8)));
7516   }
7517
7518   case MVT::v16i16: {
7519     assert(Subtarget->hasAVX2() && "256-bit integer blends require AVX2!");
7520     SmallVector<int, 8> RepeatedMask;
7521     if (is128BitLaneRepeatedShuffleMask(MVT::v16i16, Mask, RepeatedMask)) {
7522       // We can lower these with PBLENDW which is mirrored across 128-bit lanes.
7523       assert(RepeatedMask.size() == 8 && "Repeated mask size doesn't match!");
7524       BlendMask = 0;
7525       for (int i = 0; i < 8; ++i)
7526         if (RepeatedMask[i] >= 16)
7527           BlendMask |= 1u << i;
7528       return DAG.getNode(X86ISD::BLENDI, DL, MVT::v16i16, V1, V2,
7529                          DAG.getConstant(BlendMask, MVT::i8));
7530     }
7531   }
7532     // FALLTHROUGH
7533   case MVT::v32i8: {
7534     assert(Subtarget->hasAVX2() && "256-bit integer blends require AVX2!");
7535     // Scale the blend by the number of bytes per element.
7536     int Scale =  VT.getScalarSizeInBits() / 8;
7537     assert(Mask.size() * Scale == 32 && "Not a 256-bit vector!");
7538
7539     // Compute the VSELECT mask. Note that VSELECT is really confusing in the
7540     // mix of LLVM's code generator and the x86 backend. We tell the code
7541     // generator that boolean values in the elements of an x86 vector register
7542     // are -1 for true and 0 for false. We then use the LLVM semantics of 'true'
7543     // mapping a select to operand #1, and 'false' mapping to operand #2. The
7544     // reality in x86 is that vector masks (pre-AVX-512) use only the high bit
7545     // of the element (the remaining are ignored) and 0 in that high bit would
7546     // mean operand #1 while 1 in the high bit would mean operand #2. So while
7547     // the LLVM model for boolean values in vector elements gets the relevant
7548     // bit set, it is set backwards and over constrained relative to x86's
7549     // actual model.
7550     SDValue VSELECTMask[32];
7551     for (int i = 0, Size = Mask.size(); i < Size; ++i)
7552       for (int j = 0; j < Scale; ++j)
7553         VSELECTMask[Scale * i + j] =
7554             Mask[i] < 0 ? DAG.getUNDEF(MVT::i8)
7555                         : DAG.getConstant(Mask[i] < Size ? -1 : 0, MVT::i8);
7556
7557     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, V1);
7558     V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, V2);
7559     return DAG.getNode(
7560         ISD::BITCAST, DL, VT,
7561         DAG.getNode(ISD::VSELECT, DL, MVT::v32i8,
7562                     DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, VSELECTMask),
7563                     V1, V2));
7564   }
7565
7566   default:
7567     llvm_unreachable("Not a supported integer vector type!");
7568   }
7569 }
7570
7571 /// \brief Generic routine to lower a shuffle and blend as a decomposed set of
7572 /// unblended shuffles followed by an unshuffled blend.
7573 ///
7574 /// This matches the extremely common pattern for handling combined
7575 /// shuffle+blend operations on newer X86 ISAs where we have very fast blend
7576 /// operations.
7577 static SDValue lowerVectorShuffleAsDecomposedShuffleBlend(SDLoc DL, MVT VT,
7578                                                           SDValue V1,
7579                                                           SDValue V2,
7580                                                           ArrayRef<int> Mask,
7581                                                           SelectionDAG &DAG) {
7582   // Shuffle the input elements into the desired positions in V1 and V2 and
7583   // blend them together.
7584   SmallVector<int, 32> V1Mask(Mask.size(), -1);
7585   SmallVector<int, 32> V2Mask(Mask.size(), -1);
7586   SmallVector<int, 32> BlendMask(Mask.size(), -1);
7587   for (int i = 0, Size = Mask.size(); i < Size; ++i)
7588     if (Mask[i] >= 0 && Mask[i] < Size) {
7589       V1Mask[i] = Mask[i];
7590       BlendMask[i] = i;
7591     } else if (Mask[i] >= Size) {
7592       V2Mask[i] = Mask[i] - Size;
7593       BlendMask[i] = i + Size;
7594     }
7595
7596   V1 = DAG.getVectorShuffle(VT, DL, V1, DAG.getUNDEF(VT), V1Mask);
7597   V2 = DAG.getVectorShuffle(VT, DL, V2, DAG.getUNDEF(VT), V2Mask);
7598   return DAG.getVectorShuffle(VT, DL, V1, V2, BlendMask);
7599 }
7600
7601 /// \brief Try to lower a vector shuffle as a byte rotation.
7602 ///
7603 /// SSSE3 has a generic PALIGNR instruction in x86 that will do an arbitrary
7604 /// byte-rotation of the concatenation of two vectors; pre-SSSE3 can use
7605 /// a PSRLDQ/PSLLDQ/POR pattern to get a similar effect. This routine will
7606 /// try to generically lower a vector shuffle through such an pattern. It
7607 /// does not check for the profitability of lowering either as PALIGNR or
7608 /// PSRLDQ/PSLLDQ/POR, only whether the mask is valid to lower in that form.
7609 /// This matches shuffle vectors that look like:
7610 ///
7611 ///   v8i16 [11, 12, 13, 14, 15, 0, 1, 2]
7612 ///
7613 /// Essentially it concatenates V1 and V2, shifts right by some number of
7614 /// elements, and takes the low elements as the result. Note that while this is
7615 /// specified as a *right shift* because x86 is little-endian, it is a *left
7616 /// rotate* of the vector lanes.
7617 ///
7618 /// Note that this only handles 128-bit vector widths currently.
7619 static SDValue lowerVectorShuffleAsByteRotate(SDLoc DL, MVT VT, SDValue V1,
7620                                               SDValue V2,
7621                                               ArrayRef<int> Mask,
7622                                               const X86Subtarget *Subtarget,
7623                                               SelectionDAG &DAG) {
7624   assert(!isNoopShuffleMask(Mask) && "We shouldn't lower no-op shuffles!");
7625
7626   // We need to detect various ways of spelling a rotation:
7627   //   [11, 12, 13, 14, 15,  0,  1,  2]
7628   //   [-1, 12, 13, 14, -1, -1,  1, -1]
7629   //   [-1, -1, -1, -1, -1, -1,  1,  2]
7630   //   [ 3,  4,  5,  6,  7,  8,  9, 10]
7631   //   [-1,  4,  5,  6, -1, -1,  9, -1]
7632   //   [-1,  4,  5,  6, -1, -1, -1, -1]
7633   int Rotation = 0;
7634   SDValue Lo, Hi;
7635   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
7636     if (Mask[i] == -1)
7637       continue;
7638     assert(Mask[i] >= 0 && "Only -1 is a valid negative mask element!");
7639
7640     // Based on the mod-Size value of this mask element determine where
7641     // a rotated vector would have started.
7642     int StartIdx = i - (Mask[i] % Size);
7643     if (StartIdx == 0)
7644       // The identity rotation isn't interesting, stop.
7645       return SDValue();
7646
7647     // If we found the tail of a vector the rotation must be the missing
7648     // front. If we found the head of a vector, it must be how much of the head.
7649     int CandidateRotation = StartIdx < 0 ? -StartIdx : Size - StartIdx;
7650
7651     if (Rotation == 0)
7652       Rotation = CandidateRotation;
7653     else if (Rotation != CandidateRotation)
7654       // The rotations don't match, so we can't match this mask.
7655       return SDValue();
7656
7657     // Compute which value this mask is pointing at.
7658     SDValue MaskV = Mask[i] < Size ? V1 : V2;
7659
7660     // Compute which of the two target values this index should be assigned to.
7661     // This reflects whether the high elements are remaining or the low elements
7662     // are remaining.
7663     SDValue &TargetV = StartIdx < 0 ? Hi : Lo;
7664
7665     // Either set up this value if we've not encountered it before, or check
7666     // that it remains consistent.
7667     if (!TargetV)
7668       TargetV = MaskV;
7669     else if (TargetV != MaskV)
7670       // This may be a rotation, but it pulls from the inputs in some
7671       // unsupported interleaving.
7672       return SDValue();
7673   }
7674
7675   // Check that we successfully analyzed the mask, and normalize the results.
7676   assert(Rotation != 0 && "Failed to locate a viable rotation!");
7677   assert((Lo || Hi) && "Failed to find a rotated input vector!");
7678   if (!Lo)
7679     Lo = Hi;
7680   else if (!Hi)
7681     Hi = Lo;
7682
7683   assert(VT.getSizeInBits() == 128 &&
7684          "Rotate-based lowering only supports 128-bit lowering!");
7685   assert(Mask.size() <= 16 &&
7686          "Can shuffle at most 16 bytes in a 128-bit vector!");
7687
7688   // The actual rotate instruction rotates bytes, so we need to scale the
7689   // rotation based on how many bytes are in the vector.
7690   int Scale = 16 / Mask.size();
7691
7692   // SSSE3 targets can use the palignr instruction
7693   if (Subtarget->hasSSSE3()) {
7694     // Cast the inputs to v16i8 to match PALIGNR.
7695     Lo = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Lo);
7696     Hi = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Hi);
7697
7698     return DAG.getNode(ISD::BITCAST, DL, VT,
7699                        DAG.getNode(X86ISD::PALIGNR, DL, MVT::v16i8, Hi, Lo,
7700                                    DAG.getConstant(Rotation * Scale, MVT::i8)));
7701   }
7702
7703   // Default SSE2 implementation
7704   int LoByteShift = 16 - Rotation * Scale;
7705   int HiByteShift = Rotation * Scale;
7706
7707   // Cast the inputs to v2i64 to match PSLLDQ/PSRLDQ.
7708   Lo = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Lo);
7709   Hi = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Hi);
7710
7711   SDValue LoShift = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v2i64, Lo,
7712                                 DAG.getConstant(8 * LoByteShift, MVT::i8));
7713   SDValue HiShift = DAG.getNode(X86ISD::VSRLDQ, DL, MVT::v2i64, Hi,
7714                                 DAG.getConstant(8 * HiByteShift, MVT::i8));
7715   return DAG.getNode(ISD::BITCAST, DL, VT,
7716                      DAG.getNode(ISD::OR, DL, MVT::v2i64, LoShift, HiShift));
7717 }
7718
7719 /// \brief Compute whether each element of a shuffle is zeroable.
7720 ///
7721 /// A "zeroable" vector shuffle element is one which can be lowered to zero.
7722 /// Either it is an undef element in the shuffle mask, the element of the input
7723 /// referenced is undef, or the element of the input referenced is known to be
7724 /// zero. Many x86 shuffles can zero lanes cheaply and we often want to handle
7725 /// as many lanes with this technique as possible to simplify the remaining
7726 /// shuffle.
7727 static SmallBitVector computeZeroableShuffleElements(ArrayRef<int> Mask,
7728                                                      SDValue V1, SDValue V2) {
7729   SmallBitVector Zeroable(Mask.size(), false);
7730
7731   bool V1IsZero = ISD::isBuildVectorAllZeros(V1.getNode());
7732   bool V2IsZero = ISD::isBuildVectorAllZeros(V2.getNode());
7733
7734   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
7735     int M = Mask[i];
7736     // Handle the easy cases.
7737     if (M < 0 || (M >= 0 && M < Size && V1IsZero) || (M >= Size && V2IsZero)) {
7738       Zeroable[i] = true;
7739       continue;
7740     }
7741
7742     // If this is an index into a build_vector node, dig out the input value and
7743     // use it.
7744     SDValue V = M < Size ? V1 : V2;
7745     if (V.getOpcode() != ISD::BUILD_VECTOR)
7746       continue;
7747
7748     SDValue Input = V.getOperand(M % Size);
7749     // The UNDEF opcode check really should be dead code here, but not quite
7750     // worth asserting on (it isn't invalid, just unexpected).
7751     if (Input.getOpcode() == ISD::UNDEF || X86::isZeroNode(Input))
7752       Zeroable[i] = true;
7753   }
7754
7755   return Zeroable;
7756 }
7757
7758 /// \brief Try to lower a vector shuffle as a byte shift (shifts in zeros).
7759 ///
7760 /// Attempts to match a shuffle mask against the PSRLDQ and PSLLDQ SSE2
7761 /// byte-shift instructions. The mask must consist of a shifted sequential
7762 /// shuffle from one of the input vectors and zeroable elements for the
7763 /// remaining 'shifted in' elements.
7764 ///
7765 /// Note that this only handles 128-bit vector widths currently.
7766 static SDValue lowerVectorShuffleAsByteShift(SDLoc DL, MVT VT, SDValue V1,
7767                                              SDValue V2, ArrayRef<int> Mask,
7768                                              SelectionDAG &DAG) {
7769   assert(!isNoopShuffleMask(Mask) && "We shouldn't lower no-op shuffles!");
7770
7771   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
7772
7773   int Size = Mask.size();
7774   int Scale = 16 / Size;
7775
7776   for (int Shift = 1; Shift < Size; Shift++) {
7777     int ByteShift = Shift * Scale;
7778
7779     // PSRLDQ : (little-endian) right byte shift
7780     // [ 5,  6,  7, zz, zz, zz, zz, zz]
7781     // [ -1, 5,  6,  7, zz, zz, zz, zz]
7782     // [  1, 2, -1, -1, -1, -1, zz, zz]
7783     bool ZeroableRight = true;
7784     for (int i = Size - Shift; i < Size; i++) {
7785       ZeroableRight &= Zeroable[i];
7786     }
7787
7788     if (ZeroableRight) {
7789       bool ValidShiftRight1 =
7790           isSequentialOrUndefInRange(Mask, 0, Size - Shift, Shift);
7791       bool ValidShiftRight2 =
7792           isSequentialOrUndefInRange(Mask, 0, Size - Shift, Size + Shift);
7793
7794       if (ValidShiftRight1 || ValidShiftRight2) {
7795         // Cast the inputs to v2i64 to match PSRLDQ.
7796         SDValue &TargetV = ValidShiftRight1 ? V1 : V2;
7797         SDValue V = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, TargetV);
7798         SDValue Shifted = DAG.getNode(X86ISD::VSRLDQ, DL, MVT::v2i64, V,
7799                                       DAG.getConstant(ByteShift * 8, MVT::i8));
7800         return DAG.getNode(ISD::BITCAST, DL, VT, Shifted);
7801       }
7802     }
7803
7804     // PSLLDQ : (little-endian) left byte shift
7805     // [ zz,  0,  1,  2,  3,  4,  5,  6]
7806     // [ zz, zz, -1, -1,  2,  3,  4, -1]
7807     // [ zz, zz, zz, zz, zz, zz, -1,  1]
7808     bool ZeroableLeft = true;
7809     for (int i = 0; i < Shift; i++) {
7810       ZeroableLeft &= Zeroable[i];
7811     }
7812
7813     if (ZeroableLeft) {
7814       bool ValidShiftLeft1 =
7815           isSequentialOrUndefInRange(Mask, Shift, Size - Shift, 0);
7816       bool ValidShiftLeft2 =
7817           isSequentialOrUndefInRange(Mask, Shift, Size - Shift, Size);
7818
7819       if (ValidShiftLeft1 || ValidShiftLeft2) {
7820         // Cast the inputs to v2i64 to match PSLLDQ.
7821         SDValue &TargetV = ValidShiftLeft1 ? V1 : V2;
7822         SDValue V = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, TargetV);
7823         SDValue Shifted = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v2i64, V,
7824                                       DAG.getConstant(ByteShift * 8, MVT::i8));
7825         return DAG.getNode(ISD::BITCAST, DL, VT, Shifted);
7826       }
7827     }
7828   }
7829
7830   return SDValue();
7831 }
7832
7833 /// \brief Lower a vector shuffle as a zero or any extension.
7834 ///
7835 /// Given a specific number of elements, element bit width, and extension
7836 /// stride, produce either a zero or any extension based on the available
7837 /// features of the subtarget.
7838 static SDValue lowerVectorShuffleAsSpecificZeroOrAnyExtend(
7839     SDLoc DL, MVT VT, int NumElements, int Scale, bool AnyExt, SDValue InputV,
7840     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
7841   assert(Scale > 1 && "Need a scale to extend.");
7842   int EltBits = VT.getSizeInBits() / NumElements;
7843   assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
7844          "Only 8, 16, and 32 bit elements can be extended.");
7845   assert(Scale * EltBits <= 64 && "Cannot zero extend past 64 bits.");
7846
7847   // Found a valid zext mask! Try various lowering strategies based on the
7848   // input type and available ISA extensions.
7849   if (Subtarget->hasSSE41()) {
7850     MVT InputVT = MVT::getVectorVT(MVT::getIntegerVT(EltBits), NumElements);
7851     MVT ExtVT = MVT::getVectorVT(MVT::getIntegerVT(EltBits * Scale),
7852                                  NumElements / Scale);
7853     InputV = DAG.getNode(ISD::BITCAST, DL, InputVT, InputV);
7854     return DAG.getNode(ISD::BITCAST, DL, VT,
7855                        DAG.getNode(X86ISD::VZEXT, DL, ExtVT, InputV));
7856   }
7857
7858   // For any extends we can cheat for larger element sizes and use shuffle
7859   // instructions that can fold with a load and/or copy.
7860   if (AnyExt && EltBits == 32) {
7861     int PSHUFDMask[4] = {0, -1, 1, -1};
7862     return DAG.getNode(
7863         ISD::BITCAST, DL, VT,
7864         DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
7865                     DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, InputV),
7866                     getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
7867   }
7868   if (AnyExt && EltBits == 16 && Scale > 2) {
7869     int PSHUFDMask[4] = {0, -1, 0, -1};
7870     InputV = DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
7871                          DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, InputV),
7872                          getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG));
7873     int PSHUFHWMask[4] = {1, -1, -1, -1};
7874     return DAG.getNode(
7875         ISD::BITCAST, DL, VT,
7876         DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16,
7877                     DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, InputV),
7878                     getV4X86ShuffleImm8ForMask(PSHUFHWMask, DAG)));
7879   }
7880
7881   // If this would require more than 2 unpack instructions to expand, use
7882   // pshufb when available. We can only use more than 2 unpack instructions
7883   // when zero extending i8 elements which also makes it easier to use pshufb.
7884   if (Scale > 4 && EltBits == 8 && Subtarget->hasSSSE3()) {
7885     assert(NumElements == 16 && "Unexpected byte vector width!");
7886     SDValue PSHUFBMask[16];
7887     for (int i = 0; i < 16; ++i)
7888       PSHUFBMask[i] =
7889           DAG.getConstant((i % Scale == 0) ? i / Scale : 0x80, MVT::i8);
7890     InputV = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, InputV);
7891     return DAG.getNode(ISD::BITCAST, DL, VT,
7892                        DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, InputV,
7893                                    DAG.getNode(ISD::BUILD_VECTOR, DL,
7894                                                MVT::v16i8, PSHUFBMask)));
7895   }
7896
7897   // Otherwise emit a sequence of unpacks.
7898   do {
7899     MVT InputVT = MVT::getVectorVT(MVT::getIntegerVT(EltBits), NumElements);
7900     SDValue Ext = AnyExt ? DAG.getUNDEF(InputVT)
7901                          : getZeroVector(InputVT, Subtarget, DAG, DL);
7902     InputV = DAG.getNode(ISD::BITCAST, DL, InputVT, InputV);
7903     InputV = DAG.getNode(X86ISD::UNPCKL, DL, InputVT, InputV, Ext);
7904     Scale /= 2;
7905     EltBits *= 2;
7906     NumElements /= 2;
7907   } while (Scale > 1);
7908   return DAG.getNode(ISD::BITCAST, DL, VT, InputV);
7909 }
7910
7911 /// \brief Try to lower a vector shuffle as a zero extension on any micrarch.
7912 ///
7913 /// This routine will try to do everything in its power to cleverly lower
7914 /// a shuffle which happens to match the pattern of a zero extend. It doesn't
7915 /// check for the profitability of this lowering,  it tries to aggressively
7916 /// match this pattern. It will use all of the micro-architectural details it
7917 /// can to emit an efficient lowering. It handles both blends with all-zero
7918 /// inputs to explicitly zero-extend and undef-lanes (sometimes undef due to
7919 /// masking out later).
7920 ///
7921 /// The reason we have dedicated lowering for zext-style shuffles is that they
7922 /// are both incredibly common and often quite performance sensitive.
7923 static SDValue lowerVectorShuffleAsZeroOrAnyExtend(
7924     SDLoc DL, MVT VT, SDValue V1, SDValue V2, ArrayRef<int> Mask,
7925     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
7926   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
7927
7928   int Bits = VT.getSizeInBits();
7929   int NumElements = Mask.size();
7930
7931   // Define a helper function to check a particular ext-scale and lower to it if
7932   // valid.
7933   auto Lower = [&](int Scale) -> SDValue {
7934     SDValue InputV;
7935     bool AnyExt = true;
7936     for (int i = 0; i < NumElements; ++i) {
7937       if (Mask[i] == -1)
7938         continue; // Valid anywhere but doesn't tell us anything.
7939       if (i % Scale != 0) {
7940         // Each of the extend elements needs to be zeroable.
7941         if (!Zeroable[i])
7942           return SDValue();
7943
7944         // We no lorger are in the anyext case.
7945         AnyExt = false;
7946         continue;
7947       }
7948
7949       // Each of the base elements needs to be consecutive indices into the
7950       // same input vector.
7951       SDValue V = Mask[i] < NumElements ? V1 : V2;
7952       if (!InputV)
7953         InputV = V;
7954       else if (InputV != V)
7955         return SDValue(); // Flip-flopping inputs.
7956
7957       if (Mask[i] % NumElements != i / Scale)
7958         return SDValue(); // Non-consecutive strided elemenst.
7959     }
7960
7961     // If we fail to find an input, we have a zero-shuffle which should always
7962     // have already been handled.
7963     // FIXME: Maybe handle this here in case during blending we end up with one?
7964     if (!InputV)
7965       return SDValue();
7966
7967     return lowerVectorShuffleAsSpecificZeroOrAnyExtend(
7968         DL, VT, NumElements, Scale, AnyExt, InputV, Subtarget, DAG);
7969   };
7970
7971   // The widest scale possible for extending is to a 64-bit integer.
7972   assert(Bits % 64 == 0 &&
7973          "The number of bits in a vector must be divisible by 64 on x86!");
7974   int NumExtElements = Bits / 64;
7975
7976   // Each iteration, try extending the elements half as much, but into twice as
7977   // many elements.
7978   for (; NumExtElements < NumElements; NumExtElements *= 2) {
7979     assert(NumElements % NumExtElements == 0 &&
7980            "The input vector size must be divisble by the extended size.");
7981     if (SDValue V = Lower(NumElements / NumExtElements))
7982       return V;
7983   }
7984
7985   // No viable ext lowering found.
7986   return SDValue();
7987 }
7988
7989 /// \brief Try to get a scalar value for a specific element of a vector.
7990 ///
7991 /// Looks through BUILD_VECTOR and SCALAR_TO_VECTOR nodes to find a scalar.
7992 static SDValue getScalarValueForVectorElement(SDValue V, int Idx,
7993                                               SelectionDAG &DAG) {
7994   MVT VT = V.getSimpleValueType();
7995   MVT EltVT = VT.getVectorElementType();
7996   while (V.getOpcode() == ISD::BITCAST)
7997     V = V.getOperand(0);
7998   // If the bitcasts shift the element size, we can't extract an equivalent
7999   // element from it.
8000   MVT NewVT = V.getSimpleValueType();
8001   if (!NewVT.isVector() || NewVT.getScalarSizeInBits() != VT.getScalarSizeInBits())
8002     return SDValue();
8003
8004   if (V.getOpcode() == ISD::BUILD_VECTOR ||
8005       (Idx == 0 && V.getOpcode() == ISD::SCALAR_TO_VECTOR))
8006     return DAG.getNode(ISD::BITCAST, SDLoc(V), EltVT, V.getOperand(Idx));
8007
8008   return SDValue();
8009 }
8010
8011 /// \brief Helper to test for a load that can be folded with x86 shuffles.
8012 ///
8013 /// This is particularly important because the set of instructions varies
8014 /// significantly based on whether the operand is a load or not.
8015 static bool isShuffleFoldableLoad(SDValue V) {
8016   while (V.getOpcode() == ISD::BITCAST)
8017     V = V.getOperand(0);
8018
8019   return ISD::isNON_EXTLoad(V.getNode());
8020 }
8021
8022 /// \brief Try to lower insertion of a single element into a zero vector.
8023 ///
8024 /// This is a common pattern that we have especially efficient patterns to lower
8025 /// across all subtarget feature sets.
8026 static SDValue lowerVectorShuffleAsElementInsertion(
8027     MVT VT, SDLoc DL, SDValue V1, SDValue V2, ArrayRef<int> Mask,
8028     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
8029   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
8030   MVT ExtVT = VT;
8031   MVT EltVT = VT.getVectorElementType();
8032
8033   int V2Index = std::find_if(Mask.begin(), Mask.end(),
8034                              [&Mask](int M) { return M >= (int)Mask.size(); }) -
8035                 Mask.begin();
8036   bool IsV1Zeroable = true;
8037   for (int i = 0, Size = Mask.size(); i < Size; ++i)
8038     if (i != V2Index && !Zeroable[i]) {
8039       IsV1Zeroable = false;
8040       break;
8041     }
8042
8043   // Check for a single input from a SCALAR_TO_VECTOR node.
8044   // FIXME: All of this should be canonicalized into INSERT_VECTOR_ELT and
8045   // all the smarts here sunk into that routine. However, the current
8046   // lowering of BUILD_VECTOR makes that nearly impossible until the old
8047   // vector shuffle lowering is dead.
8048   if (SDValue V2S = getScalarValueForVectorElement(
8049           V2, Mask[V2Index] - Mask.size(), DAG)) {
8050     // We need to zext the scalar if it is smaller than an i32.
8051     V2S = DAG.getNode(ISD::BITCAST, DL, EltVT, V2S);
8052     if (EltVT == MVT::i8 || EltVT == MVT::i16) {
8053       // Using zext to expand a narrow element won't work for non-zero
8054       // insertions.
8055       if (!IsV1Zeroable)
8056         return SDValue();
8057
8058       // Zero-extend directly to i32.
8059       ExtVT = MVT::v4i32;
8060       V2S = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, V2S);
8061     }
8062     V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, ExtVT, V2S);
8063   } else if (Mask[V2Index] != (int)Mask.size() || EltVT == MVT::i8 ||
8064              EltVT == MVT::i16) {
8065     // Either not inserting from the low element of the input or the input
8066     // element size is too small to use VZEXT_MOVL to clear the high bits.
8067     return SDValue();
8068   }
8069
8070   if (!IsV1Zeroable) {
8071     // If V1 can't be treated as a zero vector we have fewer options to lower
8072     // this. We can't support integer vectors or non-zero targets cheaply, and
8073     // the V1 elements can't be permuted in any way.
8074     assert(VT == ExtVT && "Cannot change extended type when non-zeroable!");
8075     if (!VT.isFloatingPoint() || V2Index != 0)
8076       return SDValue();
8077     SmallVector<int, 8> V1Mask(Mask.begin(), Mask.end());
8078     V1Mask[V2Index] = -1;
8079     if (!isNoopShuffleMask(V1Mask))
8080       return SDValue();
8081     // This is essentially a special case blend operation, but if we have
8082     // general purpose blend operations, they are always faster. Bail and let
8083     // the rest of the lowering handle these as blends.
8084     if (Subtarget->hasSSE41())
8085       return SDValue();
8086
8087     // Otherwise, use MOVSD or MOVSS.
8088     assert((EltVT == MVT::f32 || EltVT == MVT::f64) &&
8089            "Only two types of floating point element types to handle!");
8090     return DAG.getNode(EltVT == MVT::f32 ? X86ISD::MOVSS : X86ISD::MOVSD, DL,
8091                        ExtVT, V1, V2);
8092   }
8093
8094   V2 = DAG.getNode(X86ISD::VZEXT_MOVL, DL, ExtVT, V2);
8095   if (ExtVT != VT)
8096     V2 = DAG.getNode(ISD::BITCAST, DL, VT, V2);
8097
8098   if (V2Index != 0) {
8099     // If we have 4 or fewer lanes we can cheaply shuffle the element into
8100     // the desired position. Otherwise it is more efficient to do a vector
8101     // shift left. We know that we can do a vector shift left because all
8102     // the inputs are zero.
8103     if (VT.isFloatingPoint() || VT.getVectorNumElements() <= 4) {
8104       SmallVector<int, 4> V2Shuffle(Mask.size(), 1);
8105       V2Shuffle[V2Index] = 0;
8106       V2 = DAG.getVectorShuffle(VT, DL, V2, DAG.getUNDEF(VT), V2Shuffle);
8107     } else {
8108       V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, V2);
8109       V2 = DAG.getNode(
8110           X86ISD::VSHLDQ, DL, MVT::v2i64, V2,
8111           DAG.getConstant(
8112               V2Index * EltVT.getSizeInBits(),
8113               DAG.getTargetLoweringInfo().getScalarShiftAmountTy(MVT::v2i64)));
8114       V2 = DAG.getNode(ISD::BITCAST, DL, VT, V2);
8115     }
8116   }
8117   return V2;
8118 }
8119
8120 /// \brief Try to lower broadcast of a single element.
8121 ///
8122 /// For convenience, this code also bundles all of the subtarget feature set
8123 /// filtering. While a little annoying to re-dispatch on type here, there isn't
8124 /// a convenient way to factor it out.
8125 static SDValue lowerVectorShuffleAsBroadcast(MVT VT, SDLoc DL, SDValue V,
8126                                              ArrayRef<int> Mask,
8127                                              const X86Subtarget *Subtarget,
8128                                              SelectionDAG &DAG) {
8129   if (!Subtarget->hasAVX())
8130     return SDValue();
8131   if (VT.isInteger() && !Subtarget->hasAVX2())
8132     return SDValue();
8133
8134   // Check that the mask is a broadcast.
8135   int BroadcastIdx = -1;
8136   for (int M : Mask)
8137     if (M >= 0 && BroadcastIdx == -1)
8138       BroadcastIdx = M;
8139     else if (M >= 0 && M != BroadcastIdx)
8140       return SDValue();
8141
8142   assert(BroadcastIdx < (int)Mask.size() && "We only expect to be called with "
8143                                             "a sorted mask where the broadcast "
8144                                             "comes from V1.");
8145
8146   // Go up the chain of (vector) values to try and find a scalar load that
8147   // we can combine with the broadcast.
8148   for (;;) {
8149     switch (V.getOpcode()) {
8150     case ISD::CONCAT_VECTORS: {
8151       int OperandSize = Mask.size() / V.getNumOperands();
8152       V = V.getOperand(BroadcastIdx / OperandSize);
8153       BroadcastIdx %= OperandSize;
8154       continue;
8155     }
8156
8157     case ISD::INSERT_SUBVECTOR: {
8158       SDValue VOuter = V.getOperand(0), VInner = V.getOperand(1);
8159       auto ConstantIdx = dyn_cast<ConstantSDNode>(V.getOperand(2));
8160       if (!ConstantIdx)
8161         break;
8162
8163       int BeginIdx = (int)ConstantIdx->getZExtValue();
8164       int EndIdx =
8165           BeginIdx + (int)VInner.getValueType().getVectorNumElements();
8166       if (BroadcastIdx >= BeginIdx && BroadcastIdx < EndIdx) {
8167         BroadcastIdx -= BeginIdx;
8168         V = VInner;
8169       } else {
8170         V = VOuter;
8171       }
8172       continue;
8173     }
8174     }
8175     break;
8176   }
8177
8178   // Check if this is a broadcast of a scalar. We special case lowering
8179   // for scalars so that we can more effectively fold with loads.
8180   if (V.getOpcode() == ISD::BUILD_VECTOR ||
8181       (V.getOpcode() == ISD::SCALAR_TO_VECTOR && BroadcastIdx == 0)) {
8182     V = V.getOperand(BroadcastIdx);
8183
8184     // If the scalar isn't a load we can't broadcast from it in AVX1, only with
8185     // AVX2.
8186     if (!Subtarget->hasAVX2() && !isShuffleFoldableLoad(V))
8187       return SDValue();
8188   } else if (BroadcastIdx != 0 || !Subtarget->hasAVX2()) {
8189     // We can't broadcast from a vector register w/o AVX2, and we can only
8190     // broadcast from the zero-element of a vector register.
8191     return SDValue();
8192   }
8193
8194   return DAG.getNode(X86ISD::VBROADCAST, DL, VT, V);
8195 }
8196
8197 // Check for whether we can use INSERTPS to perform the shuffle. We only use
8198 // INSERTPS when the V1 elements are already in the correct locations
8199 // because otherwise we can just always use two SHUFPS instructions which
8200 // are much smaller to encode than a SHUFPS and an INSERTPS. We can also
8201 // perform INSERTPS if a single V1 element is out of place and all V2
8202 // elements are zeroable.
8203 static SDValue lowerVectorShuffleAsInsertPS(SDValue Op, SDValue V1, SDValue V2,
8204                                             ArrayRef<int> Mask,
8205                                             SelectionDAG &DAG) {
8206   assert(Op.getSimpleValueType() == MVT::v4f32 && "Bad shuffle type!");
8207   assert(V1.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
8208   assert(V2.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
8209   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
8210
8211   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
8212
8213   unsigned ZMask = 0;
8214   int V1DstIndex = -1;
8215   int V2DstIndex = -1;
8216   bool V1UsedInPlace = false;
8217
8218   for (int i = 0; i < 4; i++) {
8219     // Synthesize a zero mask from the zeroable elements (includes undefs).
8220     if (Zeroable[i]) {
8221       ZMask |= 1 << i;
8222       continue;
8223     }
8224
8225     // Flag if we use any V1 inputs in place.
8226     if (i == Mask[i]) {
8227       V1UsedInPlace = true;
8228       continue;
8229     }
8230
8231     // We can only insert a single non-zeroable element.
8232     if (V1DstIndex != -1 || V2DstIndex != -1)
8233       return SDValue();
8234
8235     if (Mask[i] < 4) {
8236       // V1 input out of place for insertion.
8237       V1DstIndex = i;
8238     } else {
8239       // V2 input for insertion.
8240       V2DstIndex = i;
8241     }
8242   }
8243
8244   // Don't bother if we have no (non-zeroable) element for insertion.
8245   if (V1DstIndex == -1 && V2DstIndex == -1)
8246     return SDValue();
8247
8248   // Determine element insertion src/dst indices. The src index is from the
8249   // start of the inserted vector, not the start of the concatenated vector.
8250   unsigned V2SrcIndex = 0;
8251   if (V1DstIndex != -1) {
8252     // If we have a V1 input out of place, we use V1 as the V2 element insertion
8253     // and don't use the original V2 at all.
8254     V2SrcIndex = Mask[V1DstIndex];
8255     V2DstIndex = V1DstIndex;
8256     V2 = V1;
8257   } else {
8258     V2SrcIndex = Mask[V2DstIndex] - 4;
8259   }
8260
8261   // If no V1 inputs are used in place, then the result is created only from
8262   // the zero mask and the V2 insertion - so remove V1 dependency.
8263   if (!V1UsedInPlace)
8264     V1 = DAG.getUNDEF(MVT::v4f32);
8265
8266   unsigned InsertPSMask = V2SrcIndex << 6 | V2DstIndex << 4 | ZMask;
8267   assert((InsertPSMask & ~0xFFu) == 0 && "Invalid mask!");
8268
8269   // Insert the V2 element into the desired position.
8270   SDLoc DL(Op);
8271   return DAG.getNode(X86ISD::INSERTPS, DL, MVT::v4f32, V1, V2,
8272                      DAG.getConstant(InsertPSMask, MVT::i8));
8273 }
8274
8275 /// \brief Handle lowering of 2-lane 64-bit floating point shuffles.
8276 ///
8277 /// This is the basis function for the 2-lane 64-bit shuffles as we have full
8278 /// support for floating point shuffles but not integer shuffles. These
8279 /// instructions will incur a domain crossing penalty on some chips though so
8280 /// it is better to avoid lowering through this for integer vectors where
8281 /// possible.
8282 static SDValue lowerV2F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8283                                        const X86Subtarget *Subtarget,
8284                                        SelectionDAG &DAG) {
8285   SDLoc DL(Op);
8286   assert(Op.getSimpleValueType() == MVT::v2f64 && "Bad shuffle type!");
8287   assert(V1.getSimpleValueType() == MVT::v2f64 && "Bad operand type!");
8288   assert(V2.getSimpleValueType() == MVT::v2f64 && "Bad operand type!");
8289   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8290   ArrayRef<int> Mask = SVOp->getMask();
8291   assert(Mask.size() == 2 && "Unexpected mask size for v2 shuffle!");
8292
8293   if (isSingleInputShuffleMask(Mask)) {
8294     // Use low duplicate instructions for masks that match their pattern.
8295     if (Subtarget->hasSSE3())
8296       if (isShuffleEquivalent(Mask, 0, 0))
8297         return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v2f64, V1);
8298
8299     // Straight shuffle of a single input vector. Simulate this by using the
8300     // single input as both of the "inputs" to this instruction..
8301     unsigned SHUFPDMask = (Mask[0] == 1) | ((Mask[1] == 1) << 1);
8302
8303     if (Subtarget->hasAVX()) {
8304       // If we have AVX, we can use VPERMILPS which will allow folding a load
8305       // into the shuffle.
8306       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v2f64, V1,
8307                          DAG.getConstant(SHUFPDMask, MVT::i8));
8308     }
8309
8310     return DAG.getNode(X86ISD::SHUFP, SDLoc(Op), MVT::v2f64, V1, V1,
8311                        DAG.getConstant(SHUFPDMask, MVT::i8));
8312   }
8313   assert(Mask[0] >= 0 && Mask[0] < 2 && "Non-canonicalized blend!");
8314   assert(Mask[1] >= 2 && "Non-canonicalized blend!");
8315
8316   // Use dedicated unpack instructions for masks that match their pattern.
8317   if (isShuffleEquivalent(Mask, 0, 2))
8318     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2f64, V1, V2);
8319   if (isShuffleEquivalent(Mask, 1, 3))
8320     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v2f64, V1, V2);
8321
8322   // If we have a single input, insert that into V1 if we can do so cheaply.
8323   if ((Mask[0] >= 2) + (Mask[1] >= 2) == 1) {
8324     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
8325             MVT::v2f64, DL, V1, V2, Mask, Subtarget, DAG))
8326       return Insertion;
8327     // Try inverting the insertion since for v2 masks it is easy to do and we
8328     // can't reliably sort the mask one way or the other.
8329     int InverseMask[2] = {Mask[0] < 0 ? -1 : (Mask[0] ^ 2),
8330                           Mask[1] < 0 ? -1 : (Mask[1] ^ 2)};
8331     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
8332             MVT::v2f64, DL, V2, V1, InverseMask, Subtarget, DAG))
8333       return Insertion;
8334   }
8335
8336   // Try to use one of the special instruction patterns to handle two common
8337   // blend patterns if a zero-blend above didn't work.
8338   if (isShuffleEquivalent(Mask, 0, 3) || isShuffleEquivalent(Mask, 1, 3))
8339     if (SDValue V1S = getScalarValueForVectorElement(V1, Mask[0], DAG))
8340       // We can either use a special instruction to load over the low double or
8341       // to move just the low double.
8342       return DAG.getNode(
8343           isShuffleFoldableLoad(V1S) ? X86ISD::MOVLPD : X86ISD::MOVSD,
8344           DL, MVT::v2f64, V2,
8345           DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64, V1S));
8346
8347   if (Subtarget->hasSSE41())
8348     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v2f64, V1, V2, Mask,
8349                                                   Subtarget, DAG))
8350       return Blend;
8351
8352   unsigned SHUFPDMask = (Mask[0] == 1) | (((Mask[1] - 2) == 1) << 1);
8353   return DAG.getNode(X86ISD::SHUFP, SDLoc(Op), MVT::v2f64, V1, V2,
8354                      DAG.getConstant(SHUFPDMask, MVT::i8));
8355 }
8356
8357 /// \brief Handle lowering of 2-lane 64-bit integer shuffles.
8358 ///
8359 /// Tries to lower a 2-lane 64-bit shuffle using shuffle operations provided by
8360 /// the integer unit to minimize domain crossing penalties. However, for blends
8361 /// it falls back to the floating point shuffle operation with appropriate bit
8362 /// casting.
8363 static SDValue lowerV2I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8364                                        const X86Subtarget *Subtarget,
8365                                        SelectionDAG &DAG) {
8366   SDLoc DL(Op);
8367   assert(Op.getSimpleValueType() == MVT::v2i64 && "Bad shuffle type!");
8368   assert(V1.getSimpleValueType() == MVT::v2i64 && "Bad operand type!");
8369   assert(V2.getSimpleValueType() == MVT::v2i64 && "Bad operand type!");
8370   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8371   ArrayRef<int> Mask = SVOp->getMask();
8372   assert(Mask.size() == 2 && "Unexpected mask size for v2 shuffle!");
8373
8374   if (isSingleInputShuffleMask(Mask)) {
8375     // Check for being able to broadcast a single element.
8376     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v2i64, DL, V1,
8377                                                           Mask, Subtarget, DAG))
8378       return Broadcast;
8379
8380     // Straight shuffle of a single input vector. For everything from SSE2
8381     // onward this has a single fast instruction with no scary immediates.
8382     // We have to map the mask as it is actually a v4i32 shuffle instruction.
8383     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V1);
8384     int WidenedMask[4] = {
8385         std::max(Mask[0], 0) * 2, std::max(Mask[0], 0) * 2 + 1,
8386         std::max(Mask[1], 0) * 2, std::max(Mask[1], 0) * 2 + 1};
8387     return DAG.getNode(
8388         ISD::BITCAST, DL, MVT::v2i64,
8389         DAG.getNode(X86ISD::PSHUFD, SDLoc(Op), MVT::v4i32, V1,
8390                     getV4X86ShuffleImm8ForMask(WidenedMask, DAG)));
8391   }
8392
8393   // Try to use byte shift instructions.
8394   if (SDValue Shift = lowerVectorShuffleAsByteShift(
8395           DL, MVT::v2i64, V1, V2, Mask, DAG))
8396     return Shift;
8397
8398   // If we have a single input from V2 insert that into V1 if we can do so
8399   // cheaply.
8400   if ((Mask[0] >= 2) + (Mask[1] >= 2) == 1) {
8401     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
8402             MVT::v2i64, DL, V1, V2, Mask, Subtarget, DAG))
8403       return Insertion;
8404     // Try inverting the insertion since for v2 masks it is easy to do and we
8405     // can't reliably sort the mask one way or the other.
8406     int InverseMask[2] = {Mask[0] < 0 ? -1 : (Mask[0] ^ 2),
8407                           Mask[1] < 0 ? -1 : (Mask[1] ^ 2)};
8408     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
8409             MVT::v2i64, DL, V2, V1, InverseMask, Subtarget, DAG))
8410       return Insertion;
8411   }
8412
8413   // Use dedicated unpack instructions for masks that match their pattern.
8414   if (isShuffleEquivalent(Mask, 0, 2))
8415     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2i64, V1, V2);
8416   if (isShuffleEquivalent(Mask, 1, 3))
8417     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v2i64, V1, V2);
8418
8419   if (Subtarget->hasSSE41())
8420     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v2i64, V1, V2, Mask,
8421                                                   Subtarget, DAG))
8422       return Blend;
8423
8424   // Try to use byte rotation instructions.
8425   // Its more profitable for pre-SSSE3 to use shuffles/unpacks.
8426   if (Subtarget->hasSSSE3())
8427     if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
8428             DL, MVT::v2i64, V1, V2, Mask, Subtarget, DAG))
8429       return Rotate;
8430
8431   // We implement this with SHUFPD which is pretty lame because it will likely
8432   // incur 2 cycles of stall for integer vectors on Nehalem and older chips.
8433   // However, all the alternatives are still more cycles and newer chips don't
8434   // have this problem. It would be really nice if x86 had better shuffles here.
8435   V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, V1);
8436   V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, V2);
8437   return DAG.getNode(ISD::BITCAST, DL, MVT::v2i64,
8438                      DAG.getVectorShuffle(MVT::v2f64, DL, V1, V2, Mask));
8439 }
8440
8441 /// \brief Lower a vector shuffle using the SHUFPS instruction.
8442 ///
8443 /// This is a helper routine dedicated to lowering vector shuffles using SHUFPS.
8444 /// It makes no assumptions about whether this is the *best* lowering, it simply
8445 /// uses it.
8446 static SDValue lowerVectorShuffleWithSHUFPS(SDLoc DL, MVT VT,
8447                                             ArrayRef<int> Mask, SDValue V1,
8448                                             SDValue V2, SelectionDAG &DAG) {
8449   SDValue LowV = V1, HighV = V2;
8450   int NewMask[4] = {Mask[0], Mask[1], Mask[2], Mask[3]};
8451
8452   int NumV2Elements =
8453       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
8454
8455   if (NumV2Elements == 1) {
8456     int V2Index =
8457         std::find_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; }) -
8458         Mask.begin();
8459
8460     // Compute the index adjacent to V2Index and in the same half by toggling
8461     // the low bit.
8462     int V2AdjIndex = V2Index ^ 1;
8463
8464     if (Mask[V2AdjIndex] == -1) {
8465       // Handles all the cases where we have a single V2 element and an undef.
8466       // This will only ever happen in the high lanes because we commute the
8467       // vector otherwise.
8468       if (V2Index < 2)
8469         std::swap(LowV, HighV);
8470       NewMask[V2Index] -= 4;
8471     } else {
8472       // Handle the case where the V2 element ends up adjacent to a V1 element.
8473       // To make this work, blend them together as the first step.
8474       int V1Index = V2AdjIndex;
8475       int BlendMask[4] = {Mask[V2Index] - 4, 0, Mask[V1Index], 0};
8476       V2 = DAG.getNode(X86ISD::SHUFP, DL, VT, V2, V1,
8477                        getV4X86ShuffleImm8ForMask(BlendMask, DAG));
8478
8479       // Now proceed to reconstruct the final blend as we have the necessary
8480       // high or low half formed.
8481       if (V2Index < 2) {
8482         LowV = V2;
8483         HighV = V1;
8484       } else {
8485         HighV = V2;
8486       }
8487       NewMask[V1Index] = 2; // We put the V1 element in V2[2].
8488       NewMask[V2Index] = 0; // We shifted the V2 element into V2[0].
8489     }
8490   } else if (NumV2Elements == 2) {
8491     if (Mask[0] < 4 && Mask[1] < 4) {
8492       // Handle the easy case where we have V1 in the low lanes and V2 in the
8493       // high lanes.
8494       NewMask[2] -= 4;
8495       NewMask[3] -= 4;
8496     } else if (Mask[2] < 4 && Mask[3] < 4) {
8497       // We also handle the reversed case because this utility may get called
8498       // when we detect a SHUFPS pattern but can't easily commute the shuffle to
8499       // arrange things in the right direction.
8500       NewMask[0] -= 4;
8501       NewMask[1] -= 4;
8502       HighV = V1;
8503       LowV = V2;
8504     } else {
8505       // We have a mixture of V1 and V2 in both low and high lanes. Rather than
8506       // trying to place elements directly, just blend them and set up the final
8507       // shuffle to place them.
8508
8509       // The first two blend mask elements are for V1, the second two are for
8510       // V2.
8511       int BlendMask[4] = {Mask[0] < 4 ? Mask[0] : Mask[1],
8512                           Mask[2] < 4 ? Mask[2] : Mask[3],
8513                           (Mask[0] >= 4 ? Mask[0] : Mask[1]) - 4,
8514                           (Mask[2] >= 4 ? Mask[2] : Mask[3]) - 4};
8515       V1 = DAG.getNode(X86ISD::SHUFP, DL, VT, V1, V2,
8516                        getV4X86ShuffleImm8ForMask(BlendMask, DAG));
8517
8518       // Now we do a normal shuffle of V1 by giving V1 as both operands to
8519       // a blend.
8520       LowV = HighV = V1;
8521       NewMask[0] = Mask[0] < 4 ? 0 : 2;
8522       NewMask[1] = Mask[0] < 4 ? 2 : 0;
8523       NewMask[2] = Mask[2] < 4 ? 1 : 3;
8524       NewMask[3] = Mask[2] < 4 ? 3 : 1;
8525     }
8526   }
8527   return DAG.getNode(X86ISD::SHUFP, DL, VT, LowV, HighV,
8528                      getV4X86ShuffleImm8ForMask(NewMask, DAG));
8529 }
8530
8531 /// \brief Lower 4-lane 32-bit floating point shuffles.
8532 ///
8533 /// Uses instructions exclusively from the floating point unit to minimize
8534 /// domain crossing penalties, as these are sufficient to implement all v4f32
8535 /// shuffles.
8536 static SDValue lowerV4F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8537                                        const X86Subtarget *Subtarget,
8538                                        SelectionDAG &DAG) {
8539   SDLoc DL(Op);
8540   assert(Op.getSimpleValueType() == MVT::v4f32 && "Bad shuffle type!");
8541   assert(V1.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
8542   assert(V2.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
8543   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8544   ArrayRef<int> Mask = SVOp->getMask();
8545   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
8546
8547   int NumV2Elements =
8548       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
8549
8550   if (NumV2Elements == 0) {
8551     // Check for being able to broadcast a single element.
8552     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4f32, DL, V1,
8553                                                           Mask, Subtarget, DAG))
8554       return Broadcast;
8555
8556     // Use even/odd duplicate instructions for masks that match their pattern.
8557     if (Subtarget->hasSSE3()) {
8558       if (isShuffleEquivalent(Mask, 0, 0, 2, 2))
8559         return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v4f32, V1);
8560       if (isShuffleEquivalent(Mask, 1, 1, 3, 3))
8561         return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v4f32, V1);
8562     }
8563
8564     if (Subtarget->hasAVX()) {
8565       // If we have AVX, we can use VPERMILPS which will allow folding a load
8566       // into the shuffle.
8567       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f32, V1,
8568                          getV4X86ShuffleImm8ForMask(Mask, DAG));
8569     }
8570
8571     // Otherwise, use a straight shuffle of a single input vector. We pass the
8572     // input vector to both operands to simulate this with a SHUFPS.
8573     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f32, V1, V1,
8574                        getV4X86ShuffleImm8ForMask(Mask, DAG));
8575   }
8576
8577   // Use dedicated unpack instructions for masks that match their pattern.
8578   if (isShuffleEquivalent(Mask, 0, 4, 1, 5))
8579     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f32, V1, V2);
8580   if (isShuffleEquivalent(Mask, 2, 6, 3, 7))
8581     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f32, V1, V2);
8582
8583   // There are special ways we can lower some single-element blends. However, we
8584   // have custom ways we can lower more complex single-element blends below that
8585   // we defer to if both this and BLENDPS fail to match, so restrict this to
8586   // when the V2 input is targeting element 0 of the mask -- that is the fast
8587   // case here.
8588   if (NumV2Elements == 1 && Mask[0] >= 4)
8589     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v4f32, DL, V1, V2,
8590                                                          Mask, Subtarget, DAG))
8591       return V;
8592
8593   if (Subtarget->hasSSE41()) {
8594     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4f32, V1, V2, Mask,
8595                                                   Subtarget, DAG))
8596       return Blend;
8597
8598     // Use INSERTPS if we can complete the shuffle efficiently.
8599     if (SDValue V = lowerVectorShuffleAsInsertPS(Op, V1, V2, Mask, DAG))
8600       return V;
8601   }
8602
8603   // Otherwise fall back to a SHUFPS lowering strategy.
8604   return lowerVectorShuffleWithSHUFPS(DL, MVT::v4f32, Mask, V1, V2, DAG);
8605 }
8606
8607 /// \brief Lower 4-lane i32 vector shuffles.
8608 ///
8609 /// We try to handle these with integer-domain shuffles where we can, but for
8610 /// blends we use the floating point domain blend instructions.
8611 static SDValue lowerV4I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8612                                        const X86Subtarget *Subtarget,
8613                                        SelectionDAG &DAG) {
8614   SDLoc DL(Op);
8615   assert(Op.getSimpleValueType() == MVT::v4i32 && "Bad shuffle type!");
8616   assert(V1.getSimpleValueType() == MVT::v4i32 && "Bad operand type!");
8617   assert(V2.getSimpleValueType() == MVT::v4i32 && "Bad operand type!");
8618   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8619   ArrayRef<int> Mask = SVOp->getMask();
8620   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
8621
8622   // Whenever we can lower this as a zext, that instruction is strictly faster
8623   // than any alternative. It also allows us to fold memory operands into the
8624   // shuffle in many cases.
8625   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v4i32, V1, V2,
8626                                                          Mask, Subtarget, DAG))
8627     return ZExt;
8628
8629   int NumV2Elements =
8630       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
8631
8632   if (NumV2Elements == 0) {
8633     // Check for being able to broadcast a single element.
8634     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4i32, DL, V1,
8635                                                           Mask, Subtarget, DAG))
8636       return Broadcast;
8637
8638     // Straight shuffle of a single input vector. For everything from SSE2
8639     // onward this has a single fast instruction with no scary immediates.
8640     // We coerce the shuffle pattern to be compatible with UNPCK instructions
8641     // but we aren't actually going to use the UNPCK instruction because doing
8642     // so prevents folding a load into this instruction or making a copy.
8643     const int UnpackLoMask[] = {0, 0, 1, 1};
8644     const int UnpackHiMask[] = {2, 2, 3, 3};
8645     if (isShuffleEquivalent(Mask, 0, 0, 1, 1))
8646       Mask = UnpackLoMask;
8647     else if (isShuffleEquivalent(Mask, 2, 2, 3, 3))
8648       Mask = UnpackHiMask;
8649
8650     return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V1,
8651                        getV4X86ShuffleImm8ForMask(Mask, DAG));
8652   }
8653
8654   // Try to use byte shift instructions.
8655   if (SDValue Shift = lowerVectorShuffleAsByteShift(
8656           DL, MVT::v4i32, V1, V2, Mask, DAG))
8657     return Shift;
8658
8659   // There are special ways we can lower some single-element blends.
8660   if (NumV2Elements == 1)
8661     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v4i32, DL, V1, V2,
8662                                                          Mask, Subtarget, DAG))
8663       return V;
8664
8665   // Use dedicated unpack instructions for masks that match their pattern.
8666   if (isShuffleEquivalent(Mask, 0, 4, 1, 5))
8667     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i32, V1, V2);
8668   if (isShuffleEquivalent(Mask, 2, 6, 3, 7))
8669     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i32, V1, V2);
8670
8671   if (Subtarget->hasSSE41())
8672     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4i32, V1, V2, Mask,
8673                                                   Subtarget, DAG))
8674       return Blend;
8675
8676   // Try to use byte rotation instructions.
8677   // Its more profitable for pre-SSSE3 to use shuffles/unpacks.
8678   if (Subtarget->hasSSSE3())
8679     if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
8680             DL, MVT::v4i32, V1, V2, Mask, Subtarget, DAG))
8681       return Rotate;
8682
8683   // We implement this with SHUFPS because it can blend from two vectors.
8684   // Because we're going to eventually use SHUFPS, we use SHUFPS even to build
8685   // up the inputs, bypassing domain shift penalties that we would encur if we
8686   // directly used PSHUFD on Nehalem and older. For newer chips, this isn't
8687   // relevant.
8688   return DAG.getNode(ISD::BITCAST, DL, MVT::v4i32,
8689                      DAG.getVectorShuffle(
8690                          MVT::v4f32, DL,
8691                          DAG.getNode(ISD::BITCAST, DL, MVT::v4f32, V1),
8692                          DAG.getNode(ISD::BITCAST, DL, MVT::v4f32, V2), Mask));
8693 }
8694
8695 /// \brief Lowering of single-input v8i16 shuffles is the cornerstone of SSE2
8696 /// shuffle lowering, and the most complex part.
8697 ///
8698 /// The lowering strategy is to try to form pairs of input lanes which are
8699 /// targeted at the same half of the final vector, and then use a dword shuffle
8700 /// to place them onto the right half, and finally unpack the paired lanes into
8701 /// their final position.
8702 ///
8703 /// The exact breakdown of how to form these dword pairs and align them on the
8704 /// correct sides is really tricky. See the comments within the function for
8705 /// more of the details.
8706 static SDValue lowerV8I16SingleInputVectorShuffle(
8707     SDLoc DL, SDValue V, MutableArrayRef<int> Mask,
8708     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
8709   assert(V.getSimpleValueType() == MVT::v8i16 && "Bad input type!");
8710   MutableArrayRef<int> LoMask = Mask.slice(0, 4);
8711   MutableArrayRef<int> HiMask = Mask.slice(4, 4);
8712
8713   SmallVector<int, 4> LoInputs;
8714   std::copy_if(LoMask.begin(), LoMask.end(), std::back_inserter(LoInputs),
8715                [](int M) { return M >= 0; });
8716   std::sort(LoInputs.begin(), LoInputs.end());
8717   LoInputs.erase(std::unique(LoInputs.begin(), LoInputs.end()), LoInputs.end());
8718   SmallVector<int, 4> HiInputs;
8719   std::copy_if(HiMask.begin(), HiMask.end(), std::back_inserter(HiInputs),
8720                [](int M) { return M >= 0; });
8721   std::sort(HiInputs.begin(), HiInputs.end());
8722   HiInputs.erase(std::unique(HiInputs.begin(), HiInputs.end()), HiInputs.end());
8723   int NumLToL =
8724       std::lower_bound(LoInputs.begin(), LoInputs.end(), 4) - LoInputs.begin();
8725   int NumHToL = LoInputs.size() - NumLToL;
8726   int NumLToH =
8727       std::lower_bound(HiInputs.begin(), HiInputs.end(), 4) - HiInputs.begin();
8728   int NumHToH = HiInputs.size() - NumLToH;
8729   MutableArrayRef<int> LToLInputs(LoInputs.data(), NumLToL);
8730   MutableArrayRef<int> LToHInputs(HiInputs.data(), NumLToH);
8731   MutableArrayRef<int> HToLInputs(LoInputs.data() + NumLToL, NumHToL);
8732   MutableArrayRef<int> HToHInputs(HiInputs.data() + NumLToH, NumHToH);
8733
8734   // Check for being able to broadcast a single element.
8735   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v8i16, DL, V,
8736                                                         Mask, Subtarget, DAG))
8737     return Broadcast;
8738
8739   // Try to use byte shift instructions.
8740   if (SDValue Shift = lowerVectorShuffleAsByteShift(
8741           DL, MVT::v8i16, V, V, Mask, DAG))
8742     return Shift;
8743
8744   // Use dedicated unpack instructions for masks that match their pattern.
8745   if (isShuffleEquivalent(Mask, 0, 0, 1, 1, 2, 2, 3, 3))
8746     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, V, V);
8747   if (isShuffleEquivalent(Mask, 4, 4, 5, 5, 6, 6, 7, 7))
8748     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i16, V, V);
8749
8750   // Try to use byte rotation instructions.
8751   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
8752           DL, MVT::v8i16, V, V, Mask, Subtarget, DAG))
8753     return Rotate;
8754
8755   // Simplify the 1-into-3 and 3-into-1 cases with a single pshufd. For all
8756   // such inputs we can swap two of the dwords across the half mark and end up
8757   // with <=2 inputs to each half in each half. Once there, we can fall through
8758   // to the generic code below. For example:
8759   //
8760   // Input: [a, b, c, d, e, f, g, h] -PSHUFD[0,2,1,3]-> [a, b, e, f, c, d, g, h]
8761   // Mask:  [0, 1, 2, 7, 4, 5, 6, 3] -----------------> [0, 1, 4, 7, 2, 3, 6, 5]
8762   //
8763   // However in some very rare cases we have a 1-into-3 or 3-into-1 on one half
8764   // and an existing 2-into-2 on the other half. In this case we may have to
8765   // pre-shuffle the 2-into-2 half to avoid turning it into a 3-into-1 or
8766   // 1-into-3 which could cause us to cycle endlessly fixing each side in turn.
8767   // Fortunately, we don't have to handle anything but a 2-into-2 pattern
8768   // because any other situation (including a 3-into-1 or 1-into-3 in the other
8769   // half than the one we target for fixing) will be fixed when we re-enter this
8770   // path. We will also combine away any sequence of PSHUFD instructions that
8771   // result into a single instruction. Here is an example of the tricky case:
8772   //
8773   // Input: [a, b, c, d, e, f, g, h] -PSHUFD[0,2,1,3]-> [a, b, e, f, c, d, g, h]
8774   // Mask:  [3, 7, 1, 0, 2, 7, 3, 5] -THIS-IS-BAD!!!!-> [5, 7, 1, 0, 4, 7, 5, 3]
8775   //
8776   // This now has a 1-into-3 in the high half! Instead, we do two shuffles:
8777   //
8778   // Input: [a, b, c, d, e, f, g, h] PSHUFHW[0,2,1,3]-> [a, b, c, d, e, g, f, h]
8779   // Mask:  [3, 7, 1, 0, 2, 7, 3, 5] -----------------> [3, 7, 1, 0, 2, 7, 3, 6]
8780   //
8781   // Input: [a, b, c, d, e, g, f, h] -PSHUFD[0,2,1,3]-> [a, b, e, g, c, d, f, h]
8782   // Mask:  [3, 7, 1, 0, 2, 7, 3, 6] -----------------> [5, 7, 1, 0, 4, 7, 5, 6]
8783   //
8784   // The result is fine to be handled by the generic logic.
8785   auto balanceSides = [&](ArrayRef<int> AToAInputs, ArrayRef<int> BToAInputs,
8786                           ArrayRef<int> BToBInputs, ArrayRef<int> AToBInputs,
8787                           int AOffset, int BOffset) {
8788     assert((AToAInputs.size() == 3 || AToAInputs.size() == 1) &&
8789            "Must call this with A having 3 or 1 inputs from the A half.");
8790     assert((BToAInputs.size() == 1 || BToAInputs.size() == 3) &&
8791            "Must call this with B having 1 or 3 inputs from the B half.");
8792     assert(AToAInputs.size() + BToAInputs.size() == 4 &&
8793            "Must call this with either 3:1 or 1:3 inputs (summing to 4).");
8794
8795     // Compute the index of dword with only one word among the three inputs in
8796     // a half by taking the sum of the half with three inputs and subtracting
8797     // the sum of the actual three inputs. The difference is the remaining
8798     // slot.
8799     int ADWord, BDWord;
8800     int &TripleDWord = AToAInputs.size() == 3 ? ADWord : BDWord;
8801     int &OneInputDWord = AToAInputs.size() == 3 ? BDWord : ADWord;
8802     int TripleInputOffset = AToAInputs.size() == 3 ? AOffset : BOffset;
8803     ArrayRef<int> TripleInputs = AToAInputs.size() == 3 ? AToAInputs : BToAInputs;
8804     int OneInput = AToAInputs.size() == 3 ? BToAInputs[0] : AToAInputs[0];
8805     int TripleInputSum = 0 + 1 + 2 + 3 + (4 * TripleInputOffset);
8806     int TripleNonInputIdx =
8807         TripleInputSum - std::accumulate(TripleInputs.begin(), TripleInputs.end(), 0);
8808     TripleDWord = TripleNonInputIdx / 2;
8809
8810     // We use xor with one to compute the adjacent DWord to whichever one the
8811     // OneInput is in.
8812     OneInputDWord = (OneInput / 2) ^ 1;
8813
8814     // Check for one tricky case: We're fixing a 3<-1 or a 1<-3 shuffle for AToA
8815     // and BToA inputs. If there is also such a problem with the BToB and AToB
8816     // inputs, we don't try to fix it necessarily -- we'll recurse and see it in
8817     // the next pass. However, if we have a 2<-2 in the BToB and AToB inputs, it
8818     // is essential that we don't *create* a 3<-1 as then we might oscillate.
8819     if (BToBInputs.size() == 2 && AToBInputs.size() == 2) {
8820       // Compute how many inputs will be flipped by swapping these DWords. We
8821       // need
8822       // to balance this to ensure we don't form a 3-1 shuffle in the other
8823       // half.
8824       int NumFlippedAToBInputs =
8825           std::count(AToBInputs.begin(), AToBInputs.end(), 2 * ADWord) +
8826           std::count(AToBInputs.begin(), AToBInputs.end(), 2 * ADWord + 1);
8827       int NumFlippedBToBInputs =
8828           std::count(BToBInputs.begin(), BToBInputs.end(), 2 * BDWord) +
8829           std::count(BToBInputs.begin(), BToBInputs.end(), 2 * BDWord + 1);
8830       if ((NumFlippedAToBInputs == 1 &&
8831            (NumFlippedBToBInputs == 0 || NumFlippedBToBInputs == 2)) ||
8832           (NumFlippedBToBInputs == 1 &&
8833            (NumFlippedAToBInputs == 0 || NumFlippedAToBInputs == 2))) {
8834         // We choose whether to fix the A half or B half based on whether that
8835         // half has zero flipped inputs. At zero, we may not be able to fix it
8836         // with that half. We also bias towards fixing the B half because that
8837         // will more commonly be the high half, and we have to bias one way.
8838         auto FixFlippedInputs = [&V, &DL, &Mask, &DAG](int PinnedIdx, int DWord,
8839                                                        ArrayRef<int> Inputs) {
8840           int FixIdx = PinnedIdx ^ 1; // The adjacent slot to the pinned slot.
8841           bool IsFixIdxInput = std::find(Inputs.begin(), Inputs.end(),
8842                                          PinnedIdx ^ 1) != Inputs.end();
8843           // Determine whether the free index is in the flipped dword or the
8844           // unflipped dword based on where the pinned index is. We use this bit
8845           // in an xor to conditionally select the adjacent dword.
8846           int FixFreeIdx = 2 * (DWord ^ (PinnedIdx / 2 == DWord));
8847           bool IsFixFreeIdxInput = std::find(Inputs.begin(), Inputs.end(),
8848                                              FixFreeIdx) != Inputs.end();
8849           if (IsFixIdxInput == IsFixFreeIdxInput)
8850             FixFreeIdx += 1;
8851           IsFixFreeIdxInput = std::find(Inputs.begin(), Inputs.end(),
8852                                         FixFreeIdx) != Inputs.end();
8853           assert(IsFixIdxInput != IsFixFreeIdxInput &&
8854                  "We need to be changing the number of flipped inputs!");
8855           int PSHUFHalfMask[] = {0, 1, 2, 3};
8856           std::swap(PSHUFHalfMask[FixFreeIdx % 4], PSHUFHalfMask[FixIdx % 4]);
8857           V = DAG.getNode(FixIdx < 4 ? X86ISD::PSHUFLW : X86ISD::PSHUFHW, DL,
8858                           MVT::v8i16, V,
8859                           getV4X86ShuffleImm8ForMask(PSHUFHalfMask, DAG));
8860
8861           for (int &M : Mask)
8862             if (M != -1 && M == FixIdx)
8863               M = FixFreeIdx;
8864             else if (M != -1 && M == FixFreeIdx)
8865               M = FixIdx;
8866         };
8867         if (NumFlippedBToBInputs != 0) {
8868           int BPinnedIdx =
8869               BToAInputs.size() == 3 ? TripleNonInputIdx : OneInput;
8870           FixFlippedInputs(BPinnedIdx, BDWord, BToBInputs);
8871         } else {
8872           assert(NumFlippedAToBInputs != 0 && "Impossible given predicates!");
8873           int APinnedIdx =
8874               AToAInputs.size() == 3 ? TripleNonInputIdx : OneInput;
8875           FixFlippedInputs(APinnedIdx, ADWord, AToBInputs);
8876         }
8877       }
8878     }
8879
8880     int PSHUFDMask[] = {0, 1, 2, 3};
8881     PSHUFDMask[ADWord] = BDWord;
8882     PSHUFDMask[BDWord] = ADWord;
8883     V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
8884                     DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
8885                                 DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V),
8886                                 getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
8887
8888     // Adjust the mask to match the new locations of A and B.
8889     for (int &M : Mask)
8890       if (M != -1 && M/2 == ADWord)
8891         M = 2 * BDWord + M % 2;
8892       else if (M != -1 && M/2 == BDWord)
8893         M = 2 * ADWord + M % 2;
8894
8895     // Recurse back into this routine to re-compute state now that this isn't
8896     // a 3 and 1 problem.
8897     return DAG.getVectorShuffle(MVT::v8i16, DL, V, DAG.getUNDEF(MVT::v8i16),
8898                                 Mask);
8899   };
8900   if ((NumLToL == 3 && NumHToL == 1) || (NumLToL == 1 && NumHToL == 3))
8901     return balanceSides(LToLInputs, HToLInputs, HToHInputs, LToHInputs, 0, 4);
8902   else if ((NumHToH == 3 && NumLToH == 1) || (NumHToH == 1 && NumLToH == 3))
8903     return balanceSides(HToHInputs, LToHInputs, LToLInputs, HToLInputs, 4, 0);
8904
8905   // At this point there are at most two inputs to the low and high halves from
8906   // each half. That means the inputs can always be grouped into dwords and
8907   // those dwords can then be moved to the correct half with a dword shuffle.
8908   // We use at most one low and one high word shuffle to collect these paired
8909   // inputs into dwords, and finally a dword shuffle to place them.
8910   int PSHUFLMask[4] = {-1, -1, -1, -1};
8911   int PSHUFHMask[4] = {-1, -1, -1, -1};
8912   int PSHUFDMask[4] = {-1, -1, -1, -1};
8913
8914   // First fix the masks for all the inputs that are staying in their
8915   // original halves. This will then dictate the targets of the cross-half
8916   // shuffles.
8917   auto fixInPlaceInputs =
8918       [&PSHUFDMask](ArrayRef<int> InPlaceInputs, ArrayRef<int> IncomingInputs,
8919                     MutableArrayRef<int> SourceHalfMask,
8920                     MutableArrayRef<int> HalfMask, int HalfOffset) {
8921     if (InPlaceInputs.empty())
8922       return;
8923     if (InPlaceInputs.size() == 1) {
8924       SourceHalfMask[InPlaceInputs[0] - HalfOffset] =
8925           InPlaceInputs[0] - HalfOffset;
8926       PSHUFDMask[InPlaceInputs[0] / 2] = InPlaceInputs[0] / 2;
8927       return;
8928     }
8929     if (IncomingInputs.empty()) {
8930       // Just fix all of the in place inputs.
8931       for (int Input : InPlaceInputs) {
8932         SourceHalfMask[Input - HalfOffset] = Input - HalfOffset;
8933         PSHUFDMask[Input / 2] = Input / 2;
8934       }
8935       return;
8936     }
8937
8938     assert(InPlaceInputs.size() == 2 && "Cannot handle 3 or 4 inputs!");
8939     SourceHalfMask[InPlaceInputs[0] - HalfOffset] =
8940         InPlaceInputs[0] - HalfOffset;
8941     // Put the second input next to the first so that they are packed into
8942     // a dword. We find the adjacent index by toggling the low bit.
8943     int AdjIndex = InPlaceInputs[0] ^ 1;
8944     SourceHalfMask[AdjIndex - HalfOffset] = InPlaceInputs[1] - HalfOffset;
8945     std::replace(HalfMask.begin(), HalfMask.end(), InPlaceInputs[1], AdjIndex);
8946     PSHUFDMask[AdjIndex / 2] = AdjIndex / 2;
8947   };
8948   fixInPlaceInputs(LToLInputs, HToLInputs, PSHUFLMask, LoMask, 0);
8949   fixInPlaceInputs(HToHInputs, LToHInputs, PSHUFHMask, HiMask, 4);
8950
8951   // Now gather the cross-half inputs and place them into a free dword of
8952   // their target half.
8953   // FIXME: This operation could almost certainly be simplified dramatically to
8954   // look more like the 3-1 fixing operation.
8955   auto moveInputsToRightHalf = [&PSHUFDMask](
8956       MutableArrayRef<int> IncomingInputs, ArrayRef<int> ExistingInputs,
8957       MutableArrayRef<int> SourceHalfMask, MutableArrayRef<int> HalfMask,
8958       MutableArrayRef<int> FinalSourceHalfMask, int SourceOffset,
8959       int DestOffset) {
8960     auto isWordClobbered = [](ArrayRef<int> SourceHalfMask, int Word) {
8961       return SourceHalfMask[Word] != -1 && SourceHalfMask[Word] != Word;
8962     };
8963     auto isDWordClobbered = [&isWordClobbered](ArrayRef<int> SourceHalfMask,
8964                                                int Word) {
8965       int LowWord = Word & ~1;
8966       int HighWord = Word | 1;
8967       return isWordClobbered(SourceHalfMask, LowWord) ||
8968              isWordClobbered(SourceHalfMask, HighWord);
8969     };
8970
8971     if (IncomingInputs.empty())
8972       return;
8973
8974     if (ExistingInputs.empty()) {
8975       // Map any dwords with inputs from them into the right half.
8976       for (int Input : IncomingInputs) {
8977         // If the source half mask maps over the inputs, turn those into
8978         // swaps and use the swapped lane.
8979         if (isWordClobbered(SourceHalfMask, Input - SourceOffset)) {
8980           if (SourceHalfMask[SourceHalfMask[Input - SourceOffset]] == -1) {
8981             SourceHalfMask[SourceHalfMask[Input - SourceOffset]] =
8982                 Input - SourceOffset;
8983             // We have to swap the uses in our half mask in one sweep.
8984             for (int &M : HalfMask)
8985               if (M == SourceHalfMask[Input - SourceOffset] + SourceOffset)
8986                 M = Input;
8987               else if (M == Input)
8988                 M = SourceHalfMask[Input - SourceOffset] + SourceOffset;
8989           } else {
8990             assert(SourceHalfMask[SourceHalfMask[Input - SourceOffset]] ==
8991                        Input - SourceOffset &&
8992                    "Previous placement doesn't match!");
8993           }
8994           // Note that this correctly re-maps both when we do a swap and when
8995           // we observe the other side of the swap above. We rely on that to
8996           // avoid swapping the members of the input list directly.
8997           Input = SourceHalfMask[Input - SourceOffset] + SourceOffset;
8998         }
8999
9000         // Map the input's dword into the correct half.
9001         if (PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] == -1)
9002           PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] = Input / 2;
9003         else
9004           assert(PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] ==
9005                      Input / 2 &&
9006                  "Previous placement doesn't match!");
9007       }
9008
9009       // And just directly shift any other-half mask elements to be same-half
9010       // as we will have mirrored the dword containing the element into the
9011       // same position within that half.
9012       for (int &M : HalfMask)
9013         if (M >= SourceOffset && M < SourceOffset + 4) {
9014           M = M - SourceOffset + DestOffset;
9015           assert(M >= 0 && "This should never wrap below zero!");
9016         }
9017       return;
9018     }
9019
9020     // Ensure we have the input in a viable dword of its current half. This
9021     // is particularly tricky because the original position may be clobbered
9022     // by inputs being moved and *staying* in that half.
9023     if (IncomingInputs.size() == 1) {
9024       if (isWordClobbered(SourceHalfMask, IncomingInputs[0] - SourceOffset)) {
9025         int InputFixed = std::find(std::begin(SourceHalfMask),
9026                                    std::end(SourceHalfMask), -1) -
9027                          std::begin(SourceHalfMask) + SourceOffset;
9028         SourceHalfMask[InputFixed - SourceOffset] =
9029             IncomingInputs[0] - SourceOffset;
9030         std::replace(HalfMask.begin(), HalfMask.end(), IncomingInputs[0],
9031                      InputFixed);
9032         IncomingInputs[0] = InputFixed;
9033       }
9034     } else if (IncomingInputs.size() == 2) {
9035       if (IncomingInputs[0] / 2 != IncomingInputs[1] / 2 ||
9036           isDWordClobbered(SourceHalfMask, IncomingInputs[0] - SourceOffset)) {
9037         // We have two non-adjacent or clobbered inputs we need to extract from
9038         // the source half. To do this, we need to map them into some adjacent
9039         // dword slot in the source mask.
9040         int InputsFixed[2] = {IncomingInputs[0] - SourceOffset,
9041                               IncomingInputs[1] - SourceOffset};
9042
9043         // If there is a free slot in the source half mask adjacent to one of
9044         // the inputs, place the other input in it. We use (Index XOR 1) to
9045         // compute an adjacent index.
9046         if (!isWordClobbered(SourceHalfMask, InputsFixed[0]) &&
9047             SourceHalfMask[InputsFixed[0] ^ 1] == -1) {
9048           SourceHalfMask[InputsFixed[0]] = InputsFixed[0];
9049           SourceHalfMask[InputsFixed[0] ^ 1] = InputsFixed[1];
9050           InputsFixed[1] = InputsFixed[0] ^ 1;
9051         } else if (!isWordClobbered(SourceHalfMask, InputsFixed[1]) &&
9052                    SourceHalfMask[InputsFixed[1] ^ 1] == -1) {
9053           SourceHalfMask[InputsFixed[1]] = InputsFixed[1];
9054           SourceHalfMask[InputsFixed[1] ^ 1] = InputsFixed[0];
9055           InputsFixed[0] = InputsFixed[1] ^ 1;
9056         } else if (SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1)] == -1 &&
9057                    SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1) + 1] == -1) {
9058           // The two inputs are in the same DWord but it is clobbered and the
9059           // adjacent DWord isn't used at all. Move both inputs to the free
9060           // slot.
9061           SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1)] = InputsFixed[0];
9062           SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1) + 1] = InputsFixed[1];
9063           InputsFixed[0] = 2 * ((InputsFixed[0] / 2) ^ 1);
9064           InputsFixed[1] = 2 * ((InputsFixed[0] / 2) ^ 1) + 1;
9065         } else {
9066           // The only way we hit this point is if there is no clobbering
9067           // (because there are no off-half inputs to this half) and there is no
9068           // free slot adjacent to one of the inputs. In this case, we have to
9069           // swap an input with a non-input.
9070           for (int i = 0; i < 4; ++i)
9071             assert((SourceHalfMask[i] == -1 || SourceHalfMask[i] == i) &&
9072                    "We can't handle any clobbers here!");
9073           assert(InputsFixed[1] != (InputsFixed[0] ^ 1) &&
9074                  "Cannot have adjacent inputs here!");
9075
9076           SourceHalfMask[InputsFixed[0] ^ 1] = InputsFixed[1];
9077           SourceHalfMask[InputsFixed[1]] = InputsFixed[0] ^ 1;
9078
9079           // We also have to update the final source mask in this case because
9080           // it may need to undo the above swap.
9081           for (int &M : FinalSourceHalfMask)
9082             if (M == (InputsFixed[0] ^ 1) + SourceOffset)
9083               M = InputsFixed[1] + SourceOffset;
9084             else if (M == InputsFixed[1] + SourceOffset)
9085               M = (InputsFixed[0] ^ 1) + SourceOffset;
9086
9087           InputsFixed[1] = InputsFixed[0] ^ 1;
9088         }
9089
9090         // Point everything at the fixed inputs.
9091         for (int &M : HalfMask)
9092           if (M == IncomingInputs[0])
9093             M = InputsFixed[0] + SourceOffset;
9094           else if (M == IncomingInputs[1])
9095             M = InputsFixed[1] + SourceOffset;
9096
9097         IncomingInputs[0] = InputsFixed[0] + SourceOffset;
9098         IncomingInputs[1] = InputsFixed[1] + SourceOffset;
9099       }
9100     } else {
9101       llvm_unreachable("Unhandled input size!");
9102     }
9103
9104     // Now hoist the DWord down to the right half.
9105     int FreeDWord = (PSHUFDMask[DestOffset / 2] == -1 ? 0 : 1) + DestOffset / 2;
9106     assert(PSHUFDMask[FreeDWord] == -1 && "DWord not free");
9107     PSHUFDMask[FreeDWord] = IncomingInputs[0] / 2;
9108     for (int &M : HalfMask)
9109       for (int Input : IncomingInputs)
9110         if (M == Input)
9111           M = FreeDWord * 2 + Input % 2;
9112   };
9113   moveInputsToRightHalf(HToLInputs, LToLInputs, PSHUFHMask, LoMask, HiMask,
9114                         /*SourceOffset*/ 4, /*DestOffset*/ 0);
9115   moveInputsToRightHalf(LToHInputs, HToHInputs, PSHUFLMask, HiMask, LoMask,
9116                         /*SourceOffset*/ 0, /*DestOffset*/ 4);
9117
9118   // Now enact all the shuffles we've computed to move the inputs into their
9119   // target half.
9120   if (!isNoopShuffleMask(PSHUFLMask))
9121     V = DAG.getNode(X86ISD::PSHUFLW, DL, MVT::v8i16, V,
9122                     getV4X86ShuffleImm8ForMask(PSHUFLMask, DAG));
9123   if (!isNoopShuffleMask(PSHUFHMask))
9124     V = DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16, V,
9125                     getV4X86ShuffleImm8ForMask(PSHUFHMask, DAG));
9126   if (!isNoopShuffleMask(PSHUFDMask))
9127     V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
9128                     DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
9129                                 DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V),
9130                                 getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
9131
9132   // At this point, each half should contain all its inputs, and we can then
9133   // just shuffle them into their final position.
9134   assert(std::count_if(LoMask.begin(), LoMask.end(),
9135                        [](int M) { return M >= 4; }) == 0 &&
9136          "Failed to lift all the high half inputs to the low mask!");
9137   assert(std::count_if(HiMask.begin(), HiMask.end(),
9138                        [](int M) { return M >= 0 && M < 4; }) == 0 &&
9139          "Failed to lift all the low half inputs to the high mask!");
9140
9141   // Do a half shuffle for the low mask.
9142   if (!isNoopShuffleMask(LoMask))
9143     V = DAG.getNode(X86ISD::PSHUFLW, DL, MVT::v8i16, V,
9144                     getV4X86ShuffleImm8ForMask(LoMask, DAG));
9145
9146   // Do a half shuffle with the high mask after shifting its values down.
9147   for (int &M : HiMask)
9148     if (M >= 0)
9149       M -= 4;
9150   if (!isNoopShuffleMask(HiMask))
9151     V = DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16, V,
9152                     getV4X86ShuffleImm8ForMask(HiMask, DAG));
9153
9154   return V;
9155 }
9156
9157 /// \brief Detect whether the mask pattern should be lowered through
9158 /// interleaving.
9159 ///
9160 /// This essentially tests whether viewing the mask as an interleaving of two
9161 /// sub-sequences reduces the cross-input traffic of a blend operation. If so,
9162 /// lowering it through interleaving is a significantly better strategy.
9163 static bool shouldLowerAsInterleaving(ArrayRef<int> Mask) {
9164   int NumEvenInputs[2] = {0, 0};
9165   int NumOddInputs[2] = {0, 0};
9166   int NumLoInputs[2] = {0, 0};
9167   int NumHiInputs[2] = {0, 0};
9168   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
9169     if (Mask[i] < 0)
9170       continue;
9171
9172     int InputIdx = Mask[i] >= Size;
9173
9174     if (i < Size / 2)
9175       ++NumLoInputs[InputIdx];
9176     else
9177       ++NumHiInputs[InputIdx];
9178
9179     if ((i % 2) == 0)
9180       ++NumEvenInputs[InputIdx];
9181     else
9182       ++NumOddInputs[InputIdx];
9183   }
9184
9185   // The minimum number of cross-input results for both the interleaved and
9186   // split cases. If interleaving results in fewer cross-input results, return
9187   // true.
9188   int InterleavedCrosses = std::min(NumEvenInputs[1] + NumOddInputs[0],
9189                                     NumEvenInputs[0] + NumOddInputs[1]);
9190   int SplitCrosses = std::min(NumLoInputs[1] + NumHiInputs[0],
9191                               NumLoInputs[0] + NumHiInputs[1]);
9192   return InterleavedCrosses < SplitCrosses;
9193 }
9194
9195 /// \brief Blend two v8i16 vectors using a naive unpack strategy.
9196 ///
9197 /// This strategy only works when the inputs from each vector fit into a single
9198 /// half of that vector, and generally there are not so many inputs as to leave
9199 /// the in-place shuffles required highly constrained (and thus expensive). It
9200 /// shifts all the inputs into a single side of both input vectors and then
9201 /// uses an unpack to interleave these inputs in a single vector. At that
9202 /// point, we will fall back on the generic single input shuffle lowering.
9203 static SDValue lowerV8I16BasicBlendVectorShuffle(SDLoc DL, SDValue V1,
9204                                                  SDValue V2,
9205                                                  MutableArrayRef<int> Mask,
9206                                                  const X86Subtarget *Subtarget,
9207                                                  SelectionDAG &DAG) {
9208   assert(V1.getSimpleValueType() == MVT::v8i16 && "Bad input type!");
9209   assert(V2.getSimpleValueType() == MVT::v8i16 && "Bad input type!");
9210   SmallVector<int, 3> LoV1Inputs, HiV1Inputs, LoV2Inputs, HiV2Inputs;
9211   for (int i = 0; i < 8; ++i)
9212     if (Mask[i] >= 0 && Mask[i] < 4)
9213       LoV1Inputs.push_back(i);
9214     else if (Mask[i] >= 4 && Mask[i] < 8)
9215       HiV1Inputs.push_back(i);
9216     else if (Mask[i] >= 8 && Mask[i] < 12)
9217       LoV2Inputs.push_back(i);
9218     else if (Mask[i] >= 12)
9219       HiV2Inputs.push_back(i);
9220
9221   int NumV1Inputs = LoV1Inputs.size() + HiV1Inputs.size();
9222   int NumV2Inputs = LoV2Inputs.size() + HiV2Inputs.size();
9223   (void)NumV1Inputs;
9224   (void)NumV2Inputs;
9225   assert(NumV1Inputs > 0 && NumV1Inputs <= 3 && "At most 3 inputs supported");
9226   assert(NumV2Inputs > 0 && NumV2Inputs <= 3 && "At most 3 inputs supported");
9227   assert(NumV1Inputs + NumV2Inputs <= 4 && "At most 4 combined inputs");
9228
9229   bool MergeFromLo = LoV1Inputs.size() + LoV2Inputs.size() >=
9230                      HiV1Inputs.size() + HiV2Inputs.size();
9231
9232   auto moveInputsToHalf = [&](SDValue V, ArrayRef<int> LoInputs,
9233                               ArrayRef<int> HiInputs, bool MoveToLo,
9234                               int MaskOffset) {
9235     ArrayRef<int> GoodInputs = MoveToLo ? LoInputs : HiInputs;
9236     ArrayRef<int> BadInputs = MoveToLo ? HiInputs : LoInputs;
9237     if (BadInputs.empty())
9238       return V;
9239
9240     int MoveMask[] = {-1, -1, -1, -1, -1, -1, -1, -1};
9241     int MoveOffset = MoveToLo ? 0 : 4;
9242
9243     if (GoodInputs.empty()) {
9244       for (int BadInput : BadInputs) {
9245         MoveMask[Mask[BadInput] % 4 + MoveOffset] = Mask[BadInput] - MaskOffset;
9246         Mask[BadInput] = Mask[BadInput] % 4 + MoveOffset + MaskOffset;
9247       }
9248     } else {
9249       if (GoodInputs.size() == 2) {
9250         // If the low inputs are spread across two dwords, pack them into
9251         // a single dword.
9252         MoveMask[MoveOffset] = Mask[GoodInputs[0]] - MaskOffset;
9253         MoveMask[MoveOffset + 1] = Mask[GoodInputs[1]] - MaskOffset;
9254         Mask[GoodInputs[0]] = MoveOffset + MaskOffset;
9255         Mask[GoodInputs[1]] = MoveOffset + 1 + MaskOffset;
9256       } else {
9257         // Otherwise pin the good inputs.
9258         for (int GoodInput : GoodInputs)
9259           MoveMask[Mask[GoodInput] - MaskOffset] = Mask[GoodInput] - MaskOffset;
9260       }
9261
9262       if (BadInputs.size() == 2) {
9263         // If we have two bad inputs then there may be either one or two good
9264         // inputs fixed in place. Find a fixed input, and then find the *other*
9265         // two adjacent indices by using modular arithmetic.
9266         int GoodMaskIdx =
9267             std::find_if(std::begin(MoveMask) + MoveOffset, std::end(MoveMask),
9268                          [](int M) { return M >= 0; }) -
9269             std::begin(MoveMask);
9270         int MoveMaskIdx =
9271             ((((GoodMaskIdx - MoveOffset) & ~1) + 2) % 4) + MoveOffset;
9272         assert(MoveMask[MoveMaskIdx] == -1 && "Expected empty slot");
9273         assert(MoveMask[MoveMaskIdx + 1] == -1 && "Expected empty slot");
9274         MoveMask[MoveMaskIdx] = Mask[BadInputs[0]] - MaskOffset;
9275         MoveMask[MoveMaskIdx + 1] = Mask[BadInputs[1]] - MaskOffset;
9276         Mask[BadInputs[0]] = MoveMaskIdx + MaskOffset;
9277         Mask[BadInputs[1]] = MoveMaskIdx + 1 + MaskOffset;
9278       } else {
9279         assert(BadInputs.size() == 1 && "All sizes handled");
9280         int MoveMaskIdx = std::find(std::begin(MoveMask) + MoveOffset,
9281                                     std::end(MoveMask), -1) -
9282                           std::begin(MoveMask);
9283         MoveMask[MoveMaskIdx] = Mask[BadInputs[0]] - MaskOffset;
9284         Mask[BadInputs[0]] = MoveMaskIdx + MaskOffset;
9285       }
9286     }
9287
9288     return DAG.getVectorShuffle(MVT::v8i16, DL, V, DAG.getUNDEF(MVT::v8i16),
9289                                 MoveMask);
9290   };
9291   V1 = moveInputsToHalf(V1, LoV1Inputs, HiV1Inputs, MergeFromLo,
9292                         /*MaskOffset*/ 0);
9293   V2 = moveInputsToHalf(V2, LoV2Inputs, HiV2Inputs, MergeFromLo,
9294                         /*MaskOffset*/ 8);
9295
9296   // FIXME: Select an interleaving of the merge of V1 and V2 that minimizes
9297   // cross-half traffic in the final shuffle.
9298
9299   // Munge the mask to be a single-input mask after the unpack merges the
9300   // results.
9301   for (int &M : Mask)
9302     if (M != -1)
9303       M = 2 * (M % 4) + (M / 8);
9304
9305   return DAG.getVectorShuffle(
9306       MVT::v8i16, DL, DAG.getNode(MergeFromLo ? X86ISD::UNPCKL : X86ISD::UNPCKH,
9307                                   DL, MVT::v8i16, V1, V2),
9308       DAG.getUNDEF(MVT::v8i16), Mask);
9309 }
9310
9311 /// \brief Generic lowering of 8-lane i16 shuffles.
9312 ///
9313 /// This handles both single-input shuffles and combined shuffle/blends with
9314 /// two inputs. The single input shuffles are immediately delegated to
9315 /// a dedicated lowering routine.
9316 ///
9317 /// The blends are lowered in one of three fundamental ways. If there are few
9318 /// enough inputs, it delegates to a basic UNPCK-based strategy. If the shuffle
9319 /// of the input is significantly cheaper when lowered as an interleaving of
9320 /// the two inputs, try to interleave them. Otherwise, blend the low and high
9321 /// halves of the inputs separately (making them have relatively few inputs)
9322 /// and then concatenate them.
9323 static SDValue lowerV8I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9324                                        const X86Subtarget *Subtarget,
9325                                        SelectionDAG &DAG) {
9326   SDLoc DL(Op);
9327   assert(Op.getSimpleValueType() == MVT::v8i16 && "Bad shuffle type!");
9328   assert(V1.getSimpleValueType() == MVT::v8i16 && "Bad operand type!");
9329   assert(V2.getSimpleValueType() == MVT::v8i16 && "Bad operand type!");
9330   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9331   ArrayRef<int> OrigMask = SVOp->getMask();
9332   int MaskStorage[8] = {OrigMask[0], OrigMask[1], OrigMask[2], OrigMask[3],
9333                         OrigMask[4], OrigMask[5], OrigMask[6], OrigMask[7]};
9334   MutableArrayRef<int> Mask(MaskStorage);
9335
9336   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
9337
9338   // Whenever we can lower this as a zext, that instruction is strictly faster
9339   // than any alternative.
9340   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(
9341           DL, MVT::v8i16, V1, V2, OrigMask, Subtarget, DAG))
9342     return ZExt;
9343
9344   auto isV1 = [](int M) { return M >= 0 && M < 8; };
9345   auto isV2 = [](int M) { return M >= 8; };
9346
9347   int NumV1Inputs = std::count_if(Mask.begin(), Mask.end(), isV1);
9348   int NumV2Inputs = std::count_if(Mask.begin(), Mask.end(), isV2);
9349
9350   if (NumV2Inputs == 0)
9351     return lowerV8I16SingleInputVectorShuffle(DL, V1, Mask, Subtarget, DAG);
9352
9353   assert(NumV1Inputs > 0 && "All single-input shuffles should be canonicalized "
9354                             "to be V1-input shuffles.");
9355
9356   // Try to use byte shift instructions.
9357   if (SDValue Shift = lowerVectorShuffleAsByteShift(
9358           DL, MVT::v8i16, V1, V2, Mask, DAG))
9359     return Shift;
9360
9361   // There are special ways we can lower some single-element blends.
9362   if (NumV2Inputs == 1)
9363     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v8i16, DL, V1, V2,
9364                                                          Mask, Subtarget, DAG))
9365       return V;
9366
9367   // Use dedicated unpack instructions for masks that match their pattern.
9368   if (isShuffleEquivalent(Mask, 0, 8, 1, 9, 2, 10, 3, 11))
9369     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, V1, V2);
9370   if (isShuffleEquivalent(Mask, 4, 12, 5, 13, 6, 14, 7, 15))
9371     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i16, V1, V2);
9372
9373   if (Subtarget->hasSSE41())
9374     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8i16, V1, V2, Mask,
9375                                                   Subtarget, DAG))
9376       return Blend;
9377
9378   // Try to use byte rotation instructions.
9379   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9380           DL, MVT::v8i16, V1, V2, Mask, Subtarget, DAG))
9381     return Rotate;
9382
9383   if (NumV1Inputs + NumV2Inputs <= 4)
9384     return lowerV8I16BasicBlendVectorShuffle(DL, V1, V2, Mask, Subtarget, DAG);
9385
9386   // Check whether an interleaving lowering is likely to be more efficient.
9387   // This isn't perfect but it is a strong heuristic that tends to work well on
9388   // the kinds of shuffles that show up in practice.
9389   //
9390   // FIXME: Handle 1x, 2x, and 4x interleaving.
9391   if (shouldLowerAsInterleaving(Mask)) {
9392     // FIXME: Figure out whether we should pack these into the low or high
9393     // halves.
9394
9395     int EMask[8], OMask[8];
9396     for (int i = 0; i < 4; ++i) {
9397       EMask[i] = Mask[2*i];
9398       OMask[i] = Mask[2*i + 1];
9399       EMask[i + 4] = -1;
9400       OMask[i + 4] = -1;
9401     }
9402
9403     SDValue Evens = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, EMask);
9404     SDValue Odds = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, OMask);
9405
9406     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, Evens, Odds);
9407   }
9408
9409   int LoBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9410   int HiBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9411
9412   for (int i = 0; i < 4; ++i) {
9413     LoBlendMask[i] = Mask[i];
9414     HiBlendMask[i] = Mask[i + 4];
9415   }
9416
9417   SDValue LoV = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, LoBlendMask);
9418   SDValue HiV = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, HiBlendMask);
9419   LoV = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, LoV);
9420   HiV = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, HiV);
9421
9422   return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
9423                      DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2i64, LoV, HiV));
9424 }
9425
9426 /// \brief Check whether a compaction lowering can be done by dropping even
9427 /// elements and compute how many times even elements must be dropped.
9428 ///
9429 /// This handles shuffles which take every Nth element where N is a power of
9430 /// two. Example shuffle masks:
9431 ///
9432 ///  N = 1:  0,  2,  4,  6,  8, 10, 12, 14,  0,  2,  4,  6,  8, 10, 12, 14
9433 ///  N = 1:  0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30
9434 ///  N = 2:  0,  4,  8, 12,  0,  4,  8, 12,  0,  4,  8, 12,  0,  4,  8, 12
9435 ///  N = 2:  0,  4,  8, 12, 16, 20, 24, 28,  0,  4,  8, 12, 16, 20, 24, 28
9436 ///  N = 3:  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8
9437 ///  N = 3:  0,  8, 16, 24,  0,  8, 16, 24,  0,  8, 16, 24,  0,  8, 16, 24
9438 ///
9439 /// Any of these lanes can of course be undef.
9440 ///
9441 /// This routine only supports N <= 3.
9442 /// FIXME: Evaluate whether either AVX or AVX-512 have any opportunities here
9443 /// for larger N.
9444 ///
9445 /// \returns N above, or the number of times even elements must be dropped if
9446 /// there is such a number. Otherwise returns zero.
9447 static int canLowerByDroppingEvenElements(ArrayRef<int> Mask) {
9448   // Figure out whether we're looping over two inputs or just one.
9449   bool IsSingleInput = isSingleInputShuffleMask(Mask);
9450
9451   // The modulus for the shuffle vector entries is based on whether this is
9452   // a single input or not.
9453   int ShuffleModulus = Mask.size() * (IsSingleInput ? 1 : 2);
9454   assert(isPowerOf2_32((uint32_t)ShuffleModulus) &&
9455          "We should only be called with masks with a power-of-2 size!");
9456
9457   uint64_t ModMask = (uint64_t)ShuffleModulus - 1;
9458
9459   // We track whether the input is viable for all power-of-2 strides 2^1, 2^2,
9460   // and 2^3 simultaneously. This is because we may have ambiguity with
9461   // partially undef inputs.
9462   bool ViableForN[3] = {true, true, true};
9463
9464   for (int i = 0, e = Mask.size(); i < e; ++i) {
9465     // Ignore undef lanes, we'll optimistically collapse them to the pattern we
9466     // want.
9467     if (Mask[i] == -1)
9468       continue;
9469
9470     bool IsAnyViable = false;
9471     for (unsigned j = 0; j != array_lengthof(ViableForN); ++j)
9472       if (ViableForN[j]) {
9473         uint64_t N = j + 1;
9474
9475         // The shuffle mask must be equal to (i * 2^N) % M.
9476         if ((uint64_t)Mask[i] == (((uint64_t)i << N) & ModMask))
9477           IsAnyViable = true;
9478         else
9479           ViableForN[j] = false;
9480       }
9481     // Early exit if we exhaust the possible powers of two.
9482     if (!IsAnyViable)
9483       break;
9484   }
9485
9486   for (unsigned j = 0; j != array_lengthof(ViableForN); ++j)
9487     if (ViableForN[j])
9488       return j + 1;
9489
9490   // Return 0 as there is no viable power of two.
9491   return 0;
9492 }
9493
9494 /// \brief Generic lowering of v16i8 shuffles.
9495 ///
9496 /// This is a hybrid strategy to lower v16i8 vectors. It first attempts to
9497 /// detect any complexity reducing interleaving. If that doesn't help, it uses
9498 /// UNPCK to spread the i8 elements across two i16-element vectors, and uses
9499 /// the existing lowering for v8i16 blends on each half, finally PACK-ing them
9500 /// back together.
9501 static SDValue lowerV16I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9502                                        const X86Subtarget *Subtarget,
9503                                        SelectionDAG &DAG) {
9504   SDLoc DL(Op);
9505   assert(Op.getSimpleValueType() == MVT::v16i8 && "Bad shuffle type!");
9506   assert(V1.getSimpleValueType() == MVT::v16i8 && "Bad operand type!");
9507   assert(V2.getSimpleValueType() == MVT::v16i8 && "Bad operand type!");
9508   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9509   ArrayRef<int> OrigMask = SVOp->getMask();
9510   assert(OrigMask.size() == 16 && "Unexpected mask size for v16 shuffle!");
9511
9512   // Try to use byte shift instructions.
9513   if (SDValue Shift = lowerVectorShuffleAsByteShift(
9514           DL, MVT::v16i8, V1, V2, OrigMask, DAG))
9515     return Shift;
9516
9517   // Try to use byte rotation instructions.
9518   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9519           DL, MVT::v16i8, V1, V2, OrigMask, Subtarget, DAG))
9520     return Rotate;
9521
9522   // Try to use a zext lowering.
9523   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(
9524           DL, MVT::v16i8, V1, V2, OrigMask, Subtarget, DAG))
9525     return ZExt;
9526
9527   int MaskStorage[16] = {
9528       OrigMask[0],  OrigMask[1],  OrigMask[2],  OrigMask[3],
9529       OrigMask[4],  OrigMask[5],  OrigMask[6],  OrigMask[7],
9530       OrigMask[8],  OrigMask[9],  OrigMask[10], OrigMask[11],
9531       OrigMask[12], OrigMask[13], OrigMask[14], OrigMask[15]};
9532   MutableArrayRef<int> Mask(MaskStorage);
9533   MutableArrayRef<int> LoMask = Mask.slice(0, 8);
9534   MutableArrayRef<int> HiMask = Mask.slice(8, 8);
9535
9536   int NumV2Elements =
9537       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 16; });
9538
9539   // For single-input shuffles, there are some nicer lowering tricks we can use.
9540   if (NumV2Elements == 0) {
9541     // Check for being able to broadcast a single element.
9542     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v16i8, DL, V1,
9543                                                           Mask, Subtarget, DAG))
9544       return Broadcast;
9545
9546     // Check whether we can widen this to an i16 shuffle by duplicating bytes.
9547     // Notably, this handles splat and partial-splat shuffles more efficiently.
9548     // However, it only makes sense if the pre-duplication shuffle simplifies
9549     // things significantly. Currently, this means we need to be able to
9550     // express the pre-duplication shuffle as an i16 shuffle.
9551     //
9552     // FIXME: We should check for other patterns which can be widened into an
9553     // i16 shuffle as well.
9554     auto canWidenViaDuplication = [](ArrayRef<int> Mask) {
9555       for (int i = 0; i < 16; i += 2)
9556         if (Mask[i] != -1 && Mask[i + 1] != -1 && Mask[i] != Mask[i + 1])
9557           return false;
9558
9559       return true;
9560     };
9561     auto tryToWidenViaDuplication = [&]() -> SDValue {
9562       if (!canWidenViaDuplication(Mask))
9563         return SDValue();
9564       SmallVector<int, 4> LoInputs;
9565       std::copy_if(Mask.begin(), Mask.end(), std::back_inserter(LoInputs),
9566                    [](int M) { return M >= 0 && M < 8; });
9567       std::sort(LoInputs.begin(), LoInputs.end());
9568       LoInputs.erase(std::unique(LoInputs.begin(), LoInputs.end()),
9569                      LoInputs.end());
9570       SmallVector<int, 4> HiInputs;
9571       std::copy_if(Mask.begin(), Mask.end(), std::back_inserter(HiInputs),
9572                    [](int M) { return M >= 8; });
9573       std::sort(HiInputs.begin(), HiInputs.end());
9574       HiInputs.erase(std::unique(HiInputs.begin(), HiInputs.end()),
9575                      HiInputs.end());
9576
9577       bool TargetLo = LoInputs.size() >= HiInputs.size();
9578       ArrayRef<int> InPlaceInputs = TargetLo ? LoInputs : HiInputs;
9579       ArrayRef<int> MovingInputs = TargetLo ? HiInputs : LoInputs;
9580
9581       int PreDupI16Shuffle[] = {-1, -1, -1, -1, -1, -1, -1, -1};
9582       SmallDenseMap<int, int, 8> LaneMap;
9583       for (int I : InPlaceInputs) {
9584         PreDupI16Shuffle[I/2] = I/2;
9585         LaneMap[I] = I;
9586       }
9587       int j = TargetLo ? 0 : 4, je = j + 4;
9588       for (int i = 0, ie = MovingInputs.size(); i < ie; ++i) {
9589         // Check if j is already a shuffle of this input. This happens when
9590         // there are two adjacent bytes after we move the low one.
9591         if (PreDupI16Shuffle[j] != MovingInputs[i] / 2) {
9592           // If we haven't yet mapped the input, search for a slot into which
9593           // we can map it.
9594           while (j < je && PreDupI16Shuffle[j] != -1)
9595             ++j;
9596
9597           if (j == je)
9598             // We can't place the inputs into a single half with a simple i16 shuffle, so bail.
9599             return SDValue();
9600
9601           // Map this input with the i16 shuffle.
9602           PreDupI16Shuffle[j] = MovingInputs[i] / 2;
9603         }
9604
9605         // Update the lane map based on the mapping we ended up with.
9606         LaneMap[MovingInputs[i]] = 2 * j + MovingInputs[i] % 2;
9607       }
9608       V1 = DAG.getNode(
9609           ISD::BITCAST, DL, MVT::v16i8,
9610           DAG.getVectorShuffle(MVT::v8i16, DL,
9611                                DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
9612                                DAG.getUNDEF(MVT::v8i16), PreDupI16Shuffle));
9613
9614       // Unpack the bytes to form the i16s that will be shuffled into place.
9615       V1 = DAG.getNode(TargetLo ? X86ISD::UNPCKL : X86ISD::UNPCKH, DL,
9616                        MVT::v16i8, V1, V1);
9617
9618       int PostDupI16Shuffle[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9619       for (int i = 0; i < 16; ++i)
9620         if (Mask[i] != -1) {
9621           int MappedMask = LaneMap[Mask[i]] - (TargetLo ? 0 : 8);
9622           assert(MappedMask < 8 && "Invalid v8 shuffle mask!");
9623           if (PostDupI16Shuffle[i / 2] == -1)
9624             PostDupI16Shuffle[i / 2] = MappedMask;
9625           else
9626             assert(PostDupI16Shuffle[i / 2] == MappedMask &&
9627                    "Conflicting entrties in the original shuffle!");
9628         }
9629       return DAG.getNode(
9630           ISD::BITCAST, DL, MVT::v16i8,
9631           DAG.getVectorShuffle(MVT::v8i16, DL,
9632                                DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
9633                                DAG.getUNDEF(MVT::v8i16), PostDupI16Shuffle));
9634     };
9635     if (SDValue V = tryToWidenViaDuplication())
9636       return V;
9637   }
9638
9639   // Check whether an interleaving lowering is likely to be more efficient.
9640   // This isn't perfect but it is a strong heuristic that tends to work well on
9641   // the kinds of shuffles that show up in practice.
9642   //
9643   // FIXME: We need to handle other interleaving widths (i16, i32, ...).
9644   if (shouldLowerAsInterleaving(Mask)) {
9645     int NumLoHalf = std::count_if(Mask.begin(), Mask.end(), [](int M) {
9646       return (M >= 0 && M < 8) || (M >= 16 && M < 24);
9647     });
9648     int NumHiHalf = std::count_if(Mask.begin(), Mask.end(), [](int M) {
9649       return (M >= 8 && M < 16) || M >= 24;
9650     });
9651     int EMask[16] = {-1, -1, -1, -1, -1, -1, -1, -1,
9652                      -1, -1, -1, -1, -1, -1, -1, -1};
9653     int OMask[16] = {-1, -1, -1, -1, -1, -1, -1, -1,
9654                      -1, -1, -1, -1, -1, -1, -1, -1};
9655     bool UnpackLo = NumLoHalf >= NumHiHalf;
9656     MutableArrayRef<int> TargetEMask(UnpackLo ? EMask : EMask + 8, 8);
9657     MutableArrayRef<int> TargetOMask(UnpackLo ? OMask : OMask + 8, 8);
9658     for (int i = 0; i < 8; ++i) {
9659       TargetEMask[i] = Mask[2 * i];
9660       TargetOMask[i] = Mask[2 * i + 1];
9661     }
9662
9663     SDValue Evens = DAG.getVectorShuffle(MVT::v16i8, DL, V1, V2, EMask);
9664     SDValue Odds = DAG.getVectorShuffle(MVT::v16i8, DL, V1, V2, OMask);
9665
9666     return DAG.getNode(UnpackLo ? X86ISD::UNPCKL : X86ISD::UNPCKH, DL,
9667                        MVT::v16i8, Evens, Odds);
9668   }
9669
9670   // Check for SSSE3 which lets us lower all v16i8 shuffles much more directly
9671   // with PSHUFB. It is important to do this before we attempt to generate any
9672   // blends but after all of the single-input lowerings. If the single input
9673   // lowerings can find an instruction sequence that is faster than a PSHUFB, we
9674   // want to preserve that and we can DAG combine any longer sequences into
9675   // a PSHUFB in the end. But once we start blending from multiple inputs,
9676   // the complexity of DAG combining bad patterns back into PSHUFB is too high,
9677   // and there are *very* few patterns that would actually be faster than the
9678   // PSHUFB approach because of its ability to zero lanes.
9679   //
9680   // FIXME: The only exceptions to the above are blends which are exact
9681   // interleavings with direct instructions supporting them. We currently don't
9682   // handle those well here.
9683   if (Subtarget->hasSSSE3()) {
9684     SDValue V1Mask[16];
9685     SDValue V2Mask[16];
9686     bool V1InUse = false;
9687     bool V2InUse = false;
9688     SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
9689
9690     for (int i = 0; i < 16; ++i) {
9691       if (Mask[i] == -1) {
9692         V1Mask[i] = V2Mask[i] = DAG.getUNDEF(MVT::i8);
9693       } else {
9694         const int ZeroMask = 0x80;
9695         int V1Idx = (Mask[i] < 16 ? Mask[i] : ZeroMask);
9696         int V2Idx = (Mask[i] < 16 ? ZeroMask : Mask[i] - 16);
9697         if (Zeroable[i])
9698           V1Idx = V2Idx = ZeroMask;
9699         V1Mask[i] = DAG.getConstant(V1Idx, MVT::i8);
9700         V2Mask[i] = DAG.getConstant(V2Idx, MVT::i8);
9701         V1InUse |= (ZeroMask != V1Idx);
9702         V2InUse |= (ZeroMask != V2Idx);
9703       }
9704     }
9705
9706     if (V1InUse)
9707       V1 = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, V1,
9708                        DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, V1Mask));
9709     if (V2InUse)
9710       V2 = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, V2,
9711                        DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, V2Mask));
9712
9713     // If we need shuffled inputs from both, blend the two.
9714     if (V1InUse && V2InUse)
9715       return DAG.getNode(ISD::OR, DL, MVT::v16i8, V1, V2);
9716     if (V1InUse)
9717       return V1; // Single inputs are easy.
9718     if (V2InUse)
9719       return V2; // Single inputs are easy.
9720     // Shuffling to a zeroable vector.
9721     return getZeroVector(MVT::v16i8, Subtarget, DAG, DL);
9722   }
9723
9724   // There are special ways we can lower some single-element blends.
9725   if (NumV2Elements == 1)
9726     if (SDValue V = lowerVectorShuffleAsElementInsertion(MVT::v16i8, DL, V1, V2,
9727                                                          Mask, Subtarget, DAG))
9728       return V;
9729
9730   // Check whether a compaction lowering can be done. This handles shuffles
9731   // which take every Nth element for some even N. See the helper function for
9732   // details.
9733   //
9734   // We special case these as they can be particularly efficiently handled with
9735   // the PACKUSB instruction on x86 and they show up in common patterns of
9736   // rearranging bytes to truncate wide elements.
9737   if (int NumEvenDrops = canLowerByDroppingEvenElements(Mask)) {
9738     // NumEvenDrops is the power of two stride of the elements. Another way of
9739     // thinking about it is that we need to drop the even elements this many
9740     // times to get the original input.
9741     bool IsSingleInput = isSingleInputShuffleMask(Mask);
9742
9743     // First we need to zero all the dropped bytes.
9744     assert(NumEvenDrops <= 3 &&
9745            "No support for dropping even elements more than 3 times.");
9746     // We use the mask type to pick which bytes are preserved based on how many
9747     // elements are dropped.
9748     MVT MaskVTs[] = { MVT::v8i16, MVT::v4i32, MVT::v2i64 };
9749     SDValue ByteClearMask =
9750         DAG.getNode(ISD::BITCAST, DL, MVT::v16i8,
9751                     DAG.getConstant(0xFF, MaskVTs[NumEvenDrops - 1]));
9752     V1 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V1, ByteClearMask);
9753     if (!IsSingleInput)
9754       V2 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V2, ByteClearMask);
9755
9756     // Now pack things back together.
9757     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1);
9758     V2 = IsSingleInput ? V1 : DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V2);
9759     SDValue Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, V1, V2);
9760     for (int i = 1; i < NumEvenDrops; ++i) {
9761       Result = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, Result);
9762       Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, Result, Result);
9763     }
9764
9765     return Result;
9766   }
9767
9768   int V1LoBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9769   int V1HiBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9770   int V2LoBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9771   int V2HiBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
9772
9773   auto buildBlendMasks = [](MutableArrayRef<int> HalfMask,
9774                             MutableArrayRef<int> V1HalfBlendMask,
9775                             MutableArrayRef<int> V2HalfBlendMask) {
9776     for (int i = 0; i < 8; ++i)
9777       if (HalfMask[i] >= 0 && HalfMask[i] < 16) {
9778         V1HalfBlendMask[i] = HalfMask[i];
9779         HalfMask[i] = i;
9780       } else if (HalfMask[i] >= 16) {
9781         V2HalfBlendMask[i] = HalfMask[i] - 16;
9782         HalfMask[i] = i + 8;
9783       }
9784   };
9785   buildBlendMasks(LoMask, V1LoBlendMask, V2LoBlendMask);
9786   buildBlendMasks(HiMask, V1HiBlendMask, V2HiBlendMask);
9787
9788   SDValue Zero = getZeroVector(MVT::v8i16, Subtarget, DAG, DL);
9789
9790   auto buildLoAndHiV8s = [&](SDValue V, MutableArrayRef<int> LoBlendMask,
9791                              MutableArrayRef<int> HiBlendMask) {
9792     SDValue V1, V2;
9793     // Check if any of the odd lanes in the v16i8 are used. If not, we can mask
9794     // them out and avoid using UNPCK{L,H} to extract the elements of V as
9795     // i16s.
9796     if (std::none_of(LoBlendMask.begin(), LoBlendMask.end(),
9797                      [](int M) { return M >= 0 && M % 2 == 1; }) &&
9798         std::none_of(HiBlendMask.begin(), HiBlendMask.end(),
9799                      [](int M) { return M >= 0 && M % 2 == 1; })) {
9800       // Use a mask to drop the high bytes.
9801       V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
9802       V1 = DAG.getNode(ISD::AND, DL, MVT::v8i16, V1,
9803                        DAG.getConstant(0x00FF, MVT::v8i16));
9804
9805       // This will be a single vector shuffle instead of a blend so nuke V2.
9806       V2 = DAG.getUNDEF(MVT::v8i16);
9807
9808       // Squash the masks to point directly into V1.
9809       for (int &M : LoBlendMask)
9810         if (M >= 0)
9811           M /= 2;
9812       for (int &M : HiBlendMask)
9813         if (M >= 0)
9814           M /= 2;
9815     } else {
9816       // Otherwise just unpack the low half of V into V1 and the high half into
9817       // V2 so that we can blend them as i16s.
9818       V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
9819                        DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V, Zero));
9820       V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
9821                        DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V, Zero));
9822     }
9823
9824     SDValue BlendedLo = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, LoBlendMask);
9825     SDValue BlendedHi = DAG.getVectorShuffle(MVT::v8i16, DL, V1, V2, HiBlendMask);
9826     return std::make_pair(BlendedLo, BlendedHi);
9827   };
9828   SDValue V1Lo, V1Hi, V2Lo, V2Hi;
9829   std::tie(V1Lo, V1Hi) = buildLoAndHiV8s(V1, V1LoBlendMask, V1HiBlendMask);
9830   std::tie(V2Lo, V2Hi) = buildLoAndHiV8s(V2, V2LoBlendMask, V2HiBlendMask);
9831
9832   SDValue LoV = DAG.getVectorShuffle(MVT::v8i16, DL, V1Lo, V2Lo, LoMask);
9833   SDValue HiV = DAG.getVectorShuffle(MVT::v8i16, DL, V1Hi, V2Hi, HiMask);
9834
9835   return DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, LoV, HiV);
9836 }
9837
9838 /// \brief Dispatching routine to lower various 128-bit x86 vector shuffles.
9839 ///
9840 /// This routine breaks down the specific type of 128-bit shuffle and
9841 /// dispatches to the lowering routines accordingly.
9842 static SDValue lower128BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9843                                         MVT VT, const X86Subtarget *Subtarget,
9844                                         SelectionDAG &DAG) {
9845   switch (VT.SimpleTy) {
9846   case MVT::v2i64:
9847     return lowerV2I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
9848   case MVT::v2f64:
9849     return lowerV2F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
9850   case MVT::v4i32:
9851     return lowerV4I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
9852   case MVT::v4f32:
9853     return lowerV4F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
9854   case MVT::v8i16:
9855     return lowerV8I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
9856   case MVT::v16i8:
9857     return lowerV16I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
9858
9859   default:
9860     llvm_unreachable("Unimplemented!");
9861   }
9862 }
9863
9864 /// \brief Helper function to test whether a shuffle mask could be
9865 /// simplified by widening the elements being shuffled.
9866 ///
9867 /// Appends the mask for wider elements in WidenedMask if valid. Otherwise
9868 /// leaves it in an unspecified state.
9869 ///
9870 /// NOTE: This must handle normal vector shuffle masks and *target* vector
9871 /// shuffle masks. The latter have the special property of a '-2' representing
9872 /// a zero-ed lane of a vector.
9873 static bool canWidenShuffleElements(ArrayRef<int> Mask,
9874                                     SmallVectorImpl<int> &WidenedMask) {
9875   for (int i = 0, Size = Mask.size(); i < Size; i += 2) {
9876     // If both elements are undef, its trivial.
9877     if (Mask[i] == SM_SentinelUndef && Mask[i + 1] == SM_SentinelUndef) {
9878       WidenedMask.push_back(SM_SentinelUndef);
9879       continue;
9880     }
9881
9882     // Check for an undef mask and a mask value properly aligned to fit with
9883     // a pair of values. If we find such a case, use the non-undef mask's value.
9884     if (Mask[i] == SM_SentinelUndef && Mask[i + 1] >= 0 && Mask[i + 1] % 2 == 1) {
9885       WidenedMask.push_back(Mask[i + 1] / 2);
9886       continue;
9887     }
9888     if (Mask[i + 1] == SM_SentinelUndef && Mask[i] >= 0 && Mask[i] % 2 == 0) {
9889       WidenedMask.push_back(Mask[i] / 2);
9890       continue;
9891     }
9892
9893     // When zeroing, we need to spread the zeroing across both lanes to widen.
9894     if (Mask[i] == SM_SentinelZero || Mask[i + 1] == SM_SentinelZero) {
9895       if ((Mask[i] == SM_SentinelZero || Mask[i] == SM_SentinelUndef) &&
9896           (Mask[i + 1] == SM_SentinelZero || Mask[i + 1] == SM_SentinelUndef)) {
9897         WidenedMask.push_back(SM_SentinelZero);
9898         continue;
9899       }
9900       return false;
9901     }
9902
9903     // Finally check if the two mask values are adjacent and aligned with
9904     // a pair.
9905     if (Mask[i] != SM_SentinelUndef && Mask[i] % 2 == 0 && Mask[i] + 1 == Mask[i + 1]) {
9906       WidenedMask.push_back(Mask[i] / 2);
9907       continue;
9908     }
9909
9910     // Otherwise we can't safely widen the elements used in this shuffle.
9911     return false;
9912   }
9913   assert(WidenedMask.size() == Mask.size() / 2 &&
9914          "Incorrect size of mask after widening the elements!");
9915
9916   return true;
9917 }
9918
9919 /// \brief Generic routine to split ector shuffle into half-sized shuffles.
9920 ///
9921 /// This routine just extracts two subvectors, shuffles them independently, and
9922 /// then concatenates them back together. This should work effectively with all
9923 /// AVX vector shuffle types.
9924 static SDValue splitAndLowerVectorShuffle(SDLoc DL, MVT VT, SDValue V1,
9925                                           SDValue V2, ArrayRef<int> Mask,
9926                                           SelectionDAG &DAG) {
9927   assert(VT.getSizeInBits() >= 256 &&
9928          "Only for 256-bit or wider vector shuffles!");
9929   assert(V1.getSimpleValueType() == VT && "Bad operand type!");
9930   assert(V2.getSimpleValueType() == VT && "Bad operand type!");
9931
9932   ArrayRef<int> LoMask = Mask.slice(0, Mask.size() / 2);
9933   ArrayRef<int> HiMask = Mask.slice(Mask.size() / 2);
9934
9935   int NumElements = VT.getVectorNumElements();
9936   int SplitNumElements = NumElements / 2;
9937   MVT ScalarVT = VT.getScalarType();
9938   MVT SplitVT = MVT::getVectorVT(ScalarVT, NumElements / 2);
9939
9940   SDValue LoV1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, V1,
9941                              DAG.getIntPtrConstant(0));
9942   SDValue HiV1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, V1,
9943                              DAG.getIntPtrConstant(SplitNumElements));
9944   SDValue LoV2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, V2,
9945                              DAG.getIntPtrConstant(0));
9946   SDValue HiV2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, V2,
9947                              DAG.getIntPtrConstant(SplitNumElements));
9948
9949   // Now create two 4-way blends of these half-width vectors.
9950   auto HalfBlend = [&](ArrayRef<int> HalfMask) {
9951     bool UseLoV1 = false, UseHiV1 = false, UseLoV2 = false, UseHiV2 = false;
9952     SmallVector<int, 32> V1BlendMask, V2BlendMask, BlendMask;
9953     for (int i = 0; i < SplitNumElements; ++i) {
9954       int M = HalfMask[i];
9955       if (M >= NumElements) {
9956         if (M >= NumElements + SplitNumElements)
9957           UseHiV2 = true;
9958         else
9959           UseLoV2 = true;
9960         V2BlendMask.push_back(M - NumElements);
9961         V1BlendMask.push_back(-1);
9962         BlendMask.push_back(SplitNumElements + i);
9963       } else if (M >= 0) {
9964         if (M >= SplitNumElements)
9965           UseHiV1 = true;
9966         else
9967           UseLoV1 = true;
9968         V2BlendMask.push_back(-1);
9969         V1BlendMask.push_back(M);
9970         BlendMask.push_back(i);
9971       } else {
9972         V2BlendMask.push_back(-1);
9973         V1BlendMask.push_back(-1);
9974         BlendMask.push_back(-1);
9975       }
9976     }
9977
9978     // Because the lowering happens after all combining takes place, we need to
9979     // manually combine these blend masks as much as possible so that we create
9980     // a minimal number of high-level vector shuffle nodes.
9981
9982     // First try just blending the halves of V1 or V2.
9983     if (!UseLoV1 && !UseHiV1 && !UseLoV2 && !UseHiV2)
9984       return DAG.getUNDEF(SplitVT);
9985     if (!UseLoV2 && !UseHiV2)
9986       return DAG.getVectorShuffle(SplitVT, DL, LoV1, HiV1, V1BlendMask);
9987     if (!UseLoV1 && !UseHiV1)
9988       return DAG.getVectorShuffle(SplitVT, DL, LoV2, HiV2, V2BlendMask);
9989
9990     SDValue V1Blend, V2Blend;
9991     if (UseLoV1 && UseHiV1) {
9992       V1Blend =
9993         DAG.getVectorShuffle(SplitVT, DL, LoV1, HiV1, V1BlendMask);
9994     } else {
9995       // We only use half of V1 so map the usage down into the final blend mask.
9996       V1Blend = UseLoV1 ? LoV1 : HiV1;
9997       for (int i = 0; i < SplitNumElements; ++i)
9998         if (BlendMask[i] >= 0 && BlendMask[i] < SplitNumElements)
9999           BlendMask[i] = V1BlendMask[i] - (UseLoV1 ? 0 : SplitNumElements);
10000     }
10001     if (UseLoV2 && UseHiV2) {
10002       V2Blend =
10003         DAG.getVectorShuffle(SplitVT, DL, LoV2, HiV2, V2BlendMask);
10004     } else {
10005       // We only use half of V2 so map the usage down into the final blend mask.
10006       V2Blend = UseLoV2 ? LoV2 : HiV2;
10007       for (int i = 0; i < SplitNumElements; ++i)
10008         if (BlendMask[i] >= SplitNumElements)
10009           BlendMask[i] = V2BlendMask[i] + (UseLoV2 ? SplitNumElements : 0);
10010     }
10011     return DAG.getVectorShuffle(SplitVT, DL, V1Blend, V2Blend, BlendMask);
10012   };
10013   SDValue Lo = HalfBlend(LoMask);
10014   SDValue Hi = HalfBlend(HiMask);
10015   return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
10016 }
10017
10018 /// \brief Either split a vector in halves or decompose the shuffles and the
10019 /// blend.
10020 ///
10021 /// This is provided as a good fallback for many lowerings of non-single-input
10022 /// shuffles with more than one 128-bit lane. In those cases, we want to select
10023 /// between splitting the shuffle into 128-bit components and stitching those
10024 /// back together vs. extracting the single-input shuffles and blending those
10025 /// results.
10026 static SDValue lowerVectorShuffleAsSplitOrBlend(SDLoc DL, MVT VT, SDValue V1,
10027                                                 SDValue V2, ArrayRef<int> Mask,
10028                                                 SelectionDAG &DAG) {
10029   assert(!isSingleInputShuffleMask(Mask) && "This routine must not be used to "
10030                                             "lower single-input shuffles as it "
10031                                             "could then recurse on itself.");
10032   int Size = Mask.size();
10033
10034   // If this can be modeled as a broadcast of two elements followed by a blend,
10035   // prefer that lowering. This is especially important because broadcasts can
10036   // often fold with memory operands.
10037   auto DoBothBroadcast = [&] {
10038     int V1BroadcastIdx = -1, V2BroadcastIdx = -1;
10039     for (int M : Mask)
10040       if (M >= Size) {
10041         if (V2BroadcastIdx == -1)
10042           V2BroadcastIdx = M - Size;
10043         else if (M - Size != V2BroadcastIdx)
10044           return false;
10045       } else if (M >= 0) {
10046         if (V1BroadcastIdx == -1)
10047           V1BroadcastIdx = M;
10048         else if (M != V1BroadcastIdx)
10049           return false;
10050       }
10051     return true;
10052   };
10053   if (DoBothBroadcast())
10054     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask,
10055                                                       DAG);
10056
10057   // If the inputs all stem from a single 128-bit lane of each input, then we
10058   // split them rather than blending because the split will decompose to
10059   // unusually few instructions.
10060   int LaneCount = VT.getSizeInBits() / 128;
10061   int LaneSize = Size / LaneCount;
10062   SmallBitVector LaneInputs[2];
10063   LaneInputs[0].resize(LaneCount, false);
10064   LaneInputs[1].resize(LaneCount, false);
10065   for (int i = 0; i < Size; ++i)
10066     if (Mask[i] >= 0)
10067       LaneInputs[Mask[i] / Size][(Mask[i] % Size) / LaneSize] = true;
10068   if (LaneInputs[0].count() <= 1 && LaneInputs[1].count() <= 1)
10069     return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10070
10071   // Otherwise, just fall back to decomposed shuffles and a blend. This requires
10072   // that the decomposed single-input shuffles don't end up here.
10073   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask, DAG);
10074 }
10075
10076 /// \brief Lower a vector shuffle crossing multiple 128-bit lanes as
10077 /// a permutation and blend of those lanes.
10078 ///
10079 /// This essentially blends the out-of-lane inputs to each lane into the lane
10080 /// from a permuted copy of the vector. This lowering strategy results in four
10081 /// instructions in the worst case for a single-input cross lane shuffle which
10082 /// is lower than any other fully general cross-lane shuffle strategy I'm aware
10083 /// of. Special cases for each particular shuffle pattern should be handled
10084 /// prior to trying this lowering.
10085 static SDValue lowerVectorShuffleAsLanePermuteAndBlend(SDLoc DL, MVT VT,
10086                                                        SDValue V1, SDValue V2,
10087                                                        ArrayRef<int> Mask,
10088                                                        SelectionDAG &DAG) {
10089   // FIXME: This should probably be generalized for 512-bit vectors as well.
10090   assert(VT.getSizeInBits() == 256 && "Only for 256-bit vector shuffles!");
10091   int LaneSize = Mask.size() / 2;
10092
10093   // If there are only inputs from one 128-bit lane, splitting will in fact be
10094   // less expensive. The flags track wether the given lane contains an element
10095   // that crosses to another lane.
10096   bool LaneCrossing[2] = {false, false};
10097   for (int i = 0, Size = Mask.size(); i < Size; ++i)
10098     if (Mask[i] >= 0 && (Mask[i] % Size) / LaneSize != i / LaneSize)
10099       LaneCrossing[(Mask[i] % Size) / LaneSize] = true;
10100   if (!LaneCrossing[0] || !LaneCrossing[1])
10101     return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10102
10103   if (isSingleInputShuffleMask(Mask)) {
10104     SmallVector<int, 32> FlippedBlendMask;
10105     for (int i = 0, Size = Mask.size(); i < Size; ++i)
10106       FlippedBlendMask.push_back(
10107           Mask[i] < 0 ? -1 : (((Mask[i] % Size) / LaneSize == i / LaneSize)
10108                                   ? Mask[i]
10109                                   : Mask[i] % LaneSize +
10110                                         (i / LaneSize) * LaneSize + Size));
10111
10112     // Flip the vector, and blend the results which should now be in-lane. The
10113     // VPERM2X128 mask uses the low 2 bits for the low source and bits 4 and
10114     // 5 for the high source. The value 3 selects the high half of source 2 and
10115     // the value 2 selects the low half of source 2. We only use source 2 to
10116     // allow folding it into a memory operand.
10117     unsigned PERMMask = 3 | 2 << 4;
10118     SDValue Flipped = DAG.getNode(X86ISD::VPERM2X128, DL, VT, DAG.getUNDEF(VT),
10119                                   V1, DAG.getConstant(PERMMask, MVT::i8));
10120     return DAG.getVectorShuffle(VT, DL, V1, Flipped, FlippedBlendMask);
10121   }
10122
10123   // This now reduces to two single-input shuffles of V1 and V2 which at worst
10124   // will be handled by the above logic and a blend of the results, much like
10125   // other patterns in AVX.
10126   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask, DAG);
10127 }
10128
10129 /// \brief Handle lowering 2-lane 128-bit shuffles.
10130 static SDValue lowerV2X128VectorShuffle(SDLoc DL, MVT VT, SDValue V1,
10131                                         SDValue V2, ArrayRef<int> Mask,
10132                                         const X86Subtarget *Subtarget,
10133                                         SelectionDAG &DAG) {
10134   // Blends are faster and handle all the non-lane-crossing cases.
10135   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, VT, V1, V2, Mask,
10136                                                 Subtarget, DAG))
10137     return Blend;
10138
10139   MVT SubVT = MVT::getVectorVT(VT.getVectorElementType(),
10140                                VT.getVectorNumElements() / 2);
10141   // Check for patterns which can be matched with a single insert of a 128-bit
10142   // subvector.
10143   if (isShuffleEquivalent(Mask, 0, 1, 0, 1) ||
10144       isShuffleEquivalent(Mask, 0, 1, 4, 5)) {
10145     SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
10146                               DAG.getIntPtrConstant(0));
10147     SDValue HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT,
10148                               Mask[2] < 4 ? V1 : V2, DAG.getIntPtrConstant(0));
10149     return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LoV, HiV);
10150   }
10151   if (isShuffleEquivalent(Mask, 0, 1, 6, 7)) {
10152     SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
10153                               DAG.getIntPtrConstant(0));
10154     SDValue HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V2,
10155                               DAG.getIntPtrConstant(2));
10156     return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LoV, HiV);
10157   }
10158
10159   // Otherwise form a 128-bit permutation.
10160   // FIXME: Detect zero-vector inputs and use the VPERM2X128 to zero that half.
10161   unsigned PermMask = Mask[0] / 2 | (Mask[2] / 2) << 4;
10162   return DAG.getNode(X86ISD::VPERM2X128, DL, VT, V1, V2,
10163                      DAG.getConstant(PermMask, MVT::i8));
10164 }
10165
10166 /// \brief Lower a vector shuffle by first fixing the 128-bit lanes and then
10167 /// shuffling each lane.
10168 ///
10169 /// This will only succeed when the result of fixing the 128-bit lanes results
10170 /// in a single-input non-lane-crossing shuffle with a repeating shuffle mask in
10171 /// each 128-bit lanes. This handles many cases where we can quickly blend away
10172 /// the lane crosses early and then use simpler shuffles within each lane.
10173 ///
10174 /// FIXME: It might be worthwhile at some point to support this without
10175 /// requiring the 128-bit lane-relative shuffles to be repeating, but currently
10176 /// in x86 only floating point has interesting non-repeating shuffles, and even
10177 /// those are still *marginally* more expensive.
10178 static SDValue lowerVectorShuffleByMerging128BitLanes(
10179     SDLoc DL, MVT VT, SDValue V1, SDValue V2, ArrayRef<int> Mask,
10180     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
10181   assert(!isSingleInputShuffleMask(Mask) &&
10182          "This is only useful with multiple inputs.");
10183
10184   int Size = Mask.size();
10185   int LaneSize = 128 / VT.getScalarSizeInBits();
10186   int NumLanes = Size / LaneSize;
10187   assert(NumLanes > 1 && "Only handles 256-bit and wider shuffles.");
10188
10189   // See if we can build a hypothetical 128-bit lane-fixing shuffle mask. Also
10190   // check whether the in-128-bit lane shuffles share a repeating pattern.
10191   SmallVector<int, 4> Lanes;
10192   Lanes.resize(NumLanes, -1);
10193   SmallVector<int, 4> InLaneMask;
10194   InLaneMask.resize(LaneSize, -1);
10195   for (int i = 0; i < Size; ++i) {
10196     if (Mask[i] < 0)
10197       continue;
10198
10199     int j = i / LaneSize;
10200
10201     if (Lanes[j] < 0) {
10202       // First entry we've seen for this lane.
10203       Lanes[j] = Mask[i] / LaneSize;
10204     } else if (Lanes[j] != Mask[i] / LaneSize) {
10205       // This doesn't match the lane selected previously!
10206       return SDValue();
10207     }
10208
10209     // Check that within each lane we have a consistent shuffle mask.
10210     int k = i % LaneSize;
10211     if (InLaneMask[k] < 0) {
10212       InLaneMask[k] = Mask[i] % LaneSize;
10213     } else if (InLaneMask[k] != Mask[i] % LaneSize) {
10214       // This doesn't fit a repeating in-lane mask.
10215       return SDValue();
10216     }
10217   }
10218
10219   // First shuffle the lanes into place.
10220   MVT LaneVT = MVT::getVectorVT(VT.isFloatingPoint() ? MVT::f64 : MVT::i64,
10221                                 VT.getSizeInBits() / 64);
10222   SmallVector<int, 8> LaneMask;
10223   LaneMask.resize(NumLanes * 2, -1);
10224   for (int i = 0; i < NumLanes; ++i)
10225     if (Lanes[i] >= 0) {
10226       LaneMask[2 * i + 0] = 2*Lanes[i] + 0;
10227       LaneMask[2 * i + 1] = 2*Lanes[i] + 1;
10228     }
10229
10230   V1 = DAG.getNode(ISD::BITCAST, DL, LaneVT, V1);
10231   V2 = DAG.getNode(ISD::BITCAST, DL, LaneVT, V2);
10232   SDValue LaneShuffle = DAG.getVectorShuffle(LaneVT, DL, V1, V2, LaneMask);
10233
10234   // Cast it back to the type we actually want.
10235   LaneShuffle = DAG.getNode(ISD::BITCAST, DL, VT, LaneShuffle);
10236
10237   // Now do a simple shuffle that isn't lane crossing.
10238   SmallVector<int, 8> NewMask;
10239   NewMask.resize(Size, -1);
10240   for (int i = 0; i < Size; ++i)
10241     if (Mask[i] >= 0)
10242       NewMask[i] = (i / LaneSize) * LaneSize + Mask[i] % LaneSize;
10243   assert(!is128BitLaneCrossingShuffleMask(VT, NewMask) &&
10244          "Must not introduce lane crosses at this point!");
10245
10246   return DAG.getVectorShuffle(VT, DL, LaneShuffle, DAG.getUNDEF(VT), NewMask);
10247 }
10248
10249 /// \brief Test whether the specified input (0 or 1) is in-place blended by the
10250 /// given mask.
10251 ///
10252 /// This returns true if the elements from a particular input are already in the
10253 /// slot required by the given mask and require no permutation.
10254 static bool isShuffleMaskInputInPlace(int Input, ArrayRef<int> Mask) {
10255   assert((Input == 0 || Input == 1) && "Only two inputs to shuffles.");
10256   int Size = Mask.size();
10257   for (int i = 0; i < Size; ++i)
10258     if (Mask[i] >= 0 && Mask[i] / Size == Input && Mask[i] % Size != i)
10259       return false;
10260
10261   return true;
10262 }
10263
10264 /// \brief Handle lowering of 4-lane 64-bit floating point shuffles.
10265 ///
10266 /// Also ends up handling lowering of 4-lane 64-bit integer shuffles when AVX2
10267 /// isn't available.
10268 static SDValue lowerV4F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10269                                        const X86Subtarget *Subtarget,
10270                                        SelectionDAG &DAG) {
10271   SDLoc DL(Op);
10272   assert(V1.getSimpleValueType() == MVT::v4f64 && "Bad operand type!");
10273   assert(V2.getSimpleValueType() == MVT::v4f64 && "Bad operand type!");
10274   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10275   ArrayRef<int> Mask = SVOp->getMask();
10276   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
10277
10278   SmallVector<int, 4> WidenedMask;
10279   if (canWidenShuffleElements(Mask, WidenedMask))
10280     return lowerV2X128VectorShuffle(DL, MVT::v4f64, V1, V2, Mask, Subtarget,
10281                                     DAG);
10282
10283   if (isSingleInputShuffleMask(Mask)) {
10284     // Check for being able to broadcast a single element.
10285     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4f64, DL, V1,
10286                                                           Mask, Subtarget, DAG))
10287       return Broadcast;
10288
10289     // Use low duplicate instructions for masks that match their pattern.
10290     if (isShuffleEquivalent(Mask, 0, 0, 2, 2))
10291       return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v4f64, V1);
10292
10293     if (!is128BitLaneCrossingShuffleMask(MVT::v4f64, Mask)) {
10294       // Non-half-crossing single input shuffles can be lowerid with an
10295       // interleaved permutation.
10296       unsigned VPERMILPMask = (Mask[0] == 1) | ((Mask[1] == 1) << 1) |
10297                               ((Mask[2] == 3) << 2) | ((Mask[3] == 3) << 3);
10298       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f64, V1,
10299                          DAG.getConstant(VPERMILPMask, MVT::i8));
10300     }
10301
10302     // With AVX2 we have direct support for this permutation.
10303     if (Subtarget->hasAVX2())
10304       return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4f64, V1,
10305                          getV4X86ShuffleImm8ForMask(Mask, DAG));
10306
10307     // Otherwise, fall back.
10308     return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v4f64, V1, V2, Mask,
10309                                                    DAG);
10310   }
10311
10312   // X86 has dedicated unpack instructions that can handle specific blend
10313   // operations: UNPCKH and UNPCKL.
10314   if (isShuffleEquivalent(Mask, 0, 4, 2, 6))
10315     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f64, V1, V2);
10316   if (isShuffleEquivalent(Mask, 1, 5, 3, 7))
10317     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f64, V1, V2);
10318
10319   // If we have a single input to the zero element, insert that into V1 if we
10320   // can do so cheaply.
10321   int NumV2Elements =
10322       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
10323   if (NumV2Elements == 1 && Mask[0] >= 4)
10324     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
10325             MVT::v4f64, DL, V1, V2, Mask, Subtarget, DAG))
10326       return Insertion;
10327
10328   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4f64, V1, V2, Mask,
10329                                                 Subtarget, DAG))
10330     return Blend;
10331
10332   // Check if the blend happens to exactly fit that of SHUFPD.
10333   if ((Mask[0] == -1 || Mask[0] < 2) &&
10334       (Mask[1] == -1 || (Mask[1] >= 4 && Mask[1] < 6)) &&
10335       (Mask[2] == -1 || (Mask[2] >= 2 && Mask[2] < 4)) &&
10336       (Mask[3] == -1 || Mask[3] >= 6)) {
10337     unsigned SHUFPDMask = (Mask[0] == 1) | ((Mask[1] == 5) << 1) |
10338                           ((Mask[2] == 3) << 2) | ((Mask[3] == 7) << 3);
10339     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f64, V1, V2,
10340                        DAG.getConstant(SHUFPDMask, MVT::i8));
10341   }
10342   if ((Mask[0] == -1 || (Mask[0] >= 4 && Mask[0] < 6)) &&
10343       (Mask[1] == -1 || Mask[1] < 2) &&
10344       (Mask[2] == -1 || Mask[2] >= 6) &&
10345       (Mask[3] == -1 || (Mask[3] >= 2 && Mask[3] < 4))) {
10346     unsigned SHUFPDMask = (Mask[0] == 5) | ((Mask[1] == 1) << 1) |
10347                           ((Mask[2] == 7) << 2) | ((Mask[3] == 3) << 3);
10348     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f64, V2, V1,
10349                        DAG.getConstant(SHUFPDMask, MVT::i8));
10350   }
10351
10352   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10353   // shuffle. However, if we have AVX2 and either inputs are already in place,
10354   // we will be able to shuffle even across lanes the other input in a single
10355   // instruction so skip this pattern.
10356   if (!(Subtarget->hasAVX2() && (isShuffleMaskInputInPlace(0, Mask) ||
10357                                  isShuffleMaskInputInPlace(1, Mask))))
10358     if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10359             DL, MVT::v4f64, V1, V2, Mask, Subtarget, DAG))
10360       return Result;
10361
10362   // If we have AVX2 then we always want to lower with a blend because an v4 we
10363   // can fully permute the elements.
10364   if (Subtarget->hasAVX2())
10365     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4f64, V1, V2,
10366                                                       Mask, DAG);
10367
10368   // Otherwise fall back on generic lowering.
10369   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v4f64, V1, V2, Mask, DAG);
10370 }
10371
10372 /// \brief Handle lowering of 4-lane 64-bit integer shuffles.
10373 ///
10374 /// This routine is only called when we have AVX2 and thus a reasonable
10375 /// instruction set for v4i64 shuffling..
10376 static SDValue lowerV4I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10377                                        const X86Subtarget *Subtarget,
10378                                        SelectionDAG &DAG) {
10379   SDLoc DL(Op);
10380   assert(V1.getSimpleValueType() == MVT::v4i64 && "Bad operand type!");
10381   assert(V2.getSimpleValueType() == MVT::v4i64 && "Bad operand type!");
10382   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10383   ArrayRef<int> Mask = SVOp->getMask();
10384   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
10385   assert(Subtarget->hasAVX2() && "We can only lower v4i64 with AVX2!");
10386
10387   SmallVector<int, 4> WidenedMask;
10388   if (canWidenShuffleElements(Mask, WidenedMask))
10389     return lowerV2X128VectorShuffle(DL, MVT::v4i64, V1, V2, Mask, Subtarget,
10390                                     DAG);
10391
10392   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4i64, V1, V2, Mask,
10393                                                 Subtarget, DAG))
10394     return Blend;
10395
10396   // Check for being able to broadcast a single element.
10397   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v4i64, DL, V1,
10398                                                         Mask, Subtarget, DAG))
10399     return Broadcast;
10400
10401   // When the shuffle is mirrored between the 128-bit lanes of the unit, we can
10402   // use lower latency instructions that will operate on both 128-bit lanes.
10403   SmallVector<int, 2> RepeatedMask;
10404   if (is128BitLaneRepeatedShuffleMask(MVT::v4i64, Mask, RepeatedMask)) {
10405     if (isSingleInputShuffleMask(Mask)) {
10406       int PSHUFDMask[] = {-1, -1, -1, -1};
10407       for (int i = 0; i < 2; ++i)
10408         if (RepeatedMask[i] >= 0) {
10409           PSHUFDMask[2 * i] = 2 * RepeatedMask[i];
10410           PSHUFDMask[2 * i + 1] = 2 * RepeatedMask[i] + 1;
10411         }
10412       return DAG.getNode(
10413           ISD::BITCAST, DL, MVT::v4i64,
10414           DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32,
10415                       DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, V1),
10416                       getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
10417     }
10418
10419     // Use dedicated unpack instructions for masks that match their pattern.
10420     if (isShuffleEquivalent(Mask, 0, 4, 2, 6))
10421       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i64, V1, V2);
10422     if (isShuffleEquivalent(Mask, 1, 5, 3, 7))
10423       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i64, V1, V2);
10424   }
10425
10426   // AVX2 provides a direct instruction for permuting a single input across
10427   // lanes.
10428   if (isSingleInputShuffleMask(Mask))
10429     return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4i64, V1,
10430                        getV4X86ShuffleImm8ForMask(Mask, DAG));
10431
10432   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10433   // shuffle. However, if we have AVX2 and either inputs are already in place,
10434   // we will be able to shuffle even across lanes the other input in a single
10435   // instruction so skip this pattern.
10436   if (!(Subtarget->hasAVX2() && (isShuffleMaskInputInPlace(0, Mask) ||
10437                                  isShuffleMaskInputInPlace(1, Mask))))
10438     if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10439             DL, MVT::v4i64, V1, V2, Mask, Subtarget, DAG))
10440       return Result;
10441
10442   // Otherwise fall back on generic blend lowering.
10443   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4i64, V1, V2,
10444                                                     Mask, DAG);
10445 }
10446
10447 /// \brief Handle lowering of 8-lane 32-bit floating point shuffles.
10448 ///
10449 /// Also ends up handling lowering of 8-lane 32-bit integer shuffles when AVX2
10450 /// isn't available.
10451 static SDValue lowerV8F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10452                                        const X86Subtarget *Subtarget,
10453                                        SelectionDAG &DAG) {
10454   SDLoc DL(Op);
10455   assert(V1.getSimpleValueType() == MVT::v8f32 && "Bad operand type!");
10456   assert(V2.getSimpleValueType() == MVT::v8f32 && "Bad operand type!");
10457   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10458   ArrayRef<int> Mask = SVOp->getMask();
10459   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
10460
10461   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8f32, V1, V2, Mask,
10462                                                 Subtarget, DAG))
10463     return Blend;
10464
10465   // Check for being able to broadcast a single element.
10466   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v8f32, DL, V1,
10467                                                         Mask, Subtarget, DAG))
10468     return Broadcast;
10469
10470   // If the shuffle mask is repeated in each 128-bit lane, we have many more
10471   // options to efficiently lower the shuffle.
10472   SmallVector<int, 4> RepeatedMask;
10473   if (is128BitLaneRepeatedShuffleMask(MVT::v8f32, Mask, RepeatedMask)) {
10474     assert(RepeatedMask.size() == 4 &&
10475            "Repeated masks must be half the mask width!");
10476
10477     // Use even/odd duplicate instructions for masks that match their pattern.
10478     if (isShuffleEquivalent(Mask, 0, 0, 2, 2, 4, 4, 6, 6))
10479       return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v8f32, V1);
10480     if (isShuffleEquivalent(Mask, 1, 1, 3, 3, 5, 5, 7, 7))
10481       return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v8f32, V1);
10482
10483     if (isSingleInputShuffleMask(Mask))
10484       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v8f32, V1,
10485                          getV4X86ShuffleImm8ForMask(RepeatedMask, DAG));
10486
10487     // Use dedicated unpack instructions for masks that match their pattern.
10488     if (isShuffleEquivalent(Mask, 0, 8, 1, 9, 4, 12, 5, 13))
10489       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f32, V1, V2);
10490     if (isShuffleEquivalent(Mask, 2, 10, 3, 11, 6, 14, 7, 15))
10491       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f32, V1, V2);
10492
10493     // Otherwise, fall back to a SHUFPS sequence. Here it is important that we
10494     // have already handled any direct blends. We also need to squash the
10495     // repeated mask into a simulated v4f32 mask.
10496     for (int i = 0; i < 4; ++i)
10497       if (RepeatedMask[i] >= 8)
10498         RepeatedMask[i] -= 4;
10499     return lowerVectorShuffleWithSHUFPS(DL, MVT::v8f32, RepeatedMask, V1, V2, DAG);
10500   }
10501
10502   // If we have a single input shuffle with different shuffle patterns in the
10503   // two 128-bit lanes use the variable mask to VPERMILPS.
10504   if (isSingleInputShuffleMask(Mask)) {
10505     SDValue VPermMask[8];
10506     for (int i = 0; i < 8; ++i)
10507       VPermMask[i] = Mask[i] < 0 ? DAG.getUNDEF(MVT::i32)
10508                                  : DAG.getConstant(Mask[i], MVT::i32);
10509     if (!is128BitLaneCrossingShuffleMask(MVT::v8f32, Mask))
10510       return DAG.getNode(
10511           X86ISD::VPERMILPV, DL, MVT::v8f32, V1,
10512           DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v8i32, VPermMask));
10513
10514     if (Subtarget->hasAVX2())
10515       return DAG.getNode(X86ISD::VPERMV, DL, MVT::v8f32,
10516                          DAG.getNode(ISD::BITCAST, DL, MVT::v8f32,
10517                                      DAG.getNode(ISD::BUILD_VECTOR, DL,
10518                                                  MVT::v8i32, VPermMask)),
10519                          V1);
10520
10521     // Otherwise, fall back.
10522     return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v8f32, V1, V2, Mask,
10523                                                    DAG);
10524   }
10525
10526   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10527   // shuffle.
10528   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10529           DL, MVT::v8f32, V1, V2, Mask, Subtarget, DAG))
10530     return Result;
10531
10532   // If we have AVX2 then we always want to lower with a blend because at v8 we
10533   // can fully permute the elements.
10534   if (Subtarget->hasAVX2())
10535     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8f32, V1, V2,
10536                                                       Mask, DAG);
10537
10538   // Otherwise fall back on generic lowering.
10539   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v8f32, V1, V2, Mask, DAG);
10540 }
10541
10542 /// \brief Handle lowering of 8-lane 32-bit integer shuffles.
10543 ///
10544 /// This routine is only called when we have AVX2 and thus a reasonable
10545 /// instruction set for v8i32 shuffling..
10546 static SDValue lowerV8I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10547                                        const X86Subtarget *Subtarget,
10548                                        SelectionDAG &DAG) {
10549   SDLoc DL(Op);
10550   assert(V1.getSimpleValueType() == MVT::v8i32 && "Bad operand type!");
10551   assert(V2.getSimpleValueType() == MVT::v8i32 && "Bad operand type!");
10552   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10553   ArrayRef<int> Mask = SVOp->getMask();
10554   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
10555   assert(Subtarget->hasAVX2() && "We can only lower v8i32 with AVX2!");
10556
10557   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8i32, V1, V2, Mask,
10558                                                 Subtarget, DAG))
10559     return Blend;
10560
10561   // Check for being able to broadcast a single element.
10562   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v8i32, DL, V1,
10563                                                         Mask, Subtarget, DAG))
10564     return Broadcast;
10565
10566   // If the shuffle mask is repeated in each 128-bit lane we can use more
10567   // efficient instructions that mirror the shuffles across the two 128-bit
10568   // lanes.
10569   SmallVector<int, 4> RepeatedMask;
10570   if (is128BitLaneRepeatedShuffleMask(MVT::v8i32, Mask, RepeatedMask)) {
10571     assert(RepeatedMask.size() == 4 && "Unexpected repeated mask size!");
10572     if (isSingleInputShuffleMask(Mask))
10573       return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32, V1,
10574                          getV4X86ShuffleImm8ForMask(RepeatedMask, DAG));
10575
10576     // Use dedicated unpack instructions for masks that match their pattern.
10577     if (isShuffleEquivalent(Mask, 0, 8, 1, 9, 4, 12, 5, 13))
10578       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i32, V1, V2);
10579     if (isShuffleEquivalent(Mask, 2, 10, 3, 11, 6, 14, 7, 15))
10580       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i32, V1, V2);
10581   }
10582
10583   // If the shuffle patterns aren't repeated but it is a single input, directly
10584   // generate a cross-lane VPERMD instruction.
10585   if (isSingleInputShuffleMask(Mask)) {
10586     SDValue VPermMask[8];
10587     for (int i = 0; i < 8; ++i)
10588       VPermMask[i] = Mask[i] < 0 ? DAG.getUNDEF(MVT::i32)
10589                                  : DAG.getConstant(Mask[i], MVT::i32);
10590     return DAG.getNode(
10591         X86ISD::VPERMV, DL, MVT::v8i32,
10592         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v8i32, VPermMask), V1);
10593   }
10594
10595   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10596   // shuffle.
10597   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10598           DL, MVT::v8i32, V1, V2, Mask, Subtarget, DAG))
10599     return Result;
10600
10601   // Otherwise fall back on generic blend lowering.
10602   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8i32, V1, V2,
10603                                                     Mask, DAG);
10604 }
10605
10606 /// \brief Handle lowering of 16-lane 16-bit integer shuffles.
10607 ///
10608 /// This routine is only called when we have AVX2 and thus a reasonable
10609 /// instruction set for v16i16 shuffling..
10610 static SDValue lowerV16I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10611                                         const X86Subtarget *Subtarget,
10612                                         SelectionDAG &DAG) {
10613   SDLoc DL(Op);
10614   assert(V1.getSimpleValueType() == MVT::v16i16 && "Bad operand type!");
10615   assert(V2.getSimpleValueType() == MVT::v16i16 && "Bad operand type!");
10616   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10617   ArrayRef<int> Mask = SVOp->getMask();
10618   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
10619   assert(Subtarget->hasAVX2() && "We can only lower v16i16 with AVX2!");
10620
10621   // Check for being able to broadcast a single element.
10622   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v16i16, DL, V1,
10623                                                         Mask, Subtarget, DAG))
10624     return Broadcast;
10625
10626   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v16i16, V1, V2, Mask,
10627                                                 Subtarget, DAG))
10628     return Blend;
10629
10630   // Use dedicated unpack instructions for masks that match their pattern.
10631   if (isShuffleEquivalent(Mask,
10632                           // First 128-bit lane:
10633                           0, 16, 1, 17, 2, 18, 3, 19,
10634                           // Second 128-bit lane:
10635                           8, 24, 9, 25, 10, 26, 11, 27))
10636     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i16, V1, V2);
10637   if (isShuffleEquivalent(Mask,
10638                           // First 128-bit lane:
10639                           4, 20, 5, 21, 6, 22, 7, 23,
10640                           // Second 128-bit lane:
10641                           12, 28, 13, 29, 14, 30, 15, 31))
10642     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i16, V1, V2);
10643
10644   if (isSingleInputShuffleMask(Mask)) {
10645     // There are no generalized cross-lane shuffle operations available on i16
10646     // element types.
10647     if (is128BitLaneCrossingShuffleMask(MVT::v16i16, Mask))
10648       return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v16i16, V1, V2,
10649                                                      Mask, DAG);
10650
10651     SDValue PSHUFBMask[32];
10652     for (int i = 0; i < 16; ++i) {
10653       if (Mask[i] == -1) {
10654         PSHUFBMask[2 * i] = PSHUFBMask[2 * i + 1] = DAG.getUNDEF(MVT::i8);
10655         continue;
10656       }
10657
10658       int M = i < 8 ? Mask[i] : Mask[i] - 8;
10659       assert(M >= 0 && M < 8 && "Invalid single-input mask!");
10660       PSHUFBMask[2 * i] = DAG.getConstant(2 * M, MVT::i8);
10661       PSHUFBMask[2 * i + 1] = DAG.getConstant(2 * M + 1, MVT::i8);
10662     }
10663     return DAG.getNode(
10664         ISD::BITCAST, DL, MVT::v16i16,
10665         DAG.getNode(
10666             X86ISD::PSHUFB, DL, MVT::v32i8,
10667             DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, V1),
10668             DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, PSHUFBMask)));
10669   }
10670
10671   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10672   // shuffle.
10673   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10674           DL, MVT::v16i16, V1, V2, Mask, Subtarget, DAG))
10675     return Result;
10676
10677   // Otherwise fall back on generic lowering.
10678   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v16i16, V1, V2, Mask, DAG);
10679 }
10680
10681 /// \brief Handle lowering of 32-lane 8-bit integer shuffles.
10682 ///
10683 /// This routine is only called when we have AVX2 and thus a reasonable
10684 /// instruction set for v32i8 shuffling..
10685 static SDValue lowerV32I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10686                                        const X86Subtarget *Subtarget,
10687                                        SelectionDAG &DAG) {
10688   SDLoc DL(Op);
10689   assert(V1.getSimpleValueType() == MVT::v32i8 && "Bad operand type!");
10690   assert(V2.getSimpleValueType() == MVT::v32i8 && "Bad operand type!");
10691   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10692   ArrayRef<int> Mask = SVOp->getMask();
10693   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
10694   assert(Subtarget->hasAVX2() && "We can only lower v32i8 with AVX2!");
10695
10696   // Check for being able to broadcast a single element.
10697   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(MVT::v32i8, DL, V1,
10698                                                         Mask, Subtarget, DAG))
10699     return Broadcast;
10700
10701   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v32i8, V1, V2, Mask,
10702                                                 Subtarget, DAG))
10703     return Blend;
10704
10705   // Use dedicated unpack instructions for masks that match their pattern.
10706   // Note that these are repeated 128-bit lane unpacks, not unpacks across all
10707   // 256-bit lanes.
10708   if (isShuffleEquivalent(
10709           Mask,
10710           // First 128-bit lane:
10711           0, 32, 1, 33, 2, 34, 3, 35, 4, 36, 5, 37, 6, 38, 7, 39,
10712           // Second 128-bit lane:
10713           16, 48, 17, 49, 18, 50, 19, 51, 20, 52, 21, 53, 22, 54, 23, 55))
10714     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v32i8, V1, V2);
10715   if (isShuffleEquivalent(
10716           Mask,
10717           // First 128-bit lane:
10718           8, 40, 9, 41, 10, 42, 11, 43, 12, 44, 13, 45, 14, 46, 15, 47,
10719           // Second 128-bit lane:
10720           24, 56, 25, 57, 26, 58, 27, 59, 28, 60, 29, 61, 30, 62, 31, 63))
10721     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v32i8, V1, V2);
10722
10723   if (isSingleInputShuffleMask(Mask)) {
10724     // There are no generalized cross-lane shuffle operations available on i8
10725     // element types.
10726     if (is128BitLaneCrossingShuffleMask(MVT::v32i8, Mask))
10727       return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v32i8, V1, V2,
10728                                                      Mask, DAG);
10729
10730     SDValue PSHUFBMask[32];
10731     for (int i = 0; i < 32; ++i)
10732       PSHUFBMask[i] =
10733           Mask[i] < 0
10734               ? DAG.getUNDEF(MVT::i8)
10735               : DAG.getConstant(Mask[i] < 16 ? Mask[i] : Mask[i] - 16, MVT::i8);
10736
10737     return DAG.getNode(
10738         X86ISD::PSHUFB, DL, MVT::v32i8, V1,
10739         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, PSHUFBMask));
10740   }
10741
10742   // Try to simplify this by merging 128-bit lanes to enable a lane-based
10743   // shuffle.
10744   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
10745           DL, MVT::v32i8, V1, V2, Mask, Subtarget, DAG))
10746     return Result;
10747
10748   // Otherwise fall back on generic lowering.
10749   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v32i8, V1, V2, Mask, DAG);
10750 }
10751
10752 /// \brief High-level routine to lower various 256-bit x86 vector shuffles.
10753 ///
10754 /// This routine either breaks down the specific type of a 256-bit x86 vector
10755 /// shuffle or splits it into two 128-bit shuffles and fuses the results back
10756 /// together based on the available instructions.
10757 static SDValue lower256BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10758                                         MVT VT, const X86Subtarget *Subtarget,
10759                                         SelectionDAG &DAG) {
10760   SDLoc DL(Op);
10761   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10762   ArrayRef<int> Mask = SVOp->getMask();
10763
10764   // There is a really nice hard cut-over between AVX1 and AVX2 that means we can
10765   // check for those subtargets here and avoid much of the subtarget querying in
10766   // the per-vector-type lowering routines. With AVX1 we have essentially *zero*
10767   // ability to manipulate a 256-bit vector with integer types. Since we'll use
10768   // floating point types there eventually, just immediately cast everything to
10769   // a float and operate entirely in that domain.
10770   if (VT.isInteger() && !Subtarget->hasAVX2()) {
10771     int ElementBits = VT.getScalarSizeInBits();
10772     if (ElementBits < 32)
10773       // No floating point type available, decompose into 128-bit vectors.
10774       return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10775
10776     MVT FpVT = MVT::getVectorVT(MVT::getFloatingPointVT(ElementBits),
10777                                 VT.getVectorNumElements());
10778     V1 = DAG.getNode(ISD::BITCAST, DL, FpVT, V1);
10779     V2 = DAG.getNode(ISD::BITCAST, DL, FpVT, V2);
10780     return DAG.getNode(ISD::BITCAST, DL, VT,
10781                        DAG.getVectorShuffle(FpVT, DL, V1, V2, Mask));
10782   }
10783
10784   switch (VT.SimpleTy) {
10785   case MVT::v4f64:
10786     return lowerV4F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10787   case MVT::v4i64:
10788     return lowerV4I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10789   case MVT::v8f32:
10790     return lowerV8F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10791   case MVT::v8i32:
10792     return lowerV8I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10793   case MVT::v16i16:
10794     return lowerV16I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
10795   case MVT::v32i8:
10796     return lowerV32I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
10797
10798   default:
10799     llvm_unreachable("Not a valid 256-bit x86 vector type!");
10800   }
10801 }
10802
10803 /// \brief Handle lowering of 8-lane 64-bit floating point shuffles.
10804 static SDValue lowerV8F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10805                                        const X86Subtarget *Subtarget,
10806                                        SelectionDAG &DAG) {
10807   SDLoc DL(Op);
10808   assert(V1.getSimpleValueType() == MVT::v8f64 && "Bad operand type!");
10809   assert(V2.getSimpleValueType() == MVT::v8f64 && "Bad operand type!");
10810   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10811   ArrayRef<int> Mask = SVOp->getMask();
10812   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
10813
10814   // X86 has dedicated unpack instructions that can handle specific blend
10815   // operations: UNPCKH and UNPCKL.
10816   if (isShuffleEquivalent(Mask, 0, 8, 2, 10, 4, 12, 6, 14))
10817     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f64, V1, V2);
10818   if (isShuffleEquivalent(Mask, 1, 9, 3, 11, 5, 13, 7, 15))
10819     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f64, V1, V2);
10820
10821   // FIXME: Implement direct support for this type!
10822   return splitAndLowerVectorShuffle(DL, MVT::v8f64, V1, V2, Mask, DAG);
10823 }
10824
10825 /// \brief Handle lowering of 16-lane 32-bit floating point shuffles.
10826 static SDValue lowerV16F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10827                                        const X86Subtarget *Subtarget,
10828                                        SelectionDAG &DAG) {
10829   SDLoc DL(Op);
10830   assert(V1.getSimpleValueType() == MVT::v16f32 && "Bad operand type!");
10831   assert(V2.getSimpleValueType() == MVT::v16f32 && "Bad operand type!");
10832   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10833   ArrayRef<int> Mask = SVOp->getMask();
10834   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
10835
10836   // Use dedicated unpack instructions for masks that match their pattern.
10837   if (isShuffleEquivalent(Mask,
10838                           0, 16, 1, 17, 4, 20, 5, 21,
10839                           8, 24, 9, 25, 12, 28, 13, 29))
10840     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16f32, V1, V2);
10841   if (isShuffleEquivalent(Mask,
10842                           2, 18, 3, 19, 6, 22, 7, 23,
10843                           10, 26, 11, 27, 14, 30, 15, 31))
10844     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16f32, V1, V2);
10845
10846   // FIXME: Implement direct support for this type!
10847   return splitAndLowerVectorShuffle(DL, MVT::v16f32, V1, V2, Mask, DAG);
10848 }
10849
10850 /// \brief Handle lowering of 8-lane 64-bit integer shuffles.
10851 static SDValue lowerV8I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10852                                        const X86Subtarget *Subtarget,
10853                                        SelectionDAG &DAG) {
10854   SDLoc DL(Op);
10855   assert(V1.getSimpleValueType() == MVT::v8i64 && "Bad operand type!");
10856   assert(V2.getSimpleValueType() == MVT::v8i64 && "Bad operand type!");
10857   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10858   ArrayRef<int> Mask = SVOp->getMask();
10859   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
10860
10861   // X86 has dedicated unpack instructions that can handle specific blend
10862   // operations: UNPCKH and UNPCKL.
10863   if (isShuffleEquivalent(Mask, 0, 8, 2, 10, 4, 12, 6, 14))
10864     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i64, V1, V2);
10865   if (isShuffleEquivalent(Mask, 1, 9, 3, 11, 5, 13, 7, 15))
10866     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i64, V1, V2);
10867
10868   // FIXME: Implement direct support for this type!
10869   return splitAndLowerVectorShuffle(DL, MVT::v8i64, V1, V2, Mask, DAG);
10870 }
10871
10872 /// \brief Handle lowering of 16-lane 32-bit integer shuffles.
10873 static SDValue lowerV16I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10874                                        const X86Subtarget *Subtarget,
10875                                        SelectionDAG &DAG) {
10876   SDLoc DL(Op);
10877   assert(V1.getSimpleValueType() == MVT::v16i32 && "Bad operand type!");
10878   assert(V2.getSimpleValueType() == MVT::v16i32 && "Bad operand type!");
10879   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10880   ArrayRef<int> Mask = SVOp->getMask();
10881   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
10882
10883   // Use dedicated unpack instructions for masks that match their pattern.
10884   if (isShuffleEquivalent(Mask,
10885                           0, 16, 1, 17, 4, 20, 5, 21,
10886                           8, 24, 9, 25, 12, 28, 13, 29))
10887     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i32, V1, V2);
10888   if (isShuffleEquivalent(Mask,
10889                           2, 18, 3, 19, 6, 22, 7, 23,
10890                           10, 26, 11, 27, 14, 30, 15, 31))
10891     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i32, V1, V2);
10892
10893   // FIXME: Implement direct support for this type!
10894   return splitAndLowerVectorShuffle(DL, MVT::v16i32, V1, V2, Mask, DAG);
10895 }
10896
10897 /// \brief Handle lowering of 32-lane 16-bit integer shuffles.
10898 static SDValue lowerV32I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10899                                         const X86Subtarget *Subtarget,
10900                                         SelectionDAG &DAG) {
10901   SDLoc DL(Op);
10902   assert(V1.getSimpleValueType() == MVT::v32i16 && "Bad operand type!");
10903   assert(V2.getSimpleValueType() == MVT::v32i16 && "Bad operand type!");
10904   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10905   ArrayRef<int> Mask = SVOp->getMask();
10906   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
10907   assert(Subtarget->hasBWI() && "We can only lower v32i16 with AVX-512-BWI!");
10908
10909   // FIXME: Implement direct support for this type!
10910   return splitAndLowerVectorShuffle(DL, MVT::v32i16, V1, V2, Mask, DAG);
10911 }
10912
10913 /// \brief Handle lowering of 64-lane 8-bit integer shuffles.
10914 static SDValue lowerV64I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10915                                        const X86Subtarget *Subtarget,
10916                                        SelectionDAG &DAG) {
10917   SDLoc DL(Op);
10918   assert(V1.getSimpleValueType() == MVT::v64i8 && "Bad operand type!");
10919   assert(V2.getSimpleValueType() == MVT::v64i8 && "Bad operand type!");
10920   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10921   ArrayRef<int> Mask = SVOp->getMask();
10922   assert(Mask.size() == 64 && "Unexpected mask size for v64 shuffle!");
10923   assert(Subtarget->hasBWI() && "We can only lower v64i8 with AVX-512-BWI!");
10924
10925   // FIXME: Implement direct support for this type!
10926   return splitAndLowerVectorShuffle(DL, MVT::v64i8, V1, V2, Mask, DAG);
10927 }
10928
10929 /// \brief High-level routine to lower various 512-bit x86 vector shuffles.
10930 ///
10931 /// This routine either breaks down the specific type of a 512-bit x86 vector
10932 /// shuffle or splits it into two 256-bit shuffles and fuses the results back
10933 /// together based on the available instructions.
10934 static SDValue lower512BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10935                                         MVT VT, const X86Subtarget *Subtarget,
10936                                         SelectionDAG &DAG) {
10937   SDLoc DL(Op);
10938   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10939   ArrayRef<int> Mask = SVOp->getMask();
10940   assert(Subtarget->hasAVX512() &&
10941          "Cannot lower 512-bit vectors w/ basic ISA!");
10942
10943   // Check for being able to broadcast a single element.
10944   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(VT.SimpleTy, DL, V1,
10945                                                         Mask, Subtarget, DAG))
10946     return Broadcast;
10947
10948   // Dispatch to each element type for lowering. If we don't have supprot for
10949   // specific element type shuffles at 512 bits, immediately split them and
10950   // lower them. Each lowering routine of a given type is allowed to assume that
10951   // the requisite ISA extensions for that element type are available.
10952   switch (VT.SimpleTy) {
10953   case MVT::v8f64:
10954     return lowerV8F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10955   case MVT::v16f32:
10956     return lowerV16F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10957   case MVT::v8i64:
10958     return lowerV8I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10959   case MVT::v16i32:
10960     return lowerV16I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10961   case MVT::v32i16:
10962     if (Subtarget->hasBWI())
10963       return lowerV32I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
10964     break;
10965   case MVT::v64i8:
10966     if (Subtarget->hasBWI())
10967       return lowerV64I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
10968     break;
10969
10970   default:
10971     llvm_unreachable("Not a valid 512-bit x86 vector type!");
10972   }
10973
10974   // Otherwise fall back on splitting.
10975   return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10976 }
10977
10978 /// \brief Top-level lowering for x86 vector shuffles.
10979 ///
10980 /// This handles decomposition, canonicalization, and lowering of all x86
10981 /// vector shuffles. Most of the specific lowering strategies are encapsulated
10982 /// above in helper routines. The canonicalization attempts to widen shuffles
10983 /// to involve fewer lanes of wider elements, consolidate symmetric patterns
10984 /// s.t. only one of the two inputs needs to be tested, etc.
10985 static SDValue lowerVectorShuffle(SDValue Op, const X86Subtarget *Subtarget,
10986                                   SelectionDAG &DAG) {
10987   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10988   ArrayRef<int> Mask = SVOp->getMask();
10989   SDValue V1 = Op.getOperand(0);
10990   SDValue V2 = Op.getOperand(1);
10991   MVT VT = Op.getSimpleValueType();
10992   int NumElements = VT.getVectorNumElements();
10993   SDLoc dl(Op);
10994
10995   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
10996
10997   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
10998   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
10999   if (V1IsUndef && V2IsUndef)
11000     return DAG.getUNDEF(VT);
11001
11002   // When we create a shuffle node we put the UNDEF node to second operand,
11003   // but in some cases the first operand may be transformed to UNDEF.
11004   // In this case we should just commute the node.
11005   if (V1IsUndef)
11006     return DAG.getCommutedVectorShuffle(*SVOp);
11007
11008   // Check for non-undef masks pointing at an undef vector and make the masks
11009   // undef as well. This makes it easier to match the shuffle based solely on
11010   // the mask.
11011   if (V2IsUndef)
11012     for (int M : Mask)
11013       if (M >= NumElements) {
11014         SmallVector<int, 8> NewMask(Mask.begin(), Mask.end());
11015         for (int &M : NewMask)
11016           if (M >= NumElements)
11017             M = -1;
11018         return DAG.getVectorShuffle(VT, dl, V1, V2, NewMask);
11019       }
11020
11021   // Try to collapse shuffles into using a vector type with fewer elements but
11022   // wider element types. We cap this to not form integers or floating point
11023   // elements wider than 64 bits, but it might be interesting to form i128
11024   // integers to handle flipping the low and high halves of AVX 256-bit vectors.
11025   SmallVector<int, 16> WidenedMask;
11026   if (VT.getScalarSizeInBits() < 64 &&
11027       canWidenShuffleElements(Mask, WidenedMask)) {
11028     MVT NewEltVT = VT.isFloatingPoint()
11029                        ? MVT::getFloatingPointVT(VT.getScalarSizeInBits() * 2)
11030                        : MVT::getIntegerVT(VT.getScalarSizeInBits() * 2);
11031     MVT NewVT = MVT::getVectorVT(NewEltVT, VT.getVectorNumElements() / 2);
11032     // Make sure that the new vector type is legal. For example, v2f64 isn't
11033     // legal on SSE1.
11034     if (DAG.getTargetLoweringInfo().isTypeLegal(NewVT)) {
11035       V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, V1);
11036       V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, V2);
11037       return DAG.getNode(ISD::BITCAST, dl, VT,
11038                          DAG.getVectorShuffle(NewVT, dl, V1, V2, WidenedMask));
11039     }
11040   }
11041
11042   int NumV1Elements = 0, NumUndefElements = 0, NumV2Elements = 0;
11043   for (int M : SVOp->getMask())
11044     if (M < 0)
11045       ++NumUndefElements;
11046     else if (M < NumElements)
11047       ++NumV1Elements;
11048     else
11049       ++NumV2Elements;
11050
11051   // Commute the shuffle as needed such that more elements come from V1 than
11052   // V2. This allows us to match the shuffle pattern strictly on how many
11053   // elements come from V1 without handling the symmetric cases.
11054   if (NumV2Elements > NumV1Elements)
11055     return DAG.getCommutedVectorShuffle(*SVOp);
11056
11057   // When the number of V1 and V2 elements are the same, try to minimize the
11058   // number of uses of V2 in the low half of the vector. When that is tied,
11059   // ensure that the sum of indices for V1 is equal to or lower than the sum
11060   // indices for V2. When those are equal, try to ensure that the number of odd
11061   // indices for V1 is lower than the number of odd indices for V2.
11062   if (NumV1Elements == NumV2Elements) {
11063     int LowV1Elements = 0, LowV2Elements = 0;
11064     for (int M : SVOp->getMask().slice(0, NumElements / 2))
11065       if (M >= NumElements)
11066         ++LowV2Elements;
11067       else if (M >= 0)
11068         ++LowV1Elements;
11069     if (LowV2Elements > LowV1Elements) {
11070       return DAG.getCommutedVectorShuffle(*SVOp);
11071     } else if (LowV2Elements == LowV1Elements) {
11072       int SumV1Indices = 0, SumV2Indices = 0;
11073       for (int i = 0, Size = SVOp->getMask().size(); i < Size; ++i)
11074         if (SVOp->getMask()[i] >= NumElements)
11075           SumV2Indices += i;
11076         else if (SVOp->getMask()[i] >= 0)
11077           SumV1Indices += i;
11078       if (SumV2Indices < SumV1Indices) {
11079         return DAG.getCommutedVectorShuffle(*SVOp);
11080       } else if (SumV2Indices == SumV1Indices) {
11081         int NumV1OddIndices = 0, NumV2OddIndices = 0;
11082         for (int i = 0, Size = SVOp->getMask().size(); i < Size; ++i)
11083           if (SVOp->getMask()[i] >= NumElements)
11084             NumV2OddIndices += i % 2;
11085           else if (SVOp->getMask()[i] >= 0)
11086             NumV1OddIndices += i % 2;
11087         if (NumV2OddIndices < NumV1OddIndices)
11088           return DAG.getCommutedVectorShuffle(*SVOp);
11089       }
11090     }
11091   }
11092
11093   // For each vector width, delegate to a specialized lowering routine.
11094   if (VT.getSizeInBits() == 128)
11095     return lower128BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11096
11097   if (VT.getSizeInBits() == 256)
11098     return lower256BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11099
11100   // Force AVX-512 vectors to be scalarized for now.
11101   // FIXME: Implement AVX-512 support!
11102   if (VT.getSizeInBits() == 512)
11103     return lower512BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
11104
11105   llvm_unreachable("Unimplemented!");
11106 }
11107
11108
11109 //===----------------------------------------------------------------------===//
11110 // Legacy vector shuffle lowering
11111 //
11112 // This code is the legacy code handling vector shuffles until the above
11113 // replaces its functionality and performance.
11114 //===----------------------------------------------------------------------===//
11115
11116 static bool isBlendMask(ArrayRef<int> MaskVals, MVT VT, bool hasSSE41,
11117                         bool hasInt256, unsigned *MaskOut = nullptr) {
11118   MVT EltVT = VT.getVectorElementType();
11119
11120   // There is no blend with immediate in AVX-512.
11121   if (VT.is512BitVector())
11122     return false;
11123
11124   if (!hasSSE41 || EltVT == MVT::i8)
11125     return false;
11126   if (!hasInt256 && VT == MVT::v16i16)
11127     return false;
11128
11129   unsigned MaskValue = 0;
11130   unsigned NumElems = VT.getVectorNumElements();
11131   // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
11132   unsigned NumLanes = (NumElems - 1) / 8 + 1;
11133   unsigned NumElemsInLane = NumElems / NumLanes;
11134
11135   // Blend for v16i16 should be symetric for the both lanes.
11136   for (unsigned i = 0; i < NumElemsInLane; ++i) {
11137
11138     int SndLaneEltIdx = (NumLanes == 2) ? MaskVals[i + NumElemsInLane] : -1;
11139     int EltIdx = MaskVals[i];
11140
11141     if ((EltIdx < 0 || EltIdx == (int)i) &&
11142         (SndLaneEltIdx < 0 || SndLaneEltIdx == (int)(i + NumElemsInLane)))
11143       continue;
11144
11145     if (((unsigned)EltIdx == (i + NumElems)) &&
11146         (SndLaneEltIdx < 0 ||
11147          (unsigned)SndLaneEltIdx == i + NumElems + NumElemsInLane))
11148       MaskValue |= (1 << i);
11149     else
11150       return false;
11151   }
11152
11153   if (MaskOut)
11154     *MaskOut = MaskValue;
11155   return true;
11156 }
11157
11158 // Try to lower a shuffle node into a simple blend instruction.
11159 // This function assumes isBlendMask returns true for this
11160 // SuffleVectorSDNode
11161 static SDValue LowerVECTOR_SHUFFLEtoBlend(ShuffleVectorSDNode *SVOp,
11162                                           unsigned MaskValue,
11163                                           const X86Subtarget *Subtarget,
11164                                           SelectionDAG &DAG) {
11165   MVT VT = SVOp->getSimpleValueType(0);
11166   MVT EltVT = VT.getVectorElementType();
11167   assert(isBlendMask(SVOp->getMask(), VT, Subtarget->hasSSE41(),
11168                      Subtarget->hasInt256() && "Trying to lower a "
11169                                                "VECTOR_SHUFFLE to a Blend but "
11170                                                "with the wrong mask"));
11171   SDValue V1 = SVOp->getOperand(0);
11172   SDValue V2 = SVOp->getOperand(1);
11173   SDLoc dl(SVOp);
11174   unsigned NumElems = VT.getVectorNumElements();
11175
11176   // Convert i32 vectors to floating point if it is not AVX2.
11177   // AVX2 introduced VPBLENDD instruction for 128 and 256-bit vectors.
11178   MVT BlendVT = VT;
11179   if (EltVT == MVT::i64 || (EltVT == MVT::i32 && !Subtarget->hasInt256())) {
11180     BlendVT = MVT::getVectorVT(MVT::getFloatingPointVT(EltVT.getSizeInBits()),
11181                                NumElems);
11182     V1 = DAG.getNode(ISD::BITCAST, dl, VT, V1);
11183     V2 = DAG.getNode(ISD::BITCAST, dl, VT, V2);
11184   }
11185
11186   SDValue Ret = DAG.getNode(X86ISD::BLENDI, dl, BlendVT, V1, V2,
11187                             DAG.getConstant(MaskValue, MVT::i32));
11188   return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
11189 }
11190
11191 /// In vector type \p VT, return true if the element at index \p InputIdx
11192 /// falls on a different 128-bit lane than \p OutputIdx.
11193 static bool ShuffleCrosses128bitLane(MVT VT, unsigned InputIdx,
11194                                      unsigned OutputIdx) {
11195   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
11196   return InputIdx * EltSize / 128 != OutputIdx * EltSize / 128;
11197 }
11198
11199 /// Generate a PSHUFB if possible.  Selects elements from \p V1 according to
11200 /// \p MaskVals.  MaskVals[OutputIdx] = InputIdx specifies that we want to
11201 /// shuffle the element at InputIdx in V1 to OutputIdx in the result.  If \p
11202 /// MaskVals refers to elements outside of \p V1 or is undef (-1), insert a
11203 /// zero.
11204 static SDValue getPSHUFB(ArrayRef<int> MaskVals, SDValue V1, SDLoc &dl,
11205                          SelectionDAG &DAG) {
11206   MVT VT = V1.getSimpleValueType();
11207   assert(VT.is128BitVector() || VT.is256BitVector());
11208
11209   MVT EltVT = VT.getVectorElementType();
11210   unsigned EltSizeInBytes = EltVT.getSizeInBits() / 8;
11211   unsigned NumElts = VT.getVectorNumElements();
11212
11213   SmallVector<SDValue, 32> PshufbMask;
11214   for (unsigned OutputIdx = 0; OutputIdx < NumElts; ++OutputIdx) {
11215     int InputIdx = MaskVals[OutputIdx];
11216     unsigned InputByteIdx;
11217
11218     if (InputIdx < 0 || NumElts <= (unsigned)InputIdx)
11219       InputByteIdx = 0x80;
11220     else {
11221       // Cross lane is not allowed.
11222       if (ShuffleCrosses128bitLane(VT, InputIdx, OutputIdx))
11223         return SDValue();
11224       InputByteIdx = InputIdx * EltSizeInBytes;
11225       // Index is an byte offset within the 128-bit lane.
11226       InputByteIdx &= 0xf;
11227     }
11228
11229     for (unsigned j = 0; j < EltSizeInBytes; ++j) {
11230       PshufbMask.push_back(DAG.getConstant(InputByteIdx, MVT::i8));
11231       if (InputByteIdx != 0x80)
11232         ++InputByteIdx;
11233     }
11234   }
11235
11236   MVT ShufVT = MVT::getVectorVT(MVT::i8, PshufbMask.size());
11237   if (ShufVT != VT)
11238     V1 = DAG.getNode(ISD::BITCAST, dl, ShufVT, V1);
11239   return DAG.getNode(X86ISD::PSHUFB, dl, ShufVT, V1,
11240                      DAG.getNode(ISD::BUILD_VECTOR, dl, ShufVT, PshufbMask));
11241 }
11242
11243 // v8i16 shuffles - Prefer shuffles in the following order:
11244 // 1. [all]   pshuflw, pshufhw, optional move
11245 // 2. [ssse3] 1 x pshufb
11246 // 3. [ssse3] 2 x pshufb + 1 x por
11247 // 4. [all]   mov + pshuflw + pshufhw + N x (pextrw + pinsrw)
11248 static SDValue
11249 LowerVECTOR_SHUFFLEv8i16(SDValue Op, const X86Subtarget *Subtarget,
11250                          SelectionDAG &DAG) {
11251   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11252   SDValue V1 = SVOp->getOperand(0);
11253   SDValue V2 = SVOp->getOperand(1);
11254   SDLoc dl(SVOp);
11255   SmallVector<int, 8> MaskVals;
11256
11257   // Determine if more than 1 of the words in each of the low and high quadwords
11258   // of the result come from the same quadword of one of the two inputs.  Undef
11259   // mask values count as coming from any quadword, for better codegen.
11260   //
11261   // Lo/HiQuad[i] = j indicates how many words from the ith quad of the input
11262   // feeds this quad.  For i, 0 and 1 refer to V1, 2 and 3 refer to V2.
11263   unsigned LoQuad[] = { 0, 0, 0, 0 };
11264   unsigned HiQuad[] = { 0, 0, 0, 0 };
11265   // Indices of quads used.
11266   std::bitset<4> InputQuads;
11267   for (unsigned i = 0; i < 8; ++i) {
11268     unsigned *Quad = i < 4 ? LoQuad : HiQuad;
11269     int EltIdx = SVOp->getMaskElt(i);
11270     MaskVals.push_back(EltIdx);
11271     if (EltIdx < 0) {
11272       ++Quad[0];
11273       ++Quad[1];
11274       ++Quad[2];
11275       ++Quad[3];
11276       continue;
11277     }
11278     ++Quad[EltIdx / 4];
11279     InputQuads.set(EltIdx / 4);
11280   }
11281
11282   int BestLoQuad = -1;
11283   unsigned MaxQuad = 1;
11284   for (unsigned i = 0; i < 4; ++i) {
11285     if (LoQuad[i] > MaxQuad) {
11286       BestLoQuad = i;
11287       MaxQuad = LoQuad[i];
11288     }
11289   }
11290
11291   int BestHiQuad = -1;
11292   MaxQuad = 1;
11293   for (unsigned i = 0; i < 4; ++i) {
11294     if (HiQuad[i] > MaxQuad) {
11295       BestHiQuad = i;
11296       MaxQuad = HiQuad[i];
11297     }
11298   }
11299
11300   // For SSSE3, If all 8 words of the result come from only 1 quadword of each
11301   // of the two input vectors, shuffle them into one input vector so only a
11302   // single pshufb instruction is necessary. If there are more than 2 input
11303   // quads, disable the next transformation since it does not help SSSE3.
11304   bool V1Used = InputQuads[0] || InputQuads[1];
11305   bool V2Used = InputQuads[2] || InputQuads[3];
11306   if (Subtarget->hasSSSE3()) {
11307     if (InputQuads.count() == 2 && V1Used && V2Used) {
11308       BestLoQuad = InputQuads[0] ? 0 : 1;
11309       BestHiQuad = InputQuads[2] ? 2 : 3;
11310     }
11311     if (InputQuads.count() > 2) {
11312       BestLoQuad = -1;
11313       BestHiQuad = -1;
11314     }
11315   }
11316
11317   // If BestLoQuad or BestHiQuad are set, shuffle the quads together and update
11318   // the shuffle mask.  If a quad is scored as -1, that means that it contains
11319   // words from all 4 input quadwords.
11320   SDValue NewV;
11321   if (BestLoQuad >= 0 || BestHiQuad >= 0) {
11322     int MaskV[] = {
11323       BestLoQuad < 0 ? 0 : BestLoQuad,
11324       BestHiQuad < 0 ? 1 : BestHiQuad
11325     };
11326     NewV = DAG.getVectorShuffle(MVT::v2i64, dl,
11327                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1),
11328                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2), &MaskV[0]);
11329     NewV = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, NewV);
11330
11331     // Rewrite the MaskVals and assign NewV to V1 if NewV now contains all the
11332     // source words for the shuffle, to aid later transformations.
11333     bool AllWordsInNewV = true;
11334     bool InOrder[2] = { true, true };
11335     for (unsigned i = 0; i != 8; ++i) {
11336       int idx = MaskVals[i];
11337       if (idx != (int)i)
11338         InOrder[i/4] = false;
11339       if (idx < 0 || (idx/4) == BestLoQuad || (idx/4) == BestHiQuad)
11340         continue;
11341       AllWordsInNewV = false;
11342       break;
11343     }
11344
11345     bool pshuflw = AllWordsInNewV, pshufhw = AllWordsInNewV;
11346     if (AllWordsInNewV) {
11347       for (int i = 0; i != 8; ++i) {
11348         int idx = MaskVals[i];
11349         if (idx < 0)
11350           continue;
11351         idx = MaskVals[i] = (idx / 4) == BestLoQuad ? (idx & 3) : (idx & 3) + 4;
11352         if ((idx != i) && idx < 4)
11353           pshufhw = false;
11354         if ((idx != i) && idx > 3)
11355           pshuflw = false;
11356       }
11357       V1 = NewV;
11358       V2Used = false;
11359       BestLoQuad = 0;
11360       BestHiQuad = 1;
11361     }
11362
11363     // If we've eliminated the use of V2, and the new mask is a pshuflw or
11364     // pshufhw, that's as cheap as it gets.  Return the new shuffle.
11365     if ((pshufhw && InOrder[0]) || (pshuflw && InOrder[1])) {
11366       unsigned Opc = pshufhw ? X86ISD::PSHUFHW : X86ISD::PSHUFLW;
11367       unsigned TargetMask = 0;
11368       NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV,
11369                                   DAG.getUNDEF(MVT::v8i16), &MaskVals[0]);
11370       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11371       TargetMask = pshufhw ? getShufflePSHUFHWImmediate(SVOp):
11372                              getShufflePSHUFLWImmediate(SVOp);
11373       V1 = NewV.getOperand(0);
11374       return getTargetShuffleNode(Opc, dl, MVT::v8i16, V1, TargetMask, DAG);
11375     }
11376   }
11377
11378   // Promote splats to a larger type which usually leads to more efficient code.
11379   // FIXME: Is this true if pshufb is available?
11380   if (SVOp->isSplat())
11381     return PromoteSplat(SVOp, DAG);
11382
11383   // If we have SSSE3, and all words of the result are from 1 input vector,
11384   // case 2 is generated, otherwise case 3 is generated.  If no SSSE3
11385   // is present, fall back to case 4.
11386   if (Subtarget->hasSSSE3()) {
11387     SmallVector<SDValue,16> pshufbMask;
11388
11389     // If we have elements from both input vectors, set the high bit of the
11390     // shuffle mask element to zero out elements that come from V2 in the V1
11391     // mask, and elements that come from V1 in the V2 mask, so that the two
11392     // results can be OR'd together.
11393     bool TwoInputs = V1Used && V2Used;
11394     V1 = getPSHUFB(MaskVals, V1, dl, DAG);
11395     if (!TwoInputs)
11396       return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
11397
11398     // Calculate the shuffle mask for the second input, shuffle it, and
11399     // OR it with the first shuffled input.
11400     CommuteVectorShuffleMask(MaskVals, 8);
11401     V2 = getPSHUFB(MaskVals, V2, dl, DAG);
11402     V1 = DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
11403     return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
11404   }
11405
11406   // If BestLoQuad >= 0, generate a pshuflw to put the low elements in order,
11407   // and update MaskVals with new element order.
11408   std::bitset<8> InOrder;
11409   if (BestLoQuad >= 0) {
11410     int MaskV[] = { -1, -1, -1, -1, 4, 5, 6, 7 };
11411     for (int i = 0; i != 4; ++i) {
11412       int idx = MaskVals[i];
11413       if (idx < 0) {
11414         InOrder.set(i);
11415       } else if ((idx / 4) == BestLoQuad) {
11416         MaskV[i] = idx & 3;
11417         InOrder.set(i);
11418       }
11419     }
11420     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
11421                                 &MaskV[0]);
11422
11423     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSE2()) {
11424       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11425       NewV = getTargetShuffleNode(X86ISD::PSHUFLW, dl, MVT::v8i16,
11426                                   NewV.getOperand(0),
11427                                   getShufflePSHUFLWImmediate(SVOp), DAG);
11428     }
11429   }
11430
11431   // If BestHi >= 0, generate a pshufhw to put the high elements in order,
11432   // and update MaskVals with the new element order.
11433   if (BestHiQuad >= 0) {
11434     int MaskV[] = { 0, 1, 2, 3, -1, -1, -1, -1 };
11435     for (unsigned i = 4; i != 8; ++i) {
11436       int idx = MaskVals[i];
11437       if (idx < 0) {
11438         InOrder.set(i);
11439       } else if ((idx / 4) == BestHiQuad) {
11440         MaskV[i] = (idx & 3) + 4;
11441         InOrder.set(i);
11442       }
11443     }
11444     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
11445                                 &MaskV[0]);
11446
11447     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSE2()) {
11448       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
11449       NewV = getTargetShuffleNode(X86ISD::PSHUFHW, dl, MVT::v8i16,
11450                                   NewV.getOperand(0),
11451                                   getShufflePSHUFHWImmediate(SVOp), DAG);
11452     }
11453   }
11454
11455   // In case BestHi & BestLo were both -1, which means each quadword has a word
11456   // from each of the four input quadwords, calculate the InOrder bitvector now
11457   // before falling through to the insert/extract cleanup.
11458   if (BestLoQuad == -1 && BestHiQuad == -1) {
11459     NewV = V1;
11460     for (int i = 0; i != 8; ++i)
11461       if (MaskVals[i] < 0 || MaskVals[i] == i)
11462         InOrder.set(i);
11463   }
11464
11465   // The other elements are put in the right place using pextrw and pinsrw.
11466   for (unsigned i = 0; i != 8; ++i) {
11467     if (InOrder[i])
11468       continue;
11469     int EltIdx = MaskVals[i];
11470     if (EltIdx < 0)
11471       continue;
11472     SDValue ExtOp = (EltIdx < 8) ?
11473       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V1,
11474                   DAG.getIntPtrConstant(EltIdx)) :
11475       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V2,
11476                   DAG.getIntPtrConstant(EltIdx - 8));
11477     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, ExtOp,
11478                        DAG.getIntPtrConstant(i));
11479   }
11480   return NewV;
11481 }
11482
11483 /// \brief v16i16 shuffles
11484 ///
11485 /// FIXME: We only support generation of a single pshufb currently.  We can
11486 /// generalize the other applicable cases from LowerVECTOR_SHUFFLEv8i16 as
11487 /// well (e.g 2 x pshufb + 1 x por).
11488 static SDValue
11489 LowerVECTOR_SHUFFLEv16i16(SDValue Op, SelectionDAG &DAG) {
11490   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
11491   SDValue V1 = SVOp->getOperand(0);
11492   SDValue V2 = SVOp->getOperand(1);
11493   SDLoc dl(SVOp);
11494
11495   if (V2.getOpcode() != ISD::UNDEF)
11496     return SDValue();
11497
11498   SmallVector<int, 16> MaskVals(SVOp->getMask().begin(), SVOp->getMask().end());
11499   return getPSHUFB(MaskVals, V1, dl, DAG);
11500 }
11501
11502 // v16i8 shuffles - Prefer shuffles in the following order:
11503 // 1. [ssse3] 1 x pshufb
11504 // 2. [ssse3] 2 x pshufb + 1 x por
11505 // 3. [all]   v8i16 shuffle + N x pextrw + rotate + pinsrw
11506 static SDValue LowerVECTOR_SHUFFLEv16i8(ShuffleVectorSDNode *SVOp,
11507                                         const X86Subtarget* Subtarget,
11508                                         SelectionDAG &DAG) {
11509   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
11510   SDValue V1 = SVOp->getOperand(0);
11511   SDValue V2 = SVOp->getOperand(1);
11512   SDLoc dl(SVOp);
11513   ArrayRef<int> MaskVals = SVOp->getMask();
11514
11515   // Promote splats to a larger type which usually leads to more efficient code.
11516   // FIXME: Is this true if pshufb is available?
11517   if (SVOp->isSplat())
11518     return PromoteSplat(SVOp, DAG);
11519
11520   // If we have SSSE3, case 1 is generated when all result bytes come from
11521   // one of  the inputs.  Otherwise, case 2 is generated.  If no SSSE3 is
11522   // present, fall back to case 3.
11523
11524   // If SSSE3, use 1 pshufb instruction per vector with elements in the result.
11525   if (Subtarget->hasSSSE3()) {
11526     SmallVector<SDValue,16> pshufbMask;
11527
11528     // If all result elements are from one input vector, then only translate
11529     // undef mask values to 0x80 (zero out result) in the pshufb mask.
11530     //
11531     // Otherwise, we have elements from both input vectors, and must zero out
11532     // elements that come from V2 in the first mask, and V1 in the second mask
11533     // so that we can OR them together.
11534     for (unsigned i = 0; i != 16; ++i) {
11535       int EltIdx = MaskVals[i];
11536       if (EltIdx < 0 || EltIdx >= 16)
11537         EltIdx = 0x80;
11538       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
11539     }
11540     V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
11541                      DAG.getNode(ISD::BUILD_VECTOR, dl,
11542                                  MVT::v16i8, pshufbMask));
11543
11544     // As PSHUFB will zero elements with negative indices, it's safe to ignore
11545     // the 2nd operand if it's undefined or zero.
11546     if (V2.getOpcode() == ISD::UNDEF ||
11547         ISD::isBuildVectorAllZeros(V2.getNode()))
11548       return V1;
11549
11550     // Calculate the shuffle mask for the second input, shuffle it, and
11551     // OR it with the first shuffled input.
11552     pshufbMask.clear();
11553     for (unsigned i = 0; i != 16; ++i) {
11554       int EltIdx = MaskVals[i];
11555       EltIdx = (EltIdx < 16) ? 0x80 : EltIdx - 16;
11556       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
11557     }
11558     V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
11559                      DAG.getNode(ISD::BUILD_VECTOR, dl,
11560                                  MVT::v16i8, pshufbMask));
11561     return DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
11562   }
11563
11564   // No SSSE3 - Calculate in place words and then fix all out of place words
11565   // With 0-16 extracts & inserts.  Worst case is 16 bytes out of order from
11566   // the 16 different words that comprise the two doublequadword input vectors.
11567   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
11568   V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
11569   SDValue NewV = V1;
11570   for (int i = 0; i != 8; ++i) {
11571     int Elt0 = MaskVals[i*2];
11572     int Elt1 = MaskVals[i*2+1];
11573
11574     // This word of the result is all undef, skip it.
11575     if (Elt0 < 0 && Elt1 < 0)
11576       continue;
11577
11578     // This word of the result is already in the correct place, skip it.
11579     if ((Elt0 == i*2) && (Elt1 == i*2+1))
11580       continue;
11581
11582     SDValue Elt0Src = Elt0 < 16 ? V1 : V2;
11583     SDValue Elt1Src = Elt1 < 16 ? V1 : V2;
11584     SDValue InsElt;
11585
11586     // If Elt0 and Elt1 are defined, are consecutive, and can be load
11587     // using a single extract together, load it and store it.
11588     if ((Elt0 >= 0) && ((Elt0 + 1) == Elt1) && ((Elt0 & 1) == 0)) {
11589       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
11590                            DAG.getIntPtrConstant(Elt1 / 2));
11591       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
11592                         DAG.getIntPtrConstant(i));
11593       continue;
11594     }
11595
11596     // If Elt1 is defined, extract it from the appropriate source.  If the
11597     // source byte is not also odd, shift the extracted word left 8 bits
11598     // otherwise clear the bottom 8 bits if we need to do an or.
11599     if (Elt1 >= 0) {
11600       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
11601                            DAG.getIntPtrConstant(Elt1 / 2));
11602       if ((Elt1 & 1) == 0)
11603         InsElt = DAG.getNode(ISD::SHL, dl, MVT::i16, InsElt,
11604                              DAG.getConstant(8,
11605                                   TLI.getShiftAmountTy(InsElt.getValueType())));
11606       else if (Elt0 >= 0)
11607         InsElt = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt,
11608                              DAG.getConstant(0xFF00, MVT::i16));
11609     }
11610     // If Elt0 is defined, extract it from the appropriate source.  If the
11611     // source byte is not also even, shift the extracted word right 8 bits. If
11612     // Elt1 was also defined, OR the extracted values together before
11613     // inserting them in the result.
11614     if (Elt0 >= 0) {
11615       SDValue InsElt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
11616                                     Elt0Src, DAG.getIntPtrConstant(Elt0 / 2));
11617       if ((Elt0 & 1) != 0)
11618         InsElt0 = DAG.getNode(ISD::SRL, dl, MVT::i16, InsElt0,
11619                               DAG.getConstant(8,
11620                                  TLI.getShiftAmountTy(InsElt0.getValueType())));
11621       else if (Elt1 >= 0)
11622         InsElt0 = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt0,
11623                              DAG.getConstant(0x00FF, MVT::i16));
11624       InsElt = Elt1 >= 0 ? DAG.getNode(ISD::OR, dl, MVT::i16, InsElt, InsElt0)
11625                          : InsElt0;
11626     }
11627     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
11628                        DAG.getIntPtrConstant(i));
11629   }
11630   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, NewV);
11631 }
11632
11633 // v32i8 shuffles - Translate to VPSHUFB if possible.
11634 static
11635 SDValue LowerVECTOR_SHUFFLEv32i8(ShuffleVectorSDNode *SVOp,
11636                                  const X86Subtarget *Subtarget,
11637                                  SelectionDAG &DAG) {
11638   MVT VT = SVOp->getSimpleValueType(0);
11639   SDValue V1 = SVOp->getOperand(0);
11640   SDValue V2 = SVOp->getOperand(1);
11641   SDLoc dl(SVOp);
11642   SmallVector<int, 32> MaskVals(SVOp->getMask().begin(), SVOp->getMask().end());
11643
11644   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
11645   bool V1IsAllZero = ISD::isBuildVectorAllZeros(V1.getNode());
11646   bool V2IsAllZero = ISD::isBuildVectorAllZeros(V2.getNode());
11647
11648   // VPSHUFB may be generated if
11649   // (1) one of input vector is undefined or zeroinitializer.
11650   // The mask value 0x80 puts 0 in the corresponding slot of the vector.
11651   // And (2) the mask indexes don't cross the 128-bit lane.
11652   if (VT != MVT::v32i8 || !Subtarget->hasInt256() ||
11653       (!V2IsUndef && !V2IsAllZero && !V1IsAllZero))
11654     return SDValue();
11655
11656   if (V1IsAllZero && !V2IsAllZero) {
11657     CommuteVectorShuffleMask(MaskVals, 32);
11658     V1 = V2;
11659   }
11660   return getPSHUFB(MaskVals, V1, dl, DAG);
11661 }
11662
11663 /// RewriteAsNarrowerShuffle - Try rewriting v8i16 and v16i8 shuffles as 4 wide
11664 /// ones, or rewriting v4i32 / v4f32 as 2 wide ones if possible. This can be
11665 /// done when every pair / quad of shuffle mask elements point to elements in
11666 /// the right sequence. e.g.
11667 /// vector_shuffle X, Y, <2, 3, | 10, 11, | 0, 1, | 14, 15>
11668 static
11669 SDValue RewriteAsNarrowerShuffle(ShuffleVectorSDNode *SVOp,
11670                                  SelectionDAG &DAG) {
11671   MVT VT = SVOp->getSimpleValueType(0);
11672   SDLoc dl(SVOp);
11673   unsigned NumElems = VT.getVectorNumElements();
11674   MVT NewVT;
11675   unsigned Scale;
11676   switch (VT.SimpleTy) {
11677   default: llvm_unreachable("Unexpected!");
11678   case MVT::v2i64:
11679   case MVT::v2f64:
11680            return SDValue(SVOp, 0);
11681   case MVT::v4f32:  NewVT = MVT::v2f64; Scale = 2; break;
11682   case MVT::v4i32:  NewVT = MVT::v2i64; Scale = 2; break;
11683   case MVT::v8i16:  NewVT = MVT::v4i32; Scale = 2; break;
11684   case MVT::v16i8:  NewVT = MVT::v4i32; Scale = 4; break;
11685   case MVT::v16i16: NewVT = MVT::v8i32; Scale = 2; break;
11686   case MVT::v32i8:  NewVT = MVT::v8i32; Scale = 4; break;
11687   }
11688
11689   SmallVector<int, 8> MaskVec;
11690   for (unsigned i = 0; i != NumElems; i += Scale) {
11691     int StartIdx = -1;
11692     for (unsigned j = 0; j != Scale; ++j) {
11693       int EltIdx = SVOp->getMaskElt(i+j);
11694       if (EltIdx < 0)
11695         continue;
11696       if (StartIdx < 0)
11697         StartIdx = (EltIdx / Scale);
11698       if (EltIdx != (int)(StartIdx*Scale + j))
11699         return SDValue();
11700     }
11701     MaskVec.push_back(StartIdx);
11702   }
11703
11704   SDValue V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(0));
11705   SDValue V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(1));
11706   return DAG.getVectorShuffle(NewVT, dl, V1, V2, &MaskVec[0]);
11707 }
11708
11709 /// getVZextMovL - Return a zero-extending vector move low node.
11710 ///
11711 static SDValue getVZextMovL(MVT VT, MVT OpVT,
11712                             SDValue SrcOp, SelectionDAG &DAG,
11713                             const X86Subtarget *Subtarget, SDLoc dl) {
11714   if (VT == MVT::v2f64 || VT == MVT::v4f32) {
11715     LoadSDNode *LD = nullptr;
11716     if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
11717       LD = dyn_cast<LoadSDNode>(SrcOp);
11718     if (!LD) {
11719       // movssrr and movsdrr do not clear top bits. Try to use movd, movq
11720       // instead.
11721       MVT ExtVT = (OpVT == MVT::v2f64) ? MVT::i64 : MVT::i32;
11722       if ((ExtVT != MVT::i64 || Subtarget->is64Bit()) &&
11723           SrcOp.getOpcode() == ISD::SCALAR_TO_VECTOR &&
11724           SrcOp.getOperand(0).getOpcode() == ISD::BITCAST &&
11725           SrcOp.getOperand(0).getOperand(0).getValueType() == ExtVT) {
11726         // PR2108
11727         OpVT = (OpVT == MVT::v2f64) ? MVT::v2i64 : MVT::v4i32;
11728         return DAG.getNode(ISD::BITCAST, dl, VT,
11729                            DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
11730                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
11731                                                    OpVT,
11732                                                    SrcOp.getOperand(0)
11733                                                           .getOperand(0))));
11734       }
11735     }
11736   }
11737
11738   return DAG.getNode(ISD::BITCAST, dl, VT,
11739                      DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
11740                                  DAG.getNode(ISD::BITCAST, dl,
11741                                              OpVT, SrcOp)));
11742 }
11743
11744 /// LowerVECTOR_SHUFFLE_256 - Handle all 256-bit wide vectors shuffles
11745 /// which could not be matched by any known target speficic shuffle
11746 static SDValue
11747 LowerVECTOR_SHUFFLE_256(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
11748
11749   SDValue NewOp = Compact8x32ShuffleNode(SVOp, DAG);
11750   if (NewOp.getNode())
11751     return NewOp;
11752
11753   MVT VT = SVOp->getSimpleValueType(0);
11754
11755   unsigned NumElems = VT.getVectorNumElements();
11756   unsigned NumLaneElems = NumElems / 2;
11757
11758   SDLoc dl(SVOp);
11759   MVT EltVT = VT.getVectorElementType();
11760   MVT NVT = MVT::getVectorVT(EltVT, NumLaneElems);
11761   SDValue Output[2];
11762
11763   SmallVector<int, 16> Mask;
11764   for (unsigned l = 0; l < 2; ++l) {
11765     // Build a shuffle mask for the output, discovering on the fly which
11766     // input vectors to use as shuffle operands (recorded in InputUsed).
11767     // If building a suitable shuffle vector proves too hard, then bail
11768     // out with UseBuildVector set.
11769     bool UseBuildVector = false;
11770     int InputUsed[2] = { -1, -1 }; // Not yet discovered.
11771     unsigned LaneStart = l * NumLaneElems;
11772     for (unsigned i = 0; i != NumLaneElems; ++i) {
11773       // The mask element.  This indexes into the input.
11774       int Idx = SVOp->getMaskElt(i+LaneStart);
11775       if (Idx < 0) {
11776         // the mask element does not index into any input vector.
11777         Mask.push_back(-1);
11778         continue;
11779       }
11780
11781       // The input vector this mask element indexes into.
11782       int Input = Idx / NumLaneElems;
11783
11784       // Turn the index into an offset from the start of the input vector.
11785       Idx -= Input * NumLaneElems;
11786
11787       // Find or create a shuffle vector operand to hold this input.
11788       unsigned OpNo;
11789       for (OpNo = 0; OpNo < array_lengthof(InputUsed); ++OpNo) {
11790         if (InputUsed[OpNo] == Input)
11791           // This input vector is already an operand.
11792           break;
11793         if (InputUsed[OpNo] < 0) {
11794           // Create a new operand for this input vector.
11795           InputUsed[OpNo] = Input;
11796           break;
11797         }
11798       }
11799
11800       if (OpNo >= array_lengthof(InputUsed)) {
11801         // More than two input vectors used!  Give up on trying to create a
11802         // shuffle vector.  Insert all elements into a BUILD_VECTOR instead.
11803         UseBuildVector = true;
11804         break;
11805       }
11806
11807       // Add the mask index for the new shuffle vector.
11808       Mask.push_back(Idx + OpNo * NumLaneElems);
11809     }
11810
11811     if (UseBuildVector) {
11812       SmallVector<SDValue, 16> SVOps;
11813       for (unsigned i = 0; i != NumLaneElems; ++i) {
11814         // The mask element.  This indexes into the input.
11815         int Idx = SVOp->getMaskElt(i+LaneStart);
11816         if (Idx < 0) {
11817           SVOps.push_back(DAG.getUNDEF(EltVT));
11818           continue;
11819         }
11820
11821         // The input vector this mask element indexes into.
11822         int Input = Idx / NumElems;
11823
11824         // Turn the index into an offset from the start of the input vector.
11825         Idx -= Input * NumElems;
11826
11827         // Extract the vector element by hand.
11828         SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
11829                                     SVOp->getOperand(Input),
11830                                     DAG.getIntPtrConstant(Idx)));
11831       }
11832
11833       // Construct the output using a BUILD_VECTOR.
11834       Output[l] = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, SVOps);
11835     } else if (InputUsed[0] < 0) {
11836       // No input vectors were used! The result is undefined.
11837       Output[l] = DAG.getUNDEF(NVT);
11838     } else {
11839       SDValue Op0 = Extract128BitVector(SVOp->getOperand(InputUsed[0] / 2),
11840                                         (InputUsed[0] % 2) * NumLaneElems,
11841                                         DAG, dl);
11842       // If only one input was used, use an undefined vector for the other.
11843       SDValue Op1 = (InputUsed[1] < 0) ? DAG.getUNDEF(NVT) :
11844         Extract128BitVector(SVOp->getOperand(InputUsed[1] / 2),
11845                             (InputUsed[1] % 2) * NumLaneElems, DAG, dl);
11846       // At least one input vector was used. Create a new shuffle vector.
11847       Output[l] = DAG.getVectorShuffle(NVT, dl, Op0, Op1, &Mask[0]);
11848     }
11849
11850     Mask.clear();
11851   }
11852
11853   // Concatenate the result back
11854   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Output[0], Output[1]);
11855 }
11856
11857 /// LowerVECTOR_SHUFFLE_128v4 - Handle all 128-bit wide vectors with
11858 /// 4 elements, and match them with several different shuffle types.
11859 static SDValue
11860 LowerVECTOR_SHUFFLE_128v4(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
11861   SDValue V1 = SVOp->getOperand(0);
11862   SDValue V2 = SVOp->getOperand(1);
11863   SDLoc dl(SVOp);
11864   MVT VT = SVOp->getSimpleValueType(0);
11865
11866   assert(VT.is128BitVector() && "Unsupported vector size");
11867
11868   std::pair<int, int> Locs[4];
11869   int Mask1[] = { -1, -1, -1, -1 };
11870   SmallVector<int, 8> PermMask(SVOp->getMask().begin(), SVOp->getMask().end());
11871
11872   unsigned NumHi = 0;
11873   unsigned NumLo = 0;
11874   for (unsigned i = 0; i != 4; ++i) {
11875     int Idx = PermMask[i];
11876     if (Idx < 0) {
11877       Locs[i] = std::make_pair(-1, -1);
11878     } else {
11879       assert(Idx < 8 && "Invalid VECTOR_SHUFFLE index!");
11880       if (Idx < 4) {
11881         Locs[i] = std::make_pair(0, NumLo);
11882         Mask1[NumLo] = Idx;
11883         NumLo++;
11884       } else {
11885         Locs[i] = std::make_pair(1, NumHi);
11886         if (2+NumHi < 4)
11887           Mask1[2+NumHi] = Idx;
11888         NumHi++;
11889       }
11890     }
11891   }
11892
11893   if (NumLo <= 2 && NumHi <= 2) {
11894     // If no more than two elements come from either vector. This can be
11895     // implemented with two shuffles. First shuffle gather the elements.
11896     // The second shuffle, which takes the first shuffle as both of its
11897     // vector operands, put the elements into the right order.
11898     V1 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
11899
11900     int Mask2[] = { -1, -1, -1, -1 };
11901
11902     for (unsigned i = 0; i != 4; ++i)
11903       if (Locs[i].first != -1) {
11904         unsigned Idx = (i < 2) ? 0 : 4;
11905         Idx += Locs[i].first * 2 + Locs[i].second;
11906         Mask2[i] = Idx;
11907       }
11908
11909     return DAG.getVectorShuffle(VT, dl, V1, V1, &Mask2[0]);
11910   }
11911
11912   if (NumLo == 3 || NumHi == 3) {
11913     // Otherwise, we must have three elements from one vector, call it X, and
11914     // one element from the other, call it Y.  First, use a shufps to build an
11915     // intermediate vector with the one element from Y and the element from X
11916     // that will be in the same half in the final destination (the indexes don't
11917     // matter). Then, use a shufps to build the final vector, taking the half
11918     // containing the element from Y from the intermediate, and the other half
11919     // from X.
11920     if (NumHi == 3) {
11921       // Normalize it so the 3 elements come from V1.
11922       CommuteVectorShuffleMask(PermMask, 4);
11923       std::swap(V1, V2);
11924     }
11925
11926     // Find the element from V2.
11927     unsigned HiIndex;
11928     for (HiIndex = 0; HiIndex < 3; ++HiIndex) {
11929       int Val = PermMask[HiIndex];
11930       if (Val < 0)
11931         continue;
11932       if (Val >= 4)
11933         break;
11934     }
11935
11936     Mask1[0] = PermMask[HiIndex];
11937     Mask1[1] = -1;
11938     Mask1[2] = PermMask[HiIndex^1];
11939     Mask1[3] = -1;
11940     V2 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
11941
11942     if (HiIndex >= 2) {
11943       Mask1[0] = PermMask[0];
11944       Mask1[1] = PermMask[1];
11945       Mask1[2] = HiIndex & 1 ? 6 : 4;
11946       Mask1[3] = HiIndex & 1 ? 4 : 6;
11947       return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
11948     }
11949
11950     Mask1[0] = HiIndex & 1 ? 2 : 0;
11951     Mask1[1] = HiIndex & 1 ? 0 : 2;
11952     Mask1[2] = PermMask[2];
11953     Mask1[3] = PermMask[3];
11954     if (Mask1[2] >= 0)
11955       Mask1[2] += 4;
11956     if (Mask1[3] >= 0)
11957       Mask1[3] += 4;
11958     return DAG.getVectorShuffle(VT, dl, V2, V1, &Mask1[0]);
11959   }
11960
11961   // Break it into (shuffle shuffle_hi, shuffle_lo).
11962   int LoMask[] = { -1, -1, -1, -1 };
11963   int HiMask[] = { -1, -1, -1, -1 };
11964
11965   int *MaskPtr = LoMask;
11966   unsigned MaskIdx = 0;
11967   unsigned LoIdx = 0;
11968   unsigned HiIdx = 2;
11969   for (unsigned i = 0; i != 4; ++i) {
11970     if (i == 2) {
11971       MaskPtr = HiMask;
11972       MaskIdx = 1;
11973       LoIdx = 0;
11974       HiIdx = 2;
11975     }
11976     int Idx = PermMask[i];
11977     if (Idx < 0) {
11978       Locs[i] = std::make_pair(-1, -1);
11979     } else if (Idx < 4) {
11980       Locs[i] = std::make_pair(MaskIdx, LoIdx);
11981       MaskPtr[LoIdx] = Idx;
11982       LoIdx++;
11983     } else {
11984       Locs[i] = std::make_pair(MaskIdx, HiIdx);
11985       MaskPtr[HiIdx] = Idx;
11986       HiIdx++;
11987     }
11988   }
11989
11990   SDValue LoShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &LoMask[0]);
11991   SDValue HiShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &HiMask[0]);
11992   int MaskOps[] = { -1, -1, -1, -1 };
11993   for (unsigned i = 0; i != 4; ++i)
11994     if (Locs[i].first != -1)
11995       MaskOps[i] = Locs[i].first * 4 + Locs[i].second;
11996   return DAG.getVectorShuffle(VT, dl, LoShuffle, HiShuffle, &MaskOps[0]);
11997 }
11998
11999 static bool MayFoldVectorLoad(SDValue V) {
12000   while (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
12001     V = V.getOperand(0);
12002
12003   if (V.hasOneUse() && V.getOpcode() == ISD::SCALAR_TO_VECTOR)
12004     V = V.getOperand(0);
12005   if (V.hasOneUse() && V.getOpcode() == ISD::BUILD_VECTOR &&
12006       V.getNumOperands() == 2 && V.getOperand(1).getOpcode() == ISD::UNDEF)
12007     // BUILD_VECTOR (load), undef
12008     V = V.getOperand(0);
12009
12010   return MayFoldLoad(V);
12011 }
12012
12013 static
12014 SDValue getMOVDDup(SDValue &Op, SDLoc &dl, SDValue V1, SelectionDAG &DAG) {
12015   MVT VT = Op.getSimpleValueType();
12016
12017   // Canonizalize to v2f64.
12018   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
12019   return DAG.getNode(ISD::BITCAST, dl, VT,
12020                      getTargetShuffleNode(X86ISD::MOVDDUP, dl, MVT::v2f64,
12021                                           V1, DAG));
12022 }
12023
12024 static
12025 SDValue getMOVLowToHigh(SDValue &Op, SDLoc &dl, SelectionDAG &DAG,
12026                         bool HasSSE2) {
12027   SDValue V1 = Op.getOperand(0);
12028   SDValue V2 = Op.getOperand(1);
12029   MVT VT = Op.getSimpleValueType();
12030
12031   assert(VT != MVT::v2i64 && "unsupported shuffle type");
12032
12033   if (HasSSE2 && VT == MVT::v2f64)
12034     return getTargetShuffleNode(X86ISD::MOVLHPD, dl, VT, V1, V2, DAG);
12035
12036   // v4f32 or v4i32: canonizalized to v4f32 (which is legal for SSE1)
12037   return DAG.getNode(ISD::BITCAST, dl, VT,
12038                      getTargetShuffleNode(X86ISD::MOVLHPS, dl, MVT::v4f32,
12039                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V1),
12040                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V2), DAG));
12041 }
12042
12043 static
12044 SDValue getMOVHighToLow(SDValue &Op, SDLoc &dl, SelectionDAG &DAG) {
12045   SDValue V1 = Op.getOperand(0);
12046   SDValue V2 = Op.getOperand(1);
12047   MVT VT = Op.getSimpleValueType();
12048
12049   assert((VT == MVT::v4i32 || VT == MVT::v4f32) &&
12050          "unsupported shuffle type");
12051
12052   if (V2.getOpcode() == ISD::UNDEF)
12053     V2 = V1;
12054
12055   // v4i32 or v4f32
12056   return getTargetShuffleNode(X86ISD::MOVHLPS, dl, VT, V1, V2, DAG);
12057 }
12058
12059 static
12060 SDValue getMOVLP(SDValue &Op, SDLoc &dl, SelectionDAG &DAG, bool HasSSE2) {
12061   SDValue V1 = Op.getOperand(0);
12062   SDValue V2 = Op.getOperand(1);
12063   MVT VT = Op.getSimpleValueType();
12064   unsigned NumElems = VT.getVectorNumElements();
12065
12066   // Use MOVLPS and MOVLPD in case V1 or V2 are loads. During isel, the second
12067   // operand of these instructions is only memory, so check if there's a
12068   // potencial load folding here, otherwise use SHUFPS or MOVSD to match the
12069   // same masks.
12070   bool CanFoldLoad = false;
12071
12072   // Trivial case, when V2 comes from a load.
12073   if (MayFoldVectorLoad(V2))
12074     CanFoldLoad = true;
12075
12076   // When V1 is a load, it can be folded later into a store in isel, example:
12077   //  (store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)), addr:$src1)
12078   //    turns into:
12079   //  (MOVLPSmr addr:$src1, VR128:$src2)
12080   // So, recognize this potential and also use MOVLPS or MOVLPD
12081   else if (MayFoldVectorLoad(V1) && MayFoldIntoStore(Op))
12082     CanFoldLoad = true;
12083
12084   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12085   if (CanFoldLoad) {
12086     if (HasSSE2 && NumElems == 2)
12087       return getTargetShuffleNode(X86ISD::MOVLPD, dl, VT, V1, V2, DAG);
12088
12089     if (NumElems == 4)
12090       // If we don't care about the second element, proceed to use movss.
12091       if (SVOp->getMaskElt(1) != -1)
12092         return getTargetShuffleNode(X86ISD::MOVLPS, dl, VT, V1, V2, DAG);
12093   }
12094
12095   // movl and movlp will both match v2i64, but v2i64 is never matched by
12096   // movl earlier because we make it strict to avoid messing with the movlp load
12097   // folding logic (see the code above getMOVLP call). Match it here then,
12098   // this is horrible, but will stay like this until we move all shuffle
12099   // matching to x86 specific nodes. Note that for the 1st condition all
12100   // types are matched with movsd.
12101   if (HasSSE2) {
12102     // FIXME: isMOVLMask should be checked and matched before getMOVLP,
12103     // as to remove this logic from here, as much as possible
12104     if (NumElems == 2 || !isMOVLMask(SVOp->getMask(), VT))
12105       return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
12106     return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
12107   }
12108
12109   assert(VT != MVT::v4i32 && "unsupported shuffle type");
12110
12111   // Invert the operand order and use SHUFPS to match it.
12112   return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V2, V1,
12113                               getShuffleSHUFImmediate(SVOp), DAG);
12114 }
12115
12116 static SDValue NarrowVectorLoadToElement(LoadSDNode *Load, unsigned Index,
12117                                          SelectionDAG &DAG) {
12118   SDLoc dl(Load);
12119   MVT VT = Load->getSimpleValueType(0);
12120   MVT EVT = VT.getVectorElementType();
12121   SDValue Addr = Load->getOperand(1);
12122   SDValue NewAddr = DAG.getNode(
12123       ISD::ADD, dl, Addr.getSimpleValueType(), Addr,
12124       DAG.getConstant(Index * EVT.getStoreSize(), Addr.getSimpleValueType()));
12125
12126   SDValue NewLoad =
12127       DAG.getLoad(EVT, dl, Load->getChain(), NewAddr,
12128                   DAG.getMachineFunction().getMachineMemOperand(
12129                       Load->getMemOperand(), 0, EVT.getStoreSize()));
12130   return NewLoad;
12131 }
12132
12133 // It is only safe to call this function if isINSERTPSMask is true for
12134 // this shufflevector mask.
12135 static SDValue getINSERTPS(ShuffleVectorSDNode *SVOp, SDLoc &dl,
12136                            SelectionDAG &DAG) {
12137   // Generate an insertps instruction when inserting an f32 from memory onto a
12138   // v4f32 or when copying a member from one v4f32 to another.
12139   // We also use it for transferring i32 from one register to another,
12140   // since it simply copies the same bits.
12141   // If we're transferring an i32 from memory to a specific element in a
12142   // register, we output a generic DAG that will match the PINSRD
12143   // instruction.
12144   MVT VT = SVOp->getSimpleValueType(0);
12145   MVT EVT = VT.getVectorElementType();
12146   SDValue V1 = SVOp->getOperand(0);
12147   SDValue V2 = SVOp->getOperand(1);
12148   auto Mask = SVOp->getMask();
12149   assert((VT == MVT::v4f32 || VT == MVT::v4i32) &&
12150          "unsupported vector type for insertps/pinsrd");
12151
12152   auto FromV1Predicate = [](const int &i) { return i < 4 && i > -1; };
12153   auto FromV2Predicate = [](const int &i) { return i >= 4; };
12154   int FromV1 = std::count_if(Mask.begin(), Mask.end(), FromV1Predicate);
12155
12156   SDValue From;
12157   SDValue To;
12158   unsigned DestIndex;
12159   if (FromV1 == 1) {
12160     From = V1;
12161     To = V2;
12162     DestIndex = std::find_if(Mask.begin(), Mask.end(), FromV1Predicate) -
12163                 Mask.begin();
12164
12165     // If we have 1 element from each vector, we have to check if we're
12166     // changing V1's element's place. If so, we're done. Otherwise, we
12167     // should assume we're changing V2's element's place and behave
12168     // accordingly.
12169     int FromV2 = std::count_if(Mask.begin(), Mask.end(), FromV2Predicate);
12170     assert(DestIndex <= INT32_MAX && "truncated destination index");
12171     if (FromV1 == FromV2 &&
12172         static_cast<int>(DestIndex) == Mask[DestIndex] % 4) {
12173       From = V2;
12174       To = V1;
12175       DestIndex =
12176           std::find_if(Mask.begin(), Mask.end(), FromV2Predicate) - Mask.begin();
12177     }
12178   } else {
12179     assert(std::count_if(Mask.begin(), Mask.end(), FromV2Predicate) == 1 &&
12180            "More than one element from V1 and from V2, or no elements from one "
12181            "of the vectors. This case should not have returned true from "
12182            "isINSERTPSMask");
12183     From = V2;
12184     To = V1;
12185     DestIndex =
12186         std::find_if(Mask.begin(), Mask.end(), FromV2Predicate) - Mask.begin();
12187   }
12188
12189   // Get an index into the source vector in the range [0,4) (the mask is
12190   // in the range [0,8) because it can address V1 and V2)
12191   unsigned SrcIndex = Mask[DestIndex] % 4;
12192   if (MayFoldLoad(From)) {
12193     // Trivial case, when From comes from a load and is only used by the
12194     // shuffle. Make it use insertps from the vector that we need from that
12195     // load.
12196     SDValue NewLoad =
12197         NarrowVectorLoadToElement(cast<LoadSDNode>(From), SrcIndex, DAG);
12198     if (!NewLoad.getNode())
12199       return SDValue();
12200
12201     if (EVT == MVT::f32) {
12202       // Create this as a scalar to vector to match the instruction pattern.
12203       SDValue LoadScalarToVector =
12204           DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, NewLoad);
12205       SDValue InsertpsMask = DAG.getIntPtrConstant(DestIndex << 4);
12206       return DAG.getNode(X86ISD::INSERTPS, dl, VT, To, LoadScalarToVector,
12207                          InsertpsMask);
12208     } else { // EVT == MVT::i32
12209       // If we're getting an i32 from memory, use an INSERT_VECTOR_ELT
12210       // instruction, to match the PINSRD instruction, which loads an i32 to a
12211       // certain vector element.
12212       return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, To, NewLoad,
12213                          DAG.getConstant(DestIndex, MVT::i32));
12214     }
12215   }
12216
12217   // Vector-element-to-vector
12218   SDValue InsertpsMask = DAG.getIntPtrConstant(DestIndex << 4 | SrcIndex << 6);
12219   return DAG.getNode(X86ISD::INSERTPS, dl, VT, To, From, InsertpsMask);
12220 }
12221
12222 // Reduce a vector shuffle to zext.
12223 static SDValue LowerVectorIntExtend(SDValue Op, const X86Subtarget *Subtarget,
12224                                     SelectionDAG &DAG) {
12225   // PMOVZX is only available from SSE41.
12226   if (!Subtarget->hasSSE41())
12227     return SDValue();
12228
12229   MVT VT = Op.getSimpleValueType();
12230
12231   // Only AVX2 support 256-bit vector integer extending.
12232   if (!Subtarget->hasInt256() && VT.is256BitVector())
12233     return SDValue();
12234
12235   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12236   SDLoc DL(Op);
12237   SDValue V1 = Op.getOperand(0);
12238   SDValue V2 = Op.getOperand(1);
12239   unsigned NumElems = VT.getVectorNumElements();
12240
12241   // Extending is an unary operation and the element type of the source vector
12242   // won't be equal to or larger than i64.
12243   if (V2.getOpcode() != ISD::UNDEF || !VT.isInteger() ||
12244       VT.getVectorElementType() == MVT::i64)
12245     return SDValue();
12246
12247   // Find the expansion ratio, e.g. expanding from i8 to i32 has a ratio of 4.
12248   unsigned Shift = 1; // Start from 2, i.e. 1 << 1.
12249   while ((1U << Shift) < NumElems) {
12250     if (SVOp->getMaskElt(1U << Shift) == 1)
12251       break;
12252     Shift += 1;
12253     // The maximal ratio is 8, i.e. from i8 to i64.
12254     if (Shift > 3)
12255       return SDValue();
12256   }
12257
12258   // Check the shuffle mask.
12259   unsigned Mask = (1U << Shift) - 1;
12260   for (unsigned i = 0; i != NumElems; ++i) {
12261     int EltIdx = SVOp->getMaskElt(i);
12262     if ((i & Mask) != 0 && EltIdx != -1)
12263       return SDValue();
12264     if ((i & Mask) == 0 && (unsigned)EltIdx != (i >> Shift))
12265       return SDValue();
12266   }
12267
12268   unsigned NBits = VT.getVectorElementType().getSizeInBits() << Shift;
12269   MVT NeVT = MVT::getIntegerVT(NBits);
12270   MVT NVT = MVT::getVectorVT(NeVT, NumElems >> Shift);
12271
12272   if (!DAG.getTargetLoweringInfo().isTypeLegal(NVT))
12273     return SDValue();
12274
12275   return DAG.getNode(ISD::BITCAST, DL, VT,
12276                      DAG.getNode(X86ISD::VZEXT, DL, NVT, V1));
12277 }
12278
12279 static SDValue NormalizeVectorShuffle(SDValue Op, const X86Subtarget *Subtarget,
12280                                       SelectionDAG &DAG) {
12281   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12282   MVT VT = Op.getSimpleValueType();
12283   SDLoc dl(Op);
12284   SDValue V1 = Op.getOperand(0);
12285   SDValue V2 = Op.getOperand(1);
12286
12287   if (isZeroShuffle(SVOp))
12288     return getZeroVector(VT, Subtarget, DAG, dl);
12289
12290   // Handle splat operations
12291   if (SVOp->isSplat()) {
12292     // Use vbroadcast whenever the splat comes from a foldable load
12293     SDValue Broadcast = LowerVectorBroadcast(Op, Subtarget, DAG);
12294     if (Broadcast.getNode())
12295       return Broadcast;
12296   }
12297
12298   // Check integer expanding shuffles.
12299   SDValue NewOp = LowerVectorIntExtend(Op, Subtarget, DAG);
12300   if (NewOp.getNode())
12301     return NewOp;
12302
12303   // If the shuffle can be profitably rewritten as a narrower shuffle, then
12304   // do it!
12305   if (VT == MVT::v8i16 || VT == MVT::v16i8 || VT == MVT::v16i16 ||
12306       VT == MVT::v32i8) {
12307     SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12308     if (NewOp.getNode())
12309       return DAG.getNode(ISD::BITCAST, dl, VT, NewOp);
12310   } else if (VT.is128BitVector() && Subtarget->hasSSE2()) {
12311     // FIXME: Figure out a cleaner way to do this.
12312     if (ISD::isBuildVectorAllZeros(V2.getNode())) {
12313       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12314       if (NewOp.getNode()) {
12315         MVT NewVT = NewOp.getSimpleValueType();
12316         if (isCommutedMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(),
12317                                NewVT, true, false))
12318           return getVZextMovL(VT, NewVT, NewOp.getOperand(0), DAG, Subtarget,
12319                               dl);
12320       }
12321     } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
12322       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
12323       if (NewOp.getNode()) {
12324         MVT NewVT = NewOp.getSimpleValueType();
12325         if (isMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(), NewVT))
12326           return getVZextMovL(VT, NewVT, NewOp.getOperand(1), DAG, Subtarget,
12327                               dl);
12328       }
12329     }
12330   }
12331   return SDValue();
12332 }
12333
12334 SDValue
12335 X86TargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const {
12336   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
12337   SDValue V1 = Op.getOperand(0);
12338   SDValue V2 = Op.getOperand(1);
12339   MVT VT = Op.getSimpleValueType();
12340   SDLoc dl(Op);
12341   unsigned NumElems = VT.getVectorNumElements();
12342   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
12343   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
12344   bool V1IsSplat = false;
12345   bool V2IsSplat = false;
12346   bool HasSSE2 = Subtarget->hasSSE2();
12347   bool HasFp256    = Subtarget->hasFp256();
12348   bool HasInt256   = Subtarget->hasInt256();
12349   MachineFunction &MF = DAG.getMachineFunction();
12350   bool OptForSize = MF.getFunction()->getAttributes().
12351     hasAttribute(AttributeSet::FunctionIndex, Attribute::OptimizeForSize);
12352
12353   // Check if we should use the experimental vector shuffle lowering. If so,
12354   // delegate completely to that code path.
12355   if (ExperimentalVectorShuffleLowering)
12356     return lowerVectorShuffle(Op, Subtarget, DAG);
12357
12358   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
12359
12360   if (V1IsUndef && V2IsUndef)
12361     return DAG.getUNDEF(VT);
12362
12363   // When we create a shuffle node we put the UNDEF node to second operand,
12364   // but in some cases the first operand may be transformed to UNDEF.
12365   // In this case we should just commute the node.
12366   if (V1IsUndef)
12367     return DAG.getCommutedVectorShuffle(*SVOp);
12368
12369   // Vector shuffle lowering takes 3 steps:
12370   //
12371   // 1) Normalize the input vectors. Here splats, zeroed vectors, profitable
12372   //    narrowing and commutation of operands should be handled.
12373   // 2) Matching of shuffles with known shuffle masks to x86 target specific
12374   //    shuffle nodes.
12375   // 3) Rewriting of unmatched masks into new generic shuffle operations,
12376   //    so the shuffle can be broken into other shuffles and the legalizer can
12377   //    try the lowering again.
12378   //
12379   // The general idea is that no vector_shuffle operation should be left to
12380   // be matched during isel, all of them must be converted to a target specific
12381   // node here.
12382
12383   // Normalize the input vectors. Here splats, zeroed vectors, profitable
12384   // narrowing and commutation of operands should be handled. The actual code
12385   // doesn't include all of those, work in progress...
12386   SDValue NewOp = NormalizeVectorShuffle(Op, Subtarget, DAG);
12387   if (NewOp.getNode())
12388     return NewOp;
12389
12390   SmallVector<int, 8> M(SVOp->getMask().begin(), SVOp->getMask().end());
12391
12392   // NOTE: isPSHUFDMask can also match both masks below (unpckl_undef and
12393   // unpckh_undef). Only use pshufd if speed is more important than size.
12394   if (OptForSize && isUNPCKL_v_undef_Mask(M, VT, HasInt256))
12395     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
12396   if (OptForSize && isUNPCKH_v_undef_Mask(M, VT, HasInt256))
12397     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
12398
12399   if (isMOVDDUPMask(M, VT) && Subtarget->hasSSE3() &&
12400       V2IsUndef && MayFoldVectorLoad(V1))
12401     return getMOVDDup(Op, dl, V1, DAG);
12402
12403   if (isMOVHLPS_v_undef_Mask(M, VT))
12404     return getMOVHighToLow(Op, dl, DAG);
12405
12406   // Use to match splats
12407   if (HasSSE2 && isUNPCKHMask(M, VT, HasInt256) && V2IsUndef &&
12408       (VT == MVT::v2f64 || VT == MVT::v2i64))
12409     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
12410
12411   if (isPSHUFDMask(M, VT)) {
12412     // The actual implementation will match the mask in the if above and then
12413     // during isel it can match several different instructions, not only pshufd
12414     // as its name says, sad but true, emulate the behavior for now...
12415     if (isMOVDDUPMask(M, VT) && ((VT == MVT::v4f32 || VT == MVT::v2i64)))
12416       return getTargetShuffleNode(X86ISD::MOVLHPS, dl, VT, V1, V1, DAG);
12417
12418     unsigned TargetMask = getShuffleSHUFImmediate(SVOp);
12419
12420     if (HasSSE2 && (VT == MVT::v4f32 || VT == MVT::v4i32))
12421       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1, TargetMask, DAG);
12422
12423     if (HasFp256 && (VT == MVT::v4f32 || VT == MVT::v2f64))
12424       return getTargetShuffleNode(X86ISD::VPERMILPI, dl, VT, V1, TargetMask,
12425                                   DAG);
12426
12427     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V1,
12428                                 TargetMask, DAG);
12429   }
12430
12431   if (isPALIGNRMask(M, VT, Subtarget))
12432     return getTargetShuffleNode(X86ISD::PALIGNR, dl, VT, V1, V2,
12433                                 getShufflePALIGNRImmediate(SVOp),
12434                                 DAG);
12435
12436   if (isVALIGNMask(M, VT, Subtarget))
12437     return getTargetShuffleNode(X86ISD::VALIGN, dl, VT, V1, V2,
12438                                 getShuffleVALIGNImmediate(SVOp),
12439                                 DAG);
12440
12441   // Check if this can be converted into a logical shift.
12442   bool isLeft = false;
12443   unsigned ShAmt = 0;
12444   SDValue ShVal;
12445   bool isShift = HasSSE2 && isVectorShift(SVOp, DAG, isLeft, ShVal, ShAmt);
12446   if (isShift && ShVal.hasOneUse()) {
12447     // If the shifted value has multiple uses, it may be cheaper to use
12448     // v_set0 + movlhps or movhlps, etc.
12449     MVT EltVT = VT.getVectorElementType();
12450     ShAmt *= EltVT.getSizeInBits();
12451     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
12452   }
12453
12454   if (isMOVLMask(M, VT)) {
12455     if (ISD::isBuildVectorAllZeros(V1.getNode()))
12456       return getVZextMovL(VT, VT, V2, DAG, Subtarget, dl);
12457     if (!isMOVLPMask(M, VT)) {
12458       if (HasSSE2 && (VT == MVT::v2i64 || VT == MVT::v2f64))
12459         return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
12460
12461       if (VT == MVT::v4i32 || VT == MVT::v4f32)
12462         return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
12463     }
12464   }
12465
12466   // FIXME: fold these into legal mask.
12467   if (isMOVLHPSMask(M, VT) && !isUNPCKLMask(M, VT, HasInt256))
12468     return getMOVLowToHigh(Op, dl, DAG, HasSSE2);
12469
12470   if (isMOVHLPSMask(M, VT))
12471     return getMOVHighToLow(Op, dl, DAG);
12472
12473   if (V2IsUndef && isMOVSHDUPMask(M, VT, Subtarget))
12474     return getTargetShuffleNode(X86ISD::MOVSHDUP, dl, VT, V1, DAG);
12475
12476   if (V2IsUndef && isMOVSLDUPMask(M, VT, Subtarget))
12477     return getTargetShuffleNode(X86ISD::MOVSLDUP, dl, VT, V1, DAG);
12478
12479   if (isMOVLPMask(M, VT))
12480     return getMOVLP(Op, dl, DAG, HasSSE2);
12481
12482   if (ShouldXformToMOVHLPS(M, VT) ||
12483       ShouldXformToMOVLP(V1.getNode(), V2.getNode(), M, VT))
12484     return DAG.getCommutedVectorShuffle(*SVOp);
12485
12486   if (isShift) {
12487     // No better options. Use a vshldq / vsrldq.
12488     MVT EltVT = VT.getVectorElementType();
12489     ShAmt *= EltVT.getSizeInBits();
12490     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
12491   }
12492
12493   bool Commuted = false;
12494   // FIXME: This should also accept a bitcast of a splat?  Be careful, not
12495   // 1,1,1,1 -> v8i16 though.
12496   BitVector UndefElements;
12497   if (auto *BVOp = dyn_cast<BuildVectorSDNode>(V1.getNode()))
12498     if (BVOp->getConstantSplatNode(&UndefElements) && UndefElements.none())
12499       V1IsSplat = true;
12500   if (auto *BVOp = dyn_cast<BuildVectorSDNode>(V2.getNode()))
12501     if (BVOp->getConstantSplatNode(&UndefElements) && UndefElements.none())
12502       V2IsSplat = true;
12503
12504   // Canonicalize the splat or undef, if present, to be on the RHS.
12505   if (!V2IsUndef && V1IsSplat && !V2IsSplat) {
12506     CommuteVectorShuffleMask(M, NumElems);
12507     std::swap(V1, V2);
12508     std::swap(V1IsSplat, V2IsSplat);
12509     Commuted = true;
12510   }
12511
12512   if (isCommutedMOVLMask(M, VT, V2IsSplat, V2IsUndef)) {
12513     // Shuffling low element of v1 into undef, just return v1.
12514     if (V2IsUndef)
12515       return V1;
12516     // If V2 is a splat, the mask may be malformed such as <4,3,3,3>, which
12517     // the instruction selector will not match, so get a canonical MOVL with
12518     // swapped operands to undo the commute.
12519     return getMOVL(DAG, dl, VT, V2, V1);
12520   }
12521
12522   if (isUNPCKLMask(M, VT, HasInt256))
12523     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
12524
12525   if (isUNPCKHMask(M, VT, HasInt256))
12526     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
12527
12528   if (V2IsSplat) {
12529     // Normalize mask so all entries that point to V2 points to its first
12530     // element then try to match unpck{h|l} again. If match, return a
12531     // new vector_shuffle with the corrected mask.p
12532     SmallVector<int, 8> NewMask(M.begin(), M.end());
12533     NormalizeMask(NewMask, NumElems);
12534     if (isUNPCKLMask(NewMask, VT, HasInt256, true))
12535       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
12536     if (isUNPCKHMask(NewMask, VT, HasInt256, true))
12537       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
12538   }
12539
12540   if (Commuted) {
12541     // Commute is back and try unpck* again.
12542     // FIXME: this seems wrong.
12543     CommuteVectorShuffleMask(M, NumElems);
12544     std::swap(V1, V2);
12545     std::swap(V1IsSplat, V2IsSplat);
12546
12547     if (isUNPCKLMask(M, VT, HasInt256))
12548       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
12549
12550     if (isUNPCKHMask(M, VT, HasInt256))
12551       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
12552   }
12553
12554   // Normalize the node to match x86 shuffle ops if needed
12555   if (!V2IsUndef && (isSHUFPMask(M, VT, /* Commuted */ true)))
12556     return DAG.getCommutedVectorShuffle(*SVOp);
12557
12558   // The checks below are all present in isShuffleMaskLegal, but they are
12559   // inlined here right now to enable us to directly emit target specific
12560   // nodes, and remove one by one until they don't return Op anymore.
12561
12562   if (ShuffleVectorSDNode::isSplatMask(&M[0], VT) &&
12563       SVOp->getSplatIndex() == 0 && V2IsUndef) {
12564     if (VT == MVT::v2f64 || VT == MVT::v2i64)
12565       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
12566   }
12567
12568   if (isPSHUFHWMask(M, VT, HasInt256))
12569     return getTargetShuffleNode(X86ISD::PSHUFHW, dl, VT, V1,
12570                                 getShufflePSHUFHWImmediate(SVOp),
12571                                 DAG);
12572
12573   if (isPSHUFLWMask(M, VT, HasInt256))
12574     return getTargetShuffleNode(X86ISD::PSHUFLW, dl, VT, V1,
12575                                 getShufflePSHUFLWImmediate(SVOp),
12576                                 DAG);
12577
12578   unsigned MaskValue;
12579   if (isBlendMask(M, VT, Subtarget->hasSSE41(), Subtarget->hasInt256(),
12580                   &MaskValue))
12581     return LowerVECTOR_SHUFFLEtoBlend(SVOp, MaskValue, Subtarget, DAG);
12582
12583   if (isSHUFPMask(M, VT))
12584     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V2,
12585                                 getShuffleSHUFImmediate(SVOp), DAG);
12586
12587   if (isUNPCKL_v_undef_Mask(M, VT, HasInt256))
12588     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
12589   if (isUNPCKH_v_undef_Mask(M, VT, HasInt256))
12590     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
12591
12592   //===--------------------------------------------------------------------===//
12593   // Generate target specific nodes for 128 or 256-bit shuffles only
12594   // supported in the AVX instruction set.
12595   //
12596
12597   // Handle VMOVDDUPY permutations
12598   if (V2IsUndef && isMOVDDUPYMask(M, VT, HasFp256))
12599     return getTargetShuffleNode(X86ISD::MOVDDUP, dl, VT, V1, DAG);
12600
12601   // Handle VPERMILPS/D* permutations
12602   if (isVPERMILPMask(M, VT)) {
12603     if ((HasInt256 && VT == MVT::v8i32) || VT == MVT::v16i32)
12604       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1,
12605                                   getShuffleSHUFImmediate(SVOp), DAG);
12606     return getTargetShuffleNode(X86ISD::VPERMILPI, dl, VT, V1,
12607                                 getShuffleSHUFImmediate(SVOp), DAG);
12608   }
12609
12610   unsigned Idx;
12611   if (VT.is512BitVector() && isINSERT64x4Mask(M, VT, &Idx))
12612     return Insert256BitVector(V1, Extract256BitVector(V2, 0, DAG, dl),
12613                               Idx*(NumElems/2), DAG, dl);
12614
12615   // Handle VPERM2F128/VPERM2I128 permutations
12616   if (isVPERM2X128Mask(M, VT, HasFp256))
12617     return getTargetShuffleNode(X86ISD::VPERM2X128, dl, VT, V1,
12618                                 V2, getShuffleVPERM2X128Immediate(SVOp), DAG);
12619
12620   if (Subtarget->hasSSE41() && isINSERTPSMask(M, VT))
12621     return getINSERTPS(SVOp, dl, DAG);
12622
12623   unsigned Imm8;
12624   if (V2IsUndef && HasInt256 && isPermImmMask(M, VT, Imm8))
12625     return getTargetShuffleNode(X86ISD::VPERMI, dl, VT, V1, Imm8, DAG);
12626
12627   if ((V2IsUndef && HasInt256 && VT.is256BitVector() && NumElems == 8) ||
12628       VT.is512BitVector()) {
12629     MVT MaskEltVT = MVT::getIntegerVT(VT.getVectorElementType().getSizeInBits());
12630     MVT MaskVectorVT = MVT::getVectorVT(MaskEltVT, NumElems);
12631     SmallVector<SDValue, 16> permclMask;
12632     for (unsigned i = 0; i != NumElems; ++i) {
12633       permclMask.push_back(DAG.getConstant((M[i]>=0) ? M[i] : 0, MaskEltVT));
12634     }
12635
12636     SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, MaskVectorVT, permclMask);
12637     if (V2IsUndef)
12638       // Bitcast is for VPERMPS since mask is v8i32 but node takes v8f32
12639       return DAG.getNode(X86ISD::VPERMV, dl, VT,
12640                           DAG.getNode(ISD::BITCAST, dl, VT, Mask), V1);
12641     return DAG.getNode(X86ISD::VPERMV3, dl, VT, V1,
12642                        DAG.getNode(ISD::BITCAST, dl, VT, Mask), V2);
12643   }
12644
12645   //===--------------------------------------------------------------------===//
12646   // Since no target specific shuffle was selected for this generic one,
12647   // lower it into other known shuffles. FIXME: this isn't true yet, but
12648   // this is the plan.
12649   //
12650
12651   // Handle v8i16 specifically since SSE can do byte extraction and insertion.
12652   if (VT == MVT::v8i16) {
12653     SDValue NewOp = LowerVECTOR_SHUFFLEv8i16(Op, Subtarget, DAG);
12654     if (NewOp.getNode())
12655       return NewOp;
12656   }
12657
12658   if (VT == MVT::v16i16 && Subtarget->hasInt256()) {
12659     SDValue NewOp = LowerVECTOR_SHUFFLEv16i16(Op, DAG);
12660     if (NewOp.getNode())
12661       return NewOp;
12662   }
12663
12664   if (VT == MVT::v16i8) {
12665     SDValue NewOp = LowerVECTOR_SHUFFLEv16i8(SVOp, Subtarget, DAG);
12666     if (NewOp.getNode())
12667       return NewOp;
12668   }
12669
12670   if (VT == MVT::v32i8) {
12671     SDValue NewOp = LowerVECTOR_SHUFFLEv32i8(SVOp, Subtarget, DAG);
12672     if (NewOp.getNode())
12673       return NewOp;
12674   }
12675
12676   // Handle all 128-bit wide vectors with 4 elements, and match them with
12677   // several different shuffle types.
12678   if (NumElems == 4 && VT.is128BitVector())
12679     return LowerVECTOR_SHUFFLE_128v4(SVOp, DAG);
12680
12681   // Handle general 256-bit shuffles
12682   if (VT.is256BitVector())
12683     return LowerVECTOR_SHUFFLE_256(SVOp, DAG);
12684
12685   return SDValue();
12686 }
12687
12688 // This function assumes its argument is a BUILD_VECTOR of constants or
12689 // undef SDNodes. i.e: ISD::isBuildVectorOfConstantSDNodes(BuildVector) is
12690 // true.
12691 static bool BUILD_VECTORtoBlendMask(BuildVectorSDNode *BuildVector,
12692                                     unsigned &MaskValue) {
12693   MaskValue = 0;
12694   unsigned NumElems = BuildVector->getNumOperands();
12695   // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
12696   unsigned NumLanes = (NumElems - 1) / 8 + 1;
12697   unsigned NumElemsInLane = NumElems / NumLanes;
12698
12699   // Blend for v16i16 should be symetric for the both lanes.
12700   for (unsigned i = 0; i < NumElemsInLane; ++i) {
12701     SDValue EltCond = BuildVector->getOperand(i);
12702     SDValue SndLaneEltCond =
12703         (NumLanes == 2) ? BuildVector->getOperand(i + NumElemsInLane) : EltCond;
12704
12705     int Lane1Cond = -1, Lane2Cond = -1;
12706     if (isa<ConstantSDNode>(EltCond))
12707       Lane1Cond = !isZero(EltCond);
12708     if (isa<ConstantSDNode>(SndLaneEltCond))
12709       Lane2Cond = !isZero(SndLaneEltCond);
12710
12711     if (Lane1Cond == Lane2Cond || Lane2Cond < 0)
12712       // Lane1Cond != 0, means we want the first argument.
12713       // Lane1Cond == 0, means we want the second argument.
12714       // The encoding of this argument is 0 for the first argument, 1
12715       // for the second. Therefore, invert the condition.
12716       MaskValue |= !Lane1Cond << i;
12717     else if (Lane1Cond < 0)
12718       MaskValue |= !Lane2Cond << i;
12719     else
12720       return false;
12721   }
12722   return true;
12723 }
12724
12725 /// \brief Try to lower a VSELECT instruction to an immediate-controlled blend
12726 /// instruction.
12727 static SDValue lowerVSELECTtoBLENDI(SDValue Op, const X86Subtarget *Subtarget,
12728                                     SelectionDAG &DAG) {
12729   SDValue Cond = Op.getOperand(0);
12730   SDValue LHS = Op.getOperand(1);
12731   SDValue RHS = Op.getOperand(2);
12732   SDLoc dl(Op);
12733   MVT VT = Op.getSimpleValueType();
12734   MVT EltVT = VT.getVectorElementType();
12735   unsigned NumElems = VT.getVectorNumElements();
12736
12737   // There is no blend with immediate in AVX-512.
12738   if (VT.is512BitVector())
12739     return SDValue();
12740
12741   if (!Subtarget->hasSSE41() || EltVT == MVT::i8)
12742     return SDValue();
12743   if (!Subtarget->hasInt256() && VT == MVT::v16i16)
12744     return SDValue();
12745
12746   if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
12747     return SDValue();
12748
12749   // Check the mask for BLEND and build the value.
12750   unsigned MaskValue = 0;
12751   if (!BUILD_VECTORtoBlendMask(cast<BuildVectorSDNode>(Cond), MaskValue))
12752     return SDValue();
12753
12754   // Convert i32 vectors to floating point if it is not AVX2.
12755   // AVX2 introduced VPBLENDD instruction for 128 and 256-bit vectors.
12756   MVT BlendVT = VT;
12757   if (EltVT == MVT::i64 || (EltVT == MVT::i32 && !Subtarget->hasInt256())) {
12758     BlendVT = MVT::getVectorVT(MVT::getFloatingPointVT(EltVT.getSizeInBits()),
12759                                NumElems);
12760     LHS = DAG.getNode(ISD::BITCAST, dl, VT, LHS);
12761     RHS = DAG.getNode(ISD::BITCAST, dl, VT, RHS);
12762   }
12763
12764   SDValue Ret = DAG.getNode(X86ISD::BLENDI, dl, BlendVT, LHS, RHS,
12765                             DAG.getConstant(MaskValue, MVT::i32));
12766   return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
12767 }
12768
12769 SDValue X86TargetLowering::LowerVSELECT(SDValue Op, SelectionDAG &DAG) const {
12770   // A vselect where all conditions and data are constants can be optimized into
12771   // a single vector load by SelectionDAGLegalize::ExpandBUILD_VECTOR().
12772   if (ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(0).getNode()) &&
12773       ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(1).getNode()) &&
12774       ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(2).getNode()))
12775     return SDValue();
12776
12777   SDValue BlendOp = lowerVSELECTtoBLENDI(Op, Subtarget, DAG);
12778   if (BlendOp.getNode())
12779     return BlendOp;
12780
12781   // Some types for vselect were previously set to Expand, not Legal or
12782   // Custom. Return an empty SDValue so we fall-through to Expand, after
12783   // the Custom lowering phase.
12784   MVT VT = Op.getSimpleValueType();
12785   switch (VT.SimpleTy) {
12786   default:
12787     break;
12788   case MVT::v8i16:
12789   case MVT::v16i16:
12790     if (Subtarget->hasBWI() && Subtarget->hasVLX())
12791       break;
12792     return SDValue();
12793   }
12794
12795   // We couldn't create a "Blend with immediate" node.
12796   // This node should still be legal, but we'll have to emit a blendv*
12797   // instruction.
12798   return Op;
12799 }
12800
12801 static SDValue LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG) {
12802   MVT VT = Op.getSimpleValueType();
12803   SDLoc dl(Op);
12804
12805   if (!Op.getOperand(0).getSimpleValueType().is128BitVector())
12806     return SDValue();
12807
12808   if (VT.getSizeInBits() == 8) {
12809     SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
12810                                   Op.getOperand(0), Op.getOperand(1));
12811     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
12812                                   DAG.getValueType(VT));
12813     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
12814   }
12815
12816   if (VT.getSizeInBits() == 16) {
12817     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
12818     // If Idx is 0, it's cheaper to do a move instead of a pextrw.
12819     if (Idx == 0)
12820       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
12821                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
12822                                      DAG.getNode(ISD::BITCAST, dl,
12823                                                  MVT::v4i32,
12824                                                  Op.getOperand(0)),
12825                                      Op.getOperand(1)));
12826     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
12827                                   Op.getOperand(0), Op.getOperand(1));
12828     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
12829                                   DAG.getValueType(VT));
12830     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
12831   }
12832
12833   if (VT == MVT::f32) {
12834     // EXTRACTPS outputs to a GPR32 register which will require a movd to copy
12835     // the result back to FR32 register. It's only worth matching if the
12836     // result has a single use which is a store or a bitcast to i32.  And in
12837     // the case of a store, it's not worth it if the index is a constant 0,
12838     // because a MOVSSmr can be used instead, which is smaller and faster.
12839     if (!Op.hasOneUse())
12840       return SDValue();
12841     SDNode *User = *Op.getNode()->use_begin();
12842     if ((User->getOpcode() != ISD::STORE ||
12843          (isa<ConstantSDNode>(Op.getOperand(1)) &&
12844           cast<ConstantSDNode>(Op.getOperand(1))->isNullValue())) &&
12845         (User->getOpcode() != ISD::BITCAST ||
12846          User->getValueType(0) != MVT::i32))
12847       return SDValue();
12848     SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
12849                                   DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
12850                                               Op.getOperand(0)),
12851                                               Op.getOperand(1));
12852     return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
12853   }
12854
12855   if (VT == MVT::i32 || VT == MVT::i64) {
12856     // ExtractPS/pextrq works with constant index.
12857     if (isa<ConstantSDNode>(Op.getOperand(1)))
12858       return Op;
12859   }
12860   return SDValue();
12861 }
12862
12863 /// Extract one bit from mask vector, like v16i1 or v8i1.
12864 /// AVX-512 feature.
12865 SDValue
12866 X86TargetLowering::ExtractBitFromMaskVector(SDValue Op, SelectionDAG &DAG) const {
12867   SDValue Vec = Op.getOperand(0);
12868   SDLoc dl(Vec);
12869   MVT VecVT = Vec.getSimpleValueType();
12870   SDValue Idx = Op.getOperand(1);
12871   MVT EltVT = Op.getSimpleValueType();
12872
12873   assert((EltVT == MVT::i1) && "Unexpected operands in ExtractBitFromMaskVector");
12874   assert((VecVT.getVectorNumElements() <= 16 || Subtarget->hasBWI()) &&
12875          "Unexpected vector type in ExtractBitFromMaskVector");
12876
12877   // variable index can't be handled in mask registers,
12878   // extend vector to VR512
12879   if (!isa<ConstantSDNode>(Idx)) {
12880     MVT ExtVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
12881     SDValue Ext = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, Vec);
12882     SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
12883                               ExtVT.getVectorElementType(), Ext, Idx);
12884     return DAG.getNode(ISD::TRUNCATE, dl, EltVT, Elt);
12885   }
12886
12887   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
12888   const TargetRegisterClass* rc = getRegClassFor(VecVT);
12889   if (!Subtarget->hasDQI() && (VecVT.getVectorNumElements() <= 8))
12890     rc = getRegClassFor(MVT::v16i1);
12891   unsigned MaxSift = rc->getSize()*8 - 1;
12892   Vec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, Vec,
12893                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
12894   Vec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, Vec,
12895                     DAG.getConstant(MaxSift, MVT::i8));
12896   return DAG.getNode(X86ISD::VEXTRACT, dl, MVT::i1, Vec,
12897                        DAG.getIntPtrConstant(0));
12898 }
12899
12900 SDValue
12901 X86TargetLowering::LowerEXTRACT_VECTOR_ELT(SDValue Op,
12902                                            SelectionDAG &DAG) const {
12903   SDLoc dl(Op);
12904   SDValue Vec = Op.getOperand(0);
12905   MVT VecVT = Vec.getSimpleValueType();
12906   SDValue Idx = Op.getOperand(1);
12907
12908   if (Op.getSimpleValueType() == MVT::i1)
12909     return ExtractBitFromMaskVector(Op, DAG);
12910
12911   if (!isa<ConstantSDNode>(Idx)) {
12912     if (VecVT.is512BitVector() ||
12913         (VecVT.is256BitVector() && Subtarget->hasInt256() &&
12914          VecVT.getVectorElementType().getSizeInBits() == 32)) {
12915
12916       MVT MaskEltVT =
12917         MVT::getIntegerVT(VecVT.getVectorElementType().getSizeInBits());
12918       MVT MaskVT = MVT::getVectorVT(MaskEltVT, VecVT.getSizeInBits() /
12919                                     MaskEltVT.getSizeInBits());
12920
12921       Idx = DAG.getZExtOrTrunc(Idx, dl, MaskEltVT);
12922       SDValue Mask = DAG.getNode(X86ISD::VINSERT, dl, MaskVT,
12923                                 getZeroVector(MaskVT, Subtarget, DAG, dl),
12924                                 Idx, DAG.getConstant(0, getPointerTy()));
12925       SDValue Perm = DAG.getNode(X86ISD::VPERMV, dl, VecVT, Mask, Vec);
12926       return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(),
12927                         Perm, DAG.getConstant(0, getPointerTy()));
12928     }
12929     return SDValue();
12930   }
12931
12932   // If this is a 256-bit vector result, first extract the 128-bit vector and
12933   // then extract the element from the 128-bit vector.
12934   if (VecVT.is256BitVector() || VecVT.is512BitVector()) {
12935
12936     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
12937     // Get the 128-bit vector.
12938     Vec = Extract128BitVector(Vec, IdxVal, DAG, dl);
12939     MVT EltVT = VecVT.getVectorElementType();
12940
12941     unsigned ElemsPerChunk = 128 / EltVT.getSizeInBits();
12942
12943     //if (IdxVal >= NumElems/2)
12944     //  IdxVal -= NumElems/2;
12945     IdxVal -= (IdxVal/ElemsPerChunk)*ElemsPerChunk;
12946     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
12947                        DAG.getConstant(IdxVal, MVT::i32));
12948   }
12949
12950   assert(VecVT.is128BitVector() && "Unexpected vector length");
12951
12952   if (Subtarget->hasSSE41()) {
12953     SDValue Res = LowerEXTRACT_VECTOR_ELT_SSE4(Op, DAG);
12954     if (Res.getNode())
12955       return Res;
12956   }
12957
12958   MVT VT = Op.getSimpleValueType();
12959   // TODO: handle v16i8.
12960   if (VT.getSizeInBits() == 16) {
12961     SDValue Vec = Op.getOperand(0);
12962     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
12963     if (Idx == 0)
12964       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
12965                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
12966                                      DAG.getNode(ISD::BITCAST, dl,
12967                                                  MVT::v4i32, Vec),
12968                                      Op.getOperand(1)));
12969     // Transform it so it match pextrw which produces a 32-bit result.
12970     MVT EltVT = MVT::i32;
12971     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
12972                                   Op.getOperand(0), Op.getOperand(1));
12973     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
12974                                   DAG.getValueType(VT));
12975     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
12976   }
12977
12978   if (VT.getSizeInBits() == 32) {
12979     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
12980     if (Idx == 0)
12981       return Op;
12982
12983     // SHUFPS the element to the lowest double word, then movss.
12984     int Mask[4] = { static_cast<int>(Idx), -1, -1, -1 };
12985     MVT VVT = Op.getOperand(0).getSimpleValueType();
12986     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
12987                                        DAG.getUNDEF(VVT), Mask);
12988     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
12989                        DAG.getIntPtrConstant(0));
12990   }
12991
12992   if (VT.getSizeInBits() == 64) {
12993     // FIXME: .td only matches this for <2 x f64>, not <2 x i64> on 32b
12994     // FIXME: seems like this should be unnecessary if mov{h,l}pd were taught
12995     //        to match extract_elt for f64.
12996     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
12997     if (Idx == 0)
12998       return Op;
12999
13000     // UNPCKHPD the element to the lowest double word, then movsd.
13001     // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
13002     // to a f64mem, the whole operation is folded into a single MOVHPDmr.
13003     int Mask[2] = { 1, -1 };
13004     MVT VVT = Op.getOperand(0).getSimpleValueType();
13005     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
13006                                        DAG.getUNDEF(VVT), Mask);
13007     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
13008                        DAG.getIntPtrConstant(0));
13009   }
13010
13011   return SDValue();
13012 }
13013
13014 /// Insert one bit to mask vector, like v16i1 or v8i1.
13015 /// AVX-512 feature.
13016 SDValue
13017 X86TargetLowering::InsertBitToMaskVector(SDValue Op, SelectionDAG &DAG) const {
13018   SDLoc dl(Op);
13019   SDValue Vec = Op.getOperand(0);
13020   SDValue Elt = Op.getOperand(1);
13021   SDValue Idx = Op.getOperand(2);
13022   MVT VecVT = Vec.getSimpleValueType();
13023
13024   if (!isa<ConstantSDNode>(Idx)) {
13025     // Non constant index. Extend source and destination,
13026     // insert element and then truncate the result.
13027     MVT ExtVecVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
13028     MVT ExtEltVT = (VecVT == MVT::v8i1 ?  MVT::i64 : MVT::i32);
13029     SDValue ExtOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, ExtVecVT,
13030       DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVecVT, Vec),
13031       DAG.getNode(ISD::ZERO_EXTEND, dl, ExtEltVT, Elt), Idx);
13032     return DAG.getNode(ISD::TRUNCATE, dl, VecVT, ExtOp);
13033   }
13034
13035   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13036   SDValue EltInVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Elt);
13037   if (Vec.getOpcode() == ISD::UNDEF)
13038     return DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
13039                        DAG.getConstant(IdxVal, MVT::i8));
13040   const TargetRegisterClass* rc = getRegClassFor(VecVT);
13041   unsigned MaxSift = rc->getSize()*8 - 1;
13042   EltInVec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
13043                     DAG.getConstant(MaxSift, MVT::i8));
13044   EltInVec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, EltInVec,
13045                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
13046   return DAG.getNode(ISD::OR, dl, VecVT, Vec, EltInVec);
13047 }
13048
13049 SDValue X86TargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op,
13050                                                   SelectionDAG &DAG) const {
13051   MVT VT = Op.getSimpleValueType();
13052   MVT EltVT = VT.getVectorElementType();
13053
13054   if (EltVT == MVT::i1)
13055     return InsertBitToMaskVector(Op, DAG);
13056
13057   SDLoc dl(Op);
13058   SDValue N0 = Op.getOperand(0);
13059   SDValue N1 = Op.getOperand(1);
13060   SDValue N2 = Op.getOperand(2);
13061   if (!isa<ConstantSDNode>(N2))
13062     return SDValue();
13063   auto *N2C = cast<ConstantSDNode>(N2);
13064   unsigned IdxVal = N2C->getZExtValue();
13065
13066   // If the vector is wider than 128 bits, extract the 128-bit subvector, insert
13067   // into that, and then insert the subvector back into the result.
13068   if (VT.is256BitVector() || VT.is512BitVector()) {
13069     // Get the desired 128-bit vector half.
13070     SDValue V = Extract128BitVector(N0, IdxVal, DAG, dl);
13071
13072     // Insert the element into the desired half.
13073     unsigned NumEltsIn128 = 128 / EltVT.getSizeInBits();
13074     unsigned IdxIn128 = IdxVal - (IdxVal / NumEltsIn128) * NumEltsIn128;
13075
13076     V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V, N1,
13077                     DAG.getConstant(IdxIn128, MVT::i32));
13078
13079     // Insert the changed part back to the 256-bit vector
13080     return Insert128BitVector(N0, V, IdxVal, DAG, dl);
13081   }
13082   assert(VT.is128BitVector() && "Only 128-bit vector types should be left!");
13083
13084   if (Subtarget->hasSSE41()) {
13085     if (EltVT.getSizeInBits() == 8 || EltVT.getSizeInBits() == 16) {
13086       unsigned Opc;
13087       if (VT == MVT::v8i16) {
13088         Opc = X86ISD::PINSRW;
13089       } else {
13090         assert(VT == MVT::v16i8);
13091         Opc = X86ISD::PINSRB;
13092       }
13093
13094       // Transform it so it match pinsr{b,w} which expects a GR32 as its second
13095       // argument.
13096       if (N1.getValueType() != MVT::i32)
13097         N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
13098       if (N2.getValueType() != MVT::i32)
13099         N2 = DAG.getIntPtrConstant(IdxVal);
13100       return DAG.getNode(Opc, dl, VT, N0, N1, N2);
13101     }
13102
13103     if (EltVT == MVT::f32) {
13104       // Bits [7:6] of the constant are the source select.  This will always be
13105       //  zero here.  The DAG Combiner may combine an extract_elt index into
13106       //  these
13107       //  bits.  For example (insert (extract, 3), 2) could be matched by
13108       //  putting
13109       //  the '3' into bits [7:6] of X86ISD::INSERTPS.
13110       // Bits [5:4] of the constant are the destination select.  This is the
13111       //  value of the incoming immediate.
13112       // Bits [3:0] of the constant are the zero mask.  The DAG Combiner may
13113       //   combine either bitwise AND or insert of float 0.0 to set these bits.
13114       N2 = DAG.getIntPtrConstant(IdxVal << 4);
13115       // Create this as a scalar to vector..
13116       N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
13117       return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
13118     }
13119
13120     if (EltVT == MVT::i32 || EltVT == MVT::i64) {
13121       // PINSR* works with constant index.
13122       return Op;
13123     }
13124   }
13125
13126   if (EltVT == MVT::i8)
13127     return SDValue();
13128
13129   if (EltVT.getSizeInBits() == 16) {
13130     // Transform it so it match pinsrw which expects a 16-bit value in a GR32
13131     // as its second argument.
13132     if (N1.getValueType() != MVT::i32)
13133       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
13134     if (N2.getValueType() != MVT::i32)
13135       N2 = DAG.getIntPtrConstant(IdxVal);
13136     return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
13137   }
13138   return SDValue();
13139 }
13140
13141 static SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) {
13142   SDLoc dl(Op);
13143   MVT OpVT = Op.getSimpleValueType();
13144
13145   // If this is a 256-bit vector result, first insert into a 128-bit
13146   // vector and then insert into the 256-bit vector.
13147   if (!OpVT.is128BitVector()) {
13148     // Insert into a 128-bit vector.
13149     unsigned SizeFactor = OpVT.getSizeInBits()/128;
13150     MVT VT128 = MVT::getVectorVT(OpVT.getVectorElementType(),
13151                                  OpVT.getVectorNumElements() / SizeFactor);
13152
13153     Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
13154
13155     // Insert the 128-bit vector.
13156     return Insert128BitVector(DAG.getUNDEF(OpVT), Op, 0, DAG, dl);
13157   }
13158
13159   if (OpVT == MVT::v1i64 &&
13160       Op.getOperand(0).getValueType() == MVT::i64)
13161     return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
13162
13163   SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
13164   assert(OpVT.is128BitVector() && "Expected an SSE type!");
13165   return DAG.getNode(ISD::BITCAST, dl, OpVT,
13166                      DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
13167 }
13168
13169 // Lower a node with an EXTRACT_SUBVECTOR opcode.  This may result in
13170 // a simple subregister reference or explicit instructions to grab
13171 // upper bits of a vector.
13172 static SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
13173                                       SelectionDAG &DAG) {
13174   SDLoc dl(Op);
13175   SDValue In =  Op.getOperand(0);
13176   SDValue Idx = Op.getOperand(1);
13177   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13178   MVT ResVT   = Op.getSimpleValueType();
13179   MVT InVT    = In.getSimpleValueType();
13180
13181   if (Subtarget->hasFp256()) {
13182     if (ResVT.is128BitVector() &&
13183         (InVT.is256BitVector() || InVT.is512BitVector()) &&
13184         isa<ConstantSDNode>(Idx)) {
13185       return Extract128BitVector(In, IdxVal, DAG, dl);
13186     }
13187     if (ResVT.is256BitVector() && InVT.is512BitVector() &&
13188         isa<ConstantSDNode>(Idx)) {
13189       return Extract256BitVector(In, IdxVal, DAG, dl);
13190     }
13191   }
13192   return SDValue();
13193 }
13194
13195 // Lower a node with an INSERT_SUBVECTOR opcode.  This may result in a
13196 // simple superregister reference or explicit instructions to insert
13197 // the upper bits of a vector.
13198 static SDValue LowerINSERT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
13199                                      SelectionDAG &DAG) {
13200   if (Subtarget->hasFp256()) {
13201     SDLoc dl(Op.getNode());
13202     SDValue Vec = Op.getNode()->getOperand(0);
13203     SDValue SubVec = Op.getNode()->getOperand(1);
13204     SDValue Idx = Op.getNode()->getOperand(2);
13205
13206     if ((Op.getNode()->getSimpleValueType(0).is256BitVector() ||
13207          Op.getNode()->getSimpleValueType(0).is512BitVector()) &&
13208         SubVec.getNode()->getSimpleValueType(0).is128BitVector() &&
13209         isa<ConstantSDNode>(Idx)) {
13210       unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13211       return Insert128BitVector(Vec, SubVec, IdxVal, DAG, dl);
13212     }
13213
13214     if (Op.getNode()->getSimpleValueType(0).is512BitVector() &&
13215         SubVec.getNode()->getSimpleValueType(0).is256BitVector() &&
13216         isa<ConstantSDNode>(Idx)) {
13217       unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
13218       return Insert256BitVector(Vec, SubVec, IdxVal, DAG, dl);
13219     }
13220   }
13221   return SDValue();
13222 }
13223
13224 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
13225 // their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is
13226 // one of the above mentioned nodes. It has to be wrapped because otherwise
13227 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
13228 // be used to form addressing mode. These wrapped nodes will be selected
13229 // into MOV32ri.
13230 SDValue
13231 X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
13232   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
13233
13234   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13235   // global base reg.
13236   unsigned char OpFlag = 0;
13237   unsigned WrapperKind = X86ISD::Wrapper;
13238   CodeModel::Model M = DAG.getTarget().getCodeModel();
13239
13240   if (Subtarget->isPICStyleRIPRel() &&
13241       (M == CodeModel::Small || M == CodeModel::Kernel))
13242     WrapperKind = X86ISD::WrapperRIP;
13243   else if (Subtarget->isPICStyleGOT())
13244     OpFlag = X86II::MO_GOTOFF;
13245   else if (Subtarget->isPICStyleStubPIC())
13246     OpFlag = X86II::MO_PIC_BASE_OFFSET;
13247
13248   SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(), getPointerTy(),
13249                                              CP->getAlignment(),
13250                                              CP->getOffset(), OpFlag);
13251   SDLoc DL(CP);
13252   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13253   // With PIC, the address is actually $g + Offset.
13254   if (OpFlag) {
13255     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13256                          DAG.getNode(X86ISD::GlobalBaseReg,
13257                                      SDLoc(), getPointerTy()),
13258                          Result);
13259   }
13260
13261   return Result;
13262 }
13263
13264 SDValue X86TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
13265   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
13266
13267   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13268   // global base reg.
13269   unsigned char OpFlag = 0;
13270   unsigned WrapperKind = X86ISD::Wrapper;
13271   CodeModel::Model M = DAG.getTarget().getCodeModel();
13272
13273   if (Subtarget->isPICStyleRIPRel() &&
13274       (M == CodeModel::Small || M == CodeModel::Kernel))
13275     WrapperKind = X86ISD::WrapperRIP;
13276   else if (Subtarget->isPICStyleGOT())
13277     OpFlag = X86II::MO_GOTOFF;
13278   else if (Subtarget->isPICStyleStubPIC())
13279     OpFlag = X86II::MO_PIC_BASE_OFFSET;
13280
13281   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy(),
13282                                           OpFlag);
13283   SDLoc DL(JT);
13284   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13285
13286   // With PIC, the address is actually $g + Offset.
13287   if (OpFlag)
13288     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13289                          DAG.getNode(X86ISD::GlobalBaseReg,
13290                                      SDLoc(), getPointerTy()),
13291                          Result);
13292
13293   return Result;
13294 }
13295
13296 SDValue
13297 X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const {
13298   const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
13299
13300   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13301   // global base reg.
13302   unsigned char OpFlag = 0;
13303   unsigned WrapperKind = X86ISD::Wrapper;
13304   CodeModel::Model M = DAG.getTarget().getCodeModel();
13305
13306   if (Subtarget->isPICStyleRIPRel() &&
13307       (M == CodeModel::Small || M == CodeModel::Kernel)) {
13308     if (Subtarget->isTargetDarwin() || Subtarget->isTargetELF())
13309       OpFlag = X86II::MO_GOTPCREL;
13310     WrapperKind = X86ISD::WrapperRIP;
13311   } else if (Subtarget->isPICStyleGOT()) {
13312     OpFlag = X86II::MO_GOT;
13313   } else if (Subtarget->isPICStyleStubPIC()) {
13314     OpFlag = X86II::MO_DARWIN_NONLAZY_PIC_BASE;
13315   } else if (Subtarget->isPICStyleStubNoDynamic()) {
13316     OpFlag = X86II::MO_DARWIN_NONLAZY;
13317   }
13318
13319   SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlag);
13320
13321   SDLoc DL(Op);
13322   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13323
13324   // With PIC, the address is actually $g + Offset.
13325   if (DAG.getTarget().getRelocationModel() == Reloc::PIC_ &&
13326       !Subtarget->is64Bit()) {
13327     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13328                          DAG.getNode(X86ISD::GlobalBaseReg,
13329                                      SDLoc(), getPointerTy()),
13330                          Result);
13331   }
13332
13333   // For symbols that require a load from a stub to get the address, emit the
13334   // load.
13335   if (isGlobalStubReference(OpFlag))
13336     Result = DAG.getLoad(getPointerTy(), DL, DAG.getEntryNode(), Result,
13337                          MachinePointerInfo::getGOT(), false, false, false, 0);
13338
13339   return Result;
13340 }
13341
13342 SDValue
13343 X86TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
13344   // Create the TargetBlockAddressAddress node.
13345   unsigned char OpFlags =
13346     Subtarget->ClassifyBlockAddressReference();
13347   CodeModel::Model M = DAG.getTarget().getCodeModel();
13348   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
13349   int64_t Offset = cast<BlockAddressSDNode>(Op)->getOffset();
13350   SDLoc dl(Op);
13351   SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy(), Offset,
13352                                              OpFlags);
13353
13354   if (Subtarget->isPICStyleRIPRel() &&
13355       (M == CodeModel::Small || M == CodeModel::Kernel))
13356     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
13357   else
13358     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
13359
13360   // With PIC, the address is actually $g + Offset.
13361   if (isGlobalRelativeToPICBase(OpFlags)) {
13362     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
13363                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
13364                          Result);
13365   }
13366
13367   return Result;
13368 }
13369
13370 SDValue
13371 X86TargetLowering::LowerGlobalAddress(const GlobalValue *GV, SDLoc dl,
13372                                       int64_t Offset, SelectionDAG &DAG) const {
13373   // Create the TargetGlobalAddress node, folding in the constant
13374   // offset if it is legal.
13375   unsigned char OpFlags =
13376       Subtarget->ClassifyGlobalReference(GV, DAG.getTarget());
13377   CodeModel::Model M = DAG.getTarget().getCodeModel();
13378   SDValue Result;
13379   if (OpFlags == X86II::MO_NO_FLAG &&
13380       X86::isOffsetSuitableForCodeModel(Offset, M)) {
13381     // A direct static reference to a global.
13382     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
13383     Offset = 0;
13384   } else {
13385     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
13386   }
13387
13388   if (Subtarget->isPICStyleRIPRel() &&
13389       (M == CodeModel::Small || M == CodeModel::Kernel))
13390     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
13391   else
13392     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
13393
13394   // With PIC, the address is actually $g + Offset.
13395   if (isGlobalRelativeToPICBase(OpFlags)) {
13396     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
13397                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
13398                          Result);
13399   }
13400
13401   // For globals that require a load from a stub to get the address, emit the
13402   // load.
13403   if (isGlobalStubReference(OpFlags))
13404     Result = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Result,
13405                          MachinePointerInfo::getGOT(), false, false, false, 0);
13406
13407   // If there was a non-zero offset that we didn't fold, create an explicit
13408   // addition for it.
13409   if (Offset != 0)
13410     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
13411                          DAG.getConstant(Offset, getPointerTy()));
13412
13413   return Result;
13414 }
13415
13416 SDValue
13417 X86TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
13418   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
13419   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
13420   return LowerGlobalAddress(GV, SDLoc(Op), Offset, DAG);
13421 }
13422
13423 static SDValue
13424 GetTLSADDR(SelectionDAG &DAG, SDValue Chain, GlobalAddressSDNode *GA,
13425            SDValue *InFlag, const EVT PtrVT, unsigned ReturnReg,
13426            unsigned char OperandFlags, bool LocalDynamic = false) {
13427   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
13428   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
13429   SDLoc dl(GA);
13430   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
13431                                            GA->getValueType(0),
13432                                            GA->getOffset(),
13433                                            OperandFlags);
13434
13435   X86ISD::NodeType CallType = LocalDynamic ? X86ISD::TLSBASEADDR
13436                                            : X86ISD::TLSADDR;
13437
13438   if (InFlag) {
13439     SDValue Ops[] = { Chain,  TGA, *InFlag };
13440     Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
13441   } else {
13442     SDValue Ops[]  = { Chain, TGA };
13443     Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
13444   }
13445
13446   // TLSADDR will be codegen'ed as call. Inform MFI that function has calls.
13447   MFI->setAdjustsStack(true);
13448   MFI->setHasCalls(true);
13449
13450   SDValue Flag = Chain.getValue(1);
13451   return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Flag);
13452 }
13453
13454 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 32 bit
13455 static SDValue
13456 LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13457                                 const EVT PtrVT) {
13458   SDValue InFlag;
13459   SDLoc dl(GA);  // ? function entry point might be better
13460   SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
13461                                    DAG.getNode(X86ISD::GlobalBaseReg,
13462                                                SDLoc(), PtrVT), InFlag);
13463   InFlag = Chain.getValue(1);
13464
13465   return GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX, X86II::MO_TLSGD);
13466 }
13467
13468 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 64 bit
13469 static SDValue
13470 LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13471                                 const EVT PtrVT) {
13472   return GetTLSADDR(DAG, DAG.getEntryNode(), GA, nullptr, PtrVT,
13473                     X86::RAX, X86II::MO_TLSGD);
13474 }
13475
13476 static SDValue LowerToTLSLocalDynamicModel(GlobalAddressSDNode *GA,
13477                                            SelectionDAG &DAG,
13478                                            const EVT PtrVT,
13479                                            bool is64Bit) {
13480   SDLoc dl(GA);
13481
13482   // Get the start address of the TLS block for this module.
13483   X86MachineFunctionInfo* MFI = DAG.getMachineFunction()
13484       .getInfo<X86MachineFunctionInfo>();
13485   MFI->incNumLocalDynamicTLSAccesses();
13486
13487   SDValue Base;
13488   if (is64Bit) {
13489     Base = GetTLSADDR(DAG, DAG.getEntryNode(), GA, nullptr, PtrVT, X86::RAX,
13490                       X86II::MO_TLSLD, /*LocalDynamic=*/true);
13491   } else {
13492     SDValue InFlag;
13493     SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
13494         DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT), InFlag);
13495     InFlag = Chain.getValue(1);
13496     Base = GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX,
13497                       X86II::MO_TLSLDM, /*LocalDynamic=*/true);
13498   }
13499
13500   // Note: the CleanupLocalDynamicTLSPass will remove redundant computations
13501   // of Base.
13502
13503   // Build x@dtpoff.
13504   unsigned char OperandFlags = X86II::MO_DTPOFF;
13505   unsigned WrapperKind = X86ISD::Wrapper;
13506   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
13507                                            GA->getValueType(0),
13508                                            GA->getOffset(), OperandFlags);
13509   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
13510
13511   // Add x@dtpoff with the base.
13512   return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
13513 }
13514
13515 // Lower ISD::GlobalTLSAddress using the "initial exec" or "local exec" model.
13516 static SDValue LowerToTLSExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG,
13517                                    const EVT PtrVT, TLSModel::Model model,
13518                                    bool is64Bit, bool isPIC) {
13519   SDLoc dl(GA);
13520
13521   // Get the Thread Pointer, which is %gs:0 (32-bit) or %fs:0 (64-bit).
13522   Value *Ptr = Constant::getNullValue(Type::getInt8PtrTy(*DAG.getContext(),
13523                                                          is64Bit ? 257 : 256));
13524
13525   SDValue ThreadPointer =
13526       DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), DAG.getIntPtrConstant(0),
13527                   MachinePointerInfo(Ptr), false, false, false, 0);
13528
13529   unsigned char OperandFlags = 0;
13530   // Most TLS accesses are not RIP relative, even on x86-64.  One exception is
13531   // initialexec.
13532   unsigned WrapperKind = X86ISD::Wrapper;
13533   if (model == TLSModel::LocalExec) {
13534     OperandFlags = is64Bit ? X86II::MO_TPOFF : X86II::MO_NTPOFF;
13535   } else if (model == TLSModel::InitialExec) {
13536     if (is64Bit) {
13537       OperandFlags = X86II::MO_GOTTPOFF;
13538       WrapperKind = X86ISD::WrapperRIP;
13539     } else {
13540       OperandFlags = isPIC ? X86II::MO_GOTNTPOFF : X86II::MO_INDNTPOFF;
13541     }
13542   } else {
13543     llvm_unreachable("Unexpected model");
13544   }
13545
13546   // emit "addl x@ntpoff,%eax" (local exec)
13547   // or "addl x@indntpoff,%eax" (initial exec)
13548   // or "addl x@gotntpoff(%ebx) ,%eax" (initial exec, 32-bit pic)
13549   SDValue TGA =
13550       DAG.getTargetGlobalAddress(GA->getGlobal(), dl, GA->getValueType(0),
13551                                  GA->getOffset(), OperandFlags);
13552   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
13553
13554   if (model == TLSModel::InitialExec) {
13555     if (isPIC && !is64Bit) {
13556       Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
13557                            DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT),
13558                            Offset);
13559     }
13560
13561     Offset = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Offset,
13562                          MachinePointerInfo::getGOT(), false, false, false, 0);
13563   }
13564
13565   // The address of the thread local variable is the add of the thread
13566   // pointer with the offset of the variable.
13567   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
13568 }
13569
13570 SDValue
13571 X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
13572
13573   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
13574   const GlobalValue *GV = GA->getGlobal();
13575
13576   if (Subtarget->isTargetELF()) {
13577     TLSModel::Model model = DAG.getTarget().getTLSModel(GV);
13578
13579     switch (model) {
13580       case TLSModel::GeneralDynamic:
13581         if (Subtarget->is64Bit())
13582           return LowerToTLSGeneralDynamicModel64(GA, DAG, getPointerTy());
13583         return LowerToTLSGeneralDynamicModel32(GA, DAG, getPointerTy());
13584       case TLSModel::LocalDynamic:
13585         return LowerToTLSLocalDynamicModel(GA, DAG, getPointerTy(),
13586                                            Subtarget->is64Bit());
13587       case TLSModel::InitialExec:
13588       case TLSModel::LocalExec:
13589         return LowerToTLSExecModel(
13590             GA, DAG, getPointerTy(), model, Subtarget->is64Bit(),
13591             DAG.getTarget().getRelocationModel() == Reloc::PIC_);
13592     }
13593     llvm_unreachable("Unknown TLS model.");
13594   }
13595
13596   if (Subtarget->isTargetDarwin()) {
13597     // Darwin only has one model of TLS.  Lower to that.
13598     unsigned char OpFlag = 0;
13599     unsigned WrapperKind = Subtarget->isPICStyleRIPRel() ?
13600                            X86ISD::WrapperRIP : X86ISD::Wrapper;
13601
13602     // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
13603     // global base reg.
13604     bool PIC32 = (DAG.getTarget().getRelocationModel() == Reloc::PIC_) &&
13605                  !Subtarget->is64Bit();
13606     if (PIC32)
13607       OpFlag = X86II::MO_TLVP_PIC_BASE;
13608     else
13609       OpFlag = X86II::MO_TLVP;
13610     SDLoc DL(Op);
13611     SDValue Result = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
13612                                                 GA->getValueType(0),
13613                                                 GA->getOffset(), OpFlag);
13614     SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
13615
13616     // With PIC32, the address is actually $g + Offset.
13617     if (PIC32)
13618       Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13619                            DAG.getNode(X86ISD::GlobalBaseReg,
13620                                        SDLoc(), getPointerTy()),
13621                            Offset);
13622
13623     // Lowering the machine isd will make sure everything is in the right
13624     // location.
13625     SDValue Chain = DAG.getEntryNode();
13626     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
13627     SDValue Args[] = { Chain, Offset };
13628     Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args);
13629
13630     // TLSCALL will be codegen'ed as call. Inform MFI that function has calls.
13631     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
13632     MFI->setAdjustsStack(true);
13633
13634     // And our return value (tls address) is in the standard call return value
13635     // location.
13636     unsigned Reg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
13637     return DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy(),
13638                               Chain.getValue(1));
13639   }
13640
13641   if (Subtarget->isTargetKnownWindowsMSVC() ||
13642       Subtarget->isTargetWindowsGNU()) {
13643     // Just use the implicit TLS architecture
13644     // Need to generate someting similar to:
13645     //   mov     rdx, qword [gs:abs 58H]; Load pointer to ThreadLocalStorage
13646     //                                  ; from TEB
13647     //   mov     ecx, dword [rel _tls_index]: Load index (from C runtime)
13648     //   mov     rcx, qword [rdx+rcx*8]
13649     //   mov     eax, .tls$:tlsvar
13650     //   [rax+rcx] contains the address
13651     // Windows 64bit: gs:0x58
13652     // Windows 32bit: fs:__tls_array
13653
13654     SDLoc dl(GA);
13655     SDValue Chain = DAG.getEntryNode();
13656
13657     // Get the Thread Pointer, which is %fs:__tls_array (32-bit) or
13658     // %gs:0x58 (64-bit). On MinGW, __tls_array is not available, so directly
13659     // use its literal value of 0x2C.
13660     Value *Ptr = Constant::getNullValue(Subtarget->is64Bit()
13661                                         ? Type::getInt8PtrTy(*DAG.getContext(),
13662                                                              256)
13663                                         : Type::getInt32PtrTy(*DAG.getContext(),
13664                                                               257));
13665
13666     SDValue TlsArray =
13667         Subtarget->is64Bit()
13668             ? DAG.getIntPtrConstant(0x58)
13669             : (Subtarget->isTargetWindowsGNU()
13670                    ? DAG.getIntPtrConstant(0x2C)
13671                    : DAG.getExternalSymbol("_tls_array", getPointerTy()));
13672
13673     SDValue ThreadPointer =
13674         DAG.getLoad(getPointerTy(), dl, Chain, TlsArray,
13675                     MachinePointerInfo(Ptr), false, false, false, 0);
13676
13677     // Load the _tls_index variable
13678     SDValue IDX = DAG.getExternalSymbol("_tls_index", getPointerTy());
13679     if (Subtarget->is64Bit())
13680       IDX = DAG.getExtLoad(ISD::ZEXTLOAD, dl, getPointerTy(), Chain,
13681                            IDX, MachinePointerInfo(), MVT::i32,
13682                            false, false, false, 0);
13683     else
13684       IDX = DAG.getLoad(getPointerTy(), dl, Chain, IDX, MachinePointerInfo(),
13685                         false, false, false, 0);
13686
13687     SDValue Scale = DAG.getConstant(Log2_64_Ceil(TD->getPointerSize()),
13688                                     getPointerTy());
13689     IDX = DAG.getNode(ISD::SHL, dl, getPointerTy(), IDX, Scale);
13690
13691     SDValue res = DAG.getNode(ISD::ADD, dl, getPointerTy(), ThreadPointer, IDX);
13692     res = DAG.getLoad(getPointerTy(), dl, Chain, res, MachinePointerInfo(),
13693                       false, false, false, 0);
13694
13695     // Get the offset of start of .tls section
13696     SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
13697                                              GA->getValueType(0),
13698                                              GA->getOffset(), X86II::MO_SECREL);
13699     SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), TGA);
13700
13701     // The address of the thread local variable is the add of the thread
13702     // pointer with the offset of the variable.
13703     return DAG.getNode(ISD::ADD, dl, getPointerTy(), res, Offset);
13704   }
13705
13706   llvm_unreachable("TLS not implemented for this target.");
13707 }
13708
13709 /// LowerShiftParts - Lower SRA_PARTS and friends, which return two i32 values
13710 /// and take a 2 x i32 value to shift plus a shift amount.
13711 static SDValue LowerShiftParts(SDValue Op, SelectionDAG &DAG) {
13712   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
13713   MVT VT = Op.getSimpleValueType();
13714   unsigned VTBits = VT.getSizeInBits();
13715   SDLoc dl(Op);
13716   bool isSRA = Op.getOpcode() == ISD::SRA_PARTS;
13717   SDValue ShOpLo = Op.getOperand(0);
13718   SDValue ShOpHi = Op.getOperand(1);
13719   SDValue ShAmt  = Op.getOperand(2);
13720   // X86ISD::SHLD and X86ISD::SHRD have defined overflow behavior but the
13721   // generic ISD nodes haven't. Insert an AND to be safe, it's optimized away
13722   // during isel.
13723   SDValue SafeShAmt = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
13724                                   DAG.getConstant(VTBits - 1, MVT::i8));
13725   SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
13726                                      DAG.getConstant(VTBits - 1, MVT::i8))
13727                        : DAG.getConstant(0, VT);
13728
13729   SDValue Tmp2, Tmp3;
13730   if (Op.getOpcode() == ISD::SHL_PARTS) {
13731     Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
13732     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, SafeShAmt);
13733   } else {
13734     Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
13735     Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, SafeShAmt);
13736   }
13737
13738   // If the shift amount is larger or equal than the width of a part we can't
13739   // rely on the results of shld/shrd. Insert a test and select the appropriate
13740   // values for large shift amounts.
13741   SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
13742                                 DAG.getConstant(VTBits, MVT::i8));
13743   SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
13744                              AndNode, DAG.getConstant(0, MVT::i8));
13745
13746   SDValue Hi, Lo;
13747   SDValue CC = DAG.getConstant(X86::COND_NE, MVT::i8);
13748   SDValue Ops0[4] = { Tmp2, Tmp3, CC, Cond };
13749   SDValue Ops1[4] = { Tmp3, Tmp1, CC, Cond };
13750
13751   if (Op.getOpcode() == ISD::SHL_PARTS) {
13752     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
13753     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
13754   } else {
13755     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
13756     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
13757   }
13758
13759   SDValue Ops[2] = { Lo, Hi };
13760   return DAG.getMergeValues(Ops, dl);
13761 }
13762
13763 SDValue X86TargetLowering::LowerSINT_TO_FP(SDValue Op,
13764                                            SelectionDAG &DAG) const {
13765   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
13766   SDLoc dl(Op);
13767
13768   if (SrcVT.isVector()) {
13769     if (SrcVT.getVectorElementType() == MVT::i1) {
13770       MVT IntegerVT = MVT::getVectorVT(MVT::i32, SrcVT.getVectorNumElements());
13771       return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
13772                          DAG.getNode(ISD::SIGN_EXTEND, dl, IntegerVT,
13773                                      Op.getOperand(0)));
13774     }
13775     return SDValue();
13776   }
13777
13778   assert(SrcVT <= MVT::i64 && SrcVT >= MVT::i16 &&
13779          "Unknown SINT_TO_FP to lower!");
13780
13781   // These are really Legal; return the operand so the caller accepts it as
13782   // Legal.
13783   if (SrcVT == MVT::i32 && isScalarFPTypeInSSEReg(Op.getValueType()))
13784     return Op;
13785   if (SrcVT == MVT::i64 && isScalarFPTypeInSSEReg(Op.getValueType()) &&
13786       Subtarget->is64Bit()) {
13787     return Op;
13788   }
13789
13790   unsigned Size = SrcVT.getSizeInBits()/8;
13791   MachineFunction &MF = DAG.getMachineFunction();
13792   int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size, false);
13793   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
13794   SDValue Chain = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
13795                                StackSlot,
13796                                MachinePointerInfo::getFixedStack(SSFI),
13797                                false, false, 0);
13798   return BuildFILD(Op, SrcVT, Chain, StackSlot, DAG);
13799 }
13800
13801 SDValue X86TargetLowering::BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain,
13802                                      SDValue StackSlot,
13803                                      SelectionDAG &DAG) const {
13804   // Build the FILD
13805   SDLoc DL(Op);
13806   SDVTList Tys;
13807   bool useSSE = isScalarFPTypeInSSEReg(Op.getValueType());
13808   if (useSSE)
13809     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Glue);
13810   else
13811     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
13812
13813   unsigned ByteSize = SrcVT.getSizeInBits()/8;
13814
13815   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(StackSlot);
13816   MachineMemOperand *MMO;
13817   if (FI) {
13818     int SSFI = FI->getIndex();
13819     MMO =
13820       DAG.getMachineFunction()
13821       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
13822                             MachineMemOperand::MOLoad, ByteSize, ByteSize);
13823   } else {
13824     MMO = cast<LoadSDNode>(StackSlot)->getMemOperand();
13825     StackSlot = StackSlot.getOperand(1);
13826   }
13827   SDValue Ops[] = { Chain, StackSlot, DAG.getValueType(SrcVT) };
13828   SDValue Result = DAG.getMemIntrinsicNode(useSSE ? X86ISD::FILD_FLAG :
13829                                            X86ISD::FILD, DL,
13830                                            Tys, Ops, SrcVT, MMO);
13831
13832   if (useSSE) {
13833     Chain = Result.getValue(1);
13834     SDValue InFlag = Result.getValue(2);
13835
13836     // FIXME: Currently the FST is flagged to the FILD_FLAG. This
13837     // shouldn't be necessary except that RFP cannot be live across
13838     // multiple blocks. When stackifier is fixed, they can be uncoupled.
13839     MachineFunction &MF = DAG.getMachineFunction();
13840     unsigned SSFISize = Op.getValueType().getSizeInBits()/8;
13841     int SSFI = MF.getFrameInfo()->CreateStackObject(SSFISize, SSFISize, false);
13842     SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
13843     Tys = DAG.getVTList(MVT::Other);
13844     SDValue Ops[] = {
13845       Chain, Result, StackSlot, DAG.getValueType(Op.getValueType()), InFlag
13846     };
13847     MachineMemOperand *MMO =
13848       DAG.getMachineFunction()
13849       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
13850                             MachineMemOperand::MOStore, SSFISize, SSFISize);
13851
13852     Chain = DAG.getMemIntrinsicNode(X86ISD::FST, DL, Tys,
13853                                     Ops, Op.getValueType(), MMO);
13854     Result = DAG.getLoad(Op.getValueType(), DL, Chain, StackSlot,
13855                          MachinePointerInfo::getFixedStack(SSFI),
13856                          false, false, false, 0);
13857   }
13858
13859   return Result;
13860 }
13861
13862 // LowerUINT_TO_FP_i64 - 64-bit unsigned integer to double expansion.
13863 SDValue X86TargetLowering::LowerUINT_TO_FP_i64(SDValue Op,
13864                                                SelectionDAG &DAG) const {
13865   // This algorithm is not obvious. Here it is what we're trying to output:
13866   /*
13867      movq       %rax,  %xmm0
13868      punpckldq  (c0),  %xmm0  // c0: (uint4){ 0x43300000U, 0x45300000U, 0U, 0U }
13869      subpd      (c1),  %xmm0  // c1: (double2){ 0x1.0p52, 0x1.0p52 * 0x1.0p32 }
13870      #ifdef __SSE3__
13871        haddpd   %xmm0, %xmm0
13872      #else
13873        pshufd   $0x4e, %xmm0, %xmm1
13874        addpd    %xmm1, %xmm0
13875      #endif
13876   */
13877
13878   SDLoc dl(Op);
13879   LLVMContext *Context = DAG.getContext();
13880
13881   // Build some magic constants.
13882   static const uint32_t CV0[] = { 0x43300000, 0x45300000, 0, 0 };
13883   Constant *C0 = ConstantDataVector::get(*Context, CV0);
13884   SDValue CPIdx0 = DAG.getConstantPool(C0, getPointerTy(), 16);
13885
13886   SmallVector<Constant*,2> CV1;
13887   CV1.push_back(
13888     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
13889                                       APInt(64, 0x4330000000000000ULL))));
13890   CV1.push_back(
13891     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
13892                                       APInt(64, 0x4530000000000000ULL))));
13893   Constant *C1 = ConstantVector::get(CV1);
13894   SDValue CPIdx1 = DAG.getConstantPool(C1, getPointerTy(), 16);
13895
13896   // Load the 64-bit value into an XMM register.
13897   SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
13898                             Op.getOperand(0));
13899   SDValue CLod0 = DAG.getLoad(MVT::v4i32, dl, DAG.getEntryNode(), CPIdx0,
13900                               MachinePointerInfo::getConstantPool(),
13901                               false, false, false, 16);
13902   SDValue Unpck1 = getUnpackl(DAG, dl, MVT::v4i32,
13903                               DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, XR1),
13904                               CLod0);
13905
13906   SDValue CLod1 = DAG.getLoad(MVT::v2f64, dl, CLod0.getValue(1), CPIdx1,
13907                               MachinePointerInfo::getConstantPool(),
13908                               false, false, false, 16);
13909   SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck1);
13910   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
13911   SDValue Result;
13912
13913   if (Subtarget->hasSSE3()) {
13914     // FIXME: The 'haddpd' instruction may be slower than 'movhlps + addsd'.
13915     Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
13916   } else {
13917     SDValue S2F = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Sub);
13918     SDValue Shuffle = getTargetShuffleNode(X86ISD::PSHUFD, dl, MVT::v4i32,
13919                                            S2F, 0x4E, DAG);
13920     Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64,
13921                          DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Shuffle),
13922                          Sub);
13923   }
13924
13925   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
13926                      DAG.getIntPtrConstant(0));
13927 }
13928
13929 // LowerUINT_TO_FP_i32 - 32-bit unsigned integer to float expansion.
13930 SDValue X86TargetLowering::LowerUINT_TO_FP_i32(SDValue Op,
13931                                                SelectionDAG &DAG) const {
13932   SDLoc dl(Op);
13933   // FP constant to bias correct the final result.
13934   SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
13935                                    MVT::f64);
13936
13937   // Load the 32-bit value into an XMM register.
13938   SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
13939                              Op.getOperand(0));
13940
13941   // Zero out the upper parts of the register.
13942   Load = getShuffleVectorZeroOrUndef(Load, 0, true, Subtarget, DAG);
13943
13944   Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
13945                      DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
13946                      DAG.getIntPtrConstant(0));
13947
13948   // Or the load with the bias.
13949   SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
13950                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
13951                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
13952                                                    MVT::v2f64, Load)),
13953                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
13954                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
13955                                                    MVT::v2f64, Bias)));
13956   Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
13957                    DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
13958                    DAG.getIntPtrConstant(0));
13959
13960   // Subtract the bias.
13961   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
13962
13963   // Handle final rounding.
13964   EVT DestVT = Op.getValueType();
13965
13966   if (DestVT.bitsLT(MVT::f64))
13967     return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
13968                        DAG.getIntPtrConstant(0));
13969   if (DestVT.bitsGT(MVT::f64))
13970     return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
13971
13972   // Handle final rounding.
13973   return Sub;
13974 }
13975
13976 static SDValue lowerUINT_TO_FP_vXi32(SDValue Op, SelectionDAG &DAG,
13977                                      const X86Subtarget &Subtarget) {
13978   // The algorithm is the following:
13979   // #ifdef __SSE4_1__
13980   //     uint4 lo = _mm_blend_epi16( v, (uint4) 0x4b000000, 0xaa);
13981   //     uint4 hi = _mm_blend_epi16( _mm_srli_epi32(v,16),
13982   //                                 (uint4) 0x53000000, 0xaa);
13983   // #else
13984   //     uint4 lo = (v & (uint4) 0xffff) | (uint4) 0x4b000000;
13985   //     uint4 hi = (v >> 16) | (uint4) 0x53000000;
13986   // #endif
13987   //     float4 fhi = (float4) hi - (0x1.0p39f + 0x1.0p23f);
13988   //     return (float4) lo + fhi;
13989
13990   SDLoc DL(Op);
13991   SDValue V = Op->getOperand(0);
13992   EVT VecIntVT = V.getValueType();
13993   bool Is128 = VecIntVT == MVT::v4i32;
13994   EVT VecFloatVT = Is128 ? MVT::v4f32 : MVT::v8f32;
13995   // If we convert to something else than the supported type, e.g., to v4f64,
13996   // abort early.
13997   if (VecFloatVT != Op->getValueType(0))
13998     return SDValue();
13999
14000   unsigned NumElts = VecIntVT.getVectorNumElements();
14001   assert((VecIntVT == MVT::v4i32 || VecIntVT == MVT::v8i32) &&
14002          "Unsupported custom type");
14003   assert(NumElts <= 8 && "The size of the constant array must be fixed");
14004
14005   // In the #idef/#else code, we have in common:
14006   // - The vector of constants:
14007   // -- 0x4b000000
14008   // -- 0x53000000
14009   // - A shift:
14010   // -- v >> 16
14011
14012   // Create the splat vector for 0x4b000000.
14013   SDValue CstLow = DAG.getConstant(0x4b000000, MVT::i32);
14014   SDValue CstLowArray[] = {CstLow, CstLow, CstLow, CstLow,
14015                            CstLow, CstLow, CstLow, CstLow};
14016   SDValue VecCstLow = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14017                                   makeArrayRef(&CstLowArray[0], NumElts));
14018   // Create the splat vector for 0x53000000.
14019   SDValue CstHigh = DAG.getConstant(0x53000000, MVT::i32);
14020   SDValue CstHighArray[] = {CstHigh, CstHigh, CstHigh, CstHigh,
14021                             CstHigh, CstHigh, CstHigh, CstHigh};
14022   SDValue VecCstHigh = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14023                                    makeArrayRef(&CstHighArray[0], NumElts));
14024
14025   // Create the right shift.
14026   SDValue CstShift = DAG.getConstant(16, MVT::i32);
14027   SDValue CstShiftArray[] = {CstShift, CstShift, CstShift, CstShift,
14028                              CstShift, CstShift, CstShift, CstShift};
14029   SDValue VecCstShift = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
14030                                     makeArrayRef(&CstShiftArray[0], NumElts));
14031   SDValue HighShift = DAG.getNode(ISD::SRL, DL, VecIntVT, V, VecCstShift);
14032
14033   SDValue Low, High;
14034   if (Subtarget.hasSSE41()) {
14035     EVT VecI16VT = Is128 ? MVT::v8i16 : MVT::v16i16;
14036     //     uint4 lo = _mm_blend_epi16( v, (uint4) 0x4b000000, 0xaa);
14037     SDValue VecCstLowBitcast =
14038         DAG.getNode(ISD::BITCAST, DL, VecI16VT, VecCstLow);
14039     SDValue VecBitcast = DAG.getNode(ISD::BITCAST, DL, VecI16VT, V);
14040     // Low will be bitcasted right away, so do not bother bitcasting back to its
14041     // original type.
14042     Low = DAG.getNode(X86ISD::BLENDI, DL, VecI16VT, VecBitcast,
14043                       VecCstLowBitcast, DAG.getConstant(0xaa, MVT::i32));
14044     //     uint4 hi = _mm_blend_epi16( _mm_srli_epi32(v,16),
14045     //                                 (uint4) 0x53000000, 0xaa);
14046     SDValue VecCstHighBitcast =
14047         DAG.getNode(ISD::BITCAST, DL, VecI16VT, VecCstHigh);
14048     SDValue VecShiftBitcast =
14049         DAG.getNode(ISD::BITCAST, DL, VecI16VT, HighShift);
14050     // High will be bitcasted right away, so do not bother bitcasting back to
14051     // its original type.
14052     High = DAG.getNode(X86ISD::BLENDI, DL, VecI16VT, VecShiftBitcast,
14053                        VecCstHighBitcast, DAG.getConstant(0xaa, MVT::i32));
14054   } else {
14055     SDValue CstMask = DAG.getConstant(0xffff, MVT::i32);
14056     SDValue VecCstMask = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT, CstMask,
14057                                      CstMask, CstMask, CstMask);
14058     //     uint4 lo = (v & (uint4) 0xffff) | (uint4) 0x4b000000;
14059     SDValue LowAnd = DAG.getNode(ISD::AND, DL, VecIntVT, V, VecCstMask);
14060     Low = DAG.getNode(ISD::OR, DL, VecIntVT, LowAnd, VecCstLow);
14061
14062     //     uint4 hi = (v >> 16) | (uint4) 0x53000000;
14063     High = DAG.getNode(ISD::OR, DL, VecIntVT, HighShift, VecCstHigh);
14064   }
14065
14066   // Create the vector constant for -(0x1.0p39f + 0x1.0p23f).
14067   SDValue CstFAdd = DAG.getConstantFP(
14068       APFloat(APFloat::IEEEsingle, APInt(32, 0xD3000080)), MVT::f32);
14069   SDValue CstFAddArray[] = {CstFAdd, CstFAdd, CstFAdd, CstFAdd,
14070                             CstFAdd, CstFAdd, CstFAdd, CstFAdd};
14071   SDValue VecCstFAdd = DAG.getNode(ISD::BUILD_VECTOR, DL, VecFloatVT,
14072                                    makeArrayRef(&CstFAddArray[0], NumElts));
14073
14074   //     float4 fhi = (float4) hi - (0x1.0p39f + 0x1.0p23f);
14075   SDValue HighBitcast = DAG.getNode(ISD::BITCAST, DL, VecFloatVT, High);
14076   SDValue FHigh =
14077       DAG.getNode(ISD::FADD, DL, VecFloatVT, HighBitcast, VecCstFAdd);
14078   //     return (float4) lo + fhi;
14079   SDValue LowBitcast = DAG.getNode(ISD::BITCAST, DL, VecFloatVT, Low);
14080   return DAG.getNode(ISD::FADD, DL, VecFloatVT, LowBitcast, FHigh);
14081 }
14082
14083 SDValue X86TargetLowering::lowerUINT_TO_FP_vec(SDValue Op,
14084                                                SelectionDAG &DAG) const {
14085   SDValue N0 = Op.getOperand(0);
14086   MVT SVT = N0.getSimpleValueType();
14087   SDLoc dl(Op);
14088
14089   switch (SVT.SimpleTy) {
14090   default:
14091     llvm_unreachable("Custom UINT_TO_FP is not supported!");
14092   case MVT::v4i8:
14093   case MVT::v4i16:
14094   case MVT::v8i8:
14095   case MVT::v8i16: {
14096     MVT NVT = MVT::getVectorVT(MVT::i32, SVT.getVectorNumElements());
14097     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
14098                        DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N0));
14099   }
14100   case MVT::v4i32:
14101   case MVT::v8i32:
14102     return lowerUINT_TO_FP_vXi32(Op, DAG, *Subtarget);
14103   }
14104   llvm_unreachable(nullptr);
14105 }
14106
14107 SDValue X86TargetLowering::LowerUINT_TO_FP(SDValue Op,
14108                                            SelectionDAG &DAG) const {
14109   SDValue N0 = Op.getOperand(0);
14110   SDLoc dl(Op);
14111
14112   if (Op.getValueType().isVector())
14113     return lowerUINT_TO_FP_vec(Op, DAG);
14114
14115   // Since UINT_TO_FP is legal (it's marked custom), dag combiner won't
14116   // optimize it to a SINT_TO_FP when the sign bit is known zero. Perform
14117   // the optimization here.
14118   if (DAG.SignBitIsZero(N0))
14119     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
14120
14121   MVT SrcVT = N0.getSimpleValueType();
14122   MVT DstVT = Op.getSimpleValueType();
14123   if (SrcVT == MVT::i64 && DstVT == MVT::f64 && X86ScalarSSEf64)
14124     return LowerUINT_TO_FP_i64(Op, DAG);
14125   if (SrcVT == MVT::i32 && X86ScalarSSEf64)
14126     return LowerUINT_TO_FP_i32(Op, DAG);
14127   if (Subtarget->is64Bit() && SrcVT == MVT::i64 && DstVT == MVT::f32)
14128     return SDValue();
14129
14130   // Make a 64-bit buffer, and use it to build an FILD.
14131   SDValue StackSlot = DAG.CreateStackTemporary(MVT::i64);
14132   if (SrcVT == MVT::i32) {
14133     SDValue WordOff = DAG.getConstant(4, getPointerTy());
14134     SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
14135                                      getPointerTy(), StackSlot, WordOff);
14136     SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
14137                                   StackSlot, MachinePointerInfo(),
14138                                   false, false, 0);
14139     SDValue Store2 = DAG.getStore(Store1, dl, DAG.getConstant(0, MVT::i32),
14140                                   OffsetSlot, MachinePointerInfo(),
14141                                   false, false, 0);
14142     SDValue Fild = BuildFILD(Op, MVT::i64, Store2, StackSlot, DAG);
14143     return Fild;
14144   }
14145
14146   assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
14147   SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
14148                                StackSlot, MachinePointerInfo(),
14149                                false, false, 0);
14150   // For i64 source, we need to add the appropriate power of 2 if the input
14151   // was negative.  This is the same as the optimization in
14152   // DAGTypeLegalizer::ExpandIntOp_UNIT_TO_FP, and for it to be safe here,
14153   // we must be careful to do the computation in x87 extended precision, not
14154   // in SSE. (The generic code can't know it's OK to do this, or how to.)
14155   int SSFI = cast<FrameIndexSDNode>(StackSlot)->getIndex();
14156   MachineMemOperand *MMO =
14157     DAG.getMachineFunction()
14158     .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14159                           MachineMemOperand::MOLoad, 8, 8);
14160
14161   SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other);
14162   SDValue Ops[] = { Store, StackSlot, DAG.getValueType(MVT::i64) };
14163   SDValue Fild = DAG.getMemIntrinsicNode(X86ISD::FILD, dl, Tys, Ops,
14164                                          MVT::i64, MMO);
14165
14166   APInt FF(32, 0x5F800000ULL);
14167
14168   // Check whether the sign bit is set.
14169   SDValue SignSet = DAG.getSetCC(dl,
14170                                  getSetCCResultType(*DAG.getContext(), MVT::i64),
14171                                  Op.getOperand(0), DAG.getConstant(0, MVT::i64),
14172                                  ISD::SETLT);
14173
14174   // Build a 64 bit pair (0, FF) in the constant pool, with FF in the lo bits.
14175   SDValue FudgePtr = DAG.getConstantPool(
14176                              ConstantInt::get(*DAG.getContext(), FF.zext(64)),
14177                                          getPointerTy());
14178
14179   // Get a pointer to FF if the sign bit was set, or to 0 otherwise.
14180   SDValue Zero = DAG.getIntPtrConstant(0);
14181   SDValue Four = DAG.getIntPtrConstant(4);
14182   SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
14183                                Zero, Four);
14184   FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
14185
14186   // Load the value out, extending it from f32 to f80.
14187   // FIXME: Avoid the extend by constructing the right constant pool?
14188   SDValue Fudge = DAG.getExtLoad(ISD::EXTLOAD, dl, MVT::f80, DAG.getEntryNode(),
14189                                  FudgePtr, MachinePointerInfo::getConstantPool(),
14190                                  MVT::f32, false, false, false, 4);
14191   // Extend everything to 80 bits to force it to be done on x87.
14192   SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
14193   return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
14194 }
14195
14196 std::pair<SDValue,SDValue>
14197 X86TargetLowering:: FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG,
14198                                     bool IsSigned, bool IsReplace) const {
14199   SDLoc DL(Op);
14200
14201   EVT DstTy = Op.getValueType();
14202
14203   if (!IsSigned && !isIntegerTypeFTOL(DstTy)) {
14204     assert(DstTy == MVT::i32 && "Unexpected FP_TO_UINT");
14205     DstTy = MVT::i64;
14206   }
14207
14208   assert(DstTy.getSimpleVT() <= MVT::i64 &&
14209          DstTy.getSimpleVT() >= MVT::i16 &&
14210          "Unknown FP_TO_INT to lower!");
14211
14212   // These are really Legal.
14213   if (DstTy == MVT::i32 &&
14214       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
14215     return std::make_pair(SDValue(), SDValue());
14216   if (Subtarget->is64Bit() &&
14217       DstTy == MVT::i64 &&
14218       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
14219     return std::make_pair(SDValue(), SDValue());
14220
14221   // We lower FP->int64 either into FISTP64 followed by a load from a temporary
14222   // stack slot, or into the FTOL runtime function.
14223   MachineFunction &MF = DAG.getMachineFunction();
14224   unsigned MemSize = DstTy.getSizeInBits()/8;
14225   int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
14226   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14227
14228   unsigned Opc;
14229   if (!IsSigned && isIntegerTypeFTOL(DstTy))
14230     Opc = X86ISD::WIN_FTOL;
14231   else
14232     switch (DstTy.getSimpleVT().SimpleTy) {
14233     default: llvm_unreachable("Invalid FP_TO_SINT to lower!");
14234     case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
14235     case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
14236     case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
14237     }
14238
14239   SDValue Chain = DAG.getEntryNode();
14240   SDValue Value = Op.getOperand(0);
14241   EVT TheVT = Op.getOperand(0).getValueType();
14242   // FIXME This causes a redundant load/store if the SSE-class value is already
14243   // in memory, such as if it is on the callstack.
14244   if (isScalarFPTypeInSSEReg(TheVT)) {
14245     assert(DstTy == MVT::i64 && "Invalid FP_TO_SINT to lower!");
14246     Chain = DAG.getStore(Chain, DL, Value, StackSlot,
14247                          MachinePointerInfo::getFixedStack(SSFI),
14248                          false, false, 0);
14249     SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other);
14250     SDValue Ops[] = {
14251       Chain, StackSlot, DAG.getValueType(TheVT)
14252     };
14253
14254     MachineMemOperand *MMO =
14255       MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14256                               MachineMemOperand::MOLoad, MemSize, MemSize);
14257     Value = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops, DstTy, MMO);
14258     Chain = Value.getValue(1);
14259     SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
14260     StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
14261   }
14262
14263   MachineMemOperand *MMO =
14264     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
14265                             MachineMemOperand::MOStore, MemSize, MemSize);
14266
14267   if (Opc != X86ISD::WIN_FTOL) {
14268     // Build the FP_TO_INT*_IN_MEM
14269     SDValue Ops[] = { Chain, Value, StackSlot };
14270     SDValue FIST = DAG.getMemIntrinsicNode(Opc, DL, DAG.getVTList(MVT::Other),
14271                                            Ops, DstTy, MMO);
14272     return std::make_pair(FIST, StackSlot);
14273   } else {
14274     SDValue ftol = DAG.getNode(X86ISD::WIN_FTOL, DL,
14275       DAG.getVTList(MVT::Other, MVT::Glue),
14276       Chain, Value);
14277     SDValue eax = DAG.getCopyFromReg(ftol, DL, X86::EAX,
14278       MVT::i32, ftol.getValue(1));
14279     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), DL, X86::EDX,
14280       MVT::i32, eax.getValue(2));
14281     SDValue Ops[] = { eax, edx };
14282     SDValue pair = IsReplace
14283       ? DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops)
14284       : DAG.getMergeValues(Ops, DL);
14285     return std::make_pair(pair, SDValue());
14286   }
14287 }
14288
14289 static SDValue LowerAVXExtend(SDValue Op, SelectionDAG &DAG,
14290                               const X86Subtarget *Subtarget) {
14291   MVT VT = Op->getSimpleValueType(0);
14292   SDValue In = Op->getOperand(0);
14293   MVT InVT = In.getSimpleValueType();
14294   SDLoc dl(Op);
14295
14296   // Optimize vectors in AVX mode:
14297   //
14298   //   v8i16 -> v8i32
14299   //   Use vpunpcklwd for 4 lower elements  v8i16 -> v4i32.
14300   //   Use vpunpckhwd for 4 upper elements  v8i16 -> v4i32.
14301   //   Concat upper and lower parts.
14302   //
14303   //   v4i32 -> v4i64
14304   //   Use vpunpckldq for 4 lower elements  v4i32 -> v2i64.
14305   //   Use vpunpckhdq for 4 upper elements  v4i32 -> v2i64.
14306   //   Concat upper and lower parts.
14307   //
14308
14309   if (((VT != MVT::v16i16) || (InVT != MVT::v16i8)) &&
14310       ((VT != MVT::v8i32) || (InVT != MVT::v8i16)) &&
14311       ((VT != MVT::v4i64) || (InVT != MVT::v4i32)))
14312     return SDValue();
14313
14314   if (Subtarget->hasInt256())
14315     return DAG.getNode(X86ISD::VZEXT, dl, VT, In);
14316
14317   SDValue ZeroVec = getZeroVector(InVT, Subtarget, DAG, dl);
14318   SDValue Undef = DAG.getUNDEF(InVT);
14319   bool NeedZero = Op.getOpcode() == ISD::ZERO_EXTEND;
14320   SDValue OpLo = getUnpackl(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
14321   SDValue OpHi = getUnpackh(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
14322
14323   MVT HVT = MVT::getVectorVT(VT.getVectorElementType(),
14324                              VT.getVectorNumElements()/2);
14325
14326   OpLo = DAG.getNode(ISD::BITCAST, dl, HVT, OpLo);
14327   OpHi = DAG.getNode(ISD::BITCAST, dl, HVT, OpHi);
14328
14329   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
14330 }
14331
14332 static  SDValue LowerZERO_EXTEND_AVX512(SDValue Op,
14333                                         SelectionDAG &DAG) {
14334   MVT VT = Op->getSimpleValueType(0);
14335   SDValue In = Op->getOperand(0);
14336   MVT InVT = In.getSimpleValueType();
14337   SDLoc DL(Op);
14338   unsigned int NumElts = VT.getVectorNumElements();
14339   if (NumElts != 8 && NumElts != 16)
14340     return SDValue();
14341
14342   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1)
14343     return DAG.getNode(X86ISD::VZEXT, DL, VT, In);
14344
14345   EVT ExtVT = (NumElts == 8)? MVT::v8i64 : MVT::v16i32;
14346   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14347   // Now we have only mask extension
14348   assert(InVT.getVectorElementType() == MVT::i1);
14349   SDValue Cst = DAG.getTargetConstant(1, ExtVT.getScalarType());
14350   const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
14351   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
14352   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
14353   SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
14354                            MachinePointerInfo::getConstantPool(),
14355                            false, false, false, Alignment);
14356
14357   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, DL, ExtVT, In, Ld);
14358   if (VT.is512BitVector())
14359     return Brcst;
14360   return DAG.getNode(X86ISD::VTRUNC, DL, VT, Brcst);
14361 }
14362
14363 static SDValue LowerANY_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
14364                                SelectionDAG &DAG) {
14365   if (Subtarget->hasFp256()) {
14366     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
14367     if (Res.getNode())
14368       return Res;
14369   }
14370
14371   return SDValue();
14372 }
14373
14374 static SDValue LowerZERO_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
14375                                 SelectionDAG &DAG) {
14376   SDLoc DL(Op);
14377   MVT VT = Op.getSimpleValueType();
14378   SDValue In = Op.getOperand(0);
14379   MVT SVT = In.getSimpleValueType();
14380
14381   if (VT.is512BitVector() || SVT.getVectorElementType() == MVT::i1)
14382     return LowerZERO_EXTEND_AVX512(Op, DAG);
14383
14384   if (Subtarget->hasFp256()) {
14385     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
14386     if (Res.getNode())
14387       return Res;
14388   }
14389
14390   assert(!VT.is256BitVector() || !SVT.is128BitVector() ||
14391          VT.getVectorNumElements() != SVT.getVectorNumElements());
14392   return SDValue();
14393 }
14394
14395 SDValue X86TargetLowering::LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const {
14396   SDLoc DL(Op);
14397   MVT VT = Op.getSimpleValueType();
14398   SDValue In = Op.getOperand(0);
14399   MVT InVT = In.getSimpleValueType();
14400
14401   if (VT == MVT::i1) {
14402     assert((InVT.isInteger() && (InVT.getSizeInBits() <= 64)) &&
14403            "Invalid scalar TRUNCATE operation");
14404     if (InVT.getSizeInBits() >= 32)
14405       return SDValue();
14406     In = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, In);
14407     return DAG.getNode(ISD::TRUNCATE, DL, VT, In);
14408   }
14409   assert(VT.getVectorNumElements() == InVT.getVectorNumElements() &&
14410          "Invalid TRUNCATE operation");
14411
14412   if (InVT.is512BitVector() || VT.getVectorElementType() == MVT::i1) {
14413     if (VT.getVectorElementType().getSizeInBits() >=8)
14414       return DAG.getNode(X86ISD::VTRUNC, DL, VT, In);
14415
14416     assert(VT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
14417     unsigned NumElts = InVT.getVectorNumElements();
14418     assert ((NumElts == 8 || NumElts == 16) && "Unexpected vector type");
14419     if (InVT.getSizeInBits() < 512) {
14420       MVT ExtVT = (NumElts == 16)? MVT::v16i32 : MVT::v8i64;
14421       In = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, In);
14422       InVT = ExtVT;
14423     }
14424
14425     SDValue Cst = DAG.getTargetConstant(1, InVT.getVectorElementType());
14426     const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
14427     SDValue CP = DAG.getConstantPool(C, getPointerTy());
14428     unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
14429     SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
14430                            MachinePointerInfo::getConstantPool(),
14431                            false, false, false, Alignment);
14432     SDValue OneV = DAG.getNode(X86ISD::VBROADCAST, DL, InVT, Ld);
14433     SDValue And = DAG.getNode(ISD::AND, DL, InVT, OneV, In);
14434     return DAG.getNode(X86ISD::TESTM, DL, VT, And, And);
14435   }
14436
14437   if ((VT == MVT::v4i32) && (InVT == MVT::v4i64)) {
14438     // On AVX2, v4i64 -> v4i32 becomes VPERMD.
14439     if (Subtarget->hasInt256()) {
14440       static const int ShufMask[] = {0, 2, 4, 6, -1, -1, -1, -1};
14441       In = DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, In);
14442       In = DAG.getVectorShuffle(MVT::v8i32, DL, In, DAG.getUNDEF(MVT::v8i32),
14443                                 ShufMask);
14444       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, In,
14445                          DAG.getIntPtrConstant(0));
14446     }
14447
14448     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14449                                DAG.getIntPtrConstant(0));
14450     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14451                                DAG.getIntPtrConstant(2));
14452     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
14453     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
14454     static const int ShufMask[] = {0, 2, 4, 6};
14455     return DAG.getVectorShuffle(VT, DL, OpLo, OpHi, ShufMask);
14456   }
14457
14458   if ((VT == MVT::v8i16) && (InVT == MVT::v8i32)) {
14459     // On AVX2, v8i32 -> v8i16 becomed PSHUFB.
14460     if (Subtarget->hasInt256()) {
14461       In = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, In);
14462
14463       SmallVector<SDValue,32> pshufbMask;
14464       for (unsigned i = 0; i < 2; ++i) {
14465         pshufbMask.push_back(DAG.getConstant(0x0, MVT::i8));
14466         pshufbMask.push_back(DAG.getConstant(0x1, MVT::i8));
14467         pshufbMask.push_back(DAG.getConstant(0x4, MVT::i8));
14468         pshufbMask.push_back(DAG.getConstant(0x5, MVT::i8));
14469         pshufbMask.push_back(DAG.getConstant(0x8, MVT::i8));
14470         pshufbMask.push_back(DAG.getConstant(0x9, MVT::i8));
14471         pshufbMask.push_back(DAG.getConstant(0xc, MVT::i8));
14472         pshufbMask.push_back(DAG.getConstant(0xd, MVT::i8));
14473         for (unsigned j = 0; j < 8; ++j)
14474           pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
14475       }
14476       SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, pshufbMask);
14477       In = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v32i8, In, BV);
14478       In = DAG.getNode(ISD::BITCAST, DL, MVT::v4i64, In);
14479
14480       static const int ShufMask[] = {0,  2,  -1,  -1};
14481       In = DAG.getVectorShuffle(MVT::v4i64, DL,  In, DAG.getUNDEF(MVT::v4i64),
14482                                 &ShufMask[0]);
14483       In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
14484                        DAG.getIntPtrConstant(0));
14485       return DAG.getNode(ISD::BITCAST, DL, VT, In);
14486     }
14487
14488     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
14489                                DAG.getIntPtrConstant(0));
14490
14491     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
14492                                DAG.getIntPtrConstant(4));
14493
14494     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpLo);
14495     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpHi);
14496
14497     // The PSHUFB mask:
14498     static const int ShufMask1[] = {0,  1,  4,  5,  8,  9, 12, 13,
14499                                    -1, -1, -1, -1, -1, -1, -1, -1};
14500
14501     SDValue Undef = DAG.getUNDEF(MVT::v16i8);
14502     OpLo = DAG.getVectorShuffle(MVT::v16i8, DL, OpLo, Undef, ShufMask1);
14503     OpHi = DAG.getVectorShuffle(MVT::v16i8, DL, OpHi, Undef, ShufMask1);
14504
14505     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
14506     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
14507
14508     // The MOVLHPS Mask:
14509     static const int ShufMask2[] = {0, 1, 4, 5};
14510     SDValue res = DAG.getVectorShuffle(MVT::v4i32, DL, OpLo, OpHi, ShufMask2);
14511     return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, res);
14512   }
14513
14514   // Handle truncation of V256 to V128 using shuffles.
14515   if (!VT.is128BitVector() || !InVT.is256BitVector())
14516     return SDValue();
14517
14518   assert(Subtarget->hasFp256() && "256-bit vector without AVX!");
14519
14520   unsigned NumElems = VT.getVectorNumElements();
14521   MVT NVT = MVT::getVectorVT(VT.getVectorElementType(), NumElems * 2);
14522
14523   SmallVector<int, 16> MaskVec(NumElems * 2, -1);
14524   // Prepare truncation shuffle mask
14525   for (unsigned i = 0; i != NumElems; ++i)
14526     MaskVec[i] = i * 2;
14527   SDValue V = DAG.getVectorShuffle(NVT, DL,
14528                                    DAG.getNode(ISD::BITCAST, DL, NVT, In),
14529                                    DAG.getUNDEF(NVT), &MaskVec[0]);
14530   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, V,
14531                      DAG.getIntPtrConstant(0));
14532 }
14533
14534 SDValue X86TargetLowering::LowerFP_TO_SINT(SDValue Op,
14535                                            SelectionDAG &DAG) const {
14536   assert(!Op.getSimpleValueType().isVector());
14537
14538   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
14539     /*IsSigned=*/ true, /*IsReplace=*/ false);
14540   SDValue FIST = Vals.first, StackSlot = Vals.second;
14541   // If FP_TO_INTHelper failed, the node is actually supposed to be Legal.
14542   if (!FIST.getNode()) return Op;
14543
14544   if (StackSlot.getNode())
14545     // Load the result.
14546     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
14547                        FIST, StackSlot, MachinePointerInfo(),
14548                        false, false, false, 0);
14549
14550   // The node is the result.
14551   return FIST;
14552 }
14553
14554 SDValue X86TargetLowering::LowerFP_TO_UINT(SDValue Op,
14555                                            SelectionDAG &DAG) const {
14556   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
14557     /*IsSigned=*/ false, /*IsReplace=*/ false);
14558   SDValue FIST = Vals.first, StackSlot = Vals.second;
14559   assert(FIST.getNode() && "Unexpected failure");
14560
14561   if (StackSlot.getNode())
14562     // Load the result.
14563     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
14564                        FIST, StackSlot, MachinePointerInfo(),
14565                        false, false, false, 0);
14566
14567   // The node is the result.
14568   return FIST;
14569 }
14570
14571 static SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) {
14572   SDLoc DL(Op);
14573   MVT VT = Op.getSimpleValueType();
14574   SDValue In = Op.getOperand(0);
14575   MVT SVT = In.getSimpleValueType();
14576
14577   assert(SVT == MVT::v2f32 && "Only customize MVT::v2f32 type legalization!");
14578
14579   return DAG.getNode(X86ISD::VFPEXT, DL, VT,
14580                      DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4f32,
14581                                  In, DAG.getUNDEF(SVT)));
14582 }
14583
14584 /// The only differences between FABS and FNEG are the mask and the logic op.
14585 /// FNEG also has a folding opportunity for FNEG(FABS(x)).
14586 static SDValue LowerFABSorFNEG(SDValue Op, SelectionDAG &DAG) {
14587   assert((Op.getOpcode() == ISD::FABS || Op.getOpcode() == ISD::FNEG) &&
14588          "Wrong opcode for lowering FABS or FNEG.");
14589
14590   bool IsFABS = (Op.getOpcode() == ISD::FABS);
14591
14592   // If this is a FABS and it has an FNEG user, bail out to fold the combination
14593   // into an FNABS. We'll lower the FABS after that if it is still in use.
14594   if (IsFABS)
14595     for (SDNode *User : Op->uses())
14596       if (User->getOpcode() == ISD::FNEG)
14597         return Op;
14598
14599   SDValue Op0 = Op.getOperand(0);
14600   bool IsFNABS = !IsFABS && (Op0.getOpcode() == ISD::FABS);
14601
14602   SDLoc dl(Op);
14603   MVT VT = Op.getSimpleValueType();
14604   // Assume scalar op for initialization; update for vector if needed.
14605   // Note that there are no scalar bitwise logical SSE/AVX instructions, so we
14606   // generate a 16-byte vector constant and logic op even for the scalar case.
14607   // Using a 16-byte mask allows folding the load of the mask with
14608   // the logic op, so it can save (~4 bytes) on code size.
14609   MVT EltVT = VT;
14610   unsigned NumElts = VT == MVT::f64 ? 2 : 4;
14611   // FIXME: Use function attribute "OptimizeForSize" and/or CodeGenOpt::Level to
14612   // decide if we should generate a 16-byte constant mask when we only need 4 or
14613   // 8 bytes for the scalar case.
14614   if (VT.isVector()) {
14615     EltVT = VT.getVectorElementType();
14616     NumElts = VT.getVectorNumElements();
14617   }
14618
14619   unsigned EltBits = EltVT.getSizeInBits();
14620   LLVMContext *Context = DAG.getContext();
14621   // For FABS, mask is 0x7f...; for FNEG, mask is 0x80...
14622   APInt MaskElt =
14623     IsFABS ? APInt::getSignedMaxValue(EltBits) : APInt::getSignBit(EltBits);
14624   Constant *C = ConstantInt::get(*Context, MaskElt);
14625   C = ConstantVector::getSplat(NumElts, C);
14626   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14627   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy());
14628   unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment();
14629   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
14630                              MachinePointerInfo::getConstantPool(),
14631                              false, false, false, Alignment);
14632
14633   if (VT.isVector()) {
14634     // For a vector, cast operands to a vector type, perform the logic op,
14635     // and cast the result back to the original value type.
14636     MVT VecVT = MVT::getVectorVT(MVT::i64, VT.getSizeInBits() / 64);
14637     SDValue MaskCasted = DAG.getNode(ISD::BITCAST, dl, VecVT, Mask);
14638     SDValue Operand = IsFNABS ?
14639       DAG.getNode(ISD::BITCAST, dl, VecVT, Op0.getOperand(0)) :
14640       DAG.getNode(ISD::BITCAST, dl, VecVT, Op0);
14641     unsigned BitOp = IsFABS ? ISD::AND : IsFNABS ? ISD::OR : ISD::XOR;
14642     return DAG.getNode(ISD::BITCAST, dl, VT,
14643                        DAG.getNode(BitOp, dl, VecVT, Operand, MaskCasted));
14644   }
14645
14646   // If not vector, then scalar.
14647   unsigned BitOp = IsFABS ? X86ISD::FAND : IsFNABS ? X86ISD::FOR : X86ISD::FXOR;
14648   SDValue Operand = IsFNABS ? Op0.getOperand(0) : Op0;
14649   return DAG.getNode(BitOp, dl, VT, Operand, Mask);
14650 }
14651
14652 static SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) {
14653   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14654   LLVMContext *Context = DAG.getContext();
14655   SDValue Op0 = Op.getOperand(0);
14656   SDValue Op1 = Op.getOperand(1);
14657   SDLoc dl(Op);
14658   MVT VT = Op.getSimpleValueType();
14659   MVT SrcVT = Op1.getSimpleValueType();
14660
14661   // If second operand is smaller, extend it first.
14662   if (SrcVT.bitsLT(VT)) {
14663     Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
14664     SrcVT = VT;
14665   }
14666   // And if it is bigger, shrink it first.
14667   if (SrcVT.bitsGT(VT)) {
14668     Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
14669     SrcVT = VT;
14670   }
14671
14672   // At this point the operands and the result should have the same
14673   // type, and that won't be f80 since that is not custom lowered.
14674
14675   const fltSemantics &Sem =
14676       VT == MVT::f64 ? APFloat::IEEEdouble : APFloat::IEEEsingle;
14677   const unsigned SizeInBits = VT.getSizeInBits();
14678
14679   SmallVector<Constant *, 4> CV(
14680       VT == MVT::f64 ? 2 : 4,
14681       ConstantFP::get(*Context, APFloat(Sem, APInt(SizeInBits, 0))));
14682
14683   // First, clear all bits but the sign bit from the second operand (sign).
14684   CV[0] = ConstantFP::get(*Context,
14685                           APFloat(Sem, APInt::getHighBitsSet(SizeInBits, 1)));
14686   Constant *C = ConstantVector::get(CV);
14687   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
14688   SDValue Mask1 = DAG.getLoad(SrcVT, dl, DAG.getEntryNode(), CPIdx,
14689                               MachinePointerInfo::getConstantPool(),
14690                               false, false, false, 16);
14691   SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
14692
14693   // Next, clear the sign bit from the first operand (magnitude).
14694   // If it's a constant, we can clear it here.
14695   if (ConstantFPSDNode *Op0CN = dyn_cast<ConstantFPSDNode>(Op0)) {
14696     APFloat APF = Op0CN->getValueAPF();
14697     // If the magnitude is a positive zero, the sign bit alone is enough.
14698     if (APF.isPosZero())
14699       return SignBit;
14700     APF.clearSign();
14701     CV[0] = ConstantFP::get(*Context, APF);
14702   } else {
14703     CV[0] = ConstantFP::get(
14704         *Context,
14705         APFloat(Sem, APInt::getLowBitsSet(SizeInBits, SizeInBits - 1)));
14706   }
14707   C = ConstantVector::get(CV);
14708   CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
14709   SDValue Val = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
14710                             MachinePointerInfo::getConstantPool(),
14711                             false, false, false, 16);
14712   // If the magnitude operand wasn't a constant, we need to AND out the sign.
14713   if (!isa<ConstantFPSDNode>(Op0))
14714     Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Val);
14715
14716   // OR the magnitude value with the sign bit.
14717   return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
14718 }
14719
14720 static SDValue LowerFGETSIGN(SDValue Op, SelectionDAG &DAG) {
14721   SDValue N0 = Op.getOperand(0);
14722   SDLoc dl(Op);
14723   MVT VT = Op.getSimpleValueType();
14724
14725   // Lower ISD::FGETSIGN to (AND (X86ISD::FGETSIGNx86 ...) 1).
14726   SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
14727                                   DAG.getConstant(1, VT));
14728   return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
14729 }
14730
14731 // Check whether an OR'd tree is PTEST-able.
14732 static SDValue LowerVectorAllZeroTest(SDValue Op, const X86Subtarget *Subtarget,
14733                                       SelectionDAG &DAG) {
14734   assert(Op.getOpcode() == ISD::OR && "Only check OR'd tree.");
14735
14736   if (!Subtarget->hasSSE41())
14737     return SDValue();
14738
14739   if (!Op->hasOneUse())
14740     return SDValue();
14741
14742   SDNode *N = Op.getNode();
14743   SDLoc DL(N);
14744
14745   SmallVector<SDValue, 8> Opnds;
14746   DenseMap<SDValue, unsigned> VecInMap;
14747   SmallVector<SDValue, 8> VecIns;
14748   EVT VT = MVT::Other;
14749
14750   // Recognize a special case where a vector is casted into wide integer to
14751   // test all 0s.
14752   Opnds.push_back(N->getOperand(0));
14753   Opnds.push_back(N->getOperand(1));
14754
14755   for (unsigned Slot = 0, e = Opnds.size(); Slot < e; ++Slot) {
14756     SmallVectorImpl<SDValue>::const_iterator I = Opnds.begin() + Slot;
14757     // BFS traverse all OR'd operands.
14758     if (I->getOpcode() == ISD::OR) {
14759       Opnds.push_back(I->getOperand(0));
14760       Opnds.push_back(I->getOperand(1));
14761       // Re-evaluate the number of nodes to be traversed.
14762       e += 2; // 2 more nodes (LHS and RHS) are pushed.
14763       continue;
14764     }
14765
14766     // Quit if a non-EXTRACT_VECTOR_ELT
14767     if (I->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
14768       return SDValue();
14769
14770     // Quit if without a constant index.
14771     SDValue Idx = I->getOperand(1);
14772     if (!isa<ConstantSDNode>(Idx))
14773       return SDValue();
14774
14775     SDValue ExtractedFromVec = I->getOperand(0);
14776     DenseMap<SDValue, unsigned>::iterator M = VecInMap.find(ExtractedFromVec);
14777     if (M == VecInMap.end()) {
14778       VT = ExtractedFromVec.getValueType();
14779       // Quit if not 128/256-bit vector.
14780       if (!VT.is128BitVector() && !VT.is256BitVector())
14781         return SDValue();
14782       // Quit if not the same type.
14783       if (VecInMap.begin() != VecInMap.end() &&
14784           VT != VecInMap.begin()->first.getValueType())
14785         return SDValue();
14786       M = VecInMap.insert(std::make_pair(ExtractedFromVec, 0)).first;
14787       VecIns.push_back(ExtractedFromVec);
14788     }
14789     M->second |= 1U << cast<ConstantSDNode>(Idx)->getZExtValue();
14790   }
14791
14792   assert((VT.is128BitVector() || VT.is256BitVector()) &&
14793          "Not extracted from 128-/256-bit vector.");
14794
14795   unsigned FullMask = (1U << VT.getVectorNumElements()) - 1U;
14796
14797   for (DenseMap<SDValue, unsigned>::const_iterator
14798         I = VecInMap.begin(), E = VecInMap.end(); I != E; ++I) {
14799     // Quit if not all elements are used.
14800     if (I->second != FullMask)
14801       return SDValue();
14802   }
14803
14804   EVT TestVT = VT.is128BitVector() ? MVT::v2i64 : MVT::v4i64;
14805
14806   // Cast all vectors into TestVT for PTEST.
14807   for (unsigned i = 0, e = VecIns.size(); i < e; ++i)
14808     VecIns[i] = DAG.getNode(ISD::BITCAST, DL, TestVT, VecIns[i]);
14809
14810   // If more than one full vectors are evaluated, OR them first before PTEST.
14811   for (unsigned Slot = 0, e = VecIns.size(); e - Slot > 1; Slot += 2, e += 1) {
14812     // Each iteration will OR 2 nodes and append the result until there is only
14813     // 1 node left, i.e. the final OR'd value of all vectors.
14814     SDValue LHS = VecIns[Slot];
14815     SDValue RHS = VecIns[Slot + 1];
14816     VecIns.push_back(DAG.getNode(ISD::OR, DL, TestVT, LHS, RHS));
14817   }
14818
14819   return DAG.getNode(X86ISD::PTEST, DL, MVT::i32,
14820                      VecIns.back(), VecIns.back());
14821 }
14822
14823 /// \brief return true if \c Op has a use that doesn't just read flags.
14824 static bool hasNonFlagsUse(SDValue Op) {
14825   for (SDNode::use_iterator UI = Op->use_begin(), UE = Op->use_end(); UI != UE;
14826        ++UI) {
14827     SDNode *User = *UI;
14828     unsigned UOpNo = UI.getOperandNo();
14829     if (User->getOpcode() == ISD::TRUNCATE && User->hasOneUse()) {
14830       // Look pass truncate.
14831       UOpNo = User->use_begin().getOperandNo();
14832       User = *User->use_begin();
14833     }
14834
14835     if (User->getOpcode() != ISD::BRCOND && User->getOpcode() != ISD::SETCC &&
14836         !(User->getOpcode() == ISD::SELECT && UOpNo == 0))
14837       return true;
14838   }
14839   return false;
14840 }
14841
14842 /// Emit nodes that will be selected as "test Op0,Op0", or something
14843 /// equivalent.
14844 SDValue X86TargetLowering::EmitTest(SDValue Op, unsigned X86CC, SDLoc dl,
14845                                     SelectionDAG &DAG) const {
14846   if (Op.getValueType() == MVT::i1)
14847     // KORTEST instruction should be selected
14848     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
14849                        DAG.getConstant(0, Op.getValueType()));
14850
14851   // CF and OF aren't always set the way we want. Determine which
14852   // of these we need.
14853   bool NeedCF = false;
14854   bool NeedOF = false;
14855   switch (X86CC) {
14856   default: break;
14857   case X86::COND_A: case X86::COND_AE:
14858   case X86::COND_B: case X86::COND_BE:
14859     NeedCF = true;
14860     break;
14861   case X86::COND_G: case X86::COND_GE:
14862   case X86::COND_L: case X86::COND_LE:
14863   case X86::COND_O: case X86::COND_NO: {
14864     // Check if we really need to set the
14865     // Overflow flag. If NoSignedWrap is present
14866     // that is not actually needed.
14867     switch (Op->getOpcode()) {
14868     case ISD::ADD:
14869     case ISD::SUB:
14870     case ISD::MUL:
14871     case ISD::SHL: {
14872       const BinaryWithFlagsSDNode *BinNode =
14873           cast<BinaryWithFlagsSDNode>(Op.getNode());
14874       if (BinNode->hasNoSignedWrap())
14875         break;
14876     }
14877     default:
14878       NeedOF = true;
14879       break;
14880     }
14881     break;
14882   }
14883   }
14884   // See if we can use the EFLAGS value from the operand instead of
14885   // doing a separate TEST. TEST always sets OF and CF to 0, so unless
14886   // we prove that the arithmetic won't overflow, we can't use OF or CF.
14887   if (Op.getResNo() != 0 || NeedOF || NeedCF) {
14888     // Emit a CMP with 0, which is the TEST pattern.
14889     //if (Op.getValueType() == MVT::i1)
14890     //  return DAG.getNode(X86ISD::CMP, dl, MVT::i1, Op,
14891     //                     DAG.getConstant(0, MVT::i1));
14892     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
14893                        DAG.getConstant(0, Op.getValueType()));
14894   }
14895   unsigned Opcode = 0;
14896   unsigned NumOperands = 0;
14897
14898   // Truncate operations may prevent the merge of the SETCC instruction
14899   // and the arithmetic instruction before it. Attempt to truncate the operands
14900   // of the arithmetic instruction and use a reduced bit-width instruction.
14901   bool NeedTruncation = false;
14902   SDValue ArithOp = Op;
14903   if (Op->getOpcode() == ISD::TRUNCATE && Op->hasOneUse()) {
14904     SDValue Arith = Op->getOperand(0);
14905     // Both the trunc and the arithmetic op need to have one user each.
14906     if (Arith->hasOneUse())
14907       switch (Arith.getOpcode()) {
14908         default: break;
14909         case ISD::ADD:
14910         case ISD::SUB:
14911         case ISD::AND:
14912         case ISD::OR:
14913         case ISD::XOR: {
14914           NeedTruncation = true;
14915           ArithOp = Arith;
14916         }
14917       }
14918   }
14919
14920   // NOTICE: In the code below we use ArithOp to hold the arithmetic operation
14921   // which may be the result of a CAST.  We use the variable 'Op', which is the
14922   // non-casted variable when we check for possible users.
14923   switch (ArithOp.getOpcode()) {
14924   case ISD::ADD:
14925     // Due to an isel shortcoming, be conservative if this add is likely to be
14926     // selected as part of a load-modify-store instruction. When the root node
14927     // in a match is a store, isel doesn't know how to remap non-chain non-flag
14928     // uses of other nodes in the match, such as the ADD in this case. This
14929     // leads to the ADD being left around and reselected, with the result being
14930     // two adds in the output.  Alas, even if none our users are stores, that
14931     // doesn't prove we're O.K.  Ergo, if we have any parents that aren't
14932     // CopyToReg or SETCC, eschew INC/DEC.  A better fix seems to require
14933     // climbing the DAG back to the root, and it doesn't seem to be worth the
14934     // effort.
14935     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
14936          UE = Op.getNode()->use_end(); UI != UE; ++UI)
14937       if (UI->getOpcode() != ISD::CopyToReg &&
14938           UI->getOpcode() != ISD::SETCC &&
14939           UI->getOpcode() != ISD::STORE)
14940         goto default_case;
14941
14942     if (ConstantSDNode *C =
14943         dyn_cast<ConstantSDNode>(ArithOp.getNode()->getOperand(1))) {
14944       // An add of one will be selected as an INC.
14945       if (C->getAPIntValue() == 1 && !Subtarget->slowIncDec()) {
14946         Opcode = X86ISD::INC;
14947         NumOperands = 1;
14948         break;
14949       }
14950
14951       // An add of negative one (subtract of one) will be selected as a DEC.
14952       if (C->getAPIntValue().isAllOnesValue() && !Subtarget->slowIncDec()) {
14953         Opcode = X86ISD::DEC;
14954         NumOperands = 1;
14955         break;
14956       }
14957     }
14958
14959     // Otherwise use a regular EFLAGS-setting add.
14960     Opcode = X86ISD::ADD;
14961     NumOperands = 2;
14962     break;
14963   case ISD::SHL:
14964   case ISD::SRL:
14965     // If we have a constant logical shift that's only used in a comparison
14966     // against zero turn it into an equivalent AND. This allows turning it into
14967     // a TEST instruction later.
14968     if ((X86CC == X86::COND_E || X86CC == X86::COND_NE) && Op->hasOneUse() &&
14969         isa<ConstantSDNode>(Op->getOperand(1)) && !hasNonFlagsUse(Op)) {
14970       EVT VT = Op.getValueType();
14971       unsigned BitWidth = VT.getSizeInBits();
14972       unsigned ShAmt = Op->getConstantOperandVal(1);
14973       if (ShAmt >= BitWidth) // Avoid undefined shifts.
14974         break;
14975       APInt Mask = ArithOp.getOpcode() == ISD::SRL
14976                        ? APInt::getHighBitsSet(BitWidth, BitWidth - ShAmt)
14977                        : APInt::getLowBitsSet(BitWidth, BitWidth - ShAmt);
14978       if (!Mask.isSignedIntN(32)) // Avoid large immediates.
14979         break;
14980       SDValue New = DAG.getNode(ISD::AND, dl, VT, Op->getOperand(0),
14981                                 DAG.getConstant(Mask, VT));
14982       DAG.ReplaceAllUsesWith(Op, New);
14983       Op = New;
14984     }
14985     break;
14986
14987   case ISD::AND:
14988     // If the primary and result isn't used, don't bother using X86ISD::AND,
14989     // because a TEST instruction will be better.
14990     if (!hasNonFlagsUse(Op))
14991       break;
14992     // FALL THROUGH
14993   case ISD::SUB:
14994   case ISD::OR:
14995   case ISD::XOR:
14996     // Due to the ISEL shortcoming noted above, be conservative if this op is
14997     // likely to be selected as part of a load-modify-store instruction.
14998     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
14999            UE = Op.getNode()->use_end(); UI != UE; ++UI)
15000       if (UI->getOpcode() == ISD::STORE)
15001         goto default_case;
15002
15003     // Otherwise use a regular EFLAGS-setting instruction.
15004     switch (ArithOp.getOpcode()) {
15005     default: llvm_unreachable("unexpected operator!");
15006     case ISD::SUB: Opcode = X86ISD::SUB; break;
15007     case ISD::XOR: Opcode = X86ISD::XOR; break;
15008     case ISD::AND: Opcode = X86ISD::AND; break;
15009     case ISD::OR: {
15010       if (!NeedTruncation && (X86CC == X86::COND_E || X86CC == X86::COND_NE)) {
15011         SDValue EFLAGS = LowerVectorAllZeroTest(Op, Subtarget, DAG);
15012         if (EFLAGS.getNode())
15013           return EFLAGS;
15014       }
15015       Opcode = X86ISD::OR;
15016       break;
15017     }
15018     }
15019
15020     NumOperands = 2;
15021     break;
15022   case X86ISD::ADD:
15023   case X86ISD::SUB:
15024   case X86ISD::INC:
15025   case X86ISD::DEC:
15026   case X86ISD::OR:
15027   case X86ISD::XOR:
15028   case X86ISD::AND:
15029     return SDValue(Op.getNode(), 1);
15030   default:
15031   default_case:
15032     break;
15033   }
15034
15035   // If we found that truncation is beneficial, perform the truncation and
15036   // update 'Op'.
15037   if (NeedTruncation) {
15038     EVT VT = Op.getValueType();
15039     SDValue WideVal = Op->getOperand(0);
15040     EVT WideVT = WideVal.getValueType();
15041     unsigned ConvertedOp = 0;
15042     // Use a target machine opcode to prevent further DAGCombine
15043     // optimizations that may separate the arithmetic operations
15044     // from the setcc node.
15045     switch (WideVal.getOpcode()) {
15046       default: break;
15047       case ISD::ADD: ConvertedOp = X86ISD::ADD; break;
15048       case ISD::SUB: ConvertedOp = X86ISD::SUB; break;
15049       case ISD::AND: ConvertedOp = X86ISD::AND; break;
15050       case ISD::OR:  ConvertedOp = X86ISD::OR;  break;
15051       case ISD::XOR: ConvertedOp = X86ISD::XOR; break;
15052     }
15053
15054     if (ConvertedOp) {
15055       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
15056       if (TLI.isOperationLegal(WideVal.getOpcode(), WideVT)) {
15057         SDValue V0 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(0));
15058         SDValue V1 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(1));
15059         Op = DAG.getNode(ConvertedOp, dl, VT, V0, V1);
15060       }
15061     }
15062   }
15063
15064   if (Opcode == 0)
15065     // Emit a CMP with 0, which is the TEST pattern.
15066     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
15067                        DAG.getConstant(0, Op.getValueType()));
15068
15069   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
15070   SmallVector<SDValue, 4> Ops;
15071   for (unsigned i = 0; i != NumOperands; ++i)
15072     Ops.push_back(Op.getOperand(i));
15073
15074   SDValue New = DAG.getNode(Opcode, dl, VTs, Ops);
15075   DAG.ReplaceAllUsesWith(Op, New);
15076   return SDValue(New.getNode(), 1);
15077 }
15078
15079 /// Emit nodes that will be selected as "cmp Op0,Op1", or something
15080 /// equivalent.
15081 SDValue X86TargetLowering::EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC,
15082                                    SDLoc dl, SelectionDAG &DAG) const {
15083   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op1)) {
15084     if (C->getAPIntValue() == 0)
15085       return EmitTest(Op0, X86CC, dl, DAG);
15086
15087      if (Op0.getValueType() == MVT::i1)
15088        llvm_unreachable("Unexpected comparison operation for MVT::i1 operands");
15089   }
15090
15091   if ((Op0.getValueType() == MVT::i8 || Op0.getValueType() == MVT::i16 ||
15092        Op0.getValueType() == MVT::i32 || Op0.getValueType() == MVT::i64)) {
15093     // Do the comparison at i32 if it's smaller, besides the Atom case.
15094     // This avoids subregister aliasing issues. Keep the smaller reference
15095     // if we're optimizing for size, however, as that'll allow better folding
15096     // of memory operations.
15097     if (Op0.getValueType() != MVT::i32 && Op0.getValueType() != MVT::i64 &&
15098         !DAG.getMachineFunction().getFunction()->getAttributes().hasAttribute(
15099              AttributeSet::FunctionIndex, Attribute::MinSize) &&
15100         !Subtarget->isAtom()) {
15101       unsigned ExtendOp =
15102           isX86CCUnsigned(X86CC) ? ISD::ZERO_EXTEND : ISD::SIGN_EXTEND;
15103       Op0 = DAG.getNode(ExtendOp, dl, MVT::i32, Op0);
15104       Op1 = DAG.getNode(ExtendOp, dl, MVT::i32, Op1);
15105     }
15106     // Use SUB instead of CMP to enable CSE between SUB and CMP.
15107     SDVTList VTs = DAG.getVTList(Op0.getValueType(), MVT::i32);
15108     SDValue Sub = DAG.getNode(X86ISD::SUB, dl, VTs,
15109                               Op0, Op1);
15110     return SDValue(Sub.getNode(), 1);
15111   }
15112   return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
15113 }
15114
15115 /// Convert a comparison if required by the subtarget.
15116 SDValue X86TargetLowering::ConvertCmpIfNecessary(SDValue Cmp,
15117                                                  SelectionDAG &DAG) const {
15118   // If the subtarget does not support the FUCOMI instruction, floating-point
15119   // comparisons have to be converted.
15120   if (Subtarget->hasCMov() ||
15121       Cmp.getOpcode() != X86ISD::CMP ||
15122       !Cmp.getOperand(0).getValueType().isFloatingPoint() ||
15123       !Cmp.getOperand(1).getValueType().isFloatingPoint())
15124     return Cmp;
15125
15126   // The instruction selector will select an FUCOM instruction instead of
15127   // FUCOMI, which writes the comparison result to FPSW instead of EFLAGS. Hence
15128   // build an SDNode sequence that transfers the result from FPSW into EFLAGS:
15129   // (X86sahf (trunc (srl (X86fp_stsw (trunc (X86cmp ...)), 8))))
15130   SDLoc dl(Cmp);
15131   SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
15132   SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
15133   SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
15134                             DAG.getConstant(8, MVT::i8));
15135   SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
15136   return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
15137 }
15138
15139 /// The minimum architected relative accuracy is 2^-12. We need one
15140 /// Newton-Raphson step to have a good float result (24 bits of precision).
15141 SDValue X86TargetLowering::getRsqrtEstimate(SDValue Op,
15142                                             DAGCombinerInfo &DCI,
15143                                             unsigned &RefinementSteps,
15144                                             bool &UseOneConstNR) const {
15145   // FIXME: We should use instruction latency models to calculate the cost of
15146   // each potential sequence, but this is very hard to do reliably because
15147   // at least Intel's Core* chips have variable timing based on the number of
15148   // significant digits in the divisor and/or sqrt operand.
15149   if (!Subtarget->useSqrtEst())
15150     return SDValue();
15151
15152   EVT VT = Op.getValueType();
15153
15154   // SSE1 has rsqrtss and rsqrtps.
15155   // TODO: Add support for AVX512 (v16f32).
15156   // It is likely not profitable to do this for f64 because a double-precision
15157   // rsqrt estimate with refinement on x86 prior to FMA requires at least 16
15158   // instructions: convert to single, rsqrtss, convert back to double, refine
15159   // (3 steps = at least 13 insts). If an 'rsqrtsd' variant was added to the ISA
15160   // along with FMA, this could be a throughput win.
15161   if ((Subtarget->hasSSE1() && (VT == MVT::f32 || VT == MVT::v4f32)) ||
15162       (Subtarget->hasAVX() && VT == MVT::v8f32)) {
15163     RefinementSteps = 1;
15164     UseOneConstNR = false;
15165     return DCI.DAG.getNode(X86ISD::FRSQRT, SDLoc(Op), VT, Op);
15166   }
15167   return SDValue();
15168 }
15169
15170 /// The minimum architected relative accuracy is 2^-12. We need one
15171 /// Newton-Raphson step to have a good float result (24 bits of precision).
15172 SDValue X86TargetLowering::getRecipEstimate(SDValue Op,
15173                                             DAGCombinerInfo &DCI,
15174                                             unsigned &RefinementSteps) const {
15175   // FIXME: We should use instruction latency models to calculate the cost of
15176   // each potential sequence, but this is very hard to do reliably because
15177   // at least Intel's Core* chips have variable timing based on the number of
15178   // significant digits in the divisor.
15179   if (!Subtarget->useReciprocalEst())
15180     return SDValue();
15181
15182   EVT VT = Op.getValueType();
15183
15184   // SSE1 has rcpss and rcpps. AVX adds a 256-bit variant for rcpps.
15185   // TODO: Add support for AVX512 (v16f32).
15186   // It is likely not profitable to do this for f64 because a double-precision
15187   // reciprocal estimate with refinement on x86 prior to FMA requires
15188   // 15 instructions: convert to single, rcpss, convert back to double, refine
15189   // (3 steps = 12 insts). If an 'rcpsd' variant was added to the ISA
15190   // along with FMA, this could be a throughput win.
15191   if ((Subtarget->hasSSE1() && (VT == MVT::f32 || VT == MVT::v4f32)) ||
15192       (Subtarget->hasAVX() && VT == MVT::v8f32)) {
15193     RefinementSteps = ReciprocalEstimateRefinementSteps;
15194     return DCI.DAG.getNode(X86ISD::FRCP, SDLoc(Op), VT, Op);
15195   }
15196   return SDValue();
15197 }
15198
15199 static bool isAllOnes(SDValue V) {
15200   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
15201   return C && C->isAllOnesValue();
15202 }
15203
15204 /// LowerToBT - Result of 'and' is compared against zero. Turn it into a BT node
15205 /// if it's possible.
15206 SDValue X86TargetLowering::LowerToBT(SDValue And, ISD::CondCode CC,
15207                                      SDLoc dl, SelectionDAG &DAG) const {
15208   SDValue Op0 = And.getOperand(0);
15209   SDValue Op1 = And.getOperand(1);
15210   if (Op0.getOpcode() == ISD::TRUNCATE)
15211     Op0 = Op0.getOperand(0);
15212   if (Op1.getOpcode() == ISD::TRUNCATE)
15213     Op1 = Op1.getOperand(0);
15214
15215   SDValue LHS, RHS;
15216   if (Op1.getOpcode() == ISD::SHL)
15217     std::swap(Op0, Op1);
15218   if (Op0.getOpcode() == ISD::SHL) {
15219     if (ConstantSDNode *And00C = dyn_cast<ConstantSDNode>(Op0.getOperand(0)))
15220       if (And00C->getZExtValue() == 1) {
15221         // If we looked past a truncate, check that it's only truncating away
15222         // known zeros.
15223         unsigned BitWidth = Op0.getValueSizeInBits();
15224         unsigned AndBitWidth = And.getValueSizeInBits();
15225         if (BitWidth > AndBitWidth) {
15226           APInt Zeros, Ones;
15227           DAG.computeKnownBits(Op0, Zeros, Ones);
15228           if (Zeros.countLeadingOnes() < BitWidth - AndBitWidth)
15229             return SDValue();
15230         }
15231         LHS = Op1;
15232         RHS = Op0.getOperand(1);
15233       }
15234   } else if (Op1.getOpcode() == ISD::Constant) {
15235     ConstantSDNode *AndRHS = cast<ConstantSDNode>(Op1);
15236     uint64_t AndRHSVal = AndRHS->getZExtValue();
15237     SDValue AndLHS = Op0;
15238
15239     if (AndRHSVal == 1 && AndLHS.getOpcode() == ISD::SRL) {
15240       LHS = AndLHS.getOperand(0);
15241       RHS = AndLHS.getOperand(1);
15242     }
15243
15244     // Use BT if the immediate can't be encoded in a TEST instruction.
15245     if (!isUInt<32>(AndRHSVal) && isPowerOf2_64(AndRHSVal)) {
15246       LHS = AndLHS;
15247       RHS = DAG.getConstant(Log2_64_Ceil(AndRHSVal), LHS.getValueType());
15248     }
15249   }
15250
15251   if (LHS.getNode()) {
15252     // If LHS is i8, promote it to i32 with any_extend.  There is no i8 BT
15253     // instruction.  Since the shift amount is in-range-or-undefined, we know
15254     // that doing a bittest on the i32 value is ok.  We extend to i32 because
15255     // the encoding for the i16 version is larger than the i32 version.
15256     // Also promote i16 to i32 for performance / code size reason.
15257     if (LHS.getValueType() == MVT::i8 ||
15258         LHS.getValueType() == MVT::i16)
15259       LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
15260
15261     // If the operand types disagree, extend the shift amount to match.  Since
15262     // BT ignores high bits (like shifts) we can use anyextend.
15263     if (LHS.getValueType() != RHS.getValueType())
15264       RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
15265
15266     SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
15267     X86::CondCode Cond = CC == ISD::SETEQ ? X86::COND_AE : X86::COND_B;
15268     return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
15269                        DAG.getConstant(Cond, MVT::i8), BT);
15270   }
15271
15272   return SDValue();
15273 }
15274
15275 /// \brief - Turns an ISD::CondCode into a value suitable for SSE floating point
15276 /// mask CMPs.
15277 static int translateX86FSETCC(ISD::CondCode SetCCOpcode, SDValue &Op0,
15278                               SDValue &Op1) {
15279   unsigned SSECC;
15280   bool Swap = false;
15281
15282   // SSE Condition code mapping:
15283   //  0 - EQ
15284   //  1 - LT
15285   //  2 - LE
15286   //  3 - UNORD
15287   //  4 - NEQ
15288   //  5 - NLT
15289   //  6 - NLE
15290   //  7 - ORD
15291   switch (SetCCOpcode) {
15292   default: llvm_unreachable("Unexpected SETCC condition");
15293   case ISD::SETOEQ:
15294   case ISD::SETEQ:  SSECC = 0; break;
15295   case ISD::SETOGT:
15296   case ISD::SETGT:  Swap = true; // Fallthrough
15297   case ISD::SETLT:
15298   case ISD::SETOLT: SSECC = 1; break;
15299   case ISD::SETOGE:
15300   case ISD::SETGE:  Swap = true; // Fallthrough
15301   case ISD::SETLE:
15302   case ISD::SETOLE: SSECC = 2; break;
15303   case ISD::SETUO:  SSECC = 3; break;
15304   case ISD::SETUNE:
15305   case ISD::SETNE:  SSECC = 4; break;
15306   case ISD::SETULE: Swap = true; // Fallthrough
15307   case ISD::SETUGE: SSECC = 5; break;
15308   case ISD::SETULT: Swap = true; // Fallthrough
15309   case ISD::SETUGT: SSECC = 6; break;
15310   case ISD::SETO:   SSECC = 7; break;
15311   case ISD::SETUEQ:
15312   case ISD::SETONE: SSECC = 8; break;
15313   }
15314   if (Swap)
15315     std::swap(Op0, Op1);
15316
15317   return SSECC;
15318 }
15319
15320 // Lower256IntVSETCC - Break a VSETCC 256-bit integer VSETCC into two new 128
15321 // ones, and then concatenate the result back.
15322 static SDValue Lower256IntVSETCC(SDValue Op, SelectionDAG &DAG) {
15323   MVT VT = Op.getSimpleValueType();
15324
15325   assert(VT.is256BitVector() && Op.getOpcode() == ISD::SETCC &&
15326          "Unsupported value type for operation");
15327
15328   unsigned NumElems = VT.getVectorNumElements();
15329   SDLoc dl(Op);
15330   SDValue CC = Op.getOperand(2);
15331
15332   // Extract the LHS vectors
15333   SDValue LHS = Op.getOperand(0);
15334   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
15335   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
15336
15337   // Extract the RHS vectors
15338   SDValue RHS = Op.getOperand(1);
15339   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
15340   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
15341
15342   // Issue the operation on the smaller types and concatenate the result back
15343   MVT EltVT = VT.getVectorElementType();
15344   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
15345   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
15346                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
15347                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
15348 }
15349
15350 static SDValue LowerIntVSETCC_AVX512(SDValue Op, SelectionDAG &DAG,
15351                                      const X86Subtarget *Subtarget) {
15352   SDValue Op0 = Op.getOperand(0);
15353   SDValue Op1 = Op.getOperand(1);
15354   SDValue CC = Op.getOperand(2);
15355   MVT VT = Op.getSimpleValueType();
15356   SDLoc dl(Op);
15357
15358   assert(Op0.getValueType().getVectorElementType().getSizeInBits() >= 8 &&
15359          Op.getValueType().getScalarType() == MVT::i1 &&
15360          "Cannot set masked compare for this operation");
15361
15362   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
15363   unsigned  Opc = 0;
15364   bool Unsigned = false;
15365   bool Swap = false;
15366   unsigned SSECC;
15367   switch (SetCCOpcode) {
15368   default: llvm_unreachable("Unexpected SETCC condition");
15369   case ISD::SETNE:  SSECC = 4; break;
15370   case ISD::SETEQ:  Opc = X86ISD::PCMPEQM; break;
15371   case ISD::SETUGT: SSECC = 6; Unsigned = true; break;
15372   case ISD::SETLT:  Swap = true; //fall-through
15373   case ISD::SETGT:  Opc = X86ISD::PCMPGTM; break;
15374   case ISD::SETULT: SSECC = 1; Unsigned = true; break;
15375   case ISD::SETUGE: SSECC = 5; Unsigned = true; break; //NLT
15376   case ISD::SETGE:  Swap = true; SSECC = 2; break; // LE + swap
15377   case ISD::SETULE: Unsigned = true; //fall-through
15378   case ISD::SETLE:  SSECC = 2; break;
15379   }
15380
15381   if (Swap)
15382     std::swap(Op0, Op1);
15383   if (Opc)
15384     return DAG.getNode(Opc, dl, VT, Op0, Op1);
15385   Opc = Unsigned ? X86ISD::CMPMU: X86ISD::CMPM;
15386   return DAG.getNode(Opc, dl, VT, Op0, Op1,
15387                      DAG.getConstant(SSECC, MVT::i8));
15388 }
15389
15390 /// \brief Try to turn a VSETULT into a VSETULE by modifying its second
15391 /// operand \p Op1.  If non-trivial (for example because it's not constant)
15392 /// return an empty value.
15393 static SDValue ChangeVSETULTtoVSETULE(SDLoc dl, SDValue Op1, SelectionDAG &DAG)
15394 {
15395   BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Op1.getNode());
15396   if (!BV)
15397     return SDValue();
15398
15399   MVT VT = Op1.getSimpleValueType();
15400   MVT EVT = VT.getVectorElementType();
15401   unsigned n = VT.getVectorNumElements();
15402   SmallVector<SDValue, 8> ULTOp1;
15403
15404   for (unsigned i = 0; i < n; ++i) {
15405     ConstantSDNode *Elt = dyn_cast<ConstantSDNode>(BV->getOperand(i));
15406     if (!Elt || Elt->isOpaque() || Elt->getValueType(0) != EVT)
15407       return SDValue();
15408
15409     // Avoid underflow.
15410     APInt Val = Elt->getAPIntValue();
15411     if (Val == 0)
15412       return SDValue();
15413
15414     ULTOp1.push_back(DAG.getConstant(Val - 1, EVT));
15415   }
15416
15417   return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, ULTOp1);
15418 }
15419
15420 static SDValue LowerVSETCC(SDValue Op, const X86Subtarget *Subtarget,
15421                            SelectionDAG &DAG) {
15422   SDValue Op0 = Op.getOperand(0);
15423   SDValue Op1 = Op.getOperand(1);
15424   SDValue CC = Op.getOperand(2);
15425   MVT VT = Op.getSimpleValueType();
15426   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
15427   bool isFP = Op.getOperand(1).getSimpleValueType().isFloatingPoint();
15428   SDLoc dl(Op);
15429
15430   if (isFP) {
15431 #ifndef NDEBUG
15432     MVT EltVT = Op0.getSimpleValueType().getVectorElementType();
15433     assert(EltVT == MVT::f32 || EltVT == MVT::f64);
15434 #endif
15435
15436     unsigned SSECC = translateX86FSETCC(SetCCOpcode, Op0, Op1);
15437     unsigned Opc = X86ISD::CMPP;
15438     if (Subtarget->hasAVX512() && VT.getVectorElementType() == MVT::i1) {
15439       assert(VT.getVectorNumElements() <= 16);
15440       Opc = X86ISD::CMPM;
15441     }
15442     // In the two special cases we can't handle, emit two comparisons.
15443     if (SSECC == 8) {
15444       unsigned CC0, CC1;
15445       unsigned CombineOpc;
15446       if (SetCCOpcode == ISD::SETUEQ) {
15447         CC0 = 3; CC1 = 0; CombineOpc = ISD::OR;
15448       } else {
15449         assert(SetCCOpcode == ISD::SETONE);
15450         CC0 = 7; CC1 = 4; CombineOpc = ISD::AND;
15451       }
15452
15453       SDValue Cmp0 = DAG.getNode(Opc, dl, VT, Op0, Op1,
15454                                  DAG.getConstant(CC0, MVT::i8));
15455       SDValue Cmp1 = DAG.getNode(Opc, dl, VT, Op0, Op1,
15456                                  DAG.getConstant(CC1, MVT::i8));
15457       return DAG.getNode(CombineOpc, dl, VT, Cmp0, Cmp1);
15458     }
15459     // Handle all other FP comparisons here.
15460     return DAG.getNode(Opc, dl, VT, Op0, Op1,
15461                        DAG.getConstant(SSECC, MVT::i8));
15462   }
15463
15464   // Break 256-bit integer vector compare into smaller ones.
15465   if (VT.is256BitVector() && !Subtarget->hasInt256())
15466     return Lower256IntVSETCC(Op, DAG);
15467
15468   bool MaskResult = (VT.getVectorElementType() == MVT::i1);
15469   EVT OpVT = Op1.getValueType();
15470   if (Subtarget->hasAVX512()) {
15471     if (Op1.getValueType().is512BitVector() ||
15472         (Subtarget->hasBWI() && Subtarget->hasVLX()) ||
15473         (MaskResult && OpVT.getVectorElementType().getSizeInBits() >= 32))
15474       return LowerIntVSETCC_AVX512(Op, DAG, Subtarget);
15475
15476     // In AVX-512 architecture setcc returns mask with i1 elements,
15477     // But there is no compare instruction for i8 and i16 elements in KNL.
15478     // We are not talking about 512-bit operands in this case, these
15479     // types are illegal.
15480     if (MaskResult &&
15481         (OpVT.getVectorElementType().getSizeInBits() < 32 &&
15482          OpVT.getVectorElementType().getSizeInBits() >= 8))
15483       return DAG.getNode(ISD::TRUNCATE, dl, VT,
15484                          DAG.getNode(ISD::SETCC, dl, OpVT, Op0, Op1, CC));
15485   }
15486
15487   // We are handling one of the integer comparisons here.  Since SSE only has
15488   // GT and EQ comparisons for integer, swapping operands and multiple
15489   // operations may be required for some comparisons.
15490   unsigned Opc;
15491   bool Swap = false, Invert = false, FlipSigns = false, MinMax = false;
15492   bool Subus = false;
15493
15494   switch (SetCCOpcode) {
15495   default: llvm_unreachable("Unexpected SETCC condition");
15496   case ISD::SETNE:  Invert = true;
15497   case ISD::SETEQ:  Opc = X86ISD::PCMPEQ; break;
15498   case ISD::SETLT:  Swap = true;
15499   case ISD::SETGT:  Opc = X86ISD::PCMPGT; break;
15500   case ISD::SETGE:  Swap = true;
15501   case ISD::SETLE:  Opc = X86ISD::PCMPGT;
15502                     Invert = true; break;
15503   case ISD::SETULT: Swap = true;
15504   case ISD::SETUGT: Opc = X86ISD::PCMPGT;
15505                     FlipSigns = true; break;
15506   case ISD::SETUGE: Swap = true;
15507   case ISD::SETULE: Opc = X86ISD::PCMPGT;
15508                     FlipSigns = true; Invert = true; break;
15509   }
15510
15511   // Special case: Use min/max operations for SETULE/SETUGE
15512   MVT VET = VT.getVectorElementType();
15513   bool hasMinMax =
15514        (Subtarget->hasSSE41() && (VET >= MVT::i8 && VET <= MVT::i32))
15515     || (Subtarget->hasSSE2()  && (VET == MVT::i8));
15516
15517   if (hasMinMax) {
15518     switch (SetCCOpcode) {
15519     default: break;
15520     case ISD::SETULE: Opc = X86ISD::UMIN; MinMax = true; break;
15521     case ISD::SETUGE: Opc = X86ISD::UMAX; MinMax = true; break;
15522     }
15523
15524     if (MinMax) { Swap = false; Invert = false; FlipSigns = false; }
15525   }
15526
15527   bool hasSubus = Subtarget->hasSSE2() && (VET == MVT::i8 || VET == MVT::i16);
15528   if (!MinMax && hasSubus) {
15529     // As another special case, use PSUBUS[BW] when it's profitable. E.g. for
15530     // Op0 u<= Op1:
15531     //   t = psubus Op0, Op1
15532     //   pcmpeq t, <0..0>
15533     switch (SetCCOpcode) {
15534     default: break;
15535     case ISD::SETULT: {
15536       // If the comparison is against a constant we can turn this into a
15537       // setule.  With psubus, setule does not require a swap.  This is
15538       // beneficial because the constant in the register is no longer
15539       // destructed as the destination so it can be hoisted out of a loop.
15540       // Only do this pre-AVX since vpcmp* is no longer destructive.
15541       if (Subtarget->hasAVX())
15542         break;
15543       SDValue ULEOp1 = ChangeVSETULTtoVSETULE(dl, Op1, DAG);
15544       if (ULEOp1.getNode()) {
15545         Op1 = ULEOp1;
15546         Subus = true; Invert = false; Swap = false;
15547       }
15548       break;
15549     }
15550     // Psubus is better than flip-sign because it requires no inversion.
15551     case ISD::SETUGE: Subus = true; Invert = false; Swap = true;  break;
15552     case ISD::SETULE: Subus = true; Invert = false; Swap = false; break;
15553     }
15554
15555     if (Subus) {
15556       Opc = X86ISD::SUBUS;
15557       FlipSigns = false;
15558     }
15559   }
15560
15561   if (Swap)
15562     std::swap(Op0, Op1);
15563
15564   // Check that the operation in question is available (most are plain SSE2,
15565   // but PCMPGTQ and PCMPEQQ have different requirements).
15566   if (VT == MVT::v2i64) {
15567     if (Opc == X86ISD::PCMPGT && !Subtarget->hasSSE42()) {
15568       assert(Subtarget->hasSSE2() && "Don't know how to lower!");
15569
15570       // First cast everything to the right type.
15571       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
15572       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
15573
15574       // Since SSE has no unsigned integer comparisons, we need to flip the sign
15575       // bits of the inputs before performing those operations. The lower
15576       // compare is always unsigned.
15577       SDValue SB;
15578       if (FlipSigns) {
15579         SB = DAG.getConstant(0x80000000U, MVT::v4i32);
15580       } else {
15581         SDValue Sign = DAG.getConstant(0x80000000U, MVT::i32);
15582         SDValue Zero = DAG.getConstant(0x00000000U, MVT::i32);
15583         SB = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
15584                          Sign, Zero, Sign, Zero);
15585       }
15586       Op0 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op0, SB);
15587       Op1 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op1, SB);
15588
15589       // Emulate PCMPGTQ with (hi1 > hi2) | ((hi1 == hi2) & (lo1 > lo2))
15590       SDValue GT = DAG.getNode(X86ISD::PCMPGT, dl, MVT::v4i32, Op0, Op1);
15591       SDValue EQ = DAG.getNode(X86ISD::PCMPEQ, dl, MVT::v4i32, Op0, Op1);
15592
15593       // Create masks for only the low parts/high parts of the 64 bit integers.
15594       static const int MaskHi[] = { 1, 1, 3, 3 };
15595       static const int MaskLo[] = { 0, 0, 2, 2 };
15596       SDValue EQHi = DAG.getVectorShuffle(MVT::v4i32, dl, EQ, EQ, MaskHi);
15597       SDValue GTLo = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskLo);
15598       SDValue GTHi = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskHi);
15599
15600       SDValue Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, EQHi, GTLo);
15601       Result = DAG.getNode(ISD::OR, dl, MVT::v4i32, Result, GTHi);
15602
15603       if (Invert)
15604         Result = DAG.getNOT(dl, Result, MVT::v4i32);
15605
15606       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
15607     }
15608
15609     if (Opc == X86ISD::PCMPEQ && !Subtarget->hasSSE41()) {
15610       // If pcmpeqq is missing but pcmpeqd is available synthesize pcmpeqq with
15611       // pcmpeqd + pshufd + pand.
15612       assert(Subtarget->hasSSE2() && !FlipSigns && "Don't know how to lower!");
15613
15614       // First cast everything to the right type.
15615       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
15616       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
15617
15618       // Do the compare.
15619       SDValue Result = DAG.getNode(Opc, dl, MVT::v4i32, Op0, Op1);
15620
15621       // Make sure the lower and upper halves are both all-ones.
15622       static const int Mask[] = { 1, 0, 3, 2 };
15623       SDValue Shuf = DAG.getVectorShuffle(MVT::v4i32, dl, Result, Result, Mask);
15624       Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, Result, Shuf);
15625
15626       if (Invert)
15627         Result = DAG.getNOT(dl, Result, MVT::v4i32);
15628
15629       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
15630     }
15631   }
15632
15633   // Since SSE has no unsigned integer comparisons, we need to flip the sign
15634   // bits of the inputs before performing those operations.
15635   if (FlipSigns) {
15636     EVT EltVT = VT.getVectorElementType();
15637     SDValue SB = DAG.getConstant(APInt::getSignBit(EltVT.getSizeInBits()), VT);
15638     Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SB);
15639     Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SB);
15640   }
15641
15642   SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
15643
15644   // If the logical-not of the result is required, perform that now.
15645   if (Invert)
15646     Result = DAG.getNOT(dl, Result, VT);
15647
15648   if (MinMax)
15649     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Op0, Result);
15650
15651   if (Subus)
15652     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Result,
15653                          getZeroVector(VT, Subtarget, DAG, dl));
15654
15655   return Result;
15656 }
15657
15658 SDValue X86TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
15659
15660   MVT VT = Op.getSimpleValueType();
15661
15662   if (VT.isVector()) return LowerVSETCC(Op, Subtarget, DAG);
15663
15664   assert(((!Subtarget->hasAVX512() && VT == MVT::i8) || (VT == MVT::i1))
15665          && "SetCC type must be 8-bit or 1-bit integer");
15666   SDValue Op0 = Op.getOperand(0);
15667   SDValue Op1 = Op.getOperand(1);
15668   SDLoc dl(Op);
15669   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
15670
15671   // Optimize to BT if possible.
15672   // Lower (X & (1 << N)) == 0 to BT(X, N).
15673   // Lower ((X >>u N) & 1) != 0 to BT(X, N).
15674   // Lower ((X >>s N) & 1) != 0 to BT(X, N).
15675   if (Op0.getOpcode() == ISD::AND && Op0.hasOneUse() &&
15676       Op1.getOpcode() == ISD::Constant &&
15677       cast<ConstantSDNode>(Op1)->isNullValue() &&
15678       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
15679     SDValue NewSetCC = LowerToBT(Op0, CC, dl, DAG);
15680     if (NewSetCC.getNode()) {
15681       if (VT == MVT::i1)
15682         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewSetCC);
15683       return NewSetCC;
15684     }
15685   }
15686
15687   // Look for X == 0, X == 1, X != 0, or X != 1.  We can simplify some forms of
15688   // these.
15689   if (Op1.getOpcode() == ISD::Constant &&
15690       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1 ||
15691        cast<ConstantSDNode>(Op1)->isNullValue()) &&
15692       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
15693
15694     // If the input is a setcc, then reuse the input setcc or use a new one with
15695     // the inverted condition.
15696     if (Op0.getOpcode() == X86ISD::SETCC) {
15697       X86::CondCode CCode = (X86::CondCode)Op0.getConstantOperandVal(0);
15698       bool Invert = (CC == ISD::SETNE) ^
15699         cast<ConstantSDNode>(Op1)->isNullValue();
15700       if (!Invert)
15701         return Op0;
15702
15703       CCode = X86::GetOppositeBranchCondition(CCode);
15704       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
15705                                   DAG.getConstant(CCode, MVT::i8),
15706                                   Op0.getOperand(1));
15707       if (VT == MVT::i1)
15708         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
15709       return SetCC;
15710     }
15711   }
15712   if ((Op0.getValueType() == MVT::i1) && (Op1.getOpcode() == ISD::Constant) &&
15713       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1) &&
15714       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
15715
15716     ISD::CondCode NewCC = ISD::getSetCCInverse(CC, true);
15717     return DAG.getSetCC(dl, VT, Op0, DAG.getConstant(0, MVT::i1), NewCC);
15718   }
15719
15720   bool isFP = Op1.getSimpleValueType().isFloatingPoint();
15721   unsigned X86CC = TranslateX86CC(CC, isFP, Op0, Op1, DAG);
15722   if (X86CC == X86::COND_INVALID)
15723     return SDValue();
15724
15725   SDValue EFLAGS = EmitCmp(Op0, Op1, X86CC, dl, DAG);
15726   EFLAGS = ConvertCmpIfNecessary(EFLAGS, DAG);
15727   SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
15728                               DAG.getConstant(X86CC, MVT::i8), EFLAGS);
15729   if (VT == MVT::i1)
15730     return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
15731   return SetCC;
15732 }
15733
15734 // isX86LogicalCmp - Return true if opcode is a X86 logical comparison.
15735 static bool isX86LogicalCmp(SDValue Op) {
15736   unsigned Opc = Op.getNode()->getOpcode();
15737   if (Opc == X86ISD::CMP || Opc == X86ISD::COMI || Opc == X86ISD::UCOMI ||
15738       Opc == X86ISD::SAHF)
15739     return true;
15740   if (Op.getResNo() == 1 &&
15741       (Opc == X86ISD::ADD ||
15742        Opc == X86ISD::SUB ||
15743        Opc == X86ISD::ADC ||
15744        Opc == X86ISD::SBB ||
15745        Opc == X86ISD::SMUL ||
15746        Opc == X86ISD::UMUL ||
15747        Opc == X86ISD::INC ||
15748        Opc == X86ISD::DEC ||
15749        Opc == X86ISD::OR ||
15750        Opc == X86ISD::XOR ||
15751        Opc == X86ISD::AND))
15752     return true;
15753
15754   if (Op.getResNo() == 2 && Opc == X86ISD::UMUL)
15755     return true;
15756
15757   return false;
15758 }
15759
15760 static bool isTruncWithZeroHighBitsInput(SDValue V, SelectionDAG &DAG) {
15761   if (V.getOpcode() != ISD::TRUNCATE)
15762     return false;
15763
15764   SDValue VOp0 = V.getOperand(0);
15765   unsigned InBits = VOp0.getValueSizeInBits();
15766   unsigned Bits = V.getValueSizeInBits();
15767   return DAG.MaskedValueIsZero(VOp0, APInt::getHighBitsSet(InBits,InBits-Bits));
15768 }
15769
15770 SDValue X86TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
15771   bool addTest = true;
15772   SDValue Cond  = Op.getOperand(0);
15773   SDValue Op1 = Op.getOperand(1);
15774   SDValue Op2 = Op.getOperand(2);
15775   SDLoc DL(Op);
15776   EVT VT = Op1.getValueType();
15777   SDValue CC;
15778
15779   // Lower fp selects into a CMP/AND/ANDN/OR sequence when the necessary SSE ops
15780   // are available. Otherwise fp cmovs get lowered into a less efficient branch
15781   // sequence later on.
15782   if (Cond.getOpcode() == ISD::SETCC &&
15783       ((Subtarget->hasSSE2() && (VT == MVT::f32 || VT == MVT::f64)) ||
15784        (Subtarget->hasSSE1() && VT == MVT::f32)) &&
15785       VT == Cond.getOperand(0).getValueType() && Cond->hasOneUse()) {
15786     SDValue CondOp0 = Cond.getOperand(0), CondOp1 = Cond.getOperand(1);
15787     int SSECC = translateX86FSETCC(
15788         cast<CondCodeSDNode>(Cond.getOperand(2))->get(), CondOp0, CondOp1);
15789
15790     if (SSECC != 8) {
15791       if (Subtarget->hasAVX512()) {
15792         SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CondOp0, CondOp1,
15793                                   DAG.getConstant(SSECC, MVT::i8));
15794         return DAG.getNode(X86ISD::SELECT, DL, VT, Cmp, Op1, Op2);
15795       }
15796       SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, VT, CondOp0, CondOp1,
15797                                 DAG.getConstant(SSECC, MVT::i8));
15798       SDValue AndN = DAG.getNode(X86ISD::FANDN, DL, VT, Cmp, Op2);
15799       SDValue And = DAG.getNode(X86ISD::FAND, DL, VT, Cmp, Op1);
15800       return DAG.getNode(X86ISD::FOR, DL, VT, AndN, And);
15801     }
15802   }
15803
15804   if (Cond.getOpcode() == ISD::SETCC) {
15805     SDValue NewCond = LowerSETCC(Cond, DAG);
15806     if (NewCond.getNode())
15807       Cond = NewCond;
15808   }
15809
15810   // (select (x == 0), -1, y) -> (sign_bit (x - 1)) | y
15811   // (select (x == 0), y, -1) -> ~(sign_bit (x - 1)) | y
15812   // (select (x != 0), y, -1) -> (sign_bit (x - 1)) | y
15813   // (select (x != 0), -1, y) -> ~(sign_bit (x - 1)) | y
15814   if (Cond.getOpcode() == X86ISD::SETCC &&
15815       Cond.getOperand(1).getOpcode() == X86ISD::CMP &&
15816       isZero(Cond.getOperand(1).getOperand(1))) {
15817     SDValue Cmp = Cond.getOperand(1);
15818
15819     unsigned CondCode =cast<ConstantSDNode>(Cond.getOperand(0))->getZExtValue();
15820
15821     if ((isAllOnes(Op1) || isAllOnes(Op2)) &&
15822         (CondCode == X86::COND_E || CondCode == X86::COND_NE)) {
15823       SDValue Y = isAllOnes(Op2) ? Op1 : Op2;
15824
15825       SDValue CmpOp0 = Cmp.getOperand(0);
15826       // Apply further optimizations for special cases
15827       // (select (x != 0), -1, 0) -> neg & sbb
15828       // (select (x == 0), 0, -1) -> neg & sbb
15829       if (ConstantSDNode *YC = dyn_cast<ConstantSDNode>(Y))
15830         if (YC->isNullValue() &&
15831             (isAllOnes(Op1) == (CondCode == X86::COND_NE))) {
15832           SDVTList VTs = DAG.getVTList(CmpOp0.getValueType(), MVT::i32);
15833           SDValue Neg = DAG.getNode(X86ISD::SUB, DL, VTs,
15834                                     DAG.getConstant(0, CmpOp0.getValueType()),
15835                                     CmpOp0);
15836           SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
15837                                     DAG.getConstant(X86::COND_B, MVT::i8),
15838                                     SDValue(Neg.getNode(), 1));
15839           return Res;
15840         }
15841
15842       Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
15843                         CmpOp0, DAG.getConstant(1, CmpOp0.getValueType()));
15844       Cmp = ConvertCmpIfNecessary(Cmp, DAG);
15845
15846       SDValue Res =   // Res = 0 or -1.
15847         DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
15848                     DAG.getConstant(X86::COND_B, MVT::i8), Cmp);
15849
15850       if (isAllOnes(Op1) != (CondCode == X86::COND_E))
15851         Res = DAG.getNOT(DL, Res, Res.getValueType());
15852
15853       ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(Op2);
15854       if (!N2C || !N2C->isNullValue())
15855         Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
15856       return Res;
15857     }
15858   }
15859
15860   // Look past (and (setcc_carry (cmp ...)), 1).
15861   if (Cond.getOpcode() == ISD::AND &&
15862       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
15863     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
15864     if (C && C->getAPIntValue() == 1)
15865       Cond = Cond.getOperand(0);
15866   }
15867
15868   // If condition flag is set by a X86ISD::CMP, then use it as the condition
15869   // setting operand in place of the X86ISD::SETCC.
15870   unsigned CondOpcode = Cond.getOpcode();
15871   if (CondOpcode == X86ISD::SETCC ||
15872       CondOpcode == X86ISD::SETCC_CARRY) {
15873     CC = Cond.getOperand(0);
15874
15875     SDValue Cmp = Cond.getOperand(1);
15876     unsigned Opc = Cmp.getOpcode();
15877     MVT VT = Op.getSimpleValueType();
15878
15879     bool IllegalFPCMov = false;
15880     if (VT.isFloatingPoint() && !VT.isVector() &&
15881         !isScalarFPTypeInSSEReg(VT))  // FPStack?
15882       IllegalFPCMov = !hasFPCMov(cast<ConstantSDNode>(CC)->getSExtValue());
15883
15884     if ((isX86LogicalCmp(Cmp) && !IllegalFPCMov) ||
15885         Opc == X86ISD::BT) { // FIXME
15886       Cond = Cmp;
15887       addTest = false;
15888     }
15889   } else if (CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
15890              CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
15891              ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
15892               Cond.getOperand(0).getValueType() != MVT::i8)) {
15893     SDValue LHS = Cond.getOperand(0);
15894     SDValue RHS = Cond.getOperand(1);
15895     unsigned X86Opcode;
15896     unsigned X86Cond;
15897     SDVTList VTs;
15898     switch (CondOpcode) {
15899     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
15900     case ISD::SADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
15901     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
15902     case ISD::SSUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
15903     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
15904     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
15905     default: llvm_unreachable("unexpected overflowing operator");
15906     }
15907     if (CondOpcode == ISD::UMULO)
15908       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
15909                           MVT::i32);
15910     else
15911       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
15912
15913     SDValue X86Op = DAG.getNode(X86Opcode, DL, VTs, LHS, RHS);
15914
15915     if (CondOpcode == ISD::UMULO)
15916       Cond = X86Op.getValue(2);
15917     else
15918       Cond = X86Op.getValue(1);
15919
15920     CC = DAG.getConstant(X86Cond, MVT::i8);
15921     addTest = false;
15922   }
15923
15924   if (addTest) {
15925     // Look pass the truncate if the high bits are known zero.
15926     if (isTruncWithZeroHighBitsInput(Cond, DAG))
15927         Cond = Cond.getOperand(0);
15928
15929     // We know the result of AND is compared against zero. Try to match
15930     // it to BT.
15931     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
15932       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, DL, DAG);
15933       if (NewSetCC.getNode()) {
15934         CC = NewSetCC.getOperand(0);
15935         Cond = NewSetCC.getOperand(1);
15936         addTest = false;
15937       }
15938     }
15939   }
15940
15941   if (addTest) {
15942     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
15943     Cond = EmitTest(Cond, X86::COND_NE, DL, DAG);
15944   }
15945
15946   // a <  b ? -1 :  0 -> RES = ~setcc_carry
15947   // a <  b ?  0 : -1 -> RES = setcc_carry
15948   // a >= b ? -1 :  0 -> RES = setcc_carry
15949   // a >= b ?  0 : -1 -> RES = ~setcc_carry
15950   if (Cond.getOpcode() == X86ISD::SUB) {
15951     Cond = ConvertCmpIfNecessary(Cond, DAG);
15952     unsigned CondCode = cast<ConstantSDNode>(CC)->getZExtValue();
15953
15954     if ((CondCode == X86::COND_AE || CondCode == X86::COND_B) &&
15955         (isAllOnes(Op1) || isAllOnes(Op2)) && (isZero(Op1) || isZero(Op2))) {
15956       SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
15957                                 DAG.getConstant(X86::COND_B, MVT::i8), Cond);
15958       if (isAllOnes(Op1) != (CondCode == X86::COND_B))
15959         return DAG.getNOT(DL, Res, Res.getValueType());
15960       return Res;
15961     }
15962   }
15963
15964   // X86 doesn't have an i8 cmov. If both operands are the result of a truncate
15965   // widen the cmov and push the truncate through. This avoids introducing a new
15966   // branch during isel and doesn't add any extensions.
15967   if (Op.getValueType() == MVT::i8 &&
15968       Op1.getOpcode() == ISD::TRUNCATE && Op2.getOpcode() == ISD::TRUNCATE) {
15969     SDValue T1 = Op1.getOperand(0), T2 = Op2.getOperand(0);
15970     if (T1.getValueType() == T2.getValueType() &&
15971         // Blacklist CopyFromReg to avoid partial register stalls.
15972         T1.getOpcode() != ISD::CopyFromReg && T2.getOpcode()!=ISD::CopyFromReg){
15973       SDVTList VTs = DAG.getVTList(T1.getValueType(), MVT::Glue);
15974       SDValue Cmov = DAG.getNode(X86ISD::CMOV, DL, VTs, T2, T1, CC, Cond);
15975       return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
15976     }
15977   }
15978
15979   // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
15980   // condition is true.
15981   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
15982   SDValue Ops[] = { Op2, Op1, CC, Cond };
15983   return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops);
15984 }
15985
15986 static SDValue LowerSIGN_EXTEND_AVX512(SDValue Op, const X86Subtarget *Subtarget,
15987                                        SelectionDAG &DAG) {
15988   MVT VT = Op->getSimpleValueType(0);
15989   SDValue In = Op->getOperand(0);
15990   MVT InVT = In.getSimpleValueType();
15991   MVT VTElt = VT.getVectorElementType();
15992   MVT InVTElt = InVT.getVectorElementType();
15993   SDLoc dl(Op);
15994
15995   // SKX processor
15996   if ((InVTElt == MVT::i1) &&
15997       (((Subtarget->hasBWI() && Subtarget->hasVLX() &&
15998         VT.getSizeInBits() <= 256 && VTElt.getSizeInBits() <= 16)) ||
15999
16000        ((Subtarget->hasBWI() && VT.is512BitVector() &&
16001         VTElt.getSizeInBits() <= 16)) ||
16002
16003        ((Subtarget->hasDQI() && Subtarget->hasVLX() &&
16004         VT.getSizeInBits() <= 256 && VTElt.getSizeInBits() >= 32)) ||
16005
16006        ((Subtarget->hasDQI() && VT.is512BitVector() &&
16007         VTElt.getSizeInBits() >= 32))))
16008     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16009
16010   unsigned int NumElts = VT.getVectorNumElements();
16011
16012   if (NumElts != 8 && NumElts != 16)
16013     return SDValue();
16014
16015   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1) {
16016     if (In.getOpcode() == X86ISD::VSEXT || In.getOpcode() == X86ISD::VZEXT)
16017       return DAG.getNode(In.getOpcode(), dl, VT, In.getOperand(0));
16018     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16019   }
16020
16021   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16022   assert (InVT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
16023
16024   MVT ExtVT = (NumElts == 8) ? MVT::v8i64 : MVT::v16i32;
16025   Constant *C = ConstantInt::get(*DAG.getContext(),
16026     APInt::getAllOnesValue(ExtVT.getScalarType().getSizeInBits()));
16027
16028   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
16029   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
16030   SDValue Ld = DAG.getLoad(ExtVT.getScalarType(), dl, DAG.getEntryNode(), CP,
16031                           MachinePointerInfo::getConstantPool(),
16032                           false, false, false, Alignment);
16033   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, dl, ExtVT, In, Ld);
16034   if (VT.is512BitVector())
16035     return Brcst;
16036   return DAG.getNode(X86ISD::VTRUNC, dl, VT, Brcst);
16037 }
16038
16039 static SDValue LowerSIGN_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
16040                                 SelectionDAG &DAG) {
16041   MVT VT = Op->getSimpleValueType(0);
16042   SDValue In = Op->getOperand(0);
16043   MVT InVT = In.getSimpleValueType();
16044   SDLoc dl(Op);
16045
16046   if (VT.is512BitVector() || InVT.getVectorElementType() == MVT::i1)
16047     return LowerSIGN_EXTEND_AVX512(Op, Subtarget, DAG);
16048
16049   if ((VT != MVT::v4i64 || InVT != MVT::v4i32) &&
16050       (VT != MVT::v8i32 || InVT != MVT::v8i16) &&
16051       (VT != MVT::v16i16 || InVT != MVT::v16i8))
16052     return SDValue();
16053
16054   if (Subtarget->hasInt256())
16055     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
16056
16057   // Optimize vectors in AVX mode
16058   // Sign extend  v8i16 to v8i32 and
16059   //              v4i32 to v4i64
16060   //
16061   // Divide input vector into two parts
16062   // for v4i32 the shuffle mask will be { 0, 1, -1, -1} {2, 3, -1, -1}
16063   // use vpmovsx instruction to extend v4i32 -> v2i64; v8i16 -> v4i32
16064   // concat the vectors to original VT
16065
16066   unsigned NumElems = InVT.getVectorNumElements();
16067   SDValue Undef = DAG.getUNDEF(InVT);
16068
16069   SmallVector<int,8> ShufMask1(NumElems, -1);
16070   for (unsigned i = 0; i != NumElems/2; ++i)
16071     ShufMask1[i] = i;
16072
16073   SDValue OpLo = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask1[0]);
16074
16075   SmallVector<int,8> ShufMask2(NumElems, -1);
16076   for (unsigned i = 0; i != NumElems/2; ++i)
16077     ShufMask2[i] = i + NumElems/2;
16078
16079   SDValue OpHi = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask2[0]);
16080
16081   MVT HalfVT = MVT::getVectorVT(VT.getScalarType(),
16082                                 VT.getVectorNumElements()/2);
16083
16084   OpLo = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpLo);
16085   OpHi = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpHi);
16086
16087   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
16088 }
16089
16090 // Lower vector extended loads using a shuffle. If SSSE3 is not available we
16091 // may emit an illegal shuffle but the expansion is still better than scalar
16092 // code. We generate X86ISD::VSEXT for SEXTLOADs if it's available, otherwise
16093 // we'll emit a shuffle and a arithmetic shift.
16094 // TODO: It is possible to support ZExt by zeroing the undef values during
16095 // the shuffle phase or after the shuffle.
16096 static SDValue LowerExtendedLoad(SDValue Op, const X86Subtarget *Subtarget,
16097                                  SelectionDAG &DAG) {
16098   MVT RegVT = Op.getSimpleValueType();
16099   assert(RegVT.isVector() && "We only custom lower vector sext loads.");
16100   assert(RegVT.isInteger() &&
16101          "We only custom lower integer vector sext loads.");
16102
16103   // Nothing useful we can do without SSE2 shuffles.
16104   assert(Subtarget->hasSSE2() && "We only custom lower sext loads with SSE2.");
16105
16106   LoadSDNode *Ld = cast<LoadSDNode>(Op.getNode());
16107   SDLoc dl(Ld);
16108   EVT MemVT = Ld->getMemoryVT();
16109   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16110   unsigned RegSz = RegVT.getSizeInBits();
16111
16112   ISD::LoadExtType Ext = Ld->getExtensionType();
16113
16114   assert((Ext == ISD::EXTLOAD || Ext == ISD::SEXTLOAD)
16115          && "Only anyext and sext are currently implemented.");
16116   assert(MemVT != RegVT && "Cannot extend to the same type");
16117   assert(MemVT.isVector() && "Must load a vector from memory");
16118
16119   unsigned NumElems = RegVT.getVectorNumElements();
16120   unsigned MemSz = MemVT.getSizeInBits();
16121   assert(RegSz > MemSz && "Register size must be greater than the mem size");
16122
16123   if (Ext == ISD::SEXTLOAD && RegSz == 256 && !Subtarget->hasInt256()) {
16124     // The only way in which we have a legal 256-bit vector result but not the
16125     // integer 256-bit operations needed to directly lower a sextload is if we
16126     // have AVX1 but not AVX2. In that case, we can always emit a sextload to
16127     // a 128-bit vector and a normal sign_extend to 256-bits that should get
16128     // correctly legalized. We do this late to allow the canonical form of
16129     // sextload to persist throughout the rest of the DAG combiner -- it wants
16130     // to fold together any extensions it can, and so will fuse a sign_extend
16131     // of an sextload into a sextload targeting a wider value.
16132     SDValue Load;
16133     if (MemSz == 128) {
16134       // Just switch this to a normal load.
16135       assert(TLI.isTypeLegal(MemVT) && "If the memory type is a 128-bit type, "
16136                                        "it must be a legal 128-bit vector "
16137                                        "type!");
16138       Load = DAG.getLoad(MemVT, dl, Ld->getChain(), Ld->getBasePtr(),
16139                   Ld->getPointerInfo(), Ld->isVolatile(), Ld->isNonTemporal(),
16140                   Ld->isInvariant(), Ld->getAlignment());
16141     } else {
16142       assert(MemSz < 128 &&
16143              "Can't extend a type wider than 128 bits to a 256 bit vector!");
16144       // Do an sext load to a 128-bit vector type. We want to use the same
16145       // number of elements, but elements half as wide. This will end up being
16146       // recursively lowered by this routine, but will succeed as we definitely
16147       // have all the necessary features if we're using AVX1.
16148       EVT HalfEltVT =
16149           EVT::getIntegerVT(*DAG.getContext(), RegVT.getScalarSizeInBits() / 2);
16150       EVT HalfVecVT = EVT::getVectorVT(*DAG.getContext(), HalfEltVT, NumElems);
16151       Load =
16152           DAG.getExtLoad(Ext, dl, HalfVecVT, Ld->getChain(), Ld->getBasePtr(),
16153                          Ld->getPointerInfo(), MemVT, Ld->isVolatile(),
16154                          Ld->isNonTemporal(), Ld->isInvariant(),
16155                          Ld->getAlignment());
16156     }
16157
16158     // Replace chain users with the new chain.
16159     assert(Load->getNumValues() == 2 && "Loads must carry a chain!");
16160     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), Load.getValue(1));
16161
16162     // Finally, do a normal sign-extend to the desired register.
16163     return DAG.getSExtOrTrunc(Load, dl, RegVT);
16164   }
16165
16166   // All sizes must be a power of two.
16167   assert(isPowerOf2_32(RegSz * MemSz * NumElems) &&
16168          "Non-power-of-two elements are not custom lowered!");
16169
16170   // Attempt to load the original value using scalar loads.
16171   // Find the largest scalar type that divides the total loaded size.
16172   MVT SclrLoadTy = MVT::i8;
16173   for (MVT Tp : MVT::integer_valuetypes()) {
16174     if (TLI.isTypeLegal(Tp) && ((MemSz % Tp.getSizeInBits()) == 0)) {
16175       SclrLoadTy = Tp;
16176     }
16177   }
16178
16179   // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
16180   if (TLI.isTypeLegal(MVT::f64) && SclrLoadTy.getSizeInBits() < 64 &&
16181       (64 <= MemSz))
16182     SclrLoadTy = MVT::f64;
16183
16184   // Calculate the number of scalar loads that we need to perform
16185   // in order to load our vector from memory.
16186   unsigned NumLoads = MemSz / SclrLoadTy.getSizeInBits();
16187
16188   assert((Ext != ISD::SEXTLOAD || NumLoads == 1) &&
16189          "Can only lower sext loads with a single scalar load!");
16190
16191   unsigned loadRegZize = RegSz;
16192   if (Ext == ISD::SEXTLOAD && RegSz == 256)
16193     loadRegZize /= 2;
16194
16195   // Represent our vector as a sequence of elements which are the
16196   // largest scalar that we can load.
16197   EVT LoadUnitVecVT = EVT::getVectorVT(
16198       *DAG.getContext(), SclrLoadTy, loadRegZize / SclrLoadTy.getSizeInBits());
16199
16200   // Represent the data using the same element type that is stored in
16201   // memory. In practice, we ''widen'' MemVT.
16202   EVT WideVecVT =
16203       EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
16204                        loadRegZize / MemVT.getScalarType().getSizeInBits());
16205
16206   assert(WideVecVT.getSizeInBits() == LoadUnitVecVT.getSizeInBits() &&
16207          "Invalid vector type");
16208
16209   // We can't shuffle using an illegal type.
16210   assert(TLI.isTypeLegal(WideVecVT) &&
16211          "We only lower types that form legal widened vector types");
16212
16213   SmallVector<SDValue, 8> Chains;
16214   SDValue Ptr = Ld->getBasePtr();
16215   SDValue Increment =
16216       DAG.getConstant(SclrLoadTy.getSizeInBits() / 8, TLI.getPointerTy());
16217   SDValue Res = DAG.getUNDEF(LoadUnitVecVT);
16218
16219   for (unsigned i = 0; i < NumLoads; ++i) {
16220     // Perform a single load.
16221     SDValue ScalarLoad =
16222         DAG.getLoad(SclrLoadTy, dl, Ld->getChain(), Ptr, Ld->getPointerInfo(),
16223                     Ld->isVolatile(), Ld->isNonTemporal(), Ld->isInvariant(),
16224                     Ld->getAlignment());
16225     Chains.push_back(ScalarLoad.getValue(1));
16226     // Create the first element type using SCALAR_TO_VECTOR in order to avoid
16227     // another round of DAGCombining.
16228     if (i == 0)
16229       Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoadUnitVecVT, ScalarLoad);
16230     else
16231       Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, LoadUnitVecVT, Res,
16232                         ScalarLoad, DAG.getIntPtrConstant(i));
16233
16234     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
16235   }
16236
16237   SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
16238
16239   // Bitcast the loaded value to a vector of the original element type, in
16240   // the size of the target vector type.
16241   SDValue SlicedVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Res);
16242   unsigned SizeRatio = RegSz / MemSz;
16243
16244   if (Ext == ISD::SEXTLOAD) {
16245     // If we have SSE4.1, we can directly emit a VSEXT node.
16246     if (Subtarget->hasSSE41()) {
16247       SDValue Sext = DAG.getNode(X86ISD::VSEXT, dl, RegVT, SlicedVec);
16248       DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16249       return Sext;
16250     }
16251
16252     // Otherwise we'll shuffle the small elements in the high bits of the
16253     // larger type and perform an arithmetic shift. If the shift is not legal
16254     // it's better to scalarize.
16255     assert(TLI.isOperationLegalOrCustom(ISD::SRA, RegVT) &&
16256            "We can't implement a sext load without an arithmetic right shift!");
16257
16258     // Redistribute the loaded elements into the different locations.
16259     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
16260     for (unsigned i = 0; i != NumElems; ++i)
16261       ShuffleVec[i * SizeRatio + SizeRatio - 1] = i;
16262
16263     SDValue Shuff = DAG.getVectorShuffle(
16264         WideVecVT, dl, SlicedVec, DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
16265
16266     Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
16267
16268     // Build the arithmetic shift.
16269     unsigned Amt = RegVT.getVectorElementType().getSizeInBits() -
16270                    MemVT.getVectorElementType().getSizeInBits();
16271     Shuff =
16272         DAG.getNode(ISD::SRA, dl, RegVT, Shuff, DAG.getConstant(Amt, RegVT));
16273
16274     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16275     return Shuff;
16276   }
16277
16278   // Redistribute the loaded elements into the different locations.
16279   SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
16280   for (unsigned i = 0; i != NumElems; ++i)
16281     ShuffleVec[i * SizeRatio] = i;
16282
16283   SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, SlicedVec,
16284                                        DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
16285
16286   // Bitcast to the requested type.
16287   Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
16288   DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
16289   return Shuff;
16290 }
16291
16292 // isAndOrOfSingleUseSetCCs - Return true if node is an ISD::AND or
16293 // ISD::OR of two X86ISD::SETCC nodes each of which has no other use apart
16294 // from the AND / OR.
16295 static bool isAndOrOfSetCCs(SDValue Op, unsigned &Opc) {
16296   Opc = Op.getOpcode();
16297   if (Opc != ISD::OR && Opc != ISD::AND)
16298     return false;
16299   return (Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
16300           Op.getOperand(0).hasOneUse() &&
16301           Op.getOperand(1).getOpcode() == X86ISD::SETCC &&
16302           Op.getOperand(1).hasOneUse());
16303 }
16304
16305 // isXor1OfSetCC - Return true if node is an ISD::XOR of a X86ISD::SETCC and
16306 // 1 and that the SETCC node has a single use.
16307 static bool isXor1OfSetCC(SDValue Op) {
16308   if (Op.getOpcode() != ISD::XOR)
16309     return false;
16310   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
16311   if (N1C && N1C->getAPIntValue() == 1) {
16312     return Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
16313       Op.getOperand(0).hasOneUse();
16314   }
16315   return false;
16316 }
16317
16318 SDValue X86TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
16319   bool addTest = true;
16320   SDValue Chain = Op.getOperand(0);
16321   SDValue Cond  = Op.getOperand(1);
16322   SDValue Dest  = Op.getOperand(2);
16323   SDLoc dl(Op);
16324   SDValue CC;
16325   bool Inverted = false;
16326
16327   if (Cond.getOpcode() == ISD::SETCC) {
16328     // Check for setcc([su]{add,sub,mul}o == 0).
16329     if (cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETEQ &&
16330         isa<ConstantSDNode>(Cond.getOperand(1)) &&
16331         cast<ConstantSDNode>(Cond.getOperand(1))->isNullValue() &&
16332         Cond.getOperand(0).getResNo() == 1 &&
16333         (Cond.getOperand(0).getOpcode() == ISD::SADDO ||
16334          Cond.getOperand(0).getOpcode() == ISD::UADDO ||
16335          Cond.getOperand(0).getOpcode() == ISD::SSUBO ||
16336          Cond.getOperand(0).getOpcode() == ISD::USUBO ||
16337          Cond.getOperand(0).getOpcode() == ISD::SMULO ||
16338          Cond.getOperand(0).getOpcode() == ISD::UMULO)) {
16339       Inverted = true;
16340       Cond = Cond.getOperand(0);
16341     } else {
16342       SDValue NewCond = LowerSETCC(Cond, DAG);
16343       if (NewCond.getNode())
16344         Cond = NewCond;
16345     }
16346   }
16347 #if 0
16348   // FIXME: LowerXALUO doesn't handle these!!
16349   else if (Cond.getOpcode() == X86ISD::ADD  ||
16350            Cond.getOpcode() == X86ISD::SUB  ||
16351            Cond.getOpcode() == X86ISD::SMUL ||
16352            Cond.getOpcode() == X86ISD::UMUL)
16353     Cond = LowerXALUO(Cond, DAG);
16354 #endif
16355
16356   // Look pass (and (setcc_carry (cmp ...)), 1).
16357   if (Cond.getOpcode() == ISD::AND &&
16358       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
16359     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
16360     if (C && C->getAPIntValue() == 1)
16361       Cond = Cond.getOperand(0);
16362   }
16363
16364   // If condition flag is set by a X86ISD::CMP, then use it as the condition
16365   // setting operand in place of the X86ISD::SETCC.
16366   unsigned CondOpcode = Cond.getOpcode();
16367   if (CondOpcode == X86ISD::SETCC ||
16368       CondOpcode == X86ISD::SETCC_CARRY) {
16369     CC = Cond.getOperand(0);
16370
16371     SDValue Cmp = Cond.getOperand(1);
16372     unsigned Opc = Cmp.getOpcode();
16373     // FIXME: WHY THE SPECIAL CASING OF LogicalCmp??
16374     if (isX86LogicalCmp(Cmp) || Opc == X86ISD::BT) {
16375       Cond = Cmp;
16376       addTest = false;
16377     } else {
16378       switch (cast<ConstantSDNode>(CC)->getZExtValue()) {
16379       default: break;
16380       case X86::COND_O:
16381       case X86::COND_B:
16382         // These can only come from an arithmetic instruction with overflow,
16383         // e.g. SADDO, UADDO.
16384         Cond = Cond.getNode()->getOperand(1);
16385         addTest = false;
16386         break;
16387       }
16388     }
16389   }
16390   CondOpcode = Cond.getOpcode();
16391   if (CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
16392       CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
16393       ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
16394        Cond.getOperand(0).getValueType() != MVT::i8)) {
16395     SDValue LHS = Cond.getOperand(0);
16396     SDValue RHS = Cond.getOperand(1);
16397     unsigned X86Opcode;
16398     unsigned X86Cond;
16399     SDVTList VTs;
16400     // Keep this in sync with LowerXALUO, otherwise we might create redundant
16401     // instructions that can't be removed afterwards (i.e. X86ISD::ADD and
16402     // X86ISD::INC).
16403     switch (CondOpcode) {
16404     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
16405     case ISD::SADDO:
16406       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
16407         if (C->isOne()) {
16408           X86Opcode = X86ISD::INC; X86Cond = X86::COND_O;
16409           break;
16410         }
16411       X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
16412     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
16413     case ISD::SSUBO:
16414       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
16415         if (C->isOne()) {
16416           X86Opcode = X86ISD::DEC; X86Cond = X86::COND_O;
16417           break;
16418         }
16419       X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
16420     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
16421     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
16422     default: llvm_unreachable("unexpected overflowing operator");
16423     }
16424     if (Inverted)
16425       X86Cond = X86::GetOppositeBranchCondition((X86::CondCode)X86Cond);
16426     if (CondOpcode == ISD::UMULO)
16427       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
16428                           MVT::i32);
16429     else
16430       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
16431
16432     SDValue X86Op = DAG.getNode(X86Opcode, dl, VTs, LHS, RHS);
16433
16434     if (CondOpcode == ISD::UMULO)
16435       Cond = X86Op.getValue(2);
16436     else
16437       Cond = X86Op.getValue(1);
16438
16439     CC = DAG.getConstant(X86Cond, MVT::i8);
16440     addTest = false;
16441   } else {
16442     unsigned CondOpc;
16443     if (Cond.hasOneUse() && isAndOrOfSetCCs(Cond, CondOpc)) {
16444       SDValue Cmp = Cond.getOperand(0).getOperand(1);
16445       if (CondOpc == ISD::OR) {
16446         // Also, recognize the pattern generated by an FCMP_UNE. We can emit
16447         // two branches instead of an explicit OR instruction with a
16448         // separate test.
16449         if (Cmp == Cond.getOperand(1).getOperand(1) &&
16450             isX86LogicalCmp(Cmp)) {
16451           CC = Cond.getOperand(0).getOperand(0);
16452           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16453                               Chain, Dest, CC, Cmp);
16454           CC = Cond.getOperand(1).getOperand(0);
16455           Cond = Cmp;
16456           addTest = false;
16457         }
16458       } else { // ISD::AND
16459         // Also, recognize the pattern generated by an FCMP_OEQ. We can emit
16460         // two branches instead of an explicit AND instruction with a
16461         // separate test. However, we only do this if this block doesn't
16462         // have a fall-through edge, because this requires an explicit
16463         // jmp when the condition is false.
16464         if (Cmp == Cond.getOperand(1).getOperand(1) &&
16465             isX86LogicalCmp(Cmp) &&
16466             Op.getNode()->hasOneUse()) {
16467           X86::CondCode CCode =
16468             (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
16469           CCode = X86::GetOppositeBranchCondition(CCode);
16470           CC = DAG.getConstant(CCode, MVT::i8);
16471           SDNode *User = *Op.getNode()->use_begin();
16472           // Look for an unconditional branch following this conditional branch.
16473           // We need this because we need to reverse the successors in order
16474           // to implement FCMP_OEQ.
16475           if (User->getOpcode() == ISD::BR) {
16476             SDValue FalseBB = User->getOperand(1);
16477             SDNode *NewBR =
16478               DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
16479             assert(NewBR == User);
16480             (void)NewBR;
16481             Dest = FalseBB;
16482
16483             Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16484                                 Chain, Dest, CC, Cmp);
16485             X86::CondCode CCode =
16486               (X86::CondCode)Cond.getOperand(1).getConstantOperandVal(0);
16487             CCode = X86::GetOppositeBranchCondition(CCode);
16488             CC = DAG.getConstant(CCode, MVT::i8);
16489             Cond = Cmp;
16490             addTest = false;
16491           }
16492         }
16493       }
16494     } else if (Cond.hasOneUse() && isXor1OfSetCC(Cond)) {
16495       // Recognize for xorb (setcc), 1 patterns. The xor inverts the condition.
16496       // It should be transformed during dag combiner except when the condition
16497       // is set by a arithmetics with overflow node.
16498       X86::CondCode CCode =
16499         (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
16500       CCode = X86::GetOppositeBranchCondition(CCode);
16501       CC = DAG.getConstant(CCode, MVT::i8);
16502       Cond = Cond.getOperand(0).getOperand(1);
16503       addTest = false;
16504     } else if (Cond.getOpcode() == ISD::SETCC &&
16505                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETOEQ) {
16506       // For FCMP_OEQ, we can emit
16507       // two branches instead of an explicit AND instruction with a
16508       // separate test. However, we only do this if this block doesn't
16509       // have a fall-through edge, because this requires an explicit
16510       // jmp when the condition is false.
16511       if (Op.getNode()->hasOneUse()) {
16512         SDNode *User = *Op.getNode()->use_begin();
16513         // Look for an unconditional branch following this conditional branch.
16514         // We need this because we need to reverse the successors in order
16515         // to implement FCMP_OEQ.
16516         if (User->getOpcode() == ISD::BR) {
16517           SDValue FalseBB = User->getOperand(1);
16518           SDNode *NewBR =
16519             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
16520           assert(NewBR == User);
16521           (void)NewBR;
16522           Dest = FalseBB;
16523
16524           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
16525                                     Cond.getOperand(0), Cond.getOperand(1));
16526           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
16527           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
16528           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16529                               Chain, Dest, CC, Cmp);
16530           CC = DAG.getConstant(X86::COND_P, MVT::i8);
16531           Cond = Cmp;
16532           addTest = false;
16533         }
16534       }
16535     } else if (Cond.getOpcode() == ISD::SETCC &&
16536                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETUNE) {
16537       // For FCMP_UNE, we can emit
16538       // two branches instead of an explicit AND instruction with a
16539       // separate test. However, we only do this if this block doesn't
16540       // have a fall-through edge, because this requires an explicit
16541       // jmp when the condition is false.
16542       if (Op.getNode()->hasOneUse()) {
16543         SDNode *User = *Op.getNode()->use_begin();
16544         // Look for an unconditional branch following this conditional branch.
16545         // We need this because we need to reverse the successors in order
16546         // to implement FCMP_UNE.
16547         if (User->getOpcode() == ISD::BR) {
16548           SDValue FalseBB = User->getOperand(1);
16549           SDNode *NewBR =
16550             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
16551           assert(NewBR == User);
16552           (void)NewBR;
16553
16554           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
16555                                     Cond.getOperand(0), Cond.getOperand(1));
16556           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
16557           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
16558           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16559                               Chain, Dest, CC, Cmp);
16560           CC = DAG.getConstant(X86::COND_NP, MVT::i8);
16561           Cond = Cmp;
16562           addTest = false;
16563           Dest = FalseBB;
16564         }
16565       }
16566     }
16567   }
16568
16569   if (addTest) {
16570     // Look pass the truncate if the high bits are known zero.
16571     if (isTruncWithZeroHighBitsInput(Cond, DAG))
16572         Cond = Cond.getOperand(0);
16573
16574     // We know the result of AND is compared against zero. Try to match
16575     // it to BT.
16576     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
16577       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, dl, DAG);
16578       if (NewSetCC.getNode()) {
16579         CC = NewSetCC.getOperand(0);
16580         Cond = NewSetCC.getOperand(1);
16581         addTest = false;
16582       }
16583     }
16584   }
16585
16586   if (addTest) {
16587     X86::CondCode X86Cond = Inverted ? X86::COND_E : X86::COND_NE;
16588     CC = DAG.getConstant(X86Cond, MVT::i8);
16589     Cond = EmitTest(Cond, X86Cond, dl, DAG);
16590   }
16591   Cond = ConvertCmpIfNecessary(Cond, DAG);
16592   return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
16593                      Chain, Dest, CC, Cond);
16594 }
16595
16596 // Lower dynamic stack allocation to _alloca call for Cygwin/Mingw targets.
16597 // Calls to _alloca are needed to probe the stack when allocating more than 4k
16598 // bytes in one go. Touching the stack at 4K increments is necessary to ensure
16599 // that the guard pages used by the OS virtual memory manager are allocated in
16600 // correct sequence.
16601 SDValue
16602 X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
16603                                            SelectionDAG &DAG) const {
16604   MachineFunction &MF = DAG.getMachineFunction();
16605   bool SplitStack = MF.shouldSplitStack();
16606   bool Lower = (Subtarget->isOSWindows() && !Subtarget->isTargetMachO()) ||
16607                SplitStack;
16608   SDLoc dl(Op);
16609
16610   if (!Lower) {
16611     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16612     SDNode* Node = Op.getNode();
16613
16614     unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore();
16615     assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and"
16616         " not tell us which reg is the stack pointer!");
16617     EVT VT = Node->getValueType(0);
16618     SDValue Tmp1 = SDValue(Node, 0);
16619     SDValue Tmp2 = SDValue(Node, 1);
16620     SDValue Tmp3 = Node->getOperand(2);
16621     SDValue Chain = Tmp1.getOperand(0);
16622
16623     // Chain the dynamic stack allocation so that it doesn't modify the stack
16624     // pointer when other instructions are using the stack.
16625     Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true),
16626         SDLoc(Node));
16627
16628     SDValue Size = Tmp2.getOperand(1);
16629     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
16630     Chain = SP.getValue(1);
16631     unsigned Align = cast<ConstantSDNode>(Tmp3)->getZExtValue();
16632     const TargetFrameLowering &TFI = *DAG.getSubtarget().getFrameLowering();
16633     unsigned StackAlign = TFI.getStackAlignment();
16634     Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
16635     if (Align > StackAlign)
16636       Tmp1 = DAG.getNode(ISD::AND, dl, VT, Tmp1,
16637           DAG.getConstant(-(uint64_t)Align, VT));
16638     Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain
16639
16640     Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true),
16641         DAG.getIntPtrConstant(0, true), SDValue(),
16642         SDLoc(Node));
16643
16644     SDValue Ops[2] = { Tmp1, Tmp2 };
16645     return DAG.getMergeValues(Ops, dl);
16646   }
16647
16648   // Get the inputs.
16649   SDValue Chain = Op.getOperand(0);
16650   SDValue Size  = Op.getOperand(1);
16651   unsigned Align = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue();
16652   EVT VT = Op.getNode()->getValueType(0);
16653
16654   bool Is64Bit = Subtarget->is64Bit();
16655   EVT SPTy = getPointerTy();
16656
16657   if (SplitStack) {
16658     MachineRegisterInfo &MRI = MF.getRegInfo();
16659
16660     if (Is64Bit) {
16661       // The 64 bit implementation of segmented stacks needs to clobber both r10
16662       // r11. This makes it impossible to use it along with nested parameters.
16663       const Function *F = MF.getFunction();
16664
16665       for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
16666            I != E; ++I)
16667         if (I->hasNestAttr())
16668           report_fatal_error("Cannot use segmented stacks with functions that "
16669                              "have nested arguments.");
16670     }
16671
16672     const TargetRegisterClass *AddrRegClass =
16673       getRegClassFor(getPointerTy());
16674     unsigned Vreg = MRI.createVirtualRegister(AddrRegClass);
16675     Chain = DAG.getCopyToReg(Chain, dl, Vreg, Size);
16676     SDValue Value = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
16677                                 DAG.getRegister(Vreg, SPTy));
16678     SDValue Ops1[2] = { Value, Chain };
16679     return DAG.getMergeValues(Ops1, dl);
16680   } else {
16681     SDValue Flag;
16682     const unsigned Reg = (Subtarget->isTarget64BitLP64() ? X86::RAX : X86::EAX);
16683
16684     Chain = DAG.getCopyToReg(Chain, dl, Reg, Size, Flag);
16685     Flag = Chain.getValue(1);
16686     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
16687
16688     Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
16689
16690     const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
16691         DAG.getSubtarget().getRegisterInfo());
16692     unsigned SPReg = RegInfo->getStackRegister();
16693     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, SPTy);
16694     Chain = SP.getValue(1);
16695
16696     if (Align) {
16697       SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
16698                        DAG.getConstant(-(uint64_t)Align, VT));
16699       Chain = DAG.getCopyToReg(Chain, dl, SPReg, SP);
16700     }
16701
16702     SDValue Ops1[2] = { SP, Chain };
16703     return DAG.getMergeValues(Ops1, dl);
16704   }
16705 }
16706
16707 SDValue X86TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
16708   MachineFunction &MF = DAG.getMachineFunction();
16709   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
16710
16711   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
16712   SDLoc DL(Op);
16713
16714   if (!Subtarget->is64Bit() || Subtarget->isTargetWin64()) {
16715     // vastart just stores the address of the VarArgsFrameIndex slot into the
16716     // memory location argument.
16717     SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
16718                                    getPointerTy());
16719     return DAG.getStore(Op.getOperand(0), DL, FR, Op.getOperand(1),
16720                         MachinePointerInfo(SV), false, false, 0);
16721   }
16722
16723   // __va_list_tag:
16724   //   gp_offset         (0 - 6 * 8)
16725   //   fp_offset         (48 - 48 + 8 * 16)
16726   //   overflow_arg_area (point to parameters coming in memory).
16727   //   reg_save_area
16728   SmallVector<SDValue, 8> MemOps;
16729   SDValue FIN = Op.getOperand(1);
16730   // Store gp_offset
16731   SDValue Store = DAG.getStore(Op.getOperand(0), DL,
16732                                DAG.getConstant(FuncInfo->getVarArgsGPOffset(),
16733                                                MVT::i32),
16734                                FIN, MachinePointerInfo(SV), false, false, 0);
16735   MemOps.push_back(Store);
16736
16737   // Store fp_offset
16738   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
16739                     FIN, DAG.getIntPtrConstant(4));
16740   Store = DAG.getStore(Op.getOperand(0), DL,
16741                        DAG.getConstant(FuncInfo->getVarArgsFPOffset(),
16742                                        MVT::i32),
16743                        FIN, MachinePointerInfo(SV, 4), false, false, 0);
16744   MemOps.push_back(Store);
16745
16746   // Store ptr to overflow_arg_area
16747   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
16748                     FIN, DAG.getIntPtrConstant(4));
16749   SDValue OVFIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
16750                                     getPointerTy());
16751   Store = DAG.getStore(Op.getOperand(0), DL, OVFIN, FIN,
16752                        MachinePointerInfo(SV, 8),
16753                        false, false, 0);
16754   MemOps.push_back(Store);
16755
16756   // Store ptr to reg_save_area.
16757   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
16758                     FIN, DAG.getIntPtrConstant(8));
16759   SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
16760                                     getPointerTy());
16761   Store = DAG.getStore(Op.getOperand(0), DL, RSFIN, FIN,
16762                        MachinePointerInfo(SV, 16), false, false, 0);
16763   MemOps.push_back(Store);
16764   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
16765 }
16766
16767 SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
16768   assert(Subtarget->is64Bit() &&
16769          "LowerVAARG only handles 64-bit va_arg!");
16770   assert((Subtarget->isTargetLinux() ||
16771           Subtarget->isTargetDarwin()) &&
16772           "Unhandled target in LowerVAARG");
16773   assert(Op.getNode()->getNumOperands() == 4);
16774   SDValue Chain = Op.getOperand(0);
16775   SDValue SrcPtr = Op.getOperand(1);
16776   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
16777   unsigned Align = Op.getConstantOperandVal(3);
16778   SDLoc dl(Op);
16779
16780   EVT ArgVT = Op.getNode()->getValueType(0);
16781   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
16782   uint32_t ArgSize = getDataLayout()->getTypeAllocSize(ArgTy);
16783   uint8_t ArgMode;
16784
16785   // Decide which area this value should be read from.
16786   // TODO: Implement the AMD64 ABI in its entirety. This simple
16787   // selection mechanism works only for the basic types.
16788   if (ArgVT == MVT::f80) {
16789     llvm_unreachable("va_arg for f80 not yet implemented");
16790   } else if (ArgVT.isFloatingPoint() && ArgSize <= 16 /*bytes*/) {
16791     ArgMode = 2;  // Argument passed in XMM register. Use fp_offset.
16792   } else if (ArgVT.isInteger() && ArgSize <= 32 /*bytes*/) {
16793     ArgMode = 1;  // Argument passed in GPR64 register(s). Use gp_offset.
16794   } else {
16795     llvm_unreachable("Unhandled argument type in LowerVAARG");
16796   }
16797
16798   if (ArgMode == 2) {
16799     // Sanity Check: Make sure using fp_offset makes sense.
16800     assert(!DAG.getTarget().Options.UseSoftFloat &&
16801            !(DAG.getMachineFunction()
16802                 .getFunction()->getAttributes()
16803                 .hasAttribute(AttributeSet::FunctionIndex,
16804                               Attribute::NoImplicitFloat)) &&
16805            Subtarget->hasSSE1());
16806   }
16807
16808   // Insert VAARG_64 node into the DAG
16809   // VAARG_64 returns two values: Variable Argument Address, Chain
16810   SmallVector<SDValue, 11> InstOps;
16811   InstOps.push_back(Chain);
16812   InstOps.push_back(SrcPtr);
16813   InstOps.push_back(DAG.getConstant(ArgSize, MVT::i32));
16814   InstOps.push_back(DAG.getConstant(ArgMode, MVT::i8));
16815   InstOps.push_back(DAG.getConstant(Align, MVT::i32));
16816   SDVTList VTs = DAG.getVTList(getPointerTy(), MVT::Other);
16817   SDValue VAARG = DAG.getMemIntrinsicNode(X86ISD::VAARG_64, dl,
16818                                           VTs, InstOps, MVT::i64,
16819                                           MachinePointerInfo(SV),
16820                                           /*Align=*/0,
16821                                           /*Volatile=*/false,
16822                                           /*ReadMem=*/true,
16823                                           /*WriteMem=*/true);
16824   Chain = VAARG.getValue(1);
16825
16826   // Load the next argument and return it
16827   return DAG.getLoad(ArgVT, dl,
16828                      Chain,
16829                      VAARG,
16830                      MachinePointerInfo(),
16831                      false, false, false, 0);
16832 }
16833
16834 static SDValue LowerVACOPY(SDValue Op, const X86Subtarget *Subtarget,
16835                            SelectionDAG &DAG) {
16836   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
16837   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_copy!");
16838   SDValue Chain = Op.getOperand(0);
16839   SDValue DstPtr = Op.getOperand(1);
16840   SDValue SrcPtr = Op.getOperand(2);
16841   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
16842   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
16843   SDLoc DL(Op);
16844
16845   return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr,
16846                        DAG.getIntPtrConstant(24), 8, /*isVolatile*/false,
16847                        false,
16848                        MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV));
16849 }
16850
16851 // getTargetVShiftByConstNode - Handle vector element shifts where the shift
16852 // amount is a constant. Takes immediate version of shift as input.
16853 static SDValue getTargetVShiftByConstNode(unsigned Opc, SDLoc dl, MVT VT,
16854                                           SDValue SrcOp, uint64_t ShiftAmt,
16855                                           SelectionDAG &DAG) {
16856   MVT ElementType = VT.getVectorElementType();
16857
16858   // Fold this packed shift into its first operand if ShiftAmt is 0.
16859   if (ShiftAmt == 0)
16860     return SrcOp;
16861
16862   // Check for ShiftAmt >= element width
16863   if (ShiftAmt >= ElementType.getSizeInBits()) {
16864     if (Opc == X86ISD::VSRAI)
16865       ShiftAmt = ElementType.getSizeInBits() - 1;
16866     else
16867       return DAG.getConstant(0, VT);
16868   }
16869
16870   assert((Opc == X86ISD::VSHLI || Opc == X86ISD::VSRLI || Opc == X86ISD::VSRAI)
16871          && "Unknown target vector shift-by-constant node");
16872
16873   // Fold this packed vector shift into a build vector if SrcOp is a
16874   // vector of Constants or UNDEFs, and SrcOp valuetype is the same as VT.
16875   if (VT == SrcOp.getSimpleValueType() &&
16876       ISD::isBuildVectorOfConstantSDNodes(SrcOp.getNode())) {
16877     SmallVector<SDValue, 8> Elts;
16878     unsigned NumElts = SrcOp->getNumOperands();
16879     ConstantSDNode *ND;
16880
16881     switch(Opc) {
16882     default: llvm_unreachable(nullptr);
16883     case X86ISD::VSHLI:
16884       for (unsigned i=0; i!=NumElts; ++i) {
16885         SDValue CurrentOp = SrcOp->getOperand(i);
16886         if (CurrentOp->getOpcode() == ISD::UNDEF) {
16887           Elts.push_back(CurrentOp);
16888           continue;
16889         }
16890         ND = cast<ConstantSDNode>(CurrentOp);
16891         const APInt &C = ND->getAPIntValue();
16892         Elts.push_back(DAG.getConstant(C.shl(ShiftAmt), ElementType));
16893       }
16894       break;
16895     case X86ISD::VSRLI:
16896       for (unsigned i=0; i!=NumElts; ++i) {
16897         SDValue CurrentOp = SrcOp->getOperand(i);
16898         if (CurrentOp->getOpcode() == ISD::UNDEF) {
16899           Elts.push_back(CurrentOp);
16900           continue;
16901         }
16902         ND = cast<ConstantSDNode>(CurrentOp);
16903         const APInt &C = ND->getAPIntValue();
16904         Elts.push_back(DAG.getConstant(C.lshr(ShiftAmt), ElementType));
16905       }
16906       break;
16907     case X86ISD::VSRAI:
16908       for (unsigned i=0; i!=NumElts; ++i) {
16909         SDValue CurrentOp = SrcOp->getOperand(i);
16910         if (CurrentOp->getOpcode() == ISD::UNDEF) {
16911           Elts.push_back(CurrentOp);
16912           continue;
16913         }
16914         ND = cast<ConstantSDNode>(CurrentOp);
16915         const APInt &C = ND->getAPIntValue();
16916         Elts.push_back(DAG.getConstant(C.ashr(ShiftAmt), ElementType));
16917       }
16918       break;
16919     }
16920
16921     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
16922   }
16923
16924   return DAG.getNode(Opc, dl, VT, SrcOp, DAG.getConstant(ShiftAmt, MVT::i8));
16925 }
16926
16927 // getTargetVShiftNode - Handle vector element shifts where the shift amount
16928 // may or may not be a constant. Takes immediate version of shift as input.
16929 static SDValue getTargetVShiftNode(unsigned Opc, SDLoc dl, MVT VT,
16930                                    SDValue SrcOp, SDValue ShAmt,
16931                                    SelectionDAG &DAG) {
16932   MVT SVT = ShAmt.getSimpleValueType();
16933   assert((SVT == MVT::i32 || SVT == MVT::i64) && "Unexpected value type!");
16934
16935   // Catch shift-by-constant.
16936   if (ConstantSDNode *CShAmt = dyn_cast<ConstantSDNode>(ShAmt))
16937     return getTargetVShiftByConstNode(Opc, dl, VT, SrcOp,
16938                                       CShAmt->getZExtValue(), DAG);
16939
16940   // Change opcode to non-immediate version
16941   switch (Opc) {
16942     default: llvm_unreachable("Unknown target vector shift node");
16943     case X86ISD::VSHLI: Opc = X86ISD::VSHL; break;
16944     case X86ISD::VSRLI: Opc = X86ISD::VSRL; break;
16945     case X86ISD::VSRAI: Opc = X86ISD::VSRA; break;
16946   }
16947
16948   const X86Subtarget &Subtarget =
16949       DAG.getTarget().getSubtarget<X86Subtarget>();
16950   if (Subtarget.hasSSE41() && ShAmt.getOpcode() == ISD::ZERO_EXTEND &&
16951       ShAmt.getOperand(0).getSimpleValueType() == MVT::i16) {
16952     // Let the shuffle legalizer expand this shift amount node.
16953     SDValue Op0 = ShAmt.getOperand(0);
16954     Op0 = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(Op0), MVT::v8i16, Op0);
16955     ShAmt = getShuffleVectorZeroOrUndef(Op0, 0, true, &Subtarget, DAG);
16956   } else {
16957     // Need to build a vector containing shift amount.
16958     // SSE/AVX packed shifts only use the lower 64-bit of the shift count.
16959     SmallVector<SDValue, 4> ShOps;
16960     ShOps.push_back(ShAmt);
16961     if (SVT == MVT::i32) {
16962       ShOps.push_back(DAG.getConstant(0, SVT));
16963       ShOps.push_back(DAG.getUNDEF(SVT));
16964     }
16965     ShOps.push_back(DAG.getUNDEF(SVT));
16966
16967     MVT BVT = SVT == MVT::i32 ? MVT::v4i32 : MVT::v2i64;
16968     ShAmt = DAG.getNode(ISD::BUILD_VECTOR, dl, BVT, ShOps);
16969   }
16970
16971   // The return type has to be a 128-bit type with the same element
16972   // type as the input type.
16973   MVT EltVT = VT.getVectorElementType();
16974   EVT ShVT = MVT::getVectorVT(EltVT, 128/EltVT.getSizeInBits());
16975
16976   ShAmt = DAG.getNode(ISD::BITCAST, dl, ShVT, ShAmt);
16977   return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
16978 }
16979
16980 /// \brief Return (and \p Op, \p Mask) for compare instructions or
16981 /// (vselect \p Mask, \p Op, \p PreservedSrc) for others along with the
16982 /// necessary casting for \p Mask when lowering masking intrinsics.
16983 static SDValue getVectorMaskingNode(SDValue Op, SDValue Mask,
16984                                     SDValue PreservedSrc,
16985                                     const X86Subtarget *Subtarget,
16986                                     SelectionDAG &DAG) {
16987     EVT VT = Op.getValueType();
16988     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(),
16989                                   MVT::i1, VT.getVectorNumElements());
16990     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
16991                                      Mask.getValueType().getSizeInBits());
16992     SDLoc dl(Op);
16993
16994     assert(MaskVT.isSimple() && "invalid mask type");
16995
16996     if (isAllOnes(Mask))
16997       return Op;
16998
16999     // In case when MaskVT equals v2i1 or v4i1, low 2 or 4 elements
17000     // are extracted by EXTRACT_SUBVECTOR.
17001     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17002                               DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17003                               DAG.getIntPtrConstant(0));
17004
17005     switch (Op.getOpcode()) {
17006       default: break;
17007       case X86ISD::PCMPEQM:
17008       case X86ISD::PCMPGTM:
17009       case X86ISD::CMPM:
17010       case X86ISD::CMPMU:
17011         return DAG.getNode(ISD::AND, dl, VT, Op, VMask);
17012     }
17013     if (PreservedSrc.getOpcode() == ISD::UNDEF)
17014       PreservedSrc = getZeroVector(VT, Subtarget, DAG, dl);
17015     return DAG.getNode(ISD::VSELECT, dl, VT, VMask, Op, PreservedSrc);
17016 }
17017
17018 /// \brief Creates an SDNode for a predicated scalar operation.
17019 /// \returns (X86vselect \p Mask, \p Op, \p PreservedSrc).
17020 /// The mask is comming as MVT::i8 and it should be truncated
17021 /// to MVT::i1 while lowering masking intrinsics.
17022 /// The main difference between ScalarMaskingNode and VectorMaskingNode is using
17023 /// "X86select" instead of "vselect". We just can't create the "vselect" node for
17024 /// a scalar instruction.
17025 static SDValue getScalarMaskingNode(SDValue Op, SDValue Mask,
17026                                     SDValue PreservedSrc,
17027                                     const X86Subtarget *Subtarget,
17028                                     SelectionDAG &DAG) {
17029     if (isAllOnes(Mask))
17030       return Op;
17031
17032     EVT VT = Op.getValueType();
17033     SDLoc dl(Op);
17034     // The mask should be of type MVT::i1
17035     SDValue IMask = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, Mask);
17036
17037     if (PreservedSrc.getOpcode() == ISD::UNDEF)
17038       PreservedSrc = getZeroVector(VT, Subtarget, DAG, dl);
17039     return DAG.getNode(X86ISD::SELECT, dl, VT, IMask, Op, PreservedSrc);
17040 }
17041
17042 static unsigned getOpcodeForFMAIntrinsic(unsigned IntNo) {
17043     switch (IntNo) {
17044     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
17045     case Intrinsic::x86_fma_vfmadd_ps:
17046     case Intrinsic::x86_fma_vfmadd_pd:
17047     case Intrinsic::x86_fma_vfmadd_ps_256:
17048     case Intrinsic::x86_fma_vfmadd_pd_256:
17049     case Intrinsic::x86_fma_mask_vfmadd_ps_512:
17050     case Intrinsic::x86_fma_mask_vfmadd_pd_512:
17051       return X86ISD::FMADD;
17052     case Intrinsic::x86_fma_vfmsub_ps:
17053     case Intrinsic::x86_fma_vfmsub_pd:
17054     case Intrinsic::x86_fma_vfmsub_ps_256:
17055     case Intrinsic::x86_fma_vfmsub_pd_256:
17056     case Intrinsic::x86_fma_mask_vfmsub_ps_512:
17057     case Intrinsic::x86_fma_mask_vfmsub_pd_512:
17058       return X86ISD::FMSUB;
17059     case Intrinsic::x86_fma_vfnmadd_ps:
17060     case Intrinsic::x86_fma_vfnmadd_pd:
17061     case Intrinsic::x86_fma_vfnmadd_ps_256:
17062     case Intrinsic::x86_fma_vfnmadd_pd_256:
17063     case Intrinsic::x86_fma_mask_vfnmadd_ps_512:
17064     case Intrinsic::x86_fma_mask_vfnmadd_pd_512:
17065       return X86ISD::FNMADD;
17066     case Intrinsic::x86_fma_vfnmsub_ps:
17067     case Intrinsic::x86_fma_vfnmsub_pd:
17068     case Intrinsic::x86_fma_vfnmsub_ps_256:
17069     case Intrinsic::x86_fma_vfnmsub_pd_256:
17070     case Intrinsic::x86_fma_mask_vfnmsub_ps_512:
17071     case Intrinsic::x86_fma_mask_vfnmsub_pd_512:
17072       return X86ISD::FNMSUB;
17073     case Intrinsic::x86_fma_vfmaddsub_ps:
17074     case Intrinsic::x86_fma_vfmaddsub_pd:
17075     case Intrinsic::x86_fma_vfmaddsub_ps_256:
17076     case Intrinsic::x86_fma_vfmaddsub_pd_256:
17077     case Intrinsic::x86_fma_mask_vfmaddsub_ps_512:
17078     case Intrinsic::x86_fma_mask_vfmaddsub_pd_512:
17079       return X86ISD::FMADDSUB;
17080     case Intrinsic::x86_fma_vfmsubadd_ps:
17081     case Intrinsic::x86_fma_vfmsubadd_pd:
17082     case Intrinsic::x86_fma_vfmsubadd_ps_256:
17083     case Intrinsic::x86_fma_vfmsubadd_pd_256:
17084     case Intrinsic::x86_fma_mask_vfmsubadd_ps_512:
17085     case Intrinsic::x86_fma_mask_vfmsubadd_pd_512:
17086       return X86ISD::FMSUBADD;
17087     }
17088 }
17089
17090 static SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
17091                                        SelectionDAG &DAG) {
17092   SDLoc dl(Op);
17093   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
17094   EVT VT = Op.getValueType();
17095   const IntrinsicData* IntrData = getIntrinsicWithoutChain(IntNo);
17096   if (IntrData) {
17097     switch(IntrData->Type) {
17098     case INTR_TYPE_1OP:
17099       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1));
17100     case INTR_TYPE_2OP:
17101       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1),
17102         Op.getOperand(2));
17103     case INTR_TYPE_3OP:
17104       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1),
17105         Op.getOperand(2), Op.getOperand(3));
17106     case INTR_TYPE_1OP_MASK_RM: {
17107       SDValue Src = Op.getOperand(1);
17108       SDValue Src0 = Op.getOperand(2);
17109       SDValue Mask = Op.getOperand(3);
17110       SDValue RoundingMode = Op.getOperand(4);
17111       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src,
17112                                               RoundingMode),
17113                                   Mask, Src0, Subtarget, DAG);
17114     }
17115     case INTR_TYPE_SCALAR_MASK_RM: {
17116       SDValue Src1 = Op.getOperand(1);
17117       SDValue Src2 = Op.getOperand(2);
17118       SDValue Src0 = Op.getOperand(3);
17119       SDValue Mask = Op.getOperand(4);
17120       SDValue RoundingMode = Op.getOperand(5);
17121       return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2,
17122                                               RoundingMode),
17123                                   Mask, Src0, Subtarget, DAG);
17124     }
17125     case INTR_TYPE_2OP_MASK: {
17126       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Op.getOperand(1),
17127                                               Op.getOperand(2)),
17128                                   Op.getOperand(4), Op.getOperand(3), Subtarget, DAG);
17129     }
17130     case CMP_MASK:
17131     case CMP_MASK_CC: {
17132       // Comparison intrinsics with masks.
17133       // Example of transformation:
17134       // (i8 (int_x86_avx512_mask_pcmpeq_q_128
17135       //             (v2i64 %a), (v2i64 %b), (i8 %mask))) ->
17136       // (i8 (bitcast
17137       //   (v8i1 (insert_subvector undef,
17138       //           (v2i1 (and (PCMPEQM %a, %b),
17139       //                      (extract_subvector
17140       //                         (v8i1 (bitcast %mask)), 0))), 0))))
17141       EVT VT = Op.getOperand(1).getValueType();
17142       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17143                                     VT.getVectorNumElements());
17144       SDValue Mask = Op.getOperand((IntrData->Type == CMP_MASK_CC) ? 4 : 3);
17145       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17146                                        Mask.getValueType().getSizeInBits());
17147       SDValue Cmp;
17148       if (IntrData->Type == CMP_MASK_CC) {
17149         Cmp = DAG.getNode(IntrData->Opc0, dl, MaskVT, Op.getOperand(1),
17150                     Op.getOperand(2), Op.getOperand(3));
17151       } else {
17152         assert(IntrData->Type == CMP_MASK && "Unexpected intrinsic type!");
17153         Cmp = DAG.getNode(IntrData->Opc0, dl, MaskVT, Op.getOperand(1),
17154                     Op.getOperand(2));
17155       }
17156       SDValue CmpMask = getVectorMaskingNode(Cmp, Mask,
17157                                              DAG.getTargetConstant(0, MaskVT),
17158                                              Subtarget, DAG);
17159       SDValue Res = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, BitcastVT,
17160                                 DAG.getUNDEF(BitcastVT), CmpMask,
17161                                 DAG.getIntPtrConstant(0));
17162       return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
17163     }
17164     case COMI: { // Comparison intrinsics
17165       ISD::CondCode CC = (ISD::CondCode)IntrData->Opc1;
17166       SDValue LHS = Op.getOperand(1);
17167       SDValue RHS = Op.getOperand(2);
17168       unsigned X86CC = TranslateX86CC(CC, true, LHS, RHS, DAG);
17169       assert(X86CC != X86::COND_INVALID && "Unexpected illegal condition!");
17170       SDValue Cond = DAG.getNode(IntrData->Opc0, dl, MVT::i32, LHS, RHS);
17171       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17172                                   DAG.getConstant(X86CC, MVT::i8), Cond);
17173       return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17174     }
17175     case VSHIFT:
17176       return getTargetVShiftNode(IntrData->Opc0, dl, Op.getSimpleValueType(),
17177                                  Op.getOperand(1), Op.getOperand(2), DAG);
17178     case VSHIFT_MASK:
17179       return getVectorMaskingNode(getTargetVShiftNode(IntrData->Opc0, dl,
17180                                                       Op.getSimpleValueType(),
17181                                                       Op.getOperand(1),
17182                                                       Op.getOperand(2), DAG),
17183                                   Op.getOperand(4), Op.getOperand(3), Subtarget,
17184                                   DAG);
17185     case COMPRESS_EXPAND_IN_REG: {
17186       SDValue Mask = Op.getOperand(3);
17187       SDValue DataToCompress = Op.getOperand(1);
17188       SDValue PassThru = Op.getOperand(2);
17189       if (isAllOnes(Mask)) // return data as is
17190         return Op.getOperand(1);
17191       EVT VT = Op.getValueType();
17192       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17193                                     VT.getVectorNumElements());
17194       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17195                                        Mask.getValueType().getSizeInBits());
17196       SDLoc dl(Op);
17197       SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17198                                   DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17199                                   DAG.getIntPtrConstant(0));
17200
17201       return DAG.getNode(IntrData->Opc0, dl, VT, VMask, DataToCompress,
17202                          PassThru);
17203     }
17204     case BLEND: {
17205       SDValue Mask = Op.getOperand(3);
17206       EVT VT = Op.getValueType();
17207       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17208                                     VT.getVectorNumElements());
17209       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17210                                        Mask.getValueType().getSizeInBits());
17211       SDLoc dl(Op);
17212       SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17213                                   DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17214                                   DAG.getIntPtrConstant(0));
17215       return DAG.getNode(IntrData->Opc0, dl, VT, VMask, Op.getOperand(1),
17216                          Op.getOperand(2));
17217     }
17218     case FMA_OP_MASK:
17219     {
17220         return getVectorMaskingNode(DAG.getNode(IntrData->Opc0,
17221             dl, Op.getValueType(),
17222             Op.getOperand(1),
17223             Op.getOperand(2),
17224             Op.getOperand(3)),
17225             Op.getOperand(4), Op.getOperand(1),
17226             Subtarget, DAG);
17227     }
17228     default:
17229       break;
17230     }
17231   }
17232
17233   switch (IntNo) {
17234   default: return SDValue();    // Don't custom lower most intrinsics.
17235
17236   case Intrinsic::x86_avx512_mask_valign_q_512:
17237   case Intrinsic::x86_avx512_mask_valign_d_512:
17238     // Vector source operands are swapped.
17239     return getVectorMaskingNode(DAG.getNode(X86ISD::VALIGN, dl,
17240                                             Op.getValueType(), Op.getOperand(2),
17241                                             Op.getOperand(1),
17242                                             Op.getOperand(3)),
17243                                 Op.getOperand(5), Op.getOperand(4),
17244                                 Subtarget, DAG);
17245
17246   // ptest and testp intrinsics. The intrinsic these come from are designed to
17247   // return an integer value, not just an instruction so lower it to the ptest
17248   // or testp pattern and a setcc for the result.
17249   case Intrinsic::x86_sse41_ptestz:
17250   case Intrinsic::x86_sse41_ptestc:
17251   case Intrinsic::x86_sse41_ptestnzc:
17252   case Intrinsic::x86_avx_ptestz_256:
17253   case Intrinsic::x86_avx_ptestc_256:
17254   case Intrinsic::x86_avx_ptestnzc_256:
17255   case Intrinsic::x86_avx_vtestz_ps:
17256   case Intrinsic::x86_avx_vtestc_ps:
17257   case Intrinsic::x86_avx_vtestnzc_ps:
17258   case Intrinsic::x86_avx_vtestz_pd:
17259   case Intrinsic::x86_avx_vtestc_pd:
17260   case Intrinsic::x86_avx_vtestnzc_pd:
17261   case Intrinsic::x86_avx_vtestz_ps_256:
17262   case Intrinsic::x86_avx_vtestc_ps_256:
17263   case Intrinsic::x86_avx_vtestnzc_ps_256:
17264   case Intrinsic::x86_avx_vtestz_pd_256:
17265   case Intrinsic::x86_avx_vtestc_pd_256:
17266   case Intrinsic::x86_avx_vtestnzc_pd_256: {
17267     bool IsTestPacked = false;
17268     unsigned X86CC;
17269     switch (IntNo) {
17270     default: llvm_unreachable("Bad fallthrough in Intrinsic lowering.");
17271     case Intrinsic::x86_avx_vtestz_ps:
17272     case Intrinsic::x86_avx_vtestz_pd:
17273     case Intrinsic::x86_avx_vtestz_ps_256:
17274     case Intrinsic::x86_avx_vtestz_pd_256:
17275       IsTestPacked = true; // Fallthrough
17276     case Intrinsic::x86_sse41_ptestz:
17277     case Intrinsic::x86_avx_ptestz_256:
17278       // ZF = 1
17279       X86CC = X86::COND_E;
17280       break;
17281     case Intrinsic::x86_avx_vtestc_ps:
17282     case Intrinsic::x86_avx_vtestc_pd:
17283     case Intrinsic::x86_avx_vtestc_ps_256:
17284     case Intrinsic::x86_avx_vtestc_pd_256:
17285       IsTestPacked = true; // Fallthrough
17286     case Intrinsic::x86_sse41_ptestc:
17287     case Intrinsic::x86_avx_ptestc_256:
17288       // CF = 1
17289       X86CC = X86::COND_B;
17290       break;
17291     case Intrinsic::x86_avx_vtestnzc_ps:
17292     case Intrinsic::x86_avx_vtestnzc_pd:
17293     case Intrinsic::x86_avx_vtestnzc_ps_256:
17294     case Intrinsic::x86_avx_vtestnzc_pd_256:
17295       IsTestPacked = true; // Fallthrough
17296     case Intrinsic::x86_sse41_ptestnzc:
17297     case Intrinsic::x86_avx_ptestnzc_256:
17298       // ZF and CF = 0
17299       X86CC = X86::COND_A;
17300       break;
17301     }
17302
17303     SDValue LHS = Op.getOperand(1);
17304     SDValue RHS = Op.getOperand(2);
17305     unsigned TestOpc = IsTestPacked ? X86ISD::TESTP : X86ISD::PTEST;
17306     SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
17307     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
17308     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
17309     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17310   }
17311   case Intrinsic::x86_avx512_kortestz_w:
17312   case Intrinsic::x86_avx512_kortestc_w: {
17313     unsigned X86CC = (IntNo == Intrinsic::x86_avx512_kortestz_w)? X86::COND_E: X86::COND_B;
17314     SDValue LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(1));
17315     SDValue RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(2));
17316     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
17317     SDValue Test = DAG.getNode(X86ISD::KORTEST, dl, MVT::i32, LHS, RHS);
17318     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i1, CC, Test);
17319     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17320   }
17321
17322   case Intrinsic::x86_sse42_pcmpistria128:
17323   case Intrinsic::x86_sse42_pcmpestria128:
17324   case Intrinsic::x86_sse42_pcmpistric128:
17325   case Intrinsic::x86_sse42_pcmpestric128:
17326   case Intrinsic::x86_sse42_pcmpistrio128:
17327   case Intrinsic::x86_sse42_pcmpestrio128:
17328   case Intrinsic::x86_sse42_pcmpistris128:
17329   case Intrinsic::x86_sse42_pcmpestris128:
17330   case Intrinsic::x86_sse42_pcmpistriz128:
17331   case Intrinsic::x86_sse42_pcmpestriz128: {
17332     unsigned Opcode;
17333     unsigned X86CC;
17334     switch (IntNo) {
17335     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
17336     case Intrinsic::x86_sse42_pcmpistria128:
17337       Opcode = X86ISD::PCMPISTRI;
17338       X86CC = X86::COND_A;
17339       break;
17340     case Intrinsic::x86_sse42_pcmpestria128:
17341       Opcode = X86ISD::PCMPESTRI;
17342       X86CC = X86::COND_A;
17343       break;
17344     case Intrinsic::x86_sse42_pcmpistric128:
17345       Opcode = X86ISD::PCMPISTRI;
17346       X86CC = X86::COND_B;
17347       break;
17348     case Intrinsic::x86_sse42_pcmpestric128:
17349       Opcode = X86ISD::PCMPESTRI;
17350       X86CC = X86::COND_B;
17351       break;
17352     case Intrinsic::x86_sse42_pcmpistrio128:
17353       Opcode = X86ISD::PCMPISTRI;
17354       X86CC = X86::COND_O;
17355       break;
17356     case Intrinsic::x86_sse42_pcmpestrio128:
17357       Opcode = X86ISD::PCMPESTRI;
17358       X86CC = X86::COND_O;
17359       break;
17360     case Intrinsic::x86_sse42_pcmpistris128:
17361       Opcode = X86ISD::PCMPISTRI;
17362       X86CC = X86::COND_S;
17363       break;
17364     case Intrinsic::x86_sse42_pcmpestris128:
17365       Opcode = X86ISD::PCMPESTRI;
17366       X86CC = X86::COND_S;
17367       break;
17368     case Intrinsic::x86_sse42_pcmpistriz128:
17369       Opcode = X86ISD::PCMPISTRI;
17370       X86CC = X86::COND_E;
17371       break;
17372     case Intrinsic::x86_sse42_pcmpestriz128:
17373       Opcode = X86ISD::PCMPESTRI;
17374       X86CC = X86::COND_E;
17375       break;
17376     }
17377     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
17378     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
17379     SDValue PCMP = DAG.getNode(Opcode, dl, VTs, NewOps);
17380     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17381                                 DAG.getConstant(X86CC, MVT::i8),
17382                                 SDValue(PCMP.getNode(), 1));
17383     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
17384   }
17385
17386   case Intrinsic::x86_sse42_pcmpistri128:
17387   case Intrinsic::x86_sse42_pcmpestri128: {
17388     unsigned Opcode;
17389     if (IntNo == Intrinsic::x86_sse42_pcmpistri128)
17390       Opcode = X86ISD::PCMPISTRI;
17391     else
17392       Opcode = X86ISD::PCMPESTRI;
17393
17394     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
17395     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
17396     return DAG.getNode(Opcode, dl, VTs, NewOps);
17397   }
17398
17399   case Intrinsic::x86_fma_mask_vfmadd_ps_512:
17400   case Intrinsic::x86_fma_mask_vfmadd_pd_512:
17401   case Intrinsic::x86_fma_mask_vfmsub_ps_512:
17402   case Intrinsic::x86_fma_mask_vfmsub_pd_512:
17403   case Intrinsic::x86_fma_mask_vfnmadd_ps_512:
17404   case Intrinsic::x86_fma_mask_vfnmadd_pd_512:
17405   case Intrinsic::x86_fma_mask_vfnmsub_ps_512:
17406   case Intrinsic::x86_fma_mask_vfnmsub_pd_512:
17407   case Intrinsic::x86_fma_mask_vfmaddsub_ps_512:
17408   case Intrinsic::x86_fma_mask_vfmaddsub_pd_512:
17409   case Intrinsic::x86_fma_mask_vfmsubadd_ps_512:
17410   case Intrinsic::x86_fma_mask_vfmsubadd_pd_512: {
17411     auto *SAE = cast<ConstantSDNode>(Op.getOperand(5));
17412     if (SAE->getZExtValue() == X86::STATIC_ROUNDING::CUR_DIRECTION)
17413       return getVectorMaskingNode(DAG.getNode(getOpcodeForFMAIntrinsic(IntNo),
17414                                               dl, Op.getValueType(),
17415                                               Op.getOperand(1),
17416                                               Op.getOperand(2),
17417                                               Op.getOperand(3)),
17418                                   Op.getOperand(4), Op.getOperand(1),
17419                                   Subtarget, DAG);
17420     else
17421       return SDValue();
17422   }
17423
17424   case Intrinsic::x86_fma_vfmadd_ps:
17425   case Intrinsic::x86_fma_vfmadd_pd:
17426   case Intrinsic::x86_fma_vfmsub_ps:
17427   case Intrinsic::x86_fma_vfmsub_pd:
17428   case Intrinsic::x86_fma_vfnmadd_ps:
17429   case Intrinsic::x86_fma_vfnmadd_pd:
17430   case Intrinsic::x86_fma_vfnmsub_ps:
17431   case Intrinsic::x86_fma_vfnmsub_pd:
17432   case Intrinsic::x86_fma_vfmaddsub_ps:
17433   case Intrinsic::x86_fma_vfmaddsub_pd:
17434   case Intrinsic::x86_fma_vfmsubadd_ps:
17435   case Intrinsic::x86_fma_vfmsubadd_pd:
17436   case Intrinsic::x86_fma_vfmadd_ps_256:
17437   case Intrinsic::x86_fma_vfmadd_pd_256:
17438   case Intrinsic::x86_fma_vfmsub_ps_256:
17439   case Intrinsic::x86_fma_vfmsub_pd_256:
17440   case Intrinsic::x86_fma_vfnmadd_ps_256:
17441   case Intrinsic::x86_fma_vfnmadd_pd_256:
17442   case Intrinsic::x86_fma_vfnmsub_ps_256:
17443   case Intrinsic::x86_fma_vfnmsub_pd_256:
17444   case Intrinsic::x86_fma_vfmaddsub_ps_256:
17445   case Intrinsic::x86_fma_vfmaddsub_pd_256:
17446   case Intrinsic::x86_fma_vfmsubadd_ps_256:
17447   case Intrinsic::x86_fma_vfmsubadd_pd_256:
17448     return DAG.getNode(getOpcodeForFMAIntrinsic(IntNo), dl, Op.getValueType(),
17449                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
17450   }
17451 }
17452
17453 static SDValue getGatherNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17454                               SDValue Src, SDValue Mask, SDValue Base,
17455                               SDValue Index, SDValue ScaleOp, SDValue Chain,
17456                               const X86Subtarget * Subtarget) {
17457   SDLoc dl(Op);
17458   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17459   assert(C && "Invalid scale type");
17460   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17461   EVT MaskVT = MVT::getVectorVT(MVT::i1,
17462                              Index.getSimpleValueType().getVectorNumElements());
17463   SDValue MaskInReg;
17464   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17465   if (MaskC)
17466     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17467   else
17468     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17469   SDVTList VTs = DAG.getVTList(Op.getValueType(), MaskVT, MVT::Other);
17470   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17471   SDValue Segment = DAG.getRegister(0, MVT::i32);
17472   if (Src.getOpcode() == ISD::UNDEF)
17473     Src = getZeroVector(Op.getValueType(), Subtarget, DAG, dl);
17474   SDValue Ops[] = {Src, MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
17475   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
17476   SDValue RetOps[] = { SDValue(Res, 0), SDValue(Res, 2) };
17477   return DAG.getMergeValues(RetOps, dl);
17478 }
17479
17480 static SDValue getScatterNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17481                                SDValue Src, SDValue Mask, SDValue Base,
17482                                SDValue Index, SDValue ScaleOp, SDValue Chain) {
17483   SDLoc dl(Op);
17484   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17485   assert(C && "Invalid scale type");
17486   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17487   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17488   SDValue Segment = DAG.getRegister(0, MVT::i32);
17489   EVT MaskVT = MVT::getVectorVT(MVT::i1,
17490                              Index.getSimpleValueType().getVectorNumElements());
17491   SDValue MaskInReg;
17492   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17493   if (MaskC)
17494     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17495   else
17496     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17497   SDVTList VTs = DAG.getVTList(MaskVT, MVT::Other);
17498   SDValue Ops[] = {Base, Scale, Index, Disp, Segment, MaskInReg, Src, Chain};
17499   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
17500   return SDValue(Res, 1);
17501 }
17502
17503 static SDValue getPrefetchNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
17504                                SDValue Mask, SDValue Base, SDValue Index,
17505                                SDValue ScaleOp, SDValue Chain) {
17506   SDLoc dl(Op);
17507   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
17508   assert(C && "Invalid scale type");
17509   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
17510   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
17511   SDValue Segment = DAG.getRegister(0, MVT::i32);
17512   EVT MaskVT =
17513     MVT::getVectorVT(MVT::i1, Index.getSimpleValueType().getVectorNumElements());
17514   SDValue MaskInReg;
17515   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
17516   if (MaskC)
17517     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
17518   else
17519     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
17520   //SDVTList VTs = DAG.getVTList(MVT::Other);
17521   SDValue Ops[] = {MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
17522   SDNode *Res = DAG.getMachineNode(Opc, dl, MVT::Other, Ops);
17523   return SDValue(Res, 0);
17524 }
17525
17526 // getReadPerformanceCounter - Handles the lowering of builtin intrinsics that
17527 // read performance monitor counters (x86_rdpmc).
17528 static void getReadPerformanceCounter(SDNode *N, SDLoc DL,
17529                               SelectionDAG &DAG, const X86Subtarget *Subtarget,
17530                               SmallVectorImpl<SDValue> &Results) {
17531   assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
17532   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
17533   SDValue LO, HI;
17534
17535   // The ECX register is used to select the index of the performance counter
17536   // to read.
17537   SDValue Chain = DAG.getCopyToReg(N->getOperand(0), DL, X86::ECX,
17538                                    N->getOperand(2));
17539   SDValue rd = DAG.getNode(X86ISD::RDPMC_DAG, DL, Tys, Chain);
17540
17541   // Reads the content of a 64-bit performance counter and returns it in the
17542   // registers EDX:EAX.
17543   if (Subtarget->is64Bit()) {
17544     LO = DAG.getCopyFromReg(rd, DL, X86::RAX, MVT::i64, rd.getValue(1));
17545     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::RDX, MVT::i64,
17546                             LO.getValue(2));
17547   } else {
17548     LO = DAG.getCopyFromReg(rd, DL, X86::EAX, MVT::i32, rd.getValue(1));
17549     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::EDX, MVT::i32,
17550                             LO.getValue(2));
17551   }
17552   Chain = HI.getValue(1);
17553
17554   if (Subtarget->is64Bit()) {
17555     // The EAX register is loaded with the low-order 32 bits. The EDX register
17556     // is loaded with the supported high-order bits of the counter.
17557     SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
17558                               DAG.getConstant(32, MVT::i8));
17559     Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
17560     Results.push_back(Chain);
17561     return;
17562   }
17563
17564   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
17565   SDValue Ops[] = { LO, HI };
17566   SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
17567   Results.push_back(Pair);
17568   Results.push_back(Chain);
17569 }
17570
17571 // getReadTimeStampCounter - Handles the lowering of builtin intrinsics that
17572 // read the time stamp counter (x86_rdtsc and x86_rdtscp). This function is
17573 // also used to custom lower READCYCLECOUNTER nodes.
17574 static void getReadTimeStampCounter(SDNode *N, SDLoc DL, unsigned Opcode,
17575                               SelectionDAG &DAG, const X86Subtarget *Subtarget,
17576                               SmallVectorImpl<SDValue> &Results) {
17577   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
17578   SDValue rd = DAG.getNode(Opcode, DL, Tys, N->getOperand(0));
17579   SDValue LO, HI;
17580
17581   // The processor's time-stamp counter (a 64-bit MSR) is stored into the
17582   // EDX:EAX registers. EDX is loaded with the high-order 32 bits of the MSR
17583   // and the EAX register is loaded with the low-order 32 bits.
17584   if (Subtarget->is64Bit()) {
17585     LO = DAG.getCopyFromReg(rd, DL, X86::RAX, MVT::i64, rd.getValue(1));
17586     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::RDX, MVT::i64,
17587                             LO.getValue(2));
17588   } else {
17589     LO = DAG.getCopyFromReg(rd, DL, X86::EAX, MVT::i32, rd.getValue(1));
17590     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::EDX, MVT::i32,
17591                             LO.getValue(2));
17592   }
17593   SDValue Chain = HI.getValue(1);
17594
17595   if (Opcode == X86ISD::RDTSCP_DAG) {
17596     assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
17597
17598     // Instruction RDTSCP loads the IA32:TSC_AUX_MSR (address C000_0103H) into
17599     // the ECX register. Add 'ecx' explicitly to the chain.
17600     SDValue ecx = DAG.getCopyFromReg(Chain, DL, X86::ECX, MVT::i32,
17601                                      HI.getValue(2));
17602     // Explicitly store the content of ECX at the location passed in input
17603     // to the 'rdtscp' intrinsic.
17604     Chain = DAG.getStore(ecx.getValue(1), DL, ecx, N->getOperand(2),
17605                          MachinePointerInfo(), false, false, 0);
17606   }
17607
17608   if (Subtarget->is64Bit()) {
17609     // The EDX register is loaded with the high-order 32 bits of the MSR, and
17610     // the EAX register is loaded with the low-order 32 bits.
17611     SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
17612                               DAG.getConstant(32, MVT::i8));
17613     Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
17614     Results.push_back(Chain);
17615     return;
17616   }
17617
17618   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
17619   SDValue Ops[] = { LO, HI };
17620   SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
17621   Results.push_back(Pair);
17622   Results.push_back(Chain);
17623 }
17624
17625 static SDValue LowerREADCYCLECOUNTER(SDValue Op, const X86Subtarget *Subtarget,
17626                                      SelectionDAG &DAG) {
17627   SmallVector<SDValue, 2> Results;
17628   SDLoc DL(Op);
17629   getReadTimeStampCounter(Op.getNode(), DL, X86ISD::RDTSC_DAG, DAG, Subtarget,
17630                           Results);
17631   return DAG.getMergeValues(Results, DL);
17632 }
17633
17634
17635 static SDValue LowerINTRINSIC_W_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
17636                                       SelectionDAG &DAG) {
17637   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
17638
17639   const IntrinsicData* IntrData = getIntrinsicWithChain(IntNo);
17640   if (!IntrData)
17641     return SDValue();
17642
17643   SDLoc dl(Op);
17644   switch(IntrData->Type) {
17645   default:
17646     llvm_unreachable("Unknown Intrinsic Type");
17647     break;
17648   case RDSEED:
17649   case RDRAND: {
17650     // Emit the node with the right value type.
17651     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Glue, MVT::Other);
17652     SDValue Result = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(0));
17653
17654     // If the value returned by RDRAND/RDSEED was valid (CF=1), return 1.
17655     // Otherwise return the value from Rand, which is always 0, casted to i32.
17656     SDValue Ops[] = { DAG.getZExtOrTrunc(Result, dl, Op->getValueType(1)),
17657                       DAG.getConstant(1, Op->getValueType(1)),
17658                       DAG.getConstant(X86::COND_B, MVT::i32),
17659                       SDValue(Result.getNode(), 1) };
17660     SDValue isValid = DAG.getNode(X86ISD::CMOV, dl,
17661                                   DAG.getVTList(Op->getValueType(1), MVT::Glue),
17662                                   Ops);
17663
17664     // Return { result, isValid, chain }.
17665     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
17666                        SDValue(Result.getNode(), 2));
17667   }
17668   case GATHER: {
17669   //gather(v1, mask, index, base, scale);
17670     SDValue Chain = Op.getOperand(0);
17671     SDValue Src   = Op.getOperand(2);
17672     SDValue Base  = Op.getOperand(3);
17673     SDValue Index = Op.getOperand(4);
17674     SDValue Mask  = Op.getOperand(5);
17675     SDValue Scale = Op.getOperand(6);
17676     return getGatherNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index, Scale, Chain,
17677                           Subtarget);
17678   }
17679   case SCATTER: {
17680   //scatter(base, mask, index, v1, scale);
17681     SDValue Chain = Op.getOperand(0);
17682     SDValue Base  = Op.getOperand(2);
17683     SDValue Mask  = Op.getOperand(3);
17684     SDValue Index = Op.getOperand(4);
17685     SDValue Src   = Op.getOperand(5);
17686     SDValue Scale = Op.getOperand(6);
17687     return getScatterNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index, Scale, Chain);
17688   }
17689   case PREFETCH: {
17690     SDValue Hint = Op.getOperand(6);
17691     unsigned HintVal;
17692     if (dyn_cast<ConstantSDNode> (Hint) == nullptr ||
17693         (HintVal = dyn_cast<ConstantSDNode> (Hint)->getZExtValue()) > 1)
17694       llvm_unreachable("Wrong prefetch hint in intrinsic: should be 0 or 1");
17695     unsigned Opcode = (HintVal ? IntrData->Opc1 : IntrData->Opc0);
17696     SDValue Chain = Op.getOperand(0);
17697     SDValue Mask  = Op.getOperand(2);
17698     SDValue Index = Op.getOperand(3);
17699     SDValue Base  = Op.getOperand(4);
17700     SDValue Scale = Op.getOperand(5);
17701     return getPrefetchNode(Opcode, Op, DAG, Mask, Base, Index, Scale, Chain);
17702   }
17703   // Read Time Stamp Counter (RDTSC) and Processor ID (RDTSCP).
17704   case RDTSC: {
17705     SmallVector<SDValue, 2> Results;
17706     getReadTimeStampCounter(Op.getNode(), dl, IntrData->Opc0, DAG, Subtarget, Results);
17707     return DAG.getMergeValues(Results, dl);
17708   }
17709   // Read Performance Monitoring Counters.
17710   case RDPMC: {
17711     SmallVector<SDValue, 2> Results;
17712     getReadPerformanceCounter(Op.getNode(), dl, DAG, Subtarget, Results);
17713     return DAG.getMergeValues(Results, dl);
17714   }
17715   // XTEST intrinsics.
17716   case XTEST: {
17717     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
17718     SDValue InTrans = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(0));
17719     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17720                                 DAG.getConstant(X86::COND_NE, MVT::i8),
17721                                 InTrans);
17722     SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
17723     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(),
17724                        Ret, SDValue(InTrans.getNode(), 1));
17725   }
17726   // ADC/ADCX/SBB
17727   case ADX: {
17728     SmallVector<SDValue, 2> Results;
17729     SDVTList CFVTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
17730     SDVTList VTs = DAG.getVTList(Op.getOperand(3)->getValueType(0), MVT::Other);
17731     SDValue GenCF = DAG.getNode(X86ISD::ADD, dl, CFVTs, Op.getOperand(2),
17732                                 DAG.getConstant(-1, MVT::i8));
17733     SDValue Res = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(3),
17734                               Op.getOperand(4), GenCF.getValue(1));
17735     SDValue Store = DAG.getStore(Op.getOperand(0), dl, Res.getValue(0),
17736                                  Op.getOperand(5), MachinePointerInfo(),
17737                                  false, false, 0);
17738     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17739                                 DAG.getConstant(X86::COND_B, MVT::i8),
17740                                 Res.getValue(1));
17741     Results.push_back(SetCC);
17742     Results.push_back(Store);
17743     return DAG.getMergeValues(Results, dl);
17744   }
17745   case COMPRESS_TO_MEM: {
17746     SDLoc dl(Op);
17747     SDValue Mask = Op.getOperand(4);
17748     SDValue DataToCompress = Op.getOperand(3);
17749     SDValue Addr = Op.getOperand(2);
17750     SDValue Chain = Op.getOperand(0);
17751
17752     if (isAllOnes(Mask)) // return just a store
17753       return DAG.getStore(Chain, dl, DataToCompress, Addr,
17754                           MachinePointerInfo(), false, false, 0);
17755
17756     EVT VT = DataToCompress.getValueType();
17757     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17758                                   VT.getVectorNumElements());
17759     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17760                                      Mask.getValueType().getSizeInBits());
17761     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17762                                 DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17763                                 DAG.getIntPtrConstant(0));
17764
17765     SDValue Compressed =  DAG.getNode(IntrData->Opc0, dl, VT, VMask,
17766                                       DataToCompress, DAG.getUNDEF(VT));
17767     return DAG.getStore(Chain, dl, Compressed, Addr,
17768                         MachinePointerInfo(), false, false, 0);
17769   }
17770   case EXPAND_FROM_MEM: {
17771     SDLoc dl(Op);
17772     SDValue Mask = Op.getOperand(4);
17773     SDValue PathThru = Op.getOperand(3);
17774     SDValue Addr = Op.getOperand(2);
17775     SDValue Chain = Op.getOperand(0);
17776     EVT VT = Op.getValueType();
17777
17778     if (isAllOnes(Mask)) // return just a load
17779       return DAG.getLoad(VT, dl, Chain, Addr, MachinePointerInfo(), false, false,
17780                          false, 0);
17781     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17782                                   VT.getVectorNumElements());
17783     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
17784                                      Mask.getValueType().getSizeInBits());
17785     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
17786                                 DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
17787                                 DAG.getIntPtrConstant(0));
17788
17789     SDValue DataToExpand = DAG.getLoad(VT, dl, Chain, Addr, MachinePointerInfo(),
17790                                    false, false, false, 0);
17791
17792     SmallVector<SDValue, 2> Results;
17793     Results.push_back(DAG.getNode(IntrData->Opc0, dl, VT, VMask, DataToExpand,
17794                                   PathThru));
17795     Results.push_back(Chain);
17796     return DAG.getMergeValues(Results, dl);
17797   }
17798   }
17799 }
17800
17801 SDValue X86TargetLowering::LowerRETURNADDR(SDValue Op,
17802                                            SelectionDAG &DAG) const {
17803   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
17804   MFI->setReturnAddressIsTaken(true);
17805
17806   if (verifyReturnAddressArgumentIsConstant(Op, DAG))
17807     return SDValue();
17808
17809   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
17810   SDLoc dl(Op);
17811   EVT PtrVT = getPointerTy();
17812
17813   if (Depth > 0) {
17814     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
17815     const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
17816         DAG.getSubtarget().getRegisterInfo());
17817     SDValue Offset = DAG.getConstant(RegInfo->getSlotSize(), PtrVT);
17818     return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
17819                        DAG.getNode(ISD::ADD, dl, PtrVT,
17820                                    FrameAddr, Offset),
17821                        MachinePointerInfo(), false, false, false, 0);
17822   }
17823
17824   // Just load the return address.
17825   SDValue RetAddrFI = getReturnAddressFrameIndex(DAG);
17826   return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
17827                      RetAddrFI, MachinePointerInfo(), false, false, false, 0);
17828 }
17829
17830 SDValue X86TargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
17831   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
17832   MFI->setFrameAddressIsTaken(true);
17833
17834   EVT VT = Op.getValueType();
17835   SDLoc dl(Op);  // FIXME probably not meaningful
17836   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
17837   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
17838       DAG.getSubtarget().getRegisterInfo());
17839   unsigned FrameReg = RegInfo->getPtrSizedFrameRegister(
17840       DAG.getMachineFunction());
17841   assert(((FrameReg == X86::RBP && VT == MVT::i64) ||
17842           (FrameReg == X86::EBP && VT == MVT::i32)) &&
17843          "Invalid Frame Register!");
17844   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
17845   while (Depth--)
17846     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
17847                             MachinePointerInfo(),
17848                             false, false, false, 0);
17849   return FrameAddr;
17850 }
17851
17852 // FIXME? Maybe this could be a TableGen attribute on some registers and
17853 // this table could be generated automatically from RegInfo.
17854 unsigned X86TargetLowering::getRegisterByName(const char* RegName,
17855                                               EVT VT) const {
17856   unsigned Reg = StringSwitch<unsigned>(RegName)
17857                        .Case("esp", X86::ESP)
17858                        .Case("rsp", X86::RSP)
17859                        .Default(0);
17860   if (Reg)
17861     return Reg;
17862   report_fatal_error("Invalid register name global variable");
17863 }
17864
17865 SDValue X86TargetLowering::LowerFRAME_TO_ARGS_OFFSET(SDValue Op,
17866                                                      SelectionDAG &DAG) const {
17867   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
17868       DAG.getSubtarget().getRegisterInfo());
17869   return DAG.getIntPtrConstant(2 * RegInfo->getSlotSize());
17870 }
17871
17872 SDValue X86TargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
17873   SDValue Chain     = Op.getOperand(0);
17874   SDValue Offset    = Op.getOperand(1);
17875   SDValue Handler   = Op.getOperand(2);
17876   SDLoc dl      (Op);
17877
17878   EVT PtrVT = getPointerTy();
17879   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
17880       DAG.getSubtarget().getRegisterInfo());
17881   unsigned FrameReg = RegInfo->getFrameRegister(DAG.getMachineFunction());
17882   assert(((FrameReg == X86::RBP && PtrVT == MVT::i64) ||
17883           (FrameReg == X86::EBP && PtrVT == MVT::i32)) &&
17884          "Invalid Frame Register!");
17885   SDValue Frame = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, PtrVT);
17886   unsigned StoreAddrReg = (PtrVT == MVT::i64) ? X86::RCX : X86::ECX;
17887
17888   SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, Frame,
17889                                  DAG.getIntPtrConstant(RegInfo->getSlotSize()));
17890   StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, StoreAddr, Offset);
17891   Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo(),
17892                        false, false, 0);
17893   Chain = DAG.getCopyToReg(Chain, dl, StoreAddrReg, StoreAddr);
17894
17895   return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
17896                      DAG.getRegister(StoreAddrReg, PtrVT));
17897 }
17898
17899 SDValue X86TargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op,
17900                                                SelectionDAG &DAG) const {
17901   SDLoc DL(Op);
17902   return DAG.getNode(X86ISD::EH_SJLJ_SETJMP, DL,
17903                      DAG.getVTList(MVT::i32, MVT::Other),
17904                      Op.getOperand(0), Op.getOperand(1));
17905 }
17906
17907 SDValue X86TargetLowering::lowerEH_SJLJ_LONGJMP(SDValue Op,
17908                                                 SelectionDAG &DAG) const {
17909   SDLoc DL(Op);
17910   return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
17911                      Op.getOperand(0), Op.getOperand(1));
17912 }
17913
17914 static SDValue LowerADJUST_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) {
17915   return Op.getOperand(0);
17916 }
17917
17918 SDValue X86TargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
17919                                                 SelectionDAG &DAG) const {
17920   SDValue Root = Op.getOperand(0);
17921   SDValue Trmp = Op.getOperand(1); // trampoline
17922   SDValue FPtr = Op.getOperand(2); // nested function
17923   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
17924   SDLoc dl (Op);
17925
17926   const Value *TrmpAddr = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
17927   const TargetRegisterInfo *TRI = DAG.getSubtarget().getRegisterInfo();
17928
17929   if (Subtarget->is64Bit()) {
17930     SDValue OutChains[6];
17931
17932     // Large code-model.
17933     const unsigned char JMP64r  = 0xFF; // 64-bit jmp through register opcode.
17934     const unsigned char MOV64ri = 0xB8; // X86::MOV64ri opcode.
17935
17936     const unsigned char N86R10 = TRI->getEncodingValue(X86::R10) & 0x7;
17937     const unsigned char N86R11 = TRI->getEncodingValue(X86::R11) & 0x7;
17938
17939     const unsigned char REX_WB = 0x40 | 0x08 | 0x01; // REX prefix
17940
17941     // Load the pointer to the nested function into R11.
17942     unsigned OpCode = ((MOV64ri | N86R11) << 8) | REX_WB; // movabsq r11
17943     SDValue Addr = Trmp;
17944     OutChains[0] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
17945                                 Addr, MachinePointerInfo(TrmpAddr),
17946                                 false, false, 0);
17947
17948     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
17949                        DAG.getConstant(2, MVT::i64));
17950     OutChains[1] = DAG.getStore(Root, dl, FPtr, Addr,
17951                                 MachinePointerInfo(TrmpAddr, 2),
17952                                 false, false, 2);
17953
17954     // Load the 'nest' parameter value into R10.
17955     // R10 is specified in X86CallingConv.td
17956     OpCode = ((MOV64ri | N86R10) << 8) | REX_WB; // movabsq r10
17957     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
17958                        DAG.getConstant(10, MVT::i64));
17959     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
17960                                 Addr, MachinePointerInfo(TrmpAddr, 10),
17961                                 false, false, 0);
17962
17963     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
17964                        DAG.getConstant(12, MVT::i64));
17965     OutChains[3] = DAG.getStore(Root, dl, Nest, Addr,
17966                                 MachinePointerInfo(TrmpAddr, 12),
17967                                 false, false, 2);
17968
17969     // Jump to the nested function.
17970     OpCode = (JMP64r << 8) | REX_WB; // jmpq *...
17971     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
17972                        DAG.getConstant(20, MVT::i64));
17973     OutChains[4] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
17974                                 Addr, MachinePointerInfo(TrmpAddr, 20),
17975                                 false, false, 0);
17976
17977     unsigned char ModRM = N86R11 | (4 << 3) | (3 << 6); // ...r11
17978     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
17979                        DAG.getConstant(22, MVT::i64));
17980     OutChains[5] = DAG.getStore(Root, dl, DAG.getConstant(ModRM, MVT::i8), Addr,
17981                                 MachinePointerInfo(TrmpAddr, 22),
17982                                 false, false, 0);
17983
17984     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
17985   } else {
17986     const Function *Func =
17987       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
17988     CallingConv::ID CC = Func->getCallingConv();
17989     unsigned NestReg;
17990
17991     switch (CC) {
17992     default:
17993       llvm_unreachable("Unsupported calling convention");
17994     case CallingConv::C:
17995     case CallingConv::X86_StdCall: {
17996       // Pass 'nest' parameter in ECX.
17997       // Must be kept in sync with X86CallingConv.td
17998       NestReg = X86::ECX;
17999
18000       // Check that ECX wasn't needed by an 'inreg' parameter.
18001       FunctionType *FTy = Func->getFunctionType();
18002       const AttributeSet &Attrs = Func->getAttributes();
18003
18004       if (!Attrs.isEmpty() && !Func->isVarArg()) {
18005         unsigned InRegCount = 0;
18006         unsigned Idx = 1;
18007
18008         for (FunctionType::param_iterator I = FTy->param_begin(),
18009              E = FTy->param_end(); I != E; ++I, ++Idx)
18010           if (Attrs.hasAttribute(Idx, Attribute::InReg))
18011             // FIXME: should only count parameters that are lowered to integers.
18012             InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
18013
18014         if (InRegCount > 2) {
18015           report_fatal_error("Nest register in use - reduce number of inreg"
18016                              " parameters!");
18017         }
18018       }
18019       break;
18020     }
18021     case CallingConv::X86_FastCall:
18022     case CallingConv::X86_ThisCall:
18023     case CallingConv::Fast:
18024       // Pass 'nest' parameter in EAX.
18025       // Must be kept in sync with X86CallingConv.td
18026       NestReg = X86::EAX;
18027       break;
18028     }
18029
18030     SDValue OutChains[4];
18031     SDValue Addr, Disp;
18032
18033     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18034                        DAG.getConstant(10, MVT::i32));
18035     Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
18036
18037     // This is storing the opcode for MOV32ri.
18038     const unsigned char MOV32ri = 0xB8; // X86::MOV32ri's opcode byte.
18039     const unsigned char N86Reg = TRI->getEncodingValue(NestReg) & 0x7;
18040     OutChains[0] = DAG.getStore(Root, dl,
18041                                 DAG.getConstant(MOV32ri|N86Reg, MVT::i8),
18042                                 Trmp, MachinePointerInfo(TrmpAddr),
18043                                 false, false, 0);
18044
18045     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18046                        DAG.getConstant(1, MVT::i32));
18047     OutChains[1] = DAG.getStore(Root, dl, Nest, Addr,
18048                                 MachinePointerInfo(TrmpAddr, 1),
18049                                 false, false, 1);
18050
18051     const unsigned char JMP = 0xE9; // jmp <32bit dst> opcode.
18052     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18053                        DAG.getConstant(5, MVT::i32));
18054     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(JMP, MVT::i8), Addr,
18055                                 MachinePointerInfo(TrmpAddr, 5),
18056                                 false, false, 1);
18057
18058     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
18059                        DAG.getConstant(6, MVT::i32));
18060     OutChains[3] = DAG.getStore(Root, dl, Disp, Addr,
18061                                 MachinePointerInfo(TrmpAddr, 6),
18062                                 false, false, 1);
18063
18064     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
18065   }
18066 }
18067
18068 SDValue X86TargetLowering::LowerFLT_ROUNDS_(SDValue Op,
18069                                             SelectionDAG &DAG) const {
18070   /*
18071    The rounding mode is in bits 11:10 of FPSR, and has the following
18072    settings:
18073      00 Round to nearest
18074      01 Round to -inf
18075      10 Round to +inf
18076      11 Round to 0
18077
18078   FLT_ROUNDS, on the other hand, expects the following:
18079     -1 Undefined
18080      0 Round to 0
18081      1 Round to nearest
18082      2 Round to +inf
18083      3 Round to -inf
18084
18085   To perform the conversion, we do:
18086     (((((FPSR & 0x800) >> 11) | ((FPSR & 0x400) >> 9)) + 1) & 3)
18087   */
18088
18089   MachineFunction &MF = DAG.getMachineFunction();
18090   const TargetMachine &TM = MF.getTarget();
18091   const TargetFrameLowering &TFI = *TM.getSubtargetImpl()->getFrameLowering();
18092   unsigned StackAlignment = TFI.getStackAlignment();
18093   MVT VT = Op.getSimpleValueType();
18094   SDLoc DL(Op);
18095
18096   // Save FP Control Word to stack slot
18097   int SSFI = MF.getFrameInfo()->CreateStackObject(2, StackAlignment, false);
18098   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
18099
18100   MachineMemOperand *MMO =
18101    MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
18102                            MachineMemOperand::MOStore, 2, 2);
18103
18104   SDValue Ops[] = { DAG.getEntryNode(), StackSlot };
18105   SDValue Chain = DAG.getMemIntrinsicNode(X86ISD::FNSTCW16m, DL,
18106                                           DAG.getVTList(MVT::Other),
18107                                           Ops, MVT::i16, MMO);
18108
18109   // Load FP Control Word from stack slot
18110   SDValue CWD = DAG.getLoad(MVT::i16, DL, Chain, StackSlot,
18111                             MachinePointerInfo(), false, false, false, 0);
18112
18113   // Transform as necessary
18114   SDValue CWD1 =
18115     DAG.getNode(ISD::SRL, DL, MVT::i16,
18116                 DAG.getNode(ISD::AND, DL, MVT::i16,
18117                             CWD, DAG.getConstant(0x800, MVT::i16)),
18118                 DAG.getConstant(11, MVT::i8));
18119   SDValue CWD2 =
18120     DAG.getNode(ISD::SRL, DL, MVT::i16,
18121                 DAG.getNode(ISD::AND, DL, MVT::i16,
18122                             CWD, DAG.getConstant(0x400, MVT::i16)),
18123                 DAG.getConstant(9, MVT::i8));
18124
18125   SDValue RetVal =
18126     DAG.getNode(ISD::AND, DL, MVT::i16,
18127                 DAG.getNode(ISD::ADD, DL, MVT::i16,
18128                             DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
18129                             DAG.getConstant(1, MVT::i16)),
18130                 DAG.getConstant(3, MVT::i16));
18131
18132   return DAG.getNode((VT.getSizeInBits() < 16 ?
18133                       ISD::TRUNCATE : ISD::ZERO_EXTEND), DL, VT, RetVal);
18134 }
18135
18136 static SDValue LowerCTLZ(SDValue Op, SelectionDAG &DAG) {
18137   MVT VT = Op.getSimpleValueType();
18138   EVT OpVT = VT;
18139   unsigned NumBits = VT.getSizeInBits();
18140   SDLoc dl(Op);
18141
18142   Op = Op.getOperand(0);
18143   if (VT == MVT::i8) {
18144     // Zero extend to i32 since there is not an i8 bsr.
18145     OpVT = MVT::i32;
18146     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
18147   }
18148
18149   // Issue a bsr (scan bits in reverse) which also sets EFLAGS.
18150   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
18151   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
18152
18153   // If src is zero (i.e. bsr sets ZF), returns NumBits.
18154   SDValue Ops[] = {
18155     Op,
18156     DAG.getConstant(NumBits+NumBits-1, OpVT),
18157     DAG.getConstant(X86::COND_E, MVT::i8),
18158     Op.getValue(1)
18159   };
18160   Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops);
18161
18162   // Finally xor with NumBits-1.
18163   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
18164
18165   if (VT == MVT::i8)
18166     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
18167   return Op;
18168 }
18169
18170 static SDValue LowerCTLZ_ZERO_UNDEF(SDValue Op, SelectionDAG &DAG) {
18171   MVT VT = Op.getSimpleValueType();
18172   EVT OpVT = VT;
18173   unsigned NumBits = VT.getSizeInBits();
18174   SDLoc dl(Op);
18175
18176   Op = Op.getOperand(0);
18177   if (VT == MVT::i8) {
18178     // Zero extend to i32 since there is not an i8 bsr.
18179     OpVT = MVT::i32;
18180     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
18181   }
18182
18183   // Issue a bsr (scan bits in reverse).
18184   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
18185   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
18186
18187   // And xor with NumBits-1.
18188   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
18189
18190   if (VT == MVT::i8)
18191     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
18192   return Op;
18193 }
18194
18195 static SDValue LowerCTTZ(SDValue Op, SelectionDAG &DAG) {
18196   MVT VT = Op.getSimpleValueType();
18197   unsigned NumBits = VT.getSizeInBits();
18198   SDLoc dl(Op);
18199   Op = Op.getOperand(0);
18200
18201   // Issue a bsf (scan bits forward) which also sets EFLAGS.
18202   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
18203   Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
18204
18205   // If src is zero (i.e. bsf sets ZF), returns NumBits.
18206   SDValue Ops[] = {
18207     Op,
18208     DAG.getConstant(NumBits, VT),
18209     DAG.getConstant(X86::COND_E, MVT::i8),
18210     Op.getValue(1)
18211   };
18212   return DAG.getNode(X86ISD::CMOV, dl, VT, Ops);
18213 }
18214
18215 // Lower256IntArith - Break a 256-bit integer operation into two new 128-bit
18216 // ones, and then concatenate the result back.
18217 static SDValue Lower256IntArith(SDValue Op, SelectionDAG &DAG) {
18218   MVT VT = Op.getSimpleValueType();
18219
18220   assert(VT.is256BitVector() && VT.isInteger() &&
18221          "Unsupported value type for operation");
18222
18223   unsigned NumElems = VT.getVectorNumElements();
18224   SDLoc dl(Op);
18225
18226   // Extract the LHS vectors
18227   SDValue LHS = Op.getOperand(0);
18228   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
18229   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
18230
18231   // Extract the RHS vectors
18232   SDValue RHS = Op.getOperand(1);
18233   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
18234   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
18235
18236   MVT EltVT = VT.getVectorElementType();
18237   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
18238
18239   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
18240                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
18241                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
18242 }
18243
18244 static SDValue LowerADD(SDValue Op, SelectionDAG &DAG) {
18245   assert(Op.getSimpleValueType().is256BitVector() &&
18246          Op.getSimpleValueType().isInteger() &&
18247          "Only handle AVX 256-bit vector integer operation");
18248   return Lower256IntArith(Op, DAG);
18249 }
18250
18251 static SDValue LowerSUB(SDValue Op, SelectionDAG &DAG) {
18252   assert(Op.getSimpleValueType().is256BitVector() &&
18253          Op.getSimpleValueType().isInteger() &&
18254          "Only handle AVX 256-bit vector integer operation");
18255   return Lower256IntArith(Op, DAG);
18256 }
18257
18258 static SDValue LowerMUL(SDValue Op, const X86Subtarget *Subtarget,
18259                         SelectionDAG &DAG) {
18260   SDLoc dl(Op);
18261   MVT VT = Op.getSimpleValueType();
18262
18263   // Decompose 256-bit ops into smaller 128-bit ops.
18264   if (VT.is256BitVector() && !Subtarget->hasInt256())
18265     return Lower256IntArith(Op, DAG);
18266
18267   SDValue A = Op.getOperand(0);
18268   SDValue B = Op.getOperand(1);
18269
18270   // Lower v4i32 mul as 2x shuffle, 2x pmuludq, 2x shuffle.
18271   if (VT == MVT::v4i32) {
18272     assert(Subtarget->hasSSE2() && !Subtarget->hasSSE41() &&
18273            "Should not custom lower when pmuldq is available!");
18274
18275     // Extract the odd parts.
18276     static const int UnpackMask[] = { 1, -1, 3, -1 };
18277     SDValue Aodds = DAG.getVectorShuffle(VT, dl, A, A, UnpackMask);
18278     SDValue Bodds = DAG.getVectorShuffle(VT, dl, B, B, UnpackMask);
18279
18280     // Multiply the even parts.
18281     SDValue Evens = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, A, B);
18282     // Now multiply odd parts.
18283     SDValue Odds = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, Aodds, Bodds);
18284
18285     Evens = DAG.getNode(ISD::BITCAST, dl, VT, Evens);
18286     Odds = DAG.getNode(ISD::BITCAST, dl, VT, Odds);
18287
18288     // Merge the two vectors back together with a shuffle. This expands into 2
18289     // shuffles.
18290     static const int ShufMask[] = { 0, 4, 2, 6 };
18291     return DAG.getVectorShuffle(VT, dl, Evens, Odds, ShufMask);
18292   }
18293
18294   assert((VT == MVT::v2i64 || VT == MVT::v4i64 || VT == MVT::v8i64) &&
18295          "Only know how to lower V2I64/V4I64/V8I64 multiply");
18296
18297   //  Ahi = psrlqi(a, 32);
18298   //  Bhi = psrlqi(b, 32);
18299   //
18300   //  AloBlo = pmuludq(a, b);
18301   //  AloBhi = pmuludq(a, Bhi);
18302   //  AhiBlo = pmuludq(Ahi, b);
18303
18304   //  AloBhi = psllqi(AloBhi, 32);
18305   //  AhiBlo = psllqi(AhiBlo, 32);
18306   //  return AloBlo + AloBhi + AhiBlo;
18307
18308   SDValue Ahi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, A, 32, DAG);
18309   SDValue Bhi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, B, 32, DAG);
18310
18311   // Bit cast to 32-bit vectors for MULUDQ
18312   EVT MulVT = (VT == MVT::v2i64) ? MVT::v4i32 :
18313                                   (VT == MVT::v4i64) ? MVT::v8i32 : MVT::v16i32;
18314   A = DAG.getNode(ISD::BITCAST, dl, MulVT, A);
18315   B = DAG.getNode(ISD::BITCAST, dl, MulVT, B);
18316   Ahi = DAG.getNode(ISD::BITCAST, dl, MulVT, Ahi);
18317   Bhi = DAG.getNode(ISD::BITCAST, dl, MulVT, Bhi);
18318
18319   SDValue AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
18320   SDValue AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
18321   SDValue AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
18322
18323   AloBhi = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AloBhi, 32, DAG);
18324   AhiBlo = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AhiBlo, 32, DAG);
18325
18326   SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
18327   return DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
18328 }
18329
18330 SDValue X86TargetLowering::LowerWin64_i128OP(SDValue Op, SelectionDAG &DAG) const {
18331   assert(Subtarget->isTargetWin64() && "Unexpected target");
18332   EVT VT = Op.getValueType();
18333   assert(VT.isInteger() && VT.getSizeInBits() == 128 &&
18334          "Unexpected return type for lowering");
18335
18336   RTLIB::Libcall LC;
18337   bool isSigned;
18338   switch (Op->getOpcode()) {
18339   default: llvm_unreachable("Unexpected request for libcall!");
18340   case ISD::SDIV:      isSigned = true;  LC = RTLIB::SDIV_I128;    break;
18341   case ISD::UDIV:      isSigned = false; LC = RTLIB::UDIV_I128;    break;
18342   case ISD::SREM:      isSigned = true;  LC = RTLIB::SREM_I128;    break;
18343   case ISD::UREM:      isSigned = false; LC = RTLIB::UREM_I128;    break;
18344   case ISD::SDIVREM:   isSigned = true;  LC = RTLIB::SDIVREM_I128; break;
18345   case ISD::UDIVREM:   isSigned = false; LC = RTLIB::UDIVREM_I128; break;
18346   }
18347
18348   SDLoc dl(Op);
18349   SDValue InChain = DAG.getEntryNode();
18350
18351   TargetLowering::ArgListTy Args;
18352   TargetLowering::ArgListEntry Entry;
18353   for (unsigned i = 0, e = Op->getNumOperands(); i != e; ++i) {
18354     EVT ArgVT = Op->getOperand(i).getValueType();
18355     assert(ArgVT.isInteger() && ArgVT.getSizeInBits() == 128 &&
18356            "Unexpected argument type for lowering");
18357     SDValue StackPtr = DAG.CreateStackTemporary(ArgVT, 16);
18358     Entry.Node = StackPtr;
18359     InChain = DAG.getStore(InChain, dl, Op->getOperand(i), StackPtr, MachinePointerInfo(),
18360                            false, false, 16);
18361     Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
18362     Entry.Ty = PointerType::get(ArgTy,0);
18363     Entry.isSExt = false;
18364     Entry.isZExt = false;
18365     Args.push_back(Entry);
18366   }
18367
18368   SDValue Callee = DAG.getExternalSymbol(getLibcallName(LC),
18369                                          getPointerTy());
18370
18371   TargetLowering::CallLoweringInfo CLI(DAG);
18372   CLI.setDebugLoc(dl).setChain(InChain)
18373     .setCallee(getLibcallCallingConv(LC),
18374                static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext()),
18375                Callee, std::move(Args), 0)
18376     .setInRegister().setSExtResult(isSigned).setZExtResult(!isSigned);
18377
18378   std::pair<SDValue, SDValue> CallInfo = LowerCallTo(CLI);
18379   return DAG.getNode(ISD::BITCAST, dl, VT, CallInfo.first);
18380 }
18381
18382 static SDValue LowerMUL_LOHI(SDValue Op, const X86Subtarget *Subtarget,
18383                              SelectionDAG &DAG) {
18384   SDValue Op0 = Op.getOperand(0), Op1 = Op.getOperand(1);
18385   EVT VT = Op0.getValueType();
18386   SDLoc dl(Op);
18387
18388   assert((VT == MVT::v4i32 && Subtarget->hasSSE2()) ||
18389          (VT == MVT::v8i32 && Subtarget->hasInt256()));
18390
18391   // PMULxD operations multiply each even value (starting at 0) of LHS with
18392   // the related value of RHS and produce a widen result.
18393   // E.g., PMULUDQ <4 x i32> <a|b|c|d>, <4 x i32> <e|f|g|h>
18394   // => <2 x i64> <ae|cg>
18395   //
18396   // In other word, to have all the results, we need to perform two PMULxD:
18397   // 1. one with the even values.
18398   // 2. one with the odd values.
18399   // To achieve #2, with need to place the odd values at an even position.
18400   //
18401   // Place the odd value at an even position (basically, shift all values 1
18402   // step to the left):
18403   const int Mask[] = {1, -1, 3, -1, 5, -1, 7, -1};
18404   // <a|b|c|d> => <b|undef|d|undef>
18405   SDValue Odd0 = DAG.getVectorShuffle(VT, dl, Op0, Op0, Mask);
18406   // <e|f|g|h> => <f|undef|h|undef>
18407   SDValue Odd1 = DAG.getVectorShuffle(VT, dl, Op1, Op1, Mask);
18408
18409   // Emit two multiplies, one for the lower 2 ints and one for the higher 2
18410   // ints.
18411   MVT MulVT = VT == MVT::v4i32 ? MVT::v2i64 : MVT::v4i64;
18412   bool IsSigned = Op->getOpcode() == ISD::SMUL_LOHI;
18413   unsigned Opcode =
18414       (!IsSigned || !Subtarget->hasSSE41()) ? X86ISD::PMULUDQ : X86ISD::PMULDQ;
18415   // PMULUDQ <4 x i32> <a|b|c|d>, <4 x i32> <e|f|g|h>
18416   // => <2 x i64> <ae|cg>
18417   SDValue Mul1 = DAG.getNode(ISD::BITCAST, dl, VT,
18418                              DAG.getNode(Opcode, dl, MulVT, Op0, Op1));
18419   // PMULUDQ <4 x i32> <b|undef|d|undef>, <4 x i32> <f|undef|h|undef>
18420   // => <2 x i64> <bf|dh>
18421   SDValue Mul2 = DAG.getNode(ISD::BITCAST, dl, VT,
18422                              DAG.getNode(Opcode, dl, MulVT, Odd0, Odd1));
18423
18424   // Shuffle it back into the right order.
18425   SDValue Highs, Lows;
18426   if (VT == MVT::v8i32) {
18427     const int HighMask[] = {1, 9, 3, 11, 5, 13, 7, 15};
18428     Highs = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, HighMask);
18429     const int LowMask[] = {0, 8, 2, 10, 4, 12, 6, 14};
18430     Lows = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, LowMask);
18431   } else {
18432     const int HighMask[] = {1, 5, 3, 7};
18433     Highs = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, HighMask);
18434     const int LowMask[] = {0, 4, 2, 6};
18435     Lows = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, LowMask);
18436   }
18437
18438   // If we have a signed multiply but no PMULDQ fix up the high parts of a
18439   // unsigned multiply.
18440   if (IsSigned && !Subtarget->hasSSE41()) {
18441     SDValue ShAmt =
18442         DAG.getConstant(31, DAG.getTargetLoweringInfo().getShiftAmountTy(VT));
18443     SDValue T1 = DAG.getNode(ISD::AND, dl, VT,
18444                              DAG.getNode(ISD::SRA, dl, VT, Op0, ShAmt), Op1);
18445     SDValue T2 = DAG.getNode(ISD::AND, dl, VT,
18446                              DAG.getNode(ISD::SRA, dl, VT, Op1, ShAmt), Op0);
18447
18448     SDValue Fixup = DAG.getNode(ISD::ADD, dl, VT, T1, T2);
18449     Highs = DAG.getNode(ISD::SUB, dl, VT, Highs, Fixup);
18450   }
18451
18452   // The first result of MUL_LOHI is actually the low value, followed by the
18453   // high value.
18454   SDValue Ops[] = {Lows, Highs};
18455   return DAG.getMergeValues(Ops, dl);
18456 }
18457
18458 static SDValue LowerScalarImmediateShift(SDValue Op, SelectionDAG &DAG,
18459                                          const X86Subtarget *Subtarget) {
18460   MVT VT = Op.getSimpleValueType();
18461   SDLoc dl(Op);
18462   SDValue R = Op.getOperand(0);
18463   SDValue Amt = Op.getOperand(1);
18464
18465   // Optimize shl/srl/sra with constant shift amount.
18466   if (auto *BVAmt = dyn_cast<BuildVectorSDNode>(Amt)) {
18467     if (auto *ShiftConst = BVAmt->getConstantSplatNode()) {
18468       uint64_t ShiftAmt = ShiftConst->getZExtValue();
18469
18470       if (VT == MVT::v2i64 || VT == MVT::v4i32 || VT == MVT::v8i16 ||
18471           (Subtarget->hasInt256() &&
18472            (VT == MVT::v4i64 || VT == MVT::v8i32 || VT == MVT::v16i16)) ||
18473           (Subtarget->hasAVX512() &&
18474            (VT == MVT::v8i64 || VT == MVT::v16i32))) {
18475         if (Op.getOpcode() == ISD::SHL)
18476           return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
18477                                             DAG);
18478         if (Op.getOpcode() == ISD::SRL)
18479           return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
18480                                             DAG);
18481         if (Op.getOpcode() == ISD::SRA && VT != MVT::v2i64 && VT != MVT::v4i64)
18482           return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
18483                                             DAG);
18484       }
18485
18486       if (VT == MVT::v16i8) {
18487         if (Op.getOpcode() == ISD::SHL) {
18488           // Make a large shift.
18489           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl,
18490                                                    MVT::v8i16, R, ShiftAmt,
18491                                                    DAG);
18492           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
18493           // Zero out the rightmost bits.
18494           SmallVector<SDValue, 16> V(16,
18495                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
18496                                                      MVT::i8));
18497           return DAG.getNode(ISD::AND, dl, VT, SHL,
18498                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18499         }
18500         if (Op.getOpcode() == ISD::SRL) {
18501           // Make a large shift.
18502           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl,
18503                                                    MVT::v8i16, R, ShiftAmt,
18504                                                    DAG);
18505           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
18506           // Zero out the leftmost bits.
18507           SmallVector<SDValue, 16> V(16,
18508                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
18509                                                      MVT::i8));
18510           return DAG.getNode(ISD::AND, dl, VT, SRL,
18511                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18512         }
18513         if (Op.getOpcode() == ISD::SRA) {
18514           if (ShiftAmt == 7) {
18515             // R s>> 7  ===  R s< 0
18516             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
18517             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
18518           }
18519
18520           // R s>> a === ((R u>> a) ^ m) - m
18521           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
18522           SmallVector<SDValue, 16> V(16, DAG.getConstant(128 >> ShiftAmt,
18523                                                          MVT::i8));
18524           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
18525           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
18526           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
18527           return Res;
18528         }
18529         llvm_unreachable("Unknown shift opcode.");
18530       }
18531
18532       if (Subtarget->hasInt256() && VT == MVT::v32i8) {
18533         if (Op.getOpcode() == ISD::SHL) {
18534           // Make a large shift.
18535           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl,
18536                                                    MVT::v16i16, R, ShiftAmt,
18537                                                    DAG);
18538           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
18539           // Zero out the rightmost bits.
18540           SmallVector<SDValue, 32> V(32,
18541                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
18542                                                      MVT::i8));
18543           return DAG.getNode(ISD::AND, dl, VT, SHL,
18544                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18545         }
18546         if (Op.getOpcode() == ISD::SRL) {
18547           // Make a large shift.
18548           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl,
18549                                                    MVT::v16i16, R, ShiftAmt,
18550                                                    DAG);
18551           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
18552           // Zero out the leftmost bits.
18553           SmallVector<SDValue, 32> V(32,
18554                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
18555                                                      MVT::i8));
18556           return DAG.getNode(ISD::AND, dl, VT, SRL,
18557                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
18558         }
18559         if (Op.getOpcode() == ISD::SRA) {
18560           if (ShiftAmt == 7) {
18561             // R s>> 7  ===  R s< 0
18562             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
18563             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
18564           }
18565
18566           // R s>> a === ((R u>> a) ^ m) - m
18567           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
18568           SmallVector<SDValue, 32> V(32, DAG.getConstant(128 >> ShiftAmt,
18569                                                          MVT::i8));
18570           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
18571           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
18572           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
18573           return Res;
18574         }
18575         llvm_unreachable("Unknown shift opcode.");
18576       }
18577     }
18578   }
18579
18580   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
18581   if (!Subtarget->is64Bit() &&
18582       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64)) &&
18583       Amt.getOpcode() == ISD::BITCAST &&
18584       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
18585     Amt = Amt.getOperand(0);
18586     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
18587                      VT.getVectorNumElements();
18588     unsigned RatioInLog2 = Log2_32_Ceil(Ratio);
18589     uint64_t ShiftAmt = 0;
18590     for (unsigned i = 0; i != Ratio; ++i) {
18591       ConstantSDNode *C = dyn_cast<ConstantSDNode>(Amt.getOperand(i));
18592       if (!C)
18593         return SDValue();
18594       // 6 == Log2(64)
18595       ShiftAmt |= C->getZExtValue() << (i * (1 << (6 - RatioInLog2)));
18596     }
18597     // Check remaining shift amounts.
18598     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
18599       uint64_t ShAmt = 0;
18600       for (unsigned j = 0; j != Ratio; ++j) {
18601         ConstantSDNode *C =
18602           dyn_cast<ConstantSDNode>(Amt.getOperand(i + j));
18603         if (!C)
18604           return SDValue();
18605         // 6 == Log2(64)
18606         ShAmt |= C->getZExtValue() << (j * (1 << (6 - RatioInLog2)));
18607       }
18608       if (ShAmt != ShiftAmt)
18609         return SDValue();
18610     }
18611     switch (Op.getOpcode()) {
18612     default:
18613       llvm_unreachable("Unknown shift opcode!");
18614     case ISD::SHL:
18615       return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
18616                                         DAG);
18617     case ISD::SRL:
18618       return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
18619                                         DAG);
18620     case ISD::SRA:
18621       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
18622                                         DAG);
18623     }
18624   }
18625
18626   return SDValue();
18627 }
18628
18629 static SDValue LowerScalarVariableShift(SDValue Op, SelectionDAG &DAG,
18630                                         const X86Subtarget* Subtarget) {
18631   MVT VT = Op.getSimpleValueType();
18632   SDLoc dl(Op);
18633   SDValue R = Op.getOperand(0);
18634   SDValue Amt = Op.getOperand(1);
18635
18636   if ((VT == MVT::v2i64 && Op.getOpcode() != ISD::SRA) ||
18637       VT == MVT::v4i32 || VT == MVT::v8i16 ||
18638       (Subtarget->hasInt256() &&
18639        ((VT == MVT::v4i64 && Op.getOpcode() != ISD::SRA) ||
18640         VT == MVT::v8i32 || VT == MVT::v16i16)) ||
18641        (Subtarget->hasAVX512() && (VT == MVT::v8i64 || VT == MVT::v16i32))) {
18642     SDValue BaseShAmt;
18643     EVT EltVT = VT.getVectorElementType();
18644
18645     if (BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Amt)) {
18646       // Check if this build_vector node is doing a splat.
18647       // If so, then set BaseShAmt equal to the splat value.
18648       BaseShAmt = BV->getSplatValue();
18649       if (BaseShAmt && BaseShAmt.getOpcode() == ISD::UNDEF)
18650         BaseShAmt = SDValue();
18651     } else {
18652       if (Amt.getOpcode() == ISD::EXTRACT_SUBVECTOR)
18653         Amt = Amt.getOperand(0);
18654
18655       ShuffleVectorSDNode *SVN = dyn_cast<ShuffleVectorSDNode>(Amt);
18656       if (SVN && SVN->isSplat()) {
18657         unsigned SplatIdx = (unsigned)SVN->getSplatIndex();
18658         SDValue InVec = Amt.getOperand(0);
18659         if (InVec.getOpcode() == ISD::BUILD_VECTOR) {
18660           assert((SplatIdx < InVec.getValueType().getVectorNumElements()) &&
18661                  "Unexpected shuffle index found!");
18662           BaseShAmt = InVec.getOperand(SplatIdx);
18663         } else if (InVec.getOpcode() == ISD::INSERT_VECTOR_ELT) {
18664            if (ConstantSDNode *C =
18665                dyn_cast<ConstantSDNode>(InVec.getOperand(2))) {
18666              if (C->getZExtValue() == SplatIdx)
18667                BaseShAmt = InVec.getOperand(1);
18668            }
18669         }
18670
18671         if (!BaseShAmt)
18672           // Avoid introducing an extract element from a shuffle.
18673           BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InVec,
18674                                     DAG.getIntPtrConstant(SplatIdx));
18675       }
18676     }
18677
18678     if (BaseShAmt.getNode()) {
18679       assert(EltVT.bitsLE(MVT::i64) && "Unexpected element type!");
18680       if (EltVT != MVT::i64 && EltVT.bitsGT(MVT::i32))
18681         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, BaseShAmt);
18682       else if (EltVT.bitsLT(MVT::i32))
18683         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
18684
18685       switch (Op.getOpcode()) {
18686       default:
18687         llvm_unreachable("Unknown shift opcode!");
18688       case ISD::SHL:
18689         switch (VT.SimpleTy) {
18690         default: return SDValue();
18691         case MVT::v2i64:
18692         case MVT::v4i32:
18693         case MVT::v8i16:
18694         case MVT::v4i64:
18695         case MVT::v8i32:
18696         case MVT::v16i16:
18697         case MVT::v16i32:
18698         case MVT::v8i64:
18699           return getTargetVShiftNode(X86ISD::VSHLI, dl, VT, R, BaseShAmt, DAG);
18700         }
18701       case ISD::SRA:
18702         switch (VT.SimpleTy) {
18703         default: return SDValue();
18704         case MVT::v4i32:
18705         case MVT::v8i16:
18706         case MVT::v8i32:
18707         case MVT::v16i16:
18708         case MVT::v16i32:
18709         case MVT::v8i64:
18710           return getTargetVShiftNode(X86ISD::VSRAI, dl, VT, R, BaseShAmt, DAG);
18711         }
18712       case ISD::SRL:
18713         switch (VT.SimpleTy) {
18714         default: return SDValue();
18715         case MVT::v2i64:
18716         case MVT::v4i32:
18717         case MVT::v8i16:
18718         case MVT::v4i64:
18719         case MVT::v8i32:
18720         case MVT::v16i16:
18721         case MVT::v16i32:
18722         case MVT::v8i64:
18723           return getTargetVShiftNode(X86ISD::VSRLI, dl, VT, R, BaseShAmt, DAG);
18724         }
18725       }
18726     }
18727   }
18728
18729   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
18730   if (!Subtarget->is64Bit() &&
18731       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64) ||
18732       (Subtarget->hasAVX512() && VT == MVT::v8i64)) &&
18733       Amt.getOpcode() == ISD::BITCAST &&
18734       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
18735     Amt = Amt.getOperand(0);
18736     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
18737                      VT.getVectorNumElements();
18738     std::vector<SDValue> Vals(Ratio);
18739     for (unsigned i = 0; i != Ratio; ++i)
18740       Vals[i] = Amt.getOperand(i);
18741     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
18742       for (unsigned j = 0; j != Ratio; ++j)
18743         if (Vals[j] != Amt.getOperand(i + j))
18744           return SDValue();
18745     }
18746     switch (Op.getOpcode()) {
18747     default:
18748       llvm_unreachable("Unknown shift opcode!");
18749     case ISD::SHL:
18750       return DAG.getNode(X86ISD::VSHL, dl, VT, R, Op.getOperand(1));
18751     case ISD::SRL:
18752       return DAG.getNode(X86ISD::VSRL, dl, VT, R, Op.getOperand(1));
18753     case ISD::SRA:
18754       return DAG.getNode(X86ISD::VSRA, dl, VT, R, Op.getOperand(1));
18755     }
18756   }
18757
18758   return SDValue();
18759 }
18760
18761 static SDValue LowerShift(SDValue Op, const X86Subtarget* Subtarget,
18762                           SelectionDAG &DAG) {
18763   MVT VT = Op.getSimpleValueType();
18764   SDLoc dl(Op);
18765   SDValue R = Op.getOperand(0);
18766   SDValue Amt = Op.getOperand(1);
18767   SDValue V;
18768
18769   assert(VT.isVector() && "Custom lowering only for vector shifts!");
18770   assert(Subtarget->hasSSE2() && "Only custom lower when we have SSE2!");
18771
18772   V = LowerScalarImmediateShift(Op, DAG, Subtarget);
18773   if (V.getNode())
18774     return V;
18775
18776   V = LowerScalarVariableShift(Op, DAG, Subtarget);
18777   if (V.getNode())
18778       return V;
18779
18780   if (Subtarget->hasAVX512() && (VT == MVT::v16i32 || VT == MVT::v8i64))
18781     return Op;
18782   // AVX2 has VPSLLV/VPSRAV/VPSRLV.
18783   if (Subtarget->hasInt256()) {
18784     if (Op.getOpcode() == ISD::SRL &&
18785         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
18786          VT == MVT::v4i64 || VT == MVT::v8i32))
18787       return Op;
18788     if (Op.getOpcode() == ISD::SHL &&
18789         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
18790          VT == MVT::v4i64 || VT == MVT::v8i32))
18791       return Op;
18792     if (Op.getOpcode() == ISD::SRA && (VT == MVT::v4i32 || VT == MVT::v8i32))
18793       return Op;
18794   }
18795
18796   // If possible, lower this packed shift into a vector multiply instead of
18797   // expanding it into a sequence of scalar shifts.
18798   // Do this only if the vector shift count is a constant build_vector.
18799   if (Op.getOpcode() == ISD::SHL &&
18800       (VT == MVT::v8i16 || VT == MVT::v4i32 ||
18801        (Subtarget->hasInt256() && VT == MVT::v16i16)) &&
18802       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
18803     SmallVector<SDValue, 8> Elts;
18804     EVT SVT = VT.getScalarType();
18805     unsigned SVTBits = SVT.getSizeInBits();
18806     const APInt &One = APInt(SVTBits, 1);
18807     unsigned NumElems = VT.getVectorNumElements();
18808
18809     for (unsigned i=0; i !=NumElems; ++i) {
18810       SDValue Op = Amt->getOperand(i);
18811       if (Op->getOpcode() == ISD::UNDEF) {
18812         Elts.push_back(Op);
18813         continue;
18814       }
18815
18816       ConstantSDNode *ND = cast<ConstantSDNode>(Op);
18817       const APInt &C = APInt(SVTBits, ND->getAPIntValue().getZExtValue());
18818       uint64_t ShAmt = C.getZExtValue();
18819       if (ShAmt >= SVTBits) {
18820         Elts.push_back(DAG.getUNDEF(SVT));
18821         continue;
18822       }
18823       Elts.push_back(DAG.getConstant(One.shl(ShAmt), SVT));
18824     }
18825     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
18826     return DAG.getNode(ISD::MUL, dl, VT, R, BV);
18827   }
18828
18829   // Lower SHL with variable shift amount.
18830   if (VT == MVT::v4i32 && Op->getOpcode() == ISD::SHL) {
18831     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, VT));
18832
18833     Op = DAG.getNode(ISD::ADD, dl, VT, Op, DAG.getConstant(0x3f800000U, VT));
18834     Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
18835     Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
18836     return DAG.getNode(ISD::MUL, dl, VT, Op, R);
18837   }
18838
18839   // If possible, lower this shift as a sequence of two shifts by
18840   // constant plus a MOVSS/MOVSD instead of scalarizing it.
18841   // Example:
18842   //   (v4i32 (srl A, (build_vector < X, Y, Y, Y>)))
18843   //
18844   // Could be rewritten as:
18845   //   (v4i32 (MOVSS (srl A, <Y,Y,Y,Y>), (srl A, <X,X,X,X>)))
18846   //
18847   // The advantage is that the two shifts from the example would be
18848   // lowered as X86ISD::VSRLI nodes. This would be cheaper than scalarizing
18849   // the vector shift into four scalar shifts plus four pairs of vector
18850   // insert/extract.
18851   if ((VT == MVT::v8i16 || VT == MVT::v4i32) &&
18852       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
18853     unsigned TargetOpcode = X86ISD::MOVSS;
18854     bool CanBeSimplified;
18855     // The splat value for the first packed shift (the 'X' from the example).
18856     SDValue Amt1 = Amt->getOperand(0);
18857     // The splat value for the second packed shift (the 'Y' from the example).
18858     SDValue Amt2 = (VT == MVT::v4i32) ? Amt->getOperand(1) :
18859                                         Amt->getOperand(2);
18860
18861     // See if it is possible to replace this node with a sequence of
18862     // two shifts followed by a MOVSS/MOVSD
18863     if (VT == MVT::v4i32) {
18864       // Check if it is legal to use a MOVSS.
18865       CanBeSimplified = Amt2 == Amt->getOperand(2) &&
18866                         Amt2 == Amt->getOperand(3);
18867       if (!CanBeSimplified) {
18868         // Otherwise, check if we can still simplify this node using a MOVSD.
18869         CanBeSimplified = Amt1 == Amt->getOperand(1) &&
18870                           Amt->getOperand(2) == Amt->getOperand(3);
18871         TargetOpcode = X86ISD::MOVSD;
18872         Amt2 = Amt->getOperand(2);
18873       }
18874     } else {
18875       // Do similar checks for the case where the machine value type
18876       // is MVT::v8i16.
18877       CanBeSimplified = Amt1 == Amt->getOperand(1);
18878       for (unsigned i=3; i != 8 && CanBeSimplified; ++i)
18879         CanBeSimplified = Amt2 == Amt->getOperand(i);
18880
18881       if (!CanBeSimplified) {
18882         TargetOpcode = X86ISD::MOVSD;
18883         CanBeSimplified = true;
18884         Amt2 = Amt->getOperand(4);
18885         for (unsigned i=0; i != 4 && CanBeSimplified; ++i)
18886           CanBeSimplified = Amt1 == Amt->getOperand(i);
18887         for (unsigned j=4; j != 8 && CanBeSimplified; ++j)
18888           CanBeSimplified = Amt2 == Amt->getOperand(j);
18889       }
18890     }
18891
18892     if (CanBeSimplified && isa<ConstantSDNode>(Amt1) &&
18893         isa<ConstantSDNode>(Amt2)) {
18894       // Replace this node with two shifts followed by a MOVSS/MOVSD.
18895       EVT CastVT = MVT::v4i32;
18896       SDValue Splat1 =
18897         DAG.getConstant(cast<ConstantSDNode>(Amt1)->getAPIntValue(), VT);
18898       SDValue Shift1 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat1);
18899       SDValue Splat2 =
18900         DAG.getConstant(cast<ConstantSDNode>(Amt2)->getAPIntValue(), VT);
18901       SDValue Shift2 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat2);
18902       if (TargetOpcode == X86ISD::MOVSD)
18903         CastVT = MVT::v2i64;
18904       SDValue BitCast1 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift1);
18905       SDValue BitCast2 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift2);
18906       SDValue Result = getTargetShuffleNode(TargetOpcode, dl, CastVT, BitCast2,
18907                                             BitCast1, DAG);
18908       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
18909     }
18910   }
18911
18912   if (VT == MVT::v16i8 && Op->getOpcode() == ISD::SHL) {
18913     assert(Subtarget->hasSSE2() && "Need SSE2 for pslli/pcmpeq.");
18914
18915     // a = a << 5;
18916     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(5, VT));
18917     Op = DAG.getNode(ISD::BITCAST, dl, VT, Op);
18918
18919     // Turn 'a' into a mask suitable for VSELECT
18920     SDValue VSelM = DAG.getConstant(0x80, VT);
18921     SDValue OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
18922     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
18923
18924     SDValue CM1 = DAG.getConstant(0x0f, VT);
18925     SDValue CM2 = DAG.getConstant(0x3f, VT);
18926
18927     // r = VSELECT(r, psllw(r & (char16)15, 4), a);
18928     SDValue M = DAG.getNode(ISD::AND, dl, VT, R, CM1);
18929     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 4, DAG);
18930     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
18931     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
18932
18933     // a += a
18934     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
18935     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
18936     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
18937
18938     // r = VSELECT(r, psllw(r & (char16)63, 2), a);
18939     M = DAG.getNode(ISD::AND, dl, VT, R, CM2);
18940     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 2, DAG);
18941     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
18942     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
18943
18944     // a += a
18945     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
18946     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
18947     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
18948
18949     // return VSELECT(r, r+r, a);
18950     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel,
18951                     DAG.getNode(ISD::ADD, dl, VT, R, R), R);
18952     return R;
18953   }
18954
18955   // It's worth extending once and using the v8i32 shifts for 16-bit types, but
18956   // the extra overheads to get from v16i8 to v8i32 make the existing SSE
18957   // solution better.
18958   if (Subtarget->hasInt256() && VT == MVT::v8i16) {
18959     MVT NewVT = VT == MVT::v8i16 ? MVT::v8i32 : MVT::v16i16;
18960     unsigned ExtOpc =
18961         Op.getOpcode() == ISD::SRA ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
18962     R = DAG.getNode(ExtOpc, dl, NewVT, R);
18963     Amt = DAG.getNode(ISD::ANY_EXTEND, dl, NewVT, Amt);
18964     return DAG.getNode(ISD::TRUNCATE, dl, VT,
18965                        DAG.getNode(Op.getOpcode(), dl, NewVT, R, Amt));
18966     }
18967
18968   // Decompose 256-bit shifts into smaller 128-bit shifts.
18969   if (VT.is256BitVector()) {
18970     unsigned NumElems = VT.getVectorNumElements();
18971     MVT EltVT = VT.getVectorElementType();
18972     EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
18973
18974     // Extract the two vectors
18975     SDValue V1 = Extract128BitVector(R, 0, DAG, dl);
18976     SDValue V2 = Extract128BitVector(R, NumElems/2, DAG, dl);
18977
18978     // Recreate the shift amount vectors
18979     SDValue Amt1, Amt2;
18980     if (Amt.getOpcode() == ISD::BUILD_VECTOR) {
18981       // Constant shift amount
18982       SmallVector<SDValue, 4> Amt1Csts;
18983       SmallVector<SDValue, 4> Amt2Csts;
18984       for (unsigned i = 0; i != NumElems/2; ++i)
18985         Amt1Csts.push_back(Amt->getOperand(i));
18986       for (unsigned i = NumElems/2; i != NumElems; ++i)
18987         Amt2Csts.push_back(Amt->getOperand(i));
18988
18989       Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt1Csts);
18990       Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt2Csts);
18991     } else {
18992       // Variable shift amount
18993       Amt1 = Extract128BitVector(Amt, 0, DAG, dl);
18994       Amt2 = Extract128BitVector(Amt, NumElems/2, DAG, dl);
18995     }
18996
18997     // Issue new vector shifts for the smaller types
18998     V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
18999     V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
19000
19001     // Concatenate the result back
19002     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
19003   }
19004
19005   return SDValue();
19006 }
19007
19008 static SDValue LowerXALUO(SDValue Op, SelectionDAG &DAG) {
19009   // Lower the "add/sub/mul with overflow" instruction into a regular ins plus
19010   // a "setcc" instruction that checks the overflow flag. The "brcond" lowering
19011   // looks for this combo and may remove the "setcc" instruction if the "setcc"
19012   // has only one use.
19013   SDNode *N = Op.getNode();
19014   SDValue LHS = N->getOperand(0);
19015   SDValue RHS = N->getOperand(1);
19016   unsigned BaseOp = 0;
19017   unsigned Cond = 0;
19018   SDLoc DL(Op);
19019   switch (Op.getOpcode()) {
19020   default: llvm_unreachable("Unknown ovf instruction!");
19021   case ISD::SADDO:
19022     // A subtract of one will be selected as a INC. Note that INC doesn't
19023     // set CF, so we can't do this for UADDO.
19024     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
19025       if (C->isOne()) {
19026         BaseOp = X86ISD::INC;
19027         Cond = X86::COND_O;
19028         break;
19029       }
19030     BaseOp = X86ISD::ADD;
19031     Cond = X86::COND_O;
19032     break;
19033   case ISD::UADDO:
19034     BaseOp = X86ISD::ADD;
19035     Cond = X86::COND_B;
19036     break;
19037   case ISD::SSUBO:
19038     // A subtract of one will be selected as a DEC. Note that DEC doesn't
19039     // set CF, so we can't do this for USUBO.
19040     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
19041       if (C->isOne()) {
19042         BaseOp = X86ISD::DEC;
19043         Cond = X86::COND_O;
19044         break;
19045       }
19046     BaseOp = X86ISD::SUB;
19047     Cond = X86::COND_O;
19048     break;
19049   case ISD::USUBO:
19050     BaseOp = X86ISD::SUB;
19051     Cond = X86::COND_B;
19052     break;
19053   case ISD::SMULO:
19054     BaseOp = N->getValueType(0) == MVT::i8 ? X86ISD::SMUL8 : X86ISD::SMUL;
19055     Cond = X86::COND_O;
19056     break;
19057   case ISD::UMULO: { // i64, i8 = umulo lhs, rhs --> i64, i64, i32 umul lhs,rhs
19058     if (N->getValueType(0) == MVT::i8) {
19059       BaseOp = X86ISD::UMUL8;
19060       Cond = X86::COND_O;
19061       break;
19062     }
19063     SDVTList VTs = DAG.getVTList(N->getValueType(0), N->getValueType(0),
19064                                  MVT::i32);
19065     SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
19066
19067     SDValue SetCC =
19068       DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
19069                   DAG.getConstant(X86::COND_O, MVT::i32),
19070                   SDValue(Sum.getNode(), 2));
19071
19072     return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
19073   }
19074   }
19075
19076   // Also sets EFLAGS.
19077   SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::i32);
19078   SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
19079
19080   SDValue SetCC =
19081     DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
19082                 DAG.getConstant(Cond, MVT::i32),
19083                 SDValue(Sum.getNode(), 1));
19084
19085   return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
19086 }
19087
19088 // Sign extension of the low part of vector elements. This may be used either
19089 // when sign extend instructions are not available or if the vector element
19090 // sizes already match the sign-extended size. If the vector elements are in
19091 // their pre-extended size and sign extend instructions are available, that will
19092 // be handled by LowerSIGN_EXTEND.
19093 SDValue X86TargetLowering::LowerSIGN_EXTEND_INREG(SDValue Op,
19094                                                   SelectionDAG &DAG) const {
19095   SDLoc dl(Op);
19096   EVT ExtraVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
19097   MVT VT = Op.getSimpleValueType();
19098
19099   if (!Subtarget->hasSSE2() || !VT.isVector())
19100     return SDValue();
19101
19102   unsigned BitsDiff = VT.getScalarType().getSizeInBits() -
19103                       ExtraVT.getScalarType().getSizeInBits();
19104
19105   switch (VT.SimpleTy) {
19106     default: return SDValue();
19107     case MVT::v8i32:
19108     case MVT::v16i16:
19109       if (!Subtarget->hasFp256())
19110         return SDValue();
19111       if (!Subtarget->hasInt256()) {
19112         // needs to be split
19113         unsigned NumElems = VT.getVectorNumElements();
19114
19115         // Extract the LHS vectors
19116         SDValue LHS = Op.getOperand(0);
19117         SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
19118         SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
19119
19120         MVT EltVT = VT.getVectorElementType();
19121         EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
19122
19123         EVT ExtraEltVT = ExtraVT.getVectorElementType();
19124         unsigned ExtraNumElems = ExtraVT.getVectorNumElements();
19125         ExtraVT = EVT::getVectorVT(*DAG.getContext(), ExtraEltVT,
19126                                    ExtraNumElems/2);
19127         SDValue Extra = DAG.getValueType(ExtraVT);
19128
19129         LHS1 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, Extra);
19130         LHS2 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, Extra);
19131
19132         return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, LHS1, LHS2);
19133       }
19134       // fall through
19135     case MVT::v4i32:
19136     case MVT::v8i16: {
19137       SDValue Op0 = Op.getOperand(0);
19138
19139       // This is a sign extension of some low part of vector elements without
19140       // changing the size of the vector elements themselves:
19141       // Shift-Left + Shift-Right-Algebraic.
19142       SDValue Shl = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, Op0,
19143                                                BitsDiff, DAG);
19144       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, Shl, BitsDiff,
19145                                         DAG);
19146     }
19147   }
19148 }
19149
19150 /// Returns true if the operand type is exactly twice the native width, and
19151 /// the corresponding cmpxchg8b or cmpxchg16b instruction is available.
19152 /// Used to know whether to use cmpxchg8/16b when expanding atomic operations
19153 /// (otherwise we leave them alone to become __sync_fetch_and_... calls).
19154 bool X86TargetLowering::needsCmpXchgNb(const Type *MemType) const {
19155   const X86Subtarget &Subtarget =
19156       getTargetMachine().getSubtarget<X86Subtarget>();
19157   unsigned OpWidth = MemType->getPrimitiveSizeInBits();
19158
19159   if (OpWidth == 64)
19160     return !Subtarget.is64Bit(); // FIXME this should be Subtarget.hasCmpxchg8b
19161   else if (OpWidth == 128)
19162     return Subtarget.hasCmpxchg16b();
19163   else
19164     return false;
19165 }
19166
19167 bool X86TargetLowering::shouldExpandAtomicStoreInIR(StoreInst *SI) const {
19168   return needsCmpXchgNb(SI->getValueOperand()->getType());
19169 }
19170
19171 // Note: this turns large loads into lock cmpxchg8b/16b.
19172 // FIXME: On 32 bits x86, fild/movq might be faster than lock cmpxchg8b.
19173 bool X86TargetLowering::shouldExpandAtomicLoadInIR(LoadInst *LI) const {
19174   auto PTy = cast<PointerType>(LI->getPointerOperand()->getType());
19175   return needsCmpXchgNb(PTy->getElementType());
19176 }
19177
19178 bool X86TargetLowering::shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const {
19179   const X86Subtarget &Subtarget =
19180       getTargetMachine().getSubtarget<X86Subtarget>();
19181   unsigned NativeWidth = Subtarget.is64Bit() ? 64 : 32;
19182   const Type *MemType = AI->getType();
19183
19184   // If the operand is too big, we must see if cmpxchg8/16b is available
19185   // and default to library calls otherwise.
19186   if (MemType->getPrimitiveSizeInBits() > NativeWidth)
19187     return needsCmpXchgNb(MemType);
19188
19189   AtomicRMWInst::BinOp Op = AI->getOperation();
19190   switch (Op) {
19191   default:
19192     llvm_unreachable("Unknown atomic operation");
19193   case AtomicRMWInst::Xchg:
19194   case AtomicRMWInst::Add:
19195   case AtomicRMWInst::Sub:
19196     // It's better to use xadd, xsub or xchg for these in all cases.
19197     return false;
19198   case AtomicRMWInst::Or:
19199   case AtomicRMWInst::And:
19200   case AtomicRMWInst::Xor:
19201     // If the atomicrmw's result isn't actually used, we can just add a "lock"
19202     // prefix to a normal instruction for these operations.
19203     return !AI->use_empty();
19204   case AtomicRMWInst::Nand:
19205   case AtomicRMWInst::Max:
19206   case AtomicRMWInst::Min:
19207   case AtomicRMWInst::UMax:
19208   case AtomicRMWInst::UMin:
19209     // These always require a non-trivial set of data operations on x86. We must
19210     // use a cmpxchg loop.
19211     return true;
19212   }
19213 }
19214
19215 static bool hasMFENCE(const X86Subtarget& Subtarget) {
19216   // Use mfence if we have SSE2 or we're on x86-64 (even if we asked for
19217   // no-sse2). There isn't any reason to disable it if the target processor
19218   // supports it.
19219   return Subtarget.hasSSE2() || Subtarget.is64Bit();
19220 }
19221
19222 LoadInst *
19223 X86TargetLowering::lowerIdempotentRMWIntoFencedLoad(AtomicRMWInst *AI) const {
19224   const X86Subtarget &Subtarget =
19225       getTargetMachine().getSubtarget<X86Subtarget>();
19226   unsigned NativeWidth = Subtarget.is64Bit() ? 64 : 32;
19227   const Type *MemType = AI->getType();
19228   // Accesses larger than the native width are turned into cmpxchg/libcalls, so
19229   // there is no benefit in turning such RMWs into loads, and it is actually
19230   // harmful as it introduces a mfence.
19231   if (MemType->getPrimitiveSizeInBits() > NativeWidth)
19232     return nullptr;
19233
19234   auto Builder = IRBuilder<>(AI);
19235   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
19236   auto SynchScope = AI->getSynchScope();
19237   // We must restrict the ordering to avoid generating loads with Release or
19238   // ReleaseAcquire orderings.
19239   auto Order = AtomicCmpXchgInst::getStrongestFailureOrdering(AI->getOrdering());
19240   auto Ptr = AI->getPointerOperand();
19241
19242   // Before the load we need a fence. Here is an example lifted from
19243   // http://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf showing why a fence
19244   // is required:
19245   // Thread 0:
19246   //   x.store(1, relaxed);
19247   //   r1 = y.fetch_add(0, release);
19248   // Thread 1:
19249   //   y.fetch_add(42, acquire);
19250   //   r2 = x.load(relaxed);
19251   // r1 = r2 = 0 is impossible, but becomes possible if the idempotent rmw is
19252   // lowered to just a load without a fence. A mfence flushes the store buffer,
19253   // making the optimization clearly correct.
19254   // FIXME: it is required if isAtLeastRelease(Order) but it is not clear
19255   // otherwise, we might be able to be more agressive on relaxed idempotent
19256   // rmw. In practice, they do not look useful, so we don't try to be
19257   // especially clever.
19258   if (SynchScope == SingleThread) {
19259     // FIXME: we could just insert an X86ISD::MEMBARRIER here, except we are at
19260     // the IR level, so we must wrap it in an intrinsic.
19261     return nullptr;
19262   } else if (hasMFENCE(Subtarget)) {
19263     Function *MFence = llvm::Intrinsic::getDeclaration(M,
19264             Intrinsic::x86_sse2_mfence);
19265     Builder.CreateCall(MFence);
19266   } else {
19267     // FIXME: it might make sense to use a locked operation here but on a
19268     // different cache-line to prevent cache-line bouncing. In practice it
19269     // is probably a small win, and x86 processors without mfence are rare
19270     // enough that we do not bother.
19271     return nullptr;
19272   }
19273
19274   // Finally we can emit the atomic load.
19275   LoadInst *Loaded = Builder.CreateAlignedLoad(Ptr,
19276           AI->getType()->getPrimitiveSizeInBits());
19277   Loaded->setAtomic(Order, SynchScope);
19278   AI->replaceAllUsesWith(Loaded);
19279   AI->eraseFromParent();
19280   return Loaded;
19281 }
19282
19283 static SDValue LowerATOMIC_FENCE(SDValue Op, const X86Subtarget *Subtarget,
19284                                  SelectionDAG &DAG) {
19285   SDLoc dl(Op);
19286   AtomicOrdering FenceOrdering = static_cast<AtomicOrdering>(
19287     cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue());
19288   SynchronizationScope FenceScope = static_cast<SynchronizationScope>(
19289     cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue());
19290
19291   // The only fence that needs an instruction is a sequentially-consistent
19292   // cross-thread fence.
19293   if (FenceOrdering == SequentiallyConsistent && FenceScope == CrossThread) {
19294     if (hasMFENCE(*Subtarget))
19295       return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
19296
19297     SDValue Chain = Op.getOperand(0);
19298     SDValue Zero = DAG.getConstant(0, MVT::i32);
19299     SDValue Ops[] = {
19300       DAG.getRegister(X86::ESP, MVT::i32), // Base
19301       DAG.getTargetConstant(1, MVT::i8),   // Scale
19302       DAG.getRegister(0, MVT::i32),        // Index
19303       DAG.getTargetConstant(0, MVT::i32),  // Disp
19304       DAG.getRegister(0, MVT::i32),        // Segment.
19305       Zero,
19306       Chain
19307     };
19308     SDNode *Res = DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops);
19309     return SDValue(Res, 0);
19310   }
19311
19312   // MEMBARRIER is a compiler barrier; it codegens to a no-op.
19313   return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
19314 }
19315
19316 static SDValue LowerCMP_SWAP(SDValue Op, const X86Subtarget *Subtarget,
19317                              SelectionDAG &DAG) {
19318   MVT T = Op.getSimpleValueType();
19319   SDLoc DL(Op);
19320   unsigned Reg = 0;
19321   unsigned size = 0;
19322   switch(T.SimpleTy) {
19323   default: llvm_unreachable("Invalid value type!");
19324   case MVT::i8:  Reg = X86::AL;  size = 1; break;
19325   case MVT::i16: Reg = X86::AX;  size = 2; break;
19326   case MVT::i32: Reg = X86::EAX; size = 4; break;
19327   case MVT::i64:
19328     assert(Subtarget->is64Bit() && "Node not type legal!");
19329     Reg = X86::RAX; size = 8;
19330     break;
19331   }
19332   SDValue cpIn = DAG.getCopyToReg(Op.getOperand(0), DL, Reg,
19333                                   Op.getOperand(2), SDValue());
19334   SDValue Ops[] = { cpIn.getValue(0),
19335                     Op.getOperand(1),
19336                     Op.getOperand(3),
19337                     DAG.getTargetConstant(size, MVT::i8),
19338                     cpIn.getValue(1) };
19339   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
19340   MachineMemOperand *MMO = cast<AtomicSDNode>(Op)->getMemOperand();
19341   SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG_DAG, DL, Tys,
19342                                            Ops, T, MMO);
19343
19344   SDValue cpOut =
19345     DAG.getCopyFromReg(Result.getValue(0), DL, Reg, T, Result.getValue(1));
19346   SDValue EFLAGS = DAG.getCopyFromReg(cpOut.getValue(1), DL, X86::EFLAGS,
19347                                       MVT::i32, cpOut.getValue(2));
19348   SDValue Success = DAG.getNode(X86ISD::SETCC, DL, Op->getValueType(1),
19349                                 DAG.getConstant(X86::COND_E, MVT::i8), EFLAGS);
19350
19351   DAG.ReplaceAllUsesOfValueWith(Op.getValue(0), cpOut);
19352   DAG.ReplaceAllUsesOfValueWith(Op.getValue(1), Success);
19353   DAG.ReplaceAllUsesOfValueWith(Op.getValue(2), EFLAGS.getValue(1));
19354   return SDValue();
19355 }
19356
19357 static SDValue LowerBITCAST(SDValue Op, const X86Subtarget *Subtarget,
19358                             SelectionDAG &DAG) {
19359   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
19360   MVT DstVT = Op.getSimpleValueType();
19361
19362   if (SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 || SrcVT == MVT::v8i8) {
19363     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
19364     if (DstVT != MVT::f64)
19365       // This conversion needs to be expanded.
19366       return SDValue();
19367
19368     SDValue InVec = Op->getOperand(0);
19369     SDLoc dl(Op);
19370     unsigned NumElts = SrcVT.getVectorNumElements();
19371     EVT SVT = SrcVT.getVectorElementType();
19372
19373     // Widen the vector in input in the case of MVT::v2i32.
19374     // Example: from MVT::v2i32 to MVT::v4i32.
19375     SmallVector<SDValue, 16> Elts;
19376     for (unsigned i = 0, e = NumElts; i != e; ++i)
19377       Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT, InVec,
19378                                  DAG.getIntPtrConstant(i)));
19379
19380     // Explicitly mark the extra elements as Undef.
19381     SDValue Undef = DAG.getUNDEF(SVT);
19382     for (unsigned i = NumElts, e = NumElts * 2; i != e; ++i)
19383       Elts.push_back(Undef);
19384
19385     EVT NewVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumElts * 2);
19386     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Elts);
19387     SDValue ToV2F64 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, BV);
19388     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, ToV2F64,
19389                        DAG.getIntPtrConstant(0));
19390   }
19391
19392   assert(Subtarget->is64Bit() && !Subtarget->hasSSE2() &&
19393          Subtarget->hasMMX() && "Unexpected custom BITCAST");
19394   assert((DstVT == MVT::i64 ||
19395           (DstVT.isVector() && DstVT.getSizeInBits()==64)) &&
19396          "Unexpected custom BITCAST");
19397   // i64 <=> MMX conversions are Legal.
19398   if (SrcVT==MVT::i64 && DstVT.isVector())
19399     return Op;
19400   if (DstVT==MVT::i64 && SrcVT.isVector())
19401     return Op;
19402   // MMX <=> MMX conversions are Legal.
19403   if (SrcVT.isVector() && DstVT.isVector())
19404     return Op;
19405   // All other conversions need to be expanded.
19406   return SDValue();
19407 }
19408
19409 static SDValue LowerCTPOP(SDValue Op, const X86Subtarget *Subtarget,
19410                           SelectionDAG &DAG) {
19411   SDNode *Node = Op.getNode();
19412   SDLoc dl(Node);
19413
19414   Op = Op.getOperand(0);
19415   EVT VT = Op.getValueType();
19416   assert((VT.is128BitVector() || VT.is256BitVector()) &&
19417          "CTPOP lowering only implemented for 128/256-bit wide vector types");
19418
19419   unsigned NumElts = VT.getVectorNumElements();
19420   EVT EltVT = VT.getVectorElementType();
19421   unsigned Len = EltVT.getSizeInBits();
19422
19423   // This is the vectorized version of the "best" algorithm from
19424   // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
19425   // with a minor tweak to use a series of adds + shifts instead of vector
19426   // multiplications. Implemented for the v2i64, v4i64, v4i32, v8i32 types:
19427   //
19428   //  v2i64, v4i64, v4i32 => Only profitable w/ popcnt disabled
19429   //  v8i32 => Always profitable
19430   //
19431   // FIXME: There a couple of possible improvements:
19432   //
19433   // 1) Support for i8 and i16 vectors (needs measurements if popcnt enabled).
19434   // 2) Use strategies from http://wm.ite.pl/articles/sse-popcount.html
19435   //
19436   assert(EltVT.isInteger() && (Len == 32 || Len == 64) && Len % 8 == 0 &&
19437          "CTPOP not implemented for this vector element type.");
19438
19439   // X86 canonicalize ANDs to vXi64, generate the appropriate bitcasts to avoid
19440   // extra legalization.
19441   bool NeedsBitcast = EltVT == MVT::i32;
19442   MVT BitcastVT = VT.is256BitVector() ? MVT::v4i64 : MVT::v2i64;
19443
19444   SDValue Cst55 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x55)), EltVT);
19445   SDValue Cst33 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x33)), EltVT);
19446   SDValue Cst0F = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x0F)), EltVT);
19447
19448   // v = v - ((v >> 1) & 0x55555555...)
19449   SmallVector<SDValue, 8> Ones(NumElts, DAG.getConstant(1, EltVT));
19450   SDValue OnesV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ones);
19451   SDValue Srl = DAG.getNode(ISD::SRL, dl, VT, Op, OnesV);
19452   if (NeedsBitcast)
19453     Srl = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Srl);
19454
19455   SmallVector<SDValue, 8> Mask55(NumElts, Cst55);
19456   SDValue M55 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask55);
19457   if (NeedsBitcast)
19458     M55 = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M55);
19459
19460   SDValue And = DAG.getNode(ISD::AND, dl, Srl.getValueType(), Srl, M55);
19461   if (VT != And.getValueType())
19462     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19463   SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, Op, And);
19464
19465   // v = (v & 0x33333333...) + ((v >> 2) & 0x33333333...)
19466   SmallVector<SDValue, 8> Mask33(NumElts, Cst33);
19467   SDValue M33 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask33);
19468   SmallVector<SDValue, 8> Twos(NumElts, DAG.getConstant(2, EltVT));
19469   SDValue TwosV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Twos);
19470
19471   Srl = DAG.getNode(ISD::SRL, dl, VT, Sub, TwosV);
19472   if (NeedsBitcast) {
19473     Srl = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Srl);
19474     M33 = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M33);
19475     Sub = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Sub);
19476   }
19477
19478   SDValue AndRHS = DAG.getNode(ISD::AND, dl, M33.getValueType(), Srl, M33);
19479   SDValue AndLHS = DAG.getNode(ISD::AND, dl, M33.getValueType(), Sub, M33);
19480   if (VT != AndRHS.getValueType()) {
19481     AndRHS = DAG.getNode(ISD::BITCAST, dl, VT, AndRHS);
19482     AndLHS = DAG.getNode(ISD::BITCAST, dl, VT, AndLHS);
19483   }
19484   SDValue Add = DAG.getNode(ISD::ADD, dl, VT, AndLHS, AndRHS);
19485
19486   // v = (v + (v >> 4)) & 0x0F0F0F0F...
19487   SmallVector<SDValue, 8> Fours(NumElts, DAG.getConstant(4, EltVT));
19488   SDValue FoursV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Fours);
19489   Srl = DAG.getNode(ISD::SRL, dl, VT, Add, FoursV);
19490   Add = DAG.getNode(ISD::ADD, dl, VT, Add, Srl);
19491
19492   SmallVector<SDValue, 8> Mask0F(NumElts, Cst0F);
19493   SDValue M0F = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask0F);
19494   if (NeedsBitcast) {
19495     Add = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Add);
19496     M0F = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M0F);
19497   }
19498   And = DAG.getNode(ISD::AND, dl, M0F.getValueType(), Add, M0F);
19499   if (VT != And.getValueType())
19500     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19501
19502   // The algorithm mentioned above uses:
19503   //    v = (v * 0x01010101...) >> (Len - 8)
19504   //
19505   // Change it to use vector adds + vector shifts which yield faster results on
19506   // Haswell than using vector integer multiplication.
19507   //
19508   // For i32 elements:
19509   //    v = v + (v >> 8)
19510   //    v = v + (v >> 16)
19511   //
19512   // For i64 elements:
19513   //    v = v + (v >> 8)
19514   //    v = v + (v >> 16)
19515   //    v = v + (v >> 32)
19516   //
19517   Add = And;
19518   SmallVector<SDValue, 8> Csts;
19519   for (unsigned i = 8; i <= Len/2; i *= 2) {
19520     Csts.assign(NumElts, DAG.getConstant(i, EltVT));
19521     SDValue CstsV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Csts);
19522     Srl = DAG.getNode(ISD::SRL, dl, VT, Add, CstsV);
19523     Add = DAG.getNode(ISD::ADD, dl, VT, Add, Srl);
19524     Csts.clear();
19525   }
19526
19527   // The result is on the least significant 6-bits on i32 and 7-bits on i64.
19528   SDValue Cst3F = DAG.getConstant(APInt(Len, Len == 32 ? 0x3F : 0x7F), EltVT);
19529   SmallVector<SDValue, 8> Cst3FV(NumElts, Cst3F);
19530   SDValue M3F = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Cst3FV);
19531   if (NeedsBitcast) {
19532     Add = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Add);
19533     M3F = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M3F);
19534   }
19535   And = DAG.getNode(ISD::AND, dl, M3F.getValueType(), Add, M3F);
19536   if (VT != And.getValueType())
19537     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
19538
19539   return And;
19540 }
19541
19542 static SDValue LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) {
19543   SDNode *Node = Op.getNode();
19544   SDLoc dl(Node);
19545   EVT T = Node->getValueType(0);
19546   SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
19547                               DAG.getConstant(0, T), Node->getOperand(2));
19548   return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, dl,
19549                        cast<AtomicSDNode>(Node)->getMemoryVT(),
19550                        Node->getOperand(0),
19551                        Node->getOperand(1), negOp,
19552                        cast<AtomicSDNode>(Node)->getMemOperand(),
19553                        cast<AtomicSDNode>(Node)->getOrdering(),
19554                        cast<AtomicSDNode>(Node)->getSynchScope());
19555 }
19556
19557 static SDValue LowerATOMIC_STORE(SDValue Op, SelectionDAG &DAG) {
19558   SDNode *Node = Op.getNode();
19559   SDLoc dl(Node);
19560   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
19561
19562   // Convert seq_cst store -> xchg
19563   // Convert wide store -> swap (-> cmpxchg8b/cmpxchg16b)
19564   // FIXME: On 32-bit, store -> fist or movq would be more efficient
19565   //        (The only way to get a 16-byte store is cmpxchg16b)
19566   // FIXME: 16-byte ATOMIC_SWAP isn't actually hooked up at the moment.
19567   if (cast<AtomicSDNode>(Node)->getOrdering() == SequentiallyConsistent ||
19568       !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
19569     SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
19570                                  cast<AtomicSDNode>(Node)->getMemoryVT(),
19571                                  Node->getOperand(0),
19572                                  Node->getOperand(1), Node->getOperand(2),
19573                                  cast<AtomicSDNode>(Node)->getMemOperand(),
19574                                  cast<AtomicSDNode>(Node)->getOrdering(),
19575                                  cast<AtomicSDNode>(Node)->getSynchScope());
19576     return Swap.getValue(1);
19577   }
19578   // Other atomic stores have a simple pattern.
19579   return Op;
19580 }
19581
19582 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
19583   EVT VT = Op.getNode()->getSimpleValueType(0);
19584
19585   // Let legalize expand this if it isn't a legal type yet.
19586   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
19587     return SDValue();
19588
19589   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
19590
19591   unsigned Opc;
19592   bool ExtraOp = false;
19593   switch (Op.getOpcode()) {
19594   default: llvm_unreachable("Invalid code");
19595   case ISD::ADDC: Opc = X86ISD::ADD; break;
19596   case ISD::ADDE: Opc = X86ISD::ADC; ExtraOp = true; break;
19597   case ISD::SUBC: Opc = X86ISD::SUB; break;
19598   case ISD::SUBE: Opc = X86ISD::SBB; ExtraOp = true; break;
19599   }
19600
19601   if (!ExtraOp)
19602     return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
19603                        Op.getOperand(1));
19604   return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
19605                      Op.getOperand(1), Op.getOperand(2));
19606 }
19607
19608 static SDValue LowerFSINCOS(SDValue Op, const X86Subtarget *Subtarget,
19609                             SelectionDAG &DAG) {
19610   assert(Subtarget->isTargetDarwin() && Subtarget->is64Bit());
19611
19612   // For MacOSX, we want to call an alternative entry point: __sincos_stret,
19613   // which returns the values as { float, float } (in XMM0) or
19614   // { double, double } (which is returned in XMM0, XMM1).
19615   SDLoc dl(Op);
19616   SDValue Arg = Op.getOperand(0);
19617   EVT ArgVT = Arg.getValueType();
19618   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
19619
19620   TargetLowering::ArgListTy Args;
19621   TargetLowering::ArgListEntry Entry;
19622
19623   Entry.Node = Arg;
19624   Entry.Ty = ArgTy;
19625   Entry.isSExt = false;
19626   Entry.isZExt = false;
19627   Args.push_back(Entry);
19628
19629   bool isF64 = ArgVT == MVT::f64;
19630   // Only optimize x86_64 for now. i386 is a bit messy. For f32,
19631   // the small struct {f32, f32} is returned in (eax, edx). For f64,
19632   // the results are returned via SRet in memory.
19633   const char *LibcallName =  isF64 ? "__sincos_stret" : "__sincosf_stret";
19634   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
19635   SDValue Callee = DAG.getExternalSymbol(LibcallName, TLI.getPointerTy());
19636
19637   Type *RetTy = isF64
19638     ? (Type*)StructType::get(ArgTy, ArgTy, nullptr)
19639     : (Type*)VectorType::get(ArgTy, 4);
19640
19641   TargetLowering::CallLoweringInfo CLI(DAG);
19642   CLI.setDebugLoc(dl).setChain(DAG.getEntryNode())
19643     .setCallee(CallingConv::C, RetTy, Callee, std::move(Args), 0);
19644
19645   std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
19646
19647   if (isF64)
19648     // Returned in xmm0 and xmm1.
19649     return CallResult.first;
19650
19651   // Returned in bits 0:31 and 32:64 xmm0.
19652   SDValue SinVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
19653                                CallResult.first, DAG.getIntPtrConstant(0));
19654   SDValue CosVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
19655                                CallResult.first, DAG.getIntPtrConstant(1));
19656   SDVTList Tys = DAG.getVTList(ArgVT, ArgVT);
19657   return DAG.getNode(ISD::MERGE_VALUES, dl, Tys, SinVal, CosVal);
19658 }
19659
19660 /// LowerOperation - Provide custom lowering hooks for some operations.
19661 ///
19662 SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
19663   switch (Op.getOpcode()) {
19664   default: llvm_unreachable("Should not custom lower this!");
19665   case ISD::SIGN_EXTEND_INREG:  return LowerSIGN_EXTEND_INREG(Op,DAG);
19666   case ISD::ATOMIC_FENCE:       return LowerATOMIC_FENCE(Op, Subtarget, DAG);
19667   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS:
19668     return LowerCMP_SWAP(Op, Subtarget, DAG);
19669   case ISD::CTPOP:              return LowerCTPOP(Op, Subtarget, DAG);
19670   case ISD::ATOMIC_LOAD_SUB:    return LowerLOAD_SUB(Op,DAG);
19671   case ISD::ATOMIC_STORE:       return LowerATOMIC_STORE(Op,DAG);
19672   case ISD::BUILD_VECTOR:       return LowerBUILD_VECTOR(Op, DAG);
19673   case ISD::CONCAT_VECTORS:     return LowerCONCAT_VECTORS(Op, DAG);
19674   case ISD::VECTOR_SHUFFLE:     return LowerVECTOR_SHUFFLE(Op, DAG);
19675   case ISD::VSELECT:            return LowerVSELECT(Op, DAG);
19676   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
19677   case ISD::INSERT_VECTOR_ELT:  return LowerINSERT_VECTOR_ELT(Op, DAG);
19678   case ISD::EXTRACT_SUBVECTOR:  return LowerEXTRACT_SUBVECTOR(Op,Subtarget,DAG);
19679   case ISD::INSERT_SUBVECTOR:   return LowerINSERT_SUBVECTOR(Op, Subtarget,DAG);
19680   case ISD::SCALAR_TO_VECTOR:   return LowerSCALAR_TO_VECTOR(Op, DAG);
19681   case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
19682   case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
19683   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
19684   case ISD::ExternalSymbol:     return LowerExternalSymbol(Op, DAG);
19685   case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
19686   case ISD::SHL_PARTS:
19687   case ISD::SRA_PARTS:
19688   case ISD::SRL_PARTS:          return LowerShiftParts(Op, DAG);
19689   case ISD::SINT_TO_FP:         return LowerSINT_TO_FP(Op, DAG);
19690   case ISD::UINT_TO_FP:         return LowerUINT_TO_FP(Op, DAG);
19691   case ISD::TRUNCATE:           return LowerTRUNCATE(Op, DAG);
19692   case ISD::ZERO_EXTEND:        return LowerZERO_EXTEND(Op, Subtarget, DAG);
19693   case ISD::SIGN_EXTEND:        return LowerSIGN_EXTEND(Op, Subtarget, DAG);
19694   case ISD::ANY_EXTEND:         return LowerANY_EXTEND(Op, Subtarget, DAG);
19695   case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
19696   case ISD::FP_TO_UINT:         return LowerFP_TO_UINT(Op, DAG);
19697   case ISD::FP_EXTEND:          return LowerFP_EXTEND(Op, DAG);
19698   case ISD::LOAD:               return LowerExtendedLoad(Op, Subtarget, DAG);
19699   case ISD::FABS:
19700   case ISD::FNEG:               return LowerFABSorFNEG(Op, DAG);
19701   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
19702   case ISD::FGETSIGN:           return LowerFGETSIGN(Op, DAG);
19703   case ISD::SETCC:              return LowerSETCC(Op, DAG);
19704   case ISD::SELECT:             return LowerSELECT(Op, DAG);
19705   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
19706   case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
19707   case ISD::VASTART:            return LowerVASTART(Op, DAG);
19708   case ISD::VAARG:              return LowerVAARG(Op, DAG);
19709   case ISD::VACOPY:             return LowerVACOPY(Op, Subtarget, DAG);
19710   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, Subtarget, DAG);
19711   case ISD::INTRINSIC_VOID:
19712   case ISD::INTRINSIC_W_CHAIN:  return LowerINTRINSIC_W_CHAIN(Op, Subtarget, DAG);
19713   case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
19714   case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
19715   case ISD::FRAME_TO_ARGS_OFFSET:
19716                                 return LowerFRAME_TO_ARGS_OFFSET(Op, DAG);
19717   case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
19718   case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
19719   case ISD::EH_SJLJ_SETJMP:     return lowerEH_SJLJ_SETJMP(Op, DAG);
19720   case ISD::EH_SJLJ_LONGJMP:    return lowerEH_SJLJ_LONGJMP(Op, DAG);
19721   case ISD::INIT_TRAMPOLINE:    return LowerINIT_TRAMPOLINE(Op, DAG);
19722   case ISD::ADJUST_TRAMPOLINE:  return LowerADJUST_TRAMPOLINE(Op, DAG);
19723   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
19724   case ISD::CTLZ:               return LowerCTLZ(Op, DAG);
19725   case ISD::CTLZ_ZERO_UNDEF:    return LowerCTLZ_ZERO_UNDEF(Op, DAG);
19726   case ISD::CTTZ:               return LowerCTTZ(Op, DAG);
19727   case ISD::MUL:                return LowerMUL(Op, Subtarget, DAG);
19728   case ISD::UMUL_LOHI:
19729   case ISD::SMUL_LOHI:          return LowerMUL_LOHI(Op, Subtarget, DAG);
19730   case ISD::SRA:
19731   case ISD::SRL:
19732   case ISD::SHL:                return LowerShift(Op, Subtarget, DAG);
19733   case ISD::SADDO:
19734   case ISD::UADDO:
19735   case ISD::SSUBO:
19736   case ISD::USUBO:
19737   case ISD::SMULO:
19738   case ISD::UMULO:              return LowerXALUO(Op, DAG);
19739   case ISD::READCYCLECOUNTER:   return LowerREADCYCLECOUNTER(Op, Subtarget,DAG);
19740   case ISD::BITCAST:            return LowerBITCAST(Op, Subtarget, DAG);
19741   case ISD::ADDC:
19742   case ISD::ADDE:
19743   case ISD::SUBC:
19744   case ISD::SUBE:               return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
19745   case ISD::ADD:                return LowerADD(Op, DAG);
19746   case ISD::SUB:                return LowerSUB(Op, DAG);
19747   case ISD::FSINCOS:            return LowerFSINCOS(Op, Subtarget, DAG);
19748   }
19749 }
19750
19751 /// ReplaceNodeResults - Replace a node with an illegal result type
19752 /// with a new node built out of custom code.
19753 void X86TargetLowering::ReplaceNodeResults(SDNode *N,
19754                                            SmallVectorImpl<SDValue>&Results,
19755                                            SelectionDAG &DAG) const {
19756   SDLoc dl(N);
19757   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
19758   switch (N->getOpcode()) {
19759   default:
19760     llvm_unreachable("Do not know how to custom type legalize this operation!");
19761   // We might have generated v2f32 FMIN/FMAX operations. Widen them to v4f32.
19762   case X86ISD::FMINC:
19763   case X86ISD::FMIN:
19764   case X86ISD::FMAXC:
19765   case X86ISD::FMAX: {
19766     EVT VT = N->getValueType(0);
19767     if (VT != MVT::v2f32)
19768       llvm_unreachable("Unexpected type (!= v2f32) on FMIN/FMAX.");
19769     SDValue UNDEF = DAG.getUNDEF(VT);
19770     SDValue LHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
19771                               N->getOperand(0), UNDEF);
19772     SDValue RHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
19773                               N->getOperand(1), UNDEF);
19774     Results.push_back(DAG.getNode(N->getOpcode(), dl, MVT::v4f32, LHS, RHS));
19775     return;
19776   }
19777   case ISD::SIGN_EXTEND_INREG:
19778   case ISD::ADDC:
19779   case ISD::ADDE:
19780   case ISD::SUBC:
19781   case ISD::SUBE:
19782     // We don't want to expand or promote these.
19783     return;
19784   case ISD::SDIV:
19785   case ISD::UDIV:
19786   case ISD::SREM:
19787   case ISD::UREM:
19788   case ISD::SDIVREM:
19789   case ISD::UDIVREM: {
19790     SDValue V = LowerWin64_i128OP(SDValue(N,0), DAG);
19791     Results.push_back(V);
19792     return;
19793   }
19794   case ISD::FP_TO_SINT:
19795   case ISD::FP_TO_UINT: {
19796     bool IsSigned = N->getOpcode() == ISD::FP_TO_SINT;
19797
19798     if (!IsSigned && !isIntegerTypeFTOL(SDValue(N, 0).getValueType()))
19799       return;
19800
19801     std::pair<SDValue,SDValue> Vals =
19802         FP_TO_INTHelper(SDValue(N, 0), DAG, IsSigned, /*IsReplace=*/ true);
19803     SDValue FIST = Vals.first, StackSlot = Vals.second;
19804     if (FIST.getNode()) {
19805       EVT VT = N->getValueType(0);
19806       // Return a load from the stack slot.
19807       if (StackSlot.getNode())
19808         Results.push_back(DAG.getLoad(VT, dl, FIST, StackSlot,
19809                                       MachinePointerInfo(),
19810                                       false, false, false, 0));
19811       else
19812         Results.push_back(FIST);
19813     }
19814     return;
19815   }
19816   case ISD::UINT_TO_FP: {
19817     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
19818     if (N->getOperand(0).getValueType() != MVT::v2i32 ||
19819         N->getValueType(0) != MVT::v2f32)
19820       return;
19821     SDValue ZExtIn = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v2i64,
19822                                  N->getOperand(0));
19823     SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
19824                                      MVT::f64);
19825     SDValue VBias = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2f64, Bias, Bias);
19826     SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64, ZExtIn,
19827                              DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, VBias));
19828     Or = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or);
19829     SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, Or, VBias);
19830     Results.push_back(DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, Sub));
19831     return;
19832   }
19833   case ISD::FP_ROUND: {
19834     if (!TLI.isTypeLegal(N->getOperand(0).getValueType()))
19835         return;
19836     SDValue V = DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, N->getOperand(0));
19837     Results.push_back(V);
19838     return;
19839   }
19840   case ISD::INTRINSIC_W_CHAIN: {
19841     unsigned IntNo = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue();
19842     switch (IntNo) {
19843     default : llvm_unreachable("Do not know how to custom type "
19844                                "legalize this intrinsic operation!");
19845     case Intrinsic::x86_rdtsc:
19846       return getReadTimeStampCounter(N, dl, X86ISD::RDTSC_DAG, DAG, Subtarget,
19847                                      Results);
19848     case Intrinsic::x86_rdtscp:
19849       return getReadTimeStampCounter(N, dl, X86ISD::RDTSCP_DAG, DAG, Subtarget,
19850                                      Results);
19851     case Intrinsic::x86_rdpmc:
19852       return getReadPerformanceCounter(N, dl, DAG, Subtarget, Results);
19853     }
19854   }
19855   case ISD::READCYCLECOUNTER: {
19856     return getReadTimeStampCounter(N, dl, X86ISD::RDTSC_DAG, DAG, Subtarget,
19857                                    Results);
19858   }
19859   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: {
19860     EVT T = N->getValueType(0);
19861     assert((T == MVT::i64 || T == MVT::i128) && "can only expand cmpxchg pair");
19862     bool Regs64bit = T == MVT::i128;
19863     EVT HalfT = Regs64bit ? MVT::i64 : MVT::i32;
19864     SDValue cpInL, cpInH;
19865     cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
19866                         DAG.getConstant(0, HalfT));
19867     cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
19868                         DAG.getConstant(1, HalfT));
19869     cpInL = DAG.getCopyToReg(N->getOperand(0), dl,
19870                              Regs64bit ? X86::RAX : X86::EAX,
19871                              cpInL, SDValue());
19872     cpInH = DAG.getCopyToReg(cpInL.getValue(0), dl,
19873                              Regs64bit ? X86::RDX : X86::EDX,
19874                              cpInH, cpInL.getValue(1));
19875     SDValue swapInL, swapInH;
19876     swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
19877                           DAG.getConstant(0, HalfT));
19878     swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
19879                           DAG.getConstant(1, HalfT));
19880     swapInL = DAG.getCopyToReg(cpInH.getValue(0), dl,
19881                                Regs64bit ? X86::RBX : X86::EBX,
19882                                swapInL, cpInH.getValue(1));
19883     swapInH = DAG.getCopyToReg(swapInL.getValue(0), dl,
19884                                Regs64bit ? X86::RCX : X86::ECX,
19885                                swapInH, swapInL.getValue(1));
19886     SDValue Ops[] = { swapInH.getValue(0),
19887                       N->getOperand(1),
19888                       swapInH.getValue(1) };
19889     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
19890     MachineMemOperand *MMO = cast<AtomicSDNode>(N)->getMemOperand();
19891     unsigned Opcode = Regs64bit ? X86ISD::LCMPXCHG16_DAG :
19892                                   X86ISD::LCMPXCHG8_DAG;
19893     SDValue Result = DAG.getMemIntrinsicNode(Opcode, dl, Tys, Ops, T, MMO);
19894     SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), dl,
19895                                         Regs64bit ? X86::RAX : X86::EAX,
19896                                         HalfT, Result.getValue(1));
19897     SDValue cpOutH = DAG.getCopyFromReg(cpOutL.getValue(1), dl,
19898                                         Regs64bit ? X86::RDX : X86::EDX,
19899                                         HalfT, cpOutL.getValue(2));
19900     SDValue OpsF[] = { cpOutL.getValue(0), cpOutH.getValue(0)};
19901
19902     SDValue EFLAGS = DAG.getCopyFromReg(cpOutH.getValue(1), dl, X86::EFLAGS,
19903                                         MVT::i32, cpOutH.getValue(2));
19904     SDValue Success =
19905         DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
19906                     DAG.getConstant(X86::COND_E, MVT::i8), EFLAGS);
19907     Success = DAG.getZExtOrTrunc(Success, dl, N->getValueType(1));
19908
19909     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF));
19910     Results.push_back(Success);
19911     Results.push_back(EFLAGS.getValue(1));
19912     return;
19913   }
19914   case ISD::ATOMIC_SWAP:
19915   case ISD::ATOMIC_LOAD_ADD:
19916   case ISD::ATOMIC_LOAD_SUB:
19917   case ISD::ATOMIC_LOAD_AND:
19918   case ISD::ATOMIC_LOAD_OR:
19919   case ISD::ATOMIC_LOAD_XOR:
19920   case ISD::ATOMIC_LOAD_NAND:
19921   case ISD::ATOMIC_LOAD_MIN:
19922   case ISD::ATOMIC_LOAD_MAX:
19923   case ISD::ATOMIC_LOAD_UMIN:
19924   case ISD::ATOMIC_LOAD_UMAX:
19925   case ISD::ATOMIC_LOAD: {
19926     // Delegate to generic TypeLegalization. Situations we can really handle
19927     // should have already been dealt with by AtomicExpandPass.cpp.
19928     break;
19929   }
19930   case ISD::BITCAST: {
19931     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
19932     EVT DstVT = N->getValueType(0);
19933     EVT SrcVT = N->getOperand(0)->getValueType(0);
19934
19935     if (SrcVT != MVT::f64 ||
19936         (DstVT != MVT::v2i32 && DstVT != MVT::v4i16 && DstVT != MVT::v8i8))
19937       return;
19938
19939     unsigned NumElts = DstVT.getVectorNumElements();
19940     EVT SVT = DstVT.getVectorElementType();
19941     EVT WiderVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumElts * 2);
19942     SDValue Expanded = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
19943                                    MVT::v2f64, N->getOperand(0));
19944     SDValue ToVecInt = DAG.getNode(ISD::BITCAST, dl, WiderVT, Expanded);
19945
19946     if (ExperimentalVectorWideningLegalization) {
19947       // If we are legalizing vectors by widening, we already have the desired
19948       // legal vector type, just return it.
19949       Results.push_back(ToVecInt);
19950       return;
19951     }
19952
19953     SmallVector<SDValue, 8> Elts;
19954     for (unsigned i = 0, e = NumElts; i != e; ++i)
19955       Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT,
19956                                    ToVecInt, DAG.getIntPtrConstant(i)));
19957
19958     Results.push_back(DAG.getNode(ISD::BUILD_VECTOR, dl, DstVT, Elts));
19959   }
19960   }
19961 }
19962
19963 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
19964   switch (Opcode) {
19965   default: return nullptr;
19966   case X86ISD::BSF:                return "X86ISD::BSF";
19967   case X86ISD::BSR:                return "X86ISD::BSR";
19968   case X86ISD::SHLD:               return "X86ISD::SHLD";
19969   case X86ISD::SHRD:               return "X86ISD::SHRD";
19970   case X86ISD::FAND:               return "X86ISD::FAND";
19971   case X86ISD::FANDN:              return "X86ISD::FANDN";
19972   case X86ISD::FOR:                return "X86ISD::FOR";
19973   case X86ISD::FXOR:               return "X86ISD::FXOR";
19974   case X86ISD::FSRL:               return "X86ISD::FSRL";
19975   case X86ISD::FILD:               return "X86ISD::FILD";
19976   case X86ISD::FILD_FLAG:          return "X86ISD::FILD_FLAG";
19977   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
19978   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
19979   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
19980   case X86ISD::FLD:                return "X86ISD::FLD";
19981   case X86ISD::FST:                return "X86ISD::FST";
19982   case X86ISD::CALL:               return "X86ISD::CALL";
19983   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
19984   case X86ISD::RDTSCP_DAG:         return "X86ISD::RDTSCP_DAG";
19985   case X86ISD::RDPMC_DAG:          return "X86ISD::RDPMC_DAG";
19986   case X86ISD::BT:                 return "X86ISD::BT";
19987   case X86ISD::CMP:                return "X86ISD::CMP";
19988   case X86ISD::COMI:               return "X86ISD::COMI";
19989   case X86ISD::UCOMI:              return "X86ISD::UCOMI";
19990   case X86ISD::CMPM:               return "X86ISD::CMPM";
19991   case X86ISD::CMPMU:              return "X86ISD::CMPMU";
19992   case X86ISD::SETCC:              return "X86ISD::SETCC";
19993   case X86ISD::SETCC_CARRY:        return "X86ISD::SETCC_CARRY";
19994   case X86ISD::FSETCC:             return "X86ISD::FSETCC";
19995   case X86ISD::CMOV:               return "X86ISD::CMOV";
19996   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
19997   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
19998   case X86ISD::REP_STOS:           return "X86ISD::REP_STOS";
19999   case X86ISD::REP_MOVS:           return "X86ISD::REP_MOVS";
20000   case X86ISD::GlobalBaseReg:      return "X86ISD::GlobalBaseReg";
20001   case X86ISD::Wrapper:            return "X86ISD::Wrapper";
20002   case X86ISD::WrapperRIP:         return "X86ISD::WrapperRIP";
20003   case X86ISD::PEXTRB:             return "X86ISD::PEXTRB";
20004   case X86ISD::PEXTRW:             return "X86ISD::PEXTRW";
20005   case X86ISD::INSERTPS:           return "X86ISD::INSERTPS";
20006   case X86ISD::PINSRB:             return "X86ISD::PINSRB";
20007   case X86ISD::PINSRW:             return "X86ISD::PINSRW";
20008   case X86ISD::PSHUFB:             return "X86ISD::PSHUFB";
20009   case X86ISD::ANDNP:              return "X86ISD::ANDNP";
20010   case X86ISD::PSIGN:              return "X86ISD::PSIGN";
20011   case X86ISD::BLENDI:             return "X86ISD::BLENDI";
20012   case X86ISD::SHRUNKBLEND:        return "X86ISD::SHRUNKBLEND";
20013   case X86ISD::SUBUS:              return "X86ISD::SUBUS";
20014   case X86ISD::HADD:               return "X86ISD::HADD";
20015   case X86ISD::HSUB:               return "X86ISD::HSUB";
20016   case X86ISD::FHADD:              return "X86ISD::FHADD";
20017   case X86ISD::FHSUB:              return "X86ISD::FHSUB";
20018   case X86ISD::UMAX:               return "X86ISD::UMAX";
20019   case X86ISD::UMIN:               return "X86ISD::UMIN";
20020   case X86ISD::SMAX:               return "X86ISD::SMAX";
20021   case X86ISD::SMIN:               return "X86ISD::SMIN";
20022   case X86ISD::FMAX:               return "X86ISD::FMAX";
20023   case X86ISD::FMIN:               return "X86ISD::FMIN";
20024   case X86ISD::FMAXC:              return "X86ISD::FMAXC";
20025   case X86ISD::FMINC:              return "X86ISD::FMINC";
20026   case X86ISD::FRSQRT:             return "X86ISD::FRSQRT";
20027   case X86ISD::FRCP:               return "X86ISD::FRCP";
20028   case X86ISD::TLSADDR:            return "X86ISD::TLSADDR";
20029   case X86ISD::TLSBASEADDR:        return "X86ISD::TLSBASEADDR";
20030   case X86ISD::TLSCALL:            return "X86ISD::TLSCALL";
20031   case X86ISD::EH_SJLJ_SETJMP:     return "X86ISD::EH_SJLJ_SETJMP";
20032   case X86ISD::EH_SJLJ_LONGJMP:    return "X86ISD::EH_SJLJ_LONGJMP";
20033   case X86ISD::EH_RETURN:          return "X86ISD::EH_RETURN";
20034   case X86ISD::TC_RETURN:          return "X86ISD::TC_RETURN";
20035   case X86ISD::FNSTCW16m:          return "X86ISD::FNSTCW16m";
20036   case X86ISD::FNSTSW16r:          return "X86ISD::FNSTSW16r";
20037   case X86ISD::LCMPXCHG_DAG:       return "X86ISD::LCMPXCHG_DAG";
20038   case X86ISD::LCMPXCHG8_DAG:      return "X86ISD::LCMPXCHG8_DAG";
20039   case X86ISD::LCMPXCHG16_DAG:     return "X86ISD::LCMPXCHG16_DAG";
20040   case X86ISD::VZEXT_MOVL:         return "X86ISD::VZEXT_MOVL";
20041   case X86ISD::VZEXT_LOAD:         return "X86ISD::VZEXT_LOAD";
20042   case X86ISD::VZEXT:              return "X86ISD::VZEXT";
20043   case X86ISD::VSEXT:              return "X86ISD::VSEXT";
20044   case X86ISD::VTRUNC:             return "X86ISD::VTRUNC";
20045   case X86ISD::VTRUNCM:            return "X86ISD::VTRUNCM";
20046   case X86ISD::VINSERT:            return "X86ISD::VINSERT";
20047   case X86ISD::VFPEXT:             return "X86ISD::VFPEXT";
20048   case X86ISD::VFPROUND:           return "X86ISD::VFPROUND";
20049   case X86ISD::VSHLDQ:             return "X86ISD::VSHLDQ";
20050   case X86ISD::VSRLDQ:             return "X86ISD::VSRLDQ";
20051   case X86ISD::VSHL:               return "X86ISD::VSHL";
20052   case X86ISD::VSRL:               return "X86ISD::VSRL";
20053   case X86ISD::VSRA:               return "X86ISD::VSRA";
20054   case X86ISD::VSHLI:              return "X86ISD::VSHLI";
20055   case X86ISD::VSRLI:              return "X86ISD::VSRLI";
20056   case X86ISD::VSRAI:              return "X86ISD::VSRAI";
20057   case X86ISD::CMPP:               return "X86ISD::CMPP";
20058   case X86ISD::PCMPEQ:             return "X86ISD::PCMPEQ";
20059   case X86ISD::PCMPGT:             return "X86ISD::PCMPGT";
20060   case X86ISD::PCMPEQM:            return "X86ISD::PCMPEQM";
20061   case X86ISD::PCMPGTM:            return "X86ISD::PCMPGTM";
20062   case X86ISD::ADD:                return "X86ISD::ADD";
20063   case X86ISD::SUB:                return "X86ISD::SUB";
20064   case X86ISD::ADC:                return "X86ISD::ADC";
20065   case X86ISD::SBB:                return "X86ISD::SBB";
20066   case X86ISD::SMUL:               return "X86ISD::SMUL";
20067   case X86ISD::UMUL:               return "X86ISD::UMUL";
20068   case X86ISD::SMUL8:              return "X86ISD::SMUL8";
20069   case X86ISD::UMUL8:              return "X86ISD::UMUL8";
20070   case X86ISD::SDIVREM8_SEXT_HREG: return "X86ISD::SDIVREM8_SEXT_HREG";
20071   case X86ISD::UDIVREM8_ZEXT_HREG: return "X86ISD::UDIVREM8_ZEXT_HREG";
20072   case X86ISD::INC:                return "X86ISD::INC";
20073   case X86ISD::DEC:                return "X86ISD::DEC";
20074   case X86ISD::OR:                 return "X86ISD::OR";
20075   case X86ISD::XOR:                return "X86ISD::XOR";
20076   case X86ISD::AND:                return "X86ISD::AND";
20077   case X86ISD::BEXTR:              return "X86ISD::BEXTR";
20078   case X86ISD::MUL_IMM:            return "X86ISD::MUL_IMM";
20079   case X86ISD::PTEST:              return "X86ISD::PTEST";
20080   case X86ISD::TESTP:              return "X86ISD::TESTP";
20081   case X86ISD::TESTM:              return "X86ISD::TESTM";
20082   case X86ISD::TESTNM:             return "X86ISD::TESTNM";
20083   case X86ISD::KORTEST:            return "X86ISD::KORTEST";
20084   case X86ISD::PACKSS:             return "X86ISD::PACKSS";
20085   case X86ISD::PACKUS:             return "X86ISD::PACKUS";
20086   case X86ISD::PALIGNR:            return "X86ISD::PALIGNR";
20087   case X86ISD::VALIGN:             return "X86ISD::VALIGN";
20088   case X86ISD::PSHUFD:             return "X86ISD::PSHUFD";
20089   case X86ISD::PSHUFHW:            return "X86ISD::PSHUFHW";
20090   case X86ISD::PSHUFLW:            return "X86ISD::PSHUFLW";
20091   case X86ISD::SHUFP:              return "X86ISD::SHUFP";
20092   case X86ISD::MOVLHPS:            return "X86ISD::MOVLHPS";
20093   case X86ISD::MOVLHPD:            return "X86ISD::MOVLHPD";
20094   case X86ISD::MOVHLPS:            return "X86ISD::MOVHLPS";
20095   case X86ISD::MOVLPS:             return "X86ISD::MOVLPS";
20096   case X86ISD::MOVLPD:             return "X86ISD::MOVLPD";
20097   case X86ISD::MOVDDUP:            return "X86ISD::MOVDDUP";
20098   case X86ISD::MOVSHDUP:           return "X86ISD::MOVSHDUP";
20099   case X86ISD::MOVSLDUP:           return "X86ISD::MOVSLDUP";
20100   case X86ISD::MOVSD:              return "X86ISD::MOVSD";
20101   case X86ISD::MOVSS:              return "X86ISD::MOVSS";
20102   case X86ISD::UNPCKL:             return "X86ISD::UNPCKL";
20103   case X86ISD::UNPCKH:             return "X86ISD::UNPCKH";
20104   case X86ISD::VBROADCAST:         return "X86ISD::VBROADCAST";
20105   case X86ISD::VBROADCASTM:        return "X86ISD::VBROADCASTM";
20106   case X86ISD::VEXTRACT:           return "X86ISD::VEXTRACT";
20107   case X86ISD::VPERMILPI:          return "X86ISD::VPERMILPI";
20108   case X86ISD::VPERM2X128:         return "X86ISD::VPERM2X128";
20109   case X86ISD::VPERMV:             return "X86ISD::VPERMV";
20110   case X86ISD::VPERMV3:            return "X86ISD::VPERMV3";
20111   case X86ISD::VPERMIV3:           return "X86ISD::VPERMIV3";
20112   case X86ISD::VPERMI:             return "X86ISD::VPERMI";
20113   case X86ISD::PMULUDQ:            return "X86ISD::PMULUDQ";
20114   case X86ISD::PMULDQ:             return "X86ISD::PMULDQ";
20115   case X86ISD::VASTART_SAVE_XMM_REGS: return "X86ISD::VASTART_SAVE_XMM_REGS";
20116   case X86ISD::VAARG_64:           return "X86ISD::VAARG_64";
20117   case X86ISD::WIN_ALLOCA:         return "X86ISD::WIN_ALLOCA";
20118   case X86ISD::MEMBARRIER:         return "X86ISD::MEMBARRIER";
20119   case X86ISD::SEG_ALLOCA:         return "X86ISD::SEG_ALLOCA";
20120   case X86ISD::WIN_FTOL:           return "X86ISD::WIN_FTOL";
20121   case X86ISD::SAHF:               return "X86ISD::SAHF";
20122   case X86ISD::RDRAND:             return "X86ISD::RDRAND";
20123   case X86ISD::RDSEED:             return "X86ISD::RDSEED";
20124   case X86ISD::FMADD:              return "X86ISD::FMADD";
20125   case X86ISD::FMSUB:              return "X86ISD::FMSUB";
20126   case X86ISD::FNMADD:             return "X86ISD::FNMADD";
20127   case X86ISD::FNMSUB:             return "X86ISD::FNMSUB";
20128   case X86ISD::FMADDSUB:           return "X86ISD::FMADDSUB";
20129   case X86ISD::FMSUBADD:           return "X86ISD::FMSUBADD";
20130   case X86ISD::PCMPESTRI:          return "X86ISD::PCMPESTRI";
20131   case X86ISD::PCMPISTRI:          return "X86ISD::PCMPISTRI";
20132   case X86ISD::XTEST:              return "X86ISD::XTEST";
20133   case X86ISD::COMPRESS:           return "X86ISD::COMPRESS";
20134   case X86ISD::EXPAND:             return "X86ISD::EXPAND";
20135   case X86ISD::SELECT:             return "X86ISD::SELECT";
20136   }
20137 }
20138
20139 // isLegalAddressingMode - Return true if the addressing mode represented
20140 // by AM is legal for this target, for a load/store of the specified type.
20141 bool X86TargetLowering::isLegalAddressingMode(const AddrMode &AM,
20142                                               Type *Ty) const {
20143   // X86 supports extremely general addressing modes.
20144   CodeModel::Model M = getTargetMachine().getCodeModel();
20145   Reloc::Model R = getTargetMachine().getRelocationModel();
20146
20147   // X86 allows a sign-extended 32-bit immediate field as a displacement.
20148   if (!X86::isOffsetSuitableForCodeModel(AM.BaseOffs, M, AM.BaseGV != nullptr))
20149     return false;
20150
20151   if (AM.BaseGV) {
20152     unsigned GVFlags =
20153       Subtarget->ClassifyGlobalReference(AM.BaseGV, getTargetMachine());
20154
20155     // If a reference to this global requires an extra load, we can't fold it.
20156     if (isGlobalStubReference(GVFlags))
20157       return false;
20158
20159     // If BaseGV requires a register for the PIC base, we cannot also have a
20160     // BaseReg specified.
20161     if (AM.HasBaseReg && isGlobalRelativeToPICBase(GVFlags))
20162       return false;
20163
20164     // If lower 4G is not available, then we must use rip-relative addressing.
20165     if ((M != CodeModel::Small || R != Reloc::Static) &&
20166         Subtarget->is64Bit() && (AM.BaseOffs || AM.Scale > 1))
20167       return false;
20168   }
20169
20170   switch (AM.Scale) {
20171   case 0:
20172   case 1:
20173   case 2:
20174   case 4:
20175   case 8:
20176     // These scales always work.
20177     break;
20178   case 3:
20179   case 5:
20180   case 9:
20181     // These scales are formed with basereg+scalereg.  Only accept if there is
20182     // no basereg yet.
20183     if (AM.HasBaseReg)
20184       return false;
20185     break;
20186   default:  // Other stuff never works.
20187     return false;
20188   }
20189
20190   return true;
20191 }
20192
20193 bool X86TargetLowering::isVectorShiftByScalarCheap(Type *Ty) const {
20194   unsigned Bits = Ty->getScalarSizeInBits();
20195
20196   // 8-bit shifts are always expensive, but versions with a scalar amount aren't
20197   // particularly cheaper than those without.
20198   if (Bits == 8)
20199     return false;
20200
20201   // On AVX2 there are new vpsllv[dq] instructions (and other shifts), that make
20202   // variable shifts just as cheap as scalar ones.
20203   if (Subtarget->hasInt256() && (Bits == 32 || Bits == 64))
20204     return false;
20205
20206   // Otherwise, it's significantly cheaper to shift by a scalar amount than by a
20207   // fully general vector.
20208   return true;
20209 }
20210
20211 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
20212   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
20213     return false;
20214   unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
20215   unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
20216   return NumBits1 > NumBits2;
20217 }
20218
20219 bool X86TargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
20220   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
20221     return false;
20222
20223   if (!isTypeLegal(EVT::getEVT(Ty1)))
20224     return false;
20225
20226   assert(Ty1->getPrimitiveSizeInBits() <= 64 && "i128 is probably not a noop");
20227
20228   // Assuming the caller doesn't have a zeroext or signext return parameter,
20229   // truncation all the way down to i1 is valid.
20230   return true;
20231 }
20232
20233 bool X86TargetLowering::isLegalICmpImmediate(int64_t Imm) const {
20234   return isInt<32>(Imm);
20235 }
20236
20237 bool X86TargetLowering::isLegalAddImmediate(int64_t Imm) const {
20238   // Can also use sub to handle negated immediates.
20239   return isInt<32>(Imm);
20240 }
20241
20242 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
20243   if (!VT1.isInteger() || !VT2.isInteger())
20244     return false;
20245   unsigned NumBits1 = VT1.getSizeInBits();
20246   unsigned NumBits2 = VT2.getSizeInBits();
20247   return NumBits1 > NumBits2;
20248 }
20249
20250 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
20251   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
20252   return Ty1->isIntegerTy(32) && Ty2->isIntegerTy(64) && Subtarget->is64Bit();
20253 }
20254
20255 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
20256   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
20257   return VT1 == MVT::i32 && VT2 == MVT::i64 && Subtarget->is64Bit();
20258 }
20259
20260 bool X86TargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
20261   EVT VT1 = Val.getValueType();
20262   if (isZExtFree(VT1, VT2))
20263     return true;
20264
20265   if (Val.getOpcode() != ISD::LOAD)
20266     return false;
20267
20268   if (!VT1.isSimple() || !VT1.isInteger() ||
20269       !VT2.isSimple() || !VT2.isInteger())
20270     return false;
20271
20272   switch (VT1.getSimpleVT().SimpleTy) {
20273   default: break;
20274   case MVT::i8:
20275   case MVT::i16:
20276   case MVT::i32:
20277     // X86 has 8, 16, and 32-bit zero-extending loads.
20278     return true;
20279   }
20280
20281   return false;
20282 }
20283
20284 bool
20285 X86TargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
20286   if (!(Subtarget->hasFMA() || Subtarget->hasFMA4()))
20287     return false;
20288
20289   VT = VT.getScalarType();
20290
20291   if (!VT.isSimple())
20292     return false;
20293
20294   switch (VT.getSimpleVT().SimpleTy) {
20295   case MVT::f32:
20296   case MVT::f64:
20297     return true;
20298   default:
20299     break;
20300   }
20301
20302   return false;
20303 }
20304
20305 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
20306   // i16 instructions are longer (0x66 prefix) and potentially slower.
20307   return !(VT1 == MVT::i32 && VT2 == MVT::i16);
20308 }
20309
20310 /// isShuffleMaskLegal - Targets can use this to indicate that they only
20311 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
20312 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
20313 /// are assumed to be legal.
20314 bool
20315 X86TargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
20316                                       EVT VT) const {
20317   if (!VT.isSimple())
20318     return false;
20319
20320   MVT SVT = VT.getSimpleVT();
20321
20322   // Very little shuffling can be done for 64-bit vectors right now.
20323   if (VT.getSizeInBits() == 64)
20324     return false;
20325
20326   // This is an experimental legality test that is tailored to match the
20327   // legality test of the experimental lowering more closely. They are gated
20328   // separately to ease testing of performance differences.
20329   if (ExperimentalVectorShuffleLegality)
20330     // We only care that the types being shuffled are legal. The lowering can
20331     // handle any possible shuffle mask that results.
20332     return isTypeLegal(SVT);
20333
20334   // If this is a single-input shuffle with no 128 bit lane crossings we can
20335   // lower it into pshufb.
20336   if ((SVT.is128BitVector() && Subtarget->hasSSSE3()) ||
20337       (SVT.is256BitVector() && Subtarget->hasInt256())) {
20338     bool isLegal = true;
20339     for (unsigned I = 0, E = M.size(); I != E; ++I) {
20340       if (M[I] >= (int)SVT.getVectorNumElements() ||
20341           ShuffleCrosses128bitLane(SVT, I, M[I])) {
20342         isLegal = false;
20343         break;
20344       }
20345     }
20346     if (isLegal)
20347       return true;
20348   }
20349
20350   // FIXME: blends, shifts.
20351   return (SVT.getVectorNumElements() == 2 ||
20352           ShuffleVectorSDNode::isSplatMask(&M[0], VT) ||
20353           isMOVLMask(M, SVT) ||
20354           isCommutedMOVLMask(M, SVT) ||
20355           isMOVHLPSMask(M, SVT) ||
20356           isSHUFPMask(M, SVT) ||
20357           isSHUFPMask(M, SVT, /* Commuted */ true) ||
20358           isPSHUFDMask(M, SVT) ||
20359           isPSHUFDMask(M, SVT, /* SecondOperand */ true) ||
20360           isPSHUFHWMask(M, SVT, Subtarget->hasInt256()) ||
20361           isPSHUFLWMask(M, SVT, Subtarget->hasInt256()) ||
20362           isPALIGNRMask(M, SVT, Subtarget) ||
20363           isUNPCKLMask(M, SVT, Subtarget->hasInt256()) ||
20364           isUNPCKHMask(M, SVT, Subtarget->hasInt256()) ||
20365           isUNPCKL_v_undef_Mask(M, SVT, Subtarget->hasInt256()) ||
20366           isUNPCKH_v_undef_Mask(M, SVT, Subtarget->hasInt256()) ||
20367           isBlendMask(M, SVT, Subtarget->hasSSE41(), Subtarget->hasInt256()) ||
20368           (Subtarget->hasSSE41() && isINSERTPSMask(M, SVT)));
20369 }
20370
20371 bool
20372 X86TargetLowering::isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
20373                                           EVT VT) const {
20374   if (!VT.isSimple())
20375     return false;
20376
20377   MVT SVT = VT.getSimpleVT();
20378
20379   // This is an experimental legality test that is tailored to match the
20380   // legality test of the experimental lowering more closely. They are gated
20381   // separately to ease testing of performance differences.
20382   if (ExperimentalVectorShuffleLegality)
20383     // The new vector shuffle lowering is very good at managing zero-inputs.
20384     return isShuffleMaskLegal(Mask, VT);
20385
20386   unsigned NumElts = SVT.getVectorNumElements();
20387   // FIXME: This collection of masks seems suspect.
20388   if (NumElts == 2)
20389     return true;
20390   if (NumElts == 4 && SVT.is128BitVector()) {
20391     return (isMOVLMask(Mask, SVT)  ||
20392             isCommutedMOVLMask(Mask, SVT, true) ||
20393             isSHUFPMask(Mask, SVT) ||
20394             isSHUFPMask(Mask, SVT, /* Commuted */ true) ||
20395             isBlendMask(Mask, SVT, Subtarget->hasSSE41(),
20396                         Subtarget->hasInt256()));
20397   }
20398   return false;
20399 }
20400
20401 //===----------------------------------------------------------------------===//
20402 //                           X86 Scheduler Hooks
20403 //===----------------------------------------------------------------------===//
20404
20405 /// Utility function to emit xbegin specifying the start of an RTM region.
20406 static MachineBasicBlock *EmitXBegin(MachineInstr *MI, MachineBasicBlock *MBB,
20407                                      const TargetInstrInfo *TII) {
20408   DebugLoc DL = MI->getDebugLoc();
20409
20410   const BasicBlock *BB = MBB->getBasicBlock();
20411   MachineFunction::iterator I = MBB;
20412   ++I;
20413
20414   // For the v = xbegin(), we generate
20415   //
20416   // thisMBB:
20417   //  xbegin sinkMBB
20418   //
20419   // mainMBB:
20420   //  eax = -1
20421   //
20422   // sinkMBB:
20423   //  v = eax
20424
20425   MachineBasicBlock *thisMBB = MBB;
20426   MachineFunction *MF = MBB->getParent();
20427   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
20428   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
20429   MF->insert(I, mainMBB);
20430   MF->insert(I, sinkMBB);
20431
20432   // Transfer the remainder of BB and its successor edges to sinkMBB.
20433   sinkMBB->splice(sinkMBB->begin(), MBB,
20434                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
20435   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
20436
20437   // thisMBB:
20438   //  xbegin sinkMBB
20439   //  # fallthrough to mainMBB
20440   //  # abortion to sinkMBB
20441   BuildMI(thisMBB, DL, TII->get(X86::XBEGIN_4)).addMBB(sinkMBB);
20442   thisMBB->addSuccessor(mainMBB);
20443   thisMBB->addSuccessor(sinkMBB);
20444
20445   // mainMBB:
20446   //  EAX = -1
20447   BuildMI(mainMBB, DL, TII->get(X86::MOV32ri), X86::EAX).addImm(-1);
20448   mainMBB->addSuccessor(sinkMBB);
20449
20450   // sinkMBB:
20451   // EAX is live into the sinkMBB
20452   sinkMBB->addLiveIn(X86::EAX);
20453   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
20454           TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20455     .addReg(X86::EAX);
20456
20457   MI->eraseFromParent();
20458   return sinkMBB;
20459 }
20460
20461 // FIXME: When we get size specific XMM0 registers, i.e. XMM0_V16I8
20462 // or XMM0_V32I8 in AVX all of this code can be replaced with that
20463 // in the .td file.
20464 static MachineBasicBlock *EmitPCMPSTRM(MachineInstr *MI, MachineBasicBlock *BB,
20465                                        const TargetInstrInfo *TII) {
20466   unsigned Opc;
20467   switch (MI->getOpcode()) {
20468   default: llvm_unreachable("illegal opcode!");
20469   case X86::PCMPISTRM128REG:  Opc = X86::PCMPISTRM128rr;  break;
20470   case X86::VPCMPISTRM128REG: Opc = X86::VPCMPISTRM128rr; break;
20471   case X86::PCMPISTRM128MEM:  Opc = X86::PCMPISTRM128rm;  break;
20472   case X86::VPCMPISTRM128MEM: Opc = X86::VPCMPISTRM128rm; break;
20473   case X86::PCMPESTRM128REG:  Opc = X86::PCMPESTRM128rr;  break;
20474   case X86::VPCMPESTRM128REG: Opc = X86::VPCMPESTRM128rr; break;
20475   case X86::PCMPESTRM128MEM:  Opc = X86::PCMPESTRM128rm;  break;
20476   case X86::VPCMPESTRM128MEM: Opc = X86::VPCMPESTRM128rm; break;
20477   }
20478
20479   DebugLoc dl = MI->getDebugLoc();
20480   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
20481
20482   unsigned NumArgs = MI->getNumOperands();
20483   for (unsigned i = 1; i < NumArgs; ++i) {
20484     MachineOperand &Op = MI->getOperand(i);
20485     if (!(Op.isReg() && Op.isImplicit()))
20486       MIB.addOperand(Op);
20487   }
20488   if (MI->hasOneMemOperand())
20489     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
20490
20491   BuildMI(*BB, MI, dl,
20492     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20493     .addReg(X86::XMM0);
20494
20495   MI->eraseFromParent();
20496   return BB;
20497 }
20498
20499 // FIXME: Custom handling because TableGen doesn't support multiple implicit
20500 // defs in an instruction pattern
20501 static MachineBasicBlock *EmitPCMPSTRI(MachineInstr *MI, MachineBasicBlock *BB,
20502                                        const TargetInstrInfo *TII) {
20503   unsigned Opc;
20504   switch (MI->getOpcode()) {
20505   default: llvm_unreachable("illegal opcode!");
20506   case X86::PCMPISTRIREG:  Opc = X86::PCMPISTRIrr;  break;
20507   case X86::VPCMPISTRIREG: Opc = X86::VPCMPISTRIrr; break;
20508   case X86::PCMPISTRIMEM:  Opc = X86::PCMPISTRIrm;  break;
20509   case X86::VPCMPISTRIMEM: Opc = X86::VPCMPISTRIrm; break;
20510   case X86::PCMPESTRIREG:  Opc = X86::PCMPESTRIrr;  break;
20511   case X86::VPCMPESTRIREG: Opc = X86::VPCMPESTRIrr; break;
20512   case X86::PCMPESTRIMEM:  Opc = X86::PCMPESTRIrm;  break;
20513   case X86::VPCMPESTRIMEM: Opc = X86::VPCMPESTRIrm; break;
20514   }
20515
20516   DebugLoc dl = MI->getDebugLoc();
20517   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
20518
20519   unsigned NumArgs = MI->getNumOperands(); // remove the results
20520   for (unsigned i = 1; i < NumArgs; ++i) {
20521     MachineOperand &Op = MI->getOperand(i);
20522     if (!(Op.isReg() && Op.isImplicit()))
20523       MIB.addOperand(Op);
20524   }
20525   if (MI->hasOneMemOperand())
20526     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
20527
20528   BuildMI(*BB, MI, dl,
20529     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
20530     .addReg(X86::ECX);
20531
20532   MI->eraseFromParent();
20533   return BB;
20534 }
20535
20536 static MachineBasicBlock * EmitMonitor(MachineInstr *MI, MachineBasicBlock *BB,
20537                                        const TargetInstrInfo *TII,
20538                                        const X86Subtarget* Subtarget) {
20539   DebugLoc dl = MI->getDebugLoc();
20540
20541   // Address into RAX/EAX, other two args into ECX, EDX.
20542   unsigned MemOpc = Subtarget->is64Bit() ? X86::LEA64r : X86::LEA32r;
20543   unsigned MemReg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
20544   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(MemOpc), MemReg);
20545   for (int i = 0; i < X86::AddrNumOperands; ++i)
20546     MIB.addOperand(MI->getOperand(i));
20547
20548   unsigned ValOps = X86::AddrNumOperands;
20549   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::ECX)
20550     .addReg(MI->getOperand(ValOps).getReg());
20551   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::EDX)
20552     .addReg(MI->getOperand(ValOps+1).getReg());
20553
20554   // The instruction doesn't actually take any operands though.
20555   BuildMI(*BB, MI, dl, TII->get(X86::MONITORrrr));
20556
20557   MI->eraseFromParent(); // The pseudo is gone now.
20558   return BB;
20559 }
20560
20561 MachineBasicBlock *
20562 X86TargetLowering::EmitVAARG64WithCustomInserter(
20563                    MachineInstr *MI,
20564                    MachineBasicBlock *MBB) const {
20565   // Emit va_arg instruction on X86-64.
20566
20567   // Operands to this pseudo-instruction:
20568   // 0  ) Output        : destination address (reg)
20569   // 1-5) Input         : va_list address (addr, i64mem)
20570   // 6  ) ArgSize       : Size (in bytes) of vararg type
20571   // 7  ) ArgMode       : 0=overflow only, 1=use gp_offset, 2=use fp_offset
20572   // 8  ) Align         : Alignment of type
20573   // 9  ) EFLAGS (implicit-def)
20574
20575   assert(MI->getNumOperands() == 10 && "VAARG_64 should have 10 operands!");
20576   assert(X86::AddrNumOperands == 5 && "VAARG_64 assumes 5 address operands");
20577
20578   unsigned DestReg = MI->getOperand(0).getReg();
20579   MachineOperand &Base = MI->getOperand(1);
20580   MachineOperand &Scale = MI->getOperand(2);
20581   MachineOperand &Index = MI->getOperand(3);
20582   MachineOperand &Disp = MI->getOperand(4);
20583   MachineOperand &Segment = MI->getOperand(5);
20584   unsigned ArgSize = MI->getOperand(6).getImm();
20585   unsigned ArgMode = MI->getOperand(7).getImm();
20586   unsigned Align = MI->getOperand(8).getImm();
20587
20588   // Memory Reference
20589   assert(MI->hasOneMemOperand() && "Expected VAARG_64 to have one memoperand");
20590   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
20591   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
20592
20593   // Machine Information
20594   const TargetInstrInfo *TII = MBB->getParent()->getSubtarget().getInstrInfo();
20595   MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
20596   const TargetRegisterClass *AddrRegClass = getRegClassFor(MVT::i64);
20597   const TargetRegisterClass *OffsetRegClass = getRegClassFor(MVT::i32);
20598   DebugLoc DL = MI->getDebugLoc();
20599
20600   // struct va_list {
20601   //   i32   gp_offset
20602   //   i32   fp_offset
20603   //   i64   overflow_area (address)
20604   //   i64   reg_save_area (address)
20605   // }
20606   // sizeof(va_list) = 24
20607   // alignment(va_list) = 8
20608
20609   unsigned TotalNumIntRegs = 6;
20610   unsigned TotalNumXMMRegs = 8;
20611   bool UseGPOffset = (ArgMode == 1);
20612   bool UseFPOffset = (ArgMode == 2);
20613   unsigned MaxOffset = TotalNumIntRegs * 8 +
20614                        (UseFPOffset ? TotalNumXMMRegs * 16 : 0);
20615
20616   /* Align ArgSize to a multiple of 8 */
20617   unsigned ArgSizeA8 = (ArgSize + 7) & ~7;
20618   bool NeedsAlign = (Align > 8);
20619
20620   MachineBasicBlock *thisMBB = MBB;
20621   MachineBasicBlock *overflowMBB;
20622   MachineBasicBlock *offsetMBB;
20623   MachineBasicBlock *endMBB;
20624
20625   unsigned OffsetDestReg = 0;    // Argument address computed by offsetMBB
20626   unsigned OverflowDestReg = 0;  // Argument address computed by overflowMBB
20627   unsigned OffsetReg = 0;
20628
20629   if (!UseGPOffset && !UseFPOffset) {
20630     // If we only pull from the overflow region, we don't create a branch.
20631     // We don't need to alter control flow.
20632     OffsetDestReg = 0; // unused
20633     OverflowDestReg = DestReg;
20634
20635     offsetMBB = nullptr;
20636     overflowMBB = thisMBB;
20637     endMBB = thisMBB;
20638   } else {
20639     // First emit code to check if gp_offset (or fp_offset) is below the bound.
20640     // If so, pull the argument from reg_save_area. (branch to offsetMBB)
20641     // If not, pull from overflow_area. (branch to overflowMBB)
20642     //
20643     //       thisMBB
20644     //         |     .
20645     //         |        .
20646     //     offsetMBB   overflowMBB
20647     //         |        .
20648     //         |     .
20649     //        endMBB
20650
20651     // Registers for the PHI in endMBB
20652     OffsetDestReg = MRI.createVirtualRegister(AddrRegClass);
20653     OverflowDestReg = MRI.createVirtualRegister(AddrRegClass);
20654
20655     const BasicBlock *LLVM_BB = MBB->getBasicBlock();
20656     MachineFunction *MF = MBB->getParent();
20657     overflowMBB = MF->CreateMachineBasicBlock(LLVM_BB);
20658     offsetMBB = MF->CreateMachineBasicBlock(LLVM_BB);
20659     endMBB = MF->CreateMachineBasicBlock(LLVM_BB);
20660
20661     MachineFunction::iterator MBBIter = MBB;
20662     ++MBBIter;
20663
20664     // Insert the new basic blocks
20665     MF->insert(MBBIter, offsetMBB);
20666     MF->insert(MBBIter, overflowMBB);
20667     MF->insert(MBBIter, endMBB);
20668
20669     // Transfer the remainder of MBB and its successor edges to endMBB.
20670     endMBB->splice(endMBB->begin(), thisMBB,
20671                    std::next(MachineBasicBlock::iterator(MI)), thisMBB->end());
20672     endMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
20673
20674     // Make offsetMBB and overflowMBB successors of thisMBB
20675     thisMBB->addSuccessor(offsetMBB);
20676     thisMBB->addSuccessor(overflowMBB);
20677
20678     // endMBB is a successor of both offsetMBB and overflowMBB
20679     offsetMBB->addSuccessor(endMBB);
20680     overflowMBB->addSuccessor(endMBB);
20681
20682     // Load the offset value into a register
20683     OffsetReg = MRI.createVirtualRegister(OffsetRegClass);
20684     BuildMI(thisMBB, DL, TII->get(X86::MOV32rm), OffsetReg)
20685       .addOperand(Base)
20686       .addOperand(Scale)
20687       .addOperand(Index)
20688       .addDisp(Disp, UseFPOffset ? 4 : 0)
20689       .addOperand(Segment)
20690       .setMemRefs(MMOBegin, MMOEnd);
20691
20692     // Check if there is enough room left to pull this argument.
20693     BuildMI(thisMBB, DL, TII->get(X86::CMP32ri))
20694       .addReg(OffsetReg)
20695       .addImm(MaxOffset + 8 - ArgSizeA8);
20696
20697     // Branch to "overflowMBB" if offset >= max
20698     // Fall through to "offsetMBB" otherwise
20699     BuildMI(thisMBB, DL, TII->get(X86::GetCondBranchFromCond(X86::COND_AE)))
20700       .addMBB(overflowMBB);
20701   }
20702
20703   // In offsetMBB, emit code to use the reg_save_area.
20704   if (offsetMBB) {
20705     assert(OffsetReg != 0);
20706
20707     // Read the reg_save_area address.
20708     unsigned RegSaveReg = MRI.createVirtualRegister(AddrRegClass);
20709     BuildMI(offsetMBB, DL, TII->get(X86::MOV64rm), RegSaveReg)
20710       .addOperand(Base)
20711       .addOperand(Scale)
20712       .addOperand(Index)
20713       .addDisp(Disp, 16)
20714       .addOperand(Segment)
20715       .setMemRefs(MMOBegin, MMOEnd);
20716
20717     // Zero-extend the offset
20718     unsigned OffsetReg64 = MRI.createVirtualRegister(AddrRegClass);
20719       BuildMI(offsetMBB, DL, TII->get(X86::SUBREG_TO_REG), OffsetReg64)
20720         .addImm(0)
20721         .addReg(OffsetReg)
20722         .addImm(X86::sub_32bit);
20723
20724     // Add the offset to the reg_save_area to get the final address.
20725     BuildMI(offsetMBB, DL, TII->get(X86::ADD64rr), OffsetDestReg)
20726       .addReg(OffsetReg64)
20727       .addReg(RegSaveReg);
20728
20729     // Compute the offset for the next argument
20730     unsigned NextOffsetReg = MRI.createVirtualRegister(OffsetRegClass);
20731     BuildMI(offsetMBB, DL, TII->get(X86::ADD32ri), NextOffsetReg)
20732       .addReg(OffsetReg)
20733       .addImm(UseFPOffset ? 16 : 8);
20734
20735     // Store it back into the va_list.
20736     BuildMI(offsetMBB, DL, TII->get(X86::MOV32mr))
20737       .addOperand(Base)
20738       .addOperand(Scale)
20739       .addOperand(Index)
20740       .addDisp(Disp, UseFPOffset ? 4 : 0)
20741       .addOperand(Segment)
20742       .addReg(NextOffsetReg)
20743       .setMemRefs(MMOBegin, MMOEnd);
20744
20745     // Jump to endMBB
20746     BuildMI(offsetMBB, DL, TII->get(X86::JMP_1))
20747       .addMBB(endMBB);
20748   }
20749
20750   //
20751   // Emit code to use overflow area
20752   //
20753
20754   // Load the overflow_area address into a register.
20755   unsigned OverflowAddrReg = MRI.createVirtualRegister(AddrRegClass);
20756   BuildMI(overflowMBB, DL, TII->get(X86::MOV64rm), OverflowAddrReg)
20757     .addOperand(Base)
20758     .addOperand(Scale)
20759     .addOperand(Index)
20760     .addDisp(Disp, 8)
20761     .addOperand(Segment)
20762     .setMemRefs(MMOBegin, MMOEnd);
20763
20764   // If we need to align it, do so. Otherwise, just copy the address
20765   // to OverflowDestReg.
20766   if (NeedsAlign) {
20767     // Align the overflow address
20768     assert((Align & (Align-1)) == 0 && "Alignment must be a power of 2");
20769     unsigned TmpReg = MRI.createVirtualRegister(AddrRegClass);
20770
20771     // aligned_addr = (addr + (align-1)) & ~(align-1)
20772     BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), TmpReg)
20773       .addReg(OverflowAddrReg)
20774       .addImm(Align-1);
20775
20776     BuildMI(overflowMBB, DL, TII->get(X86::AND64ri32), OverflowDestReg)
20777       .addReg(TmpReg)
20778       .addImm(~(uint64_t)(Align-1));
20779   } else {
20780     BuildMI(overflowMBB, DL, TII->get(TargetOpcode::COPY), OverflowDestReg)
20781       .addReg(OverflowAddrReg);
20782   }
20783
20784   // Compute the next overflow address after this argument.
20785   // (the overflow address should be kept 8-byte aligned)
20786   unsigned NextAddrReg = MRI.createVirtualRegister(AddrRegClass);
20787   BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), NextAddrReg)
20788     .addReg(OverflowDestReg)
20789     .addImm(ArgSizeA8);
20790
20791   // Store the new overflow address.
20792   BuildMI(overflowMBB, DL, TII->get(X86::MOV64mr))
20793     .addOperand(Base)
20794     .addOperand(Scale)
20795     .addOperand(Index)
20796     .addDisp(Disp, 8)
20797     .addOperand(Segment)
20798     .addReg(NextAddrReg)
20799     .setMemRefs(MMOBegin, MMOEnd);
20800
20801   // If we branched, emit the PHI to the front of endMBB.
20802   if (offsetMBB) {
20803     BuildMI(*endMBB, endMBB->begin(), DL,
20804             TII->get(X86::PHI), DestReg)
20805       .addReg(OffsetDestReg).addMBB(offsetMBB)
20806       .addReg(OverflowDestReg).addMBB(overflowMBB);
20807   }
20808
20809   // Erase the pseudo instruction
20810   MI->eraseFromParent();
20811
20812   return endMBB;
20813 }
20814
20815 MachineBasicBlock *
20816 X86TargetLowering::EmitVAStartSaveXMMRegsWithCustomInserter(
20817                                                  MachineInstr *MI,
20818                                                  MachineBasicBlock *MBB) const {
20819   // Emit code to save XMM registers to the stack. The ABI says that the
20820   // number of registers to save is given in %al, so it's theoretically
20821   // possible to do an indirect jump trick to avoid saving all of them,
20822   // however this code takes a simpler approach and just executes all
20823   // of the stores if %al is non-zero. It's less code, and it's probably
20824   // easier on the hardware branch predictor, and stores aren't all that
20825   // expensive anyway.
20826
20827   // Create the new basic blocks. One block contains all the XMM stores,
20828   // and one block is the final destination regardless of whether any
20829   // stores were performed.
20830   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
20831   MachineFunction *F = MBB->getParent();
20832   MachineFunction::iterator MBBIter = MBB;
20833   ++MBBIter;
20834   MachineBasicBlock *XMMSaveMBB = F->CreateMachineBasicBlock(LLVM_BB);
20835   MachineBasicBlock *EndMBB = F->CreateMachineBasicBlock(LLVM_BB);
20836   F->insert(MBBIter, XMMSaveMBB);
20837   F->insert(MBBIter, EndMBB);
20838
20839   // Transfer the remainder of MBB and its successor edges to EndMBB.
20840   EndMBB->splice(EndMBB->begin(), MBB,
20841                  std::next(MachineBasicBlock::iterator(MI)), MBB->end());
20842   EndMBB->transferSuccessorsAndUpdatePHIs(MBB);
20843
20844   // The original block will now fall through to the XMM save block.
20845   MBB->addSuccessor(XMMSaveMBB);
20846   // The XMMSaveMBB will fall through to the end block.
20847   XMMSaveMBB->addSuccessor(EndMBB);
20848
20849   // Now add the instructions.
20850   const TargetInstrInfo *TII = MBB->getParent()->getSubtarget().getInstrInfo();
20851   DebugLoc DL = MI->getDebugLoc();
20852
20853   unsigned CountReg = MI->getOperand(0).getReg();
20854   int64_t RegSaveFrameIndex = MI->getOperand(1).getImm();
20855   int64_t VarArgsFPOffset = MI->getOperand(2).getImm();
20856
20857   if (!Subtarget->isTargetWin64()) {
20858     // If %al is 0, branch around the XMM save block.
20859     BuildMI(MBB, DL, TII->get(X86::TEST8rr)).addReg(CountReg).addReg(CountReg);
20860     BuildMI(MBB, DL, TII->get(X86::JE_1)).addMBB(EndMBB);
20861     MBB->addSuccessor(EndMBB);
20862   }
20863
20864   // Make sure the last operand is EFLAGS, which gets clobbered by the branch
20865   // that was just emitted, but clearly shouldn't be "saved".
20866   assert((MI->getNumOperands() <= 3 ||
20867           !MI->getOperand(MI->getNumOperands() - 1).isReg() ||
20868           MI->getOperand(MI->getNumOperands() - 1).getReg() == X86::EFLAGS)
20869          && "Expected last argument to be EFLAGS");
20870   unsigned MOVOpc = Subtarget->hasFp256() ? X86::VMOVAPSmr : X86::MOVAPSmr;
20871   // In the XMM save block, save all the XMM argument registers.
20872   for (int i = 3, e = MI->getNumOperands() - 1; i != e; ++i) {
20873     int64_t Offset = (i - 3) * 16 + VarArgsFPOffset;
20874     MachineMemOperand *MMO =
20875       F->getMachineMemOperand(
20876           MachinePointerInfo::getFixedStack(RegSaveFrameIndex, Offset),
20877         MachineMemOperand::MOStore,
20878         /*Size=*/16, /*Align=*/16);
20879     BuildMI(XMMSaveMBB, DL, TII->get(MOVOpc))
20880       .addFrameIndex(RegSaveFrameIndex)
20881       .addImm(/*Scale=*/1)
20882       .addReg(/*IndexReg=*/0)
20883       .addImm(/*Disp=*/Offset)
20884       .addReg(/*Segment=*/0)
20885       .addReg(MI->getOperand(i).getReg())
20886       .addMemOperand(MMO);
20887   }
20888
20889   MI->eraseFromParent();   // The pseudo instruction is gone now.
20890
20891   return EndMBB;
20892 }
20893
20894 // The EFLAGS operand of SelectItr might be missing a kill marker
20895 // because there were multiple uses of EFLAGS, and ISel didn't know
20896 // which to mark. Figure out whether SelectItr should have had a
20897 // kill marker, and set it if it should. Returns the correct kill
20898 // marker value.
20899 static bool checkAndUpdateEFLAGSKill(MachineBasicBlock::iterator SelectItr,
20900                                      MachineBasicBlock* BB,
20901                                      const TargetRegisterInfo* TRI) {
20902   // Scan forward through BB for a use/def of EFLAGS.
20903   MachineBasicBlock::iterator miI(std::next(SelectItr));
20904   for (MachineBasicBlock::iterator miE = BB->end(); miI != miE; ++miI) {
20905     const MachineInstr& mi = *miI;
20906     if (mi.readsRegister(X86::EFLAGS))
20907       return false;
20908     if (mi.definesRegister(X86::EFLAGS))
20909       break; // Should have kill-flag - update below.
20910   }
20911
20912   // If we hit the end of the block, check whether EFLAGS is live into a
20913   // successor.
20914   if (miI == BB->end()) {
20915     for (MachineBasicBlock::succ_iterator sItr = BB->succ_begin(),
20916                                           sEnd = BB->succ_end();
20917          sItr != sEnd; ++sItr) {
20918       MachineBasicBlock* succ = *sItr;
20919       if (succ->isLiveIn(X86::EFLAGS))
20920         return false;
20921     }
20922   }
20923
20924   // We found a def, or hit the end of the basic block and EFLAGS wasn't live
20925   // out. SelectMI should have a kill flag on EFLAGS.
20926   SelectItr->addRegisterKilled(X86::EFLAGS, TRI);
20927   return true;
20928 }
20929
20930 MachineBasicBlock *
20931 X86TargetLowering::EmitLoweredSelect(MachineInstr *MI,
20932                                      MachineBasicBlock *BB) const {
20933   const TargetInstrInfo *TII = BB->getParent()->getSubtarget().getInstrInfo();
20934   DebugLoc DL = MI->getDebugLoc();
20935
20936   // To "insert" a SELECT_CC instruction, we actually have to insert the
20937   // diamond control-flow pattern.  The incoming instruction knows the
20938   // destination vreg to set, the condition code register to branch on, the
20939   // true/false values to select between, and a branch opcode to use.
20940   const BasicBlock *LLVM_BB = BB->getBasicBlock();
20941   MachineFunction::iterator It = BB;
20942   ++It;
20943
20944   //  thisMBB:
20945   //  ...
20946   //   TrueVal = ...
20947   //   cmpTY ccX, r1, r2
20948   //   bCC copy1MBB
20949   //   fallthrough --> copy0MBB
20950   MachineBasicBlock *thisMBB = BB;
20951   MachineFunction *F = BB->getParent();
20952   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
20953   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
20954   F->insert(It, copy0MBB);
20955   F->insert(It, sinkMBB);
20956
20957   // If the EFLAGS register isn't dead in the terminator, then claim that it's
20958   // live into the sink and copy blocks.
20959   const TargetRegisterInfo *TRI =
20960       BB->getParent()->getSubtarget().getRegisterInfo();
20961   if (!MI->killsRegister(X86::EFLAGS) &&
20962       !checkAndUpdateEFLAGSKill(MI, BB, TRI)) {
20963     copy0MBB->addLiveIn(X86::EFLAGS);
20964     sinkMBB->addLiveIn(X86::EFLAGS);
20965   }
20966
20967   // Transfer the remainder of BB and its successor edges to sinkMBB.
20968   sinkMBB->splice(sinkMBB->begin(), BB,
20969                   std::next(MachineBasicBlock::iterator(MI)), BB->end());
20970   sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
20971
20972   // Add the true and fallthrough blocks as its successors.
20973   BB->addSuccessor(copy0MBB);
20974   BB->addSuccessor(sinkMBB);
20975
20976   // Create the conditional branch instruction.
20977   unsigned Opc =
20978     X86::GetCondBranchFromCond((X86::CondCode)MI->getOperand(3).getImm());
20979   BuildMI(BB, DL, TII->get(Opc)).addMBB(sinkMBB);
20980
20981   //  copy0MBB:
20982   //   %FalseValue = ...
20983   //   # fallthrough to sinkMBB
20984   copy0MBB->addSuccessor(sinkMBB);
20985
20986   //  sinkMBB:
20987   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
20988   //  ...
20989   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
20990           TII->get(X86::PHI), MI->getOperand(0).getReg())
20991     .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
20992     .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
20993
20994   MI->eraseFromParent();   // The pseudo instruction is gone now.
20995   return sinkMBB;
20996 }
20997
20998 MachineBasicBlock *
20999 X86TargetLowering::EmitLoweredSegAlloca(MachineInstr *MI,
21000                                         MachineBasicBlock *BB) const {
21001   MachineFunction *MF = BB->getParent();
21002   const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
21003   DebugLoc DL = MI->getDebugLoc();
21004   const BasicBlock *LLVM_BB = BB->getBasicBlock();
21005
21006   assert(MF->shouldSplitStack());
21007
21008   const bool Is64Bit = Subtarget->is64Bit();
21009   const bool IsLP64 = Subtarget->isTarget64BitLP64();
21010
21011   const unsigned TlsReg = Is64Bit ? X86::FS : X86::GS;
21012   const unsigned TlsOffset = IsLP64 ? 0x70 : Is64Bit ? 0x40 : 0x30;
21013
21014   // BB:
21015   //  ... [Till the alloca]
21016   // If stacklet is not large enough, jump to mallocMBB
21017   //
21018   // bumpMBB:
21019   //  Allocate by subtracting from RSP
21020   //  Jump to continueMBB
21021   //
21022   // mallocMBB:
21023   //  Allocate by call to runtime
21024   //
21025   // continueMBB:
21026   //  ...
21027   //  [rest of original BB]
21028   //
21029
21030   MachineBasicBlock *mallocMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21031   MachineBasicBlock *bumpMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21032   MachineBasicBlock *continueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
21033
21034   MachineRegisterInfo &MRI = MF->getRegInfo();
21035   const TargetRegisterClass *AddrRegClass =
21036     getRegClassFor(getPointerTy());
21037
21038   unsigned mallocPtrVReg = MRI.createVirtualRegister(AddrRegClass),
21039     bumpSPPtrVReg = MRI.createVirtualRegister(AddrRegClass),
21040     tmpSPVReg = MRI.createVirtualRegister(AddrRegClass),
21041     SPLimitVReg = MRI.createVirtualRegister(AddrRegClass),
21042     sizeVReg = MI->getOperand(1).getReg(),
21043     physSPReg = IsLP64 || Subtarget->isTargetNaCl64() ? X86::RSP : X86::ESP;
21044
21045   MachineFunction::iterator MBBIter = BB;
21046   ++MBBIter;
21047
21048   MF->insert(MBBIter, bumpMBB);
21049   MF->insert(MBBIter, mallocMBB);
21050   MF->insert(MBBIter, continueMBB);
21051
21052   continueMBB->splice(continueMBB->begin(), BB,
21053                       std::next(MachineBasicBlock::iterator(MI)), BB->end());
21054   continueMBB->transferSuccessorsAndUpdatePHIs(BB);
21055
21056   // Add code to the main basic block to check if the stack limit has been hit,
21057   // and if so, jump to mallocMBB otherwise to bumpMBB.
21058   BuildMI(BB, DL, TII->get(TargetOpcode::COPY), tmpSPVReg).addReg(physSPReg);
21059   BuildMI(BB, DL, TII->get(IsLP64 ? X86::SUB64rr:X86::SUB32rr), SPLimitVReg)
21060     .addReg(tmpSPVReg).addReg(sizeVReg);
21061   BuildMI(BB, DL, TII->get(IsLP64 ? X86::CMP64mr:X86::CMP32mr))
21062     .addReg(0).addImm(1).addReg(0).addImm(TlsOffset).addReg(TlsReg)
21063     .addReg(SPLimitVReg);
21064   BuildMI(BB, DL, TII->get(X86::JG_1)).addMBB(mallocMBB);
21065
21066   // bumpMBB simply decreases the stack pointer, since we know the current
21067   // stacklet has enough space.
21068   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), physSPReg)
21069     .addReg(SPLimitVReg);
21070   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), bumpSPPtrVReg)
21071     .addReg(SPLimitVReg);
21072   BuildMI(bumpMBB, DL, TII->get(X86::JMP_1)).addMBB(continueMBB);
21073
21074   // Calls into a routine in libgcc to allocate more space from the heap.
21075   const uint32_t *RegMask = MF->getTarget()
21076                                 .getSubtargetImpl()
21077                                 ->getRegisterInfo()
21078                                 ->getCallPreservedMask(CallingConv::C);
21079   if (IsLP64) {
21080     BuildMI(mallocMBB, DL, TII->get(X86::MOV64rr), X86::RDI)
21081       .addReg(sizeVReg);
21082     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
21083       .addExternalSymbol("__morestack_allocate_stack_space")
21084       .addRegMask(RegMask)
21085       .addReg(X86::RDI, RegState::Implicit)
21086       .addReg(X86::RAX, RegState::ImplicitDefine);
21087   } else if (Is64Bit) {
21088     BuildMI(mallocMBB, DL, TII->get(X86::MOV32rr), X86::EDI)
21089       .addReg(sizeVReg);
21090     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
21091       .addExternalSymbol("__morestack_allocate_stack_space")
21092       .addRegMask(RegMask)
21093       .addReg(X86::EDI, RegState::Implicit)
21094       .addReg(X86::EAX, RegState::ImplicitDefine);
21095   } else {
21096     BuildMI(mallocMBB, DL, TII->get(X86::SUB32ri), physSPReg).addReg(physSPReg)
21097       .addImm(12);
21098     BuildMI(mallocMBB, DL, TII->get(X86::PUSH32r)).addReg(sizeVReg);
21099     BuildMI(mallocMBB, DL, TII->get(X86::CALLpcrel32))
21100       .addExternalSymbol("__morestack_allocate_stack_space")
21101       .addRegMask(RegMask)
21102       .addReg(X86::EAX, RegState::ImplicitDefine);
21103   }
21104
21105   if (!Is64Bit)
21106     BuildMI(mallocMBB, DL, TII->get(X86::ADD32ri), physSPReg).addReg(physSPReg)
21107       .addImm(16);
21108
21109   BuildMI(mallocMBB, DL, TII->get(TargetOpcode::COPY), mallocPtrVReg)
21110     .addReg(IsLP64 ? X86::RAX : X86::EAX);
21111   BuildMI(mallocMBB, DL, TII->get(X86::JMP_1)).addMBB(continueMBB);
21112
21113   // Set up the CFG correctly.
21114   BB->addSuccessor(bumpMBB);
21115   BB->addSuccessor(mallocMBB);
21116   mallocMBB->addSuccessor(continueMBB);
21117   bumpMBB->addSuccessor(continueMBB);
21118
21119   // Take care of the PHI nodes.
21120   BuildMI(*continueMBB, continueMBB->begin(), DL, TII->get(X86::PHI),
21121           MI->getOperand(0).getReg())
21122     .addReg(mallocPtrVReg).addMBB(mallocMBB)
21123     .addReg(bumpSPPtrVReg).addMBB(bumpMBB);
21124
21125   // Delete the original pseudo instruction.
21126   MI->eraseFromParent();
21127
21128   // And we're done.
21129   return continueMBB;
21130 }
21131
21132 MachineBasicBlock *
21133 X86TargetLowering::EmitLoweredWinAlloca(MachineInstr *MI,
21134                                         MachineBasicBlock *BB) const {
21135   const TargetInstrInfo *TII = BB->getParent()->getSubtarget().getInstrInfo();
21136   DebugLoc DL = MI->getDebugLoc();
21137
21138   assert(!Subtarget->isTargetMachO());
21139
21140   // The lowering is pretty easy: we're just emitting the call to _alloca.  The
21141   // non-trivial part is impdef of ESP.
21142
21143   if (Subtarget->isTargetWin64()) {
21144     if (Subtarget->isTargetCygMing()) {
21145       // ___chkstk(Mingw64):
21146       // Clobbers R10, R11, RAX and EFLAGS.
21147       // Updates RSP.
21148       BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
21149         .addExternalSymbol("___chkstk")
21150         .addReg(X86::RAX, RegState::Implicit)
21151         .addReg(X86::RSP, RegState::Implicit)
21152         .addReg(X86::RAX, RegState::Define | RegState::Implicit)
21153         .addReg(X86::RSP, RegState::Define | RegState::Implicit)
21154         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
21155     } else {
21156       // __chkstk(MSVCRT): does not update stack pointer.
21157       // Clobbers R10, R11 and EFLAGS.
21158       BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
21159         .addExternalSymbol("__chkstk")
21160         .addReg(X86::RAX, RegState::Implicit)
21161         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
21162       // RAX has the offset to be subtracted from RSP.
21163       BuildMI(*BB, MI, DL, TII->get(X86::SUB64rr), X86::RSP)
21164         .addReg(X86::RSP)
21165         .addReg(X86::RAX);
21166     }
21167   } else {
21168     const char *StackProbeSymbol = (Subtarget->isTargetKnownWindowsMSVC() ||
21169                                     Subtarget->isTargetWindowsItanium())
21170                                        ? "_chkstk"
21171                                        : "_alloca";
21172
21173     BuildMI(*BB, MI, DL, TII->get(X86::CALLpcrel32))
21174       .addExternalSymbol(StackProbeSymbol)
21175       .addReg(X86::EAX, RegState::Implicit)
21176       .addReg(X86::ESP, RegState::Implicit)
21177       .addReg(X86::EAX, RegState::Define | RegState::Implicit)
21178       .addReg(X86::ESP, RegState::Define | RegState::Implicit)
21179       .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
21180   }
21181
21182   MI->eraseFromParent();   // The pseudo instruction is gone now.
21183   return BB;
21184 }
21185
21186 MachineBasicBlock *
21187 X86TargetLowering::EmitLoweredTLSCall(MachineInstr *MI,
21188                                       MachineBasicBlock *BB) const {
21189   // This is pretty easy.  We're taking the value that we received from
21190   // our load from the relocation, sticking it in either RDI (x86-64)
21191   // or EAX and doing an indirect call.  The return value will then
21192   // be in the normal return register.
21193   MachineFunction *F = BB->getParent();
21194   const X86InstrInfo *TII =
21195       static_cast<const X86InstrInfo *>(F->getSubtarget().getInstrInfo());
21196   DebugLoc DL = MI->getDebugLoc();
21197
21198   assert(Subtarget->isTargetDarwin() && "Darwin only instr emitted?");
21199   assert(MI->getOperand(3).isGlobal() && "This should be a global");
21200
21201   // Get a register mask for the lowered call.
21202   // FIXME: The 32-bit calls have non-standard calling conventions. Use a
21203   // proper register mask.
21204   const uint32_t *RegMask = F->getTarget()
21205                                 .getSubtargetImpl()
21206                                 ->getRegisterInfo()
21207                                 ->getCallPreservedMask(CallingConv::C);
21208   if (Subtarget->is64Bit()) {
21209     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21210                                       TII->get(X86::MOV64rm), X86::RDI)
21211     .addReg(X86::RIP)
21212     .addImm(0).addReg(0)
21213     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21214                       MI->getOperand(3).getTargetFlags())
21215     .addReg(0);
21216     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL64m));
21217     addDirectMem(MIB, X86::RDI);
21218     MIB.addReg(X86::RAX, RegState::ImplicitDefine).addRegMask(RegMask);
21219   } else if (F->getTarget().getRelocationModel() != Reloc::PIC_) {
21220     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21221                                       TII->get(X86::MOV32rm), X86::EAX)
21222     .addReg(0)
21223     .addImm(0).addReg(0)
21224     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21225                       MI->getOperand(3).getTargetFlags())
21226     .addReg(0);
21227     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
21228     addDirectMem(MIB, X86::EAX);
21229     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
21230   } else {
21231     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
21232                                       TII->get(X86::MOV32rm), X86::EAX)
21233     .addReg(TII->getGlobalBaseReg(F))
21234     .addImm(0).addReg(0)
21235     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
21236                       MI->getOperand(3).getTargetFlags())
21237     .addReg(0);
21238     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
21239     addDirectMem(MIB, X86::EAX);
21240     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
21241   }
21242
21243   MI->eraseFromParent(); // The pseudo instruction is gone now.
21244   return BB;
21245 }
21246
21247 MachineBasicBlock *
21248 X86TargetLowering::emitEHSjLjSetJmp(MachineInstr *MI,
21249                                     MachineBasicBlock *MBB) const {
21250   DebugLoc DL = MI->getDebugLoc();
21251   MachineFunction *MF = MBB->getParent();
21252   const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
21253   MachineRegisterInfo &MRI = MF->getRegInfo();
21254
21255   const BasicBlock *BB = MBB->getBasicBlock();
21256   MachineFunction::iterator I = MBB;
21257   ++I;
21258
21259   // Memory Reference
21260   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
21261   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
21262
21263   unsigned DstReg;
21264   unsigned MemOpndSlot = 0;
21265
21266   unsigned CurOp = 0;
21267
21268   DstReg = MI->getOperand(CurOp++).getReg();
21269   const TargetRegisterClass *RC = MRI.getRegClass(DstReg);
21270   assert(RC->hasType(MVT::i32) && "Invalid destination!");
21271   unsigned mainDstReg = MRI.createVirtualRegister(RC);
21272   unsigned restoreDstReg = MRI.createVirtualRegister(RC);
21273
21274   MemOpndSlot = CurOp;
21275
21276   MVT PVT = getPointerTy();
21277   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
21278          "Invalid Pointer Size!");
21279
21280   // For v = setjmp(buf), we generate
21281   //
21282   // thisMBB:
21283   //  buf[LabelOffset] = restoreMBB
21284   //  SjLjSetup restoreMBB
21285   //
21286   // mainMBB:
21287   //  v_main = 0
21288   //
21289   // sinkMBB:
21290   //  v = phi(main, restore)
21291   //
21292   // restoreMBB:
21293   //  if base pointer being used, load it from frame
21294   //  v_restore = 1
21295
21296   MachineBasicBlock *thisMBB = MBB;
21297   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
21298   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
21299   MachineBasicBlock *restoreMBB = MF->CreateMachineBasicBlock(BB);
21300   MF->insert(I, mainMBB);
21301   MF->insert(I, sinkMBB);
21302   MF->push_back(restoreMBB);
21303
21304   MachineInstrBuilder MIB;
21305
21306   // Transfer the remainder of BB and its successor edges to sinkMBB.
21307   sinkMBB->splice(sinkMBB->begin(), MBB,
21308                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
21309   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
21310
21311   // thisMBB:
21312   unsigned PtrStoreOpc = 0;
21313   unsigned LabelReg = 0;
21314   const int64_t LabelOffset = 1 * PVT.getStoreSize();
21315   Reloc::Model RM = MF->getTarget().getRelocationModel();
21316   bool UseImmLabel = (MF->getTarget().getCodeModel() == CodeModel::Small) &&
21317                      (RM == Reloc::Static || RM == Reloc::DynamicNoPIC);
21318
21319   // Prepare IP either in reg or imm.
21320   if (!UseImmLabel) {
21321     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mr : X86::MOV32mr;
21322     const TargetRegisterClass *PtrRC = getRegClassFor(PVT);
21323     LabelReg = MRI.createVirtualRegister(PtrRC);
21324     if (Subtarget->is64Bit()) {
21325       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA64r), LabelReg)
21326               .addReg(X86::RIP)
21327               .addImm(0)
21328               .addReg(0)
21329               .addMBB(restoreMBB)
21330               .addReg(0);
21331     } else {
21332       const X86InstrInfo *XII = static_cast<const X86InstrInfo*>(TII);
21333       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA32r), LabelReg)
21334               .addReg(XII->getGlobalBaseReg(MF))
21335               .addImm(0)
21336               .addReg(0)
21337               .addMBB(restoreMBB, Subtarget->ClassifyBlockAddressReference())
21338               .addReg(0);
21339     }
21340   } else
21341     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mi32 : X86::MOV32mi;
21342   // Store IP
21343   MIB = BuildMI(*thisMBB, MI, DL, TII->get(PtrStoreOpc));
21344   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21345     if (i == X86::AddrDisp)
21346       MIB.addDisp(MI->getOperand(MemOpndSlot + i), LabelOffset);
21347     else
21348       MIB.addOperand(MI->getOperand(MemOpndSlot + i));
21349   }
21350   if (!UseImmLabel)
21351     MIB.addReg(LabelReg);
21352   else
21353     MIB.addMBB(restoreMBB);
21354   MIB.setMemRefs(MMOBegin, MMOEnd);
21355   // Setup
21356   MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::EH_SjLj_Setup))
21357           .addMBB(restoreMBB);
21358
21359   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
21360       MF->getSubtarget().getRegisterInfo());
21361   MIB.addRegMask(RegInfo->getNoPreservedMask());
21362   thisMBB->addSuccessor(mainMBB);
21363   thisMBB->addSuccessor(restoreMBB);
21364
21365   // mainMBB:
21366   //  EAX = 0
21367   BuildMI(mainMBB, DL, TII->get(X86::MOV32r0), mainDstReg);
21368   mainMBB->addSuccessor(sinkMBB);
21369
21370   // sinkMBB:
21371   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
21372           TII->get(X86::PHI), DstReg)
21373     .addReg(mainDstReg).addMBB(mainMBB)
21374     .addReg(restoreDstReg).addMBB(restoreMBB);
21375
21376   // restoreMBB:
21377   if (RegInfo->hasBasePointer(*MF)) {
21378     const X86Subtarget &STI = MF->getTarget().getSubtarget<X86Subtarget>();
21379     const bool Uses64BitFramePtr = STI.isTarget64BitLP64() || STI.isTargetNaCl64();
21380     X86MachineFunctionInfo *X86FI = MF->getInfo<X86MachineFunctionInfo>();
21381     X86FI->setRestoreBasePointer(MF);
21382     unsigned FramePtr = RegInfo->getFrameRegister(*MF);
21383     unsigned BasePtr = RegInfo->getBaseRegister();
21384     unsigned Opm = Uses64BitFramePtr ? X86::MOV64rm : X86::MOV32rm;
21385     addRegOffset(BuildMI(restoreMBB, DL, TII->get(Opm), BasePtr),
21386                  FramePtr, true, X86FI->getRestoreBasePointerOffset())
21387       .setMIFlag(MachineInstr::FrameSetup);
21388   }
21389   BuildMI(restoreMBB, DL, TII->get(X86::MOV32ri), restoreDstReg).addImm(1);
21390   BuildMI(restoreMBB, DL, TII->get(X86::JMP_1)).addMBB(sinkMBB);
21391   restoreMBB->addSuccessor(sinkMBB);
21392
21393   MI->eraseFromParent();
21394   return sinkMBB;
21395 }
21396
21397 MachineBasicBlock *
21398 X86TargetLowering::emitEHSjLjLongJmp(MachineInstr *MI,
21399                                      MachineBasicBlock *MBB) const {
21400   DebugLoc DL = MI->getDebugLoc();
21401   MachineFunction *MF = MBB->getParent();
21402   const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
21403   MachineRegisterInfo &MRI = MF->getRegInfo();
21404
21405   // Memory Reference
21406   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
21407   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
21408
21409   MVT PVT = getPointerTy();
21410   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
21411          "Invalid Pointer Size!");
21412
21413   const TargetRegisterClass *RC =
21414     (PVT == MVT::i64) ? &X86::GR64RegClass : &X86::GR32RegClass;
21415   unsigned Tmp = MRI.createVirtualRegister(RC);
21416   // Since FP is only updated here but NOT referenced, it's treated as GPR.
21417   const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo *>(
21418       MF->getSubtarget().getRegisterInfo());
21419   unsigned FP = (PVT == MVT::i64) ? X86::RBP : X86::EBP;
21420   unsigned SP = RegInfo->getStackRegister();
21421
21422   MachineInstrBuilder MIB;
21423
21424   const int64_t LabelOffset = 1 * PVT.getStoreSize();
21425   const int64_t SPOffset = 2 * PVT.getStoreSize();
21426
21427   unsigned PtrLoadOpc = (PVT == MVT::i64) ? X86::MOV64rm : X86::MOV32rm;
21428   unsigned IJmpOpc = (PVT == MVT::i64) ? X86::JMP64r : X86::JMP32r;
21429
21430   // Reload FP
21431   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), FP);
21432   for (unsigned i = 0; i < X86::AddrNumOperands; ++i)
21433     MIB.addOperand(MI->getOperand(i));
21434   MIB.setMemRefs(MMOBegin, MMOEnd);
21435   // Reload IP
21436   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), Tmp);
21437   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21438     if (i == X86::AddrDisp)
21439       MIB.addDisp(MI->getOperand(i), LabelOffset);
21440     else
21441       MIB.addOperand(MI->getOperand(i));
21442   }
21443   MIB.setMemRefs(MMOBegin, MMOEnd);
21444   // Reload SP
21445   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), SP);
21446   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
21447     if (i == X86::AddrDisp)
21448       MIB.addDisp(MI->getOperand(i), SPOffset);
21449     else
21450       MIB.addOperand(MI->getOperand(i));
21451   }
21452   MIB.setMemRefs(MMOBegin, MMOEnd);
21453   // Jump
21454   BuildMI(*MBB, MI, DL, TII->get(IJmpOpc)).addReg(Tmp);
21455
21456   MI->eraseFromParent();
21457   return MBB;
21458 }
21459
21460 // Replace 213-type (isel default) FMA3 instructions with 231-type for
21461 // accumulator loops. Writing back to the accumulator allows the coalescer
21462 // to remove extra copies in the loop.
21463 MachineBasicBlock *
21464 X86TargetLowering::emitFMA3Instr(MachineInstr *MI,
21465                                  MachineBasicBlock *MBB) const {
21466   MachineOperand &AddendOp = MI->getOperand(3);
21467
21468   // Bail out early if the addend isn't a register - we can't switch these.
21469   if (!AddendOp.isReg())
21470     return MBB;
21471
21472   MachineFunction &MF = *MBB->getParent();
21473   MachineRegisterInfo &MRI = MF.getRegInfo();
21474
21475   // Check whether the addend is defined by a PHI:
21476   assert(MRI.hasOneDef(AddendOp.getReg()) && "Multiple defs in SSA?");
21477   MachineInstr &AddendDef = *MRI.def_instr_begin(AddendOp.getReg());
21478   if (!AddendDef.isPHI())
21479     return MBB;
21480
21481   // Look for the following pattern:
21482   // loop:
21483   //   %addend = phi [%entry, 0], [%loop, %result]
21484   //   ...
21485   //   %result<tied1> = FMA213 %m2<tied0>, %m1, %addend
21486
21487   // Replace with:
21488   //   loop:
21489   //   %addend = phi [%entry, 0], [%loop, %result]
21490   //   ...
21491   //   %result<tied1> = FMA231 %addend<tied0>, %m1, %m2
21492
21493   for (unsigned i = 1, e = AddendDef.getNumOperands(); i < e; i += 2) {
21494     assert(AddendDef.getOperand(i).isReg());
21495     MachineOperand PHISrcOp = AddendDef.getOperand(i);
21496     MachineInstr &PHISrcInst = *MRI.def_instr_begin(PHISrcOp.getReg());
21497     if (&PHISrcInst == MI) {
21498       // Found a matching instruction.
21499       unsigned NewFMAOpc = 0;
21500       switch (MI->getOpcode()) {
21501         case X86::VFMADDPDr213r: NewFMAOpc = X86::VFMADDPDr231r; break;
21502         case X86::VFMADDPSr213r: NewFMAOpc = X86::VFMADDPSr231r; break;
21503         case X86::VFMADDSDr213r: NewFMAOpc = X86::VFMADDSDr231r; break;
21504         case X86::VFMADDSSr213r: NewFMAOpc = X86::VFMADDSSr231r; break;
21505         case X86::VFMSUBPDr213r: NewFMAOpc = X86::VFMSUBPDr231r; break;
21506         case X86::VFMSUBPSr213r: NewFMAOpc = X86::VFMSUBPSr231r; break;
21507         case X86::VFMSUBSDr213r: NewFMAOpc = X86::VFMSUBSDr231r; break;
21508         case X86::VFMSUBSSr213r: NewFMAOpc = X86::VFMSUBSSr231r; break;
21509         case X86::VFNMADDPDr213r: NewFMAOpc = X86::VFNMADDPDr231r; break;
21510         case X86::VFNMADDPSr213r: NewFMAOpc = X86::VFNMADDPSr231r; break;
21511         case X86::VFNMADDSDr213r: NewFMAOpc = X86::VFNMADDSDr231r; break;
21512         case X86::VFNMADDSSr213r: NewFMAOpc = X86::VFNMADDSSr231r; break;
21513         case X86::VFNMSUBPDr213r: NewFMAOpc = X86::VFNMSUBPDr231r; break;
21514         case X86::VFNMSUBPSr213r: NewFMAOpc = X86::VFNMSUBPSr231r; break;
21515         case X86::VFNMSUBSDr213r: NewFMAOpc = X86::VFNMSUBSDr231r; break;
21516         case X86::VFNMSUBSSr213r: NewFMAOpc = X86::VFNMSUBSSr231r; break;
21517         case X86::VFMADDSUBPDr213r: NewFMAOpc = X86::VFMADDSUBPDr231r; break;
21518         case X86::VFMADDSUBPSr213r: NewFMAOpc = X86::VFMADDSUBPSr231r; break;
21519         case X86::VFMSUBADDPDr213r: NewFMAOpc = X86::VFMSUBADDPDr231r; break;
21520         case X86::VFMSUBADDPSr213r: NewFMAOpc = X86::VFMSUBADDPSr231r; break;
21521
21522         case X86::VFMADDPDr213rY: NewFMAOpc = X86::VFMADDPDr231rY; break;
21523         case X86::VFMADDPSr213rY: NewFMAOpc = X86::VFMADDPSr231rY; break;
21524         case X86::VFMSUBPDr213rY: NewFMAOpc = X86::VFMSUBPDr231rY; break;
21525         case X86::VFMSUBPSr213rY: NewFMAOpc = X86::VFMSUBPSr231rY; break;
21526         case X86::VFNMADDPDr213rY: NewFMAOpc = X86::VFNMADDPDr231rY; break;
21527         case X86::VFNMADDPSr213rY: NewFMAOpc = X86::VFNMADDPSr231rY; break;
21528         case X86::VFNMSUBPDr213rY: NewFMAOpc = X86::VFNMSUBPDr231rY; break;
21529         case X86::VFNMSUBPSr213rY: NewFMAOpc = X86::VFNMSUBPSr231rY; break;
21530         case X86::VFMADDSUBPDr213rY: NewFMAOpc = X86::VFMADDSUBPDr231rY; break;
21531         case X86::VFMADDSUBPSr213rY: NewFMAOpc = X86::VFMADDSUBPSr231rY; break;
21532         case X86::VFMSUBADDPDr213rY: NewFMAOpc = X86::VFMSUBADDPDr231rY; break;
21533         case X86::VFMSUBADDPSr213rY: NewFMAOpc = X86::VFMSUBADDPSr231rY; break;
21534         default: llvm_unreachable("Unrecognized FMA variant.");
21535       }
21536
21537       const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
21538       MachineInstrBuilder MIB =
21539         BuildMI(MF, MI->getDebugLoc(), TII.get(NewFMAOpc))
21540         .addOperand(MI->getOperand(0))
21541         .addOperand(MI->getOperand(3))
21542         .addOperand(MI->getOperand(2))
21543         .addOperand(MI->getOperand(1));
21544       MBB->insert(MachineBasicBlock::iterator(MI), MIB);
21545       MI->eraseFromParent();
21546     }
21547   }
21548
21549   return MBB;
21550 }
21551
21552 MachineBasicBlock *
21553 X86TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
21554                                                MachineBasicBlock *BB) const {
21555   switch (MI->getOpcode()) {
21556   default: llvm_unreachable("Unexpected instr type to insert");
21557   case X86::TAILJMPd64:
21558   case X86::TAILJMPr64:
21559   case X86::TAILJMPm64:
21560     llvm_unreachable("TAILJMP64 would not be touched here.");
21561   case X86::TCRETURNdi64:
21562   case X86::TCRETURNri64:
21563   case X86::TCRETURNmi64:
21564     return BB;
21565   case X86::WIN_ALLOCA:
21566     return EmitLoweredWinAlloca(MI, BB);
21567   case X86::SEG_ALLOCA_32:
21568   case X86::SEG_ALLOCA_64:
21569     return EmitLoweredSegAlloca(MI, BB);
21570   case X86::TLSCall_32:
21571   case X86::TLSCall_64:
21572     return EmitLoweredTLSCall(MI, BB);
21573   case X86::CMOV_GR8:
21574   case X86::CMOV_FR32:
21575   case X86::CMOV_FR64:
21576   case X86::CMOV_V4F32:
21577   case X86::CMOV_V2F64:
21578   case X86::CMOV_V2I64:
21579   case X86::CMOV_V8F32:
21580   case X86::CMOV_V4F64:
21581   case X86::CMOV_V4I64:
21582   case X86::CMOV_V16F32:
21583   case X86::CMOV_V8F64:
21584   case X86::CMOV_V8I64:
21585   case X86::CMOV_GR16:
21586   case X86::CMOV_GR32:
21587   case X86::CMOV_RFP32:
21588   case X86::CMOV_RFP64:
21589   case X86::CMOV_RFP80:
21590     return EmitLoweredSelect(MI, BB);
21591
21592   case X86::FP32_TO_INT16_IN_MEM:
21593   case X86::FP32_TO_INT32_IN_MEM:
21594   case X86::FP32_TO_INT64_IN_MEM:
21595   case X86::FP64_TO_INT16_IN_MEM:
21596   case X86::FP64_TO_INT32_IN_MEM:
21597   case X86::FP64_TO_INT64_IN_MEM:
21598   case X86::FP80_TO_INT16_IN_MEM:
21599   case X86::FP80_TO_INT32_IN_MEM:
21600   case X86::FP80_TO_INT64_IN_MEM: {
21601     MachineFunction *F = BB->getParent();
21602     const TargetInstrInfo *TII = F->getSubtarget().getInstrInfo();
21603     DebugLoc DL = MI->getDebugLoc();
21604
21605     // Change the floating point control register to use "round towards zero"
21606     // mode when truncating to an integer value.
21607     int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2, false);
21608     addFrameReference(BuildMI(*BB, MI, DL,
21609                               TII->get(X86::FNSTCW16m)), CWFrameIdx);
21610
21611     // Load the old value of the high byte of the control word...
21612     unsigned OldCW =
21613       F->getRegInfo().createVirtualRegister(&X86::GR16RegClass);
21614     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16rm), OldCW),
21615                       CWFrameIdx);
21616
21617     // Set the high part to be round to zero...
21618     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mi)), CWFrameIdx)
21619       .addImm(0xC7F);
21620
21621     // Reload the modified control word now...
21622     addFrameReference(BuildMI(*BB, MI, DL,
21623                               TII->get(X86::FLDCW16m)), CWFrameIdx);
21624
21625     // Restore the memory image of control word to original value
21626     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mr)), CWFrameIdx)
21627       .addReg(OldCW);
21628
21629     // Get the X86 opcode to use.
21630     unsigned Opc;
21631     switch (MI->getOpcode()) {
21632     default: llvm_unreachable("illegal opcode!");
21633     case X86::FP32_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m32; break;
21634     case X86::FP32_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m32; break;
21635     case X86::FP32_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m32; break;
21636     case X86::FP64_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m64; break;
21637     case X86::FP64_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m64; break;
21638     case X86::FP64_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m64; break;
21639     case X86::FP80_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m80; break;
21640     case X86::FP80_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m80; break;
21641     case X86::FP80_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m80; break;
21642     }
21643
21644     X86AddressMode AM;
21645     MachineOperand &Op = MI->getOperand(0);
21646     if (Op.isReg()) {
21647       AM.BaseType = X86AddressMode::RegBase;
21648       AM.Base.Reg = Op.getReg();
21649     } else {
21650       AM.BaseType = X86AddressMode::FrameIndexBase;
21651       AM.Base.FrameIndex = Op.getIndex();
21652     }
21653     Op = MI->getOperand(1);
21654     if (Op.isImm())
21655       AM.Scale = Op.getImm();
21656     Op = MI->getOperand(2);
21657     if (Op.isImm())
21658       AM.IndexReg = Op.getImm();
21659     Op = MI->getOperand(3);
21660     if (Op.isGlobal()) {
21661       AM.GV = Op.getGlobal();
21662     } else {
21663       AM.Disp = Op.getImm();
21664     }
21665     addFullAddress(BuildMI(*BB, MI, DL, TII->get(Opc)), AM)
21666                       .addReg(MI->getOperand(X86::AddrNumOperands).getReg());
21667
21668     // Reload the original control word now.
21669     addFrameReference(BuildMI(*BB, MI, DL,
21670                               TII->get(X86::FLDCW16m)), CWFrameIdx);
21671
21672     MI->eraseFromParent();   // The pseudo instruction is gone now.
21673     return BB;
21674   }
21675     // String/text processing lowering.
21676   case X86::PCMPISTRM128REG:
21677   case X86::VPCMPISTRM128REG:
21678   case X86::PCMPISTRM128MEM:
21679   case X86::VPCMPISTRM128MEM:
21680   case X86::PCMPESTRM128REG:
21681   case X86::VPCMPESTRM128REG:
21682   case X86::PCMPESTRM128MEM:
21683   case X86::VPCMPESTRM128MEM:
21684     assert(Subtarget->hasSSE42() &&
21685            "Target must have SSE4.2 or AVX features enabled");
21686     return EmitPCMPSTRM(MI, BB, BB->getParent()->getSubtarget().getInstrInfo());
21687
21688   // String/text processing lowering.
21689   case X86::PCMPISTRIREG:
21690   case X86::VPCMPISTRIREG:
21691   case X86::PCMPISTRIMEM:
21692   case X86::VPCMPISTRIMEM:
21693   case X86::PCMPESTRIREG:
21694   case X86::VPCMPESTRIREG:
21695   case X86::PCMPESTRIMEM:
21696   case X86::VPCMPESTRIMEM:
21697     assert(Subtarget->hasSSE42() &&
21698            "Target must have SSE4.2 or AVX features enabled");
21699     return EmitPCMPSTRI(MI, BB, BB->getParent()->getSubtarget().getInstrInfo());
21700
21701   // Thread synchronization.
21702   case X86::MONITOR:
21703     return EmitMonitor(MI, BB, BB->getParent()->getSubtarget().getInstrInfo(),
21704                        Subtarget);
21705
21706   // xbegin
21707   case X86::XBEGIN:
21708     return EmitXBegin(MI, BB, BB->getParent()->getSubtarget().getInstrInfo());
21709
21710   case X86::VASTART_SAVE_XMM_REGS:
21711     return EmitVAStartSaveXMMRegsWithCustomInserter(MI, BB);
21712
21713   case X86::VAARG_64:
21714     return EmitVAARG64WithCustomInserter(MI, BB);
21715
21716   case X86::EH_SjLj_SetJmp32:
21717   case X86::EH_SjLj_SetJmp64:
21718     return emitEHSjLjSetJmp(MI, BB);
21719
21720   case X86::EH_SjLj_LongJmp32:
21721   case X86::EH_SjLj_LongJmp64:
21722     return emitEHSjLjLongJmp(MI, BB);
21723
21724   case TargetOpcode::STATEPOINT:
21725     // As an implementation detail, STATEPOINT shares the STACKMAP format at
21726     // this point in the process.  We diverge later.
21727     return emitPatchPoint(MI, BB);
21728
21729   case TargetOpcode::STACKMAP:
21730   case TargetOpcode::PATCHPOINT:
21731     return emitPatchPoint(MI, BB);
21732
21733   case X86::VFMADDPDr213r:
21734   case X86::VFMADDPSr213r:
21735   case X86::VFMADDSDr213r:
21736   case X86::VFMADDSSr213r:
21737   case X86::VFMSUBPDr213r:
21738   case X86::VFMSUBPSr213r:
21739   case X86::VFMSUBSDr213r:
21740   case X86::VFMSUBSSr213r:
21741   case X86::VFNMADDPDr213r:
21742   case X86::VFNMADDPSr213r:
21743   case X86::VFNMADDSDr213r:
21744   case X86::VFNMADDSSr213r:
21745   case X86::VFNMSUBPDr213r:
21746   case X86::VFNMSUBPSr213r:
21747   case X86::VFNMSUBSDr213r:
21748   case X86::VFNMSUBSSr213r:
21749   case X86::VFMADDSUBPDr213r:
21750   case X86::VFMADDSUBPSr213r:
21751   case X86::VFMSUBADDPDr213r:
21752   case X86::VFMSUBADDPSr213r:
21753   case X86::VFMADDPDr213rY:
21754   case X86::VFMADDPSr213rY:
21755   case X86::VFMSUBPDr213rY:
21756   case X86::VFMSUBPSr213rY:
21757   case X86::VFNMADDPDr213rY:
21758   case X86::VFNMADDPSr213rY:
21759   case X86::VFNMSUBPDr213rY:
21760   case X86::VFNMSUBPSr213rY:
21761   case X86::VFMADDSUBPDr213rY:
21762   case X86::VFMADDSUBPSr213rY:
21763   case X86::VFMSUBADDPDr213rY:
21764   case X86::VFMSUBADDPSr213rY:
21765     return emitFMA3Instr(MI, BB);
21766   }
21767 }
21768
21769 //===----------------------------------------------------------------------===//
21770 //                           X86 Optimization Hooks
21771 //===----------------------------------------------------------------------===//
21772
21773 void X86TargetLowering::computeKnownBitsForTargetNode(const SDValue Op,
21774                                                       APInt &KnownZero,
21775                                                       APInt &KnownOne,
21776                                                       const SelectionDAG &DAG,
21777                                                       unsigned Depth) const {
21778   unsigned BitWidth = KnownZero.getBitWidth();
21779   unsigned Opc = Op.getOpcode();
21780   assert((Opc >= ISD::BUILTIN_OP_END ||
21781           Opc == ISD::INTRINSIC_WO_CHAIN ||
21782           Opc == ISD::INTRINSIC_W_CHAIN ||
21783           Opc == ISD::INTRINSIC_VOID) &&
21784          "Should use MaskedValueIsZero if you don't know whether Op"
21785          " is a target node!");
21786
21787   KnownZero = KnownOne = APInt(BitWidth, 0);   // Don't know anything.
21788   switch (Opc) {
21789   default: break;
21790   case X86ISD::ADD:
21791   case X86ISD::SUB:
21792   case X86ISD::ADC:
21793   case X86ISD::SBB:
21794   case X86ISD::SMUL:
21795   case X86ISD::UMUL:
21796   case X86ISD::INC:
21797   case X86ISD::DEC:
21798   case X86ISD::OR:
21799   case X86ISD::XOR:
21800   case X86ISD::AND:
21801     // These nodes' second result is a boolean.
21802     if (Op.getResNo() == 0)
21803       break;
21804     // Fallthrough
21805   case X86ISD::SETCC:
21806     KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
21807     break;
21808   case ISD::INTRINSIC_WO_CHAIN: {
21809     unsigned IntId = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
21810     unsigned NumLoBits = 0;
21811     switch (IntId) {
21812     default: break;
21813     case Intrinsic::x86_sse_movmsk_ps:
21814     case Intrinsic::x86_avx_movmsk_ps_256:
21815     case Intrinsic::x86_sse2_movmsk_pd:
21816     case Intrinsic::x86_avx_movmsk_pd_256:
21817     case Intrinsic::x86_mmx_pmovmskb:
21818     case Intrinsic::x86_sse2_pmovmskb_128:
21819     case Intrinsic::x86_avx2_pmovmskb: {
21820       // High bits of movmskp{s|d}, pmovmskb are known zero.
21821       switch (IntId) {
21822         default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
21823         case Intrinsic::x86_sse_movmsk_ps:      NumLoBits = 4; break;
21824         case Intrinsic::x86_avx_movmsk_ps_256:  NumLoBits = 8; break;
21825         case Intrinsic::x86_sse2_movmsk_pd:     NumLoBits = 2; break;
21826         case Intrinsic::x86_avx_movmsk_pd_256:  NumLoBits = 4; break;
21827         case Intrinsic::x86_mmx_pmovmskb:       NumLoBits = 8; break;
21828         case Intrinsic::x86_sse2_pmovmskb_128:  NumLoBits = 16; break;
21829         case Intrinsic::x86_avx2_pmovmskb:      NumLoBits = 32; break;
21830       }
21831       KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - NumLoBits);
21832       break;
21833     }
21834     }
21835     break;
21836   }
21837   }
21838 }
21839
21840 unsigned X86TargetLowering::ComputeNumSignBitsForTargetNode(
21841   SDValue Op,
21842   const SelectionDAG &,
21843   unsigned Depth) const {
21844   // SETCC_CARRY sets the dest to ~0 for true or 0 for false.
21845   if (Op.getOpcode() == X86ISD::SETCC_CARRY)
21846     return Op.getValueType().getScalarType().getSizeInBits();
21847
21848   // Fallback case.
21849   return 1;
21850 }
21851
21852 /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
21853 /// node is a GlobalAddress + offset.
21854 bool X86TargetLowering::isGAPlusOffset(SDNode *N,
21855                                        const GlobalValue* &GA,
21856                                        int64_t &Offset) const {
21857   if (N->getOpcode() == X86ISD::Wrapper) {
21858     if (isa<GlobalAddressSDNode>(N->getOperand(0))) {
21859       GA = cast<GlobalAddressSDNode>(N->getOperand(0))->getGlobal();
21860       Offset = cast<GlobalAddressSDNode>(N->getOperand(0))->getOffset();
21861       return true;
21862     }
21863   }
21864   return TargetLowering::isGAPlusOffset(N, GA, Offset);
21865 }
21866
21867 /// isShuffleHigh128VectorInsertLow - Checks whether the shuffle node is the
21868 /// same as extracting the high 128-bit part of 256-bit vector and then
21869 /// inserting the result into the low part of a new 256-bit vector
21870 static bool isShuffleHigh128VectorInsertLow(ShuffleVectorSDNode *SVOp) {
21871   EVT VT = SVOp->getValueType(0);
21872   unsigned NumElems = VT.getVectorNumElements();
21873
21874   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
21875   for (unsigned i = 0, j = NumElems/2; i != NumElems/2; ++i, ++j)
21876     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
21877         SVOp->getMaskElt(j) >= 0)
21878       return false;
21879
21880   return true;
21881 }
21882
21883 /// isShuffleLow128VectorInsertHigh - Checks whether the shuffle node is the
21884 /// same as extracting the low 128-bit part of 256-bit vector and then
21885 /// inserting the result into the high part of a new 256-bit vector
21886 static bool isShuffleLow128VectorInsertHigh(ShuffleVectorSDNode *SVOp) {
21887   EVT VT = SVOp->getValueType(0);
21888   unsigned NumElems = VT.getVectorNumElements();
21889
21890   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
21891   for (unsigned i = NumElems/2, j = 0; i != NumElems; ++i, ++j)
21892     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
21893         SVOp->getMaskElt(j) >= 0)
21894       return false;
21895
21896   return true;
21897 }
21898
21899 /// PerformShuffleCombine256 - Performs shuffle combines for 256-bit vectors.
21900 static SDValue PerformShuffleCombine256(SDNode *N, SelectionDAG &DAG,
21901                                         TargetLowering::DAGCombinerInfo &DCI,
21902                                         const X86Subtarget* Subtarget) {
21903   SDLoc dl(N);
21904   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
21905   SDValue V1 = SVOp->getOperand(0);
21906   SDValue V2 = SVOp->getOperand(1);
21907   EVT VT = SVOp->getValueType(0);
21908   unsigned NumElems = VT.getVectorNumElements();
21909
21910   if (V1.getOpcode() == ISD::CONCAT_VECTORS &&
21911       V2.getOpcode() == ISD::CONCAT_VECTORS) {
21912     //
21913     //                   0,0,0,...
21914     //                      |
21915     //    V      UNDEF    BUILD_VECTOR    UNDEF
21916     //     \      /           \           /
21917     //  CONCAT_VECTOR         CONCAT_VECTOR
21918     //         \                  /
21919     //          \                /
21920     //          RESULT: V + zero extended
21921     //
21922     if (V2.getOperand(0).getOpcode() != ISD::BUILD_VECTOR ||
21923         V2.getOperand(1).getOpcode() != ISD::UNDEF ||
21924         V1.getOperand(1).getOpcode() != ISD::UNDEF)
21925       return SDValue();
21926
21927     if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
21928       return SDValue();
21929
21930     // To match the shuffle mask, the first half of the mask should
21931     // be exactly the first vector, and all the rest a splat with the
21932     // first element of the second one.
21933     for (unsigned i = 0; i != NumElems/2; ++i)
21934       if (!isUndefOrEqual(SVOp->getMaskElt(i), i) ||
21935           !isUndefOrEqual(SVOp->getMaskElt(i+NumElems/2), NumElems))
21936         return SDValue();
21937
21938     // If V1 is coming from a vector load then just fold to a VZEXT_LOAD.
21939     if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(V1.getOperand(0))) {
21940       if (Ld->hasNUsesOfValue(1, 0)) {
21941         SDVTList Tys = DAG.getVTList(MVT::v4i64, MVT::Other);
21942         SDValue Ops[] = { Ld->getChain(), Ld->getBasePtr() };
21943         SDValue ResNode =
21944           DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, dl, Tys, Ops,
21945                                   Ld->getMemoryVT(),
21946                                   Ld->getPointerInfo(),
21947                                   Ld->getAlignment(),
21948                                   false/*isVolatile*/, true/*ReadMem*/,
21949                                   false/*WriteMem*/);
21950
21951         // Make sure the newly-created LOAD is in the same position as Ld in
21952         // terms of dependency. We create a TokenFactor for Ld and ResNode,
21953         // and update uses of Ld's output chain to use the TokenFactor.
21954         if (Ld->hasAnyUseOfValue(1)) {
21955           SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
21956                              SDValue(Ld, 1), SDValue(ResNode.getNode(), 1));
21957           DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), NewChain);
21958           DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(Ld, 1),
21959                                  SDValue(ResNode.getNode(), 1));
21960         }
21961
21962         return DAG.getNode(ISD::BITCAST, dl, VT, ResNode);
21963       }
21964     }
21965
21966     // Emit a zeroed vector and insert the desired subvector on its
21967     // first half.
21968     SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
21969     SDValue InsV = Insert128BitVector(Zeros, V1.getOperand(0), 0, DAG, dl);
21970     return DCI.CombineTo(N, InsV);
21971   }
21972
21973   //===--------------------------------------------------------------------===//
21974   // Combine some shuffles into subvector extracts and inserts:
21975   //
21976
21977   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
21978   if (isShuffleHigh128VectorInsertLow(SVOp)) {
21979     SDValue V = Extract128BitVector(V1, NumElems/2, DAG, dl);
21980     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, 0, DAG, dl);
21981     return DCI.CombineTo(N, InsV);
21982   }
21983
21984   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
21985   if (isShuffleLow128VectorInsertHigh(SVOp)) {
21986     SDValue V = Extract128BitVector(V1, 0, DAG, dl);
21987     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, NumElems/2, DAG, dl);
21988     return DCI.CombineTo(N, InsV);
21989   }
21990
21991   return SDValue();
21992 }
21993
21994 /// \brief Combine an arbitrary chain of shuffles into a single instruction if
21995 /// possible.
21996 ///
21997 /// This is the leaf of the recursive combinine below. When we have found some
21998 /// chain of single-use x86 shuffle instructions and accumulated the combined
21999 /// shuffle mask represented by them, this will try to pattern match that mask
22000 /// into either a single instruction if there is a special purpose instruction
22001 /// for this operation, or into a PSHUFB instruction which is a fully general
22002 /// instruction but should only be used to replace chains over a certain depth.
22003 static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef<int> Mask,
22004                                    int Depth, bool HasPSHUFB, SelectionDAG &DAG,
22005                                    TargetLowering::DAGCombinerInfo &DCI,
22006                                    const X86Subtarget *Subtarget) {
22007   assert(!Mask.empty() && "Cannot combine an empty shuffle mask!");
22008
22009   // Find the operand that enters the chain. Note that multiple uses are OK
22010   // here, we're not going to remove the operand we find.
22011   SDValue Input = Op.getOperand(0);
22012   while (Input.getOpcode() == ISD::BITCAST)
22013     Input = Input.getOperand(0);
22014
22015   MVT VT = Input.getSimpleValueType();
22016   MVT RootVT = Root.getSimpleValueType();
22017   SDLoc DL(Root);
22018
22019   // Just remove no-op shuffle masks.
22020   if (Mask.size() == 1) {
22021     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Input),
22022                   /*AddTo*/ true);
22023     return true;
22024   }
22025
22026   // Use the float domain if the operand type is a floating point type.
22027   bool FloatDomain = VT.isFloatingPoint();
22028
22029   // For floating point shuffles, we don't have free copies in the shuffle
22030   // instructions or the ability to load as part of the instruction, so
22031   // canonicalize their shuffles to UNPCK or MOV variants.
22032   //
22033   // Note that even with AVX we prefer the PSHUFD form of shuffle for integer
22034   // vectors because it can have a load folded into it that UNPCK cannot. This
22035   // doesn't preclude something switching to the shorter encoding post-RA.
22036   if (FloatDomain) {
22037     if (Mask.equals(0, 0) || Mask.equals(1, 1)) {
22038       bool Lo = Mask.equals(0, 0);
22039       unsigned Shuffle;
22040       MVT ShuffleVT;
22041       // Check if we have SSE3 which will let us use MOVDDUP. That instruction
22042       // is no slower than UNPCKLPD but has the option to fold the input operand
22043       // into even an unaligned memory load.
22044       if (Lo && Subtarget->hasSSE3()) {
22045         Shuffle = X86ISD::MOVDDUP;
22046         ShuffleVT = MVT::v2f64;
22047       } else {
22048         // We have MOVLHPS and MOVHLPS throughout SSE and they encode smaller
22049         // than the UNPCK variants.
22050         Shuffle = Lo ? X86ISD::MOVLHPS : X86ISD::MOVHLPS;
22051         ShuffleVT = MVT::v4f32;
22052       }
22053       if (Depth == 1 && Root->getOpcode() == Shuffle)
22054         return false; // Nothing to do!
22055       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22056       DCI.AddToWorklist(Op.getNode());
22057       if (Shuffle == X86ISD::MOVDDUP)
22058         Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op);
22059       else
22060         Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22061       DCI.AddToWorklist(Op.getNode());
22062       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22063                     /*AddTo*/ true);
22064       return true;
22065     }
22066     if (Subtarget->hasSSE3() &&
22067         (Mask.equals(0, 0, 2, 2) || Mask.equals(1, 1, 3, 3))) {
22068       bool Lo = Mask.equals(0, 0, 2, 2);
22069       unsigned Shuffle = Lo ? X86ISD::MOVSLDUP : X86ISD::MOVSHDUP;
22070       MVT ShuffleVT = MVT::v4f32;
22071       if (Depth == 1 && Root->getOpcode() == Shuffle)
22072         return false; // Nothing to do!
22073       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22074       DCI.AddToWorklist(Op.getNode());
22075       Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op);
22076       DCI.AddToWorklist(Op.getNode());
22077       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22078                     /*AddTo*/ true);
22079       return true;
22080     }
22081     if (Mask.equals(0, 0, 1, 1) || Mask.equals(2, 2, 3, 3)) {
22082       bool Lo = Mask.equals(0, 0, 1, 1);
22083       unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
22084       MVT ShuffleVT = MVT::v4f32;
22085       if (Depth == 1 && Root->getOpcode() == Shuffle)
22086         return false; // Nothing to do!
22087       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22088       DCI.AddToWorklist(Op.getNode());
22089       Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22090       DCI.AddToWorklist(Op.getNode());
22091       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22092                     /*AddTo*/ true);
22093       return true;
22094     }
22095   }
22096
22097   // We always canonicalize the 8 x i16 and 16 x i8 shuffles into their UNPCK
22098   // variants as none of these have single-instruction variants that are
22099   // superior to the UNPCK formulation.
22100   if (!FloatDomain &&
22101       (Mask.equals(0, 0, 1, 1, 2, 2, 3, 3) ||
22102        Mask.equals(4, 4, 5, 5, 6, 6, 7, 7) ||
22103        Mask.equals(0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7) ||
22104        Mask.equals(8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15,
22105                    15))) {
22106     bool Lo = Mask[0] == 0;
22107     unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
22108     if (Depth == 1 && Root->getOpcode() == Shuffle)
22109       return false; // Nothing to do!
22110     MVT ShuffleVT;
22111     switch (Mask.size()) {
22112     case 8:
22113       ShuffleVT = MVT::v8i16;
22114       break;
22115     case 16:
22116       ShuffleVT = MVT::v16i8;
22117       break;
22118     default:
22119       llvm_unreachable("Impossible mask size!");
22120     };
22121     Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
22122     DCI.AddToWorklist(Op.getNode());
22123     Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
22124     DCI.AddToWorklist(Op.getNode());
22125     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22126                   /*AddTo*/ true);
22127     return true;
22128   }
22129
22130   // Don't try to re-form single instruction chains under any circumstances now
22131   // that we've done encoding canonicalization for them.
22132   if (Depth < 2)
22133     return false;
22134
22135   // If we have 3 or more shuffle instructions or a chain involving PSHUFB, we
22136   // can replace them with a single PSHUFB instruction profitably. Intel's
22137   // manuals suggest only using PSHUFB if doing so replacing 5 instructions, but
22138   // in practice PSHUFB tends to be *very* fast so we're more aggressive.
22139   if ((Depth >= 3 || HasPSHUFB) && Subtarget->hasSSSE3()) {
22140     SmallVector<SDValue, 16> PSHUFBMask;
22141     assert(Mask.size() <= 16 && "Can't shuffle elements smaller than bytes!");
22142     int Ratio = 16 / Mask.size();
22143     for (unsigned i = 0; i < 16; ++i) {
22144       if (Mask[i / Ratio] == SM_SentinelUndef) {
22145         PSHUFBMask.push_back(DAG.getUNDEF(MVT::i8));
22146         continue;
22147       }
22148       int M = Mask[i / Ratio] != SM_SentinelZero
22149                   ? Ratio * Mask[i / Ratio] + i % Ratio
22150                   : 255;
22151       PSHUFBMask.push_back(DAG.getConstant(M, MVT::i8));
22152     }
22153     Op = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Input);
22154     DCI.AddToWorklist(Op.getNode());
22155     SDValue PSHUFBMaskOp =
22156         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, PSHUFBMask);
22157     DCI.AddToWorklist(PSHUFBMaskOp.getNode());
22158     Op = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, Op, PSHUFBMaskOp);
22159     DCI.AddToWorklist(Op.getNode());
22160     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
22161                   /*AddTo*/ true);
22162     return true;
22163   }
22164
22165   // Failed to find any combines.
22166   return false;
22167 }
22168
22169 /// \brief Fully generic combining of x86 shuffle instructions.
22170 ///
22171 /// This should be the last combine run over the x86 shuffle instructions. Once
22172 /// they have been fully optimized, this will recursively consider all chains
22173 /// of single-use shuffle instructions, build a generic model of the cumulative
22174 /// shuffle operation, and check for simpler instructions which implement this
22175 /// operation. We use this primarily for two purposes:
22176 ///
22177 /// 1) Collapse generic shuffles to specialized single instructions when
22178 ///    equivalent. In most cases, this is just an encoding size win, but
22179 ///    sometimes we will collapse multiple generic shuffles into a single
22180 ///    special-purpose shuffle.
22181 /// 2) Look for sequences of shuffle instructions with 3 or more total
22182 ///    instructions, and replace them with the slightly more expensive SSSE3
22183 ///    PSHUFB instruction if available. We do this as the last combining step
22184 ///    to ensure we avoid using PSHUFB if we can implement the shuffle with
22185 ///    a suitable short sequence of other instructions. The PHUFB will either
22186 ///    use a register or have to read from memory and so is slightly (but only
22187 ///    slightly) more expensive than the other shuffle instructions.
22188 ///
22189 /// Because this is inherently a quadratic operation (for each shuffle in
22190 /// a chain, we recurse up the chain), the depth is limited to 8 instructions.
22191 /// This should never be an issue in practice as the shuffle lowering doesn't
22192 /// produce sequences of more than 8 instructions.
22193 ///
22194 /// FIXME: We will currently miss some cases where the redundant shuffling
22195 /// would simplify under the threshold for PSHUFB formation because of
22196 /// combine-ordering. To fix this, we should do the redundant instruction
22197 /// combining in this recursive walk.
22198 static bool combineX86ShufflesRecursively(SDValue Op, SDValue Root,
22199                                           ArrayRef<int> RootMask,
22200                                           int Depth, bool HasPSHUFB,
22201                                           SelectionDAG &DAG,
22202                                           TargetLowering::DAGCombinerInfo &DCI,
22203                                           const X86Subtarget *Subtarget) {
22204   // Bound the depth of our recursive combine because this is ultimately
22205   // quadratic in nature.
22206   if (Depth > 8)
22207     return false;
22208
22209   // Directly rip through bitcasts to find the underlying operand.
22210   while (Op.getOpcode() == ISD::BITCAST && Op.getOperand(0).hasOneUse())
22211     Op = Op.getOperand(0);
22212
22213   MVT VT = Op.getSimpleValueType();
22214   if (!VT.isVector())
22215     return false; // Bail if we hit a non-vector.
22216   // FIXME: This routine should be taught about 256-bit shuffles, or a 256-bit
22217   // version should be added.
22218   if (VT.getSizeInBits() != 128)
22219     return false;
22220
22221   assert(Root.getSimpleValueType().isVector() &&
22222          "Shuffles operate on vector types!");
22223   assert(VT.getSizeInBits() == Root.getSimpleValueType().getSizeInBits() &&
22224          "Can only combine shuffles of the same vector register size.");
22225
22226   if (!isTargetShuffle(Op.getOpcode()))
22227     return false;
22228   SmallVector<int, 16> OpMask;
22229   bool IsUnary;
22230   bool HaveMask = getTargetShuffleMask(Op.getNode(), VT, OpMask, IsUnary);
22231   // We only can combine unary shuffles which we can decode the mask for.
22232   if (!HaveMask || !IsUnary)
22233     return false;
22234
22235   assert(VT.getVectorNumElements() == OpMask.size() &&
22236          "Different mask size from vector size!");
22237   assert(((RootMask.size() > OpMask.size() &&
22238            RootMask.size() % OpMask.size() == 0) ||
22239           (OpMask.size() > RootMask.size() &&
22240            OpMask.size() % RootMask.size() == 0) ||
22241           OpMask.size() == RootMask.size()) &&
22242          "The smaller number of elements must divide the larger.");
22243   int RootRatio = std::max<int>(1, OpMask.size() / RootMask.size());
22244   int OpRatio = std::max<int>(1, RootMask.size() / OpMask.size());
22245   assert(((RootRatio == 1 && OpRatio == 1) ||
22246           (RootRatio == 1) != (OpRatio == 1)) &&
22247          "Must not have a ratio for both incoming and op masks!");
22248
22249   SmallVector<int, 16> Mask;
22250   Mask.reserve(std::max(OpMask.size(), RootMask.size()));
22251
22252   // Merge this shuffle operation's mask into our accumulated mask. Note that
22253   // this shuffle's mask will be the first applied to the input, followed by the
22254   // root mask to get us all the way to the root value arrangement. The reason
22255   // for this order is that we are recursing up the operation chain.
22256   for (int i = 0, e = std::max(OpMask.size(), RootMask.size()); i < e; ++i) {
22257     int RootIdx = i / RootRatio;
22258     if (RootMask[RootIdx] < 0) {
22259       // This is a zero or undef lane, we're done.
22260       Mask.push_back(RootMask[RootIdx]);
22261       continue;
22262     }
22263
22264     int RootMaskedIdx = RootMask[RootIdx] * RootRatio + i % RootRatio;
22265     int OpIdx = RootMaskedIdx / OpRatio;
22266     if (OpMask[OpIdx] < 0) {
22267       // The incoming lanes are zero or undef, it doesn't matter which ones we
22268       // are using.
22269       Mask.push_back(OpMask[OpIdx]);
22270       continue;
22271     }
22272
22273     // Ok, we have non-zero lanes, map them through.
22274     Mask.push_back(OpMask[OpIdx] * OpRatio +
22275                    RootMaskedIdx % OpRatio);
22276   }
22277
22278   // See if we can recurse into the operand to combine more things.
22279   switch (Op.getOpcode()) {
22280     case X86ISD::PSHUFB:
22281       HasPSHUFB = true;
22282     case X86ISD::PSHUFD:
22283     case X86ISD::PSHUFHW:
22284     case X86ISD::PSHUFLW:
22285       if (Op.getOperand(0).hasOneUse() &&
22286           combineX86ShufflesRecursively(Op.getOperand(0), Root, Mask, Depth + 1,
22287                                         HasPSHUFB, DAG, DCI, Subtarget))
22288         return true;
22289       break;
22290
22291     case X86ISD::UNPCKL:
22292     case X86ISD::UNPCKH:
22293       assert(Op.getOperand(0) == Op.getOperand(1) && "We only combine unary shuffles!");
22294       // We can't check for single use, we have to check that this shuffle is the only user.
22295       if (Op->isOnlyUserOf(Op.getOperand(0).getNode()) &&
22296           combineX86ShufflesRecursively(Op.getOperand(0), Root, Mask, Depth + 1,
22297                                         HasPSHUFB, DAG, DCI, Subtarget))
22298           return true;
22299       break;
22300   }
22301
22302   // Minor canonicalization of the accumulated shuffle mask to make it easier
22303   // to match below. All this does is detect masks with squential pairs of
22304   // elements, and shrink them to the half-width mask. It does this in a loop
22305   // so it will reduce the size of the mask to the minimal width mask which
22306   // performs an equivalent shuffle.
22307   SmallVector<int, 16> WidenedMask;
22308   while (Mask.size() > 1 && canWidenShuffleElements(Mask, WidenedMask)) {
22309     Mask = std::move(WidenedMask);
22310     WidenedMask.clear();
22311   }
22312
22313   return combineX86ShuffleChain(Op, Root, Mask, Depth, HasPSHUFB, DAG, DCI,
22314                                 Subtarget);
22315 }
22316
22317 /// \brief Get the PSHUF-style mask from PSHUF node.
22318 ///
22319 /// This is a very minor wrapper around getTargetShuffleMask to easy forming v4
22320 /// PSHUF-style masks that can be reused with such instructions.
22321 static SmallVector<int, 4> getPSHUFShuffleMask(SDValue N) {
22322   SmallVector<int, 4> Mask;
22323   bool IsUnary;
22324   bool HaveMask = getTargetShuffleMask(N.getNode(), N.getSimpleValueType(), Mask, IsUnary);
22325   (void)HaveMask;
22326   assert(HaveMask);
22327
22328   switch (N.getOpcode()) {
22329   case X86ISD::PSHUFD:
22330     return Mask;
22331   case X86ISD::PSHUFLW:
22332     Mask.resize(4);
22333     return Mask;
22334   case X86ISD::PSHUFHW:
22335     Mask.erase(Mask.begin(), Mask.begin() + 4);
22336     for (int &M : Mask)
22337       M -= 4;
22338     return Mask;
22339   default:
22340     llvm_unreachable("No valid shuffle instruction found!");
22341   }
22342 }
22343
22344 /// \brief Search for a combinable shuffle across a chain ending in pshufd.
22345 ///
22346 /// We walk up the chain and look for a combinable shuffle, skipping over
22347 /// shuffles that we could hoist this shuffle's transformation past without
22348 /// altering anything.
22349 static SDValue
22350 combineRedundantDWordShuffle(SDValue N, MutableArrayRef<int> Mask,
22351                              SelectionDAG &DAG,
22352                              TargetLowering::DAGCombinerInfo &DCI) {
22353   assert(N.getOpcode() == X86ISD::PSHUFD &&
22354          "Called with something other than an x86 128-bit half shuffle!");
22355   SDLoc DL(N);
22356
22357   // Walk up a single-use chain looking for a combinable shuffle. Keep a stack
22358   // of the shuffles in the chain so that we can form a fresh chain to replace
22359   // this one.
22360   SmallVector<SDValue, 8> Chain;
22361   SDValue V = N.getOperand(0);
22362   for (; V.hasOneUse(); V = V.getOperand(0)) {
22363     switch (V.getOpcode()) {
22364     default:
22365       return SDValue(); // Nothing combined!
22366
22367     case ISD::BITCAST:
22368       // Skip bitcasts as we always know the type for the target specific
22369       // instructions.
22370       continue;
22371
22372     case X86ISD::PSHUFD:
22373       // Found another dword shuffle.
22374       break;
22375
22376     case X86ISD::PSHUFLW:
22377       // Check that the low words (being shuffled) are the identity in the
22378       // dword shuffle, and the high words are self-contained.
22379       if (Mask[0] != 0 || Mask[1] != 1 ||
22380           !(Mask[2] >= 2 && Mask[2] < 4 && Mask[3] >= 2 && Mask[3] < 4))
22381         return SDValue();
22382
22383       Chain.push_back(V);
22384       continue;
22385
22386     case X86ISD::PSHUFHW:
22387       // Check that the high words (being shuffled) are the identity in the
22388       // dword shuffle, and the low words are self-contained.
22389       if (Mask[2] != 2 || Mask[3] != 3 ||
22390           !(Mask[0] >= 0 && Mask[0] < 2 && Mask[1] >= 0 && Mask[1] < 2))
22391         return SDValue();
22392
22393       Chain.push_back(V);
22394       continue;
22395
22396     case X86ISD::UNPCKL:
22397     case X86ISD::UNPCKH:
22398       // For either i8 -> i16 or i16 -> i32 unpacks, we can combine a dword
22399       // shuffle into a preceding word shuffle.
22400       if (V.getValueType() != MVT::v16i8 && V.getValueType() != MVT::v8i16)
22401         return SDValue();
22402
22403       // Search for a half-shuffle which we can combine with.
22404       unsigned CombineOp =
22405           V.getOpcode() == X86ISD::UNPCKL ? X86ISD::PSHUFLW : X86ISD::PSHUFHW;
22406       if (V.getOperand(0) != V.getOperand(1) ||
22407           !V->isOnlyUserOf(V.getOperand(0).getNode()))
22408         return SDValue();
22409       Chain.push_back(V);
22410       V = V.getOperand(0);
22411       do {
22412         switch (V.getOpcode()) {
22413         default:
22414           return SDValue(); // Nothing to combine.
22415
22416         case X86ISD::PSHUFLW:
22417         case X86ISD::PSHUFHW:
22418           if (V.getOpcode() == CombineOp)
22419             break;
22420
22421           Chain.push_back(V);
22422
22423           // Fallthrough!
22424         case ISD::BITCAST:
22425           V = V.getOperand(0);
22426           continue;
22427         }
22428         break;
22429       } while (V.hasOneUse());
22430       break;
22431     }
22432     // Break out of the loop if we break out of the switch.
22433     break;
22434   }
22435
22436   if (!V.hasOneUse())
22437     // We fell out of the loop without finding a viable combining instruction.
22438     return SDValue();
22439
22440   // Merge this node's mask and our incoming mask.
22441   SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22442   for (int &M : Mask)
22443     M = VMask[M];
22444   V = DAG.getNode(V.getOpcode(), DL, V.getValueType(), V.getOperand(0),
22445                   getV4X86ShuffleImm8ForMask(Mask, DAG));
22446
22447   // Rebuild the chain around this new shuffle.
22448   while (!Chain.empty()) {
22449     SDValue W = Chain.pop_back_val();
22450
22451     if (V.getValueType() != W.getOperand(0).getValueType())
22452       V = DAG.getNode(ISD::BITCAST, DL, W.getOperand(0).getValueType(), V);
22453
22454     switch (W.getOpcode()) {
22455     default:
22456       llvm_unreachable("Only PSHUF and UNPCK instructions get here!");
22457
22458     case X86ISD::UNPCKL:
22459     case X86ISD::UNPCKH:
22460       V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, V);
22461       break;
22462
22463     case X86ISD::PSHUFD:
22464     case X86ISD::PSHUFLW:
22465     case X86ISD::PSHUFHW:
22466       V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, W.getOperand(1));
22467       break;
22468     }
22469   }
22470   if (V.getValueType() != N.getValueType())
22471     V = DAG.getNode(ISD::BITCAST, DL, N.getValueType(), V);
22472
22473   // Return the new chain to replace N.
22474   return V;
22475 }
22476
22477 /// \brief Search for a combinable shuffle across a chain ending in pshuflw or pshufhw.
22478 ///
22479 /// We walk up the chain, skipping shuffles of the other half and looking
22480 /// through shuffles which switch halves trying to find a shuffle of the same
22481 /// pair of dwords.
22482 static bool combineRedundantHalfShuffle(SDValue N, MutableArrayRef<int> Mask,
22483                                         SelectionDAG &DAG,
22484                                         TargetLowering::DAGCombinerInfo &DCI) {
22485   assert(
22486       (N.getOpcode() == X86ISD::PSHUFLW || N.getOpcode() == X86ISD::PSHUFHW) &&
22487       "Called with something other than an x86 128-bit half shuffle!");
22488   SDLoc DL(N);
22489   unsigned CombineOpcode = N.getOpcode();
22490
22491   // Walk up a single-use chain looking for a combinable shuffle.
22492   SDValue V = N.getOperand(0);
22493   for (; V.hasOneUse(); V = V.getOperand(0)) {
22494     switch (V.getOpcode()) {
22495     default:
22496       return false; // Nothing combined!
22497
22498     case ISD::BITCAST:
22499       // Skip bitcasts as we always know the type for the target specific
22500       // instructions.
22501       continue;
22502
22503     case X86ISD::PSHUFLW:
22504     case X86ISD::PSHUFHW:
22505       if (V.getOpcode() == CombineOpcode)
22506         break;
22507
22508       // Other-half shuffles are no-ops.
22509       continue;
22510     }
22511     // Break out of the loop if we break out of the switch.
22512     break;
22513   }
22514
22515   if (!V.hasOneUse())
22516     // We fell out of the loop without finding a viable combining instruction.
22517     return false;
22518
22519   // Combine away the bottom node as its shuffle will be accumulated into
22520   // a preceding shuffle.
22521   DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
22522
22523   // Record the old value.
22524   SDValue Old = V;
22525
22526   // Merge this node's mask and our incoming mask (adjusted to account for all
22527   // the pshufd instructions encountered).
22528   SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22529   for (int &M : Mask)
22530     M = VMask[M];
22531   V = DAG.getNode(V.getOpcode(), DL, MVT::v8i16, V.getOperand(0),
22532                   getV4X86ShuffleImm8ForMask(Mask, DAG));
22533
22534   // Check that the shuffles didn't cancel each other out. If not, we need to
22535   // combine to the new one.
22536   if (Old != V)
22537     // Replace the combinable shuffle with the combined one, updating all users
22538     // so that we re-evaluate the chain here.
22539     DCI.CombineTo(Old.getNode(), V, /*AddTo*/ true);
22540
22541   return true;
22542 }
22543
22544 /// \brief Try to combine x86 target specific shuffles.
22545 static SDValue PerformTargetShuffleCombine(SDValue N, SelectionDAG &DAG,
22546                                            TargetLowering::DAGCombinerInfo &DCI,
22547                                            const X86Subtarget *Subtarget) {
22548   SDLoc DL(N);
22549   MVT VT = N.getSimpleValueType();
22550   SmallVector<int, 4> Mask;
22551
22552   switch (N.getOpcode()) {
22553   case X86ISD::PSHUFD:
22554   case X86ISD::PSHUFLW:
22555   case X86ISD::PSHUFHW:
22556     Mask = getPSHUFShuffleMask(N);
22557     assert(Mask.size() == 4);
22558     break;
22559   default:
22560     return SDValue();
22561   }
22562
22563   // Nuke no-op shuffles that show up after combining.
22564   if (isNoopShuffleMask(Mask))
22565     return DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
22566
22567   // Look for simplifications involving one or two shuffle instructions.
22568   SDValue V = N.getOperand(0);
22569   switch (N.getOpcode()) {
22570   default:
22571     break;
22572   case X86ISD::PSHUFLW:
22573   case X86ISD::PSHUFHW:
22574     assert(VT == MVT::v8i16);
22575     (void)VT;
22576
22577     if (combineRedundantHalfShuffle(N, Mask, DAG, DCI))
22578       return SDValue(); // We combined away this shuffle, so we're done.
22579
22580     // See if this reduces to a PSHUFD which is no more expensive and can
22581     // combine with more operations. Note that it has to at least flip the
22582     // dwords as otherwise it would have been removed as a no-op.
22583     if (Mask[0] == 2 && Mask[1] == 3 && Mask[2] == 0 && Mask[3] == 1) {
22584       int DMask[] = {0, 1, 2, 3};
22585       int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2;
22586       DMask[DOffset + 0] = DOffset + 1;
22587       DMask[DOffset + 1] = DOffset + 0;
22588       V = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V);
22589       DCI.AddToWorklist(V.getNode());
22590       V = DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V,
22591                       getV4X86ShuffleImm8ForMask(DMask, DAG));
22592       DCI.AddToWorklist(V.getNode());
22593       return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
22594     }
22595
22596     // Look for shuffle patterns which can be implemented as a single unpack.
22597     // FIXME: This doesn't handle the location of the PSHUFD generically, and
22598     // only works when we have a PSHUFD followed by two half-shuffles.
22599     if (Mask[0] == Mask[1] && Mask[2] == Mask[3] &&
22600         (V.getOpcode() == X86ISD::PSHUFLW ||
22601          V.getOpcode() == X86ISD::PSHUFHW) &&
22602         V.getOpcode() != N.getOpcode() &&
22603         V.hasOneUse()) {
22604       SDValue D = V.getOperand(0);
22605       while (D.getOpcode() == ISD::BITCAST && D.hasOneUse())
22606         D = D.getOperand(0);
22607       if (D.getOpcode() == X86ISD::PSHUFD && D.hasOneUse()) {
22608         SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
22609         SmallVector<int, 4> DMask = getPSHUFShuffleMask(D);
22610         int NOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 4;
22611         int VOffset = V.getOpcode() == X86ISD::PSHUFLW ? 0 : 4;
22612         int WordMask[8];
22613         for (int i = 0; i < 4; ++i) {
22614           WordMask[i + NOffset] = Mask[i] + NOffset;
22615           WordMask[i + VOffset] = VMask[i] + VOffset;
22616         }
22617         // Map the word mask through the DWord mask.
22618         int MappedMask[8];
22619         for (int i = 0; i < 8; ++i)
22620           MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2;
22621         const int UnpackLoMask[] = {0, 0, 1, 1, 2, 2, 3, 3};
22622         const int UnpackHiMask[] = {4, 4, 5, 5, 6, 6, 7, 7};
22623         if (std::equal(std::begin(MappedMask), std::end(MappedMask),
22624                        std::begin(UnpackLoMask)) ||
22625             std::equal(std::begin(MappedMask), std::end(MappedMask),
22626                        std::begin(UnpackHiMask))) {
22627           // We can replace all three shuffles with an unpack.
22628           V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, D.getOperand(0));
22629           DCI.AddToWorklist(V.getNode());
22630           return DAG.getNode(MappedMask[0] == 0 ? X86ISD::UNPCKL
22631                                                 : X86ISD::UNPCKH,
22632                              DL, MVT::v8i16, V, V);
22633         }
22634       }
22635     }
22636
22637     break;
22638
22639   case X86ISD::PSHUFD:
22640     if (SDValue NewN = combineRedundantDWordShuffle(N, Mask, DAG, DCI))
22641       return NewN;
22642
22643     break;
22644   }
22645
22646   return SDValue();
22647 }
22648
22649 /// \brief Try to combine a shuffle into a target-specific add-sub node.
22650 ///
22651 /// We combine this directly on the abstract vector shuffle nodes so it is
22652 /// easier to generically match. We also insert dummy vector shuffle nodes for
22653 /// the operands which explicitly discard the lanes which are unused by this
22654 /// operation to try to flow through the rest of the combiner the fact that
22655 /// they're unused.
22656 static SDValue combineShuffleToAddSub(SDNode *N, SelectionDAG &DAG) {
22657   SDLoc DL(N);
22658   EVT VT = N->getValueType(0);
22659
22660   // We only handle target-independent shuffles.
22661   // FIXME: It would be easy and harmless to use the target shuffle mask
22662   // extraction tool to support more.
22663   if (N->getOpcode() != ISD::VECTOR_SHUFFLE)
22664     return SDValue();
22665
22666   auto *SVN = cast<ShuffleVectorSDNode>(N);
22667   ArrayRef<int> Mask = SVN->getMask();
22668   SDValue V1 = N->getOperand(0);
22669   SDValue V2 = N->getOperand(1);
22670
22671   // We require the first shuffle operand to be the SUB node, and the second to
22672   // be the ADD node.
22673   // FIXME: We should support the commuted patterns.
22674   if (V1->getOpcode() != ISD::FSUB || V2->getOpcode() != ISD::FADD)
22675     return SDValue();
22676
22677   // If there are other uses of these operations we can't fold them.
22678   if (!V1->hasOneUse() || !V2->hasOneUse())
22679     return SDValue();
22680
22681   // Ensure that both operations have the same operands. Note that we can
22682   // commute the FADD operands.
22683   SDValue LHS = V1->getOperand(0), RHS = V1->getOperand(1);
22684   if ((V2->getOperand(0) != LHS || V2->getOperand(1) != RHS) &&
22685       (V2->getOperand(0) != RHS || V2->getOperand(1) != LHS))
22686     return SDValue();
22687
22688   // We're looking for blends between FADD and FSUB nodes. We insist on these
22689   // nodes being lined up in a specific expected pattern.
22690   if (!(isShuffleEquivalent(Mask, 0, 3) ||
22691         isShuffleEquivalent(Mask, 0, 5, 2, 7) ||
22692         isShuffleEquivalent(Mask, 0, 9, 2, 11, 4, 13, 6, 15)))
22693     return SDValue();
22694
22695   // Only specific types are legal at this point, assert so we notice if and
22696   // when these change.
22697   assert((VT == MVT::v4f32 || VT == MVT::v2f64 || VT == MVT::v8f32 ||
22698           VT == MVT::v4f64) &&
22699          "Unknown vector type encountered!");
22700
22701   return DAG.getNode(X86ISD::ADDSUB, DL, VT, LHS, RHS);
22702 }
22703
22704 /// PerformShuffleCombine - Performs several different shuffle combines.
22705 static SDValue PerformShuffleCombine(SDNode *N, SelectionDAG &DAG,
22706                                      TargetLowering::DAGCombinerInfo &DCI,
22707                                      const X86Subtarget *Subtarget) {
22708   SDLoc dl(N);
22709   SDValue N0 = N->getOperand(0);
22710   SDValue N1 = N->getOperand(1);
22711   EVT VT = N->getValueType(0);
22712
22713   // Don't create instructions with illegal types after legalize types has run.
22714   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
22715   if (!DCI.isBeforeLegalize() && !TLI.isTypeLegal(VT.getVectorElementType()))
22716     return SDValue();
22717
22718   // If we have legalized the vector types, look for blends of FADD and FSUB
22719   // nodes that we can fuse into an ADDSUB node.
22720   if (TLI.isTypeLegal(VT) && Subtarget->hasSSE3())
22721     if (SDValue AddSub = combineShuffleToAddSub(N, DAG))
22722       return AddSub;
22723
22724   // Combine 256-bit vector shuffles. This is only profitable when in AVX mode
22725   if (Subtarget->hasFp256() && VT.is256BitVector() &&
22726       N->getOpcode() == ISD::VECTOR_SHUFFLE)
22727     return PerformShuffleCombine256(N, DAG, DCI, Subtarget);
22728
22729   // During Type Legalization, when promoting illegal vector types,
22730   // the backend might introduce new shuffle dag nodes and bitcasts.
22731   //
22732   // This code performs the following transformation:
22733   // fold: (shuffle (bitcast (BINOP A, B)), Undef, <Mask>) ->
22734   //       (shuffle (BINOP (bitcast A), (bitcast B)), Undef, <Mask>)
22735   //
22736   // We do this only if both the bitcast and the BINOP dag nodes have
22737   // one use. Also, perform this transformation only if the new binary
22738   // operation is legal. This is to avoid introducing dag nodes that
22739   // potentially need to be further expanded (or custom lowered) into a
22740   // less optimal sequence of dag nodes.
22741   if (!DCI.isBeforeLegalize() && DCI.isBeforeLegalizeOps() &&
22742       N1.getOpcode() == ISD::UNDEF && N0.hasOneUse() &&
22743       N0.getOpcode() == ISD::BITCAST) {
22744     SDValue BC0 = N0.getOperand(0);
22745     EVT SVT = BC0.getValueType();
22746     unsigned Opcode = BC0.getOpcode();
22747     unsigned NumElts = VT.getVectorNumElements();
22748
22749     if (BC0.hasOneUse() && SVT.isVector() &&
22750         SVT.getVectorNumElements() * 2 == NumElts &&
22751         TLI.isOperationLegal(Opcode, VT)) {
22752       bool CanFold = false;
22753       switch (Opcode) {
22754       default : break;
22755       case ISD::ADD :
22756       case ISD::FADD :
22757       case ISD::SUB :
22758       case ISD::FSUB :
22759       case ISD::MUL :
22760       case ISD::FMUL :
22761         CanFold = true;
22762       }
22763
22764       unsigned SVTNumElts = SVT.getVectorNumElements();
22765       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
22766       for (unsigned i = 0, e = SVTNumElts; i != e && CanFold; ++i)
22767         CanFold = SVOp->getMaskElt(i) == (int)(i * 2);
22768       for (unsigned i = SVTNumElts, e = NumElts; i != e && CanFold; ++i)
22769         CanFold = SVOp->getMaskElt(i) < 0;
22770
22771       if (CanFold) {
22772         SDValue BC00 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(0));
22773         SDValue BC01 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(1));
22774         SDValue NewBinOp = DAG.getNode(BC0.getOpcode(), dl, VT, BC00, BC01);
22775         return DAG.getVectorShuffle(VT, dl, NewBinOp, N1, &SVOp->getMask()[0]);
22776       }
22777     }
22778   }
22779
22780   // Only handle 128 wide vector from here on.
22781   if (!VT.is128BitVector())
22782     return SDValue();
22783
22784   // Combine a vector_shuffle that is equal to build_vector load1, load2, load3,
22785   // load4, <0, 1, 2, 3> into a 128-bit load if the load addresses are
22786   // consecutive, non-overlapping, and in the right order.
22787   SmallVector<SDValue, 16> Elts;
22788   for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
22789     Elts.push_back(getShuffleScalarElt(N, i, DAG, 0));
22790
22791   SDValue LD = EltsFromConsecutiveLoads(VT, Elts, dl, DAG, true);
22792   if (LD.getNode())
22793     return LD;
22794
22795   if (isTargetShuffle(N->getOpcode())) {
22796     SDValue Shuffle =
22797         PerformTargetShuffleCombine(SDValue(N, 0), DAG, DCI, Subtarget);
22798     if (Shuffle.getNode())
22799       return Shuffle;
22800
22801     // Try recursively combining arbitrary sequences of x86 shuffle
22802     // instructions into higher-order shuffles. We do this after combining
22803     // specific PSHUF instruction sequences into their minimal form so that we
22804     // can evaluate how many specialized shuffle instructions are involved in
22805     // a particular chain.
22806     SmallVector<int, 1> NonceMask; // Just a placeholder.
22807     NonceMask.push_back(0);
22808     if (combineX86ShufflesRecursively(SDValue(N, 0), SDValue(N, 0), NonceMask,
22809                                       /*Depth*/ 1, /*HasPSHUFB*/ false, DAG,
22810                                       DCI, Subtarget))
22811       return SDValue(); // This routine will use CombineTo to replace N.
22812   }
22813
22814   return SDValue();
22815 }
22816
22817 /// PerformTruncateCombine - Converts truncate operation to
22818 /// a sequence of vector shuffle operations.
22819 /// It is possible when we truncate 256-bit vector to 128-bit vector
22820 static SDValue PerformTruncateCombine(SDNode *N, SelectionDAG &DAG,
22821                                       TargetLowering::DAGCombinerInfo &DCI,
22822                                       const X86Subtarget *Subtarget)  {
22823   return SDValue();
22824 }
22825
22826 /// XFormVExtractWithShuffleIntoLoad - Check if a vector extract from a target
22827 /// specific shuffle of a load can be folded into a single element load.
22828 /// Similar handling for VECTOR_SHUFFLE is performed by DAGCombiner, but
22829 /// shuffles have been custom lowered so we need to handle those here.
22830 static SDValue XFormVExtractWithShuffleIntoLoad(SDNode *N, SelectionDAG &DAG,
22831                                          TargetLowering::DAGCombinerInfo &DCI) {
22832   if (DCI.isBeforeLegalizeOps())
22833     return SDValue();
22834
22835   SDValue InVec = N->getOperand(0);
22836   SDValue EltNo = N->getOperand(1);
22837
22838   if (!isa<ConstantSDNode>(EltNo))
22839     return SDValue();
22840
22841   EVT OriginalVT = InVec.getValueType();
22842
22843   if (InVec.getOpcode() == ISD::BITCAST) {
22844     // Don't duplicate a load with other uses.
22845     if (!InVec.hasOneUse())
22846       return SDValue();
22847     EVT BCVT = InVec.getOperand(0).getValueType();
22848     if (BCVT.getVectorNumElements() != OriginalVT.getVectorNumElements())
22849       return SDValue();
22850     InVec = InVec.getOperand(0);
22851   }
22852
22853   EVT CurrentVT = InVec.getValueType();
22854
22855   if (!isTargetShuffle(InVec.getOpcode()))
22856     return SDValue();
22857
22858   // Don't duplicate a load with other uses.
22859   if (!InVec.hasOneUse())
22860     return SDValue();
22861
22862   SmallVector<int, 16> ShuffleMask;
22863   bool UnaryShuffle;
22864   if (!getTargetShuffleMask(InVec.getNode(), CurrentVT.getSimpleVT(),
22865                             ShuffleMask, UnaryShuffle))
22866     return SDValue();
22867
22868   // Select the input vector, guarding against out of range extract vector.
22869   unsigned NumElems = CurrentVT.getVectorNumElements();
22870   int Elt = cast<ConstantSDNode>(EltNo)->getZExtValue();
22871   int Idx = (Elt > (int)NumElems) ? -1 : ShuffleMask[Elt];
22872   SDValue LdNode = (Idx < (int)NumElems) ? InVec.getOperand(0)
22873                                          : InVec.getOperand(1);
22874
22875   // If inputs to shuffle are the same for both ops, then allow 2 uses
22876   unsigned AllowedUses = InVec.getNumOperands() > 1 &&
22877                          InVec.getOperand(0) == InVec.getOperand(1) ? 2 : 1;
22878
22879   if (LdNode.getOpcode() == ISD::BITCAST) {
22880     // Don't duplicate a load with other uses.
22881     if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
22882       return SDValue();
22883
22884     AllowedUses = 1; // only allow 1 load use if we have a bitcast
22885     LdNode = LdNode.getOperand(0);
22886   }
22887
22888   if (!ISD::isNormalLoad(LdNode.getNode()))
22889     return SDValue();
22890
22891   LoadSDNode *LN0 = cast<LoadSDNode>(LdNode);
22892
22893   if (!LN0 ||!LN0->hasNUsesOfValue(AllowedUses, 0) || LN0->isVolatile())
22894     return SDValue();
22895
22896   EVT EltVT = N->getValueType(0);
22897   // If there's a bitcast before the shuffle, check if the load type and
22898   // alignment is valid.
22899   unsigned Align = LN0->getAlignment();
22900   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
22901   unsigned NewAlign = TLI.getDataLayout()->getABITypeAlignment(
22902       EltVT.getTypeForEVT(*DAG.getContext()));
22903
22904   if (NewAlign > Align || !TLI.isOperationLegalOrCustom(ISD::LOAD, EltVT))
22905     return SDValue();
22906
22907   // All checks match so transform back to vector_shuffle so that DAG combiner
22908   // can finish the job
22909   SDLoc dl(N);
22910
22911   // Create shuffle node taking into account the case that its a unary shuffle
22912   SDValue Shuffle = (UnaryShuffle) ? DAG.getUNDEF(CurrentVT)
22913                                    : InVec.getOperand(1);
22914   Shuffle = DAG.getVectorShuffle(CurrentVT, dl,
22915                                  InVec.getOperand(0), Shuffle,
22916                                  &ShuffleMask[0]);
22917   Shuffle = DAG.getNode(ISD::BITCAST, dl, OriginalVT, Shuffle);
22918   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
22919                      EltNo);
22920 }
22921
22922 /// PerformEXTRACT_VECTOR_ELTCombine - Detect vector gather/scatter index
22923 /// generation and convert it from being a bunch of shuffles and extracts
22924 /// into a somewhat faster sequence. For i686, the best sequence is apparently
22925 /// storing the value and loading scalars back, while for x64 we should
22926 /// use 64-bit extracts and shifts.
22927 static SDValue PerformEXTRACT_VECTOR_ELTCombine(SDNode *N, SelectionDAG &DAG,
22928                                          TargetLowering::DAGCombinerInfo &DCI) {
22929   SDValue NewOp = XFormVExtractWithShuffleIntoLoad(N, DAG, DCI);
22930   if (NewOp.getNode())
22931     return NewOp;
22932
22933   SDValue InputVector = N->getOperand(0);
22934
22935   // Detect whether we are trying to convert from mmx to i32 and the bitcast
22936   // from mmx to v2i32 has a single usage.
22937   if (InputVector.getNode()->getOpcode() == llvm::ISD::BITCAST &&
22938       InputVector.getNode()->getOperand(0).getValueType() == MVT::x86mmx &&
22939       InputVector.hasOneUse() && N->getValueType(0) == MVT::i32)
22940     return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
22941                        N->getValueType(0),
22942                        InputVector.getNode()->getOperand(0));
22943
22944   // Only operate on vectors of 4 elements, where the alternative shuffling
22945   // gets to be more expensive.
22946   if (InputVector.getValueType() != MVT::v4i32)
22947     return SDValue();
22948
22949   // Check whether every use of InputVector is an EXTRACT_VECTOR_ELT with a
22950   // single use which is a sign-extend or zero-extend, and all elements are
22951   // used.
22952   SmallVector<SDNode *, 4> Uses;
22953   unsigned ExtractedElements = 0;
22954   for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
22955        UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
22956     if (UI.getUse().getResNo() != InputVector.getResNo())
22957       return SDValue();
22958
22959     SDNode *Extract = *UI;
22960     if (Extract->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
22961       return SDValue();
22962
22963     if (Extract->getValueType(0) != MVT::i32)
22964       return SDValue();
22965     if (!Extract->hasOneUse())
22966       return SDValue();
22967     if (Extract->use_begin()->getOpcode() != ISD::SIGN_EXTEND &&
22968         Extract->use_begin()->getOpcode() != ISD::ZERO_EXTEND)
22969       return SDValue();
22970     if (!isa<ConstantSDNode>(Extract->getOperand(1)))
22971       return SDValue();
22972
22973     // Record which element was extracted.
22974     ExtractedElements |=
22975       1 << cast<ConstantSDNode>(Extract->getOperand(1))->getZExtValue();
22976
22977     Uses.push_back(Extract);
22978   }
22979
22980   // If not all the elements were used, this may not be worthwhile.
22981   if (ExtractedElements != 15)
22982     return SDValue();
22983
22984   // Ok, we've now decided to do the transformation.
22985   // If 64-bit shifts are legal, use the extract-shift sequence,
22986   // otherwise bounce the vector off the cache.
22987   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
22988   SDValue Vals[4];
22989   SDLoc dl(InputVector);
22990
22991   if (TLI.isOperationLegal(ISD::SRA, MVT::i64)) {
22992     SDValue Cst = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, InputVector);
22993     EVT VecIdxTy = DAG.getTargetLoweringInfo().getVectorIdxTy();
22994     SDValue BottomHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Cst,
22995       DAG.getConstant(0, VecIdxTy));
22996     SDValue TopHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Cst,
22997       DAG.getConstant(1, VecIdxTy));
22998
22999     SDValue ShAmt = DAG.getConstant(32,
23000       DAG.getTargetLoweringInfo().getShiftAmountTy(MVT::i64));
23001     Vals[0] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BottomHalf);
23002     Vals[1] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
23003       DAG.getNode(ISD::SRA, dl, MVT::i64, BottomHalf, ShAmt));
23004     Vals[2] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, TopHalf);
23005     Vals[3] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
23006       DAG.getNode(ISD::SRA, dl, MVT::i64, TopHalf, ShAmt));
23007   } else {
23008     // Store the value to a temporary stack slot.
23009     SDValue StackPtr = DAG.CreateStackTemporary(InputVector.getValueType());
23010     SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, InputVector, StackPtr,
23011       MachinePointerInfo(), false, false, 0);
23012
23013     EVT ElementType = InputVector.getValueType().getVectorElementType();
23014     unsigned EltSize = ElementType.getSizeInBits() / 8;
23015
23016     // Replace each use (extract) with a load of the appropriate element.
23017     for (unsigned i = 0; i < 4; ++i) {
23018       uint64_t Offset = EltSize * i;
23019       SDValue OffsetVal = DAG.getConstant(Offset, TLI.getPointerTy());
23020
23021       SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
23022                                        StackPtr, OffsetVal);
23023
23024       // Load the scalar.
23025       Vals[i] = DAG.getLoad(ElementType, dl, Ch,
23026                             ScalarAddr, MachinePointerInfo(),
23027                             false, false, false, 0);
23028
23029     }
23030   }
23031
23032   // Replace the extracts
23033   for (SmallVectorImpl<SDNode *>::iterator UI = Uses.begin(),
23034     UE = Uses.end(); UI != UE; ++UI) {
23035     SDNode *Extract = *UI;
23036
23037     SDValue Idx = Extract->getOperand(1);
23038     uint64_t IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
23039     DAG.ReplaceAllUsesOfValueWith(SDValue(Extract, 0), Vals[IdxVal]);
23040   }
23041
23042   // The replacement was made in place; don't return anything.
23043   return SDValue();
23044 }
23045
23046 /// \brief Matches a VSELECT onto min/max or return 0 if the node doesn't match.
23047 static std::pair<unsigned, bool>
23048 matchIntegerMINMAX(SDValue Cond, EVT VT, SDValue LHS, SDValue RHS,
23049                    SelectionDAG &DAG, const X86Subtarget *Subtarget) {
23050   if (!VT.isVector())
23051     return std::make_pair(0, false);
23052
23053   bool NeedSplit = false;
23054   switch (VT.getSimpleVT().SimpleTy) {
23055   default: return std::make_pair(0, false);
23056   case MVT::v4i64:
23057   case MVT::v2i64:
23058     if (!Subtarget->hasVLX())
23059       return std::make_pair(0, false);
23060     break;
23061   case MVT::v64i8:
23062   case MVT::v32i16:
23063     if (!Subtarget->hasBWI())
23064       return std::make_pair(0, false);
23065     break;
23066   case MVT::v16i32:
23067   case MVT::v8i64:
23068     if (!Subtarget->hasAVX512())
23069       return std::make_pair(0, false);
23070     break;
23071   case MVT::v32i8:
23072   case MVT::v16i16:
23073   case MVT::v8i32:
23074     if (!Subtarget->hasAVX2())
23075       NeedSplit = true;
23076     if (!Subtarget->hasAVX())
23077       return std::make_pair(0, false);
23078     break;
23079   case MVT::v16i8:
23080   case MVT::v8i16:
23081   case MVT::v4i32:
23082     if (!Subtarget->hasSSE2())
23083       return std::make_pair(0, false);
23084   }
23085
23086   // SSE2 has only a small subset of the operations.
23087   bool hasUnsigned = Subtarget->hasSSE41() ||
23088                      (Subtarget->hasSSE2() && VT == MVT::v16i8);
23089   bool hasSigned = Subtarget->hasSSE41() ||
23090                    (Subtarget->hasSSE2() && VT == MVT::v8i16);
23091
23092   ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23093
23094   unsigned Opc = 0;
23095   // Check for x CC y ? x : y.
23096   if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23097       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23098     switch (CC) {
23099     default: break;
23100     case ISD::SETULT:
23101     case ISD::SETULE:
23102       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
23103     case ISD::SETUGT:
23104     case ISD::SETUGE:
23105       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
23106     case ISD::SETLT:
23107     case ISD::SETLE:
23108       Opc = hasSigned ? X86ISD::SMIN : 0; break;
23109     case ISD::SETGT:
23110     case ISD::SETGE:
23111       Opc = hasSigned ? X86ISD::SMAX : 0; break;
23112     }
23113   // Check for x CC y ? y : x -- a min/max with reversed arms.
23114   } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
23115              DAG.isEqualTo(RHS, Cond.getOperand(0))) {
23116     switch (CC) {
23117     default: break;
23118     case ISD::SETULT:
23119     case ISD::SETULE:
23120       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
23121     case ISD::SETUGT:
23122     case ISD::SETUGE:
23123       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
23124     case ISD::SETLT:
23125     case ISD::SETLE:
23126       Opc = hasSigned ? X86ISD::SMAX : 0; break;
23127     case ISD::SETGT:
23128     case ISD::SETGE:
23129       Opc = hasSigned ? X86ISD::SMIN : 0; break;
23130     }
23131   }
23132
23133   return std::make_pair(Opc, NeedSplit);
23134 }
23135
23136 static SDValue
23137 transformVSELECTtoBlendVECTOR_SHUFFLE(SDNode *N, SelectionDAG &DAG,
23138                                       const X86Subtarget *Subtarget) {
23139   SDLoc dl(N);
23140   SDValue Cond = N->getOperand(0);
23141   SDValue LHS = N->getOperand(1);
23142   SDValue RHS = N->getOperand(2);
23143
23144   if (Cond.getOpcode() == ISD::SIGN_EXTEND) {
23145     SDValue CondSrc = Cond->getOperand(0);
23146     if (CondSrc->getOpcode() == ISD::SIGN_EXTEND_INREG)
23147       Cond = CondSrc->getOperand(0);
23148   }
23149
23150   if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
23151     return SDValue();
23152
23153   // A vselect where all conditions and data are constants can be optimized into
23154   // a single vector load by SelectionDAGLegalize::ExpandBUILD_VECTOR().
23155   if (ISD::isBuildVectorOfConstantSDNodes(LHS.getNode()) &&
23156       ISD::isBuildVectorOfConstantSDNodes(RHS.getNode()))
23157     return SDValue();
23158
23159   unsigned MaskValue = 0;
23160   if (!BUILD_VECTORtoBlendMask(cast<BuildVectorSDNode>(Cond), MaskValue))
23161     return SDValue();
23162
23163   MVT VT = N->getSimpleValueType(0);
23164   unsigned NumElems = VT.getVectorNumElements();
23165   SmallVector<int, 8> ShuffleMask(NumElems, -1);
23166   for (unsigned i = 0; i < NumElems; ++i) {
23167     // Be sure we emit undef where we can.
23168     if (Cond.getOperand(i)->getOpcode() == ISD::UNDEF)
23169       ShuffleMask[i] = -1;
23170     else
23171       ShuffleMask[i] = i + NumElems * ((MaskValue >> i) & 1);
23172   }
23173
23174   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23175   if (!TLI.isShuffleMaskLegal(ShuffleMask, VT))
23176     return SDValue();
23177   return DAG.getVectorShuffle(VT, dl, LHS, RHS, &ShuffleMask[0]);
23178 }
23179
23180 /// PerformSELECTCombine - Do target-specific dag combines on SELECT and VSELECT
23181 /// nodes.
23182 static SDValue PerformSELECTCombine(SDNode *N, SelectionDAG &DAG,
23183                                     TargetLowering::DAGCombinerInfo &DCI,
23184                                     const X86Subtarget *Subtarget) {
23185   SDLoc DL(N);
23186   SDValue Cond = N->getOperand(0);
23187   // Get the LHS/RHS of the select.
23188   SDValue LHS = N->getOperand(1);
23189   SDValue RHS = N->getOperand(2);
23190   EVT VT = LHS.getValueType();
23191   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23192
23193   // If we have SSE[12] support, try to form min/max nodes. SSE min/max
23194   // instructions match the semantics of the common C idiom x<y?x:y but not
23195   // x<=y?x:y, because of how they handle negative zero (which can be
23196   // ignored in unsafe-math mode).
23197   // We also try to create v2f32 min/max nodes, which we later widen to v4f32.
23198   if (Cond.getOpcode() == ISD::SETCC && VT.isFloatingPoint() &&
23199       VT != MVT::f80 && (TLI.isTypeLegal(VT) || VT == MVT::v2f32) &&
23200       (Subtarget->hasSSE2() ||
23201        (Subtarget->hasSSE1() && VT.getScalarType() == MVT::f32))) {
23202     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23203
23204     unsigned Opcode = 0;
23205     // Check for x CC y ? x : y.
23206     if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23207         DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23208       switch (CC) {
23209       default: break;
23210       case ISD::SETULT:
23211         // Converting this to a min would handle NaNs incorrectly, and swapping
23212         // the operands would cause it to handle comparisons between positive
23213         // and negative zero incorrectly.
23214         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
23215           if (!DAG.getTarget().Options.UnsafeFPMath &&
23216               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
23217             break;
23218           std::swap(LHS, RHS);
23219         }
23220         Opcode = X86ISD::FMIN;
23221         break;
23222       case ISD::SETOLE:
23223         // Converting this to a min would handle comparisons between positive
23224         // and negative zero incorrectly.
23225         if (!DAG.getTarget().Options.UnsafeFPMath &&
23226             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
23227           break;
23228         Opcode = X86ISD::FMIN;
23229         break;
23230       case ISD::SETULE:
23231         // Converting this to a min would handle both negative zeros and NaNs
23232         // incorrectly, but we can swap the operands to fix both.
23233         std::swap(LHS, RHS);
23234       case ISD::SETOLT:
23235       case ISD::SETLT:
23236       case ISD::SETLE:
23237         Opcode = X86ISD::FMIN;
23238         break;
23239
23240       case ISD::SETOGE:
23241         // Converting this to a max would handle comparisons between positive
23242         // and negative zero incorrectly.
23243         if (!DAG.getTarget().Options.UnsafeFPMath &&
23244             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
23245           break;
23246         Opcode = X86ISD::FMAX;
23247         break;
23248       case ISD::SETUGT:
23249         // Converting this to a max would handle NaNs incorrectly, and swapping
23250         // the operands would cause it to handle comparisons between positive
23251         // and negative zero incorrectly.
23252         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
23253           if (!DAG.getTarget().Options.UnsafeFPMath &&
23254               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
23255             break;
23256           std::swap(LHS, RHS);
23257         }
23258         Opcode = X86ISD::FMAX;
23259         break;
23260       case ISD::SETUGE:
23261         // Converting this to a max would handle both negative zeros and NaNs
23262         // incorrectly, but we can swap the operands to fix both.
23263         std::swap(LHS, RHS);
23264       case ISD::SETOGT:
23265       case ISD::SETGT:
23266       case ISD::SETGE:
23267         Opcode = X86ISD::FMAX;
23268         break;
23269       }
23270     // Check for x CC y ? y : x -- a min/max with reversed arms.
23271     } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
23272                DAG.isEqualTo(RHS, Cond.getOperand(0))) {
23273       switch (CC) {
23274       default: break;
23275       case ISD::SETOGE:
23276         // Converting this to a min would handle comparisons between positive
23277         // and negative zero incorrectly, and swapping the operands would
23278         // cause it to handle NaNs incorrectly.
23279         if (!DAG.getTarget().Options.UnsafeFPMath &&
23280             !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS))) {
23281           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23282             break;
23283           std::swap(LHS, RHS);
23284         }
23285         Opcode = X86ISD::FMIN;
23286         break;
23287       case ISD::SETUGT:
23288         // Converting this to a min would handle NaNs incorrectly.
23289         if (!DAG.getTarget().Options.UnsafeFPMath &&
23290             (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)))
23291           break;
23292         Opcode = X86ISD::FMIN;
23293         break;
23294       case ISD::SETUGE:
23295         // Converting this to a min would handle both negative zeros and NaNs
23296         // incorrectly, but we can swap the operands to fix both.
23297         std::swap(LHS, RHS);
23298       case ISD::SETOGT:
23299       case ISD::SETGT:
23300       case ISD::SETGE:
23301         Opcode = X86ISD::FMIN;
23302         break;
23303
23304       case ISD::SETULT:
23305         // Converting this to a max would handle NaNs incorrectly.
23306         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23307           break;
23308         Opcode = X86ISD::FMAX;
23309         break;
23310       case ISD::SETOLE:
23311         // Converting this to a max would handle comparisons between positive
23312         // and negative zero incorrectly, and swapping the operands would
23313         // cause it to handle NaNs incorrectly.
23314         if (!DAG.getTarget().Options.UnsafeFPMath &&
23315             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS)) {
23316           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
23317             break;
23318           std::swap(LHS, RHS);
23319         }
23320         Opcode = X86ISD::FMAX;
23321         break;
23322       case ISD::SETULE:
23323         // Converting this to a max would handle both negative zeros and NaNs
23324         // incorrectly, but we can swap the operands to fix both.
23325         std::swap(LHS, RHS);
23326       case ISD::SETOLT:
23327       case ISD::SETLT:
23328       case ISD::SETLE:
23329         Opcode = X86ISD::FMAX;
23330         break;
23331       }
23332     }
23333
23334     if (Opcode)
23335       return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
23336   }
23337
23338   EVT CondVT = Cond.getValueType();
23339   if (Subtarget->hasAVX512() && VT.isVector() && CondVT.isVector() &&
23340       CondVT.getVectorElementType() == MVT::i1) {
23341     // v16i8 (select v16i1, v16i8, v16i8) does not have a proper
23342     // lowering on KNL. In this case we convert it to
23343     // v16i8 (select v16i8, v16i8, v16i8) and use AVX instruction.
23344     // The same situation for all 128 and 256-bit vectors of i8 and i16.
23345     // Since SKX these selects have a proper lowering.
23346     EVT OpVT = LHS.getValueType();
23347     if ((OpVT.is128BitVector() || OpVT.is256BitVector()) &&
23348         (OpVT.getVectorElementType() == MVT::i8 ||
23349          OpVT.getVectorElementType() == MVT::i16) &&
23350         !(Subtarget->hasBWI() && Subtarget->hasVLX())) {
23351       Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, OpVT, Cond);
23352       DCI.AddToWorklist(Cond.getNode());
23353       return DAG.getNode(N->getOpcode(), DL, OpVT, Cond, LHS, RHS);
23354     }
23355   }
23356   // If this is a select between two integer constants, try to do some
23357   // optimizations.
23358   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(LHS)) {
23359     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(RHS))
23360       // Don't do this for crazy integer types.
23361       if (DAG.getTargetLoweringInfo().isTypeLegal(LHS.getValueType())) {
23362         // If this is efficiently invertible, canonicalize the LHSC/RHSC values
23363         // so that TrueC (the true value) is larger than FalseC.
23364         bool NeedsCondInvert = false;
23365
23366         if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue()) &&
23367             // Efficiently invertible.
23368             (Cond.getOpcode() == ISD::SETCC ||  // setcc -> invertible.
23369              (Cond.getOpcode() == ISD::XOR &&   // xor(X, C) -> invertible.
23370               isa<ConstantSDNode>(Cond.getOperand(1))))) {
23371           NeedsCondInvert = true;
23372           std::swap(TrueC, FalseC);
23373         }
23374
23375         // Optimize C ? 8 : 0 -> zext(C) << 3.  Likewise for any pow2/0.
23376         if (FalseC->getAPIntValue() == 0 &&
23377             TrueC->getAPIntValue().isPowerOf2()) {
23378           if (NeedsCondInvert) // Invert the condition if needed.
23379             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23380                                DAG.getConstant(1, Cond.getValueType()));
23381
23382           // Zero extend the condition if needed.
23383           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
23384
23385           unsigned ShAmt = TrueC->getAPIntValue().logBase2();
23386           return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
23387                              DAG.getConstant(ShAmt, MVT::i8));
23388         }
23389
23390         // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.
23391         if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
23392           if (NeedsCondInvert) // Invert the condition if needed.
23393             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23394                                DAG.getConstant(1, Cond.getValueType()));
23395
23396           // Zero extend the condition if needed.
23397           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
23398                              FalseC->getValueType(0), Cond);
23399           return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
23400                              SDValue(FalseC, 0));
23401         }
23402
23403         // Optimize cases that will turn into an LEA instruction.  This requires
23404         // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
23405         if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
23406           uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
23407           if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
23408
23409           bool isFastMultiplier = false;
23410           if (Diff < 10) {
23411             switch ((unsigned char)Diff) {
23412               default: break;
23413               case 1:  // result = add base, cond
23414               case 2:  // result = lea base(    , cond*2)
23415               case 3:  // result = lea base(cond, cond*2)
23416               case 4:  // result = lea base(    , cond*4)
23417               case 5:  // result = lea base(cond, cond*4)
23418               case 8:  // result = lea base(    , cond*8)
23419               case 9:  // result = lea base(cond, cond*8)
23420                 isFastMultiplier = true;
23421                 break;
23422             }
23423           }
23424
23425           if (isFastMultiplier) {
23426             APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
23427             if (NeedsCondInvert) // Invert the condition if needed.
23428               Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
23429                                  DAG.getConstant(1, Cond.getValueType()));
23430
23431             // Zero extend the condition if needed.
23432             Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
23433                                Cond);
23434             // Scale the condition by the difference.
23435             if (Diff != 1)
23436               Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
23437                                  DAG.getConstant(Diff, Cond.getValueType()));
23438
23439             // Add the base if non-zero.
23440             if (FalseC->getAPIntValue() != 0)
23441               Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
23442                                  SDValue(FalseC, 0));
23443             return Cond;
23444           }
23445         }
23446       }
23447   }
23448
23449   // Canonicalize max and min:
23450   // (x > y) ? x : y -> (x >= y) ? x : y
23451   // (x < y) ? x : y -> (x <= y) ? x : y
23452   // This allows use of COND_S / COND_NS (see TranslateX86CC) which eliminates
23453   // the need for an extra compare
23454   // against zero. e.g.
23455   // (x - y) > 0 : (x - y) ? 0 -> (x - y) >= 0 : (x - y) ? 0
23456   // subl   %esi, %edi
23457   // testl  %edi, %edi
23458   // movl   $0, %eax
23459   // cmovgl %edi, %eax
23460   // =>
23461   // xorl   %eax, %eax
23462   // subl   %esi, $edi
23463   // cmovsl %eax, %edi
23464   if (N->getOpcode() == ISD::SELECT && Cond.getOpcode() == ISD::SETCC &&
23465       DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
23466       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
23467     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23468     switch (CC) {
23469     default: break;
23470     case ISD::SETLT:
23471     case ISD::SETGT: {
23472       ISD::CondCode NewCC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGE;
23473       Cond = DAG.getSetCC(SDLoc(Cond), Cond.getValueType(),
23474                           Cond.getOperand(0), Cond.getOperand(1), NewCC);
23475       return DAG.getNode(ISD::SELECT, DL, VT, Cond, LHS, RHS);
23476     }
23477     }
23478   }
23479
23480   // Early exit check
23481   if (!TLI.isTypeLegal(VT))
23482     return SDValue();
23483
23484   // Match VSELECTs into subs with unsigned saturation.
23485   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC &&
23486       // psubus is available in SSE2 and AVX2 for i8 and i16 vectors.
23487       ((Subtarget->hasSSE2() && (VT == MVT::v16i8 || VT == MVT::v8i16)) ||
23488        (Subtarget->hasAVX2() && (VT == MVT::v32i8 || VT == MVT::v16i16)))) {
23489     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
23490
23491     // Check if one of the arms of the VSELECT is a zero vector. If it's on the
23492     // left side invert the predicate to simplify logic below.
23493     SDValue Other;
23494     if (ISD::isBuildVectorAllZeros(LHS.getNode())) {
23495       Other = RHS;
23496       CC = ISD::getSetCCInverse(CC, true);
23497     } else if (ISD::isBuildVectorAllZeros(RHS.getNode())) {
23498       Other = LHS;
23499     }
23500
23501     if (Other.getNode() && Other->getNumOperands() == 2 &&
23502         DAG.isEqualTo(Other->getOperand(0), Cond.getOperand(0))) {
23503       SDValue OpLHS = Other->getOperand(0), OpRHS = Other->getOperand(1);
23504       SDValue CondRHS = Cond->getOperand(1);
23505
23506       // Look for a general sub with unsigned saturation first.
23507       // x >= y ? x-y : 0 --> subus x, y
23508       // x >  y ? x-y : 0 --> subus x, y
23509       if ((CC == ISD::SETUGE || CC == ISD::SETUGT) &&
23510           Other->getOpcode() == ISD::SUB && DAG.isEqualTo(OpRHS, CondRHS))
23511         return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
23512
23513       if (auto *OpRHSBV = dyn_cast<BuildVectorSDNode>(OpRHS))
23514         if (auto *OpRHSConst = OpRHSBV->getConstantSplatNode()) {
23515           if (auto *CondRHSBV = dyn_cast<BuildVectorSDNode>(CondRHS))
23516             if (auto *CondRHSConst = CondRHSBV->getConstantSplatNode())
23517               // If the RHS is a constant we have to reverse the const
23518               // canonicalization.
23519               // x > C-1 ? x+-C : 0 --> subus x, C
23520               if (CC == ISD::SETUGT && Other->getOpcode() == ISD::ADD &&
23521                   CondRHSConst->getAPIntValue() ==
23522                       (-OpRHSConst->getAPIntValue() - 1))
23523                 return DAG.getNode(
23524                     X86ISD::SUBUS, DL, VT, OpLHS,
23525                     DAG.getConstant(-OpRHSConst->getAPIntValue(), VT));
23526
23527           // Another special case: If C was a sign bit, the sub has been
23528           // canonicalized into a xor.
23529           // FIXME: Would it be better to use computeKnownBits to determine
23530           //        whether it's safe to decanonicalize the xor?
23531           // x s< 0 ? x^C : 0 --> subus x, C
23532           if (CC == ISD::SETLT && Other->getOpcode() == ISD::XOR &&
23533               ISD::isBuildVectorAllZeros(CondRHS.getNode()) &&
23534               OpRHSConst->getAPIntValue().isSignBit())
23535             // Note that we have to rebuild the RHS constant here to ensure we
23536             // don't rely on particular values of undef lanes.
23537             return DAG.getNode(
23538                 X86ISD::SUBUS, DL, VT, OpLHS,
23539                 DAG.getConstant(OpRHSConst->getAPIntValue(), VT));
23540         }
23541     }
23542   }
23543
23544   // Try to match a min/max vector operation.
23545   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC) {
23546     std::pair<unsigned, bool> ret = matchIntegerMINMAX(Cond, VT, LHS, RHS, DAG, Subtarget);
23547     unsigned Opc = ret.first;
23548     bool NeedSplit = ret.second;
23549
23550     if (Opc && NeedSplit) {
23551       unsigned NumElems = VT.getVectorNumElements();
23552       // Extract the LHS vectors
23553       SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, DL);
23554       SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, DL);
23555
23556       // Extract the RHS vectors
23557       SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, DL);
23558       SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, DL);
23559
23560       // Create min/max for each subvector
23561       LHS = DAG.getNode(Opc, DL, LHS1.getValueType(), LHS1, RHS1);
23562       RHS = DAG.getNode(Opc, DL, LHS2.getValueType(), LHS2, RHS2);
23563
23564       // Merge the result
23565       return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LHS, RHS);
23566     } else if (Opc)
23567       return DAG.getNode(Opc, DL, VT, LHS, RHS);
23568   }
23569
23570   // Simplify vector selection if condition value type matches vselect
23571   // operand type
23572   if (N->getOpcode() == ISD::VSELECT && CondVT == VT) {
23573     assert(Cond.getValueType().isVector() &&
23574            "vector select expects a vector selector!");
23575
23576     bool TValIsAllOnes = ISD::isBuildVectorAllOnes(LHS.getNode());
23577     bool FValIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
23578
23579     // Try invert the condition if true value is not all 1s and false value
23580     // is not all 0s.
23581     if (!TValIsAllOnes && !FValIsAllZeros &&
23582         // Check if the selector will be produced by CMPP*/PCMP*
23583         Cond.getOpcode() == ISD::SETCC &&
23584         // Check if SETCC has already been promoted
23585         TLI.getSetCCResultType(*DAG.getContext(), VT) == CondVT) {
23586       bool TValIsAllZeros = ISD::isBuildVectorAllZeros(LHS.getNode());
23587       bool FValIsAllOnes = ISD::isBuildVectorAllOnes(RHS.getNode());
23588
23589       if (TValIsAllZeros || FValIsAllOnes) {
23590         SDValue CC = Cond.getOperand(2);
23591         ISD::CondCode NewCC =
23592           ISD::getSetCCInverse(cast<CondCodeSDNode>(CC)->get(),
23593                                Cond.getOperand(0).getValueType().isInteger());
23594         Cond = DAG.getSetCC(DL, CondVT, Cond.getOperand(0), Cond.getOperand(1), NewCC);
23595         std::swap(LHS, RHS);
23596         TValIsAllOnes = FValIsAllOnes;
23597         FValIsAllZeros = TValIsAllZeros;
23598       }
23599     }
23600
23601     if (TValIsAllOnes || FValIsAllZeros) {
23602       SDValue Ret;
23603
23604       if (TValIsAllOnes && FValIsAllZeros)
23605         Ret = Cond;
23606       else if (TValIsAllOnes)
23607         Ret = DAG.getNode(ISD::OR, DL, CondVT, Cond,
23608                           DAG.getNode(ISD::BITCAST, DL, CondVT, RHS));
23609       else if (FValIsAllZeros)
23610         Ret = DAG.getNode(ISD::AND, DL, CondVT, Cond,
23611                           DAG.getNode(ISD::BITCAST, DL, CondVT, LHS));
23612
23613       return DAG.getNode(ISD::BITCAST, DL, VT, Ret);
23614     }
23615   }
23616
23617   // If we know that this node is legal then we know that it is going to be
23618   // matched by one of the SSE/AVX BLEND instructions. These instructions only
23619   // depend on the highest bit in each word. Try to use SimplifyDemandedBits
23620   // to simplify previous instructions.
23621   if (N->getOpcode() == ISD::VSELECT && DCI.isBeforeLegalizeOps() &&
23622       !DCI.isBeforeLegalize() &&
23623       // We explicitly check against v8i16 and v16i16 because, although
23624       // they're marked as Custom, they might only be legal when Cond is a
23625       // build_vector of constants. This will be taken care in a later
23626       // condition.
23627       (TLI.isOperationLegalOrCustom(ISD::VSELECT, VT) && VT != MVT::v16i16 &&
23628        VT != MVT::v8i16) &&
23629       // Don't optimize vector of constants. Those are handled by
23630       // the generic code and all the bits must be properly set for
23631       // the generic optimizer.
23632       !ISD::isBuildVectorOfConstantSDNodes(Cond.getNode())) {
23633     unsigned BitWidth = Cond.getValueType().getScalarType().getSizeInBits();
23634
23635     // Don't optimize vector selects that map to mask-registers.
23636     if (BitWidth == 1)
23637       return SDValue();
23638
23639     assert(BitWidth >= 8 && BitWidth <= 64 && "Invalid mask size");
23640     APInt DemandedMask = APInt::getHighBitsSet(BitWidth, 1);
23641
23642     APInt KnownZero, KnownOne;
23643     TargetLowering::TargetLoweringOpt TLO(DAG, DCI.isBeforeLegalize(),
23644                                           DCI.isBeforeLegalizeOps());
23645     if (TLO.ShrinkDemandedConstant(Cond, DemandedMask) ||
23646         TLI.SimplifyDemandedBits(Cond, DemandedMask, KnownZero, KnownOne,
23647                                  TLO)) {
23648       // If we changed the computation somewhere in the DAG, this change
23649       // will affect all users of Cond.
23650       // Make sure it is fine and update all the nodes so that we do not
23651       // use the generic VSELECT anymore. Otherwise, we may perform
23652       // wrong optimizations as we messed up with the actual expectation
23653       // for the vector boolean values.
23654       if (Cond != TLO.Old) {
23655         // Check all uses of that condition operand to check whether it will be
23656         // consumed by non-BLEND instructions, which may depend on all bits are
23657         // set properly.
23658         for (SDNode::use_iterator I = Cond->use_begin(), E = Cond->use_end();
23659              I != E; ++I)
23660           if (I->getOpcode() != ISD::VSELECT)
23661             // TODO: Add other opcodes eventually lowered into BLEND.
23662             return SDValue();
23663
23664         // Update all the users of the condition, before committing the change,
23665         // so that the VSELECT optimizations that expect the correct vector
23666         // boolean value will not be triggered.
23667         for (SDNode::use_iterator I = Cond->use_begin(), E = Cond->use_end();
23668              I != E; ++I)
23669           DAG.ReplaceAllUsesOfValueWith(
23670               SDValue(*I, 0),
23671               DAG.getNode(X86ISD::SHRUNKBLEND, SDLoc(*I), I->getValueType(0),
23672                           Cond, I->getOperand(1), I->getOperand(2)));
23673         DCI.CommitTargetLoweringOpt(TLO);
23674         return SDValue();
23675       }
23676       // At this point, only Cond is changed. Change the condition
23677       // just for N to keep the opportunity to optimize all other
23678       // users their own way.
23679       DAG.ReplaceAllUsesOfValueWith(
23680           SDValue(N, 0),
23681           DAG.getNode(X86ISD::SHRUNKBLEND, SDLoc(N), N->getValueType(0),
23682                       TLO.New, N->getOperand(1), N->getOperand(2)));
23683       return SDValue();
23684     }
23685   }
23686
23687   // We should generate an X86ISD::BLENDI from a vselect if its argument
23688   // is a sign_extend_inreg of an any_extend of a BUILD_VECTOR of
23689   // constants. This specific pattern gets generated when we split a
23690   // selector for a 512 bit vector in a machine without AVX512 (but with
23691   // 256-bit vectors), during legalization:
23692   //
23693   // (vselect (sign_extend (any_extend (BUILD_VECTOR)) i1) LHS RHS)
23694   //
23695   // Iff we find this pattern and the build_vectors are built from
23696   // constants, we translate the vselect into a shuffle_vector that we
23697   // know will be matched by LowerVECTOR_SHUFFLEtoBlend.
23698   if ((N->getOpcode() == ISD::VSELECT ||
23699        N->getOpcode() == X86ISD::SHRUNKBLEND) &&
23700       !DCI.isBeforeLegalize()) {
23701     SDValue Shuffle = transformVSELECTtoBlendVECTOR_SHUFFLE(N, DAG, Subtarget);
23702     if (Shuffle.getNode())
23703       return Shuffle;
23704   }
23705
23706   return SDValue();
23707 }
23708
23709 // Check whether a boolean test is testing a boolean value generated by
23710 // X86ISD::SETCC. If so, return the operand of that SETCC and proper condition
23711 // code.
23712 //
23713 // Simplify the following patterns:
23714 // (Op (CMP (SETCC Cond EFLAGS) 1) EQ) or
23715 // (Op (CMP (SETCC Cond EFLAGS) 0) NEQ)
23716 // to (Op EFLAGS Cond)
23717 //
23718 // (Op (CMP (SETCC Cond EFLAGS) 0) EQ) or
23719 // (Op (CMP (SETCC Cond EFLAGS) 1) NEQ)
23720 // to (Op EFLAGS !Cond)
23721 //
23722 // where Op could be BRCOND or CMOV.
23723 //
23724 static SDValue checkBoolTestSetCCCombine(SDValue Cmp, X86::CondCode &CC) {
23725   // Quit if not CMP and SUB with its value result used.
23726   if (Cmp.getOpcode() != X86ISD::CMP &&
23727       (Cmp.getOpcode() != X86ISD::SUB || Cmp.getNode()->hasAnyUseOfValue(0)))
23728       return SDValue();
23729
23730   // Quit if not used as a boolean value.
23731   if (CC != X86::COND_E && CC != X86::COND_NE)
23732     return SDValue();
23733
23734   // Check CMP operands. One of them should be 0 or 1 and the other should be
23735   // an SetCC or extended from it.
23736   SDValue Op1 = Cmp.getOperand(0);
23737   SDValue Op2 = Cmp.getOperand(1);
23738
23739   SDValue SetCC;
23740   const ConstantSDNode* C = nullptr;
23741   bool needOppositeCond = (CC == X86::COND_E);
23742   bool checkAgainstTrue = false; // Is it a comparison against 1?
23743
23744   if ((C = dyn_cast<ConstantSDNode>(Op1)))
23745     SetCC = Op2;
23746   else if ((C = dyn_cast<ConstantSDNode>(Op2)))
23747     SetCC = Op1;
23748   else // Quit if all operands are not constants.
23749     return SDValue();
23750
23751   if (C->getZExtValue() == 1) {
23752     needOppositeCond = !needOppositeCond;
23753     checkAgainstTrue = true;
23754   } else if (C->getZExtValue() != 0)
23755     // Quit if the constant is neither 0 or 1.
23756     return SDValue();
23757
23758   bool truncatedToBoolWithAnd = false;
23759   // Skip (zext $x), (trunc $x), or (and $x, 1) node.
23760   while (SetCC.getOpcode() == ISD::ZERO_EXTEND ||
23761          SetCC.getOpcode() == ISD::TRUNCATE ||
23762          SetCC.getOpcode() == ISD::AND) {
23763     if (SetCC.getOpcode() == ISD::AND) {
23764       int OpIdx = -1;
23765       ConstantSDNode *CS;
23766       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(0))) &&
23767           CS->getZExtValue() == 1)
23768         OpIdx = 1;
23769       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(1))) &&
23770           CS->getZExtValue() == 1)
23771         OpIdx = 0;
23772       if (OpIdx == -1)
23773         break;
23774       SetCC = SetCC.getOperand(OpIdx);
23775       truncatedToBoolWithAnd = true;
23776     } else
23777       SetCC = SetCC.getOperand(0);
23778   }
23779
23780   switch (SetCC.getOpcode()) {
23781   case X86ISD::SETCC_CARRY:
23782     // Since SETCC_CARRY gives output based on R = CF ? ~0 : 0, it's unsafe to
23783     // simplify it if the result of SETCC_CARRY is not canonicalized to 0 or 1,
23784     // i.e. it's a comparison against true but the result of SETCC_CARRY is not
23785     // truncated to i1 using 'and'.
23786     if (checkAgainstTrue && !truncatedToBoolWithAnd)
23787       break;
23788     assert(X86::CondCode(SetCC.getConstantOperandVal(0)) == X86::COND_B &&
23789            "Invalid use of SETCC_CARRY!");
23790     // FALL THROUGH
23791   case X86ISD::SETCC:
23792     // Set the condition code or opposite one if necessary.
23793     CC = X86::CondCode(SetCC.getConstantOperandVal(0));
23794     if (needOppositeCond)
23795       CC = X86::GetOppositeBranchCondition(CC);
23796     return SetCC.getOperand(1);
23797   case X86ISD::CMOV: {
23798     // Check whether false/true value has canonical one, i.e. 0 or 1.
23799     ConstantSDNode *FVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(0));
23800     ConstantSDNode *TVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(1));
23801     // Quit if true value is not a constant.
23802     if (!TVal)
23803       return SDValue();
23804     // Quit if false value is not a constant.
23805     if (!FVal) {
23806       SDValue Op = SetCC.getOperand(0);
23807       // Skip 'zext' or 'trunc' node.
23808       if (Op.getOpcode() == ISD::ZERO_EXTEND ||
23809           Op.getOpcode() == ISD::TRUNCATE)
23810         Op = Op.getOperand(0);
23811       // A special case for rdrand/rdseed, where 0 is set if false cond is
23812       // found.
23813       if ((Op.getOpcode() != X86ISD::RDRAND &&
23814            Op.getOpcode() != X86ISD::RDSEED) || Op.getResNo() != 0)
23815         return SDValue();
23816     }
23817     // Quit if false value is not the constant 0 or 1.
23818     bool FValIsFalse = true;
23819     if (FVal && FVal->getZExtValue() != 0) {
23820       if (FVal->getZExtValue() != 1)
23821         return SDValue();
23822       // If FVal is 1, opposite cond is needed.
23823       needOppositeCond = !needOppositeCond;
23824       FValIsFalse = false;
23825     }
23826     // Quit if TVal is not the constant opposite of FVal.
23827     if (FValIsFalse && TVal->getZExtValue() != 1)
23828       return SDValue();
23829     if (!FValIsFalse && TVal->getZExtValue() != 0)
23830       return SDValue();
23831     CC = X86::CondCode(SetCC.getConstantOperandVal(2));
23832     if (needOppositeCond)
23833       CC = X86::GetOppositeBranchCondition(CC);
23834     return SetCC.getOperand(3);
23835   }
23836   }
23837
23838   return SDValue();
23839 }
23840
23841 /// Optimize X86ISD::CMOV [LHS, RHS, CONDCODE (e.g. X86::COND_NE), CONDVAL]
23842 static SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG,
23843                                   TargetLowering::DAGCombinerInfo &DCI,
23844                                   const X86Subtarget *Subtarget) {
23845   SDLoc DL(N);
23846
23847   // If the flag operand isn't dead, don't touch this CMOV.
23848   if (N->getNumValues() == 2 && !SDValue(N, 1).use_empty())
23849     return SDValue();
23850
23851   SDValue FalseOp = N->getOperand(0);
23852   SDValue TrueOp = N->getOperand(1);
23853   X86::CondCode CC = (X86::CondCode)N->getConstantOperandVal(2);
23854   SDValue Cond = N->getOperand(3);
23855
23856   if (CC == X86::COND_E || CC == X86::COND_NE) {
23857     switch (Cond.getOpcode()) {
23858     default: break;
23859     case X86ISD::BSR:
23860     case X86ISD::BSF:
23861       // If operand of BSR / BSF are proven never zero, then ZF cannot be set.
23862       if (DAG.isKnownNeverZero(Cond.getOperand(0)))
23863         return (CC == X86::COND_E) ? FalseOp : TrueOp;
23864     }
23865   }
23866
23867   SDValue Flags;
23868
23869   Flags = checkBoolTestSetCCCombine(Cond, CC);
23870   if (Flags.getNode() &&
23871       // Extra check as FCMOV only supports a subset of X86 cond.
23872       (FalseOp.getValueType() != MVT::f80 || hasFPCMov(CC))) {
23873     SDValue Ops[] = { FalseOp, TrueOp,
23874                       DAG.getConstant(CC, MVT::i8), Flags };
23875     return DAG.getNode(X86ISD::CMOV, DL, N->getVTList(), Ops);
23876   }
23877
23878   // If this is a select between two integer constants, try to do some
23879   // optimizations.  Note that the operands are ordered the opposite of SELECT
23880   // operands.
23881   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(TrueOp)) {
23882     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(FalseOp)) {
23883       // Canonicalize the TrueC/FalseC values so that TrueC (the true value) is
23884       // larger than FalseC (the false value).
23885       if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue())) {
23886         CC = X86::GetOppositeBranchCondition(CC);
23887         std::swap(TrueC, FalseC);
23888         std::swap(TrueOp, FalseOp);
23889       }
23890
23891       // Optimize C ? 8 : 0 -> zext(setcc(C)) << 3.  Likewise for any pow2/0.
23892       // This is efficient for any integer data type (including i8/i16) and
23893       // shift amount.
23894       if (FalseC->getAPIntValue() == 0 && TrueC->getAPIntValue().isPowerOf2()) {
23895         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
23896                            DAG.getConstant(CC, MVT::i8), Cond);
23897
23898         // Zero extend the condition if needed.
23899         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
23900
23901         unsigned ShAmt = TrueC->getAPIntValue().logBase2();
23902         Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
23903                            DAG.getConstant(ShAmt, MVT::i8));
23904         if (N->getNumValues() == 2)  // Dead flag value?
23905           return DCI.CombineTo(N, Cond, SDValue());
23906         return Cond;
23907       }
23908
23909       // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.  This is efficient
23910       // for any integer data type, including i8/i16.
23911       if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
23912         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
23913                            DAG.getConstant(CC, MVT::i8), Cond);
23914
23915         // Zero extend the condition if needed.
23916         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
23917                            FalseC->getValueType(0), Cond);
23918         Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
23919                            SDValue(FalseC, 0));
23920
23921         if (N->getNumValues() == 2)  // Dead flag value?
23922           return DCI.CombineTo(N, Cond, SDValue());
23923         return Cond;
23924       }
23925
23926       // Optimize cases that will turn into an LEA instruction.  This requires
23927       // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
23928       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
23929         uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
23930         if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
23931
23932         bool isFastMultiplier = false;
23933         if (Diff < 10) {
23934           switch ((unsigned char)Diff) {
23935           default: break;
23936           case 1:  // result = add base, cond
23937           case 2:  // result = lea base(    , cond*2)
23938           case 3:  // result = lea base(cond, cond*2)
23939           case 4:  // result = lea base(    , cond*4)
23940           case 5:  // result = lea base(cond, cond*4)
23941           case 8:  // result = lea base(    , cond*8)
23942           case 9:  // result = lea base(cond, cond*8)
23943             isFastMultiplier = true;
23944             break;
23945           }
23946         }
23947
23948         if (isFastMultiplier) {
23949           APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
23950           Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
23951                              DAG.getConstant(CC, MVT::i8), Cond);
23952           // Zero extend the condition if needed.
23953           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
23954                              Cond);
23955           // Scale the condition by the difference.
23956           if (Diff != 1)
23957             Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
23958                                DAG.getConstant(Diff, Cond.getValueType()));
23959
23960           // Add the base if non-zero.
23961           if (FalseC->getAPIntValue() != 0)
23962             Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
23963                                SDValue(FalseC, 0));
23964           if (N->getNumValues() == 2)  // Dead flag value?
23965             return DCI.CombineTo(N, Cond, SDValue());
23966           return Cond;
23967         }
23968       }
23969     }
23970   }
23971
23972   // Handle these cases:
23973   //   (select (x != c), e, c) -> select (x != c), e, x),
23974   //   (select (x == c), c, e) -> select (x == c), x, e)
23975   // where the c is an integer constant, and the "select" is the combination
23976   // of CMOV and CMP.
23977   //
23978   // The rationale for this change is that the conditional-move from a constant
23979   // needs two instructions, however, conditional-move from a register needs
23980   // only one instruction.
23981   //
23982   // CAVEAT: By replacing a constant with a symbolic value, it may obscure
23983   //  some instruction-combining opportunities. This opt needs to be
23984   //  postponed as late as possible.
23985   //
23986   if (!DCI.isBeforeLegalize() && !DCI.isBeforeLegalizeOps()) {
23987     // the DCI.xxxx conditions are provided to postpone the optimization as
23988     // late as possible.
23989
23990     ConstantSDNode *CmpAgainst = nullptr;
23991     if ((Cond.getOpcode() == X86ISD::CMP || Cond.getOpcode() == X86ISD::SUB) &&
23992         (CmpAgainst = dyn_cast<ConstantSDNode>(Cond.getOperand(1))) &&
23993         !isa<ConstantSDNode>(Cond.getOperand(0))) {
23994
23995       if (CC == X86::COND_NE &&
23996           CmpAgainst == dyn_cast<ConstantSDNode>(FalseOp)) {
23997         CC = X86::GetOppositeBranchCondition(CC);
23998         std::swap(TrueOp, FalseOp);
23999       }
24000
24001       if (CC == X86::COND_E &&
24002           CmpAgainst == dyn_cast<ConstantSDNode>(TrueOp)) {
24003         SDValue Ops[] = { FalseOp, Cond.getOperand(0),
24004                           DAG.getConstant(CC, MVT::i8), Cond };
24005         return DAG.getNode(X86ISD::CMOV, DL, N->getVTList (), Ops);
24006       }
24007     }
24008   }
24009
24010   return SDValue();
24011 }
24012
24013 static SDValue PerformINTRINSIC_WO_CHAINCombine(SDNode *N, SelectionDAG &DAG,
24014                                                 const X86Subtarget *Subtarget) {
24015   unsigned IntNo = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
24016   switch (IntNo) {
24017   default: return SDValue();
24018   // SSE/AVX/AVX2 blend intrinsics.
24019   case Intrinsic::x86_avx2_pblendvb:
24020   case Intrinsic::x86_avx2_pblendw:
24021   case Intrinsic::x86_avx2_pblendd_128:
24022   case Intrinsic::x86_avx2_pblendd_256:
24023     // Don't try to simplify this intrinsic if we don't have AVX2.
24024     if (!Subtarget->hasAVX2())
24025       return SDValue();
24026     // FALL-THROUGH
24027   case Intrinsic::x86_avx_blend_pd_256:
24028   case Intrinsic::x86_avx_blend_ps_256:
24029   case Intrinsic::x86_avx_blendv_pd_256:
24030   case Intrinsic::x86_avx_blendv_ps_256:
24031     // Don't try to simplify this intrinsic if we don't have AVX.
24032     if (!Subtarget->hasAVX())
24033       return SDValue();
24034     // FALL-THROUGH
24035   case Intrinsic::x86_sse41_pblendw:
24036   case Intrinsic::x86_sse41_blendpd:
24037   case Intrinsic::x86_sse41_blendps:
24038   case Intrinsic::x86_sse41_blendvps:
24039   case Intrinsic::x86_sse41_blendvpd:
24040   case Intrinsic::x86_sse41_pblendvb: {
24041     SDValue Op0 = N->getOperand(1);
24042     SDValue Op1 = N->getOperand(2);
24043     SDValue Mask = N->getOperand(3);
24044
24045     // Don't try to simplify this intrinsic if we don't have SSE4.1.
24046     if (!Subtarget->hasSSE41())
24047       return SDValue();
24048
24049     // fold (blend A, A, Mask) -> A
24050     if (Op0 == Op1)
24051       return Op0;
24052     // fold (blend A, B, allZeros) -> A
24053     if (ISD::isBuildVectorAllZeros(Mask.getNode()))
24054       return Op0;
24055     // fold (blend A, B, allOnes) -> B
24056     if (ISD::isBuildVectorAllOnes(Mask.getNode()))
24057       return Op1;
24058
24059     // Simplify the case where the mask is a constant i32 value.
24060     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Mask)) {
24061       if (C->isNullValue())
24062         return Op0;
24063       if (C->isAllOnesValue())
24064         return Op1;
24065     }
24066
24067     return SDValue();
24068   }
24069
24070   // Packed SSE2/AVX2 arithmetic shift immediate intrinsics.
24071   case Intrinsic::x86_sse2_psrai_w:
24072   case Intrinsic::x86_sse2_psrai_d:
24073   case Intrinsic::x86_avx2_psrai_w:
24074   case Intrinsic::x86_avx2_psrai_d:
24075   case Intrinsic::x86_sse2_psra_w:
24076   case Intrinsic::x86_sse2_psra_d:
24077   case Intrinsic::x86_avx2_psra_w:
24078   case Intrinsic::x86_avx2_psra_d: {
24079     SDValue Op0 = N->getOperand(1);
24080     SDValue Op1 = N->getOperand(2);
24081     EVT VT = Op0.getValueType();
24082     assert(VT.isVector() && "Expected a vector type!");
24083
24084     if (isa<BuildVectorSDNode>(Op1))
24085       Op1 = Op1.getOperand(0);
24086
24087     if (!isa<ConstantSDNode>(Op1))
24088       return SDValue();
24089
24090     EVT SVT = VT.getVectorElementType();
24091     unsigned SVTBits = SVT.getSizeInBits();
24092
24093     ConstantSDNode *CND = cast<ConstantSDNode>(Op1);
24094     const APInt &C = APInt(SVTBits, CND->getAPIntValue().getZExtValue());
24095     uint64_t ShAmt = C.getZExtValue();
24096
24097     // Don't try to convert this shift into a ISD::SRA if the shift
24098     // count is bigger than or equal to the element size.
24099     if (ShAmt >= SVTBits)
24100       return SDValue();
24101
24102     // Trivial case: if the shift count is zero, then fold this
24103     // into the first operand.
24104     if (ShAmt == 0)
24105       return Op0;
24106
24107     // Replace this packed shift intrinsic with a target independent
24108     // shift dag node.
24109     SDValue Splat = DAG.getConstant(C, VT);
24110     return DAG.getNode(ISD::SRA, SDLoc(N), VT, Op0, Splat);
24111   }
24112   }
24113 }
24114
24115 /// PerformMulCombine - Optimize a single multiply with constant into two
24116 /// in order to implement it with two cheaper instructions, e.g.
24117 /// LEA + SHL, LEA + LEA.
24118 static SDValue PerformMulCombine(SDNode *N, SelectionDAG &DAG,
24119                                  TargetLowering::DAGCombinerInfo &DCI) {
24120   if (DCI.isBeforeLegalize() || DCI.isCalledByLegalizer())
24121     return SDValue();
24122
24123   EVT VT = N->getValueType(0);
24124   if (VT != MVT::i64)
24125     return SDValue();
24126
24127   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1));
24128   if (!C)
24129     return SDValue();
24130   uint64_t MulAmt = C->getZExtValue();
24131   if (isPowerOf2_64(MulAmt) || MulAmt == 3 || MulAmt == 5 || MulAmt == 9)
24132     return SDValue();
24133
24134   uint64_t MulAmt1 = 0;
24135   uint64_t MulAmt2 = 0;
24136   if ((MulAmt % 9) == 0) {
24137     MulAmt1 = 9;
24138     MulAmt2 = MulAmt / 9;
24139   } else if ((MulAmt % 5) == 0) {
24140     MulAmt1 = 5;
24141     MulAmt2 = MulAmt / 5;
24142   } else if ((MulAmt % 3) == 0) {
24143     MulAmt1 = 3;
24144     MulAmt2 = MulAmt / 3;
24145   }
24146   if (MulAmt2 &&
24147       (isPowerOf2_64(MulAmt2) || MulAmt2 == 3 || MulAmt2 == 5 || MulAmt2 == 9)){
24148     SDLoc DL(N);
24149
24150     if (isPowerOf2_64(MulAmt2) &&
24151         !(N->hasOneUse() && N->use_begin()->getOpcode() == ISD::ADD))
24152       // If second multiplifer is pow2, issue it first. We want the multiply by
24153       // 3, 5, or 9 to be folded into the addressing mode unless the lone use
24154       // is an add.
24155       std::swap(MulAmt1, MulAmt2);
24156
24157     SDValue NewMul;
24158     if (isPowerOf2_64(MulAmt1))
24159       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
24160                            DAG.getConstant(Log2_64(MulAmt1), MVT::i8));
24161     else
24162       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
24163                            DAG.getConstant(MulAmt1, VT));
24164
24165     if (isPowerOf2_64(MulAmt2))
24166       NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
24167                            DAG.getConstant(Log2_64(MulAmt2), MVT::i8));
24168     else
24169       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
24170                            DAG.getConstant(MulAmt2, VT));
24171
24172     // Do not add new nodes to DAG combiner worklist.
24173     DCI.CombineTo(N, NewMul, false);
24174   }
24175   return SDValue();
24176 }
24177
24178 static SDValue PerformSHLCombine(SDNode *N, SelectionDAG &DAG) {
24179   SDValue N0 = N->getOperand(0);
24180   SDValue N1 = N->getOperand(1);
24181   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
24182   EVT VT = N0.getValueType();
24183
24184   // fold (shl (and (setcc_c), c1), c2) -> (and setcc_c, (c1 << c2))
24185   // since the result of setcc_c is all zero's or all ones.
24186   if (VT.isInteger() && !VT.isVector() &&
24187       N1C && N0.getOpcode() == ISD::AND &&
24188       N0.getOperand(1).getOpcode() == ISD::Constant) {
24189     SDValue N00 = N0.getOperand(0);
24190     if (N00.getOpcode() == X86ISD::SETCC_CARRY ||
24191         ((N00.getOpcode() == ISD::ANY_EXTEND ||
24192           N00.getOpcode() == ISD::ZERO_EXTEND) &&
24193          N00.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY)) {
24194       APInt Mask = cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue();
24195       APInt ShAmt = N1C->getAPIntValue();
24196       Mask = Mask.shl(ShAmt);
24197       if (Mask != 0)
24198         return DAG.getNode(ISD::AND, SDLoc(N), VT,
24199                            N00, DAG.getConstant(Mask, VT));
24200     }
24201   }
24202
24203   // Hardware support for vector shifts is sparse which makes us scalarize the
24204   // vector operations in many cases. Also, on sandybridge ADD is faster than
24205   // shl.
24206   // (shl V, 1) -> add V,V
24207   if (auto *N1BV = dyn_cast<BuildVectorSDNode>(N1))
24208     if (auto *N1SplatC = N1BV->getConstantSplatNode()) {
24209       assert(N0.getValueType().isVector() && "Invalid vector shift type");
24210       // We shift all of the values by one. In many cases we do not have
24211       // hardware support for this operation. This is better expressed as an ADD
24212       // of two values.
24213       if (N1SplatC->getZExtValue() == 1)
24214         return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N0);
24215     }
24216
24217   return SDValue();
24218 }
24219
24220 /// \brief Returns a vector of 0s if the node in input is a vector logical
24221 /// shift by a constant amount which is known to be bigger than or equal
24222 /// to the vector element size in bits.
24223 static SDValue performShiftToAllZeros(SDNode *N, SelectionDAG &DAG,
24224                                       const X86Subtarget *Subtarget) {
24225   EVT VT = N->getValueType(0);
24226
24227   if (VT != MVT::v2i64 && VT != MVT::v4i32 && VT != MVT::v8i16 &&
24228       (!Subtarget->hasInt256() ||
24229        (VT != MVT::v4i64 && VT != MVT::v8i32 && VT != MVT::v16i16)))
24230     return SDValue();
24231
24232   SDValue Amt = N->getOperand(1);
24233   SDLoc DL(N);
24234   if (auto *AmtBV = dyn_cast<BuildVectorSDNode>(Amt))
24235     if (auto *AmtSplat = AmtBV->getConstantSplatNode()) {
24236       APInt ShiftAmt = AmtSplat->getAPIntValue();
24237       unsigned MaxAmount = VT.getVectorElementType().getSizeInBits();
24238
24239       // SSE2/AVX2 logical shifts always return a vector of 0s
24240       // if the shift amount is bigger than or equal to
24241       // the element size. The constant shift amount will be
24242       // encoded as a 8-bit immediate.
24243       if (ShiftAmt.trunc(8).uge(MaxAmount))
24244         return getZeroVector(VT, Subtarget, DAG, DL);
24245     }
24246
24247   return SDValue();
24248 }
24249
24250 /// PerformShiftCombine - Combine shifts.
24251 static SDValue PerformShiftCombine(SDNode* N, SelectionDAG &DAG,
24252                                    TargetLowering::DAGCombinerInfo &DCI,
24253                                    const X86Subtarget *Subtarget) {
24254   if (N->getOpcode() == ISD::SHL) {
24255     SDValue V = PerformSHLCombine(N, DAG);
24256     if (V.getNode()) return V;
24257   }
24258
24259   if (N->getOpcode() != ISD::SRA) {
24260     // Try to fold this logical shift into a zero vector.
24261     SDValue V = performShiftToAllZeros(N, DAG, Subtarget);
24262     if (V.getNode()) return V;
24263   }
24264
24265   return SDValue();
24266 }
24267
24268 // CMPEQCombine - Recognize the distinctive  (AND (setcc ...) (setcc ..))
24269 // where both setccs reference the same FP CMP, and rewrite for CMPEQSS
24270 // and friends.  Likewise for OR -> CMPNEQSS.
24271 static SDValue CMPEQCombine(SDNode *N, SelectionDAG &DAG,
24272                             TargetLowering::DAGCombinerInfo &DCI,
24273                             const X86Subtarget *Subtarget) {
24274   unsigned opcode;
24275
24276   // SSE1 supports CMP{eq|ne}SS, and SSE2 added CMP{eq|ne}SD, but
24277   // we're requiring SSE2 for both.
24278   if (Subtarget->hasSSE2() && isAndOrOfSetCCs(SDValue(N, 0U), opcode)) {
24279     SDValue N0 = N->getOperand(0);
24280     SDValue N1 = N->getOperand(1);
24281     SDValue CMP0 = N0->getOperand(1);
24282     SDValue CMP1 = N1->getOperand(1);
24283     SDLoc DL(N);
24284
24285     // The SETCCs should both refer to the same CMP.
24286     if (CMP0.getOpcode() != X86ISD::CMP || CMP0 != CMP1)
24287       return SDValue();
24288
24289     SDValue CMP00 = CMP0->getOperand(0);
24290     SDValue CMP01 = CMP0->getOperand(1);
24291     EVT     VT    = CMP00.getValueType();
24292
24293     if (VT == MVT::f32 || VT == MVT::f64) {
24294       bool ExpectingFlags = false;
24295       // Check for any users that want flags:
24296       for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end();
24297            !ExpectingFlags && UI != UE; ++UI)
24298         switch (UI->getOpcode()) {
24299         default:
24300         case ISD::BR_CC:
24301         case ISD::BRCOND:
24302         case ISD::SELECT:
24303           ExpectingFlags = true;
24304           break;
24305         case ISD::CopyToReg:
24306         case ISD::SIGN_EXTEND:
24307         case ISD::ZERO_EXTEND:
24308         case ISD::ANY_EXTEND:
24309           break;
24310         }
24311
24312       if (!ExpectingFlags) {
24313         enum X86::CondCode cc0 = (enum X86::CondCode)N0.getConstantOperandVal(0);
24314         enum X86::CondCode cc1 = (enum X86::CondCode)N1.getConstantOperandVal(0);
24315
24316         if (cc1 == X86::COND_E || cc1 == X86::COND_NE) {
24317           X86::CondCode tmp = cc0;
24318           cc0 = cc1;
24319           cc1 = tmp;
24320         }
24321
24322         if ((cc0 == X86::COND_E  && cc1 == X86::COND_NP) ||
24323             (cc0 == X86::COND_NE && cc1 == X86::COND_P)) {
24324           // FIXME: need symbolic constants for these magic numbers.
24325           // See X86ATTInstPrinter.cpp:printSSECC().
24326           unsigned x86cc = (cc0 == X86::COND_E) ? 0 : 4;
24327           if (Subtarget->hasAVX512()) {
24328             SDValue FSetCC = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CMP00,
24329                                          CMP01, DAG.getConstant(x86cc, MVT::i8));
24330             if (N->getValueType(0) != MVT::i1)
24331               return DAG.getNode(ISD::ZERO_EXTEND, DL, N->getValueType(0),
24332                                  FSetCC);
24333             return FSetCC;
24334           }
24335           SDValue OnesOrZeroesF = DAG.getNode(X86ISD::FSETCC, DL,
24336                                               CMP00.getValueType(), CMP00, CMP01,
24337                                               DAG.getConstant(x86cc, MVT::i8));
24338
24339           bool is64BitFP = (CMP00.getValueType() == MVT::f64);
24340           MVT IntVT = is64BitFP ? MVT::i64 : MVT::i32;
24341
24342           if (is64BitFP && !Subtarget->is64Bit()) {
24343             // On a 32-bit target, we cannot bitcast the 64-bit float to a
24344             // 64-bit integer, since that's not a legal type. Since
24345             // OnesOrZeroesF is all ones of all zeroes, we don't need all the
24346             // bits, but can do this little dance to extract the lowest 32 bits
24347             // and work with those going forward.
24348             SDValue Vector64 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64,
24349                                            OnesOrZeroesF);
24350             SDValue Vector32 = DAG.getNode(ISD::BITCAST, DL, MVT::v4f32,
24351                                            Vector64);
24352             OnesOrZeroesF = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32,
24353                                         Vector32, DAG.getIntPtrConstant(0));
24354             IntVT = MVT::i32;
24355           }
24356
24357           SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, IntVT, OnesOrZeroesF);
24358           SDValue ANDed = DAG.getNode(ISD::AND, DL, IntVT, OnesOrZeroesI,
24359                                       DAG.getConstant(1, IntVT));
24360           SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
24361           return OneBitOfTruth;
24362         }
24363       }
24364     }
24365   }
24366   return SDValue();
24367 }
24368
24369 /// CanFoldXORWithAllOnes - Test whether the XOR operand is a AllOnes vector
24370 /// so it can be folded inside ANDNP.
24371 static bool CanFoldXORWithAllOnes(const SDNode *N) {
24372   EVT VT = N->getValueType(0);
24373
24374   // Match direct AllOnes for 128 and 256-bit vectors
24375   if (ISD::isBuildVectorAllOnes(N))
24376     return true;
24377
24378   // Look through a bit convert.
24379   if (N->getOpcode() == ISD::BITCAST)
24380     N = N->getOperand(0).getNode();
24381
24382   // Sometimes the operand may come from a insert_subvector building a 256-bit
24383   // allones vector
24384   if (VT.is256BitVector() &&
24385       N->getOpcode() == ISD::INSERT_SUBVECTOR) {
24386     SDValue V1 = N->getOperand(0);
24387     SDValue V2 = N->getOperand(1);
24388
24389     if (V1.getOpcode() == ISD::INSERT_SUBVECTOR &&
24390         V1.getOperand(0).getOpcode() == ISD::UNDEF &&
24391         ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
24392         ISD::isBuildVectorAllOnes(V2.getNode()))
24393       return true;
24394   }
24395
24396   return false;
24397 }
24398
24399 // On AVX/AVX2 the type v8i1 is legalized to v8i16, which is an XMM sized
24400 // register. In most cases we actually compare or select YMM-sized registers
24401 // and mixing the two types creates horrible code. This method optimizes
24402 // some of the transition sequences.
24403 static SDValue WidenMaskArithmetic(SDNode *N, SelectionDAG &DAG,
24404                                  TargetLowering::DAGCombinerInfo &DCI,
24405                                  const X86Subtarget *Subtarget) {
24406   EVT VT = N->getValueType(0);
24407   if (!VT.is256BitVector())
24408     return SDValue();
24409
24410   assert((N->getOpcode() == ISD::ANY_EXTEND ||
24411           N->getOpcode() == ISD::ZERO_EXTEND ||
24412           N->getOpcode() == ISD::SIGN_EXTEND) && "Invalid Node");
24413
24414   SDValue Narrow = N->getOperand(0);
24415   EVT NarrowVT = Narrow->getValueType(0);
24416   if (!NarrowVT.is128BitVector())
24417     return SDValue();
24418
24419   if (Narrow->getOpcode() != ISD::XOR &&
24420       Narrow->getOpcode() != ISD::AND &&
24421       Narrow->getOpcode() != ISD::OR)
24422     return SDValue();
24423
24424   SDValue N0  = Narrow->getOperand(0);
24425   SDValue N1  = Narrow->getOperand(1);
24426   SDLoc DL(Narrow);
24427
24428   // The Left side has to be a trunc.
24429   if (N0.getOpcode() != ISD::TRUNCATE)
24430     return SDValue();
24431
24432   // The type of the truncated inputs.
24433   EVT WideVT = N0->getOperand(0)->getValueType(0);
24434   if (WideVT != VT)
24435     return SDValue();
24436
24437   // The right side has to be a 'trunc' or a constant vector.
24438   bool RHSTrunc = N1.getOpcode() == ISD::TRUNCATE;
24439   ConstantSDNode *RHSConstSplat = nullptr;
24440   if (auto *RHSBV = dyn_cast<BuildVectorSDNode>(N1))
24441     RHSConstSplat = RHSBV->getConstantSplatNode();
24442   if (!RHSTrunc && !RHSConstSplat)
24443     return SDValue();
24444
24445   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
24446
24447   if (!TLI.isOperationLegalOrPromote(Narrow->getOpcode(), WideVT))
24448     return SDValue();
24449
24450   // Set N0 and N1 to hold the inputs to the new wide operation.
24451   N0 = N0->getOperand(0);
24452   if (RHSConstSplat) {
24453     N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, WideVT.getScalarType(),
24454                      SDValue(RHSConstSplat, 0));
24455     SmallVector<SDValue, 8> C(WideVT.getVectorNumElements(), N1);
24456     N1 = DAG.getNode(ISD::BUILD_VECTOR, DL, WideVT, C);
24457   } else if (RHSTrunc) {
24458     N1 = N1->getOperand(0);
24459   }
24460
24461   // Generate the wide operation.
24462   SDValue Op = DAG.getNode(Narrow->getOpcode(), DL, WideVT, N0, N1);
24463   unsigned Opcode = N->getOpcode();
24464   switch (Opcode) {
24465   case ISD::ANY_EXTEND:
24466     return Op;
24467   case ISD::ZERO_EXTEND: {
24468     unsigned InBits = NarrowVT.getScalarType().getSizeInBits();
24469     APInt Mask = APInt::getAllOnesValue(InBits);
24470     Mask = Mask.zext(VT.getScalarType().getSizeInBits());
24471     return DAG.getNode(ISD::AND, DL, VT,
24472                        Op, DAG.getConstant(Mask, VT));
24473   }
24474   case ISD::SIGN_EXTEND:
24475     return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT,
24476                        Op, DAG.getValueType(NarrowVT));
24477   default:
24478     llvm_unreachable("Unexpected opcode");
24479   }
24480 }
24481
24482 static SDValue PerformAndCombine(SDNode *N, SelectionDAG &DAG,
24483                                  TargetLowering::DAGCombinerInfo &DCI,
24484                                  const X86Subtarget *Subtarget) {
24485   EVT VT = N->getValueType(0);
24486   if (DCI.isBeforeLegalizeOps())
24487     return SDValue();
24488
24489   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
24490   if (R.getNode())
24491     return R;
24492
24493   // Create BEXTR instructions
24494   // BEXTR is ((X >> imm) & (2**size-1))
24495   if (VT == MVT::i32 || VT == MVT::i64) {
24496     SDValue N0 = N->getOperand(0);
24497     SDValue N1 = N->getOperand(1);
24498     SDLoc DL(N);
24499
24500     // Check for BEXTR.
24501     if ((Subtarget->hasBMI() || Subtarget->hasTBM()) &&
24502         (N0.getOpcode() == ISD::SRA || N0.getOpcode() == ISD::SRL)) {
24503       ConstantSDNode *MaskNode = dyn_cast<ConstantSDNode>(N1);
24504       ConstantSDNode *ShiftNode = dyn_cast<ConstantSDNode>(N0.getOperand(1));
24505       if (MaskNode && ShiftNode) {
24506         uint64_t Mask = MaskNode->getZExtValue();
24507         uint64_t Shift = ShiftNode->getZExtValue();
24508         if (isMask_64(Mask)) {
24509           uint64_t MaskSize = CountPopulation_64(Mask);
24510           if (Shift + MaskSize <= VT.getSizeInBits())
24511             return DAG.getNode(X86ISD::BEXTR, DL, VT, N0.getOperand(0),
24512                                DAG.getConstant(Shift | (MaskSize << 8), VT));
24513         }
24514       }
24515     } // BEXTR
24516
24517     return SDValue();
24518   }
24519
24520   // Want to form ANDNP nodes:
24521   // 1) In the hopes of then easily combining them with OR and AND nodes
24522   //    to form PBLEND/PSIGN.
24523   // 2) To match ANDN packed intrinsics
24524   if (VT != MVT::v2i64 && VT != MVT::v4i64)
24525     return SDValue();
24526
24527   SDValue N0 = N->getOperand(0);
24528   SDValue N1 = N->getOperand(1);
24529   SDLoc DL(N);
24530
24531   // Check LHS for vnot
24532   if (N0.getOpcode() == ISD::XOR &&
24533       //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
24534       CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
24535     return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
24536
24537   // Check RHS for vnot
24538   if (N1.getOpcode() == ISD::XOR &&
24539       //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
24540       CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
24541     return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
24542
24543   return SDValue();
24544 }
24545
24546 static SDValue PerformOrCombine(SDNode *N, SelectionDAG &DAG,
24547                                 TargetLowering::DAGCombinerInfo &DCI,
24548                                 const X86Subtarget *Subtarget) {
24549   if (DCI.isBeforeLegalizeOps())
24550     return SDValue();
24551
24552   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
24553   if (R.getNode())
24554     return R;
24555
24556   SDValue N0 = N->getOperand(0);
24557   SDValue N1 = N->getOperand(1);
24558   EVT VT = N->getValueType(0);
24559
24560   // look for psign/blend
24561   if (VT == MVT::v2i64 || VT == MVT::v4i64) {
24562     if (!Subtarget->hasSSSE3() ||
24563         (VT == MVT::v4i64 && !Subtarget->hasInt256()))
24564       return SDValue();
24565
24566     // Canonicalize pandn to RHS
24567     if (N0.getOpcode() == X86ISD::ANDNP)
24568       std::swap(N0, N1);
24569     // or (and (m, y), (pandn m, x))
24570     if (N0.getOpcode() == ISD::AND && N1.getOpcode() == X86ISD::ANDNP) {
24571       SDValue Mask = N1.getOperand(0);
24572       SDValue X    = N1.getOperand(1);
24573       SDValue Y;
24574       if (N0.getOperand(0) == Mask)
24575         Y = N0.getOperand(1);
24576       if (N0.getOperand(1) == Mask)
24577         Y = N0.getOperand(0);
24578
24579       // Check to see if the mask appeared in both the AND and ANDNP and
24580       if (!Y.getNode())
24581         return SDValue();
24582
24583       // Validate that X, Y, and Mask are BIT_CONVERTS, and see through them.
24584       // Look through mask bitcast.
24585       if (Mask.getOpcode() == ISD::BITCAST)
24586         Mask = Mask.getOperand(0);
24587       if (X.getOpcode() == ISD::BITCAST)
24588         X = X.getOperand(0);
24589       if (Y.getOpcode() == ISD::BITCAST)
24590         Y = Y.getOperand(0);
24591
24592       EVT MaskVT = Mask.getValueType();
24593
24594       // Validate that the Mask operand is a vector sra node.
24595       // FIXME: what to do for bytes, since there is a psignb/pblendvb, but
24596       // there is no psrai.b
24597       unsigned EltBits = MaskVT.getVectorElementType().getSizeInBits();
24598       unsigned SraAmt = ~0;
24599       if (Mask.getOpcode() == ISD::SRA) {
24600         if (auto *AmtBV = dyn_cast<BuildVectorSDNode>(Mask.getOperand(1)))
24601           if (auto *AmtConst = AmtBV->getConstantSplatNode())
24602             SraAmt = AmtConst->getZExtValue();
24603       } else if (Mask.getOpcode() == X86ISD::VSRAI) {
24604         SDValue SraC = Mask.getOperand(1);
24605         SraAmt  = cast<ConstantSDNode>(SraC)->getZExtValue();
24606       }
24607       if ((SraAmt + 1) != EltBits)
24608         return SDValue();
24609
24610       SDLoc DL(N);
24611
24612       // Now we know we at least have a plendvb with the mask val.  See if
24613       // we can form a psignb/w/d.
24614       // psign = x.type == y.type == mask.type && y = sub(0, x);
24615       if (Y.getOpcode() == ISD::SUB && Y.getOperand(1) == X &&
24616           ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
24617           X.getValueType() == MaskVT && Y.getValueType() == MaskVT) {
24618         assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
24619                "Unsupported VT for PSIGN");
24620         Mask = DAG.getNode(X86ISD::PSIGN, DL, MaskVT, X, Mask.getOperand(0));
24621         return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
24622       }
24623       // PBLENDVB only available on SSE 4.1
24624       if (!Subtarget->hasSSE41())
24625         return SDValue();
24626
24627       EVT BlendVT = (VT == MVT::v4i64) ? MVT::v32i8 : MVT::v16i8;
24628
24629       X = DAG.getNode(ISD::BITCAST, DL, BlendVT, X);
24630       Y = DAG.getNode(ISD::BITCAST, DL, BlendVT, Y);
24631       Mask = DAG.getNode(ISD::BITCAST, DL, BlendVT, Mask);
24632       Mask = DAG.getNode(ISD::VSELECT, DL, BlendVT, Mask, Y, X);
24633       return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
24634     }
24635   }
24636
24637   if (VT != MVT::i16 && VT != MVT::i32 && VT != MVT::i64)
24638     return SDValue();
24639
24640   // fold (or (x << c) | (y >> (64 - c))) ==> (shld64 x, y, c)
24641   MachineFunction &MF = DAG.getMachineFunction();
24642   bool OptForSize = MF.getFunction()->getAttributes().
24643     hasAttribute(AttributeSet::FunctionIndex, Attribute::OptimizeForSize);
24644
24645   // SHLD/SHRD instructions have lower register pressure, but on some
24646   // platforms they have higher latency than the equivalent
24647   // series of shifts/or that would otherwise be generated.
24648   // Don't fold (or (x << c) | (y >> (64 - c))) if SHLD/SHRD instructions
24649   // have higher latencies and we are not optimizing for size.
24650   if (!OptForSize && Subtarget->isSHLDSlow())
24651     return SDValue();
24652
24653   if (N0.getOpcode() == ISD::SRL && N1.getOpcode() == ISD::SHL)
24654     std::swap(N0, N1);
24655   if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
24656     return SDValue();
24657   if (!N0.hasOneUse() || !N1.hasOneUse())
24658     return SDValue();
24659
24660   SDValue ShAmt0 = N0.getOperand(1);
24661   if (ShAmt0.getValueType() != MVT::i8)
24662     return SDValue();
24663   SDValue ShAmt1 = N1.getOperand(1);
24664   if (ShAmt1.getValueType() != MVT::i8)
24665     return SDValue();
24666   if (ShAmt0.getOpcode() == ISD::TRUNCATE)
24667     ShAmt0 = ShAmt0.getOperand(0);
24668   if (ShAmt1.getOpcode() == ISD::TRUNCATE)
24669     ShAmt1 = ShAmt1.getOperand(0);
24670
24671   SDLoc DL(N);
24672   unsigned Opc = X86ISD::SHLD;
24673   SDValue Op0 = N0.getOperand(0);
24674   SDValue Op1 = N1.getOperand(0);
24675   if (ShAmt0.getOpcode() == ISD::SUB) {
24676     Opc = X86ISD::SHRD;
24677     std::swap(Op0, Op1);
24678     std::swap(ShAmt0, ShAmt1);
24679   }
24680
24681   unsigned Bits = VT.getSizeInBits();
24682   if (ShAmt1.getOpcode() == ISD::SUB) {
24683     SDValue Sum = ShAmt1.getOperand(0);
24684     if (ConstantSDNode *SumC = dyn_cast<ConstantSDNode>(Sum)) {
24685       SDValue ShAmt1Op1 = ShAmt1.getOperand(1);
24686       if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
24687         ShAmt1Op1 = ShAmt1Op1.getOperand(0);
24688       if (SumC->getSExtValue() == Bits && ShAmt1Op1 == ShAmt0)
24689         return DAG.getNode(Opc, DL, VT,
24690                            Op0, Op1,
24691                            DAG.getNode(ISD::TRUNCATE, DL,
24692                                        MVT::i8, ShAmt0));
24693     }
24694   } else if (ConstantSDNode *ShAmt1C = dyn_cast<ConstantSDNode>(ShAmt1)) {
24695     ConstantSDNode *ShAmt0C = dyn_cast<ConstantSDNode>(ShAmt0);
24696     if (ShAmt0C &&
24697         ShAmt0C->getSExtValue() + ShAmt1C->getSExtValue() == Bits)
24698       return DAG.getNode(Opc, DL, VT,
24699                          N0.getOperand(0), N1.getOperand(0),
24700                          DAG.getNode(ISD::TRUNCATE, DL,
24701                                        MVT::i8, ShAmt0));
24702   }
24703
24704   return SDValue();
24705 }
24706
24707 // Generate NEG and CMOV for integer abs.
24708 static SDValue performIntegerAbsCombine(SDNode *N, SelectionDAG &DAG) {
24709   EVT VT = N->getValueType(0);
24710
24711   // Since X86 does not have CMOV for 8-bit integer, we don't convert
24712   // 8-bit integer abs to NEG and CMOV.
24713   if (VT.isInteger() && VT.getSizeInBits() == 8)
24714     return SDValue();
24715
24716   SDValue N0 = N->getOperand(0);
24717   SDValue N1 = N->getOperand(1);
24718   SDLoc DL(N);
24719
24720   // Check pattern of XOR(ADD(X,Y), Y) where Y is SRA(X, size(X)-1)
24721   // and change it to SUB and CMOV.
24722   if (VT.isInteger() && N->getOpcode() == ISD::XOR &&
24723       N0.getOpcode() == ISD::ADD &&
24724       N0.getOperand(1) == N1 &&
24725       N1.getOpcode() == ISD::SRA &&
24726       N1.getOperand(0) == N0.getOperand(0))
24727     if (ConstantSDNode *Y1C = dyn_cast<ConstantSDNode>(N1.getOperand(1)))
24728       if (Y1C->getAPIntValue() == VT.getSizeInBits()-1) {
24729         // Generate SUB & CMOV.
24730         SDValue Neg = DAG.getNode(X86ISD::SUB, DL, DAG.getVTList(VT, MVT::i32),
24731                                   DAG.getConstant(0, VT), N0.getOperand(0));
24732
24733         SDValue Ops[] = { N0.getOperand(0), Neg,
24734                           DAG.getConstant(X86::COND_GE, MVT::i8),
24735                           SDValue(Neg.getNode(), 1) };
24736         return DAG.getNode(X86ISD::CMOV, DL, DAG.getVTList(VT, MVT::Glue), Ops);
24737       }
24738   return SDValue();
24739 }
24740
24741 // PerformXorCombine - Attempts to turn XOR nodes into BLSMSK nodes
24742 static SDValue PerformXorCombine(SDNode *N, SelectionDAG &DAG,
24743                                  TargetLowering::DAGCombinerInfo &DCI,
24744                                  const X86Subtarget *Subtarget) {
24745   if (DCI.isBeforeLegalizeOps())
24746     return SDValue();
24747
24748   if (Subtarget->hasCMov()) {
24749     SDValue RV = performIntegerAbsCombine(N, DAG);
24750     if (RV.getNode())
24751       return RV;
24752   }
24753
24754   return SDValue();
24755 }
24756
24757 /// PerformLOADCombine - Do target-specific dag combines on LOAD nodes.
24758 static SDValue PerformLOADCombine(SDNode *N, SelectionDAG &DAG,
24759                                   TargetLowering::DAGCombinerInfo &DCI,
24760                                   const X86Subtarget *Subtarget) {
24761   LoadSDNode *Ld = cast<LoadSDNode>(N);
24762   EVT RegVT = Ld->getValueType(0);
24763   EVT MemVT = Ld->getMemoryVT();
24764   SDLoc dl(Ld);
24765   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
24766
24767   // For chips with slow 32-byte unaligned loads, break the 32-byte operation
24768   // into two 16-byte operations.
24769   ISD::LoadExtType Ext = Ld->getExtensionType();
24770   unsigned Alignment = Ld->getAlignment();
24771   bool IsAligned = Alignment == 0 || Alignment >= MemVT.getSizeInBits()/8;
24772   if (RegVT.is256BitVector() && Subtarget->isUnalignedMem32Slow() &&
24773       !DCI.isBeforeLegalizeOps() && !IsAligned && Ext == ISD::NON_EXTLOAD) {
24774     unsigned NumElems = RegVT.getVectorNumElements();
24775     if (NumElems < 2)
24776       return SDValue();
24777
24778     SDValue Ptr = Ld->getBasePtr();
24779     SDValue Increment = DAG.getConstant(16, TLI.getPointerTy());
24780
24781     EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
24782                                   NumElems/2);
24783     SDValue Load1 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
24784                                 Ld->getPointerInfo(), Ld->isVolatile(),
24785                                 Ld->isNonTemporal(), Ld->isInvariant(),
24786                                 Alignment);
24787     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
24788     SDValue Load2 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
24789                                 Ld->getPointerInfo(), Ld->isVolatile(),
24790                                 Ld->isNonTemporal(), Ld->isInvariant(),
24791                                 std::min(16U, Alignment));
24792     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
24793                              Load1.getValue(1),
24794                              Load2.getValue(1));
24795
24796     SDValue NewVec = DAG.getUNDEF(RegVT);
24797     NewVec = Insert128BitVector(NewVec, Load1, 0, DAG, dl);
24798     NewVec = Insert128BitVector(NewVec, Load2, NumElems/2, DAG, dl);
24799     return DCI.CombineTo(N, NewVec, TF, true);
24800   }
24801
24802   return SDValue();
24803 }
24804
24805 /// PerformMLOADCombine - Resolve extending loads
24806 static SDValue PerformMLOADCombine(SDNode *N, SelectionDAG &DAG,
24807                                    TargetLowering::DAGCombinerInfo &DCI,
24808                                    const X86Subtarget *Subtarget) {
24809   MaskedLoadSDNode *Mld = cast<MaskedLoadSDNode>(N);
24810   if (Mld->getExtensionType() != ISD::SEXTLOAD)
24811     return SDValue();
24812
24813   EVT VT = Mld->getValueType(0);
24814   unsigned NumElems = VT.getVectorNumElements();
24815   EVT LdVT = Mld->getMemoryVT();
24816   SDLoc dl(Mld);
24817
24818   assert(LdVT != VT && "Cannot extend to the same type");
24819   unsigned ToSz = VT.getVectorElementType().getSizeInBits();
24820   unsigned FromSz = LdVT.getVectorElementType().getSizeInBits();
24821   // From, To sizes and ElemCount must be pow of two
24822   assert (isPowerOf2_32(NumElems * FromSz * ToSz) &&
24823     "Unexpected size for extending masked load");
24824
24825   unsigned SizeRatio  = ToSz / FromSz;
24826   assert(SizeRatio * NumElems * FromSz == VT.getSizeInBits());
24827
24828   // Create a type on which we perform the shuffle
24829   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
24830           LdVT.getScalarType(), NumElems*SizeRatio);
24831   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
24832
24833   // Convert Src0 value
24834   SDValue WideSrc0 = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mld->getSrc0());
24835   if (Mld->getSrc0().getOpcode() != ISD::UNDEF) {
24836     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
24837     for (unsigned i = 0; i != NumElems; ++i)
24838       ShuffleVec[i] = i * SizeRatio;
24839
24840     // Can't shuffle using an illegal type.
24841     assert (DAG.getTargetLoweringInfo().isTypeLegal(WideVecVT)
24842             && "WideVecVT should be legal");
24843     WideSrc0 = DAG.getVectorShuffle(WideVecVT, dl, WideSrc0,
24844                                     DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
24845   }
24846   // Prepare the new mask
24847   SDValue NewMask;
24848   SDValue Mask = Mld->getMask();
24849   if (Mask.getValueType() == VT) {
24850     // Mask and original value have the same type
24851     NewMask = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mask);
24852     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
24853     for (unsigned i = 0; i != NumElems; ++i)
24854       ShuffleVec[i] = i * SizeRatio;
24855     for (unsigned i = NumElems; i != NumElems*SizeRatio; ++i)
24856       ShuffleVec[i] = NumElems*SizeRatio;
24857     NewMask = DAG.getVectorShuffle(WideVecVT, dl, NewMask,
24858                                    DAG.getConstant(0, WideVecVT),
24859                                    &ShuffleVec[0]);
24860   }
24861   else {
24862     assert(Mask.getValueType().getVectorElementType() == MVT::i1);
24863     unsigned WidenNumElts = NumElems*SizeRatio;
24864     unsigned MaskNumElts = VT.getVectorNumElements();
24865     EVT NewMaskVT = EVT::getVectorVT(*DAG.getContext(),  MVT::i1,
24866                                      WidenNumElts);
24867
24868     unsigned NumConcat = WidenNumElts / MaskNumElts;
24869     SmallVector<SDValue, 16> Ops(NumConcat);
24870     SDValue ZeroVal = DAG.getConstant(0, Mask.getValueType());
24871     Ops[0] = Mask;
24872     for (unsigned i = 1; i != NumConcat; ++i)
24873       Ops[i] = ZeroVal;
24874
24875     NewMask = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewMaskVT, Ops);
24876   }
24877
24878   SDValue WideLd = DAG.getMaskedLoad(WideVecVT, dl, Mld->getChain(),
24879                                      Mld->getBasePtr(), NewMask, WideSrc0,
24880                                      Mld->getMemoryVT(), Mld->getMemOperand(),
24881                                      ISD::NON_EXTLOAD);
24882   SDValue NewVec = DAG.getNode(X86ISD::VSEXT, dl, VT, WideLd);
24883   return DCI.CombineTo(N, NewVec, WideLd.getValue(1), true);
24884
24885 }
24886 /// PerformMSTORECombine - Resolve truncating stores
24887 static SDValue PerformMSTORECombine(SDNode *N, SelectionDAG &DAG,
24888                                     const X86Subtarget *Subtarget) {
24889   MaskedStoreSDNode *Mst = cast<MaskedStoreSDNode>(N);
24890   if (!Mst->isTruncatingStore())
24891     return SDValue();
24892
24893   EVT VT = Mst->getValue().getValueType();
24894   unsigned NumElems = VT.getVectorNumElements();
24895   EVT StVT = Mst->getMemoryVT();
24896   SDLoc dl(Mst);
24897
24898   assert(StVT != VT && "Cannot truncate to the same type");
24899   unsigned FromSz = VT.getVectorElementType().getSizeInBits();
24900   unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
24901
24902   // From, To sizes and ElemCount must be pow of two
24903   assert (isPowerOf2_32(NumElems * FromSz * ToSz) &&
24904     "Unexpected size for truncating masked store");
24905   // We are going to use the original vector elt for storing.
24906   // Accumulated smaller vector elements must be a multiple of the store size.
24907   assert (((NumElems * FromSz) % ToSz) == 0 &&
24908           "Unexpected ratio for truncating masked store");
24909
24910   unsigned SizeRatio  = FromSz / ToSz;
24911   assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
24912
24913   // Create a type on which we perform the shuffle
24914   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
24915           StVT.getScalarType(), NumElems*SizeRatio);
24916
24917   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
24918
24919   SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mst->getValue());
24920   SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
24921   for (unsigned i = 0; i != NumElems; ++i)
24922     ShuffleVec[i] = i * SizeRatio;
24923
24924   // Can't shuffle using an illegal type.
24925   assert (DAG.getTargetLoweringInfo().isTypeLegal(WideVecVT)
24926           && "WideVecVT should be legal");
24927
24928   SDValue TruncatedVal = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
24929                                         DAG.getUNDEF(WideVecVT),
24930                                         &ShuffleVec[0]);
24931
24932   SDValue NewMask;
24933   SDValue Mask = Mst->getMask();
24934   if (Mask.getValueType() == VT) {
24935     // Mask and original value have the same type
24936     NewMask = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mask);
24937     for (unsigned i = 0; i != NumElems; ++i)
24938       ShuffleVec[i] = i * SizeRatio;
24939     for (unsigned i = NumElems; i != NumElems*SizeRatio; ++i)
24940       ShuffleVec[i] = NumElems*SizeRatio;
24941     NewMask = DAG.getVectorShuffle(WideVecVT, dl, NewMask,
24942                                    DAG.getConstant(0, WideVecVT),
24943                                    &ShuffleVec[0]);
24944   }
24945   else {
24946     assert(Mask.getValueType().getVectorElementType() == MVT::i1);
24947     unsigned WidenNumElts = NumElems*SizeRatio;
24948     unsigned MaskNumElts = VT.getVectorNumElements();
24949     EVT NewMaskVT = EVT::getVectorVT(*DAG.getContext(),  MVT::i1,
24950                                      WidenNumElts);
24951
24952     unsigned NumConcat = WidenNumElts / MaskNumElts;
24953     SmallVector<SDValue, 16> Ops(NumConcat);
24954     SDValue ZeroVal = DAG.getConstant(0, Mask.getValueType());
24955     Ops[0] = Mask;
24956     for (unsigned i = 1; i != NumConcat; ++i)
24957       Ops[i] = ZeroVal;
24958
24959     NewMask = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewMaskVT, Ops);
24960   }
24961
24962   return DAG.getMaskedStore(Mst->getChain(), dl, TruncatedVal, Mst->getBasePtr(),
24963                             NewMask, StVT, Mst->getMemOperand(), false);
24964 }
24965 /// PerformSTORECombine - Do target-specific dag combines on STORE nodes.
24966 static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
24967                                    const X86Subtarget *Subtarget) {
24968   StoreSDNode *St = cast<StoreSDNode>(N);
24969   EVT VT = St->getValue().getValueType();
24970   EVT StVT = St->getMemoryVT();
24971   SDLoc dl(St);
24972   SDValue StoredVal = St->getOperand(1);
24973   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
24974
24975   // If we are saving a concatenation of two XMM registers and 32-byte stores
24976   // are slow, such as on Sandy Bridge, perform two 16-byte stores.
24977   unsigned Alignment = St->getAlignment();
24978   bool IsAligned = Alignment == 0 || Alignment >= VT.getSizeInBits()/8;
24979   if (VT.is256BitVector() && Subtarget->isUnalignedMem32Slow() &&
24980       StVT == VT && !IsAligned) {
24981     unsigned NumElems = VT.getVectorNumElements();
24982     if (NumElems < 2)
24983       return SDValue();
24984
24985     SDValue Value0 = Extract128BitVector(StoredVal, 0, DAG, dl);
24986     SDValue Value1 = Extract128BitVector(StoredVal, NumElems/2, DAG, dl);
24987
24988     SDValue Stride = DAG.getConstant(16, TLI.getPointerTy());
24989     SDValue Ptr0 = St->getBasePtr();
24990     SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
24991
24992     SDValue Ch0 = DAG.getStore(St->getChain(), dl, Value0, Ptr0,
24993                                 St->getPointerInfo(), St->isVolatile(),
24994                                 St->isNonTemporal(), Alignment);
24995     SDValue Ch1 = DAG.getStore(St->getChain(), dl, Value1, Ptr1,
24996                                 St->getPointerInfo(), St->isVolatile(),
24997                                 St->isNonTemporal(),
24998                                 std::min(16U, Alignment));
24999     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
25000   }
25001
25002   // Optimize trunc store (of multiple scalars) to shuffle and store.
25003   // First, pack all of the elements in one place. Next, store to memory
25004   // in fewer chunks.
25005   if (St->isTruncatingStore() && VT.isVector()) {
25006     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25007     unsigned NumElems = VT.getVectorNumElements();
25008     assert(StVT != VT && "Cannot truncate to the same type");
25009     unsigned FromSz = VT.getVectorElementType().getSizeInBits();
25010     unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
25011
25012     // From, To sizes and ElemCount must be pow of two
25013     if (!isPowerOf2_32(NumElems * FromSz * ToSz)) return SDValue();
25014     // We are going to use the original vector elt for storing.
25015     // Accumulated smaller vector elements must be a multiple of the store size.
25016     if (0 != (NumElems * FromSz) % ToSz) return SDValue();
25017
25018     unsigned SizeRatio  = FromSz / ToSz;
25019
25020     assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
25021
25022     // Create a type on which we perform the shuffle
25023     EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
25024             StVT.getScalarType(), NumElems*SizeRatio);
25025
25026     assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
25027
25028     SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
25029     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
25030     for (unsigned i = 0; i != NumElems; ++i)
25031       ShuffleVec[i] = i * SizeRatio;
25032
25033     // Can't shuffle using an illegal type.
25034     if (!TLI.isTypeLegal(WideVecVT))
25035       return SDValue();
25036
25037     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
25038                                          DAG.getUNDEF(WideVecVT),
25039                                          &ShuffleVec[0]);
25040     // At this point all of the data is stored at the bottom of the
25041     // register. We now need to save it to mem.
25042
25043     // Find the largest store unit
25044     MVT StoreType = MVT::i8;
25045     for (MVT Tp : MVT::integer_valuetypes()) {
25046       if (TLI.isTypeLegal(Tp) && Tp.getSizeInBits() <= NumElems * ToSz)
25047         StoreType = Tp;
25048     }
25049
25050     // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
25051     if (TLI.isTypeLegal(MVT::f64) && StoreType.getSizeInBits() < 64 &&
25052         (64 <= NumElems * ToSz))
25053       StoreType = MVT::f64;
25054
25055     // Bitcast the original vector into a vector of store-size units
25056     EVT StoreVecVT = EVT::getVectorVT(*DAG.getContext(),
25057             StoreType, VT.getSizeInBits()/StoreType.getSizeInBits());
25058     assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
25059     SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
25060     SmallVector<SDValue, 8> Chains;
25061     SDValue Increment = DAG.getConstant(StoreType.getSizeInBits()/8,
25062                                         TLI.getPointerTy());
25063     SDValue Ptr = St->getBasePtr();
25064
25065     // Perform one or more big stores into memory.
25066     for (unsigned i=0, e=(ToSz*NumElems)/StoreType.getSizeInBits(); i!=e; ++i) {
25067       SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
25068                                    StoreType, ShuffWide,
25069                                    DAG.getIntPtrConstant(i));
25070       SDValue Ch = DAG.getStore(St->getChain(), dl, SubVec, Ptr,
25071                                 St->getPointerInfo(), St->isVolatile(),
25072                                 St->isNonTemporal(), St->getAlignment());
25073       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
25074       Chains.push_back(Ch);
25075     }
25076
25077     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
25078   }
25079
25080   // Turn load->store of MMX types into GPR load/stores.  This avoids clobbering
25081   // the FP state in cases where an emms may be missing.
25082   // A preferable solution to the general problem is to figure out the right
25083   // places to insert EMMS.  This qualifies as a quick hack.
25084
25085   // Similarly, turn load->store of i64 into double load/stores in 32-bit mode.
25086   if (VT.getSizeInBits() != 64)
25087     return SDValue();
25088
25089   const Function *F = DAG.getMachineFunction().getFunction();
25090   bool NoImplicitFloatOps = F->getAttributes().
25091     hasAttribute(AttributeSet::FunctionIndex, Attribute::NoImplicitFloat);
25092   bool F64IsLegal = !DAG.getTarget().Options.UseSoftFloat && !NoImplicitFloatOps
25093                      && Subtarget->hasSSE2();
25094   if ((VT.isVector() ||
25095        (VT == MVT::i64 && F64IsLegal && !Subtarget->is64Bit())) &&
25096       isa<LoadSDNode>(St->getValue()) &&
25097       !cast<LoadSDNode>(St->getValue())->isVolatile() &&
25098       St->getChain().hasOneUse() && !St->isVolatile()) {
25099     SDNode* LdVal = St->getValue().getNode();
25100     LoadSDNode *Ld = nullptr;
25101     int TokenFactorIndex = -1;
25102     SmallVector<SDValue, 8> Ops;
25103     SDNode* ChainVal = St->getChain().getNode();
25104     // Must be a store of a load.  We currently handle two cases:  the load
25105     // is a direct child, and it's under an intervening TokenFactor.  It is
25106     // possible to dig deeper under nested TokenFactors.
25107     if (ChainVal == LdVal)
25108       Ld = cast<LoadSDNode>(St->getChain());
25109     else if (St->getValue().hasOneUse() &&
25110              ChainVal->getOpcode() == ISD::TokenFactor) {
25111       for (unsigned i = 0, e = ChainVal->getNumOperands(); i != e; ++i) {
25112         if (ChainVal->getOperand(i).getNode() == LdVal) {
25113           TokenFactorIndex = i;
25114           Ld = cast<LoadSDNode>(St->getValue());
25115         } else
25116           Ops.push_back(ChainVal->getOperand(i));
25117       }
25118     }
25119
25120     if (!Ld || !ISD::isNormalLoad(Ld))
25121       return SDValue();
25122
25123     // If this is not the MMX case, i.e. we are just turning i64 load/store
25124     // into f64 load/store, avoid the transformation if there are multiple
25125     // uses of the loaded value.
25126     if (!VT.isVector() && !Ld->hasNUsesOfValue(1, 0))
25127       return SDValue();
25128
25129     SDLoc LdDL(Ld);
25130     SDLoc StDL(N);
25131     // If we are a 64-bit capable x86, lower to a single movq load/store pair.
25132     // Otherwise, if it's legal to use f64 SSE instructions, use f64 load/store
25133     // pair instead.
25134     if (Subtarget->is64Bit() || F64IsLegal) {
25135       EVT LdVT = Subtarget->is64Bit() ? MVT::i64 : MVT::f64;
25136       SDValue NewLd = DAG.getLoad(LdVT, LdDL, Ld->getChain(), Ld->getBasePtr(),
25137                                   Ld->getPointerInfo(), Ld->isVolatile(),
25138                                   Ld->isNonTemporal(), Ld->isInvariant(),
25139                                   Ld->getAlignment());
25140       SDValue NewChain = NewLd.getValue(1);
25141       if (TokenFactorIndex != -1) {
25142         Ops.push_back(NewChain);
25143         NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
25144       }
25145       return DAG.getStore(NewChain, StDL, NewLd, St->getBasePtr(),
25146                           St->getPointerInfo(),
25147                           St->isVolatile(), St->isNonTemporal(),
25148                           St->getAlignment());
25149     }
25150
25151     // Otherwise, lower to two pairs of 32-bit loads / stores.
25152     SDValue LoAddr = Ld->getBasePtr();
25153     SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
25154                                  DAG.getConstant(4, MVT::i32));
25155
25156     SDValue LoLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), LoAddr,
25157                                Ld->getPointerInfo(),
25158                                Ld->isVolatile(), Ld->isNonTemporal(),
25159                                Ld->isInvariant(), Ld->getAlignment());
25160     SDValue HiLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), HiAddr,
25161                                Ld->getPointerInfo().getWithOffset(4),
25162                                Ld->isVolatile(), Ld->isNonTemporal(),
25163                                Ld->isInvariant(),
25164                                MinAlign(Ld->getAlignment(), 4));
25165
25166     SDValue NewChain = LoLd.getValue(1);
25167     if (TokenFactorIndex != -1) {
25168       Ops.push_back(LoLd);
25169       Ops.push_back(HiLd);
25170       NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
25171     }
25172
25173     LoAddr = St->getBasePtr();
25174     HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
25175                          DAG.getConstant(4, MVT::i32));
25176
25177     SDValue LoSt = DAG.getStore(NewChain, StDL, LoLd, LoAddr,
25178                                 St->getPointerInfo(),
25179                                 St->isVolatile(), St->isNonTemporal(),
25180                                 St->getAlignment());
25181     SDValue HiSt = DAG.getStore(NewChain, StDL, HiLd, HiAddr,
25182                                 St->getPointerInfo().getWithOffset(4),
25183                                 St->isVolatile(),
25184                                 St->isNonTemporal(),
25185                                 MinAlign(St->getAlignment(), 4));
25186     return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
25187   }
25188   return SDValue();
25189 }
25190
25191 /// Return 'true' if this vector operation is "horizontal"
25192 /// and return the operands for the horizontal operation in LHS and RHS.  A
25193 /// horizontal operation performs the binary operation on successive elements
25194 /// of its first operand, then on successive elements of its second operand,
25195 /// returning the resulting values in a vector.  For example, if
25196 ///   A = < float a0, float a1, float a2, float a3 >
25197 /// and
25198 ///   B = < float b0, float b1, float b2, float b3 >
25199 /// then the result of doing a horizontal operation on A and B is
25200 ///   A horizontal-op B = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >.
25201 /// In short, LHS and RHS are inspected to see if LHS op RHS is of the form
25202 /// A horizontal-op B, for some already available A and B, and if so then LHS is
25203 /// set to A, RHS to B, and the routine returns 'true'.
25204 /// Note that the binary operation should have the property that if one of the
25205 /// operands is UNDEF then the result is UNDEF.
25206 static bool isHorizontalBinOp(SDValue &LHS, SDValue &RHS, bool IsCommutative) {
25207   // Look for the following pattern: if
25208   //   A = < float a0, float a1, float a2, float a3 >
25209   //   B = < float b0, float b1, float b2, float b3 >
25210   // and
25211   //   LHS = VECTOR_SHUFFLE A, B, <0, 2, 4, 6>
25212   //   RHS = VECTOR_SHUFFLE A, B, <1, 3, 5, 7>
25213   // then LHS op RHS = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >
25214   // which is A horizontal-op B.
25215
25216   // At least one of the operands should be a vector shuffle.
25217   if (LHS.getOpcode() != ISD::VECTOR_SHUFFLE &&
25218       RHS.getOpcode() != ISD::VECTOR_SHUFFLE)
25219     return false;
25220
25221   MVT VT = LHS.getSimpleValueType();
25222
25223   assert((VT.is128BitVector() || VT.is256BitVector()) &&
25224          "Unsupported vector type for horizontal add/sub");
25225
25226   // Handle 128 and 256-bit vector lengths. AVX defines horizontal add/sub to
25227   // operate independently on 128-bit lanes.
25228   unsigned NumElts = VT.getVectorNumElements();
25229   unsigned NumLanes = VT.getSizeInBits()/128;
25230   unsigned NumLaneElts = NumElts / NumLanes;
25231   assert((NumLaneElts % 2 == 0) &&
25232          "Vector type should have an even number of elements in each lane");
25233   unsigned HalfLaneElts = NumLaneElts/2;
25234
25235   // View LHS in the form
25236   //   LHS = VECTOR_SHUFFLE A, B, LMask
25237   // If LHS is not a shuffle then pretend it is the shuffle
25238   //   LHS = VECTOR_SHUFFLE LHS, undef, <0, 1, ..., N-1>
25239   // NOTE: in what follows a default initialized SDValue represents an UNDEF of
25240   // type VT.
25241   SDValue A, B;
25242   SmallVector<int, 16> LMask(NumElts);
25243   if (LHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
25244     if (LHS.getOperand(0).getOpcode() != ISD::UNDEF)
25245       A = LHS.getOperand(0);
25246     if (LHS.getOperand(1).getOpcode() != ISD::UNDEF)
25247       B = LHS.getOperand(1);
25248     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(LHS.getNode())->getMask();
25249     std::copy(Mask.begin(), Mask.end(), LMask.begin());
25250   } else {
25251     if (LHS.getOpcode() != ISD::UNDEF)
25252       A = LHS;
25253     for (unsigned i = 0; i != NumElts; ++i)
25254       LMask[i] = i;
25255   }
25256
25257   // Likewise, view RHS in the form
25258   //   RHS = VECTOR_SHUFFLE C, D, RMask
25259   SDValue C, D;
25260   SmallVector<int, 16> RMask(NumElts);
25261   if (RHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
25262     if (RHS.getOperand(0).getOpcode() != ISD::UNDEF)
25263       C = RHS.getOperand(0);
25264     if (RHS.getOperand(1).getOpcode() != ISD::UNDEF)
25265       D = RHS.getOperand(1);
25266     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(RHS.getNode())->getMask();
25267     std::copy(Mask.begin(), Mask.end(), RMask.begin());
25268   } else {
25269     if (RHS.getOpcode() != ISD::UNDEF)
25270       C = RHS;
25271     for (unsigned i = 0; i != NumElts; ++i)
25272       RMask[i] = i;
25273   }
25274
25275   // Check that the shuffles are both shuffling the same vectors.
25276   if (!(A == C && B == D) && !(A == D && B == C))
25277     return false;
25278
25279   // If everything is UNDEF then bail out: it would be better to fold to UNDEF.
25280   if (!A.getNode() && !B.getNode())
25281     return false;
25282
25283   // If A and B occur in reverse order in RHS, then "swap" them (which means
25284   // rewriting the mask).
25285   if (A != C)
25286     CommuteVectorShuffleMask(RMask, NumElts);
25287
25288   // At this point LHS and RHS are equivalent to
25289   //   LHS = VECTOR_SHUFFLE A, B, LMask
25290   //   RHS = VECTOR_SHUFFLE A, B, RMask
25291   // Check that the masks correspond to performing a horizontal operation.
25292   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
25293     for (unsigned i = 0; i != NumLaneElts; ++i) {
25294       int LIdx = LMask[i+l], RIdx = RMask[i+l];
25295
25296       // Ignore any UNDEF components.
25297       if (LIdx < 0 || RIdx < 0 ||
25298           (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
25299           (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
25300         continue;
25301
25302       // Check that successive elements are being operated on.  If not, this is
25303       // not a horizontal operation.
25304       unsigned Src = (i/HalfLaneElts); // each lane is split between srcs
25305       int Index = 2*(i%HalfLaneElts) + NumElts*Src + l;
25306       if (!(LIdx == Index && RIdx == Index + 1) &&
25307           !(IsCommutative && LIdx == Index + 1 && RIdx == Index))
25308         return false;
25309     }
25310   }
25311
25312   LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
25313   RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
25314   return true;
25315 }
25316
25317 /// Do target-specific dag combines on floating point adds.
25318 static SDValue PerformFADDCombine(SDNode *N, SelectionDAG &DAG,
25319                                   const X86Subtarget *Subtarget) {
25320   EVT VT = N->getValueType(0);
25321   SDValue LHS = N->getOperand(0);
25322   SDValue RHS = N->getOperand(1);
25323
25324   // Try to synthesize horizontal adds from adds of shuffles.
25325   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
25326        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
25327       isHorizontalBinOp(LHS, RHS, true))
25328     return DAG.getNode(X86ISD::FHADD, SDLoc(N), VT, LHS, RHS);
25329   return SDValue();
25330 }
25331
25332 /// Do target-specific dag combines on floating point subs.
25333 static SDValue PerformFSUBCombine(SDNode *N, SelectionDAG &DAG,
25334                                   const X86Subtarget *Subtarget) {
25335   EVT VT = N->getValueType(0);
25336   SDValue LHS = N->getOperand(0);
25337   SDValue RHS = N->getOperand(1);
25338
25339   // Try to synthesize horizontal subs from subs of shuffles.
25340   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
25341        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
25342       isHorizontalBinOp(LHS, RHS, false))
25343     return DAG.getNode(X86ISD::FHSUB, SDLoc(N), VT, LHS, RHS);
25344   return SDValue();
25345 }
25346
25347 /// Do target-specific dag combines on X86ISD::FOR and X86ISD::FXOR nodes.
25348 static SDValue PerformFORCombine(SDNode *N, SelectionDAG &DAG) {
25349   assert(N->getOpcode() == X86ISD::FOR || N->getOpcode() == X86ISD::FXOR);
25350   // F[X]OR(0.0, x) -> x
25351   // F[X]OR(x, 0.0) -> x
25352   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25353     if (C->getValueAPF().isPosZero())
25354       return N->getOperand(1);
25355   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
25356     if (C->getValueAPF().isPosZero())
25357       return N->getOperand(0);
25358   return SDValue();
25359 }
25360
25361 /// Do target-specific dag combines on X86ISD::FMIN and X86ISD::FMAX nodes.
25362 static SDValue PerformFMinFMaxCombine(SDNode *N, SelectionDAG &DAG) {
25363   assert(N->getOpcode() == X86ISD::FMIN || N->getOpcode() == X86ISD::FMAX);
25364
25365   // Only perform optimizations if UnsafeMath is used.
25366   if (!DAG.getTarget().Options.UnsafeFPMath)
25367     return SDValue();
25368
25369   // If we run in unsafe-math mode, then convert the FMAX and FMIN nodes
25370   // into FMINC and FMAXC, which are Commutative operations.
25371   unsigned NewOp = 0;
25372   switch (N->getOpcode()) {
25373     default: llvm_unreachable("unknown opcode");
25374     case X86ISD::FMIN:  NewOp = X86ISD::FMINC; break;
25375     case X86ISD::FMAX:  NewOp = X86ISD::FMAXC; break;
25376   }
25377
25378   return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
25379                      N->getOperand(0), N->getOperand(1));
25380 }
25381
25382 /// Do target-specific dag combines on X86ISD::FAND nodes.
25383 static SDValue PerformFANDCombine(SDNode *N, SelectionDAG &DAG) {
25384   // FAND(0.0, x) -> 0.0
25385   // FAND(x, 0.0) -> 0.0
25386   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25387     if (C->getValueAPF().isPosZero())
25388       return N->getOperand(0);
25389   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
25390     if (C->getValueAPF().isPosZero())
25391       return N->getOperand(1);
25392   return SDValue();
25393 }
25394
25395 /// Do target-specific dag combines on X86ISD::FANDN nodes
25396 static SDValue PerformFANDNCombine(SDNode *N, SelectionDAG &DAG) {
25397   // FANDN(x, 0.0) -> 0.0
25398   // FANDN(0.0, x) -> x
25399   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
25400     if (C->getValueAPF().isPosZero())
25401       return N->getOperand(1);
25402   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
25403     if (C->getValueAPF().isPosZero())
25404       return N->getOperand(1);
25405   return SDValue();
25406 }
25407
25408 static SDValue PerformBTCombine(SDNode *N,
25409                                 SelectionDAG &DAG,
25410                                 TargetLowering::DAGCombinerInfo &DCI) {
25411   // BT ignores high bits in the bit index operand.
25412   SDValue Op1 = N->getOperand(1);
25413   if (Op1.hasOneUse()) {
25414     unsigned BitWidth = Op1.getValueSizeInBits();
25415     APInt DemandedMask = APInt::getLowBitsSet(BitWidth, Log2_32(BitWidth));
25416     APInt KnownZero, KnownOne;
25417     TargetLowering::TargetLoweringOpt TLO(DAG, !DCI.isBeforeLegalize(),
25418                                           !DCI.isBeforeLegalizeOps());
25419     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
25420     if (TLO.ShrinkDemandedConstant(Op1, DemandedMask) ||
25421         TLI.SimplifyDemandedBits(Op1, DemandedMask, KnownZero, KnownOne, TLO))
25422       DCI.CommitTargetLoweringOpt(TLO);
25423   }
25424   return SDValue();
25425 }
25426
25427 static SDValue PerformVZEXT_MOVLCombine(SDNode *N, SelectionDAG &DAG) {
25428   SDValue Op = N->getOperand(0);
25429   if (Op.getOpcode() == ISD::BITCAST)
25430     Op = Op.getOperand(0);
25431   EVT VT = N->getValueType(0), OpVT = Op.getValueType();
25432   if (Op.getOpcode() == X86ISD::VZEXT_LOAD &&
25433       VT.getVectorElementType().getSizeInBits() ==
25434       OpVT.getVectorElementType().getSizeInBits()) {
25435     return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
25436   }
25437   return SDValue();
25438 }
25439
25440 static SDValue PerformSIGN_EXTEND_INREGCombine(SDNode *N, SelectionDAG &DAG,
25441                                                const X86Subtarget *Subtarget) {
25442   EVT VT = N->getValueType(0);
25443   if (!VT.isVector())
25444     return SDValue();
25445
25446   SDValue N0 = N->getOperand(0);
25447   SDValue N1 = N->getOperand(1);
25448   EVT ExtraVT = cast<VTSDNode>(N1)->getVT();
25449   SDLoc dl(N);
25450
25451   // The SIGN_EXTEND_INREG to v4i64 is expensive operation on the
25452   // both SSE and AVX2 since there is no sign-extended shift right
25453   // operation on a vector with 64-bit elements.
25454   //(sext_in_reg (v4i64 anyext (v4i32 x )), ExtraVT) ->
25455   // (v4i64 sext (v4i32 sext_in_reg (v4i32 x , ExtraVT)))
25456   if (VT == MVT::v4i64 && (N0.getOpcode() == ISD::ANY_EXTEND ||
25457       N0.getOpcode() == ISD::SIGN_EXTEND)) {
25458     SDValue N00 = N0.getOperand(0);
25459
25460     // EXTLOAD has a better solution on AVX2,
25461     // it may be replaced with X86ISD::VSEXT node.
25462     if (N00.getOpcode() == ISD::LOAD && Subtarget->hasInt256())
25463       if (!ISD::isNormalLoad(N00.getNode()))
25464         return SDValue();
25465
25466     if (N00.getValueType() == MVT::v4i32 && ExtraVT.getSizeInBits() < 128) {
25467         SDValue Tmp = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32,
25468                                   N00, N1);
25469       return DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i64, Tmp);
25470     }
25471   }
25472   return SDValue();
25473 }
25474
25475 static SDValue PerformSExtCombine(SDNode *N, SelectionDAG &DAG,
25476                                   TargetLowering::DAGCombinerInfo &DCI,
25477                                   const X86Subtarget *Subtarget) {
25478   SDValue N0 = N->getOperand(0);
25479   EVT VT = N->getValueType(0);
25480
25481   // (i8,i32 sext (sdivrem (i8 x, i8 y)) ->
25482   // (i8,i32 (sdivrem_sext_hreg (i8 x, i8 y)
25483   // This exposes the sext to the sdivrem lowering, so that it directly extends
25484   // from AH (which we otherwise need to do contortions to access).
25485   if (N0.getOpcode() == ISD::SDIVREM && N0.getResNo() == 1 &&
25486       N0.getValueType() == MVT::i8 && VT == MVT::i32) {
25487     SDLoc dl(N);
25488     SDVTList NodeTys = DAG.getVTList(MVT::i8, VT);
25489     SDValue R = DAG.getNode(X86ISD::SDIVREM8_SEXT_HREG, dl, NodeTys,
25490                             N0.getOperand(0), N0.getOperand(1));
25491     DAG.ReplaceAllUsesOfValueWith(N0.getValue(0), R.getValue(0));
25492     return R.getValue(1);
25493   }
25494
25495   if (!DCI.isBeforeLegalizeOps())
25496     return SDValue();
25497
25498   if (!Subtarget->hasFp256())
25499     return SDValue();
25500
25501   if (VT.isVector() && VT.getSizeInBits() == 256) {
25502     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
25503     if (R.getNode())
25504       return R;
25505   }
25506
25507   return SDValue();
25508 }
25509
25510 static SDValue PerformFMACombine(SDNode *N, SelectionDAG &DAG,
25511                                  const X86Subtarget* Subtarget) {
25512   SDLoc dl(N);
25513   EVT VT = N->getValueType(0);
25514
25515   // Let legalize expand this if it isn't a legal type yet.
25516   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
25517     return SDValue();
25518
25519   EVT ScalarVT = VT.getScalarType();
25520   if ((ScalarVT != MVT::f32 && ScalarVT != MVT::f64) ||
25521       (!Subtarget->hasFMA() && !Subtarget->hasFMA4()))
25522     return SDValue();
25523
25524   SDValue A = N->getOperand(0);
25525   SDValue B = N->getOperand(1);
25526   SDValue C = N->getOperand(2);
25527
25528   bool NegA = (A.getOpcode() == ISD::FNEG);
25529   bool NegB = (B.getOpcode() == ISD::FNEG);
25530   bool NegC = (C.getOpcode() == ISD::FNEG);
25531
25532   // Negative multiplication when NegA xor NegB
25533   bool NegMul = (NegA != NegB);
25534   if (NegA)
25535     A = A.getOperand(0);
25536   if (NegB)
25537     B = B.getOperand(0);
25538   if (NegC)
25539     C = C.getOperand(0);
25540
25541   unsigned Opcode;
25542   if (!NegMul)
25543     Opcode = (!NegC) ? X86ISD::FMADD : X86ISD::FMSUB;
25544   else
25545     Opcode = (!NegC) ? X86ISD::FNMADD : X86ISD::FNMSUB;
25546
25547   return DAG.getNode(Opcode, dl, VT, A, B, C);
25548 }
25549
25550 static SDValue PerformZExtCombine(SDNode *N, SelectionDAG &DAG,
25551                                   TargetLowering::DAGCombinerInfo &DCI,
25552                                   const X86Subtarget *Subtarget) {
25553   // (i32 zext (and (i8  x86isd::setcc_carry), 1)) ->
25554   //           (and (i32 x86isd::setcc_carry), 1)
25555   // This eliminates the zext. This transformation is necessary because
25556   // ISD::SETCC is always legalized to i8.
25557   SDLoc dl(N);
25558   SDValue N0 = N->getOperand(0);
25559   EVT VT = N->getValueType(0);
25560
25561   if (N0.getOpcode() == ISD::AND &&
25562       N0.hasOneUse() &&
25563       N0.getOperand(0).hasOneUse()) {
25564     SDValue N00 = N0.getOperand(0);
25565     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
25566       ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
25567       if (!C || C->getZExtValue() != 1)
25568         return SDValue();
25569       return DAG.getNode(ISD::AND, dl, VT,
25570                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
25571                                      N00.getOperand(0), N00.getOperand(1)),
25572                          DAG.getConstant(1, VT));
25573     }
25574   }
25575
25576   if (N0.getOpcode() == ISD::TRUNCATE &&
25577       N0.hasOneUse() &&
25578       N0.getOperand(0).hasOneUse()) {
25579     SDValue N00 = N0.getOperand(0);
25580     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
25581       return DAG.getNode(ISD::AND, dl, VT,
25582                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
25583                                      N00.getOperand(0), N00.getOperand(1)),
25584                          DAG.getConstant(1, VT));
25585     }
25586   }
25587   if (VT.is256BitVector()) {
25588     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
25589     if (R.getNode())
25590       return R;
25591   }
25592
25593   // (i8,i32 zext (udivrem (i8 x, i8 y)) ->
25594   // (i8,i32 (udivrem_zext_hreg (i8 x, i8 y)
25595   // This exposes the zext to the udivrem lowering, so that it directly extends
25596   // from AH (which we otherwise need to do contortions to access).
25597   if (N0.getOpcode() == ISD::UDIVREM &&
25598       N0.getResNo() == 1 && N0.getValueType() == MVT::i8 &&
25599       (VT == MVT::i32 || VT == MVT::i64)) {
25600     SDVTList NodeTys = DAG.getVTList(MVT::i8, VT);
25601     SDValue R = DAG.getNode(X86ISD::UDIVREM8_ZEXT_HREG, dl, NodeTys,
25602                             N0.getOperand(0), N0.getOperand(1));
25603     DAG.ReplaceAllUsesOfValueWith(N0.getValue(0), R.getValue(0));
25604     return R.getValue(1);
25605   }
25606
25607   return SDValue();
25608 }
25609
25610 // Optimize x == -y --> x+y == 0
25611 //          x != -y --> x+y != 0
25612 static SDValue PerformISDSETCCCombine(SDNode *N, SelectionDAG &DAG,
25613                                       const X86Subtarget* Subtarget) {
25614   ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
25615   SDValue LHS = N->getOperand(0);
25616   SDValue RHS = N->getOperand(1);
25617   EVT VT = N->getValueType(0);
25618   SDLoc DL(N);
25619
25620   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && LHS.getOpcode() == ISD::SUB)
25621     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHS.getOperand(0)))
25622       if (C->getAPIntValue() == 0 && LHS.hasOneUse()) {
25623         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
25624                                    LHS.getValueType(), RHS, LHS.getOperand(1));
25625         return DAG.getSetCC(SDLoc(N), N->getValueType(0),
25626                             addV, DAG.getConstant(0, addV.getValueType()), CC);
25627       }
25628   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && RHS.getOpcode() == ISD::SUB)
25629     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS.getOperand(0)))
25630       if (C->getAPIntValue() == 0 && RHS.hasOneUse()) {
25631         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
25632                                    RHS.getValueType(), LHS, RHS.getOperand(1));
25633         return DAG.getSetCC(SDLoc(N), N->getValueType(0),
25634                             addV, DAG.getConstant(0, addV.getValueType()), CC);
25635       }
25636
25637   if (VT.getScalarType() == MVT::i1) {
25638     bool IsSEXT0 = (LHS.getOpcode() == ISD::SIGN_EXTEND) &&
25639       (LHS.getOperand(0).getValueType().getScalarType() ==  MVT::i1);
25640     bool IsVZero0 = ISD::isBuildVectorAllZeros(LHS.getNode());
25641     if (!IsSEXT0 && !IsVZero0)
25642       return SDValue();
25643     bool IsSEXT1 = (RHS.getOpcode() == ISD::SIGN_EXTEND) &&
25644       (RHS.getOperand(0).getValueType().getScalarType() ==  MVT::i1);
25645     bool IsVZero1 = ISD::isBuildVectorAllZeros(RHS.getNode());
25646
25647     if (!IsSEXT1 && !IsVZero1)
25648       return SDValue();
25649
25650     if (IsSEXT0 && IsVZero1) {
25651       assert(VT == LHS.getOperand(0).getValueType() && "Uexpected operand type");
25652       if (CC == ISD::SETEQ)
25653         return DAG.getNOT(DL, LHS.getOperand(0), VT);
25654       return LHS.getOperand(0);
25655     }
25656     if (IsSEXT1 && IsVZero0) {
25657       assert(VT == RHS.getOperand(0).getValueType() && "Uexpected operand type");
25658       if (CC == ISD::SETEQ)
25659         return DAG.getNOT(DL, RHS.getOperand(0), VT);
25660       return RHS.getOperand(0);
25661     }
25662   }
25663
25664   return SDValue();
25665 }
25666
25667 static SDValue PerformINSERTPSCombine(SDNode *N, SelectionDAG &DAG,
25668                                       const X86Subtarget *Subtarget) {
25669   SDLoc dl(N);
25670   MVT VT = N->getOperand(1)->getSimpleValueType(0);
25671   assert((VT == MVT::v4f32 || VT == MVT::v4i32) &&
25672          "X86insertps is only defined for v4x32");
25673
25674   SDValue Ld = N->getOperand(1);
25675   if (MayFoldLoad(Ld)) {
25676     // Extract the countS bits from the immediate so we can get the proper
25677     // address when narrowing the vector load to a specific element.
25678     // When the second source op is a memory address, interps doesn't use
25679     // countS and just gets an f32 from that address.
25680     unsigned DestIndex =
25681         cast<ConstantSDNode>(N->getOperand(2))->getZExtValue() >> 6;
25682     Ld = NarrowVectorLoadToElement(cast<LoadSDNode>(Ld), DestIndex, DAG);
25683   } else
25684     return SDValue();
25685
25686   // Create this as a scalar to vector to match the instruction pattern.
25687   SDValue LoadScalarToVector = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Ld);
25688   // countS bits are ignored when loading from memory on insertps, which
25689   // means we don't need to explicitly set them to 0.
25690   return DAG.getNode(X86ISD::INSERTPS, dl, VT, N->getOperand(0),
25691                      LoadScalarToVector, N->getOperand(2));
25692 }
25693
25694 // Helper function of PerformSETCCCombine. It is to materialize "setb reg"
25695 // as "sbb reg,reg", since it can be extended without zext and produces
25696 // an all-ones bit which is more useful than 0/1 in some cases.
25697 static SDValue MaterializeSETB(SDLoc DL, SDValue EFLAGS, SelectionDAG &DAG,
25698                                MVT VT) {
25699   if (VT == MVT::i8)
25700     return DAG.getNode(ISD::AND, DL, VT,
25701                        DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
25702                                    DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS),
25703                        DAG.getConstant(1, VT));
25704   assert (VT == MVT::i1 && "Unexpected type for SECCC node");
25705   return DAG.getNode(ISD::TRUNCATE, DL, MVT::i1,
25706                      DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
25707                                  DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS));
25708 }
25709
25710 // Optimize  RES = X86ISD::SETCC CONDCODE, EFLAG_INPUT
25711 static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG &DAG,
25712                                    TargetLowering::DAGCombinerInfo &DCI,
25713                                    const X86Subtarget *Subtarget) {
25714   SDLoc DL(N);
25715   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(0));
25716   SDValue EFLAGS = N->getOperand(1);
25717
25718   if (CC == X86::COND_A) {
25719     // Try to convert COND_A into COND_B in an attempt to facilitate
25720     // materializing "setb reg".
25721     //
25722     // Do not flip "e > c", where "c" is a constant, because Cmp instruction
25723     // cannot take an immediate as its first operand.
25724     //
25725     if (EFLAGS.getOpcode() == X86ISD::SUB && EFLAGS.hasOneUse() &&
25726         EFLAGS.getValueType().isInteger() &&
25727         !isa<ConstantSDNode>(EFLAGS.getOperand(1))) {
25728       SDValue NewSub = DAG.getNode(X86ISD::SUB, SDLoc(EFLAGS),
25729                                    EFLAGS.getNode()->getVTList(),
25730                                    EFLAGS.getOperand(1), EFLAGS.getOperand(0));
25731       SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
25732       return MaterializeSETB(DL, NewEFLAGS, DAG, N->getSimpleValueType(0));
25733     }
25734   }
25735
25736   // Materialize "setb reg" as "sbb reg,reg", since it can be extended without
25737   // a zext and produces an all-ones bit which is more useful than 0/1 in some
25738   // cases.
25739   if (CC == X86::COND_B)
25740     return MaterializeSETB(DL, EFLAGS, DAG, N->getSimpleValueType(0));
25741
25742   SDValue Flags;
25743
25744   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
25745   if (Flags.getNode()) {
25746     SDValue Cond = DAG.getConstant(CC, MVT::i8);
25747     return DAG.getNode(X86ISD::SETCC, DL, N->getVTList(), Cond, Flags);
25748   }
25749
25750   return SDValue();
25751 }
25752
25753 // Optimize branch condition evaluation.
25754 //
25755 static SDValue PerformBrCondCombine(SDNode *N, SelectionDAG &DAG,
25756                                     TargetLowering::DAGCombinerInfo &DCI,
25757                                     const X86Subtarget *Subtarget) {
25758   SDLoc DL(N);
25759   SDValue Chain = N->getOperand(0);
25760   SDValue Dest = N->getOperand(1);
25761   SDValue EFLAGS = N->getOperand(3);
25762   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(2));
25763
25764   SDValue Flags;
25765
25766   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
25767   if (Flags.getNode()) {
25768     SDValue Cond = DAG.getConstant(CC, MVT::i8);
25769     return DAG.getNode(X86ISD::BRCOND, DL, N->getVTList(), Chain, Dest, Cond,
25770                        Flags);
25771   }
25772
25773   return SDValue();
25774 }
25775
25776 static SDValue performVectorCompareAndMaskUnaryOpCombine(SDNode *N,
25777                                                          SelectionDAG &DAG) {
25778   // Take advantage of vector comparisons producing 0 or -1 in each lane to
25779   // optimize away operation when it's from a constant.
25780   //
25781   // The general transformation is:
25782   //    UNARYOP(AND(VECTOR_CMP(x,y), constant)) -->
25783   //       AND(VECTOR_CMP(x,y), constant2)
25784   //    constant2 = UNARYOP(constant)
25785
25786   // Early exit if this isn't a vector operation, the operand of the
25787   // unary operation isn't a bitwise AND, or if the sizes of the operations
25788   // aren't the same.
25789   EVT VT = N->getValueType(0);
25790   if (!VT.isVector() || N->getOperand(0)->getOpcode() != ISD::AND ||
25791       N->getOperand(0)->getOperand(0)->getOpcode() != ISD::SETCC ||
25792       VT.getSizeInBits() != N->getOperand(0)->getValueType(0).getSizeInBits())
25793     return SDValue();
25794
25795   // Now check that the other operand of the AND is a constant. We could
25796   // make the transformation for non-constant splats as well, but it's unclear
25797   // that would be a benefit as it would not eliminate any operations, just
25798   // perform one more step in scalar code before moving to the vector unit.
25799   if (BuildVectorSDNode *BV =
25800           dyn_cast<BuildVectorSDNode>(N->getOperand(0)->getOperand(1))) {
25801     // Bail out if the vector isn't a constant.
25802     if (!BV->isConstant())
25803       return SDValue();
25804
25805     // Everything checks out. Build up the new and improved node.
25806     SDLoc DL(N);
25807     EVT IntVT = BV->getValueType(0);
25808     // Create a new constant of the appropriate type for the transformed
25809     // DAG.
25810     SDValue SourceConst = DAG.getNode(N->getOpcode(), DL, VT, SDValue(BV, 0));
25811     // The AND node needs bitcasts to/from an integer vector type around it.
25812     SDValue MaskConst = DAG.getNode(ISD::BITCAST, DL, IntVT, SourceConst);
25813     SDValue NewAnd = DAG.getNode(ISD::AND, DL, IntVT,
25814                                  N->getOperand(0)->getOperand(0), MaskConst);
25815     SDValue Res = DAG.getNode(ISD::BITCAST, DL, VT, NewAnd);
25816     return Res;
25817   }
25818
25819   return SDValue();
25820 }
25821
25822 static SDValue PerformSINT_TO_FPCombine(SDNode *N, SelectionDAG &DAG,
25823                                         const X86TargetLowering *XTLI) {
25824   // First try to optimize away the conversion entirely when it's
25825   // conditionally from a constant. Vectors only.
25826   SDValue Res = performVectorCompareAndMaskUnaryOpCombine(N, DAG);
25827   if (Res != SDValue())
25828     return Res;
25829
25830   // Now move on to more general possibilities.
25831   SDValue Op0 = N->getOperand(0);
25832   EVT InVT = Op0->getValueType(0);
25833
25834   // SINT_TO_FP(v4i8) -> SINT_TO_FP(SEXT(v4i8 to v4i32))
25835   if (InVT == MVT::v8i8 || InVT == MVT::v4i8) {
25836     SDLoc dl(N);
25837     MVT DstVT = InVT == MVT::v4i8 ? MVT::v4i32 : MVT::v8i32;
25838     SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
25839     return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
25840   }
25841
25842   // Transform (SINT_TO_FP (i64 ...)) into an x87 operation if we have
25843   // a 32-bit target where SSE doesn't support i64->FP operations.
25844   if (Op0.getOpcode() == ISD::LOAD) {
25845     LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
25846     EVT VT = Ld->getValueType(0);
25847     if (!Ld->isVolatile() && !N->getValueType(0).isVector() &&
25848         ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
25849         !XTLI->getSubtarget()->is64Bit() &&
25850         VT == MVT::i64) {
25851       SDValue FILDChain = XTLI->BuildFILD(SDValue(N, 0), Ld->getValueType(0),
25852                                           Ld->getChain(), Op0, DAG);
25853       DAG.ReplaceAllUsesOfValueWith(Op0.getValue(1), FILDChain.getValue(1));
25854       return FILDChain;
25855     }
25856   }
25857   return SDValue();
25858 }
25859
25860 // Optimize RES, EFLAGS = X86ISD::ADC LHS, RHS, EFLAGS
25861 static SDValue PerformADCCombine(SDNode *N, SelectionDAG &DAG,
25862                                  X86TargetLowering::DAGCombinerInfo &DCI) {
25863   // If the LHS and RHS of the ADC node are zero, then it can't overflow and
25864   // the result is either zero or one (depending on the input carry bit).
25865   // Strength reduce this down to a "set on carry" aka SETCC_CARRY&1.
25866   if (X86::isZeroNode(N->getOperand(0)) &&
25867       X86::isZeroNode(N->getOperand(1)) &&
25868       // We don't have a good way to replace an EFLAGS use, so only do this when
25869       // dead right now.
25870       SDValue(N, 1).use_empty()) {
25871     SDLoc DL(N);
25872     EVT VT = N->getValueType(0);
25873     SDValue CarryOut = DAG.getConstant(0, N->getValueType(1));
25874     SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
25875                                DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
25876                                            DAG.getConstant(X86::COND_B,MVT::i8),
25877                                            N->getOperand(2)),
25878                                DAG.getConstant(1, VT));
25879     return DCI.CombineTo(N, Res1, CarryOut);
25880   }
25881
25882   return SDValue();
25883 }
25884
25885 // fold (add Y, (sete  X, 0)) -> adc  0, Y
25886 //      (add Y, (setne X, 0)) -> sbb -1, Y
25887 //      (sub (sete  X, 0), Y) -> sbb  0, Y
25888 //      (sub (setne X, 0), Y) -> adc -1, Y
25889 static SDValue OptimizeConditionalInDecrement(SDNode *N, SelectionDAG &DAG) {
25890   SDLoc DL(N);
25891
25892   // Look through ZExts.
25893   SDValue Ext = N->getOperand(N->getOpcode() == ISD::SUB ? 1 : 0);
25894   if (Ext.getOpcode() != ISD::ZERO_EXTEND || !Ext.hasOneUse())
25895     return SDValue();
25896
25897   SDValue SetCC = Ext.getOperand(0);
25898   if (SetCC.getOpcode() != X86ISD::SETCC || !SetCC.hasOneUse())
25899     return SDValue();
25900
25901   X86::CondCode CC = (X86::CondCode)SetCC.getConstantOperandVal(0);
25902   if (CC != X86::COND_E && CC != X86::COND_NE)
25903     return SDValue();
25904
25905   SDValue Cmp = SetCC.getOperand(1);
25906   if (Cmp.getOpcode() != X86ISD::CMP || !Cmp.hasOneUse() ||
25907       !X86::isZeroNode(Cmp.getOperand(1)) ||
25908       !Cmp.getOperand(0).getValueType().isInteger())
25909     return SDValue();
25910
25911   SDValue CmpOp0 = Cmp.getOperand(0);
25912   SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
25913                                DAG.getConstant(1, CmpOp0.getValueType()));
25914
25915   SDValue OtherVal = N->getOperand(N->getOpcode() == ISD::SUB ? 0 : 1);
25916   if (CC == X86::COND_NE)
25917     return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
25918                        DL, OtherVal.getValueType(), OtherVal,
25919                        DAG.getConstant(-1ULL, OtherVal.getValueType()), NewCmp);
25920   return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
25921                      DL, OtherVal.getValueType(), OtherVal,
25922                      DAG.getConstant(0, OtherVal.getValueType()), NewCmp);
25923 }
25924
25925 /// PerformADDCombine - Do target-specific dag combines on integer adds.
25926 static SDValue PerformAddCombine(SDNode *N, SelectionDAG &DAG,
25927                                  const X86Subtarget *Subtarget) {
25928   EVT VT = N->getValueType(0);
25929   SDValue Op0 = N->getOperand(0);
25930   SDValue Op1 = N->getOperand(1);
25931
25932   // Try to synthesize horizontal adds from adds of shuffles.
25933   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
25934        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
25935       isHorizontalBinOp(Op0, Op1, true))
25936     return DAG.getNode(X86ISD::HADD, SDLoc(N), VT, Op0, Op1);
25937
25938   return OptimizeConditionalInDecrement(N, DAG);
25939 }
25940
25941 static SDValue PerformSubCombine(SDNode *N, SelectionDAG &DAG,
25942                                  const X86Subtarget *Subtarget) {
25943   SDValue Op0 = N->getOperand(0);
25944   SDValue Op1 = N->getOperand(1);
25945
25946   // X86 can't encode an immediate LHS of a sub. See if we can push the
25947   // negation into a preceding instruction.
25948   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op0)) {
25949     // If the RHS of the sub is a XOR with one use and a constant, invert the
25950     // immediate. Then add one to the LHS of the sub so we can turn
25951     // X-Y -> X+~Y+1, saving one register.
25952     if (Op1->hasOneUse() && Op1.getOpcode() == ISD::XOR &&
25953         isa<ConstantSDNode>(Op1.getOperand(1))) {
25954       APInt XorC = cast<ConstantSDNode>(Op1.getOperand(1))->getAPIntValue();
25955       EVT VT = Op0.getValueType();
25956       SDValue NewXor = DAG.getNode(ISD::XOR, SDLoc(Op1), VT,
25957                                    Op1.getOperand(0),
25958                                    DAG.getConstant(~XorC, VT));
25959       return DAG.getNode(ISD::ADD, SDLoc(N), VT, NewXor,
25960                          DAG.getConstant(C->getAPIntValue()+1, VT));
25961     }
25962   }
25963
25964   // Try to synthesize horizontal adds from adds of shuffles.
25965   EVT VT = N->getValueType(0);
25966   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
25967        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
25968       isHorizontalBinOp(Op0, Op1, true))
25969     return DAG.getNode(X86ISD::HSUB, SDLoc(N), VT, Op0, Op1);
25970
25971   return OptimizeConditionalInDecrement(N, DAG);
25972 }
25973
25974 /// performVZEXTCombine - Performs build vector combines
25975 static SDValue performVZEXTCombine(SDNode *N, SelectionDAG &DAG,
25976                                    TargetLowering::DAGCombinerInfo &DCI,
25977                                    const X86Subtarget *Subtarget) {
25978   SDLoc DL(N);
25979   MVT VT = N->getSimpleValueType(0);
25980   SDValue Op = N->getOperand(0);
25981   MVT OpVT = Op.getSimpleValueType();
25982   MVT OpEltVT = OpVT.getVectorElementType();
25983   unsigned InputBits = OpEltVT.getSizeInBits() * VT.getVectorNumElements();
25984
25985   // (vzext (bitcast (vzext (x)) -> (vzext x)
25986   SDValue V = Op;
25987   while (V.getOpcode() == ISD::BITCAST)
25988     V = V.getOperand(0);
25989
25990   if (V != Op && V.getOpcode() == X86ISD::VZEXT) {
25991     MVT InnerVT = V.getSimpleValueType();
25992     MVT InnerEltVT = InnerVT.getVectorElementType();
25993
25994     // If the element sizes match exactly, we can just do one larger vzext. This
25995     // is always an exact type match as vzext operates on integer types.
25996     if (OpEltVT == InnerEltVT) {
25997       assert(OpVT == InnerVT && "Types must match for vzext!");
25998       return DAG.getNode(X86ISD::VZEXT, DL, VT, V.getOperand(0));
25999     }
26000
26001     // The only other way we can combine them is if only a single element of the
26002     // inner vzext is used in the input to the outer vzext.
26003     if (InnerEltVT.getSizeInBits() < InputBits)
26004       return SDValue();
26005
26006     // In this case, the inner vzext is completely dead because we're going to
26007     // only look at bits inside of the low element. Just do the outer vzext on
26008     // a bitcast of the input to the inner.
26009     return DAG.getNode(X86ISD::VZEXT, DL, VT,
26010                        DAG.getNode(ISD::BITCAST, DL, OpVT, V));
26011   }
26012
26013   // Check if we can bypass extracting and re-inserting an element of an input
26014   // vector. Essentialy:
26015   // (bitcast (sclr2vec (ext_vec_elt x))) -> (bitcast x)
26016   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR &&
26017       V.getOperand(0).getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
26018       V.getOperand(0).getSimpleValueType().getSizeInBits() == InputBits) {
26019     SDValue ExtractedV = V.getOperand(0);
26020     SDValue OrigV = ExtractedV.getOperand(0);
26021     if (auto *ExtractIdx = dyn_cast<ConstantSDNode>(ExtractedV.getOperand(1)))
26022       if (ExtractIdx->getZExtValue() == 0) {
26023         MVT OrigVT = OrigV.getSimpleValueType();
26024         // Extract a subvector if necessary...
26025         if (OrigVT.getSizeInBits() > OpVT.getSizeInBits()) {
26026           int Ratio = OrigVT.getSizeInBits() / OpVT.getSizeInBits();
26027           OrigVT = MVT::getVectorVT(OrigVT.getVectorElementType(),
26028                                     OrigVT.getVectorNumElements() / Ratio);
26029           OrigV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigVT, OrigV,
26030                               DAG.getIntPtrConstant(0));
26031         }
26032         Op = DAG.getNode(ISD::BITCAST, DL, OpVT, OrigV);
26033         return DAG.getNode(X86ISD::VZEXT, DL, VT, Op);
26034       }
26035   }
26036
26037   return SDValue();
26038 }
26039
26040 SDValue X86TargetLowering::PerformDAGCombine(SDNode *N,
26041                                              DAGCombinerInfo &DCI) const {
26042   SelectionDAG &DAG = DCI.DAG;
26043   switch (N->getOpcode()) {
26044   default: break;
26045   case ISD::EXTRACT_VECTOR_ELT:
26046     return PerformEXTRACT_VECTOR_ELTCombine(N, DAG, DCI);
26047   case ISD::VSELECT:
26048   case ISD::SELECT:
26049   case X86ISD::SHRUNKBLEND:
26050     return PerformSELECTCombine(N, DAG, DCI, Subtarget);
26051   case X86ISD::CMOV:        return PerformCMOVCombine(N, DAG, DCI, Subtarget);
26052   case ISD::ADD:            return PerformAddCombine(N, DAG, Subtarget);
26053   case ISD::SUB:            return PerformSubCombine(N, DAG, Subtarget);
26054   case X86ISD::ADC:         return PerformADCCombine(N, DAG, DCI);
26055   case ISD::MUL:            return PerformMulCombine(N, DAG, DCI);
26056   case ISD::SHL:
26057   case ISD::SRA:
26058   case ISD::SRL:            return PerformShiftCombine(N, DAG, DCI, Subtarget);
26059   case ISD::AND:            return PerformAndCombine(N, DAG, DCI, Subtarget);
26060   case ISD::OR:             return PerformOrCombine(N, DAG, DCI, Subtarget);
26061   case ISD::XOR:            return PerformXorCombine(N, DAG, DCI, Subtarget);
26062   case ISD::LOAD:           return PerformLOADCombine(N, DAG, DCI, Subtarget);
26063   case ISD::MLOAD:          return PerformMLOADCombine(N, DAG, DCI, Subtarget);
26064   case ISD::STORE:          return PerformSTORECombine(N, DAG, Subtarget);
26065   case ISD::MSTORE:         return PerformMSTORECombine(N, DAG, Subtarget);
26066   case ISD::SINT_TO_FP:     return PerformSINT_TO_FPCombine(N, DAG, this);
26067   case ISD::FADD:           return PerformFADDCombine(N, DAG, Subtarget);
26068   case ISD::FSUB:           return PerformFSUBCombine(N, DAG, Subtarget);
26069   case X86ISD::FXOR:
26070   case X86ISD::FOR:         return PerformFORCombine(N, DAG);
26071   case X86ISD::FMIN:
26072   case X86ISD::FMAX:        return PerformFMinFMaxCombine(N, DAG);
26073   case X86ISD::FAND:        return PerformFANDCombine(N, DAG);
26074   case X86ISD::FANDN:       return PerformFANDNCombine(N, DAG);
26075   case X86ISD::BT:          return PerformBTCombine(N, DAG, DCI);
26076   case X86ISD::VZEXT_MOVL:  return PerformVZEXT_MOVLCombine(N, DAG);
26077   case ISD::ANY_EXTEND:
26078   case ISD::ZERO_EXTEND:    return PerformZExtCombine(N, DAG, DCI, Subtarget);
26079   case ISD::SIGN_EXTEND:    return PerformSExtCombine(N, DAG, DCI, Subtarget);
26080   case ISD::SIGN_EXTEND_INREG:
26081     return PerformSIGN_EXTEND_INREGCombine(N, DAG, Subtarget);
26082   case ISD::TRUNCATE:       return PerformTruncateCombine(N, DAG,DCI,Subtarget);
26083   case ISD::SETCC:          return PerformISDSETCCCombine(N, DAG, Subtarget);
26084   case X86ISD::SETCC:       return PerformSETCCCombine(N, DAG, DCI, Subtarget);
26085   case X86ISD::BRCOND:      return PerformBrCondCombine(N, DAG, DCI, Subtarget);
26086   case X86ISD::VZEXT:       return performVZEXTCombine(N, DAG, DCI, Subtarget);
26087   case X86ISD::SHUFP:       // Handle all target specific shuffles
26088   case X86ISD::PALIGNR:
26089   case X86ISD::UNPCKH:
26090   case X86ISD::UNPCKL:
26091   case X86ISD::MOVHLPS:
26092   case X86ISD::MOVLHPS:
26093   case X86ISD::PSHUFB:
26094   case X86ISD::PSHUFD:
26095   case X86ISD::PSHUFHW:
26096   case X86ISD::PSHUFLW:
26097   case X86ISD::MOVSS:
26098   case X86ISD::MOVSD:
26099   case X86ISD::VPERMILPI:
26100   case X86ISD::VPERM2X128:
26101   case ISD::VECTOR_SHUFFLE: return PerformShuffleCombine(N, DAG, DCI,Subtarget);
26102   case ISD::FMA:            return PerformFMACombine(N, DAG, Subtarget);
26103   case ISD::INTRINSIC_WO_CHAIN:
26104     return PerformINTRINSIC_WO_CHAINCombine(N, DAG, Subtarget);
26105   case X86ISD::INSERTPS: {
26106     if (getTargetMachine().getOptLevel() > CodeGenOpt::None)
26107       return PerformINSERTPSCombine(N, DAG, Subtarget);
26108     break;
26109   }
26110   case ISD::BUILD_VECTOR: return PerformBUILD_VECTORCombine(N, DAG, Subtarget);
26111   }
26112
26113   return SDValue();
26114 }
26115
26116 /// isTypeDesirableForOp - Return true if the target has native support for
26117 /// the specified value type and it is 'desirable' to use the type for the
26118 /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
26119 /// instruction encodings are longer and some i16 instructions are slow.
26120 bool X86TargetLowering::isTypeDesirableForOp(unsigned Opc, EVT VT) const {
26121   if (!isTypeLegal(VT))
26122     return false;
26123   if (VT != MVT::i16)
26124     return true;
26125
26126   switch (Opc) {
26127   default:
26128     return true;
26129   case ISD::LOAD:
26130   case ISD::SIGN_EXTEND:
26131   case ISD::ZERO_EXTEND:
26132   case ISD::ANY_EXTEND:
26133   case ISD::SHL:
26134   case ISD::SRL:
26135   case ISD::SUB:
26136   case ISD::ADD:
26137   case ISD::MUL:
26138   case ISD::AND:
26139   case ISD::OR:
26140   case ISD::XOR:
26141     return false;
26142   }
26143 }
26144
26145 /// IsDesirableToPromoteOp - This method query the target whether it is
26146 /// beneficial for dag combiner to promote the specified node. If true, it
26147 /// should return the desired promotion type by reference.
26148 bool X86TargetLowering::IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
26149   EVT VT = Op.getValueType();
26150   if (VT != MVT::i16)
26151     return false;
26152
26153   bool Promote = false;
26154   bool Commute = false;
26155   switch (Op.getOpcode()) {
26156   default: break;
26157   case ISD::LOAD: {
26158     LoadSDNode *LD = cast<LoadSDNode>(Op);
26159     // If the non-extending load has a single use and it's not live out, then it
26160     // might be folded.
26161     if (LD->getExtensionType() == ISD::NON_EXTLOAD /*&&
26162                                                      Op.hasOneUse()*/) {
26163       for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
26164              UE = Op.getNode()->use_end(); UI != UE; ++UI) {
26165         // The only case where we'd want to promote LOAD (rather then it being
26166         // promoted as an operand is when it's only use is liveout.
26167         if (UI->getOpcode() != ISD::CopyToReg)
26168           return false;
26169       }
26170     }
26171     Promote = true;
26172     break;
26173   }
26174   case ISD::SIGN_EXTEND:
26175   case ISD::ZERO_EXTEND:
26176   case ISD::ANY_EXTEND:
26177     Promote = true;
26178     break;
26179   case ISD::SHL:
26180   case ISD::SRL: {
26181     SDValue N0 = Op.getOperand(0);
26182     // Look out for (store (shl (load), x)).
26183     if (MayFoldLoad(N0) && MayFoldIntoStore(Op))
26184       return false;
26185     Promote = true;
26186     break;
26187   }
26188   case ISD::ADD:
26189   case ISD::MUL:
26190   case ISD::AND:
26191   case ISD::OR:
26192   case ISD::XOR:
26193     Commute = true;
26194     // fallthrough
26195   case ISD::SUB: {
26196     SDValue N0 = Op.getOperand(0);
26197     SDValue N1 = Op.getOperand(1);
26198     if (!Commute && MayFoldLoad(N1))
26199       return false;
26200     // Avoid disabling potential load folding opportunities.
26201     if (MayFoldLoad(N0) && (!isa<ConstantSDNode>(N1) || MayFoldIntoStore(Op)))
26202       return false;
26203     if (MayFoldLoad(N1) && (!isa<ConstantSDNode>(N0) || MayFoldIntoStore(Op)))
26204       return false;
26205     Promote = true;
26206   }
26207   }
26208
26209   PVT = MVT::i32;
26210   return Promote;
26211 }
26212
26213 //===----------------------------------------------------------------------===//
26214 //                           X86 Inline Assembly Support
26215 //===----------------------------------------------------------------------===//
26216
26217 namespace {
26218   // Helper to match a string separated by whitespace.
26219   bool matchAsmImpl(StringRef s, ArrayRef<const StringRef *> args) {
26220     s = s.substr(s.find_first_not_of(" \t")); // Skip leading whitespace.
26221
26222     for (unsigned i = 0, e = args.size(); i != e; ++i) {
26223       StringRef piece(*args[i]);
26224       if (!s.startswith(piece)) // Check if the piece matches.
26225         return false;
26226
26227       s = s.substr(piece.size());
26228       StringRef::size_type pos = s.find_first_not_of(" \t");
26229       if (pos == 0) // We matched a prefix.
26230         return false;
26231
26232       s = s.substr(pos);
26233     }
26234
26235     return s.empty();
26236   }
26237   const VariadicFunction1<bool, StringRef, StringRef, matchAsmImpl> matchAsm={};
26238 }
26239
26240 static bool clobbersFlagRegisters(const SmallVector<StringRef, 4> &AsmPieces) {
26241
26242   if (AsmPieces.size() == 3 || AsmPieces.size() == 4) {
26243     if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{cc}") &&
26244         std::count(AsmPieces.begin(), AsmPieces.end(), "~{flags}") &&
26245         std::count(AsmPieces.begin(), AsmPieces.end(), "~{fpsr}")) {
26246
26247       if (AsmPieces.size() == 3)
26248         return true;
26249       else if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{dirflag}"))
26250         return true;
26251     }
26252   }
26253   return false;
26254 }
26255
26256 bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const {
26257   InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
26258
26259   std::string AsmStr = IA->getAsmString();
26260
26261   IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
26262   if (!Ty || Ty->getBitWidth() % 16 != 0)
26263     return false;
26264
26265   // TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
26266   SmallVector<StringRef, 4> AsmPieces;
26267   SplitString(AsmStr, AsmPieces, ";\n");
26268
26269   switch (AsmPieces.size()) {
26270   default: return false;
26271   case 1:
26272     // FIXME: this should verify that we are targeting a 486 or better.  If not,
26273     // we will turn this bswap into something that will be lowered to logical
26274     // ops instead of emitting the bswap asm.  For now, we don't support 486 or
26275     // lower so don't worry about this.
26276     // bswap $0
26277     if (matchAsm(AsmPieces[0], "bswap", "$0") ||
26278         matchAsm(AsmPieces[0], "bswapl", "$0") ||
26279         matchAsm(AsmPieces[0], "bswapq", "$0") ||
26280         matchAsm(AsmPieces[0], "bswap", "${0:q}") ||
26281         matchAsm(AsmPieces[0], "bswapl", "${0:q}") ||
26282         matchAsm(AsmPieces[0], "bswapq", "${0:q}")) {
26283       // No need to check constraints, nothing other than the equivalent of
26284       // "=r,0" would be valid here.
26285       return IntrinsicLowering::LowerToByteSwap(CI);
26286     }
26287
26288     // rorw $$8, ${0:w}  -->  llvm.bswap.i16
26289     if (CI->getType()->isIntegerTy(16) &&
26290         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
26291         (matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") ||
26292          matchAsm(AsmPieces[0], "rolw", "$$8,", "${0:w}"))) {
26293       AsmPieces.clear();
26294       const std::string &ConstraintsStr = IA->getConstraintString();
26295       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
26296       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
26297       if (clobbersFlagRegisters(AsmPieces))
26298         return IntrinsicLowering::LowerToByteSwap(CI);
26299     }
26300     break;
26301   case 3:
26302     if (CI->getType()->isIntegerTy(32) &&
26303         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
26304         matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") &&
26305         matchAsm(AsmPieces[1], "rorl", "$$16,", "$0") &&
26306         matchAsm(AsmPieces[2], "rorw", "$$8,", "${0:w}")) {
26307       AsmPieces.clear();
26308       const std::string &ConstraintsStr = IA->getConstraintString();
26309       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
26310       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
26311       if (clobbersFlagRegisters(AsmPieces))
26312         return IntrinsicLowering::LowerToByteSwap(CI);
26313     }
26314
26315     if (CI->getType()->isIntegerTy(64)) {
26316       InlineAsm::ConstraintInfoVector Constraints = IA->ParseConstraints();
26317       if (Constraints.size() >= 2 &&
26318           Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
26319           Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {
26320         // bswap %eax / bswap %edx / xchgl %eax, %edx  -> llvm.bswap.i64
26321         if (matchAsm(AsmPieces[0], "bswap", "%eax") &&
26322             matchAsm(AsmPieces[1], "bswap", "%edx") &&
26323             matchAsm(AsmPieces[2], "xchgl", "%eax,", "%edx"))
26324           return IntrinsicLowering::LowerToByteSwap(CI);
26325       }
26326     }
26327     break;
26328   }
26329   return false;
26330 }
26331
26332 /// getConstraintType - Given a constraint letter, return the type of
26333 /// constraint it is for this target.
26334 X86TargetLowering::ConstraintType
26335 X86TargetLowering::getConstraintType(const std::string &Constraint) const {
26336   if (Constraint.size() == 1) {
26337     switch (Constraint[0]) {
26338     case 'R':
26339     case 'q':
26340     case 'Q':
26341     case 'f':
26342     case 't':
26343     case 'u':
26344     case 'y':
26345     case 'x':
26346     case 'Y':
26347     case 'l':
26348       return C_RegisterClass;
26349     case 'a':
26350     case 'b':
26351     case 'c':
26352     case 'd':
26353     case 'S':
26354     case 'D':
26355     case 'A':
26356       return C_Register;
26357     case 'I':
26358     case 'J':
26359     case 'K':
26360     case 'L':
26361     case 'M':
26362     case 'N':
26363     case 'G':
26364     case 'C':
26365     case 'e':
26366     case 'Z':
26367       return C_Other;
26368     default:
26369       break;
26370     }
26371   }
26372   return TargetLowering::getConstraintType(Constraint);
26373 }
26374
26375 /// Examine constraint type and operand type and determine a weight value.
26376 /// This object must already have been set up with the operand type
26377 /// and the current alternative constraint selected.
26378 TargetLowering::ConstraintWeight
26379   X86TargetLowering::getSingleConstraintMatchWeight(
26380     AsmOperandInfo &info, const char *constraint) const {
26381   ConstraintWeight weight = CW_Invalid;
26382   Value *CallOperandVal = info.CallOperandVal;
26383     // If we don't have a value, we can't do a match,
26384     // but allow it at the lowest weight.
26385   if (!CallOperandVal)
26386     return CW_Default;
26387   Type *type = CallOperandVal->getType();
26388   // Look at the constraint type.
26389   switch (*constraint) {
26390   default:
26391     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
26392   case 'R':
26393   case 'q':
26394   case 'Q':
26395   case 'a':
26396   case 'b':
26397   case 'c':
26398   case 'd':
26399   case 'S':
26400   case 'D':
26401   case 'A':
26402     if (CallOperandVal->getType()->isIntegerTy())
26403       weight = CW_SpecificReg;
26404     break;
26405   case 'f':
26406   case 't':
26407   case 'u':
26408     if (type->isFloatingPointTy())
26409       weight = CW_SpecificReg;
26410     break;
26411   case 'y':
26412     if (type->isX86_MMXTy() && Subtarget->hasMMX())
26413       weight = CW_SpecificReg;
26414     break;
26415   case 'x':
26416   case 'Y':
26417     if (((type->getPrimitiveSizeInBits() == 128) && Subtarget->hasSSE1()) ||
26418         ((type->getPrimitiveSizeInBits() == 256) && Subtarget->hasFp256()))
26419       weight = CW_Register;
26420     break;
26421   case 'I':
26422     if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
26423       if (C->getZExtValue() <= 31)
26424         weight = CW_Constant;
26425     }
26426     break;
26427   case 'J':
26428     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26429       if (C->getZExtValue() <= 63)
26430         weight = CW_Constant;
26431     }
26432     break;
26433   case 'K':
26434     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26435       if ((C->getSExtValue() >= -0x80) && (C->getSExtValue() <= 0x7f))
26436         weight = CW_Constant;
26437     }
26438     break;
26439   case 'L':
26440     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26441       if ((C->getZExtValue() == 0xff) || (C->getZExtValue() == 0xffff))
26442         weight = CW_Constant;
26443     }
26444     break;
26445   case 'M':
26446     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26447       if (C->getZExtValue() <= 3)
26448         weight = CW_Constant;
26449     }
26450     break;
26451   case 'N':
26452     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26453       if (C->getZExtValue() <= 0xff)
26454         weight = CW_Constant;
26455     }
26456     break;
26457   case 'G':
26458   case 'C':
26459     if (dyn_cast<ConstantFP>(CallOperandVal)) {
26460       weight = CW_Constant;
26461     }
26462     break;
26463   case 'e':
26464     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26465       if ((C->getSExtValue() >= -0x80000000LL) &&
26466           (C->getSExtValue() <= 0x7fffffffLL))
26467         weight = CW_Constant;
26468     }
26469     break;
26470   case 'Z':
26471     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
26472       if (C->getZExtValue() <= 0xffffffff)
26473         weight = CW_Constant;
26474     }
26475     break;
26476   }
26477   return weight;
26478 }
26479
26480 /// LowerXConstraint - try to replace an X constraint, which matches anything,
26481 /// with another that has more specific requirements based on the type of the
26482 /// corresponding operand.
26483 const char *X86TargetLowering::
26484 LowerXConstraint(EVT ConstraintVT) const {
26485   // FP X constraints get lowered to SSE1/2 registers if available, otherwise
26486   // 'f' like normal targets.
26487   if (ConstraintVT.isFloatingPoint()) {
26488     if (Subtarget->hasSSE2())
26489       return "Y";
26490     if (Subtarget->hasSSE1())
26491       return "x";
26492   }
26493
26494   return TargetLowering::LowerXConstraint(ConstraintVT);
26495 }
26496
26497 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
26498 /// vector.  If it is invalid, don't add anything to Ops.
26499 void X86TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
26500                                                      std::string &Constraint,
26501                                                      std::vector<SDValue>&Ops,
26502                                                      SelectionDAG &DAG) const {
26503   SDValue Result;
26504
26505   // Only support length 1 constraints for now.
26506   if (Constraint.length() > 1) return;
26507
26508   char ConstraintLetter = Constraint[0];
26509   switch (ConstraintLetter) {
26510   default: break;
26511   case 'I':
26512     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26513       if (C->getZExtValue() <= 31) {
26514         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
26515         break;
26516       }
26517     }
26518     return;
26519   case 'J':
26520     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26521       if (C->getZExtValue() <= 63) {
26522         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
26523         break;
26524       }
26525     }
26526     return;
26527   case 'K':
26528     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26529       if (isInt<8>(C->getSExtValue())) {
26530         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
26531         break;
26532       }
26533     }
26534     return;
26535   case 'L':
26536     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26537       if (C->getZExtValue() == 0xff || C->getZExtValue() == 0xffff ||
26538           (Subtarget->is64Bit() && C->getZExtValue() == 0xffffffff)) {
26539         Result = DAG.getTargetConstant(C->getSExtValue(), Op.getValueType());
26540         break;
26541       }
26542     }
26543     return;
26544   case 'M':
26545     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26546       if (C->getZExtValue() <= 3) {
26547         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
26548         break;
26549       }
26550     }
26551     return;
26552   case 'N':
26553     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26554       if (C->getZExtValue() <= 255) {
26555         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
26556         break;
26557       }
26558     }
26559     return;
26560   case 'O':
26561     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26562       if (C->getZExtValue() <= 127) {
26563         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
26564         break;
26565       }
26566     }
26567     return;
26568   case 'e': {
26569     // 32-bit signed value
26570     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26571       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
26572                                            C->getSExtValue())) {
26573         // Widen to 64 bits here to get it sign extended.
26574         Result = DAG.getTargetConstant(C->getSExtValue(), MVT::i64);
26575         break;
26576       }
26577     // FIXME gcc accepts some relocatable values here too, but only in certain
26578     // memory models; it's complicated.
26579     }
26580     return;
26581   }
26582   case 'Z': {
26583     // 32-bit unsigned value
26584     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
26585       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
26586                                            C->getZExtValue())) {
26587         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
26588         break;
26589       }
26590     }
26591     // FIXME gcc accepts some relocatable values here too, but only in certain
26592     // memory models; it's complicated.
26593     return;
26594   }
26595   case 'i': {
26596     // Literal immediates are always ok.
26597     if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op)) {
26598       // Widen to 64 bits here to get it sign extended.
26599       Result = DAG.getTargetConstant(CST->getSExtValue(), MVT::i64);
26600       break;
26601     }
26602
26603     // In any sort of PIC mode addresses need to be computed at runtime by
26604     // adding in a register or some sort of table lookup.  These can't
26605     // be used as immediates.
26606     if (Subtarget->isPICStyleGOT() || Subtarget->isPICStyleStubPIC())
26607       return;
26608
26609     // If we are in non-pic codegen mode, we allow the address of a global (with
26610     // an optional displacement) to be used with 'i'.
26611     GlobalAddressSDNode *GA = nullptr;
26612     int64_t Offset = 0;
26613
26614     // Match either (GA), (GA+C), (GA+C1+C2), etc.
26615     while (1) {
26616       if ((GA = dyn_cast<GlobalAddressSDNode>(Op))) {
26617         Offset += GA->getOffset();
26618         break;
26619       } else if (Op.getOpcode() == ISD::ADD) {
26620         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
26621           Offset += C->getZExtValue();
26622           Op = Op.getOperand(0);
26623           continue;
26624         }
26625       } else if (Op.getOpcode() == ISD::SUB) {
26626         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
26627           Offset += -C->getZExtValue();
26628           Op = Op.getOperand(0);
26629           continue;
26630         }
26631       }
26632
26633       // Otherwise, this isn't something we can handle, reject it.
26634       return;
26635     }
26636
26637     const GlobalValue *GV = GA->getGlobal();
26638     // If we require an extra load to get this address, as in PIC mode, we
26639     // can't accept it.
26640     if (isGlobalStubReference(
26641             Subtarget->ClassifyGlobalReference(GV, DAG.getTarget())))
26642       return;
26643
26644     Result = DAG.getTargetGlobalAddress(GV, SDLoc(Op),
26645                                         GA->getValueType(0), Offset);
26646     break;
26647   }
26648   }
26649
26650   if (Result.getNode()) {
26651     Ops.push_back(Result);
26652     return;
26653   }
26654   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
26655 }
26656
26657 std::pair<unsigned, const TargetRegisterClass*>
26658 X86TargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
26659                                                 MVT VT) const {
26660   // First, see if this is a constraint that directly corresponds to an LLVM
26661   // register class.
26662   if (Constraint.size() == 1) {
26663     // GCC Constraint Letters
26664     switch (Constraint[0]) {
26665     default: break;
26666       // TODO: Slight differences here in allocation order and leaving
26667       // RIP in the class. Do they matter any more here than they do
26668       // in the normal allocation?
26669     case 'q':   // GENERAL_REGS in 64-bit mode, Q_REGS in 32-bit mode.
26670       if (Subtarget->is64Bit()) {
26671         if (VT == MVT::i32 || VT == MVT::f32)
26672           return std::make_pair(0U, &X86::GR32RegClass);
26673         if (VT == MVT::i16)
26674           return std::make_pair(0U, &X86::GR16RegClass);
26675         if (VT == MVT::i8 || VT == MVT::i1)
26676           return std::make_pair(0U, &X86::GR8RegClass);
26677         if (VT == MVT::i64 || VT == MVT::f64)
26678           return std::make_pair(0U, &X86::GR64RegClass);
26679         break;
26680       }
26681       // 32-bit fallthrough
26682     case 'Q':   // Q_REGS
26683       if (VT == MVT::i32 || VT == MVT::f32)
26684         return std::make_pair(0U, &X86::GR32_ABCDRegClass);
26685       if (VT == MVT::i16)
26686         return std::make_pair(0U, &X86::GR16_ABCDRegClass);
26687       if (VT == MVT::i8 || VT == MVT::i1)
26688         return std::make_pair(0U, &X86::GR8_ABCD_LRegClass);
26689       if (VT == MVT::i64)
26690         return std::make_pair(0U, &X86::GR64_ABCDRegClass);
26691       break;
26692     case 'r':   // GENERAL_REGS
26693     case 'l':   // INDEX_REGS
26694       if (VT == MVT::i8 || VT == MVT::i1)
26695         return std::make_pair(0U, &X86::GR8RegClass);
26696       if (VT == MVT::i16)
26697         return std::make_pair(0U, &X86::GR16RegClass);
26698       if (VT == MVT::i32 || VT == MVT::f32 || !Subtarget->is64Bit())
26699         return std::make_pair(0U, &X86::GR32RegClass);
26700       return std::make_pair(0U, &X86::GR64RegClass);
26701     case 'R':   // LEGACY_REGS
26702       if (VT == MVT::i8 || VT == MVT::i1)
26703         return std::make_pair(0U, &X86::GR8_NOREXRegClass);
26704       if (VT == MVT::i16)
26705         return std::make_pair(0U, &X86::GR16_NOREXRegClass);
26706       if (VT == MVT::i32 || !Subtarget->is64Bit())
26707         return std::make_pair(0U, &X86::GR32_NOREXRegClass);
26708       return std::make_pair(0U, &X86::GR64_NOREXRegClass);
26709     case 'f':  // FP Stack registers.
26710       // If SSE is enabled for this VT, use f80 to ensure the isel moves the
26711       // value to the correct fpstack register class.
26712       if (VT == MVT::f32 && !isScalarFPTypeInSSEReg(VT))
26713         return std::make_pair(0U, &X86::RFP32RegClass);
26714       if (VT == MVT::f64 && !isScalarFPTypeInSSEReg(VT))
26715         return std::make_pair(0U, &X86::RFP64RegClass);
26716       return std::make_pair(0U, &X86::RFP80RegClass);
26717     case 'y':   // MMX_REGS if MMX allowed.
26718       if (!Subtarget->hasMMX()) break;
26719       return std::make_pair(0U, &X86::VR64RegClass);
26720     case 'Y':   // SSE_REGS if SSE2 allowed
26721       if (!Subtarget->hasSSE2()) break;
26722       // FALL THROUGH.
26723     case 'x':   // SSE_REGS if SSE1 allowed or AVX_REGS if AVX allowed
26724       if (!Subtarget->hasSSE1()) break;
26725
26726       switch (VT.SimpleTy) {
26727       default: break;
26728       // Scalar SSE types.
26729       case MVT::f32:
26730       case MVT::i32:
26731         return std::make_pair(0U, &X86::FR32RegClass);
26732       case MVT::f64:
26733       case MVT::i64:
26734         return std::make_pair(0U, &X86::FR64RegClass);
26735       // Vector types.
26736       case MVT::v16i8:
26737       case MVT::v8i16:
26738       case MVT::v4i32:
26739       case MVT::v2i64:
26740       case MVT::v4f32:
26741       case MVT::v2f64:
26742         return std::make_pair(0U, &X86::VR128RegClass);
26743       // AVX types.
26744       case MVT::v32i8:
26745       case MVT::v16i16:
26746       case MVT::v8i32:
26747       case MVT::v4i64:
26748       case MVT::v8f32:
26749       case MVT::v4f64:
26750         return std::make_pair(0U, &X86::VR256RegClass);
26751       case MVT::v8f64:
26752       case MVT::v16f32:
26753       case MVT::v16i32:
26754       case MVT::v8i64:
26755         return std::make_pair(0U, &X86::VR512RegClass);
26756       }
26757       break;
26758     }
26759   }
26760
26761   // Use the default implementation in TargetLowering to convert the register
26762   // constraint into a member of a register class.
26763   std::pair<unsigned, const TargetRegisterClass*> Res;
26764   Res = TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
26765
26766   // Not found as a standard register?
26767   if (!Res.second) {
26768     // Map st(0) -> st(7) -> ST0
26769     if (Constraint.size() == 7 && Constraint[0] == '{' &&
26770         tolower(Constraint[1]) == 's' &&
26771         tolower(Constraint[2]) == 't' &&
26772         Constraint[3] == '(' &&
26773         (Constraint[4] >= '0' && Constraint[4] <= '7') &&
26774         Constraint[5] == ')' &&
26775         Constraint[6] == '}') {
26776
26777       Res.first = X86::FP0+Constraint[4]-'0';
26778       Res.second = &X86::RFP80RegClass;
26779       return Res;
26780     }
26781
26782     // GCC allows "st(0)" to be called just plain "st".
26783     if (StringRef("{st}").equals_lower(Constraint)) {
26784       Res.first = X86::FP0;
26785       Res.second = &X86::RFP80RegClass;
26786       return Res;
26787     }
26788
26789     // flags -> EFLAGS
26790     if (StringRef("{flags}").equals_lower(Constraint)) {
26791       Res.first = X86::EFLAGS;
26792       Res.second = &X86::CCRRegClass;
26793       return Res;
26794     }
26795
26796     // 'A' means EAX + EDX.
26797     if (Constraint == "A") {
26798       Res.first = X86::EAX;
26799       Res.second = &X86::GR32_ADRegClass;
26800       return Res;
26801     }
26802     return Res;
26803   }
26804
26805   // Otherwise, check to see if this is a register class of the wrong value
26806   // type.  For example, we want to map "{ax},i32" -> {eax}, we don't want it to
26807   // turn into {ax},{dx}.
26808   if (Res.second->hasType(VT))
26809     return Res;   // Correct type already, nothing to do.
26810
26811   // All of the single-register GCC register classes map their values onto
26812   // 16-bit register pieces "ax","dx","cx","bx","si","di","bp","sp".  If we
26813   // really want an 8-bit or 32-bit register, map to the appropriate register
26814   // class and return the appropriate register.
26815   if (Res.second == &X86::GR16RegClass) {
26816     if (VT == MVT::i8 || VT == MVT::i1) {
26817       unsigned DestReg = 0;
26818       switch (Res.first) {
26819       default: break;
26820       case X86::AX: DestReg = X86::AL; break;
26821       case X86::DX: DestReg = X86::DL; break;
26822       case X86::CX: DestReg = X86::CL; break;
26823       case X86::BX: DestReg = X86::BL; break;
26824       }
26825       if (DestReg) {
26826         Res.first = DestReg;
26827         Res.second = &X86::GR8RegClass;
26828       }
26829     } else if (VT == MVT::i32 || VT == MVT::f32) {
26830       unsigned DestReg = 0;
26831       switch (Res.first) {
26832       default: break;
26833       case X86::AX: DestReg = X86::EAX; break;
26834       case X86::DX: DestReg = X86::EDX; break;
26835       case X86::CX: DestReg = X86::ECX; break;
26836       case X86::BX: DestReg = X86::EBX; break;
26837       case X86::SI: DestReg = X86::ESI; break;
26838       case X86::DI: DestReg = X86::EDI; break;
26839       case X86::BP: DestReg = X86::EBP; break;
26840       case X86::SP: DestReg = X86::ESP; break;
26841       }
26842       if (DestReg) {
26843         Res.first = DestReg;
26844         Res.second = &X86::GR32RegClass;
26845       }
26846     } else if (VT == MVT::i64 || VT == MVT::f64) {
26847       unsigned DestReg = 0;
26848       switch (Res.first) {
26849       default: break;
26850       case X86::AX: DestReg = X86::RAX; break;
26851       case X86::DX: DestReg = X86::RDX; break;
26852       case X86::CX: DestReg = X86::RCX; break;
26853       case X86::BX: DestReg = X86::RBX; break;
26854       case X86::SI: DestReg = X86::RSI; break;
26855       case X86::DI: DestReg = X86::RDI; break;
26856       case X86::BP: DestReg = X86::RBP; break;
26857       case X86::SP: DestReg = X86::RSP; break;
26858       }
26859       if (DestReg) {
26860         Res.first = DestReg;
26861         Res.second = &X86::GR64RegClass;
26862       }
26863     }
26864   } else if (Res.second == &X86::FR32RegClass ||
26865              Res.second == &X86::FR64RegClass ||
26866              Res.second == &X86::VR128RegClass ||
26867              Res.second == &X86::VR256RegClass ||
26868              Res.second == &X86::FR32XRegClass ||
26869              Res.second == &X86::FR64XRegClass ||
26870              Res.second == &X86::VR128XRegClass ||
26871              Res.second == &X86::VR256XRegClass ||
26872              Res.second == &X86::VR512RegClass) {
26873     // Handle references to XMM physical registers that got mapped into the
26874     // wrong class.  This can happen with constraints like {xmm0} where the
26875     // target independent register mapper will just pick the first match it can
26876     // find, ignoring the required type.
26877
26878     if (VT == MVT::f32 || VT == MVT::i32)
26879       Res.second = &X86::FR32RegClass;
26880     else if (VT == MVT::f64 || VT == MVT::i64)
26881       Res.second = &X86::FR64RegClass;
26882     else if (X86::VR128RegClass.hasType(VT))
26883       Res.second = &X86::VR128RegClass;
26884     else if (X86::VR256RegClass.hasType(VT))
26885       Res.second = &X86::VR256RegClass;
26886     else if (X86::VR512RegClass.hasType(VT))
26887       Res.second = &X86::VR512RegClass;
26888   }
26889
26890   return Res;
26891 }
26892
26893 int X86TargetLowering::getScalingFactorCost(const AddrMode &AM,
26894                                             Type *Ty) const {
26895   // Scaling factors are not free at all.
26896   // An indexed folded instruction, i.e., inst (reg1, reg2, scale),
26897   // will take 2 allocations in the out of order engine instead of 1
26898   // for plain addressing mode, i.e. inst (reg1).
26899   // E.g.,
26900   // vaddps (%rsi,%drx), %ymm0, %ymm1
26901   // Requires two allocations (one for the load, one for the computation)
26902   // whereas:
26903   // vaddps (%rsi), %ymm0, %ymm1
26904   // Requires just 1 allocation, i.e., freeing allocations for other operations
26905   // and having less micro operations to execute.
26906   //
26907   // For some X86 architectures, this is even worse because for instance for
26908   // stores, the complex addressing mode forces the instruction to use the
26909   // "load" ports instead of the dedicated "store" port.
26910   // E.g., on Haswell:
26911   // vmovaps %ymm1, (%r8, %rdi) can use port 2 or 3.
26912   // vmovaps %ymm1, (%r8) can use port 2, 3, or 7.
26913   if (isLegalAddressingMode(AM, Ty))
26914     // Scale represents reg2 * scale, thus account for 1
26915     // as soon as we use a second register.
26916     return AM.Scale != 0;
26917   return -1;
26918 }
26919
26920 bool X86TargetLowering::isTargetFTOL() const {
26921   return Subtarget->isTargetKnownWindowsMSVC() && !Subtarget->is64Bit();
26922 }