lib/Target/X86/X86ISelLowering.cpp

   1 //===-- X86ISelLowering.cpp - X86 DAG Lowering Implementation -------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the interfaces that X86 uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "X86ISelLowering.h"
  16 #include "Utils/X86ShuffleDecode.h"
  17 #include "X86CallingConv.h"
  18 #include "X86FrameLowering.h"
  19 #include "X86InstrBuilder.h"
  20 #include "X86MachineFunctionInfo.h"
  21 #include "X86TargetMachine.h"
  22 #include "X86TargetObjectFile.h"
  23 #include "llvm/ADT/SmallBitVector.h"
  24 #include "llvm/ADT/SmallSet.h"
  25 #include "llvm/ADT/Statistic.h"
  26 #include "llvm/ADT/StringExtras.h"
  27 #include "llvm/ADT/StringSwitch.h"
  28 #include "llvm/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/CodeGen/WinEHFuncInfo.h"
  36 #include "llvm/IR/CallSite.h"
  37 #include "llvm/IR/CallingConv.h"
  38 #include "llvm/IR/Constants.h"
  39 #include "llvm/IR/DerivedTypes.h"
  40 #include "llvm/IR/Function.h"
  41 #include "llvm/IR/GlobalAlias.h"
  42 #include "llvm/IR/GlobalVariable.h"
  43 #include "llvm/IR/Instructions.h"
  44 #include "llvm/IR/Intrinsics.h"
  45 #include "llvm/MC/MCAsmInfo.h"
  46 #include "llvm/MC/MCContext.h"
  47 #include "llvm/MC/MCExpr.h"
  48 #include "llvm/MC/MCSymbol.h"
  49 #include "llvm/Support/CommandLine.h"
  50 #include "llvm/Support/Debug.h"
  51 #include "llvm/Support/ErrorHandling.h"
  52 #include "llvm/Support/MathExtras.h"
  53 #include "llvm/Target/TargetOptions.h"
  54 #include "X86IntrinsicsInfo.h"
  55 #include <bitset>
  56 #include <numeric>
  57 #include <cctype>
  58 using namespace llvm;
  59
  60 #define DEBUG_TYPE "x86-isel"
  61
  62 STATISTIC(NumTailCalls, "Number of tail calls");
  63
  64 static cl::opt<bool> ExperimentalVectorWideningLegalization(
  65     "x86-experimental-vector-widening-legalization", cl::init(false),
  66     cl::desc("Enable an experimental vector type legalization through widening "
  67              "rather than promotion."),
  68     cl::Hidden);
  69
  70 static cl::opt<int> ReciprocalEstimateRefinementSteps(
  71     "x86-recip-refinement-steps", cl::init(1),
  72     cl::desc("Specify the number of Newton-Raphson iterations applied to the "
  73              "result of the hardware reciprocal estimate instruction."),
  74     cl::NotHidden);
  75
  76 // Forward declarations.
  77 static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1,
  78                        SDValue V2);
  79
  80 X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM,
  81                                      const X86Subtarget &STI)
  82     : TargetLowering(TM), Subtarget(&STI) {
  83   X86ScalarSSEf64 = Subtarget->hasSSE2();
  84   X86ScalarSSEf32 = Subtarget->hasSSE1();
  85   TD = getDataLayout();
  86
  87   // Set up the TargetLowering object.
  88   static const MVT IntVTs[] = { MVT::i8, MVT::i16, MVT::i32, MVT::i64 };
  89
  90   // X86 is weird. It always uses i8 for shift amounts and setcc results.
  91   setBooleanContents(ZeroOrOneBooleanContent);
  92   // X86-SSE is even stranger. It uses -1 or 0 for vector masks.
  93   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
  94
  95   // For 64-bit, since we have so many registers, use the ILP scheduler.
  96   // For 32-bit, use the register pressure specific scheduling.
  97   // For Atom, always use ILP scheduling.
  98   if (Subtarget->isAtom())
  99     setSchedulingPreference(Sched::ILP);
 100   else if (Subtarget->is64Bit())
 101     setSchedulingPreference(Sched::ILP);
 102   else
 103     setSchedulingPreference(Sched::RegPressure);
 104   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
 105   setStackPointerRegisterToSaveRestore(RegInfo->getStackRegister());
 106
 107   // Bypass expensive divides on Atom when compiling with O2.
 108   if (TM.getOptLevel() >= CodeGenOpt::Default) {
 109     if (Subtarget->hasSlowDivide32())
 110       addBypassSlowDiv(32, 8);
 111     if (Subtarget->hasSlowDivide64() && Subtarget->is64Bit())
 112       addBypassSlowDiv(64, 16);
 113   }
 114
 115   if (Subtarget->isTargetKnownWindowsMSVC()) {
 116     // Setup Windows compiler runtime calls.
 117     setLibcallName(RTLIB::SDIV_I64, "_alldiv");
 118     setLibcallName(RTLIB::UDIV_I64, "_aulldiv");
 119     setLibcallName(RTLIB::SREM_I64, "_allrem");
 120     setLibcallName(RTLIB::UREM_I64, "_aullrem");
 121     setLibcallName(RTLIB::MUL_I64, "_allmul");
 122     setLibcallCallingConv(RTLIB::SDIV_I64, CallingConv::X86_StdCall);
 123     setLibcallCallingConv(RTLIB::UDIV_I64, CallingConv::X86_StdCall);
 124     setLibcallCallingConv(RTLIB::SREM_I64, CallingConv::X86_StdCall);
 125     setLibcallCallingConv(RTLIB::UREM_I64, CallingConv::X86_StdCall);
 126     setLibcallCallingConv(RTLIB::MUL_I64, CallingConv::X86_StdCall);
 127
 128     // The _ftol2 runtime function has an unusual calling conv, which
 129     // is modeled by a special pseudo-instruction.
 130     setLibcallName(RTLIB::FPTOUINT_F64_I64, nullptr);
 131     setLibcallName(RTLIB::FPTOUINT_F32_I64, nullptr);
 132     setLibcallName(RTLIB::FPTOUINT_F64_I32, nullptr);
 133     setLibcallName(RTLIB::FPTOUINT_F32_I32, nullptr);
 134   }
 135
 136   if (Subtarget->isTargetDarwin()) {
 137     // Darwin should use _setjmp/_longjmp instead of setjmp/longjmp.
 138     setUseUnderscoreSetJmp(false);
 139     setUseUnderscoreLongJmp(false);
 140   } else if (Subtarget->isTargetWindowsGNU()) {
 141     // MS runtime is weird: it exports _setjmp, but longjmp!
 142     setUseUnderscoreSetJmp(true);
 143     setUseUnderscoreLongJmp(false);
 144   } else {
 145     setUseUnderscoreSetJmp(true);
 146     setUseUnderscoreLongJmp(true);
 147   }
 148
 149   // Set up the register classes.
 150   addRegisterClass(MVT::i8, &X86::GR8RegClass);
 151   addRegisterClass(MVT::i16, &X86::GR16RegClass);
 152   addRegisterClass(MVT::i32, &X86::GR32RegClass);
 153   if (Subtarget->is64Bit())
 154     addRegisterClass(MVT::i64, &X86::GR64RegClass);
 155
 156   for (MVT VT : MVT::integer_valuetypes())
 157     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
 158
 159   // We don't accept any truncstore of integer registers.
 160   setTruncStoreAction(MVT::i64, MVT::i32, Expand);
 161   setTruncStoreAction(MVT::i64, MVT::i16, Expand);
 162   setTruncStoreAction(MVT::i64, MVT::i8 , Expand);
 163   setTruncStoreAction(MVT::i32, MVT::i16, Expand);
 164   setTruncStoreAction(MVT::i32, MVT::i8 , Expand);
 165   setTruncStoreAction(MVT::i16, MVT::i8,  Expand);
 166
 167   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
 168
 169   // SETOEQ and SETUNE require checking two conditions.
 170   setCondCodeAction(ISD::SETOEQ, MVT::f32, Expand);
 171   setCondCodeAction(ISD::SETOEQ, MVT::f64, Expand);
 172   setCondCodeAction(ISD::SETOEQ, MVT::f80, Expand);
 173   setCondCodeAction(ISD::SETUNE, MVT::f32, Expand);
 174   setCondCodeAction(ISD::SETUNE, MVT::f64, Expand);
 175   setCondCodeAction(ISD::SETUNE, MVT::f80, Expand);
 176
 177   // Promote all UINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have this
 178   // operation.
 179   setOperationAction(ISD::UINT_TO_FP       , MVT::i1   , Promote);
 180   setOperationAction(ISD::UINT_TO_FP       , MVT::i8   , Promote);
 181   setOperationAction(ISD::UINT_TO_FP       , MVT::i16  , Promote);
 182
 183   if (Subtarget->is64Bit()) {
 184     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Promote);
 185     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
 186   } else if (!TM.Options.UseSoftFloat) {
 187     // We have an algorithm for SSE2->double, and we turn this into a
 188     // 64-bit FILD followed by conditional FADD for other targets.
 189     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
 190     // We have an algorithm for SSE2, and we turn this into a 64-bit
 191     // FILD for other targets.
 192     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Custom);
 193   }
 194
 195   // Promote i1/i8 SINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have
 196   // this operation.
 197   setOperationAction(ISD::SINT_TO_FP       , MVT::i1   , Promote);
 198   setOperationAction(ISD::SINT_TO_FP       , MVT::i8   , Promote);
 199
 200   if (!TM.Options.UseSoftFloat) {
 201     // SSE has no i16 to fp conversion, only i32
 202     if (X86ScalarSSEf32) {
 203       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 204       // f32 and f64 cases are Legal, f80 case is not
 205       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 206     } else {
 207       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Custom);
 208       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 209     }
 210   } else {
 211     setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 212     setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Promote);
 213   }
 214
 215   // In 32-bit mode these are custom lowered.  In 64-bit mode F32 and F64
 216   // are Legal, f80 is custom lowered.
 217   setOperationAction(ISD::FP_TO_SINT     , MVT::i64  , Custom);
 218   setOperationAction(ISD::SINT_TO_FP     , MVT::i64  , Custom);
 219
 220   // Promote i1/i8 FP_TO_SINT to larger FP_TO_SINTS's, as X86 doesn't have
 221   // this operation.
 222   setOperationAction(ISD::FP_TO_SINT       , MVT::i1   , Promote);
 223   setOperationAction(ISD::FP_TO_SINT       , MVT::i8   , Promote);
 224
 225   if (X86ScalarSSEf32) {
 226     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Promote);
 227     // f32 and f64 cases are Legal, f80 case is not
 228     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 229   } else {
 230     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Custom);
 231     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 232   }
 233
 234   // Handle FP_TO_UINT by promoting the destination to a larger signed
 235   // conversion.
 236   setOperationAction(ISD::FP_TO_UINT       , MVT::i1   , Promote);
 237   setOperationAction(ISD::FP_TO_UINT       , MVT::i8   , Promote);
 238   setOperationAction(ISD::FP_TO_UINT       , MVT::i16  , Promote);
 239
 240   if (Subtarget->is64Bit()) {
 241     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Expand);
 242     setOperationAction(ISD::FP_TO_UINT     , MVT::i32  , Promote);
 243   } else if (!TM.Options.UseSoftFloat) {
 244     // Since AVX is a superset of SSE3, only check for SSE here.
 245     if (Subtarget->hasSSE1() && !Subtarget->hasSSE3())
 246       // Expand FP_TO_UINT into a select.
 247       // FIXME: We would like to use a Custom expander here eventually to do
 248       // the optimal thing for SSE vs. the default expansion in the legalizer.
 249       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Expand);
 250     else
 251       // With SSE3 we can use fisttpll to convert to a signed i64; without
 252       // SSE, we're stuck with a fistpll.
 253       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Custom);
 254   }
 255
 256   if (isTargetFTOL()) {
 257     // Use the _ftol2 runtime function, which has a pseudo-instruction
 258     // to handle its weird calling convention.
 259     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Custom);
 260   }
 261
 262   // TODO: when we have SSE, these could be more efficient, by using movd/movq.
 263   if (!X86ScalarSSEf64) {
 264     setOperationAction(ISD::BITCAST        , MVT::f32  , Expand);
 265     setOperationAction(ISD::BITCAST        , MVT::i32  , Expand);
 266     if (Subtarget->is64Bit()) {
 267       setOperationAction(ISD::BITCAST      , MVT::f64  , Expand);
 268       // Without SSE, i64->f64 goes through memory.
 269       setOperationAction(ISD::BITCAST      , MVT::i64  , Expand);
 270     }
 271   }
 272
 273   // Scalar integer divide and remainder are lowered to use operations that
 274   // produce two results, to match the available instructions. This exposes
 275   // the two-result form to trivial CSE, which is able to combine x/y and x%y
 276   // into a single instruction.
 277   //
 278   // Scalar integer multiply-high is also lowered to use two-result
 279   // operations, to match the available instructions. However, plain multiply
 280   // (low) operations are left as Legal, as there are single-result
 281   // instructions for this in x86. Using the two-result multiply instructions
 282   // when both high and low results are needed must be arranged by dagcombine.
 283   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
 284     MVT VT = IntVTs[i];
 285     setOperationAction(ISD::MULHS, VT, Expand);
 286     setOperationAction(ISD::MULHU, VT, Expand);
 287     setOperationAction(ISD::SDIV, VT, Expand);
 288     setOperationAction(ISD::UDIV, VT, Expand);
 289     setOperationAction(ISD::SREM, VT, Expand);
 290     setOperationAction(ISD::UREM, VT, Expand);
 291
 292     // Add/Sub overflow ops with MVT::Glues are lowered to EFLAGS dependences.
 293     setOperationAction(ISD::ADDC, VT, Custom);
 294     setOperationAction(ISD::ADDE, VT, Custom);
 295     setOperationAction(ISD::SUBC, VT, Custom);
 296     setOperationAction(ISD::SUBE, VT, Custom);
 297   }
 298
 299   setOperationAction(ISD::BR_JT            , MVT::Other, Expand);
 300   setOperationAction(ISD::BRCOND           , MVT::Other, Custom);
 301   setOperationAction(ISD::BR_CC            , MVT::f32,   Expand);
 302   setOperationAction(ISD::BR_CC            , MVT::f64,   Expand);
 303   setOperationAction(ISD::BR_CC            , MVT::f80,   Expand);
 304   setOperationAction(ISD::BR_CC            , MVT::i8,    Expand);
 305   setOperationAction(ISD::BR_CC            , MVT::i16,   Expand);
 306   setOperationAction(ISD::BR_CC            , MVT::i32,   Expand);
 307   setOperationAction(ISD::BR_CC            , MVT::i64,   Expand);
 308   setOperationAction(ISD::SELECT_CC        , MVT::f32,   Expand);
 309   setOperationAction(ISD::SELECT_CC        , MVT::f64,   Expand);
 310   setOperationAction(ISD::SELECT_CC        , MVT::f80,   Expand);
 311   setOperationAction(ISD::SELECT_CC        , MVT::i8,    Expand);
 312   setOperationAction(ISD::SELECT_CC        , MVT::i16,   Expand);
 313   setOperationAction(ISD::SELECT_CC        , MVT::i32,   Expand);
 314   setOperationAction(ISD::SELECT_CC        , MVT::i64,   Expand);
 315   if (Subtarget->is64Bit())
 316     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i32, Legal);
 317   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16  , Legal);
 318   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8   , Legal);
 319   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1   , Expand);
 320   setOperationAction(ISD::FP_ROUND_INREG   , MVT::f32  , Expand);
 321   setOperationAction(ISD::FREM             , MVT::f32  , Expand);
 322   setOperationAction(ISD::FREM             , MVT::f64  , Expand);
 323   setOperationAction(ISD::FREM             , MVT::f80  , Expand);
 324   setOperationAction(ISD::FLT_ROUNDS_      , MVT::i32  , Custom);
 325
 326   // Promote the i8 variants and force them on up to i32 which has a shorter
 327   // encoding.
 328   setOperationAction(ISD::CTTZ             , MVT::i8   , Promote);
 329   AddPromotedToType (ISD::CTTZ             , MVT::i8   , MVT::i32);
 330   setOperationAction(ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , Promote);
 331   AddPromotedToType (ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , MVT::i32);
 332   if (Subtarget->hasBMI()) {
 333     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i16  , Expand);
 334     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i32  , Expand);
 335     if (Subtarget->is64Bit())
 336       setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i64, Expand);
 337   } else {
 338     setOperationAction(ISD::CTTZ           , MVT::i16  , Custom);
 339     setOperationAction(ISD::CTTZ           , MVT::i32  , Custom);
 340     if (Subtarget->is64Bit())
 341       setOperationAction(ISD::CTTZ         , MVT::i64  , Custom);
 342   }
 343
 344   if (Subtarget->hasLZCNT()) {
 345     // When promoting the i8 variants, force them to i32 for a shorter
 346     // encoding.
 347     setOperationAction(ISD::CTLZ           , MVT::i8   , Promote);
 348     AddPromotedToType (ISD::CTLZ           , MVT::i8   , MVT::i32);
 349     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Promote);
 350     AddPromotedToType (ISD::CTLZ_ZERO_UNDEF, MVT::i8   , MVT::i32);
 351     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Expand);
 352     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Expand);
 353     if (Subtarget->is64Bit())
 354       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Expand);
 355   } else {
 356     setOperationAction(ISD::CTLZ           , MVT::i8   , Custom);
 357     setOperationAction(ISD::CTLZ           , MVT::i16  , Custom);
 358     setOperationAction(ISD::CTLZ           , MVT::i32  , Custom);
 359     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Custom);
 360     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Custom);
 361     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Custom);
 362     if (Subtarget->is64Bit()) {
 363       setOperationAction(ISD::CTLZ         , MVT::i64  , Custom);
 364       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Custom);
 365     }
 366   }
 367
 368   // Special handling for half-precision floating point conversions.
 369   // If we don't have F16C support, then lower half float conversions
 370   // into library calls.
 371   if (TM.Options.UseSoftFloat || !Subtarget->hasF16C()) {
 372     setOperationAction(ISD::FP16_TO_FP, MVT::f32, Expand);
 373     setOperationAction(ISD::FP_TO_FP16, MVT::f32, Expand);
 374   }
 375
 376   // There's never any support for operations beyond MVT::f32.
 377   setOperationAction(ISD::FP16_TO_FP, MVT::f64, Expand);
 378   setOperationAction(ISD::FP16_TO_FP, MVT::f80, Expand);
 379   setOperationAction(ISD::FP_TO_FP16, MVT::f64, Expand);
 380   setOperationAction(ISD::FP_TO_FP16, MVT::f80, Expand);
 381
 382   setLoadExtAction(ISD::EXTLOAD, MVT::f32, MVT::f16, Expand);
 383   setLoadExtAction(ISD::EXTLOAD, MVT::f64, MVT::f16, Expand);
 384   setLoadExtAction(ISD::EXTLOAD, MVT::f80, MVT::f16, Expand);
 385   setTruncStoreAction(MVT::f32, MVT::f16, Expand);
 386   setTruncStoreAction(MVT::f64, MVT::f16, Expand);
 387   setTruncStoreAction(MVT::f80, MVT::f16, Expand);
 388
 389   if (Subtarget->hasPOPCNT()) {
 390     setOperationAction(ISD::CTPOP          , MVT::i8   , Promote);
 391   } else {
 392     setOperationAction(ISD::CTPOP          , MVT::i8   , Expand);
 393     setOperationAction(ISD::CTPOP          , MVT::i16  , Expand);
 394     setOperationAction(ISD::CTPOP          , MVT::i32  , Expand);
 395     if (Subtarget->is64Bit())
 396       setOperationAction(ISD::CTPOP        , MVT::i64  , Expand);
 397   }
 398
 399   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
 400
 401   if (!Subtarget->hasMOVBE())
 402     setOperationAction(ISD::BSWAP          , MVT::i16  , Expand);
 403
 404   // These should be promoted to a larger select which is supported.
 405   setOperationAction(ISD::SELECT          , MVT::i1   , Promote);
 406   // X86 wants to expand cmov itself.
 407   setOperationAction(ISD::SELECT          , MVT::i8   , Custom);
 408   setOperationAction(ISD::SELECT          , MVT::i16  , Custom);
 409   setOperationAction(ISD::SELECT          , MVT::i32  , Custom);
 410   setOperationAction(ISD::SELECT          , MVT::f32  , Custom);
 411   setOperationAction(ISD::SELECT          , MVT::f64  , Custom);
 412   setOperationAction(ISD::SELECT          , MVT::f80  , Custom);
 413   setOperationAction(ISD::SETCC           , MVT::i8   , Custom);
 414   setOperationAction(ISD::SETCC           , MVT::i16  , Custom);
 415   setOperationAction(ISD::SETCC           , MVT::i32  , Custom);
 416   setOperationAction(ISD::SETCC           , MVT::f32  , Custom);
 417   setOperationAction(ISD::SETCC           , MVT::f64  , Custom);
 418   setOperationAction(ISD::SETCC           , MVT::f80  , Custom);
 419   if (Subtarget->is64Bit()) {
 420     setOperationAction(ISD::SELECT        , MVT::i64  , Custom);
 421     setOperationAction(ISD::SETCC         , MVT::i64  , Custom);
 422   }
 423   setOperationAction(ISD::EH_RETURN       , MVT::Other, Custom);
 424   // NOTE: EH_SJLJ_SETJMP/_LONGJMP supported here is NOT intended to support
 425   // SjLj exception handling but a light-weight setjmp/longjmp replacement to
 426   // support continuation, user-level threading, and etc.. As a result, no
 427   // other SjLj exception interfaces are implemented and please don't build
 428   // your own exception handling based on them.
 429   // LLVM/Clang supports zero-cost DWARF exception handling.
 430   setOperationAction(ISD::EH_SJLJ_SETJMP, MVT::i32, Custom);
 431   setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
 432
 433   // Darwin ABI issue.
 434   setOperationAction(ISD::ConstantPool    , MVT::i32  , Custom);
 435   setOperationAction(ISD::JumpTable       , MVT::i32  , Custom);
 436   setOperationAction(ISD::GlobalAddress   , MVT::i32  , Custom);
 437   setOperationAction(ISD::GlobalTLSAddress, MVT::i32  , Custom);
 438   if (Subtarget->is64Bit())
 439     setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
 440   setOperationAction(ISD::ExternalSymbol  , MVT::i32  , Custom);
 441   setOperationAction(ISD::BlockAddress    , MVT::i32  , Custom);
 442   if (Subtarget->is64Bit()) {
 443     setOperationAction(ISD::ConstantPool  , MVT::i64  , Custom);
 444     setOperationAction(ISD::JumpTable     , MVT::i64  , Custom);
 445     setOperationAction(ISD::GlobalAddress , MVT::i64  , Custom);
 446     setOperationAction(ISD::ExternalSymbol, MVT::i64  , Custom);
 447     setOperationAction(ISD::BlockAddress  , MVT::i64  , Custom);
 448   }
 449   // 64-bit addm sub, shl, sra, srl (iff 32-bit x86)
 450   setOperationAction(ISD::SHL_PARTS       , MVT::i32  , Custom);
 451   setOperationAction(ISD::SRA_PARTS       , MVT::i32  , Custom);
 452   setOperationAction(ISD::SRL_PARTS       , MVT::i32  , Custom);
 453   if (Subtarget->is64Bit()) {
 454     setOperationAction(ISD::SHL_PARTS     , MVT::i64  , Custom);
 455     setOperationAction(ISD::SRA_PARTS     , MVT::i64  , Custom);
 456     setOperationAction(ISD::SRL_PARTS     , MVT::i64  , Custom);
 457   }
 458
 459   if (Subtarget->hasSSE1())
 460     setOperationAction(ISD::PREFETCH      , MVT::Other, Legal);
 461
 462   setOperationAction(ISD::ATOMIC_FENCE  , MVT::Other, Custom);
 463
 464   // Expand certain atomics
 465   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
 466     MVT VT = IntVTs[i];
 467     setOperationAction(ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, VT, Custom);
 468     setOperationAction(ISD::ATOMIC_LOAD_SUB, VT, Custom);
 469     setOperationAction(ISD::ATOMIC_STORE, VT, Custom);
 470   }
 471
 472   if (Subtarget->hasCmpxchg16b()) {
 473     setOperationAction(ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, MVT::i128, Custom);
 474   }
 475
 476   // FIXME - use subtarget debug flags
 477   if (!Subtarget->isTargetDarwin() && !Subtarget->isTargetELF() &&
 478       !Subtarget->isTargetCygMing() && !Subtarget->isTargetWin64()) {
 479     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
 480   }
 481
 482   if (Subtarget->is64Bit()) {
 483     setExceptionPointerRegister(X86::RAX);
 484     setExceptionSelectorRegister(X86::RDX);
 485   } else {
 486     setExceptionPointerRegister(X86::EAX);
 487     setExceptionSelectorRegister(X86::EDX);
 488   }
 489   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i32, Custom);
 490   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i64, Custom);
 491
 492   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
 493   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
 494
 495   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 496   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Legal);
 497
 498   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
 499   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
 500   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
 501   if (Subtarget->is64Bit() && !Subtarget->isTargetWin64()) {
 502     // TargetInfo::X86_64ABIBuiltinVaList
 503     setOperationAction(ISD::VAARG           , MVT::Other, Custom);
 504     setOperationAction(ISD::VACOPY          , MVT::Other, Custom);
 505   } else {
 506     // TargetInfo::CharPtrBuiltinVaList
 507     setOperationAction(ISD::VAARG           , MVT::Other, Expand);
 508     setOperationAction(ISD::VACOPY          , MVT::Other, Expand);
 509   }
 510
 511   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
 512   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
 513
 514   setOperationAction(ISD::DYNAMIC_STACKALLOC, getPointerTy(), Custom);
 515
 516   if (!TM.Options.UseSoftFloat && X86ScalarSSEf64) {
 517     // f32 and f64 use SSE.
 518     // Set up the FP register classes.
 519     addRegisterClass(MVT::f32, &X86::FR32RegClass);
 520     addRegisterClass(MVT::f64, &X86::FR64RegClass);
 521
 522     // Use ANDPD to simulate FABS.
 523     setOperationAction(ISD::FABS , MVT::f64, Custom);
 524     setOperationAction(ISD::FABS , MVT::f32, Custom);
 525
 526     // Use XORP to simulate FNEG.
 527     setOperationAction(ISD::FNEG , MVT::f64, Custom);
 528     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 529
 530     // Use ANDPD and ORPD to simulate FCOPYSIGN.
 531     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
 532     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 533
 534     // Lower this to FGETSIGNx86 plus an AND.
 535     setOperationAction(ISD::FGETSIGN, MVT::i64, Custom);
 536     setOperationAction(ISD::FGETSIGN, MVT::i32, Custom);
 537
 538     // We don't support sin/cos/fmod
 539     setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 540     setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 541     setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 542     setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 543     setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 544     setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 545
 546     // Expand FP immediates into loads from the stack, except for the special
 547     // cases we handle.
 548     addLegalFPImmediate(APFloat(+0.0)); // xorpd
 549     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 550   } else if (!TM.Options.UseSoftFloat && X86ScalarSSEf32) {
 551     // Use SSE for f32, x87 for f64.
 552     // Set up the FP register classes.
 553     addRegisterClass(MVT::f32, &X86::FR32RegClass);
 554     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
 555
 556     // Use ANDPS to simulate FABS.
 557     setOperationAction(ISD::FABS , MVT::f32, Custom);
 558
 559     // Use XORP to simulate FNEG.
 560     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 561
 562     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 563
 564     // Use ANDPS and ORPS to simulate FCOPYSIGN.
 565     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 566     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 567
 568     // We don't support sin/cos/fmod
 569     setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 570     setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 571     setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 572
 573     // Special cases we handle for FP constants.
 574     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 575     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 576     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 577     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 578     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 579
 580     if (!TM.Options.UnsafeFPMath) {
 581       setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 582       setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 583       setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 584     }
 585   } else if (!TM.Options.UseSoftFloat) {
 586     // f32 and f64 in x87.
 587     // Set up the FP register classes.
 588     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
 589     addRegisterClass(MVT::f32, &X86::RFP32RegClass);
 590
 591     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 592     setOperationAction(ISD::UNDEF,     MVT::f32, Expand);
 593     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 594     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
 595
 596     if (!TM.Options.UnsafeFPMath) {
 597       setOperationAction(ISD::FSIN   , MVT::f64, Expand);
 598       setOperationAction(ISD::FSIN   , MVT::f32, Expand);
 599       setOperationAction(ISD::FCOS   , MVT::f64, Expand);
 600       setOperationAction(ISD::FCOS   , MVT::f32, Expand);
 601       setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
 602       setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
 603     }
 604     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 605     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 606     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 607     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 608     addLegalFPImmediate(APFloat(+0.0f)); // FLD0
 609     addLegalFPImmediate(APFloat(+1.0f)); // FLD1
 610     addLegalFPImmediate(APFloat(-0.0f)); // FLD0/FCHS
 611     addLegalFPImmediate(APFloat(-1.0f)); // FLD1/FCHS
 612   }
 613
 614   // We don't support FMA.
 615   setOperationAction(ISD::FMA, MVT::f64, Expand);
 616   setOperationAction(ISD::FMA, MVT::f32, Expand);
 617
 618   // Long double always uses X87.
 619   if (!TM.Options.UseSoftFloat) {
 620     addRegisterClass(MVT::f80, &X86::RFP80RegClass);
 621     setOperationAction(ISD::UNDEF,     MVT::f80, Expand);
 622     setOperationAction(ISD::FCOPYSIGN, MVT::f80, Expand);
 623     {
 624       APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended);
 625       addLegalFPImmediate(TmpFlt);  // FLD0
 626       TmpFlt.changeSign();
 627       addLegalFPImmediate(TmpFlt);  // FLD0/FCHS
 628
 629       bool ignored;
 630       APFloat TmpFlt2(+1.0);
 631       TmpFlt2.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
 632                       &ignored);
 633       addLegalFPImmediate(TmpFlt2);  // FLD1
 634       TmpFlt2.changeSign();
 635       addLegalFPImmediate(TmpFlt2);  // FLD1/FCHS
 636     }
 637
 638     if (!TM.Options.UnsafeFPMath) {
 639       setOperationAction(ISD::FSIN   , MVT::f80, Expand);
 640       setOperationAction(ISD::FCOS   , MVT::f80, Expand);
 641       setOperationAction(ISD::FSINCOS, MVT::f80, Expand);
 642     }
 643
 644     setOperationAction(ISD::FFLOOR, MVT::f80, Expand);
 645     setOperationAction(ISD::FCEIL,  MVT::f80, Expand);
 646     setOperationAction(ISD::FTRUNC, MVT::f80, Expand);
 647     setOperationAction(ISD::FRINT,  MVT::f80, Expand);
 648     setOperationAction(ISD::FNEARBYINT, MVT::f80, Expand);
 649     setOperationAction(ISD::FMA, MVT::f80, Expand);
 650   }
 651
 652   // Always use a library call for pow.
 653   setOperationAction(ISD::FPOW             , MVT::f32  , Expand);
 654   setOperationAction(ISD::FPOW             , MVT::f64  , Expand);
 655   setOperationAction(ISD::FPOW             , MVT::f80  , Expand);
 656
 657   setOperationAction(ISD::FLOG, MVT::f80, Expand);
 658   setOperationAction(ISD::FLOG2, MVT::f80, Expand);
 659   setOperationAction(ISD::FLOG10, MVT::f80, Expand);
 660   setOperationAction(ISD::FEXP, MVT::f80, Expand);
 661   setOperationAction(ISD::FEXP2, MVT::f80, Expand);
 662   setOperationAction(ISD::FMINNUM, MVT::f80, Expand);
 663   setOperationAction(ISD::FMAXNUM, MVT::f80, Expand);
 664
 665   // First set operation action for all vector types to either promote
 666   // (for widening) or expand (for scalarization). Then we will selectively
 667   // turn on ones that can be effectively codegen'd.
 668   for (MVT VT : MVT::vector_valuetypes()) {
 669     setOperationAction(ISD::ADD , VT, Expand);
 670     setOperationAction(ISD::SUB , VT, Expand);
 671     setOperationAction(ISD::FADD, VT, Expand);
 672     setOperationAction(ISD::FNEG, VT, Expand);
 673     setOperationAction(ISD::FSUB, VT, Expand);
 674     setOperationAction(ISD::MUL , VT, Expand);
 675     setOperationAction(ISD::FMUL, VT, Expand);
 676     setOperationAction(ISD::SDIV, VT, Expand);
 677     setOperationAction(ISD::UDIV, VT, Expand);
 678     setOperationAction(ISD::FDIV, VT, Expand);
 679     setOperationAction(ISD::SREM, VT, Expand);
 680     setOperationAction(ISD::UREM, VT, Expand);
 681     setOperationAction(ISD::LOAD, VT, Expand);
 682     setOperationAction(ISD::VECTOR_SHUFFLE, VT, Expand);
 683     setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT,Expand);
 684     setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Expand);
 685     setOperationAction(ISD::EXTRACT_SUBVECTOR, VT,Expand);
 686     setOperationAction(ISD::INSERT_SUBVECTOR, VT,Expand);
 687     setOperationAction(ISD::FABS, VT, Expand);
 688     setOperationAction(ISD::FSIN, VT, Expand);
 689     setOperationAction(ISD::FSINCOS, VT, Expand);
 690     setOperationAction(ISD::FCOS, VT, Expand);
 691     setOperationAction(ISD::FSINCOS, VT, Expand);
 692     setOperationAction(ISD::FREM, VT, Expand);
 693     setOperationAction(ISD::FMA,  VT, Expand);
 694     setOperationAction(ISD::FPOWI, VT, Expand);
 695     setOperationAction(ISD::FSQRT, VT, Expand);
 696     setOperationAction(ISD::FCOPYSIGN, VT, Expand);
 697     setOperationAction(ISD::FFLOOR, VT, Expand);
 698     setOperationAction(ISD::FCEIL, VT, Expand);
 699     setOperationAction(ISD::FTRUNC, VT, Expand);
 700     setOperationAction(ISD::FRINT, VT, Expand);
 701     setOperationAction(ISD::FNEARBYINT, VT, Expand);
 702     setOperationAction(ISD::SMUL_LOHI, VT, Expand);
 703     setOperationAction(ISD::MULHS, VT, Expand);
 704     setOperationAction(ISD::UMUL_LOHI, VT, Expand);
 705     setOperationAction(ISD::MULHU, VT, Expand);
 706     setOperationAction(ISD::SDIVREM, VT, Expand);
 707     setOperationAction(ISD::UDIVREM, VT, Expand);
 708     setOperationAction(ISD::FPOW, VT, Expand);
 709     setOperationAction(ISD::CTPOP, VT, Expand);
 710     setOperationAction(ISD::CTTZ, VT, Expand);
 711     setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Expand);
 712     setOperationAction(ISD::CTLZ, VT, Expand);
 713     setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Expand);
 714     setOperationAction(ISD::SHL, VT, Expand);
 715     setOperationAction(ISD::SRA, VT, Expand);
 716     setOperationAction(ISD::SRL, VT, Expand);
 717     setOperationAction(ISD::ROTL, VT, Expand);
 718     setOperationAction(ISD::ROTR, VT, Expand);
 719     setOperationAction(ISD::BSWAP, VT, Expand);
 720     setOperationAction(ISD::SETCC, VT, Expand);
 721     setOperationAction(ISD::FLOG, VT, Expand);
 722     setOperationAction(ISD::FLOG2, VT, Expand);
 723     setOperationAction(ISD::FLOG10, VT, Expand);
 724     setOperationAction(ISD::FEXP, VT, Expand);
 725     setOperationAction(ISD::FEXP2, VT, Expand);
 726     setOperationAction(ISD::FP_TO_UINT, VT, Expand);
 727     setOperationAction(ISD::FP_TO_SINT, VT, Expand);
 728     setOperationAction(ISD::UINT_TO_FP, VT, Expand);
 729     setOperationAction(ISD::SINT_TO_FP, VT, Expand);
 730     setOperationAction(ISD::SIGN_EXTEND_INREG, VT,Expand);
 731     setOperationAction(ISD::TRUNCATE, VT, Expand);
 732     setOperationAction(ISD::SIGN_EXTEND, VT, Expand);
 733     setOperationAction(ISD::ZERO_EXTEND, VT, Expand);
 734     setOperationAction(ISD::ANY_EXTEND, VT, Expand);
 735     setOperationAction(ISD::VSELECT, VT, Expand);
 736     setOperationAction(ISD::SELECT_CC, VT, Expand);
 737     for (MVT InnerVT : MVT::vector_valuetypes()) {
 738       setTruncStoreAction(InnerVT, VT, Expand);
 739
 740       setLoadExtAction(ISD::SEXTLOAD, InnerVT, VT, Expand);
 741       setLoadExtAction(ISD::ZEXTLOAD, InnerVT, VT, Expand);
 742
 743       // N.b. ISD::EXTLOAD legality is basically ignored except for i1-like
 744       // types, we have to deal with them whether we ask for Expansion or not.
 745       // Setting Expand causes its own optimisation problems though, so leave
 746       // them legal.
 747       if (VT.getVectorElementType() == MVT::i1)
 748         setLoadExtAction(ISD::EXTLOAD, InnerVT, VT, Expand);
 749     }
 750   }
 751
 752   // FIXME: In order to prevent SSE instructions being expanded to MMX ones
 753   // with -msoft-float, disable use of MMX as well.
 754   if (!TM.Options.UseSoftFloat && Subtarget->hasMMX()) {
 755     addRegisterClass(MVT::x86mmx, &X86::VR64RegClass);
 756     // No operations on x86mmx supported, everything uses intrinsics.
 757   }
 758
 759   // MMX-sized vectors (other than x86mmx) are expected to be expanded
 760   // into smaller operations.
 761   for (MVT MMXTy : {MVT::v8i8, MVT::v4i16, MVT::v2i32, MVT::v1i64}) {
 762     setOperationAction(ISD::MULHS,              MMXTy,      Expand);
 763     setOperationAction(ISD::AND,                MMXTy,      Expand);
 764     setOperationAction(ISD::OR,                 MMXTy,      Expand);
 765     setOperationAction(ISD::XOR,                MMXTy,      Expand);
 766     setOperationAction(ISD::SCALAR_TO_VECTOR,   MMXTy,      Expand);
 767     setOperationAction(ISD::SELECT,             MMXTy,      Expand);
 768     setOperationAction(ISD::BITCAST,            MMXTy,      Expand);
 769   }
 770   setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v1i64, Expand);
 771
 772   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE1()) {
 773     addRegisterClass(MVT::v4f32, &X86::VR128RegClass);
 774
 775     setOperationAction(ISD::FADD,               MVT::v4f32, Legal);
 776     setOperationAction(ISD::FSUB,               MVT::v4f32, Legal);
 777     setOperationAction(ISD::FMUL,               MVT::v4f32, Legal);
 778     setOperationAction(ISD::FDIV,               MVT::v4f32, Legal);
 779     setOperationAction(ISD::FSQRT,              MVT::v4f32, Legal);
 780     setOperationAction(ISD::FNEG,               MVT::v4f32, Custom);
 781     setOperationAction(ISD::FABS,               MVT::v4f32, Custom);
 782     setOperationAction(ISD::LOAD,               MVT::v4f32, Legal);
 783     setOperationAction(ISD::BUILD_VECTOR,       MVT::v4f32, Custom);
 784     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v4f32, Custom);
 785     setOperationAction(ISD::VSELECT,            MVT::v4f32, Custom);
 786     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
 787     setOperationAction(ISD::SELECT,             MVT::v4f32, Custom);
 788     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i32, Custom);
 789   }
 790
 791   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE2()) {
 792     addRegisterClass(MVT::v2f64, &X86::VR128RegClass);
 793
 794     // FIXME: Unfortunately, -soft-float and -no-implicit-float mean XMM
 795     // registers cannot be used even for integer operations.
 796     addRegisterClass(MVT::v16i8, &X86::VR128RegClass);
 797     addRegisterClass(MVT::v8i16, &X86::VR128RegClass);
 798     addRegisterClass(MVT::v4i32, &X86::VR128RegClass);
 799     addRegisterClass(MVT::v2i64, &X86::VR128RegClass);
 800
 801     setOperationAction(ISD::ADD,                MVT::v16i8, Legal);
 802     setOperationAction(ISD::ADD,                MVT::v8i16, Legal);
 803     setOperationAction(ISD::ADD,                MVT::v4i32, Legal);
 804     setOperationAction(ISD::ADD,                MVT::v2i64, Legal);
 805     setOperationAction(ISD::MUL,                MVT::v4i32, Custom);
 806     setOperationAction(ISD::MUL,                MVT::v2i64, Custom);
 807     setOperationAction(ISD::UMUL_LOHI,          MVT::v4i32, Custom);
 808     setOperationAction(ISD::SMUL_LOHI,          MVT::v4i32, Custom);
 809     setOperationAction(ISD::MULHU,              MVT::v8i16, Legal);
 810     setOperationAction(ISD::MULHS,              MVT::v8i16, Legal);
 811     setOperationAction(ISD::SUB,                MVT::v16i8, Legal);
 812     setOperationAction(ISD::SUB,                MVT::v8i16, Legal);
 813     setOperationAction(ISD::SUB,                MVT::v4i32, Legal);
 814     setOperationAction(ISD::SUB,                MVT::v2i64, Legal);
 815     setOperationAction(ISD::MUL,                MVT::v8i16, Legal);
 816     setOperationAction(ISD::FADD,               MVT::v2f64, Legal);
 817     setOperationAction(ISD::FSUB,               MVT::v2f64, Legal);
 818     setOperationAction(ISD::FMUL,               MVT::v2f64, Legal);
 819     setOperationAction(ISD::FDIV,               MVT::v2f64, Legal);
 820     setOperationAction(ISD::FSQRT,              MVT::v2f64, Legal);
 821     setOperationAction(ISD::FNEG,               MVT::v2f64, Custom);
 822     setOperationAction(ISD::FABS,               MVT::v2f64, Custom);
 823
 824     setOperationAction(ISD::SETCC,              MVT::v2i64, Custom);
 825     setOperationAction(ISD::SETCC,              MVT::v16i8, Custom);
 826     setOperationAction(ISD::SETCC,              MVT::v8i16, Custom);
 827     setOperationAction(ISD::SETCC,              MVT::v4i32, Custom);
 828
 829     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v16i8, Custom);
 830     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i16, Custom);
 831     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
 832     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
 833     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
 834
 835     // Only provide customized ctpop vector bit twiddling for vector types we
 836     // know to perform better than using the popcnt instructions on each vector
 837     // element. If popcnt isn't supported, always provide the custom version.
 838     if (!Subtarget->hasPOPCNT()) {
 839       setOperationAction(ISD::CTPOP,            MVT::v4i32, Custom);
 840       setOperationAction(ISD::CTPOP,            MVT::v2i64, Custom);
 841     }
 842
 843     // Custom lower build_vector, vector_shuffle, and extract_vector_elt.
 844     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
 845       MVT VT = (MVT::SimpleValueType)i;
 846       // Do not attempt to custom lower non-power-of-2 vectors
 847       if (!isPowerOf2_32(VT.getVectorNumElements()))
 848         continue;
 849       // Do not attempt to custom lower non-128-bit vectors
 850       if (!VT.is128BitVector())
 851         continue;
 852       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
 853       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
 854       setOperationAction(ISD::VSELECT,            VT, Custom);
 855       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
 856     }
 857
 858     // We support custom legalizing of sext and anyext loads for specific
 859     // memory vector types which we can load as a scalar (or sequence of
 860     // scalars) and extend in-register to a legal 128-bit vector type. For sext
 861     // loads these must work with a single scalar load.
 862     for (MVT VT : MVT::integer_vector_valuetypes()) {
 863       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v4i8, Custom);
 864       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v4i16, Custom);
 865       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v8i8, Custom);
 866       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i8, Custom);
 867       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i16, Custom);
 868       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2i32, Custom);
 869       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4i8, Custom);
 870       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4i16, Custom);
 871       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v8i8, Custom);
 872     }
 873
 874     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2f64, Custom);
 875     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2i64, Custom);
 876     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2f64, Custom);
 877     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2i64, Custom);
 878     setOperationAction(ISD::VSELECT,            MVT::v2f64, Custom);
 879     setOperationAction(ISD::VSELECT,            MVT::v2i64, Custom);
 880     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2f64, Custom);
 881     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Custom);
 882
 883     if (Subtarget->is64Bit()) {
 884       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
 885       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
 886     }
 887
 888     // Promote v16i8, v8i16, v4i32 load, select, and, or, xor to v2i64.
 889     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
 890       MVT VT = (MVT::SimpleValueType)i;
 891
 892       // Do not attempt to promote non-128-bit vectors
 893       if (!VT.is128BitVector())
 894         continue;
 895
 896       setOperationAction(ISD::AND,    VT, Promote);
 897       AddPromotedToType (ISD::AND,    VT, MVT::v2i64);
 898       setOperationAction(ISD::OR,     VT, Promote);
 899       AddPromotedToType (ISD::OR,     VT, MVT::v2i64);
 900       setOperationAction(ISD::XOR,    VT, Promote);
 901       AddPromotedToType (ISD::XOR,    VT, MVT::v2i64);
 902       setOperationAction(ISD::LOAD,   VT, Promote);
 903       AddPromotedToType (ISD::LOAD,   VT, MVT::v2i64);
 904       setOperationAction(ISD::SELECT, VT, Promote);
 905       AddPromotedToType (ISD::SELECT, VT, MVT::v2i64);
 906     }
 907
 908     // Custom lower v2i64 and v2f64 selects.
 909     setOperationAction(ISD::LOAD,               MVT::v2f64, Legal);
 910     setOperationAction(ISD::LOAD,               MVT::v2i64, Legal);
 911     setOperationAction(ISD::SELECT,             MVT::v2f64, Custom);
 912     setOperationAction(ISD::SELECT,             MVT::v2i64, Custom);
 913
 914     setOperationAction(ISD::FP_TO_SINT,         MVT::v4i32, Legal);
 915     setOperationAction(ISD::SINT_TO_FP,         MVT::v4i32, Legal);
 916
 917     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i8,  Custom);
 918     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i16, Custom);
 919     // As there is no 64-bit GPR available, we need build a special custom
 920     // sequence to convert from v2i32 to v2f32.
 921     if (!Subtarget->is64Bit())
 922       setOperationAction(ISD::UINT_TO_FP,       MVT::v2f32, Custom);
 923
 924     setOperationAction(ISD::FP_EXTEND,          MVT::v2f32, Custom);
 925     setOperationAction(ISD::FP_ROUND,           MVT::v2f32, Custom);
 926
 927     for (MVT VT : MVT::fp_vector_valuetypes())
 928       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v2f32, Legal);
 929
 930     setOperationAction(ISD::BITCAST,            MVT::v2i32, Custom);
 931     setOperationAction(ISD::BITCAST,            MVT::v4i16, Custom);
 932     setOperationAction(ISD::BITCAST,            MVT::v8i8,  Custom);
 933   }
 934
 935   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE41()) {
 936     for (MVT RoundedTy : {MVT::f32, MVT::f64, MVT::v4f32, MVT::v2f64}) {
 937       setOperationAction(ISD::FFLOOR,           RoundedTy,  Legal);
 938       setOperationAction(ISD::FCEIL,            RoundedTy,  Legal);
 939       setOperationAction(ISD::FTRUNC,           RoundedTy,  Legal);
 940       setOperationAction(ISD::FRINT,            RoundedTy,  Legal);
 941       setOperationAction(ISD::FNEARBYINT,       RoundedTy,  Legal);
 942     }
 943
 944     // FIXME: Do we need to handle scalar-to-vector here?
 945     setOperationAction(ISD::MUL,                MVT::v4i32, Legal);
 946
 947     // We directly match byte blends in the backend as they match the VSELECT
 948     // condition form.
 949     setOperationAction(ISD::VSELECT,            MVT::v16i8, Legal);
 950
 951     // SSE41 brings specific instructions for doing vector sign extend even in
 952     // cases where we don't have SRA.
 953     for (MVT VT : MVT::integer_vector_valuetypes()) {
 954       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i8, Custom);
 955       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i16, Custom);
 956       setLoadExtAction(ISD::SEXTLOAD, VT, MVT::v2i32, Custom);
 957     }
 958
 959     // SSE41 also has vector sign/zero extending loads, PMOV[SZ]X
 960     setLoadExtAction(ISD::SEXTLOAD, MVT::v8i16, MVT::v8i8,  Legal);
 961     setLoadExtAction(ISD::SEXTLOAD, MVT::v4i32, MVT::v4i8,  Legal);
 962     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i8,  Legal);
 963     setLoadExtAction(ISD::SEXTLOAD, MVT::v4i32, MVT::v4i16, Legal);
 964     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i16, Legal);
 965     setLoadExtAction(ISD::SEXTLOAD, MVT::v2i64, MVT::v2i32, Legal);
 966
 967     setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i16, MVT::v8i8,  Legal);
 968     setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i32, MVT::v4i8,  Legal);
 969     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i8,  Legal);
 970     setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i32, MVT::v4i16, Legal);
 971     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i16, Legal);
 972     setLoadExtAction(ISD::ZEXTLOAD, MVT::v2i64, MVT::v2i32, Legal);
 973
 974     // i8 and i16 vectors are custom because the source register and source
 975     // source memory operand types are not the same width.  f32 vectors are
 976     // custom since the immediate controlling the insert encodes additional
 977     // information.
 978     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i8, Custom);
 979     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
 980     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
 981     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
 982
 983     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i8, Custom);
 984     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i16, Custom);
 985     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4i32, Custom);
 986     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
 987
 988     // FIXME: these should be Legal, but that's only for the case where
 989     // the index is constant.  For now custom expand to deal with that.
 990     if (Subtarget->is64Bit()) {
 991       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
 992       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
 993     }
 994   }
 995
 996   if (Subtarget->hasSSE2()) {
 997     setOperationAction(ISD::SRL,               MVT::v8i16, Custom);
 998     setOperationAction(ISD::SRL,               MVT::v16i8, Custom);
 999
1000     setOperationAction(ISD::SHL,               MVT::v8i16, Custom);
1001     setOperationAction(ISD::SHL,               MVT::v16i8, Custom);
1002
1003     setOperationAction(ISD::SRA,               MVT::v8i16, Custom);
1004     setOperationAction(ISD::SRA,               MVT::v16i8, Custom);
1005
1006     // In the customized shift lowering, the legal cases in AVX2 will be
1007     // recognized.
1008     setOperationAction(ISD::SRL,               MVT::v2i64, Custom);
1009     setOperationAction(ISD::SRL,               MVT::v4i32, Custom);
1010
1011     setOperationAction(ISD::SHL,               MVT::v2i64, Custom);
1012     setOperationAction(ISD::SHL,               MVT::v4i32, Custom);
1013
1014     setOperationAction(ISD::SRA,               MVT::v4i32, Custom);
1015   }
1016
1017   if (!TM.Options.UseSoftFloat && Subtarget->hasFp256()) {
1018     addRegisterClass(MVT::v32i8,  &X86::VR256RegClass);
1019     addRegisterClass(MVT::v16i16, &X86::VR256RegClass);
1020     addRegisterClass(MVT::v8i32,  &X86::VR256RegClass);
1021     addRegisterClass(MVT::v8f32,  &X86::VR256RegClass);
1022     addRegisterClass(MVT::v4i64,  &X86::VR256RegClass);
1023     addRegisterClass(MVT::v4f64,  &X86::VR256RegClass);
1024
1025     setOperationAction(ISD::LOAD,               MVT::v8f32, Legal);
1026     setOperationAction(ISD::LOAD,               MVT::v4f64, Legal);
1027     setOperationAction(ISD::LOAD,               MVT::v4i64, Legal);
1028
1029     setOperationAction(ISD::FADD,               MVT::v8f32, Legal);
1030     setOperationAction(ISD::FSUB,               MVT::v8f32, Legal);
1031     setOperationAction(ISD::FMUL,               MVT::v8f32, Legal);
1032     setOperationAction(ISD::FDIV,               MVT::v8f32, Legal);
1033     setOperationAction(ISD::FSQRT,              MVT::v8f32, Legal);
1034     setOperationAction(ISD::FFLOOR,             MVT::v8f32, Legal);
1035     setOperationAction(ISD::FCEIL,              MVT::v8f32, Legal);
1036     setOperationAction(ISD::FTRUNC,             MVT::v8f32, Legal);
1037     setOperationAction(ISD::FRINT,              MVT::v8f32, Legal);
1038     setOperationAction(ISD::FNEARBYINT,         MVT::v8f32, Legal);
1039     setOperationAction(ISD::FNEG,               MVT::v8f32, Custom);
1040     setOperationAction(ISD::FABS,               MVT::v8f32, Custom);
1041
1042     setOperationAction(ISD::FADD,               MVT::v4f64, Legal);
1043     setOperationAction(ISD::FSUB,               MVT::v4f64, Legal);
1044     setOperationAction(ISD::FMUL,               MVT::v4f64, Legal);
1045     setOperationAction(ISD::FDIV,               MVT::v4f64, Legal);
1046     setOperationAction(ISD::FSQRT,              MVT::v4f64, Legal);
1047     setOperationAction(ISD::FFLOOR,             MVT::v4f64, Legal);
1048     setOperationAction(ISD::FCEIL,              MVT::v4f64, Legal);
1049     setOperationAction(ISD::FTRUNC,             MVT::v4f64, Legal);
1050     setOperationAction(ISD::FRINT,              MVT::v4f64, Legal);
1051     setOperationAction(ISD::FNEARBYINT,         MVT::v4f64, Legal);
1052     setOperationAction(ISD::FNEG,               MVT::v4f64, Custom);
1053     setOperationAction(ISD::FABS,               MVT::v4f64, Custom);
1054
1055     // (fp_to_int:v8i16 (v8f32 ..)) requires the result type to be promoted
1056     // even though v8i16 is a legal type.
1057     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i16, Promote);
1058     setOperationAction(ISD::FP_TO_UINT,         MVT::v8i16, Promote);
1059     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i32, Legal);
1060
1061     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i16, Promote);
1062     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i32, Legal);
1063     setOperationAction(ISD::FP_ROUND,           MVT::v4f32, Legal);
1064
1065     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i8,  Custom);
1066     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i16, Custom);
1067
1068     for (MVT VT : MVT::fp_vector_valuetypes())
1069       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v4f32, Legal);
1070
1071     setOperationAction(ISD::SRL,               MVT::v16i16, Custom);
1072     setOperationAction(ISD::SRL,               MVT::v32i8, Custom);
1073
1074     setOperationAction(ISD::SHL,               MVT::v16i16, Custom);
1075     setOperationAction(ISD::SHL,               MVT::v32i8, Custom);
1076
1077     setOperationAction(ISD::SRA,               MVT::v16i16, Custom);
1078     setOperationAction(ISD::SRA,               MVT::v32i8, Custom);
1079
1080     setOperationAction(ISD::SETCC,             MVT::v32i8, Custom);
1081     setOperationAction(ISD::SETCC,             MVT::v16i16, Custom);
1082     setOperationAction(ISD::SETCC,             MVT::v8i32, Custom);
1083     setOperationAction(ISD::SETCC,             MVT::v4i64, Custom);
1084
1085     setOperationAction(ISD::SELECT,            MVT::v4f64, Custom);
1086     setOperationAction(ISD::SELECT,            MVT::v4i64, Custom);
1087     setOperationAction(ISD::SELECT,            MVT::v8f32, Custom);
1088
1089     setOperationAction(ISD::SIGN_EXTEND,       MVT::v4i64, Custom);
1090     setOperationAction(ISD::SIGN_EXTEND,       MVT::v8i32, Custom);
1091     setOperationAction(ISD::SIGN_EXTEND,       MVT::v16i16, Custom);
1092     setOperationAction(ISD::ZERO_EXTEND,       MVT::v4i64, Custom);
1093     setOperationAction(ISD::ZERO_EXTEND,       MVT::v8i32, Custom);
1094     setOperationAction(ISD::ZERO_EXTEND,       MVT::v16i16, Custom);
1095     setOperationAction(ISD::ANY_EXTEND,        MVT::v4i64, Custom);
1096     setOperationAction(ISD::ANY_EXTEND,        MVT::v8i32, Custom);
1097     setOperationAction(ISD::ANY_EXTEND,        MVT::v16i16, Custom);
1098     setOperationAction(ISD::TRUNCATE,          MVT::v16i8, Custom);
1099     setOperationAction(ISD::TRUNCATE,          MVT::v8i16, Custom);
1100     setOperationAction(ISD::TRUNCATE,          MVT::v4i32, Custom);
1101
1102     if (Subtarget->hasFMA() || Subtarget->hasFMA4()) {
1103       setOperationAction(ISD::FMA,             MVT::v8f32, Legal);
1104       setOperationAction(ISD::FMA,             MVT::v4f64, Legal);
1105       setOperationAction(ISD::FMA,             MVT::v4f32, Legal);
1106       setOperationAction(ISD::FMA,             MVT::v2f64, Legal);
1107       setOperationAction(ISD::FMA,             MVT::f32, Legal);
1108       setOperationAction(ISD::FMA,             MVT::f64, Legal);
1109     }
1110
1111     if (Subtarget->hasInt256()) {
1112       setOperationAction(ISD::ADD,             MVT::v4i64, Legal);
1113       setOperationAction(ISD::ADD,             MVT::v8i32, Legal);
1114       setOperationAction(ISD::ADD,             MVT::v16i16, Legal);
1115       setOperationAction(ISD::ADD,             MVT::v32i8, Legal);
1116
1117       setOperationAction(ISD::SUB,             MVT::v4i64, Legal);
1118       setOperationAction(ISD::SUB,             MVT::v8i32, Legal);
1119       setOperationAction(ISD::SUB,             MVT::v16i16, Legal);
1120       setOperationAction(ISD::SUB,             MVT::v32i8, Legal);
1121
1122       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1123       setOperationAction(ISD::MUL,             MVT::v8i32, Legal);
1124       setOperationAction(ISD::MUL,             MVT::v16i16, Legal);
1125       // Don't lower v32i8 because there is no 128-bit byte mul
1126
1127       setOperationAction(ISD::UMUL_LOHI,       MVT::v8i32, Custom);
1128       setOperationAction(ISD::SMUL_LOHI,       MVT::v8i32, Custom);
1129       setOperationAction(ISD::MULHU,           MVT::v16i16, Legal);
1130       setOperationAction(ISD::MULHS,           MVT::v16i16, Legal);
1131
1132       // The custom lowering for UINT_TO_FP for v8i32 becomes interesting
1133       // when we have a 256bit-wide blend with immediate.
1134       setOperationAction(ISD::UINT_TO_FP, MVT::v8i32, Custom);
1135
1136       // Only provide customized ctpop vector bit twiddling for vector types we
1137       // know to perform better than using the popcnt instructions on each
1138       // vector element. If popcnt isn't supported, always provide the custom
1139       // version.
1140       if (!Subtarget->hasPOPCNT())
1141         setOperationAction(ISD::CTPOP,           MVT::v4i64, Custom);
1142
1143       // Custom CTPOP always performs better on natively supported v8i32
1144       setOperationAction(ISD::CTPOP,             MVT::v8i32, Custom);
1145
1146       // AVX2 also has wider vector sign/zero extending loads, VPMOV[SZ]X
1147       setLoadExtAction(ISD::SEXTLOAD, MVT::v16i16, MVT::v16i8, Legal);
1148       setLoadExtAction(ISD::SEXTLOAD, MVT::v8i32,  MVT::v8i8,  Legal);
1149       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i8,  Legal);
1150       setLoadExtAction(ISD::SEXTLOAD, MVT::v8i32,  MVT::v8i16, Legal);
1151       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i16, Legal);
1152       setLoadExtAction(ISD::SEXTLOAD, MVT::v4i64,  MVT::v4i32, Legal);
1153
1154       setLoadExtAction(ISD::ZEXTLOAD, MVT::v16i16, MVT::v16i8, Legal);
1155       setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i32,  MVT::v8i8,  Legal);
1156       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i8,  Legal);
1157       setLoadExtAction(ISD::ZEXTLOAD, MVT::v8i32,  MVT::v8i16, Legal);
1158       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i16, Legal);
1159       setLoadExtAction(ISD::ZEXTLOAD, MVT::v4i64,  MVT::v4i32, Legal);
1160     } else {
1161       setOperationAction(ISD::ADD,             MVT::v4i64, Custom);
1162       setOperationAction(ISD::ADD,             MVT::v8i32, Custom);
1163       setOperationAction(ISD::ADD,             MVT::v16i16, Custom);
1164       setOperationAction(ISD::ADD,             MVT::v32i8, Custom);
1165
1166       setOperationAction(ISD::SUB,             MVT::v4i64, Custom);
1167       setOperationAction(ISD::SUB,             MVT::v8i32, Custom);
1168       setOperationAction(ISD::SUB,             MVT::v16i16, Custom);
1169       setOperationAction(ISD::SUB,             MVT::v32i8, Custom);
1170
1171       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1172       setOperationAction(ISD::MUL,             MVT::v8i32, Custom);
1173       setOperationAction(ISD::MUL,             MVT::v16i16, Custom);
1174       // Don't lower v32i8 because there is no 128-bit byte mul
1175     }
1176
1177     // In the customized shift lowering, the legal cases in AVX2 will be
1178     // recognized.
1179     setOperationAction(ISD::SRL,               MVT::v4i64, Custom);
1180     setOperationAction(ISD::SRL,               MVT::v8i32, Custom);
1181
1182     setOperationAction(ISD::SHL,               MVT::v4i64, Custom);
1183     setOperationAction(ISD::SHL,               MVT::v8i32, Custom);
1184
1185     setOperationAction(ISD::SRA,               MVT::v8i32, Custom);
1186
1187     // Custom lower several nodes for 256-bit types.
1188     for (MVT VT : MVT::vector_valuetypes()) {
1189       if (VT.getScalarSizeInBits() >= 32) {
1190         setOperationAction(ISD::MLOAD,  VT, Legal);
1191         setOperationAction(ISD::MSTORE, VT, Legal);
1192       }
1193       // Extract subvector is special because the value type
1194       // (result) is 128-bit but the source is 256-bit wide.
1195       if (VT.is128BitVector()) {
1196         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Custom);
1197       }
1198       // Do not attempt to custom lower other non-256-bit vectors
1199       if (!VT.is256BitVector())
1200         continue;
1201
1202       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
1203       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
1204       setOperationAction(ISD::VSELECT,            VT, Custom);
1205       setOperationAction(ISD::INSERT_VECTOR_ELT,  VT, Custom);
1206       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
1207       setOperationAction(ISD::SCALAR_TO_VECTOR,   VT, Custom);
1208       setOperationAction(ISD::INSERT_SUBVECTOR,   VT, Custom);
1209       setOperationAction(ISD::CONCAT_VECTORS,     VT, Custom);
1210     }
1211
1212     if (Subtarget->hasInt256())
1213       setOperationAction(ISD::VSELECT,         MVT::v32i8, Legal);
1214
1215
1216     // Promote v32i8, v16i16, v8i32 select, and, or, xor to v4i64.
1217     for (int i = MVT::v32i8; i != MVT::v4i64; ++i) {
1218       MVT VT = (MVT::SimpleValueType)i;
1219
1220       // Do not attempt to promote non-256-bit vectors
1221       if (!VT.is256BitVector())
1222         continue;
1223
1224       setOperationAction(ISD::AND,    VT, Promote);
1225       AddPromotedToType (ISD::AND,    VT, MVT::v4i64);
1226       setOperationAction(ISD::OR,     VT, Promote);
1227       AddPromotedToType (ISD::OR,     VT, MVT::v4i64);
1228       setOperationAction(ISD::XOR,    VT, Promote);
1229       AddPromotedToType (ISD::XOR,    VT, MVT::v4i64);
1230       setOperationAction(ISD::LOAD,   VT, Promote);
1231       AddPromotedToType (ISD::LOAD,   VT, MVT::v4i64);
1232       setOperationAction(ISD::SELECT, VT, Promote);
1233       AddPromotedToType (ISD::SELECT, VT, MVT::v4i64);
1234     }
1235   }
1236
1237   if (!TM.Options.UseSoftFloat && Subtarget->hasAVX512()) {
1238     addRegisterClass(MVT::v16i32, &X86::VR512RegClass);
1239     addRegisterClass(MVT::v16f32, &X86::VR512RegClass);
1240     addRegisterClass(MVT::v8i64,  &X86::VR512RegClass);
1241     addRegisterClass(MVT::v8f64,  &X86::VR512RegClass);
1242
1243     addRegisterClass(MVT::i1,     &X86::VK1RegClass);
1244     addRegisterClass(MVT::v8i1,   &X86::VK8RegClass);
1245     addRegisterClass(MVT::v16i1,  &X86::VK16RegClass);
1246
1247     for (MVT VT : MVT::fp_vector_valuetypes())
1248       setLoadExtAction(ISD::EXTLOAD, VT, MVT::v8f32, Legal);
1249
1250     setOperationAction(ISD::BR_CC,              MVT::i1,    Expand);
1251     setOperationAction(ISD::SETCC,              MVT::i1,    Custom);
1252     setOperationAction(ISD::XOR,                MVT::i1,    Legal);
1253     setOperationAction(ISD::OR,                 MVT::i1,    Legal);
1254     setOperationAction(ISD::AND,                MVT::i1,    Legal);
1255     setOperationAction(ISD::LOAD,               MVT::v16f32, Legal);
1256     setOperationAction(ISD::LOAD,               MVT::v8f64, Legal);
1257     setOperationAction(ISD::LOAD,               MVT::v8i64, Legal);
1258     setOperationAction(ISD::LOAD,               MVT::v16i32, Legal);
1259     setOperationAction(ISD::LOAD,               MVT::v16i1, Legal);
1260
1261     setOperationAction(ISD::FADD,               MVT::v16f32, Legal);
1262     setOperationAction(ISD::FSUB,               MVT::v16f32, Legal);
1263     setOperationAction(ISD::FMUL,               MVT::v16f32, Legal);
1264     setOperationAction(ISD::FDIV,               MVT::v16f32, Legal);
1265     setOperationAction(ISD::FSQRT,              MVT::v16f32, Legal);
1266     setOperationAction(ISD::FNEG,               MVT::v16f32, Custom);
1267
1268     setOperationAction(ISD::FADD,               MVT::v8f64, Legal);
1269     setOperationAction(ISD::FSUB,               MVT::v8f64, Legal);
1270     setOperationAction(ISD::FMUL,               MVT::v8f64, Legal);
1271     setOperationAction(ISD::FDIV,               MVT::v8f64, Legal);
1272     setOperationAction(ISD::FSQRT,              MVT::v8f64, Legal);
1273     setOperationAction(ISD::FNEG,               MVT::v8f64, Custom);
1274     setOperationAction(ISD::FMA,                MVT::v8f64, Legal);
1275     setOperationAction(ISD::FMA,                MVT::v16f32, Legal);
1276
1277     setOperationAction(ISD::FP_TO_SINT,         MVT::i32, Legal);
1278     setOperationAction(ISD::FP_TO_UINT,         MVT::i32, Legal);
1279     setOperationAction(ISD::SINT_TO_FP,         MVT::i32, Legal);
1280     setOperationAction(ISD::UINT_TO_FP,         MVT::i32, Legal);
1281     if (Subtarget->is64Bit()) {
1282       setOperationAction(ISD::FP_TO_UINT,       MVT::i64, Legal);
1283       setOperationAction(ISD::FP_TO_SINT,       MVT::i64, Legal);
1284       setOperationAction(ISD::SINT_TO_FP,       MVT::i64, Legal);
1285       setOperationAction(ISD::UINT_TO_FP,       MVT::i64, Legal);
1286     }
1287     setOperationAction(ISD::FP_TO_SINT,         MVT::v16i32, Legal);
1288     setOperationAction(ISD::FP_TO_UINT,         MVT::v16i32, Legal);
1289     setOperationAction(ISD::FP_TO_UINT,         MVT::v8i32, Legal);
1290     setOperationAction(ISD::FP_TO_UINT,         MVT::v4i32, Legal);
1291     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i32, Legal);
1292     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i1,   Custom);
1293     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i1,  Custom);
1294     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i8,  Promote);
1295     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i16, Promote);
1296     setOperationAction(ISD::UINT_TO_FP,         MVT::v16i32, Legal);
1297     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i32, Legal);
1298     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i32, Legal);
1299     setOperationAction(ISD::FP_ROUND,           MVT::v8f32, Legal);
1300     setOperationAction(ISD::FP_EXTEND,          MVT::v8f32, Legal);
1301
1302     setOperationAction(ISD::TRUNCATE,           MVT::i1, Custom);
1303     setOperationAction(ISD::TRUNCATE,           MVT::v16i8, Custom);
1304     setOperationAction(ISD::TRUNCATE,           MVT::v8i32, Custom);
1305     setOperationAction(ISD::TRUNCATE,           MVT::v8i1, Custom);
1306     setOperationAction(ISD::TRUNCATE,           MVT::v16i1, Custom);
1307     setOperationAction(ISD::TRUNCATE,           MVT::v16i16, Custom);
1308     setOperationAction(ISD::ZERO_EXTEND,        MVT::v16i32, Custom);
1309     setOperationAction(ISD::ZERO_EXTEND,        MVT::v8i64, Custom);
1310     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i32, Custom);
1311     setOperationAction(ISD::SIGN_EXTEND,        MVT::v8i64, Custom);
1312     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i8, Custom);
1313     setOperationAction(ISD::SIGN_EXTEND,        MVT::v8i16, Custom);
1314     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i16, Custom);
1315
1316     setOperationAction(ISD::FFLOOR,             MVT::v16f32, Legal);
1317     setOperationAction(ISD::FFLOOR,             MVT::v8f64, Legal);
1318     setOperationAction(ISD::FCEIL,              MVT::v16f32, Legal);
1319     setOperationAction(ISD::FCEIL,              MVT::v8f64, Legal);
1320     setOperationAction(ISD::FTRUNC,             MVT::v16f32, Legal);
1321     setOperationAction(ISD::FTRUNC,             MVT::v8f64, Legal);
1322     setOperationAction(ISD::FRINT,              MVT::v16f32, Legal);
1323     setOperationAction(ISD::FRINT,              MVT::v8f64, Legal);
1324     setOperationAction(ISD::FNEARBYINT,         MVT::v16f32, Legal);
1325     setOperationAction(ISD::FNEARBYINT,         MVT::v8f64, Legal);
1326
1327     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8f64,  Custom);
1328     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i64,  Custom);
1329     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16f32,  Custom);
1330     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i32,  Custom);
1331     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i1, Legal);
1332
1333     setOperationAction(ISD::SETCC,              MVT::v16i1, Custom);
1334     setOperationAction(ISD::SETCC,              MVT::v8i1, Custom);
1335
1336     setOperationAction(ISD::MUL,              MVT::v8i64, Custom);
1337
1338     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i1,  Custom);
1339     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i1, Custom);
1340     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i1, Custom);
1341     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i1, Custom);
1342     setOperationAction(ISD::BUILD_VECTOR,       MVT::v8i1, Custom);
1343     setOperationAction(ISD::BUILD_VECTOR,       MVT::v16i1, Custom);
1344     setOperationAction(ISD::SELECT,             MVT::v8f64, Custom);
1345     setOperationAction(ISD::SELECT,             MVT::v8i64, Custom);
1346     setOperationAction(ISD::SELECT,             MVT::v16f32, Custom);
1347
1348     setOperationAction(ISD::ADD,                MVT::v8i64, Legal);
1349     setOperationAction(ISD::ADD,                MVT::v16i32, Legal);
1350
1351     setOperationAction(ISD::SUB,                MVT::v8i64, Legal);
1352     setOperationAction(ISD::SUB,                MVT::v16i32, Legal);
1353
1354     setOperationAction(ISD::MUL,                MVT::v16i32, Legal);
1355
1356     setOperationAction(ISD::SRL,                MVT::v8i64, Custom);
1357     setOperationAction(ISD::SRL,                MVT::v16i32, Custom);
1358
1359     setOperationAction(ISD::SHL,                MVT::v8i64, Custom);
1360     setOperationAction(ISD::SHL,                MVT::v16i32, Custom);
1361
1362     setOperationAction(ISD::SRA,                MVT::v8i64, Custom);
1363     setOperationAction(ISD::SRA,                MVT::v16i32, Custom);
1364
1365     setOperationAction(ISD::AND,                MVT::v8i64, Legal);
1366     setOperationAction(ISD::OR,                 MVT::v8i64, Legal);
1367     setOperationAction(ISD::XOR,                MVT::v8i64, Legal);
1368     setOperationAction(ISD::AND,                MVT::v16i32, Legal);
1369     setOperationAction(ISD::OR,                 MVT::v16i32, Legal);
1370     setOperationAction(ISD::XOR,                MVT::v16i32, Legal);
1371
1372     if (Subtarget->hasCDI()) {
1373       setOperationAction(ISD::CTLZ,             MVT::v8i64, Legal);
1374       setOperationAction(ISD::CTLZ,             MVT::v16i32, Legal);
1375     }
1376
1377     // Custom lower several nodes.
1378     for (MVT VT : MVT::vector_valuetypes()) {
1379       unsigned EltSize = VT.getVectorElementType().getSizeInBits();
1380       // Extract subvector is special because the value type
1381       // (result) is 256/128-bit but the source is 512-bit wide.
1382       if (VT.is128BitVector() || VT.is256BitVector()) {
1383         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Custom);
1384       }
1385       if (VT.getVectorElementType() == MVT::i1)
1386         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Legal);
1387
1388       // Do not attempt to custom lower other non-512-bit vectors
1389       if (!VT.is512BitVector())
1390         continue;
1391
1392       if ( EltSize >= 32) {
1393         setOperationAction(ISD::VECTOR_SHUFFLE,      VT, Custom);
1394         setOperationAction(ISD::INSERT_VECTOR_ELT,   VT, Custom);
1395         setOperationAction(ISD::BUILD_VECTOR,        VT, Custom);
1396         setOperationAction(ISD::VSELECT,             VT, Legal);
1397         setOperationAction(ISD::EXTRACT_VECTOR_ELT,  VT, Custom);
1398         setOperationAction(ISD::SCALAR_TO_VECTOR,    VT, Custom);
1399         setOperationAction(ISD::INSERT_SUBVECTOR,    VT, Custom);
1400         setOperationAction(ISD::MLOAD,               VT, Legal);
1401         setOperationAction(ISD::MSTORE,              VT, Legal);
1402       }
1403     }
1404     for (int i = MVT::v32i8; i != MVT::v8i64; ++i) {
1405       MVT VT = (MVT::SimpleValueType)i;
1406
1407       // Do not attempt to promote non-512-bit vectors.
1408       if (!VT.is512BitVector())
1409         continue;
1410
1411       setOperationAction(ISD::SELECT, VT, Promote);
1412       AddPromotedToType (ISD::SELECT, VT, MVT::v8i64);
1413     }
1414   }// has  AVX-512
1415
1416   if (!TM.Options.UseSoftFloat && Subtarget->hasBWI()) {
1417     addRegisterClass(MVT::v32i16, &X86::VR512RegClass);
1418     addRegisterClass(MVT::v64i8,  &X86::VR512RegClass);
1419
1420     addRegisterClass(MVT::v32i1,  &X86::VK32RegClass);
1421     addRegisterClass(MVT::v64i1,  &X86::VK64RegClass);
1422
1423     setOperationAction(ISD::LOAD,               MVT::v32i16, Legal);
1424     setOperationAction(ISD::LOAD,               MVT::v64i8, Legal);
1425     setOperationAction(ISD::SETCC,              MVT::v32i1, Custom);
1426     setOperationAction(ISD::SETCC,              MVT::v64i1, Custom);
1427     setOperationAction(ISD::ADD,                MVT::v32i16, Legal);
1428     setOperationAction(ISD::ADD,                MVT::v64i8, Legal);
1429     setOperationAction(ISD::SUB,                MVT::v32i16, Legal);
1430     setOperationAction(ISD::SUB,                MVT::v64i8, Legal);
1431     setOperationAction(ISD::MUL,                MVT::v32i16, Legal);
1432     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v32i1, Custom);
1433     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v64i1, Custom);
1434     setOperationAction(ISD::INSERT_SUBVECTOR,   MVT::v32i1, Custom);
1435     setOperationAction(ISD::INSERT_SUBVECTOR,   MVT::v64i1, Custom);
1436
1437     for (int i = MVT::v32i8; i != MVT::v8i64; ++i) {
1438       const MVT VT = (MVT::SimpleValueType)i;
1439
1440       const unsigned EltSize = VT.getVectorElementType().getSizeInBits();
1441
1442       // Do not attempt to promote non-512-bit vectors.
1443       if (!VT.is512BitVector())
1444         continue;
1445
1446       if (EltSize < 32) {
1447         setOperationAction(ISD::BUILD_VECTOR,        VT, Custom);
1448         setOperationAction(ISD::VSELECT,             VT, Legal);
1449       }
1450     }
1451   }
1452
1453   if (!TM.Options.UseSoftFloat && Subtarget->hasVLX()) {
1454     addRegisterClass(MVT::v4i1,   &X86::VK4RegClass);
1455     addRegisterClass(MVT::v2i1,   &X86::VK2RegClass);
1456
1457     setOperationAction(ISD::SETCC,              MVT::v4i1, Custom);
1458     setOperationAction(ISD::SETCC,              MVT::v2i1, Custom);
1459     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v4i1, Custom);
1460     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i1, Custom);
1461     setOperationAction(ISD::INSERT_SUBVECTOR,   MVT::v8i1, Custom);
1462     setOperationAction(ISD::INSERT_SUBVECTOR,   MVT::v4i1, Custom);
1463
1464     setOperationAction(ISD::AND,                MVT::v8i32, Legal);
1465     setOperationAction(ISD::OR,                 MVT::v8i32, Legal);
1466     setOperationAction(ISD::XOR,                MVT::v8i32, Legal);
1467     setOperationAction(ISD::AND,                MVT::v4i32, Legal);
1468     setOperationAction(ISD::OR,                 MVT::v4i32, Legal);
1469     setOperationAction(ISD::XOR,                MVT::v4i32, Legal);
1470   }
1471
1472   // We want to custom lower some of our intrinsics.
1473   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
1474   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
1475   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
1476   if (!Subtarget->is64Bit())
1477     setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::i64, Custom);
1478
1479   // Only custom-lower 64-bit SADDO and friends on 64-bit because we don't
1480   // handle type legalization for these operations here.
1481   //
1482   // FIXME: We really should do custom legalization for addition and
1483   // subtraction on x86-32 once PR3203 is fixed.  We really can't do much better
1484   // than generic legalization for 64-bit multiplication-with-overflow, though.
1485   for (unsigned i = 0, e = 3+Subtarget->is64Bit(); i != e; ++i) {
1486     // Add/Sub/Mul with overflow operations are custom lowered.
1487     MVT VT = IntVTs[i];
1488     setOperationAction(ISD::SADDO, VT, Custom);
1489     setOperationAction(ISD::UADDO, VT, Custom);
1490     setOperationAction(ISD::SSUBO, VT, Custom);
1491     setOperationAction(ISD::USUBO, VT, Custom);
1492     setOperationAction(ISD::SMULO, VT, Custom);
1493     setOperationAction(ISD::UMULO, VT, Custom);
1494   }
1495
1496
1497   if (!Subtarget->is64Bit()) {
1498     // These libcalls are not available in 32-bit.
1499     setLibcallName(RTLIB::SHL_I128, nullptr);
1500     setLibcallName(RTLIB::SRL_I128, nullptr);
1501     setLibcallName(RTLIB::SRA_I128, nullptr);
1502   }
1503
1504   // Combine sin / cos into one node or libcall if possible.
1505   if (Subtarget->hasSinCos()) {
1506     setLibcallName(RTLIB::SINCOS_F32, "sincosf");
1507     setLibcallName(RTLIB::SINCOS_F64, "sincos");
1508     if (Subtarget->isTargetDarwin()) {
1509       // For MacOSX, we don't want the normal expansion of a libcall to sincos.
1510       // We want to issue a libcall to __sincos_stret to avoid memory traffic.
1511       setOperationAction(ISD::FSINCOS, MVT::f64, Custom);
1512       setOperationAction(ISD::FSINCOS, MVT::f32, Custom);
1513     }
1514   }
1515
1516   if (Subtarget->isTargetWin64()) {
1517     setOperationAction(ISD::SDIV, MVT::i128, Custom);
1518     setOperationAction(ISD::UDIV, MVT::i128, Custom);
1519     setOperationAction(ISD::SREM, MVT::i128, Custom);
1520     setOperationAction(ISD::UREM, MVT::i128, Custom);
1521     setOperationAction(ISD::SDIVREM, MVT::i128, Custom);
1522     setOperationAction(ISD::UDIVREM, MVT::i128, Custom);
1523   }
1524
1525   // We have target-specific dag combine patterns for the following nodes:
1526   setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
1527   setTargetDAGCombine(ISD::EXTRACT_VECTOR_ELT);
1528   setTargetDAGCombine(ISD::BITCAST);
1529   setTargetDAGCombine(ISD::VSELECT);
1530   setTargetDAGCombine(ISD::SELECT);
1531   setTargetDAGCombine(ISD::SHL);
1532   setTargetDAGCombine(ISD::SRA);
1533   setTargetDAGCombine(ISD::SRL);
1534   setTargetDAGCombine(ISD::OR);
1535   setTargetDAGCombine(ISD::AND);
1536   setTargetDAGCombine(ISD::ADD);
1537   setTargetDAGCombine(ISD::FADD);
1538   setTargetDAGCombine(ISD::FSUB);
1539   setTargetDAGCombine(ISD::FMA);
1540   setTargetDAGCombine(ISD::SUB);
1541   setTargetDAGCombine(ISD::LOAD);
1542   setTargetDAGCombine(ISD::MLOAD);
1543   setTargetDAGCombine(ISD::STORE);
1544   setTargetDAGCombine(ISD::MSTORE);
1545   setTargetDAGCombine(ISD::ZERO_EXTEND);
1546   setTargetDAGCombine(ISD::ANY_EXTEND);
1547   setTargetDAGCombine(ISD::SIGN_EXTEND);
1548   setTargetDAGCombine(ISD::SIGN_EXTEND_INREG);
1549   setTargetDAGCombine(ISD::TRUNCATE);
1550   setTargetDAGCombine(ISD::SINT_TO_FP);
1551   setTargetDAGCombine(ISD::SETCC);
1552   setTargetDAGCombine(ISD::INTRINSIC_WO_CHAIN);
1553   setTargetDAGCombine(ISD::BUILD_VECTOR);
1554   setTargetDAGCombine(ISD::MUL);
1555   setTargetDAGCombine(ISD::XOR);
1556
1557   computeRegisterProperties(Subtarget->getRegisterInfo());
1558
1559   // On Darwin, -Os means optimize for size without hurting performance,
1560   // do not reduce the limit.
1561   MaxStoresPerMemset = 16; // For @llvm.memset -> sequence of stores
1562   MaxStoresPerMemsetOptSize = Subtarget->isTargetDarwin() ? 16 : 8;
1563   MaxStoresPerMemcpy = 8; // For @llvm.memcpy -> sequence of stores
1564   MaxStoresPerMemcpyOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1565   MaxStoresPerMemmove = 8; // For @llvm.memmove -> sequence of stores
1566   MaxStoresPerMemmoveOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1567   setPrefLoopAlignment(4); // 2^4 bytes.
1568
1569   // Predictable cmov don't hurt on atom because it's in-order.
1570   PredictableSelectIsExpensive = !Subtarget->isAtom();
1571   EnableExtLdPromotion = true;
1572   setPrefFunctionAlignment(4); // 2^4 bytes.
1573
1574   verifyIntrinsicTables();
1575 }
1576
1577 // This has so far only been implemented for 64-bit MachO.
1578 bool X86TargetLowering::useLoadStackGuardNode() const {
1579   return Subtarget->isTargetMachO() && Subtarget->is64Bit();
1580 }
1581
1582 TargetLoweringBase::LegalizeTypeAction
1583 X86TargetLowering::getPreferredVectorAction(EVT VT) const {
1584   if (ExperimentalVectorWideningLegalization &&
1585       VT.getVectorNumElements() != 1 &&
1586       VT.getVectorElementType().getSimpleVT() != MVT::i1)
1587     return TypeWidenVector;
1588
1589   return TargetLoweringBase::getPreferredVectorAction(VT);
1590 }
1591
1592 EVT X86TargetLowering::getSetCCResultType(LLVMContext &, EVT VT) const {
1593   if (!VT.isVector())
1594     return Subtarget->hasAVX512() ? MVT::i1: MVT::i8;
1595
1596   const unsigned NumElts = VT.getVectorNumElements();
1597   const EVT EltVT = VT.getVectorElementType();
1598   if (VT.is512BitVector()) {
1599     if (Subtarget->hasAVX512())
1600       if (EltVT == MVT::i32 || EltVT == MVT::i64 ||
1601           EltVT == MVT::f32 || EltVT == MVT::f64)
1602         switch(NumElts) {
1603         case  8: return MVT::v8i1;
1604         case 16: return MVT::v16i1;
1605       }
1606     if (Subtarget->hasBWI())
1607       if (EltVT == MVT::i8 || EltVT == MVT::i16)
1608         switch(NumElts) {
1609         case 32: return MVT::v32i1;
1610         case 64: return MVT::v64i1;
1611       }
1612   }
1613
1614   if (VT.is256BitVector() || VT.is128BitVector()) {
1615     if (Subtarget->hasVLX())
1616       if (EltVT == MVT::i32 || EltVT == MVT::i64 ||
1617           EltVT == MVT::f32 || EltVT == MVT::f64)
1618         switch(NumElts) {
1619         case 2: return MVT::v2i1;
1620         case 4: return MVT::v4i1;
1621         case 8: return MVT::v8i1;
1622       }
1623     if (Subtarget->hasBWI() && Subtarget->hasVLX())
1624       if (EltVT == MVT::i8 || EltVT == MVT::i16)
1625         switch(NumElts) {
1626         case  8: return MVT::v8i1;
1627         case 16: return MVT::v16i1;
1628         case 32: return MVT::v32i1;
1629       }
1630   }
1631
1632   return VT.changeVectorElementTypeToInteger();
1633 }
1634
1635 /// Helper for getByValTypeAlignment to determine
1636 /// the desired ByVal argument alignment.
1637 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign) {
1638   if (MaxAlign == 16)
1639     return;
1640   if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
1641     if (VTy->getBitWidth() == 128)
1642       MaxAlign = 16;
1643   } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
1644     unsigned EltAlign = 0;
1645     getMaxByValAlign(ATy->getElementType(), EltAlign);
1646     if (EltAlign > MaxAlign)
1647       MaxAlign = EltAlign;
1648   } else if (StructType *STy = dyn_cast<StructType>(Ty)) {
1649     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1650       unsigned EltAlign = 0;
1651       getMaxByValAlign(STy->getElementType(i), EltAlign);
1652       if (EltAlign > MaxAlign)
1653         MaxAlign = EltAlign;
1654       if (MaxAlign == 16)
1655         break;
1656     }
1657   }
1658 }
1659
1660 /// Return the desired alignment for ByVal aggregate
1661 /// function arguments in the caller parameter area. For X86, aggregates
1662 /// that contain SSE vectors are placed at 16-byte boundaries while the rest
1663 /// are at 4-byte boundaries.
1664 unsigned X86TargetLowering::getByValTypeAlignment(Type *Ty) const {
1665   if (Subtarget->is64Bit()) {
1666     // Max of 8 and alignment of type.
1667     unsigned TyAlign = TD->getABITypeAlignment(Ty);
1668     if (TyAlign > 8)
1669       return TyAlign;
1670     return 8;
1671   }
1672
1673   unsigned Align = 4;
1674   if (Subtarget->hasSSE1())
1675     getMaxByValAlign(Ty, Align);
1676   return Align;
1677 }
1678
1679 /// Returns the target specific optimal type for load
1680 /// and store operations as a result of memset, memcpy, and memmove
1681 /// lowering. If DstAlign is zero that means it's safe to destination
1682 /// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
1683 /// means there isn't a need to check it against alignment requirement,
1684 /// probably because the source does not need to be loaded. If 'IsMemset' is
1685 /// true, that means it's expanding a memset. If 'ZeroMemset' is true, that
1686 /// means it's a memset of zero. 'MemcpyStrSrc' indicates whether the memcpy
1687 /// source is constant so it does not need to be loaded.
1688 /// It returns EVT::Other if the type should be determined using generic
1689 /// target-independent logic.
1690 EVT
1691 X86TargetLowering::getOptimalMemOpType(uint64_t Size,
1692                                        unsigned DstAlign, unsigned SrcAlign,
1693                                        bool IsMemset, bool ZeroMemset,
1694                                        bool MemcpyStrSrc,
1695                                        MachineFunction &MF) const {
1696   const Function *F = MF.getFunction();
1697   if ((!IsMemset || ZeroMemset) &&
1698       !F->hasFnAttribute(Attribute::NoImplicitFloat)) {
1699     if (Size >= 16 &&
1700         (Subtarget->isUnalignedMemAccessFast() ||
1701          ((DstAlign == 0 || DstAlign >= 16) &&
1702           (SrcAlign == 0 || SrcAlign >= 16)))) {
1703       if (Size >= 32) {
1704         if (Subtarget->hasInt256())
1705           return MVT::v8i32;
1706         if (Subtarget->hasFp256())
1707           return MVT::v8f32;
1708       }
1709       if (Subtarget->hasSSE2())
1710         return MVT::v4i32;
1711       if (Subtarget->hasSSE1())
1712         return MVT::v4f32;
1713     } else if (!MemcpyStrSrc && Size >= 8 &&
1714                !Subtarget->is64Bit() &&
1715                Subtarget->hasSSE2()) {
1716       // Do not use f64 to lower memcpy if source is string constant. It's
1717       // better to use i32 to avoid the loads.
1718       return MVT::f64;
1719     }
1720   }
1721   if (Subtarget->is64Bit() && Size >= 8)
1722     return MVT::i64;
1723   return MVT::i32;
1724 }
1725
1726 bool X86TargetLowering::isSafeMemOpType(MVT VT) const {
1727   if (VT == MVT::f32)
1728     return X86ScalarSSEf32;
1729   else if (VT == MVT::f64)
1730     return X86ScalarSSEf64;
1731   return true;
1732 }
1733
1734 bool
1735 X86TargetLowering::allowsMisalignedMemoryAccesses(EVT VT,
1736                                                   unsigned,
1737                                                   unsigned,
1738                                                   bool *Fast) const {
1739   if (Fast)
1740     *Fast = Subtarget->isUnalignedMemAccessFast();
1741   return true;
1742 }
1743
1744 /// Return the entry encoding for a jump table in the
1745 /// current function.  The returned value is a member of the
1746 /// MachineJumpTableInfo::JTEntryKind enum.
1747 unsigned X86TargetLowering::getJumpTableEncoding() const {
1748   // In GOT pic mode, each entry in the jump table is emitted as a @GOTOFF
1749   // symbol.
1750   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1751       Subtarget->isPICStyleGOT())
1752     return MachineJumpTableInfo::EK_Custom32;
1753
1754   // Otherwise, use the normal jump table encoding heuristics.
1755   return TargetLowering::getJumpTableEncoding();
1756 }
1757
1758 const MCExpr *
1759 X86TargetLowering::LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
1760                                              const MachineBasicBlock *MBB,
1761                                              unsigned uid,MCContext &Ctx) const{
1762   assert(MBB->getParent()->getTarget().getRelocationModel() == Reloc::PIC_ &&
1763          Subtarget->isPICStyleGOT());
1764   // In 32-bit ELF systems, our jump table entries are formed with @GOTOFF
1765   // entries.
1766   return MCSymbolRefExpr::Create(MBB->getSymbol(),
1767                                  MCSymbolRefExpr::VK_GOTOFF, Ctx);
1768 }
1769
1770 /// Returns relocation base for the given PIC jumptable.
1771 SDValue X86TargetLowering::getPICJumpTableRelocBase(SDValue Table,
1772                                                     SelectionDAG &DAG) const {
1773   if (!Subtarget->is64Bit())
1774     // This doesn't have SDLoc associated with it, but is not really the
1775     // same as a Register.
1776     return DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy());
1777   return Table;
1778 }
1779
1780 /// This returns the relocation base for the given PIC jumptable,
1781 /// the same as getPICJumpTableRelocBase, but as an MCExpr.
1782 const MCExpr *X86TargetLowering::
1783 getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI,
1784                              MCContext &Ctx) const {
1785   // X86-64 uses RIP relative addressing based on the jump table label.
1786   if (Subtarget->isPICStyleRIPRel())
1787     return TargetLowering::getPICJumpTableRelocBaseExpr(MF, JTI, Ctx);
1788
1789   // Otherwise, the reference is relative to the PIC base.
1790   return MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx);
1791 }
1792
1793 std::pair<const TargetRegisterClass *, uint8_t>
1794 X86TargetLowering::findRepresentativeClass(const TargetRegisterInfo *TRI,
1795                                            MVT VT) const {
1796   const TargetRegisterClass *RRC = nullptr;
1797   uint8_t Cost = 1;
1798   switch (VT.SimpleTy) {
1799   default:
1800     return TargetLowering::findRepresentativeClass(TRI, VT);
1801   case MVT::i8: case MVT::i16: case MVT::i32: case MVT::i64:
1802     RRC = Subtarget->is64Bit() ? &X86::GR64RegClass : &X86::GR32RegClass;
1803     break;
1804   case MVT::x86mmx:
1805     RRC = &X86::VR64RegClass;
1806     break;
1807   case MVT::f32: case MVT::f64:
1808   case MVT::v16i8: case MVT::v8i16: case MVT::v4i32: case MVT::v2i64:
1809   case MVT::v4f32: case MVT::v2f64:
1810   case MVT::v32i8: case MVT::v8i32: case MVT::v4i64: case MVT::v8f32:
1811   case MVT::v4f64:
1812     RRC = &X86::VR128RegClass;
1813     break;
1814   }
1815   return std::make_pair(RRC, Cost);
1816 }
1817
1818 bool X86TargetLowering::getStackCookieLocation(unsigned &AddressSpace,
1819                                                unsigned &Offset) const {
1820   if (!Subtarget->isTargetLinux())
1821     return false;
1822
1823   if (Subtarget->is64Bit()) {
1824     // %fs:0x28, unless we're using a Kernel code model, in which case it's %gs:
1825     Offset = 0x28;
1826     if (getTargetMachine().getCodeModel() == CodeModel::Kernel)
1827       AddressSpace = 256;
1828     else
1829       AddressSpace = 257;
1830   } else {
1831     // %gs:0x14 on i386
1832     Offset = 0x14;
1833     AddressSpace = 256;
1834   }
1835   return true;
1836 }
1837
1838 bool X86TargetLowering::isNoopAddrSpaceCast(unsigned SrcAS,
1839                                             unsigned DestAS) const {
1840   assert(SrcAS != DestAS && "Expected different address spaces!");
1841
1842   return SrcAS < 256 && DestAS < 256;
1843 }
1844
1845 //===----------------------------------------------------------------------===//
1846 //               Return Value Calling Convention Implementation
1847 //===----------------------------------------------------------------------===//
1848
1849 #include "X86GenCallingConv.inc"
1850
1851 bool
1852 X86TargetLowering::CanLowerReturn(CallingConv::ID CallConv,
1853                                   MachineFunction &MF, bool isVarArg,
1854                         const SmallVectorImpl<ISD::OutputArg> &Outs,
1855                         LLVMContext &Context) const {
1856   SmallVector<CCValAssign, 16> RVLocs;
1857   CCState CCInfo(CallConv, isVarArg, MF, RVLocs, Context);
1858   return CCInfo.CheckReturn(Outs, RetCC_X86);
1859 }
1860
1861 const MCPhysReg *X86TargetLowering::getScratchRegisters(CallingConv::ID) const {
1862   static const MCPhysReg ScratchRegs[] = { X86::R11, 0 };
1863   return ScratchRegs;
1864 }
1865
1866 SDValue
1867 X86TargetLowering::LowerReturn(SDValue Chain,
1868                                CallingConv::ID CallConv, bool isVarArg,
1869                                const SmallVectorImpl<ISD::OutputArg> &Outs,
1870                                const SmallVectorImpl<SDValue> &OutVals,
1871                                SDLoc dl, SelectionDAG &DAG) const {
1872   MachineFunction &MF = DAG.getMachineFunction();
1873   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1874
1875   SmallVector<CCValAssign, 16> RVLocs;
1876   CCState CCInfo(CallConv, isVarArg, MF, RVLocs, *DAG.getContext());
1877   CCInfo.AnalyzeReturn(Outs, RetCC_X86);
1878
1879   SDValue Flag;
1880   SmallVector<SDValue, 6> RetOps;
1881   RetOps.push_back(Chain); // Operand #0 = Chain (updated below)
1882   // Operand #1 = Bytes To Pop
1883   RetOps.push_back(DAG.getTargetConstant(FuncInfo->getBytesToPopOnReturn(),
1884                    MVT::i16));
1885
1886   // Copy the result values into the output registers.
1887   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1888     CCValAssign &VA = RVLocs[i];
1889     assert(VA.isRegLoc() && "Can only return in registers!");
1890     SDValue ValToCopy = OutVals[i];
1891     EVT ValVT = ValToCopy.getValueType();
1892
1893     // Promote values to the appropriate types.
1894     if (VA.getLocInfo() == CCValAssign::SExt)
1895       ValToCopy = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), ValToCopy);
1896     else if (VA.getLocInfo() == CCValAssign::ZExt)
1897       ValToCopy = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), ValToCopy);
1898     else if (VA.getLocInfo() == CCValAssign::AExt)
1899       ValToCopy = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), ValToCopy);
1900     else if (VA.getLocInfo() == CCValAssign::BCvt)
1901       ValToCopy = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), ValToCopy);
1902
1903     assert(VA.getLocInfo() != CCValAssign::FPExt &&
1904            "Unexpected FP-extend for return value.");
1905
1906     // If this is x86-64, and we disabled SSE, we can't return FP values,
1907     // or SSE or MMX vectors.
1908     if ((ValVT == MVT::f32 || ValVT == MVT::f64 ||
1909          VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) &&
1910           (Subtarget->is64Bit() && !Subtarget->hasSSE1())) {
1911       report_fatal_error("SSE register return with SSE disabled");
1912     }
1913     // Likewise we can't return F64 values with SSE1 only.  gcc does so, but
1914     // llvm-gcc has never done it right and no one has noticed, so this
1915     // should be OK for now.
1916     if (ValVT == MVT::f64 &&
1917         (Subtarget->is64Bit() && !Subtarget->hasSSE2()))
1918       report_fatal_error("SSE2 register return with SSE2 disabled");
1919
1920     // Returns in ST0/ST1 are handled specially: these are pushed as operands to
1921     // the RET instruction and handled by the FP Stackifier.
1922     if (VA.getLocReg() == X86::FP0 ||
1923         VA.getLocReg() == X86::FP1) {
1924       // If this is a copy from an xmm register to ST(0), use an FPExtend to
1925       // change the value to the FP stack register class.
1926       if (isScalarFPTypeInSSEReg(VA.getValVT()))
1927         ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
1928       RetOps.push_back(ValToCopy);
1929       // Don't emit a copytoreg.
1930       continue;
1931     }
1932
1933     // 64-bit vector (MMX) values are returned in XMM0 / XMM1 except for v1i64
1934     // which is returned in RAX / RDX.
1935     if (Subtarget->is64Bit()) {
1936       if (ValVT == MVT::x86mmx) {
1937         if (VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) {
1938           ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ValToCopy);
1939           ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
1940                                   ValToCopy);
1941           // If we don't have SSE2 available, convert to v4f32 so the generated
1942           // register is legal.
1943           if (!Subtarget->hasSSE2())
1944             ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32,ValToCopy);
1945         }
1946       }
1947     }
1948
1949     Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), ValToCopy, Flag);
1950     Flag = Chain.getValue(1);
1951     RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
1952   }
1953
1954   // The x86-64 ABIs require that for returning structs by value we copy
1955   // the sret argument into %rax/%eax (depending on ABI) for the return.
1956   // Win32 requires us to put the sret argument to %eax as well.
1957   // We saved the argument into a virtual register in the entry block,
1958   // so now we copy the value out and into %rax/%eax.
1959   //
1960   // Checking Function.hasStructRetAttr() here is insufficient because the IR
1961   // may not have an explicit sret argument. If FuncInfo.CanLowerReturn is
1962   // false, then an sret argument may be implicitly inserted in the SelDAG. In
1963   // either case FuncInfo->setSRetReturnReg() will have been called.
1964   if (unsigned SRetReg = FuncInfo->getSRetReturnReg()) {
1965     assert((Subtarget->is64Bit() || Subtarget->isTargetKnownWindowsMSVC()) &&
1966            "No need for an sret register");
1967     SDValue Val = DAG.getCopyFromReg(Chain, dl, SRetReg, getPointerTy());
1968
1969     unsigned RetValReg
1970         = (Subtarget->is64Bit() && !Subtarget->isTarget64BitILP32()) ?
1971           X86::RAX : X86::EAX;
1972     Chain = DAG.getCopyToReg(Chain, dl, RetValReg, Val, Flag);
1973     Flag = Chain.getValue(1);
1974
1975     // RAX/EAX now acts like a return value.
1976     RetOps.push_back(DAG.getRegister(RetValReg, getPointerTy()));
1977   }
1978
1979   RetOps[0] = Chain;  // Update chain.
1980
1981   // Add the flag if we have it.
1982   if (Flag.getNode())
1983     RetOps.push_back(Flag);
1984
1985   return DAG.getNode(X86ISD::RET_FLAG, dl, MVT::Other, RetOps);
1986 }
1987
1988 bool X86TargetLowering::isUsedByReturnOnly(SDNode *N, SDValue &Chain) const {
1989   if (N->getNumValues() != 1)
1990     return false;
1991   if (!N->hasNUsesOfValue(1, 0))
1992     return false;
1993
1994   SDValue TCChain = Chain;
1995   SDNode *Copy = *N->use_begin();
1996   if (Copy->getOpcode() == ISD::CopyToReg) {
1997     // If the copy has a glue operand, we conservatively assume it isn't safe to
1998     // perform a tail call.
1999     if (Copy->getOperand(Copy->getNumOperands()-1).getValueType() == MVT::Glue)
2000       return false;
2001     TCChain = Copy->getOperand(0);
2002   } else if (Copy->getOpcode() != ISD::FP_EXTEND)
2003     return false;
2004
2005   bool HasRet = false;
2006   for (SDNode::use_iterator UI = Copy->use_begin(), UE = Copy->use_end();
2007        UI != UE; ++UI) {
2008     if (UI->getOpcode() != X86ISD::RET_FLAG)
2009       return false;
2010     // If we are returning more than one value, we can definitely
2011     // not make a tail call see PR19530
2012     if (UI->getNumOperands() > 4)
2013       return false;
2014     if (UI->getNumOperands() == 4 &&
2015         UI->getOperand(UI->getNumOperands()-1).getValueType() != MVT::Glue)
2016       return false;
2017     HasRet = true;
2018   }
2019
2020   if (!HasRet)
2021     return false;
2022
2023   Chain = TCChain;
2024   return true;
2025 }
2026
2027 EVT
2028 X86TargetLowering::getTypeForExtArgOrReturn(LLVMContext &Context, EVT VT,
2029                                             ISD::NodeType ExtendKind) const {
2030   MVT ReturnMVT;
2031   // TODO: Is this also valid on 32-bit?
2032   if (Subtarget->is64Bit() && VT == MVT::i1 && ExtendKind == ISD::ZERO_EXTEND)
2033     ReturnMVT = MVT::i8;
2034   else
2035     ReturnMVT = MVT::i32;
2036
2037   EVT MinVT = getRegisterType(Context, ReturnMVT);
2038   return VT.bitsLT(MinVT) ? MinVT : VT;
2039 }
2040
2041 /// Lower the result values of a call into the
2042 /// appropriate copies out of appropriate physical registers.
2043 ///
2044 SDValue
2045 X86TargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
2046                                    CallingConv::ID CallConv, bool isVarArg,
2047                                    const SmallVectorImpl<ISD::InputArg> &Ins,
2048                                    SDLoc dl, SelectionDAG &DAG,
2049                                    SmallVectorImpl<SDValue> &InVals) const {
2050
2051   // Assign locations to each value returned by this call.
2052   SmallVector<CCValAssign, 16> RVLocs;
2053   bool Is64Bit = Subtarget->is64Bit();
2054   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
2055                  *DAG.getContext());
2056   CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
2057
2058   // Copy all of the result registers out of their specified physreg.
2059   for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
2060     CCValAssign &VA = RVLocs[i];
2061     EVT CopyVT = VA.getValVT();
2062
2063     // If this is x86-64, and we disabled SSE, we can't return FP values
2064     if ((CopyVT == MVT::f32 || CopyVT == MVT::f64) &&
2065         ((Is64Bit || Ins[i].Flags.isInReg()) && !Subtarget->hasSSE1())) {
2066       report_fatal_error("SSE register return with SSE disabled");
2067     }
2068
2069     // If we prefer to use the value in xmm registers, copy it out as f80 and
2070     // use a truncate to move it from fp stack reg to xmm reg.
2071     if ((VA.getLocReg() == X86::FP0 || VA.getLocReg() == X86::FP1) &&
2072         isScalarFPTypeInSSEReg(VA.getValVT()))
2073       CopyVT = MVT::f80;
2074
2075     Chain = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(),
2076                                CopyVT, InFlag).getValue(1);
2077     SDValue Val = Chain.getValue(0);
2078
2079     if (CopyVT != VA.getValVT())
2080       Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
2081                         // This truncation won't change the value.
2082                         DAG.getIntPtrConstant(1));
2083
2084     InFlag = Chain.getValue(2);
2085     InVals.push_back(Val);
2086   }
2087
2088   return Chain;
2089 }
2090
2091 //===----------------------------------------------------------------------===//
2092 //                C & StdCall & Fast Calling Convention implementation
2093 //===----------------------------------------------------------------------===//
2094 //  StdCall calling convention seems to be standard for many Windows' API
2095 //  routines and around. It differs from C calling convention just a little:
2096 //  callee should clean up the stack, not caller. Symbols should be also
2097 //  decorated in some fancy way :) It doesn't support any vector arguments.
2098 //  For info on fast calling convention see Fast Calling Convention (tail call)
2099 //  implementation LowerX86_32FastCCCallTo.
2100
2101 /// CallIsStructReturn - Determines whether a call uses struct return
2102 /// semantics.
2103 enum StructReturnType {
2104   NotStructReturn,
2105   RegStructReturn,
2106   StackStructReturn
2107 };
2108 static StructReturnType
2109 callIsStructReturn(const SmallVectorImpl<ISD::OutputArg> &Outs) {
2110   if (Outs.empty())
2111     return NotStructReturn;
2112
2113   const ISD::ArgFlagsTy &Flags = Outs[0].Flags;
2114   if (!Flags.isSRet())
2115     return NotStructReturn;
2116   if (Flags.isInReg())
2117     return RegStructReturn;
2118   return StackStructReturn;
2119 }
2120
2121 /// Determines whether a function uses struct return semantics.
2122 static StructReturnType
2123 argsAreStructReturn(const SmallVectorImpl<ISD::InputArg> &Ins) {
2124   if (Ins.empty())
2125     return NotStructReturn;
2126
2127   const ISD::ArgFlagsTy &Flags = Ins[0].Flags;
2128   if (!Flags.isSRet())
2129     return NotStructReturn;
2130   if (Flags.isInReg())
2131     return RegStructReturn;
2132   return StackStructReturn;
2133 }
2134
2135 /// Make a copy of an aggregate at address specified by "Src" to address
2136 /// "Dst" with size and alignment information specified by the specific
2137 /// parameter attribute. The copy will be passed as a byval function parameter.
2138 static SDValue
2139 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
2140                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
2141                           SDLoc dl) {
2142   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
2143
2144   return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
2145                        /*isVolatile*/false, /*AlwaysInline=*/true,
2146                        MachinePointerInfo(), MachinePointerInfo());
2147 }
2148
2149 /// Return true if the calling convention is one that
2150 /// supports tail call optimization.
2151 static bool IsTailCallConvention(CallingConv::ID CC) {
2152   return (CC == CallingConv::Fast || CC == CallingConv::GHC ||
2153           CC == CallingConv::HiPE);
2154 }
2155
2156 /// \brief Return true if the calling convention is a C calling convention.
2157 static bool IsCCallConvention(CallingConv::ID CC) {
2158   return (CC == CallingConv::C || CC == CallingConv::X86_64_Win64 ||
2159           CC == CallingConv::X86_64_SysV);
2160 }
2161
2162 bool X86TargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
2163   if (!CI->isTailCall() || getTargetMachine().Options.DisableTailCalls)
2164     return false;
2165
2166   CallSite CS(CI);
2167   CallingConv::ID CalleeCC = CS.getCallingConv();
2168   if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
2169     return false;
2170
2171   return true;
2172 }
2173
2174 /// Return true if the function is being made into
2175 /// a tailcall target by changing its ABI.
2176 static bool FuncIsMadeTailCallSafe(CallingConv::ID CC,
2177                                    bool GuaranteedTailCallOpt) {
2178   return GuaranteedTailCallOpt && IsTailCallConvention(CC);
2179 }
2180
2181 SDValue
2182 X86TargetLowering::LowerMemArgument(SDValue Chain,
2183                                     CallingConv::ID CallConv,
2184                                     const SmallVectorImpl<ISD::InputArg> &Ins,
2185                                     SDLoc dl, SelectionDAG &DAG,
2186                                     const CCValAssign &VA,
2187                                     MachineFrameInfo *MFI,
2188                                     unsigned i) const {
2189   // Create the nodes corresponding to a load from this parameter slot.
2190   ISD::ArgFlagsTy Flags = Ins[i].Flags;
2191   bool AlwaysUseMutable = FuncIsMadeTailCallSafe(
2192       CallConv, DAG.getTarget().Options.GuaranteedTailCallOpt);
2193   bool isImmutable = !AlwaysUseMutable && !Flags.isByVal();
2194   EVT ValVT;
2195
2196   // If value is passed by pointer we have address passed instead of the value
2197   // itself.
2198   if (VA.getLocInfo() == CCValAssign::Indirect)
2199     ValVT = VA.getLocVT();
2200   else
2201     ValVT = VA.getValVT();
2202
2203   // FIXME: For now, all byval parameter objects are marked mutable. This can be
2204   // changed with more analysis.
2205   // In case of tail call optimization mark all arguments mutable. Since they
2206   // could be overwritten by lowering of arguments in case of a tail call.
2207   if (Flags.isByVal()) {
2208     unsigned Bytes = Flags.getByValSize();
2209     if (Bytes == 0) Bytes = 1; // Don't create zero-sized stack objects.
2210     int FI = MFI->CreateFixedObject(Bytes, VA.getLocMemOffset(), isImmutable);
2211     return DAG.getFrameIndex(FI, getPointerTy());
2212   } else {
2213     int FI = MFI->CreateFixedObject(ValVT.getSizeInBits()/8,
2214                                     VA.getLocMemOffset(), isImmutable);
2215     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2216     return DAG.getLoad(ValVT, dl, Chain, FIN,
2217                        MachinePointerInfo::getFixedStack(FI),
2218                        false, false, false, 0);
2219   }
2220 }
2221
2222 // FIXME: Get this from tablegen.
2223 static ArrayRef<MCPhysReg> get64BitArgumentGPRs(CallingConv::ID CallConv,
2224                                                 const X86Subtarget *Subtarget) {
2225   assert(Subtarget->is64Bit());
2226
2227   if (Subtarget->isCallingConvWin64(CallConv)) {
2228     static const MCPhysReg GPR64ArgRegsWin64[] = {
2229       X86::RCX, X86::RDX, X86::R8,  X86::R9
2230     };
2231     return makeArrayRef(std::begin(GPR64ArgRegsWin64), std::end(GPR64ArgRegsWin64));
2232   }
2233
2234   static const MCPhysReg GPR64ArgRegs64Bit[] = {
2235     X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
2236   };
2237   return makeArrayRef(std::begin(GPR64ArgRegs64Bit), std::end(GPR64ArgRegs64Bit));
2238 }
2239
2240 // FIXME: Get this from tablegen.
2241 static ArrayRef<MCPhysReg> get64BitArgumentXMMs(MachineFunction &MF,
2242                                                 CallingConv::ID CallConv,
2243                                                 const X86Subtarget *Subtarget) {
2244   assert(Subtarget->is64Bit());
2245   if (Subtarget->isCallingConvWin64(CallConv)) {
2246     // The XMM registers which might contain var arg parameters are shadowed
2247     // in their paired GPR.  So we only need to save the GPR to their home
2248     // slots.
2249     // TODO: __vectorcall will change this.
2250     return None;
2251   }
2252
2253   const Function *Fn = MF.getFunction();
2254   bool NoImplicitFloatOps = Fn->hasFnAttribute(Attribute::NoImplicitFloat);
2255   assert(!(MF.getTarget().Options.UseSoftFloat && NoImplicitFloatOps) &&
2256          "SSE register cannot be used when SSE is disabled!");
2257   if (MF.getTarget().Options.UseSoftFloat || NoImplicitFloatOps ||
2258       !Subtarget->hasSSE1())
2259     // Kernel mode asks for SSE to be disabled, so there are no XMM argument
2260     // registers.
2261     return None;
2262
2263   static const MCPhysReg XMMArgRegs64Bit[] = {
2264     X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
2265     X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
2266   };
2267   return makeArrayRef(std::begin(XMMArgRegs64Bit), std::end(XMMArgRegs64Bit));
2268 }
2269
2270 static bool isOutlinedHandler(const MachineFunction &MF) {
2271   const MachineModuleInfo &MMI = MF.getMMI();
2272   const Function *F = MF.getFunction();
2273   return MMI.getWinEHParent(F) != F;
2274 }
2275
2276 SDValue
2277 X86TargetLowering::LowerFormalArguments(SDValue Chain,
2278                                         CallingConv::ID CallConv,
2279                                         bool isVarArg,
2280                                       const SmallVectorImpl<ISD::InputArg> &Ins,
2281                                         SDLoc dl,
2282                                         SelectionDAG &DAG,
2283                                         SmallVectorImpl<SDValue> &InVals)
2284                                           const {
2285   MachineFunction &MF = DAG.getMachineFunction();
2286   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2287   const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
2288
2289   const Function* Fn = MF.getFunction();
2290   if (Fn->hasExternalLinkage() &&
2291       Subtarget->isTargetCygMing() &&
2292       Fn->getName() == "main")
2293     FuncInfo->setForceFramePointer(true);
2294
2295   MachineFrameInfo *MFI = MF.getFrameInfo();
2296   bool Is64Bit = Subtarget->is64Bit();
2297   bool IsWin64 = Subtarget->isCallingConvWin64(CallConv);
2298
2299   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2300          "Var args not supported with calling convention fastcc, ghc or hipe");
2301
2302   // Assign locations to all of the incoming arguments.
2303   SmallVector<CCValAssign, 16> ArgLocs;
2304   CCState CCInfo(CallConv, isVarArg, MF, ArgLocs, *DAG.getContext());
2305
2306   // Allocate shadow area for Win64
2307   if (IsWin64)
2308     CCInfo.AllocateStack(32, 8);
2309
2310   CCInfo.AnalyzeFormalArguments(Ins, CC_X86);
2311
2312   unsigned LastVal = ~0U;
2313   SDValue ArgValue;
2314   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2315     CCValAssign &VA = ArgLocs[i];
2316     // TODO: If an arg is passed in two places (e.g. reg and stack), skip later
2317     // places.
2318     assert(VA.getValNo() != LastVal &&
2319            "Don't support value assigned to multiple locs yet");
2320     (void)LastVal;
2321     LastVal = VA.getValNo();
2322
2323     if (VA.isRegLoc()) {
2324       EVT RegVT = VA.getLocVT();
2325       const TargetRegisterClass *RC;
2326       if (RegVT == MVT::i32)
2327         RC = &X86::GR32RegClass;
2328       else if (Is64Bit && RegVT == MVT::i64)
2329         RC = &X86::GR64RegClass;
2330       else if (RegVT == MVT::f32)
2331         RC = &X86::FR32RegClass;
2332       else if (RegVT == MVT::f64)
2333         RC = &X86::FR64RegClass;
2334       else if (RegVT.is512BitVector())
2335         RC = &X86::VR512RegClass;
2336       else if (RegVT.is256BitVector())
2337         RC = &X86::VR256RegClass;
2338       else if (RegVT.is128BitVector())
2339         RC = &X86::VR128RegClass;
2340       else if (RegVT == MVT::x86mmx)
2341         RC = &X86::VR64RegClass;
2342       else if (RegVT == MVT::i1)
2343         RC = &X86::VK1RegClass;
2344       else if (RegVT == MVT::v8i1)
2345         RC = &X86::VK8RegClass;
2346       else if (RegVT == MVT::v16i1)
2347         RC = &X86::VK16RegClass;
2348       else if (RegVT == MVT::v32i1)
2349         RC = &X86::VK32RegClass;
2350       else if (RegVT == MVT::v64i1)
2351         RC = &X86::VK64RegClass;
2352       else
2353         llvm_unreachable("Unknown argument type!");
2354
2355       unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
2356       ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
2357
2358       // If this is an 8 or 16-bit value, it is really passed promoted to 32
2359       // bits.  Insert an assert[sz]ext to capture this, then truncate to the
2360       // right size.
2361       if (VA.getLocInfo() == CCValAssign::SExt)
2362         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
2363                                DAG.getValueType(VA.getValVT()));
2364       else if (VA.getLocInfo() == CCValAssign::ZExt)
2365         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
2366                                DAG.getValueType(VA.getValVT()));
2367       else if (VA.getLocInfo() == CCValAssign::BCvt)
2368         ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
2369
2370       if (VA.isExtInLoc()) {
2371         // Handle MMX values passed in XMM regs.
2372         if (RegVT.isVector())
2373           ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(), ArgValue);
2374         else
2375           ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
2376       }
2377     } else {
2378       assert(VA.isMemLoc());
2379       ArgValue = LowerMemArgument(Chain, CallConv, Ins, dl, DAG, VA, MFI, i);
2380     }
2381
2382     // If value is passed via pointer - do a load.
2383     if (VA.getLocInfo() == CCValAssign::Indirect)
2384       ArgValue = DAG.getLoad(VA.getValVT(), dl, Chain, ArgValue,
2385                              MachinePointerInfo(), false, false, false, 0);
2386
2387     InVals.push_back(ArgValue);
2388   }
2389
2390   if (Subtarget->is64Bit() || Subtarget->isTargetKnownWindowsMSVC()) {
2391     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2392       // The x86-64 ABIs require that for returning structs by value we copy
2393       // the sret argument into %rax/%eax (depending on ABI) for the return.
2394       // Win32 requires us to put the sret argument to %eax as well.
2395       // Save the argument into a virtual register so that we can access it
2396       // from the return points.
2397       if (Ins[i].Flags.isSRet()) {
2398         unsigned Reg = FuncInfo->getSRetReturnReg();
2399         if (!Reg) {
2400           MVT PtrTy = getPointerTy();
2401           Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(PtrTy));
2402           FuncInfo->setSRetReturnReg(Reg);
2403         }
2404         SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[i]);
2405         Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
2406         break;
2407       }
2408     }
2409   }
2410
2411   unsigned StackSize = CCInfo.getNextStackOffset();
2412   // Align stack specially for tail calls.
2413   if (FuncIsMadeTailCallSafe(CallConv,
2414                              MF.getTarget().Options.GuaranteedTailCallOpt))
2415     StackSize = GetAlignedArgumentStackSize(StackSize, DAG);
2416
2417   // If the function takes variable number of arguments, make a frame index for
2418   // the start of the first vararg value... for expansion of llvm.va_start. We
2419   // can skip this if there are no va_start calls.
2420   if (MFI->hasVAStart() &&
2421       (Is64Bit || (CallConv != CallingConv::X86_FastCall &&
2422                    CallConv != CallingConv::X86_ThisCall))) {
2423     FuncInfo->setVarArgsFrameIndex(
2424         MFI->CreateFixedObject(1, StackSize, true));
2425   }
2426
2427   // Figure out if XMM registers are in use.
2428   assert(!(MF.getTarget().Options.UseSoftFloat &&
2429            Fn->hasFnAttribute(Attribute::NoImplicitFloat)) &&
2430          "SSE register cannot be used when SSE is disabled!");
2431
2432   // 64-bit calling conventions support varargs and register parameters, so we
2433   // have to do extra work to spill them in the prologue.
2434   if (Is64Bit && isVarArg && MFI->hasVAStart()) {
2435     // Find the first unallocated argument registers.
2436     ArrayRef<MCPhysReg> ArgGPRs = get64BitArgumentGPRs(CallConv, Subtarget);
2437     ArrayRef<MCPhysReg> ArgXMMs = get64BitArgumentXMMs(MF, CallConv, Subtarget);
2438     unsigned NumIntRegs = CCInfo.getFirstUnallocated(ArgGPRs);
2439     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(ArgXMMs);
2440     assert(!(NumXMMRegs && !Subtarget->hasSSE1()) &&
2441            "SSE register cannot be used when SSE is disabled!");
2442
2443     // Gather all the live in physical registers.
2444     SmallVector<SDValue, 6> LiveGPRs;
2445     SmallVector<SDValue, 8> LiveXMMRegs;
2446     SDValue ALVal;
2447     for (MCPhysReg Reg : ArgGPRs.slice(NumIntRegs)) {
2448       unsigned GPR = MF.addLiveIn(Reg, &X86::GR64RegClass);
2449       LiveGPRs.push_back(
2450           DAG.getCopyFromReg(Chain, dl, GPR, MVT::i64));
2451     }
2452     if (!ArgXMMs.empty()) {
2453       unsigned AL = MF.addLiveIn(X86::AL, &X86::GR8RegClass);
2454       ALVal = DAG.getCopyFromReg(Chain, dl, AL, MVT::i8);
2455       for (MCPhysReg Reg : ArgXMMs.slice(NumXMMRegs)) {
2456         unsigned XMMReg = MF.addLiveIn(Reg, &X86::VR128RegClass);
2457         LiveXMMRegs.push_back(
2458             DAG.getCopyFromReg(Chain, dl, XMMReg, MVT::v4f32));
2459       }
2460     }
2461
2462     if (IsWin64) {
2463       // Get to the caller-allocated home save location.  Add 8 to account
2464       // for the return address.
2465       int HomeOffset = TFI.getOffsetOfLocalArea() + 8;
2466       FuncInfo->setRegSaveFrameIndex(
2467           MFI->CreateFixedObject(1, NumIntRegs * 8 + HomeOffset, false));
2468       // Fixup to set vararg frame on shadow area (4 x i64).
2469       if (NumIntRegs < 4)
2470         FuncInfo->setVarArgsFrameIndex(FuncInfo->getRegSaveFrameIndex());
2471     } else {
2472       // For X86-64, if there are vararg parameters that are passed via
2473       // registers, then we must store them to their spots on the stack so
2474       // they may be loaded by deferencing the result of va_next.
2475       FuncInfo->setVarArgsGPOffset(NumIntRegs * 8);
2476       FuncInfo->setVarArgsFPOffset(ArgGPRs.size() * 8 + NumXMMRegs * 16);
2477       FuncInfo->setRegSaveFrameIndex(MFI->CreateStackObject(
2478           ArgGPRs.size() * 8 + ArgXMMs.size() * 16, 16, false));
2479     }
2480
2481     // Store the integer parameter registers.
2482     SmallVector<SDValue, 8> MemOps;
2483     SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
2484                                       getPointerTy());
2485     unsigned Offset = FuncInfo->getVarArgsGPOffset();
2486     for (SDValue Val : LiveGPRs) {
2487       SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), RSFIN,
2488                                 DAG.getIntPtrConstant(Offset));
2489       SDValue Store =
2490         DAG.getStore(Val.getValue(1), dl, Val, FIN,
2491                      MachinePointerInfo::getFixedStack(
2492                        FuncInfo->getRegSaveFrameIndex(), Offset),
2493                      false, false, 0);
2494       MemOps.push_back(Store);
2495       Offset += 8;
2496     }
2497
2498     if (!ArgXMMs.empty() && NumXMMRegs != ArgXMMs.size()) {
2499       // Now store the XMM (fp + vector) parameter registers.
2500       SmallVector<SDValue, 12> SaveXMMOps;
2501       SaveXMMOps.push_back(Chain);
2502       SaveXMMOps.push_back(ALVal);
2503       SaveXMMOps.push_back(DAG.getIntPtrConstant(
2504                              FuncInfo->getRegSaveFrameIndex()));
2505       SaveXMMOps.push_back(DAG.getIntPtrConstant(
2506                              FuncInfo->getVarArgsFPOffset()));
2507       SaveXMMOps.insert(SaveXMMOps.end(), LiveXMMRegs.begin(),
2508                         LiveXMMRegs.end());
2509       MemOps.push_back(DAG.getNode(X86ISD::VASTART_SAVE_XMM_REGS, dl,
2510                                    MVT::Other, SaveXMMOps));
2511     }
2512
2513     if (!MemOps.empty())
2514       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
2515   } else if (IsWin64 && isOutlinedHandler(MF)) {
2516     // Get to the caller-allocated home save location.  Add 8 to account
2517     // for the return address.
2518     int HomeOffset = TFI.getOffsetOfLocalArea() + 8;
2519     FuncInfo->setRegSaveFrameIndex(MFI->CreateFixedObject(
2520         /*Size=*/1, /*SPOffset=*/HomeOffset + 8, /*Immutable=*/false));
2521
2522     MachineModuleInfo &MMI = MF.getMMI();
2523     MMI.getWinEHFuncInfo(Fn)
2524         .CatchHandlerParentFrameObjIdx[const_cast<Function *>(Fn)] =
2525         FuncInfo->getRegSaveFrameIndex();
2526
2527     // Store the second integer parameter (rdx) into rsp+16 relative to the
2528     // stack pointer at the entry of the function.
2529     SDValue RSFIN =
2530         DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(), getPointerTy());
2531     unsigned GPR = MF.addLiveIn(X86::RDX, &X86::GR64RegClass);
2532     SDValue Val = DAG.getCopyFromReg(Chain, dl, GPR, MVT::i64);
2533     Chain = DAG.getStore(
2534         Val.getValue(1), dl, Val, RSFIN,
2535         MachinePointerInfo::getFixedStack(FuncInfo->getRegSaveFrameIndex()),
2536         /*isVolatile=*/true, /*isNonTemporal=*/false, /*Alignment=*/0);
2537   }
2538
2539   if (isVarArg && MFI->hasMustTailInVarArgFunc()) {
2540     // Find the largest legal vector type.
2541     MVT VecVT = MVT::Other;
2542     // FIXME: Only some x86_32 calling conventions support AVX512.
2543     if (Subtarget->hasAVX512() &&
2544         (Is64Bit || (CallConv == CallingConv::X86_VectorCall ||
2545                      CallConv == CallingConv::Intel_OCL_BI)))
2546       VecVT = MVT::v16f32;
2547     else if (Subtarget->hasAVX())
2548       VecVT = MVT::v8f32;
2549     else if (Subtarget->hasSSE2())
2550       VecVT = MVT::v4f32;
2551
2552     // We forward some GPRs and some vector types.
2553     SmallVector<MVT, 2> RegParmTypes;
2554     MVT IntVT = Is64Bit ? MVT::i64 : MVT::i32;
2555     RegParmTypes.push_back(IntVT);
2556     if (VecVT != MVT::Other)
2557       RegParmTypes.push_back(VecVT);
2558
2559     // Compute the set of forwarded registers. The rest are scratch.
2560     SmallVectorImpl<ForwardedRegister> &Forwards =
2561         FuncInfo->getForwardedMustTailRegParms();
2562     CCInfo.analyzeMustTailForwardedRegisters(Forwards, RegParmTypes, CC_X86);
2563
2564     // Conservatively forward AL on x86_64, since it might be used for varargs.
2565     if (Is64Bit && !CCInfo.isAllocated(X86::AL)) {
2566       unsigned ALVReg = MF.addLiveIn(X86::AL, &X86::GR8RegClass);
2567       Forwards.push_back(ForwardedRegister(ALVReg, X86::AL, MVT::i8));
2568     }
2569
2570     // Copy all forwards from physical to virtual registers.
2571     for (ForwardedRegister &F : Forwards) {
2572       // FIXME: Can we use a less constrained schedule?
2573       SDValue RegVal = DAG.getCopyFromReg(Chain, dl, F.VReg, F.VT);
2574       F.VReg = MF.getRegInfo().createVirtualRegister(getRegClassFor(F.VT));
2575       Chain = DAG.getCopyToReg(Chain, dl, F.VReg, RegVal);
2576     }
2577   }
2578
2579   // Some CCs need callee pop.
2580   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
2581                        MF.getTarget().Options.GuaranteedTailCallOpt)) {
2582     FuncInfo->setBytesToPopOnReturn(StackSize); // Callee pops everything.
2583   } else {
2584     FuncInfo->setBytesToPopOnReturn(0); // Callee pops nothing.
2585     // If this is an sret function, the return should pop the hidden pointer.
2586     if (!Is64Bit && !IsTailCallConvention(CallConv) &&
2587         !Subtarget->getTargetTriple().isOSMSVCRT() &&
2588         argsAreStructReturn(Ins) == StackStructReturn)
2589       FuncInfo->setBytesToPopOnReturn(4);
2590   }
2591
2592   if (!Is64Bit) {
2593     // RegSaveFrameIndex is X86-64 only.
2594     FuncInfo->setRegSaveFrameIndex(0xAAAAAAA);
2595     if (CallConv == CallingConv::X86_FastCall ||
2596         CallConv == CallingConv::X86_ThisCall)
2597       // fastcc functions can't have varargs.
2598       FuncInfo->setVarArgsFrameIndex(0xAAAAAAA);
2599   }
2600
2601   FuncInfo->setArgumentStackSize(StackSize);
2602
2603   return Chain;
2604 }
2605
2606 SDValue
2607 X86TargetLowering::LowerMemOpCallTo(SDValue Chain,
2608                                     SDValue StackPtr, SDValue Arg,
2609                                     SDLoc dl, SelectionDAG &DAG,
2610                                     const CCValAssign &VA,
2611                                     ISD::ArgFlagsTy Flags) const {
2612   unsigned LocMemOffset = VA.getLocMemOffset();
2613   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
2614   PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
2615   if (Flags.isByVal())
2616     return CreateCopyOfByValArgument(Arg, PtrOff, Chain, Flags, DAG, dl);
2617
2618   return DAG.getStore(Chain, dl, Arg, PtrOff,
2619                       MachinePointerInfo::getStack(LocMemOffset),
2620                       false, false, 0);
2621 }
2622
2623 /// Emit a load of return address if tail call
2624 /// optimization is performed and it is required.
2625 SDValue
2626 X86TargetLowering::EmitTailCallLoadRetAddr(SelectionDAG &DAG,
2627                                            SDValue &OutRetAddr, SDValue Chain,
2628                                            bool IsTailCall, bool Is64Bit,
2629                                            int FPDiff, SDLoc dl) const {
2630   // Adjust the Return address stack slot.
2631   EVT VT = getPointerTy();
2632   OutRetAddr = getReturnAddressFrameIndex(DAG);
2633
2634   // Load the "old" Return address.
2635   OutRetAddr = DAG.getLoad(VT, dl, Chain, OutRetAddr, MachinePointerInfo(),
2636                            false, false, false, 0);
2637   return SDValue(OutRetAddr.getNode(), 1);
2638 }
2639
2640 /// Emit a store of the return address if tail call
2641 /// optimization is performed and it is required (FPDiff!=0).
2642 static SDValue EmitTailCallStoreRetAddr(SelectionDAG &DAG, MachineFunction &MF,
2643                                         SDValue Chain, SDValue RetAddrFrIdx,
2644                                         EVT PtrVT, unsigned SlotSize,
2645                                         int FPDiff, SDLoc dl) {
2646   // Store the return address to the appropriate stack slot.
2647   if (!FPDiff) return Chain;
2648   // Calculate the new stack slot for the return address.
2649   int NewReturnAddrFI =
2650     MF.getFrameInfo()->CreateFixedObject(SlotSize, (int64_t)FPDiff - SlotSize,
2651                                          false);
2652   SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, PtrVT);
2653   Chain = DAG.getStore(Chain, dl, RetAddrFrIdx, NewRetAddrFrIdx,
2654                        MachinePointerInfo::getFixedStack(NewReturnAddrFI),
2655                        false, false, 0);
2656   return Chain;
2657 }
2658
2659 SDValue
2660 X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
2661                              SmallVectorImpl<SDValue> &InVals) const {
2662   SelectionDAG &DAG                     = CLI.DAG;
2663   SDLoc &dl                             = CLI.DL;
2664   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
2665   SmallVectorImpl<SDValue> &OutVals     = CLI.OutVals;
2666   SmallVectorImpl<ISD::InputArg> &Ins   = CLI.Ins;
2667   SDValue Chain                         = CLI.Chain;
2668   SDValue Callee                        = CLI.Callee;
2669   CallingConv::ID CallConv              = CLI.CallConv;
2670   bool &isTailCall                      = CLI.IsTailCall;
2671   bool isVarArg                         = CLI.IsVarArg;
2672
2673   MachineFunction &MF = DAG.getMachineFunction();
2674   bool Is64Bit        = Subtarget->is64Bit();
2675   bool IsWin64        = Subtarget->isCallingConvWin64(CallConv);
2676   StructReturnType SR = callIsStructReturn(Outs);
2677   bool IsSibcall      = false;
2678   X86MachineFunctionInfo *X86Info = MF.getInfo<X86MachineFunctionInfo>();
2679
2680   if (MF.getTarget().Options.DisableTailCalls)
2681     isTailCall = false;
2682
2683   bool IsMustTail = CLI.CS && CLI.CS->isMustTailCall();
2684   if (IsMustTail) {
2685     // Force this to be a tail call.  The verifier rules are enough to ensure
2686     // that we can lower this successfully without moving the return address
2687     // around.
2688     isTailCall = true;
2689   } else if (isTailCall) {
2690     // Check if it's really possible to do a tail call.
2691     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
2692                     isVarArg, SR != NotStructReturn,
2693                     MF.getFunction()->hasStructRetAttr(), CLI.RetTy,
2694                     Outs, OutVals, Ins, DAG);
2695
2696     // Sibcalls are automatically detected tailcalls which do not require
2697     // ABI changes.
2698     if (!MF.getTarget().Options.GuaranteedTailCallOpt && isTailCall)
2699       IsSibcall = true;
2700
2701     if (isTailCall)
2702       ++NumTailCalls;
2703   }
2704
2705   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2706          "Var args not supported with calling convention fastcc, ghc or hipe");
2707
2708   // Analyze operands of the call, assigning locations to each operand.
2709   SmallVector<CCValAssign, 16> ArgLocs;
2710   CCState CCInfo(CallConv, isVarArg, MF, ArgLocs, *DAG.getContext());
2711
2712   // Allocate shadow area for Win64
2713   if (IsWin64)
2714     CCInfo.AllocateStack(32, 8);
2715
2716   CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2717
2718   // Get a count of how many bytes are to be pushed on the stack.
2719   unsigned NumBytes = CCInfo.getNextStackOffset();
2720   if (IsSibcall)
2721     // This is a sibcall. The memory operands are available in caller's
2722     // own caller's stack.
2723     NumBytes = 0;
2724   else if (MF.getTarget().Options.GuaranteedTailCallOpt &&
2725            IsTailCallConvention(CallConv))
2726     NumBytes = GetAlignedArgumentStackSize(NumBytes, DAG);
2727
2728   int FPDiff = 0;
2729   if (isTailCall && !IsSibcall && !IsMustTail) {
2730     // Lower arguments at fp - stackoffset + fpdiff.
2731     unsigned NumBytesCallerPushed = X86Info->getBytesToPopOnReturn();
2732
2733     FPDiff = NumBytesCallerPushed - NumBytes;
2734
2735     // Set the delta of movement of the returnaddr stackslot.
2736     // But only set if delta is greater than previous delta.
2737     if (FPDiff < X86Info->getTCReturnAddrDelta())
2738       X86Info->setTCReturnAddrDelta(FPDiff);
2739   }
2740
2741   unsigned NumBytesToPush = NumBytes;
2742   unsigned NumBytesToPop = NumBytes;
2743
2744   // If we have an inalloca argument, all stack space has already been allocated
2745   // for us and be right at the top of the stack.  We don't support multiple
2746   // arguments passed in memory when using inalloca.
2747   if (!Outs.empty() && Outs.back().Flags.isInAlloca()) {
2748     NumBytesToPush = 0;
2749     if (!ArgLocs.back().isMemLoc())
2750       report_fatal_error("cannot use inalloca attribute on a register "
2751                          "parameter");
2752     if (ArgLocs.back().getLocMemOffset() != 0)
2753       report_fatal_error("any parameter with the inalloca attribute must be "
2754                          "the only memory argument");
2755   }
2756
2757   if (!IsSibcall)
2758     Chain = DAG.getCALLSEQ_START(
2759         Chain, DAG.getIntPtrConstant(NumBytesToPush, true), dl);
2760
2761   SDValue RetAddrFrIdx;
2762   // Load return address for tail calls.
2763   if (isTailCall && FPDiff)
2764     Chain = EmitTailCallLoadRetAddr(DAG, RetAddrFrIdx, Chain, isTailCall,
2765                                     Is64Bit, FPDiff, dl);
2766
2767   SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
2768   SmallVector<SDValue, 8> MemOpChains;
2769   SDValue StackPtr;
2770
2771   // Walk the register/memloc assignments, inserting copies/loads.  In the case
2772   // of tail call optimization arguments are handle later.
2773   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
2774   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2775     // Skip inalloca arguments, they have already been written.
2776     ISD::ArgFlagsTy Flags = Outs[i].Flags;
2777     if (Flags.isInAlloca())
2778       continue;
2779
2780     CCValAssign &VA = ArgLocs[i];
2781     EVT RegVT = VA.getLocVT();
2782     SDValue Arg = OutVals[i];
2783     bool isByVal = Flags.isByVal();
2784
2785     // Promote the value if needed.
2786     switch (VA.getLocInfo()) {
2787     default: llvm_unreachable("Unknown loc info!");
2788     case CCValAssign::Full: break;
2789     case CCValAssign::SExt:
2790       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
2791       break;
2792     case CCValAssign::ZExt:
2793       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
2794       break;
2795     case CCValAssign::AExt:
2796       if (RegVT.is128BitVector()) {
2797         // Special case: passing MMX values in XMM registers.
2798         Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
2799         Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
2800         Arg = getMOVL(DAG, dl, MVT::v2i64, DAG.getUNDEF(MVT::v2i64), Arg);
2801       } else
2802         Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
2803       break;
2804     case CCValAssign::BCvt:
2805       Arg = DAG.getNode(ISD::BITCAST, dl, RegVT, Arg);
2806       break;
2807     case CCValAssign::Indirect: {
2808       // Store the argument.
2809       SDValue SpillSlot = DAG.CreateStackTemporary(VA.getValVT());
2810       int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
2811       Chain = DAG.getStore(Chain, dl, Arg, SpillSlot,
2812                            MachinePointerInfo::getFixedStack(FI),
2813                            false, false, 0);
2814       Arg = SpillSlot;
2815       break;
2816     }
2817     }
2818
2819     if (VA.isRegLoc()) {
2820       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
2821       if (isVarArg && IsWin64) {
2822         // Win64 ABI requires argument XMM reg to be copied to the corresponding
2823         // shadow reg if callee is a varargs function.
2824         unsigned ShadowReg = 0;
2825         switch (VA.getLocReg()) {
2826         case X86::XMM0: ShadowReg = X86::RCX; break;
2827         case X86::XMM1: ShadowReg = X86::RDX; break;
2828         case X86::XMM2: ShadowReg = X86::R8; break;
2829         case X86::XMM3: ShadowReg = X86::R9; break;
2830         }
2831         if (ShadowReg)
2832           RegsToPass.push_back(std::make_pair(ShadowReg, Arg));
2833       }
2834     } else if (!IsSibcall && (!isTailCall || isByVal)) {
2835       assert(VA.isMemLoc());
2836       if (!StackPtr.getNode())
2837         StackPtr = DAG.getCopyFromReg(Chain, dl, RegInfo->getStackRegister(),
2838                                       getPointerTy());
2839       MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Arg,
2840                                              dl, DAG, VA, Flags));
2841     }
2842   }
2843
2844   if (!MemOpChains.empty())
2845     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
2846
2847   if (Subtarget->isPICStyleGOT()) {
2848     // ELF / PIC requires GOT in the EBX register before function calls via PLT
2849     // GOT pointer.
2850     if (!isTailCall) {
2851       RegsToPass.push_back(std::make_pair(unsigned(X86::EBX),
2852                DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy())));
2853     } else {
2854       // If we are tail calling and generating PIC/GOT style code load the
2855       // address of the callee into ECX. The value in ecx is used as target of
2856       // the tail jump. This is done to circumvent the ebx/callee-saved problem
2857       // for tail calls on PIC/GOT architectures. Normally we would just put the
2858       // address of GOT into ebx and then call target@PLT. But for tail calls
2859       // ebx would be restored (since ebx is callee saved) before jumping to the
2860       // target@PLT.
2861
2862       // Note: The actual moving to ECX is done further down.
2863       GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
2864       if (G && !G->getGlobal()->hasHiddenVisibility() &&
2865           !G->getGlobal()->hasProtectedVisibility())
2866         Callee = LowerGlobalAddress(Callee, DAG);
2867       else if (isa<ExternalSymbolSDNode>(Callee))
2868         Callee = LowerExternalSymbol(Callee, DAG);
2869     }
2870   }
2871
2872   if (Is64Bit && isVarArg && !IsWin64 && !IsMustTail) {
2873     // From AMD64 ABI document:
2874     // For calls that may call functions that use varargs or stdargs
2875     // (prototype-less calls or calls to functions containing ellipsis (...) in
2876     // the declaration) %al is used as hidden argument to specify the number
2877     // of SSE registers used. The contents of %al do not need to match exactly
2878     // the number of registers, but must be an ubound on the number of SSE
2879     // registers used and is in the range 0 - 8 inclusive.
2880
2881     // Count the number of XMM registers allocated.
2882     static const MCPhysReg XMMArgRegs[] = {
2883       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
2884       X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
2885     };
2886     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs);
2887     assert((Subtarget->hasSSE1() || !NumXMMRegs)
2888            && "SSE registers cannot be used when SSE is disabled");
2889
2890     RegsToPass.push_back(std::make_pair(unsigned(X86::AL),
2891                                         DAG.getConstant(NumXMMRegs, MVT::i8)));
2892   }
2893
2894   if (isVarArg && IsMustTail) {
2895     const auto &Forwards = X86Info->getForwardedMustTailRegParms();
2896     for (const auto &F : Forwards) {
2897       SDValue Val = DAG.getCopyFromReg(Chain, dl, F.VReg, F.VT);
2898       RegsToPass.push_back(std::make_pair(unsigned(F.PReg), Val));
2899     }
2900   }
2901
2902   // For tail calls lower the arguments to the 'real' stack slots.  Sibcalls
2903   // don't need this because the eligibility check rejects calls that require
2904   // shuffling arguments passed in memory.
2905   if (!IsSibcall && isTailCall) {
2906     // Force all the incoming stack arguments to be loaded from the stack
2907     // before any new outgoing arguments are stored to the stack, because the
2908     // outgoing stack slots may alias the incoming argument stack slots, and
2909     // the alias isn't otherwise explicit. This is slightly more conservative
2910     // than necessary, because it means that each store effectively depends
2911     // on every argument instead of just those arguments it would clobber.
2912     SDValue ArgChain = DAG.getStackArgumentTokenFactor(Chain);
2913
2914     SmallVector<SDValue, 8> MemOpChains2;
2915     SDValue FIN;
2916     int FI = 0;
2917     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2918       CCValAssign &VA = ArgLocs[i];
2919       if (VA.isRegLoc())
2920         continue;
2921       assert(VA.isMemLoc());
2922       SDValue Arg = OutVals[i];
2923       ISD::ArgFlagsTy Flags = Outs[i].Flags;
2924       // Skip inalloca arguments.  They don't require any work.
2925       if (Flags.isInAlloca())
2926         continue;
2927       // Create frame index.
2928       int32_t Offset = VA.getLocMemOffset()+FPDiff;
2929       uint32_t OpSize = (VA.getLocVT().getSizeInBits()+7)/8;
2930       FI = MF.getFrameInfo()->CreateFixedObject(OpSize, Offset, true);
2931       FIN = DAG.getFrameIndex(FI, getPointerTy());
2932
2933       if (Flags.isByVal()) {
2934         // Copy relative to framepointer.
2935         SDValue Source = DAG.getIntPtrConstant(VA.getLocMemOffset());
2936         if (!StackPtr.getNode())
2937           StackPtr = DAG.getCopyFromReg(Chain, dl,
2938                                         RegInfo->getStackRegister(),
2939                                         getPointerTy());
2940         Source = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, Source);
2941
2942         MemOpChains2.push_back(CreateCopyOfByValArgument(Source, FIN,
2943                                                          ArgChain,
2944                                                          Flags, DAG, dl));
2945       } else {
2946         // Store relative to framepointer.
2947         MemOpChains2.push_back(
2948           DAG.getStore(ArgChain, dl, Arg, FIN,
2949                        MachinePointerInfo::getFixedStack(FI),
2950                        false, false, 0));
2951       }
2952     }
2953
2954     if (!MemOpChains2.empty())
2955       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains2);
2956
2957     // Store the return address to the appropriate stack slot.
2958     Chain = EmitTailCallStoreRetAddr(DAG, MF, Chain, RetAddrFrIdx,
2959                                      getPointerTy(), RegInfo->getSlotSize(),
2960                                      FPDiff, dl);
2961   }
2962
2963   // Build a sequence of copy-to-reg nodes chained together with token chain
2964   // and flag operands which copy the outgoing args into registers.
2965   SDValue InFlag;
2966   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
2967     Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
2968                              RegsToPass[i].second, InFlag);
2969     InFlag = Chain.getValue(1);
2970   }
2971
2972   if (DAG.getTarget().getCodeModel() == CodeModel::Large) {
2973     assert(Is64Bit && "Large code model is only legal in 64-bit mode.");
2974     // In the 64-bit large code model, we have to make all calls
2975     // through a register, since the call instruction's 32-bit
2976     // pc-relative offset may not be large enough to hold the whole
2977     // address.
2978   } else if (Callee->getOpcode() == ISD::GlobalAddress) {
2979     // If the callee is a GlobalAddress node (quite common, every direct call
2980     // is) turn it into a TargetGlobalAddress node so that legalize doesn't hack
2981     // it.
2982     GlobalAddressSDNode* G = cast<GlobalAddressSDNode>(Callee);
2983
2984     // We should use extra load for direct calls to dllimported functions in
2985     // non-JIT mode.
2986     const GlobalValue *GV = G->getGlobal();
2987     if (!GV->hasDLLImportStorageClass()) {
2988       unsigned char OpFlags = 0;
2989       bool ExtraLoad = false;
2990       unsigned WrapperKind = ISD::DELETED_NODE;
2991
2992       // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
2993       // external symbols most go through the PLT in PIC mode.  If the symbol
2994       // has hidden or protected visibility, or if it is static or local, then
2995       // we don't need to use the PLT - we can directly call it.
2996       if (Subtarget->isTargetELF() &&
2997           DAG.getTarget().getRelocationModel() == Reloc::PIC_ &&
2998           GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
2999         OpFlags = X86II::MO_PLT;
3000       } else if (Subtarget->isPICStyleStubAny() &&
3001                  (GV->isDeclaration() || GV->isWeakForLinker()) &&
3002                  (!Subtarget->getTargetTriple().isMacOSX() ||
3003                   Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
3004         // PC-relative references to external symbols should go through $stub,
3005         // unless we're building with the leopard linker or later, which
3006         // automatically synthesizes these stubs.
3007         OpFlags = X86II::MO_DARWIN_STUB;
3008       } else if (Subtarget->isPICStyleRIPRel() && isa<Function>(GV) &&
3009                  cast<Function>(GV)->hasFnAttribute(Attribute::NonLazyBind)) {
3010         // If the function is marked as non-lazy, generate an indirect call
3011         // which loads from the GOT directly. This avoids runtime overhead
3012         // at the cost of eager binding (and one extra byte of encoding).
3013         OpFlags = X86II::MO_GOTPCREL;
3014         WrapperKind = X86ISD::WrapperRIP;
3015         ExtraLoad = true;
3016       }
3017
3018       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(),
3019                                           G->getOffset(), OpFlags);
3020
3021       // Add a wrapper if needed.
3022       if (WrapperKind != ISD::DELETED_NODE)
3023         Callee = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Callee);
3024       // Add extra indirection if needed.
3025       if (ExtraLoad)
3026         Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Callee,
3027                              MachinePointerInfo::getGOT(),
3028                              false, false, false, 0);
3029     }
3030   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
3031     unsigned char OpFlags = 0;
3032
3033     // On ELF targets, in either X86-64 or X86-32 mode, direct calls to
3034     // external symbols should go through the PLT.
3035     if (Subtarget->isTargetELF() &&
3036         DAG.getTarget().getRelocationModel() == Reloc::PIC_) {
3037       OpFlags = X86II::MO_PLT;
3038     } else if (Subtarget->isPICStyleStubAny() &&
3039                (!Subtarget->getTargetTriple().isMacOSX() ||
3040                 Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
3041       // PC-relative references to external symbols should go through $stub,
3042       // unless we're building with the leopard linker or later, which
3043       // automatically synthesizes these stubs.
3044       OpFlags = X86II::MO_DARWIN_STUB;
3045     }
3046
3047     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy(),
3048                                          OpFlags);
3049   } else if (Subtarget->isTarget64BitILP32() &&
3050              Callee->getValueType(0) == MVT::i32) {
3051     // Zero-extend the 32-bit Callee address into a 64-bit according to x32 ABI
3052     Callee = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Callee);
3053   }
3054
3055   // Returns a chain & a flag for retval copy to use.
3056   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
3057   SmallVector<SDValue, 8> Ops;
3058
3059   if (!IsSibcall && isTailCall) {
3060     Chain = DAG.getCALLSEQ_END(Chain,
3061                                DAG.getIntPtrConstant(NumBytesToPop, true),
3062                                DAG.getIntPtrConstant(0, true), InFlag, dl);
3063     InFlag = Chain.getValue(1);
3064   }
3065
3066   Ops.push_back(Chain);
3067   Ops.push_back(Callee);
3068
3069   if (isTailCall)
3070     Ops.push_back(DAG.getConstant(FPDiff, MVT::i32));
3071
3072   // Add argument registers to the end of the list so that they are known live
3073   // into the call.
3074   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
3075     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
3076                                   RegsToPass[i].second.getValueType()));
3077
3078   // Add a register mask operand representing the call-preserved registers.
3079   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
3080   const uint32_t *Mask = TRI->getCallPreservedMask(MF, CallConv);
3081   assert(Mask && "Missing call preserved mask for calling convention");
3082   Ops.push_back(DAG.getRegisterMask(Mask));
3083
3084   if (InFlag.getNode())
3085     Ops.push_back(InFlag);
3086
3087   if (isTailCall) {
3088     // We used to do:
3089     //// If this is the first return lowered for this function, add the regs
3090     //// to the liveout set for the function.
3091     // This isn't right, although it's probably harmless on x86; liveouts
3092     // should be computed from returns not tail calls.  Consider a void
3093     // function making a tail call to a function returning int.
3094     return DAG.getNode(X86ISD::TC_RETURN, dl, NodeTys, Ops);
3095   }
3096
3097   Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, Ops);
3098   InFlag = Chain.getValue(1);
3099
3100   // Create the CALLSEQ_END node.
3101   unsigned NumBytesForCalleeToPop;
3102   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
3103                        DAG.getTarget().Options.GuaranteedTailCallOpt))
3104     NumBytesForCalleeToPop = NumBytes;    // Callee pops everything
3105   else if (!Is64Bit && !IsTailCallConvention(CallConv) &&
3106            !Subtarget->getTargetTriple().isOSMSVCRT() &&
3107            SR == StackStructReturn)
3108     // If this is a call to a struct-return function, the callee
3109     // pops the hidden struct pointer, so we have to push it back.
3110     // This is common for Darwin/X86, Linux & Mingw32 targets.
3111     // For MSVC Win32 targets, the caller pops the hidden struct pointer.
3112     NumBytesForCalleeToPop = 4;
3113   else
3114     NumBytesForCalleeToPop = 0;  // Callee pops nothing.
3115
3116   // Returns a flag for retval copy to use.
3117   if (!IsSibcall) {
3118     Chain = DAG.getCALLSEQ_END(Chain,
3119                                DAG.getIntPtrConstant(NumBytesToPop, true),
3120                                DAG.getIntPtrConstant(NumBytesForCalleeToPop,
3121                                                      true),
3122                                InFlag, dl);
3123     InFlag = Chain.getValue(1);
3124   }
3125
3126   // Handle result values, copying them out of physregs into vregs that we
3127   // return.
3128   return LowerCallResult(Chain, InFlag, CallConv, isVarArg,
3129                          Ins, dl, DAG, InVals);
3130 }
3131
3132 //===----------------------------------------------------------------------===//
3133 //                Fast Calling Convention (tail call) implementation
3134 //===----------------------------------------------------------------------===//
3135
3136 //  Like std call, callee cleans arguments, convention except that ECX is
3137 //  reserved for storing the tail called function address. Only 2 registers are
3138 //  free for argument passing (inreg). Tail call optimization is performed
3139 //  provided:
3140 //                * tailcallopt is enabled
3141 //                * caller/callee are fastcc
3142 //  On X86_64 architecture with GOT-style position independent code only local
3143 //  (within module) calls are supported at the moment.
3144 //  To keep the stack aligned according to platform abi the function
3145 //  GetAlignedArgumentStackSize ensures that argument delta is always multiples
3146 //  of stack alignment. (Dynamic linkers need this - darwin's dyld for example)
3147 //  If a tail called function callee has more arguments than the caller the
3148 //  caller needs to make sure that there is room to move the RETADDR to. This is
3149 //  achieved by reserving an area the size of the argument delta right after the
3150 //  original RETADDR, but before the saved framepointer or the spilled registers
3151 //  e.g. caller(arg1, arg2) calls callee(arg1, arg2,arg3,arg4)
3152 //  stack layout:
3153 //    arg1
3154 //    arg2
3155 //    RETADDR
3156 //    [ new RETADDR
3157 //      move area ]
3158 //    (possible EBP)
3159 //    ESI
3160 //    EDI
3161 //    local1 ..
3162
3163 /// GetAlignedArgumentStackSize - Make the stack size align e.g 16n + 12 aligned
3164 /// for a 16 byte align requirement.
3165 unsigned
3166 X86TargetLowering::GetAlignedArgumentStackSize(unsigned StackSize,
3167                                                SelectionDAG& DAG) const {
3168   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
3169   const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
3170   unsigned StackAlignment = TFI.getStackAlignment();
3171   uint64_t AlignMask = StackAlignment - 1;
3172   int64_t Offset = StackSize;
3173   unsigned SlotSize = RegInfo->getSlotSize();
3174   if ( (Offset & AlignMask) <= (StackAlignment - SlotSize) ) {
3175     // Number smaller than 12 so just add the difference.
3176     Offset += ((StackAlignment - SlotSize) - (Offset & AlignMask));
3177   } else {
3178     // Mask out lower bits, add stackalignment once plus the 12 bytes.
3179     Offset = ((~AlignMask) & Offset) + StackAlignment +
3180       (StackAlignment-SlotSize);
3181   }
3182   return Offset;
3183 }
3184
3185 /// MatchingStackOffset - Return true if the given stack call argument is
3186 /// already available in the same position (relatively) of the caller's
3187 /// incoming argument stack.
3188 static
3189 bool MatchingStackOffset(SDValue Arg, unsigned Offset, ISD::ArgFlagsTy Flags,
3190                          MachineFrameInfo *MFI, const MachineRegisterInfo *MRI,
3191                          const X86InstrInfo *TII) {
3192   unsigned Bytes = Arg.getValueType().getSizeInBits() / 8;
3193   int FI = INT_MAX;
3194   if (Arg.getOpcode() == ISD::CopyFromReg) {
3195     unsigned VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
3196     if (!TargetRegisterInfo::isVirtualRegister(VR))
3197       return false;
3198     MachineInstr *Def = MRI->getVRegDef(VR);
3199     if (!Def)
3200       return false;
3201     if (!Flags.isByVal()) {
3202       if (!TII->isLoadFromStackSlot(Def, FI))
3203         return false;
3204     } else {
3205       unsigned Opcode = Def->getOpcode();
3206       if ((Opcode == X86::LEA32r || Opcode == X86::LEA64r ||
3207            Opcode == X86::LEA64_32r) &&
3208           Def->getOperand(1).isFI()) {
3209         FI = Def->getOperand(1).getIndex();
3210         Bytes = Flags.getByValSize();
3211       } else
3212         return false;
3213     }
3214   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
3215     if (Flags.isByVal())
3216       // ByVal argument is passed in as a pointer but it's now being
3217       // dereferenced. e.g.
3218       // define @foo(%struct.X* %A) {
3219       //   tail call @bar(%struct.X* byval %A)
3220       // }
3221       return false;
3222     SDValue Ptr = Ld->getBasePtr();
3223     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr);
3224     if (!FINode)
3225       return false;
3226     FI = FINode->getIndex();
3227   } else if (Arg.getOpcode() == ISD::FrameIndex && Flags.isByVal()) {
3228     FrameIndexSDNode *FINode = cast<FrameIndexSDNode>(Arg);
3229     FI = FINode->getIndex();
3230     Bytes = Flags.getByValSize();
3231   } else
3232     return false;
3233
3234   assert(FI != INT_MAX);
3235   if (!MFI->isFixedObjectIndex(FI))
3236     return false;
3237   return Offset == MFI->getObjectOffset(FI) && Bytes == MFI->getObjectSize(FI);
3238 }
3239
3240 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
3241 /// for tail call optimization. Targets which want to do tail call
3242 /// optimization should implement this function.
3243 bool
3244 X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
3245                                                      CallingConv::ID CalleeCC,
3246                                                      bool isVarArg,
3247                                                      bool isCalleeStructRet,
3248                                                      bool isCallerStructRet,
3249                                                      Type *RetTy,
3250                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
3251                                     const SmallVectorImpl<SDValue> &OutVals,
3252                                     const SmallVectorImpl<ISD::InputArg> &Ins,
3253                                                      SelectionDAG &DAG) const {
3254   if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
3255     return false;
3256
3257   // If -tailcallopt is specified, make fastcc functions tail-callable.
3258   const MachineFunction &MF = DAG.getMachineFunction();
3259   const Function *CallerF = MF.getFunction();
3260
3261   // If the function return type is x86_fp80 and the callee return type is not,
3262   // then the FP_EXTEND of the call result is not a nop. It's not safe to
3263   // perform a tailcall optimization here.
3264   if (CallerF->getReturnType()->isX86_FP80Ty() && !RetTy->isX86_FP80Ty())
3265     return false;
3266
3267   CallingConv::ID CallerCC = CallerF->getCallingConv();
3268   bool CCMatch = CallerCC == CalleeCC;
3269   bool IsCalleeWin64 = Subtarget->isCallingConvWin64(CalleeCC);
3270   bool IsCallerWin64 = Subtarget->isCallingConvWin64(CallerCC);
3271
3272   // Win64 functions have extra shadow space for argument homing. Don't do the
3273   // sibcall if the caller and callee have mismatched expectations for this
3274   // space.
3275   if (IsCalleeWin64 != IsCallerWin64)
3276     return false;
3277
3278   if (DAG.getTarget().Options.GuaranteedTailCallOpt) {
3279     if (IsTailCallConvention(CalleeCC) && CCMatch)
3280       return true;
3281     return false;
3282   }
3283
3284   // Look for obvious safe cases to perform tail call optimization that do not
3285   // require ABI changes. This is what gcc calls sibcall.
3286
3287   // Can't do sibcall if stack needs to be dynamically re-aligned. PEI needs to
3288   // emit a special epilogue.
3289   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
3290   if (RegInfo->needsStackRealignment(MF))
3291     return false;
3292
3293   // Also avoid sibcall optimization if either caller or callee uses struct
3294   // return semantics.
3295   if (isCalleeStructRet || isCallerStructRet)
3296     return false;
3297
3298   // An stdcall/thiscall caller is expected to clean up its arguments; the
3299   // callee isn't going to do that.
3300   // FIXME: this is more restrictive than needed. We could produce a tailcall
3301   // when the stack adjustment matches. For example, with a thiscall that takes
3302   // only one argument.
3303   if (!CCMatch && (CallerCC == CallingConv::X86_StdCall ||
3304                    CallerCC == CallingConv::X86_ThisCall))
3305     return false;
3306
3307   // Do not sibcall optimize vararg calls unless all arguments are passed via
3308   // registers.
3309   if (isVarArg && !Outs.empty()) {
3310
3311     // Optimizing for varargs on Win64 is unlikely to be safe without
3312     // additional testing.
3313     if (IsCalleeWin64 || IsCallerWin64)
3314       return false;
3315
3316     SmallVector<CCValAssign, 16> ArgLocs;
3317     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(), ArgLocs,
3318                    *DAG.getContext());
3319
3320     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
3321     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i)
3322       if (!ArgLocs[i].isRegLoc())
3323         return false;
3324   }
3325
3326   // If the call result is in ST0 / ST1, it needs to be popped off the x87
3327   // stack.  Therefore, if it's not used by the call it is not safe to optimize
3328   // this into a sibcall.
3329   bool Unused = false;
3330   for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
3331     if (!Ins[i].Used) {
3332       Unused = true;
3333       break;
3334     }
3335   }
3336   if (Unused) {
3337     SmallVector<CCValAssign, 16> RVLocs;
3338     CCState CCInfo(CalleeCC, false, DAG.getMachineFunction(), RVLocs,
3339                    *DAG.getContext());
3340     CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
3341     for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
3342       CCValAssign &VA = RVLocs[i];
3343       if (VA.getLocReg() == X86::FP0 || VA.getLocReg() == X86::FP1)
3344         return false;
3345     }
3346   }
3347
3348   // If the calling conventions do not match, then we'd better make sure the
3349   // results are returned in the same way as what the caller expects.
3350   if (!CCMatch) {
3351     SmallVector<CCValAssign, 16> RVLocs1;
3352     CCState CCInfo1(CalleeCC, false, DAG.getMachineFunction(), RVLocs1,
3353                     *DAG.getContext());
3354     CCInfo1.AnalyzeCallResult(Ins, RetCC_X86);
3355
3356     SmallVector<CCValAssign, 16> RVLocs2;
3357     CCState CCInfo2(CallerCC, false, DAG.getMachineFunction(), RVLocs2,
3358                     *DAG.getContext());
3359     CCInfo2.AnalyzeCallResult(Ins, RetCC_X86);
3360
3361     if (RVLocs1.size() != RVLocs2.size())
3362       return false;
3363     for (unsigned i = 0, e = RVLocs1.size(); i != e; ++i) {
3364       if (RVLocs1[i].isRegLoc() != RVLocs2[i].isRegLoc())
3365         return false;
3366       if (RVLocs1[i].getLocInfo() != RVLocs2[i].getLocInfo())
3367         return false;
3368       if (RVLocs1[i].isRegLoc()) {
3369         if (RVLocs1[i].getLocReg() != RVLocs2[i].getLocReg())
3370           return false;
3371       } else {
3372         if (RVLocs1[i].getLocMemOffset() != RVLocs2[i].getLocMemOffset())
3373           return false;
3374       }
3375     }
3376   }
3377
3378   // If the callee takes no arguments then go on to check the results of the
3379   // call.
3380   if (!Outs.empty()) {
3381     // Check if stack adjustment is needed. For now, do not do this if any
3382     // argument is passed on the stack.
3383     SmallVector<CCValAssign, 16> ArgLocs;
3384     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(), ArgLocs,
3385                    *DAG.getContext());
3386
3387     // Allocate shadow area for Win64
3388     if (IsCalleeWin64)
3389       CCInfo.AllocateStack(32, 8);
3390
3391     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
3392     if (CCInfo.getNextStackOffset()) {
3393       MachineFunction &MF = DAG.getMachineFunction();
3394       if (MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn())
3395         return false;
3396
3397       // Check if the arguments are already laid out in the right way as
3398       // the caller's fixed stack objects.
3399       MachineFrameInfo *MFI = MF.getFrameInfo();
3400       const MachineRegisterInfo *MRI = &MF.getRegInfo();
3401       const X86InstrInfo *TII = Subtarget->getInstrInfo();
3402       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3403         CCValAssign &VA = ArgLocs[i];
3404         SDValue Arg = OutVals[i];
3405         ISD::ArgFlagsTy Flags = Outs[i].Flags;
3406         if (VA.getLocInfo() == CCValAssign::Indirect)
3407           return false;
3408         if (!VA.isRegLoc()) {
3409           if (!MatchingStackOffset(Arg, VA.getLocMemOffset(), Flags,
3410                                    MFI, MRI, TII))
3411             return false;
3412         }
3413       }
3414     }
3415
3416     // If the tailcall address may be in a register, then make sure it's
3417     // possible to register allocate for it. In 32-bit, the call address can
3418     // only target EAX, EDX, or ECX since the tail call must be scheduled after
3419     // callee-saved registers are restored. These happen to be the same
3420     // registers used to pass 'inreg' arguments so watch out for those.
3421     if (!Subtarget->is64Bit() &&
3422         ((!isa<GlobalAddressSDNode>(Callee) &&
3423           !isa<ExternalSymbolSDNode>(Callee)) ||
3424          DAG.getTarget().getRelocationModel() == Reloc::PIC_)) {
3425       unsigned NumInRegs = 0;
3426       // In PIC we need an extra register to formulate the address computation
3427       // for the callee.
3428       unsigned MaxInRegs =
3429         (DAG.getTarget().getRelocationModel() == Reloc::PIC_) ? 2 : 3;
3430
3431       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3432         CCValAssign &VA = ArgLocs[i];
3433         if (!VA.isRegLoc())
3434           continue;
3435         unsigned Reg = VA.getLocReg();
3436         switch (Reg) {
3437         default: break;
3438         case X86::EAX: case X86::EDX: case X86::ECX:
3439           if (++NumInRegs == MaxInRegs)
3440             return false;
3441           break;
3442         }
3443       }
3444     }
3445   }
3446
3447   return true;
3448 }
3449
3450 FastISel *
3451 X86TargetLowering::createFastISel(FunctionLoweringInfo &funcInfo,
3452                                   const TargetLibraryInfo *libInfo) const {
3453   return X86::createFastISel(funcInfo, libInfo);
3454 }
3455
3456 //===----------------------------------------------------------------------===//
3457 //                           Other Lowering Hooks
3458 //===----------------------------------------------------------------------===//
3459
3460 static bool MayFoldLoad(SDValue Op) {
3461   return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
3462 }
3463
3464 static bool MayFoldIntoStore(SDValue Op) {
3465   return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
3466 }
3467
3468 static bool isTargetShuffle(unsigned Opcode) {
3469   switch(Opcode) {
3470   default: return false;
3471   case X86ISD::BLENDI:
3472   case X86ISD::PSHUFB:
3473   case X86ISD::PSHUFD:
3474   case X86ISD::PSHUFHW:
3475   case X86ISD::PSHUFLW:
3476   case X86ISD::SHUFP:
3477   case X86ISD::PALIGNR:
3478   case X86ISD::MOVLHPS:
3479   case X86ISD::MOVLHPD:
3480   case X86ISD::MOVHLPS:
3481   case X86ISD::MOVLPS:
3482   case X86ISD::MOVLPD:
3483   case X86ISD::MOVSHDUP:
3484   case X86ISD::MOVSLDUP:
3485   case X86ISD::MOVDDUP:
3486   case X86ISD::MOVSS:
3487   case X86ISD::MOVSD:
3488   case X86ISD::UNPCKL:
3489   case X86ISD::UNPCKH:
3490   case X86ISD::VPERMILPI:
3491   case X86ISD::VPERM2X128:
3492   case X86ISD::VPERMI:
3493     return true;
3494   }
3495 }
3496
3497 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3498                                     SDValue V1, unsigned TargetMask,
3499                                     SelectionDAG &DAG) {
3500   switch(Opc) {
3501   default: llvm_unreachable("Unknown x86 shuffle node");
3502   case X86ISD::PSHUFD:
3503   case X86ISD::PSHUFHW:
3504   case X86ISD::PSHUFLW:
3505   case X86ISD::VPERMILPI:
3506   case X86ISD::VPERMI:
3507     return DAG.getNode(Opc, dl, VT, V1, DAG.getConstant(TargetMask, MVT::i8));
3508   }
3509 }
3510
3511 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3512                                     SDValue V1, SDValue V2, SelectionDAG &DAG) {
3513   switch(Opc) {
3514   default: llvm_unreachable("Unknown x86 shuffle node");
3515   case X86ISD::MOVLHPS:
3516   case X86ISD::MOVLHPD:
3517   case X86ISD::MOVHLPS:
3518   case X86ISD::MOVLPS:
3519   case X86ISD::MOVLPD:
3520   case X86ISD::MOVSS:
3521   case X86ISD::MOVSD:
3522   case X86ISD::UNPCKL:
3523   case X86ISD::UNPCKH:
3524     return DAG.getNode(Opc, dl, VT, V1, V2);
3525   }
3526 }
3527
3528 SDValue X86TargetLowering::getReturnAddressFrameIndex(SelectionDAG &DAG) const {
3529   MachineFunction &MF = DAG.getMachineFunction();
3530   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
3531   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
3532   int ReturnAddrIndex = FuncInfo->getRAIndex();
3533
3534   if (ReturnAddrIndex == 0) {
3535     // Set up a frame object for the return address.
3536     unsigned SlotSize = RegInfo->getSlotSize();
3537     ReturnAddrIndex = MF.getFrameInfo()->CreateFixedObject(SlotSize,
3538                                                            -(int64_t)SlotSize,
3539                                                            false);
3540     FuncInfo->setRAIndex(ReturnAddrIndex);
3541   }
3542
3543   return DAG.getFrameIndex(ReturnAddrIndex, getPointerTy());
3544 }
3545
3546 bool X86::isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
3547                                        bool hasSymbolicDisplacement) {
3548   // Offset should fit into 32 bit immediate field.
3549   if (!isInt<32>(Offset))
3550     return false;
3551
3552   // If we don't have a symbolic displacement - we don't have any extra
3553   // restrictions.
3554   if (!hasSymbolicDisplacement)
3555     return true;
3556
3557   // FIXME: Some tweaks might be needed for medium code model.
3558   if (M != CodeModel::Small && M != CodeModel::Kernel)
3559     return false;
3560
3561   // For small code model we assume that latest object is 16MB before end of 31
3562   // bits boundary. We may also accept pretty large negative constants knowing
3563   // that all objects are in the positive half of address space.
3564   if (M == CodeModel::Small && Offset < 16*1024*1024)
3565     return true;
3566
3567   // For kernel code model we know that all object resist in the negative half
3568   // of 32bits address space. We may not accept negative offsets, since they may
3569   // be just off and we may accept pretty large positive ones.
3570   if (M == CodeModel::Kernel && Offset >= 0)
3571     return true;
3572
3573   return false;
3574 }
3575
3576 /// isCalleePop - Determines whether the callee is required to pop its
3577 /// own arguments. Callee pop is necessary to support tail calls.
3578 bool X86::isCalleePop(CallingConv::ID CallingConv,
3579                       bool is64Bit, bool IsVarArg, bool TailCallOpt) {
3580   switch (CallingConv) {
3581   default:
3582     return false;
3583   case CallingConv::X86_StdCall:
3584   case CallingConv::X86_FastCall:
3585   case CallingConv::X86_ThisCall:
3586     return !is64Bit;
3587   case CallingConv::Fast:
3588   case CallingConv::GHC:
3589   case CallingConv::HiPE:
3590     if (IsVarArg)
3591       return false;
3592     return TailCallOpt;
3593   }
3594 }
3595
3596 /// \brief Return true if the condition is an unsigned comparison operation.
3597 static bool isX86CCUnsigned(unsigned X86CC) {
3598   switch (X86CC) {
3599   default: llvm_unreachable("Invalid integer condition!");
3600   case X86::COND_E:     return true;
3601   case X86::COND_G:     return false;
3602   case X86::COND_GE:    return false;
3603   case X86::COND_L:     return false;
3604   case X86::COND_LE:    return false;
3605   case X86::COND_NE:    return true;
3606   case X86::COND_B:     return true;
3607   case X86::COND_A:     return true;
3608   case X86::COND_BE:    return true;
3609   case X86::COND_AE:    return true;
3610   }
3611   llvm_unreachable("covered switch fell through?!");
3612 }
3613
3614 /// TranslateX86CC - do a one to one translation of a ISD::CondCode to the X86
3615 /// specific condition code, returning the condition code and the LHS/RHS of the
3616 /// comparison to make.
3617 static unsigned TranslateX86CC(ISD::CondCode SetCCOpcode, bool isFP,
3618                                SDValue &LHS, SDValue &RHS, SelectionDAG &DAG) {
3619   if (!isFP) {
3620     if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS)) {
3621       if (SetCCOpcode == ISD::SETGT && RHSC->isAllOnesValue()) {
3622         // X > -1   -> X == 0, jump !sign.
3623         RHS = DAG.getConstant(0, RHS.getValueType());
3624         return X86::COND_NS;
3625       }
3626       if (SetCCOpcode == ISD::SETLT && RHSC->isNullValue()) {
3627         // X < 0   -> X == 0, jump on sign.
3628         return X86::COND_S;
3629       }
3630       if (SetCCOpcode == ISD::SETLT && RHSC->getZExtValue() == 1) {
3631         // X < 1   -> X <= 0
3632         RHS = DAG.getConstant(0, RHS.getValueType());
3633         return X86::COND_LE;
3634       }
3635     }
3636
3637     switch (SetCCOpcode) {
3638     default: llvm_unreachable("Invalid integer condition!");
3639     case ISD::SETEQ:  return X86::COND_E;
3640     case ISD::SETGT:  return X86::COND_G;
3641     case ISD::SETGE:  return X86::COND_GE;
3642     case ISD::SETLT:  return X86::COND_L;
3643     case ISD::SETLE:  return X86::COND_LE;
3644     case ISD::SETNE:  return X86::COND_NE;
3645     case ISD::SETULT: return X86::COND_B;
3646     case ISD::SETUGT: return X86::COND_A;
3647     case ISD::SETULE: return X86::COND_BE;
3648     case ISD::SETUGE: return X86::COND_AE;
3649     }
3650   }
3651
3652   // First determine if it is required or is profitable to flip the operands.
3653
3654   // If LHS is a foldable load, but RHS is not, flip the condition.
3655   if (ISD::isNON_EXTLoad(LHS.getNode()) &&
3656       !ISD::isNON_EXTLoad(RHS.getNode())) {
3657     SetCCOpcode = getSetCCSwappedOperands(SetCCOpcode);
3658     std::swap(LHS, RHS);
3659   }
3660
3661   switch (SetCCOpcode) {
3662   default: break;
3663   case ISD::SETOLT:
3664   case ISD::SETOLE:
3665   case ISD::SETUGT:
3666   case ISD::SETUGE:
3667     std::swap(LHS, RHS);
3668     break;
3669   }
3670
3671   // On a floating point condition, the flags are set as follows:
3672   // ZF  PF  CF   op
3673   //  0 | 0 | 0 | X > Y
3674   //  0 | 0 | 1 | X < Y
3675   //  1 | 0 | 0 | X == Y
3676   //  1 | 1 | 1 | unordered
3677   switch (SetCCOpcode) {
3678   default: llvm_unreachable("Condcode should be pre-legalized away");
3679   case ISD::SETUEQ:
3680   case ISD::SETEQ:   return X86::COND_E;
3681   case ISD::SETOLT:              // flipped
3682   case ISD::SETOGT:
3683   case ISD::SETGT:   return X86::COND_A;
3684   case ISD::SETOLE:              // flipped
3685   case ISD::SETOGE:
3686   case ISD::SETGE:   return X86::COND_AE;
3687   case ISD::SETUGT:              // flipped
3688   case ISD::SETULT:
3689   case ISD::SETLT:   return X86::COND_B;
3690   case ISD::SETUGE:              // flipped
3691   case ISD::SETULE:
3692   case ISD::SETLE:   return X86::COND_BE;
3693   case ISD::SETONE:
3694   case ISD::SETNE:   return X86::COND_NE;
3695   case ISD::SETUO:   return X86::COND_P;
3696   case ISD::SETO:    return X86::COND_NP;
3697   case ISD::SETOEQ:
3698   case ISD::SETUNE:  return X86::COND_INVALID;
3699   }
3700 }
3701
3702 /// hasFPCMov - is there a floating point cmov for the specific X86 condition
3703 /// code. Current x86 isa includes the following FP cmov instructions:
3704 /// fcmovb, fcomvbe, fcomve, fcmovu, fcmovae, fcmova, fcmovne, fcmovnu.
3705 static bool hasFPCMov(unsigned X86CC) {
3706   switch (X86CC) {
3707   default:
3708     return false;
3709   case X86::COND_B:
3710   case X86::COND_BE:
3711   case X86::COND_E:
3712   case X86::COND_P:
3713   case X86::COND_A:
3714   case X86::COND_AE:
3715   case X86::COND_NE:
3716   case X86::COND_NP:
3717     return true;
3718   }
3719 }
3720
3721 /// isFPImmLegal - Returns true if the target can instruction select the
3722 /// specified FP immediate natively. If false, the legalizer will
3723 /// materialize the FP immediate as a load from a constant pool.
3724 bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
3725   for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) {
3726     if (Imm.bitwiseIsEqual(LegalFPImmediates[i]))
3727       return true;
3728   }
3729   return false;
3730 }
3731
3732 bool X86TargetLowering::shouldReduceLoadWidth(SDNode *Load,
3733                                               ISD::LoadExtType ExtTy,
3734                                               EVT NewVT) const {
3735   // "ELF Handling for Thread-Local Storage" specifies that R_X86_64_GOTTPOFF
3736   // relocation target a movq or addq instruction: don't let the load shrink.
3737   SDValue BasePtr = cast<LoadSDNode>(Load)->getBasePtr();
3738   if (BasePtr.getOpcode() == X86ISD::WrapperRIP)
3739     if (const auto *GA = dyn_cast<GlobalAddressSDNode>(BasePtr.getOperand(0)))
3740       return GA->getTargetFlags() != X86II::MO_GOTTPOFF;
3741   return true;
3742 }
3743
3744 /// \brief Returns true if it is beneficial to convert a load of a constant
3745 /// to just the constant itself.
3746 bool X86TargetLowering::shouldConvertConstantLoadToIntImm(const APInt &Imm,
3747                                                           Type *Ty) const {
3748   assert(Ty->isIntegerTy());
3749
3750   unsigned BitSize = Ty->getPrimitiveSizeInBits();
3751   if (BitSize == 0 || BitSize > 64)
3752     return false;
3753   return true;
3754 }
3755
3756 bool X86TargetLowering::isExtractSubvectorCheap(EVT ResVT,
3757                                                 unsigned Index) const {
3758   if (!isOperationLegalOrCustom(ISD::EXTRACT_SUBVECTOR, ResVT))
3759     return false;
3760
3761   return (Index == 0 || Index == ResVT.getVectorNumElements());
3762 }
3763
3764 bool X86TargetLowering::isCheapToSpeculateCttz() const {
3765   // Speculate cttz only if we can directly use TZCNT.
3766   return Subtarget->hasBMI();
3767 }
3768
3769 bool X86TargetLowering::isCheapToSpeculateCtlz() const {
3770   // Speculate ctlz only if we can directly use LZCNT.
3771   return Subtarget->hasLZCNT();
3772 }
3773
3774 /// isUndefOrInRange - Return true if Val is undef or if its value falls within
3775 /// the specified range (L, H].
3776 static bool isUndefOrInRange(int Val, int Low, int Hi) {
3777   return (Val < 0) || (Val >= Low && Val < Hi);
3778 }
3779
3780 /// isUndefOrEqual - Val is either less than zero (undef) or equal to the
3781 /// specified value.
3782 static bool isUndefOrEqual(int Val, int CmpVal) {
3783   return (Val < 0 || Val == CmpVal);
3784 }
3785
3786 /// isSequentialOrUndefInRange - Return true if every element in Mask, beginning
3787 /// from position Pos and ending in Pos+Size, falls within the specified
3788 /// sequential range (Low, Low+Size]. or is undef.
3789 static bool isSequentialOrUndefInRange(ArrayRef<int> Mask,
3790                                        unsigned Pos, unsigned Size, int Low) {
3791   for (unsigned i = Pos, e = Pos+Size; i != e; ++i, ++Low)
3792     if (!isUndefOrEqual(Mask[i], Low))
3793       return false;
3794   return true;
3795 }
3796
3797 /// isVEXTRACTIndex - Return true if the specified
3798 /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
3799 /// suitable for instruction that extract 128 or 256 bit vectors
3800 static bool isVEXTRACTIndex(SDNode *N, unsigned vecWidth) {
3801   assert((vecWidth == 128 || vecWidth == 256) && "Unexpected vector width");
3802   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
3803     return false;
3804
3805   // The index should be aligned on a vecWidth-bit boundary.
3806   uint64_t Index =
3807     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
3808
3809   MVT VT = N->getSimpleValueType(0);
3810   unsigned ElSize = VT.getVectorElementType().getSizeInBits();
3811   bool Result = (Index * ElSize) % vecWidth == 0;
3812
3813   return Result;
3814 }
3815
3816 /// isVINSERTIndex - Return true if the specified INSERT_SUBVECTOR
3817 /// operand specifies a subvector insert that is suitable for input to
3818 /// insertion of 128 or 256-bit subvectors
3819 static bool isVINSERTIndex(SDNode *N, unsigned vecWidth) {
3820   assert((vecWidth == 128 || vecWidth == 256) && "Unexpected vector width");
3821   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
3822     return false;
3823   // The index should be aligned on a vecWidth-bit boundary.
3824   uint64_t Index =
3825     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
3826
3827   MVT VT = N->getSimpleValueType(0);
3828   unsigned ElSize = VT.getVectorElementType().getSizeInBits();
3829   bool Result = (Index * ElSize) % vecWidth == 0;
3830
3831   return Result;
3832 }
3833
3834 bool X86::isVINSERT128Index(SDNode *N) {
3835   return isVINSERTIndex(N, 128);
3836 }
3837
3838 bool X86::isVINSERT256Index(SDNode *N) {
3839   return isVINSERTIndex(N, 256);
3840 }
3841
3842 bool X86::isVEXTRACT128Index(SDNode *N) {
3843   return isVEXTRACTIndex(N, 128);
3844 }
3845
3846 bool X86::isVEXTRACT256Index(SDNode *N) {
3847   return isVEXTRACTIndex(N, 256);
3848 }
3849
3850 static unsigned getExtractVEXTRACTImmediate(SDNode *N, unsigned vecWidth) {
3851   assert((vecWidth == 128 || vecWidth == 256) && "Unsupported vector width");
3852   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
3853     llvm_unreachable("Illegal extract subvector for VEXTRACT");
3854
3855   uint64_t Index =
3856     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
3857
3858   MVT VecVT = N->getOperand(0).getSimpleValueType();
3859   MVT ElVT = VecVT.getVectorElementType();
3860
3861   unsigned NumElemsPerChunk = vecWidth / ElVT.getSizeInBits();
3862   return Index / NumElemsPerChunk;
3863 }
3864
3865 static unsigned getInsertVINSERTImmediate(SDNode *N, unsigned vecWidth) {
3866   assert((vecWidth == 128 || vecWidth == 256) && "Unsupported vector width");
3867   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
3868     llvm_unreachable("Illegal insert subvector for VINSERT");
3869
3870   uint64_t Index =
3871     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
3872
3873   MVT VecVT = N->getSimpleValueType(0);
3874   MVT ElVT = VecVT.getVectorElementType();
3875
3876   unsigned NumElemsPerChunk = vecWidth / ElVT.getSizeInBits();
3877   return Index / NumElemsPerChunk;
3878 }
3879
3880 /// getExtractVEXTRACT128Immediate - Return the appropriate immediate
3881 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF128
3882 /// and VINSERTI128 instructions.
3883 unsigned X86::getExtractVEXTRACT128Immediate(SDNode *N) {
3884   return getExtractVEXTRACTImmediate(N, 128);
3885 }
3886
3887 /// getExtractVEXTRACT256Immediate - Return the appropriate immediate
3888 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF64x4
3889 /// and VINSERTI64x4 instructions.
3890 unsigned X86::getExtractVEXTRACT256Immediate(SDNode *N) {
3891   return getExtractVEXTRACTImmediate(N, 256);
3892 }
3893
3894 /// getInsertVINSERT128Immediate - Return the appropriate immediate
3895 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF128
3896 /// and VINSERTI128 instructions.
3897 unsigned X86::getInsertVINSERT128Immediate(SDNode *N) {
3898   return getInsertVINSERTImmediate(N, 128);
3899 }
3900
3901 /// getInsertVINSERT256Immediate - Return the appropriate immediate
3902 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF46x4
3903 /// and VINSERTI64x4 instructions.
3904 unsigned X86::getInsertVINSERT256Immediate(SDNode *N) {
3905   return getInsertVINSERTImmediate(N, 256);
3906 }
3907
3908 /// isZero - Returns true if Elt is a constant integer zero
3909 static bool isZero(SDValue V) {
3910   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
3911   return C && C->isNullValue();
3912 }
3913
3914 /// isZeroNode - Returns true if Elt is a constant zero or a floating point
3915 /// constant +0.0.
3916 bool X86::isZeroNode(SDValue Elt) {
3917   if (isZero(Elt))
3918     return true;
3919   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Elt))
3920     return CFP->getValueAPF().isPosZero();
3921   return false;
3922 }
3923
3924 /// getZeroVector - Returns a vector of specified type with all zero elements.
3925 ///
3926 static SDValue getZeroVector(EVT VT, const X86Subtarget *Subtarget,
3927                              SelectionDAG &DAG, SDLoc dl) {
3928   assert(VT.isVector() && "Expected a vector type");
3929
3930   // Always build SSE zero vectors as <4 x i32> bitcasted
3931   // to their dest type. This ensures they get CSE'd.
3932   SDValue Vec;
3933   if (VT.is128BitVector()) {  // SSE
3934     if (Subtarget->hasSSE2()) {  // SSE2
3935       SDValue Cst = DAG.getConstant(0, MVT::i32);
3936       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
3937     } else { // SSE1
3938       SDValue Cst = DAG.getConstantFP(+0.0, MVT::f32);
3939       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4f32, Cst, Cst, Cst, Cst);
3940     }
3941   } else if (VT.is256BitVector()) { // AVX
3942     if (Subtarget->hasInt256()) { // AVX2
3943       SDValue Cst = DAG.getConstant(0, MVT::i32);
3944       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
3945       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops);
3946     } else {
3947       // 256-bit logic and arithmetic instructions in AVX are all
3948       // floating-point, no support for integer ops. Emit fp zeroed vectors.
3949       SDValue Cst = DAG.getConstantFP(+0.0, MVT::f32);
3950       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
3951       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8f32, Ops);
3952     }
3953   } else if (VT.is512BitVector()) { // AVX-512
3954       SDValue Cst = DAG.getConstant(0, MVT::i32);
3955       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst,
3956                         Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
3957       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v16i32, Ops);
3958   } else if (VT.getScalarType() == MVT::i1) {
3959
3960     assert((Subtarget->hasBWI() || VT.getVectorNumElements() <= 16)
3961             && "Unexpected vector type");
3962     assert((Subtarget->hasVLX() || VT.getVectorNumElements() >= 8)
3963             && "Unexpected vector type");
3964     SDValue Cst = DAG.getConstant(0, MVT::i1);
3965     SmallVector<SDValue, 64> Ops(VT.getVectorNumElements(), Cst);
3966     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
3967   } else
3968     llvm_unreachable("Unexpected vector type");
3969
3970   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
3971 }
3972
3973 static SDValue ExtractSubVector(SDValue Vec, unsigned IdxVal,
3974                                 SelectionDAG &DAG, SDLoc dl,
3975                                 unsigned vectorWidth) {
3976   assert((vectorWidth == 128 || vectorWidth == 256) &&
3977          "Unsupported vector width");
3978   EVT VT = Vec.getValueType();
3979   EVT ElVT = VT.getVectorElementType();
3980   unsigned Factor = VT.getSizeInBits()/vectorWidth;
3981   EVT ResultVT = EVT::getVectorVT(*DAG.getContext(), ElVT,
3982                                   VT.getVectorNumElements()/Factor);
3983
3984   // Extract from UNDEF is UNDEF.
3985   if (Vec.getOpcode() == ISD::UNDEF)
3986     return DAG.getUNDEF(ResultVT);
3987
3988   // Extract the relevant vectorWidth bits.  Generate an EXTRACT_SUBVECTOR
3989   unsigned ElemsPerChunk = vectorWidth / ElVT.getSizeInBits();
3990
3991   // This is the index of the first element of the vectorWidth-bit chunk
3992   // we want.
3993   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits()) / vectorWidth)
3994                                * ElemsPerChunk);
3995
3996   // If the input is a buildvector just emit a smaller one.
3997   if (Vec.getOpcode() == ISD::BUILD_VECTOR)
3998     return DAG.getNode(ISD::BUILD_VECTOR, dl, ResultVT,
3999                        makeArrayRef(Vec->op_begin() + NormalizedIdxVal,
4000                                     ElemsPerChunk));
4001
4002   SDValue VecIdx = DAG.getIntPtrConstant(NormalizedIdxVal);
4003   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec, VecIdx);
4004 }
4005
4006 /// Generate a DAG to grab 128-bits from a vector > 128 bits.  This
4007 /// sets things up to match to an AVX VEXTRACTF128 / VEXTRACTI128
4008 /// or AVX-512 VEXTRACTF32x4 / VEXTRACTI32x4
4009 /// instructions or a simple subregister reference. Idx is an index in the
4010 /// 128 bits we want.  It need not be aligned to a 128-bit boundary.  That makes
4011 /// lowering EXTRACT_VECTOR_ELT operations easier.
4012 static SDValue Extract128BitVector(SDValue Vec, unsigned IdxVal,
4013                                    SelectionDAG &DAG, SDLoc dl) {
4014   assert((Vec.getValueType().is256BitVector() ||
4015           Vec.getValueType().is512BitVector()) && "Unexpected vector size!");
4016   return ExtractSubVector(Vec, IdxVal, DAG, dl, 128);
4017 }
4018
4019 /// Generate a DAG to grab 256-bits from a 512-bit vector.
4020 static SDValue Extract256BitVector(SDValue Vec, unsigned IdxVal,
4021                                    SelectionDAG &DAG, SDLoc dl) {
4022   assert(Vec.getValueType().is512BitVector() && "Unexpected vector size!");
4023   return ExtractSubVector(Vec, IdxVal, DAG, dl, 256);
4024 }
4025
4026 static SDValue InsertSubVector(SDValue Result, SDValue Vec,
4027                                unsigned IdxVal, SelectionDAG &DAG,
4028                                SDLoc dl, unsigned vectorWidth) {
4029   assert((vectorWidth == 128 || vectorWidth == 256) &&
4030          "Unsupported vector width");
4031   // Inserting UNDEF is Result
4032   if (Vec.getOpcode() == ISD::UNDEF)
4033     return Result;
4034   EVT VT = Vec.getValueType();
4035   EVT ElVT = VT.getVectorElementType();
4036   EVT ResultVT = Result.getValueType();
4037
4038   // Insert the relevant vectorWidth bits.
4039   unsigned ElemsPerChunk = vectorWidth/ElVT.getSizeInBits();
4040
4041   // This is the index of the first element of the vectorWidth-bit chunk
4042   // we want.
4043   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits())/vectorWidth)
4044                                * ElemsPerChunk);
4045
4046   SDValue VecIdx = DAG.getIntPtrConstant(NormalizedIdxVal);
4047   return DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec, VecIdx);
4048 }
4049
4050 /// Generate a DAG to put 128-bits into a vector > 128 bits.  This
4051 /// sets things up to match to an AVX VINSERTF128/VINSERTI128 or
4052 /// AVX-512 VINSERTF32x4/VINSERTI32x4 instructions or a
4053 /// simple superregister reference.  Idx is an index in the 128 bits
4054 /// we want.  It need not be aligned to a 128-bit boundary.  That makes
4055 /// lowering INSERT_VECTOR_ELT operations easier.
4056 static SDValue Insert128BitVector(SDValue Result, SDValue Vec, unsigned IdxVal,
4057                                   SelectionDAG &DAG, SDLoc dl) {
4058   assert(Vec.getValueType().is128BitVector() && "Unexpected vector size!");
4059
4060   // For insertion into the zero index (low half) of a 256-bit vector, it is
4061   // more efficient to generate a blend with immediate instead of an insert*128.
4062   // We are still creating an INSERT_SUBVECTOR below with an undef node to
4063   // extend the subvector to the size of the result vector. Make sure that
4064   // we are not recursing on that node by checking for undef here.
4065   if (IdxVal == 0 && Result.getValueType().is256BitVector() &&
4066       Result.getOpcode() != ISD::UNDEF) {
4067     EVT ResultVT = Result.getValueType();
4068     SDValue ZeroIndex = DAG.getIntPtrConstant(0);
4069     SDValue Undef = DAG.getUNDEF(ResultVT);
4070     SDValue Vec256 = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Undef,
4071                                  Vec, ZeroIndex);
4072
4073     // The blend instruction, and therefore its mask, depend on the data type.
4074     MVT ScalarType = ResultVT.getScalarType().getSimpleVT();
4075     if (ScalarType.isFloatingPoint()) {
4076       // Choose either vblendps (float) or vblendpd (double).
4077       unsigned ScalarSize = ScalarType.getSizeInBits();
4078       assert((ScalarSize == 64 || ScalarSize == 32) && "Unknown float type");
4079       unsigned MaskVal = (ScalarSize == 64) ? 0x03 : 0x0f;
4080       SDValue Mask = DAG.getConstant(MaskVal, MVT::i8);
4081       return DAG.getNode(X86ISD::BLENDI, dl, ResultVT, Result, Vec256, Mask);
4082     }
4083
4084     const X86Subtarget &Subtarget =
4085     static_cast<const X86Subtarget &>(DAG.getSubtarget());
4086
4087     // AVX2 is needed for 256-bit integer blend support.
4088     // Integers must be cast to 32-bit because there is only vpblendd;
4089     // vpblendw can't be used for this because it has a handicapped mask.
4090
4091     // If we don't have AVX2, then cast to float. Using a wrong domain blend
4092     // is still more efficient than using the wrong domain vinsertf128 that
4093     // will be created by InsertSubVector().
4094     MVT CastVT = Subtarget.hasAVX2() ? MVT::v8i32 : MVT::v8f32;
4095
4096     SDValue Mask = DAG.getConstant(0x0f, MVT::i8);
4097     Vec256 = DAG.getNode(ISD::BITCAST, dl, CastVT, Vec256);
4098     Vec256 = DAG.getNode(X86ISD::BLENDI, dl, CastVT, Result, Vec256, Mask);
4099     return DAG.getNode(ISD::BITCAST, dl, ResultVT, Vec256);
4100   }
4101
4102   return InsertSubVector(Result, Vec, IdxVal, DAG, dl, 128);
4103 }
4104
4105 static SDValue Insert256BitVector(SDValue Result, SDValue Vec, unsigned IdxVal,
4106                                   SelectionDAG &DAG, SDLoc dl) {
4107   assert(Vec.getValueType().is256BitVector() && "Unexpected vector size!");
4108   return InsertSubVector(Result, Vec, IdxVal, DAG, dl, 256);
4109 }
4110
4111 /// Concat two 128-bit vectors into a 256 bit vector using VINSERTF128
4112 /// instructions. This is used because creating CONCAT_VECTOR nodes of
4113 /// BUILD_VECTORS returns a larger BUILD_VECTOR while we're trying to lower
4114 /// large BUILD_VECTORS.
4115 static SDValue Concat128BitVectors(SDValue V1, SDValue V2, EVT VT,
4116                                    unsigned NumElems, SelectionDAG &DAG,
4117                                    SDLoc dl) {
4118   SDValue V = Insert128BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
4119   return Insert128BitVector(V, V2, NumElems/2, DAG, dl);
4120 }
4121
4122 static SDValue Concat256BitVectors(SDValue V1, SDValue V2, EVT VT,
4123                                    unsigned NumElems, SelectionDAG &DAG,
4124                                    SDLoc dl) {
4125   SDValue V = Insert256BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
4126   return Insert256BitVector(V, V2, NumElems/2, DAG, dl);
4127 }
4128
4129 /// getOnesVector - Returns a vector of specified type with all bits set.
4130 /// Always build ones vectors as <4 x i32> or <8 x i32>. For 256-bit types with
4131 /// no AVX2 supprt, use two <4 x i32> inserted in a <8 x i32> appropriately.
4132 /// Then bitcast to their original type, ensuring they get CSE'd.
4133 static SDValue getOnesVector(MVT VT, bool HasInt256, SelectionDAG &DAG,
4134                              SDLoc dl) {
4135   assert(VT.isVector() && "Expected a vector type");
4136
4137   SDValue Cst = DAG.getConstant(~0U, MVT::i32);
4138   SDValue Vec;
4139   if (VT.is256BitVector()) {
4140     if (HasInt256) { // AVX2
4141       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4142       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops);
4143     } else { // AVX
4144       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4145       Vec = Concat128BitVectors(Vec, Vec, MVT::v8i32, 8, DAG, dl);
4146     }
4147   } else if (VT.is128BitVector()) {
4148     Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4149   } else
4150     llvm_unreachable("Unexpected vector type");
4151
4152   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4153 }
4154
4155 /// getMOVLMask - Returns a vector_shuffle mask for an movs{s|d}, movd
4156 /// operation of specified width.
4157 static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1,
4158                        SDValue V2) {
4159   unsigned NumElems = VT.getVectorNumElements();
4160   SmallVector<int, 8> Mask;
4161   Mask.push_back(NumElems);
4162   for (unsigned i = 1; i != NumElems; ++i)
4163     Mask.push_back(i);
4164   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4165 }
4166
4167 /// getUnpackl - Returns a vector_shuffle node for an unpackl operation.
4168 static SDValue getUnpackl(SelectionDAG &DAG, SDLoc dl, MVT VT, SDValue V1,
4169                           SDValue V2) {
4170   unsigned NumElems = VT.getVectorNumElements();
4171   SmallVector<int, 8> Mask;
4172   for (unsigned i = 0, e = NumElems/2; i != e; ++i) {
4173     Mask.push_back(i);
4174     Mask.push_back(i + NumElems);
4175   }
4176   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4177 }
4178
4179 /// getUnpackh - Returns a vector_shuffle node for an unpackh operation.
4180 static SDValue getUnpackh(SelectionDAG &DAG, SDLoc dl, MVT VT, SDValue V1,
4181                           SDValue V2) {
4182   unsigned NumElems = VT.getVectorNumElements();
4183   SmallVector<int, 8> Mask;
4184   for (unsigned i = 0, Half = NumElems/2; i != Half; ++i) {
4185     Mask.push_back(i + Half);
4186     Mask.push_back(i + NumElems + Half);
4187   }
4188   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4189 }
4190
4191 /// getShuffleVectorZeroOrUndef - Return a vector_shuffle of the specified
4192 /// vector of zero or undef vector.  This produces a shuffle where the low
4193 /// element of V2 is swizzled into the zero/undef vector, landing at element
4194 /// Idx.  This produces a shuffle mask like 4,1,2,3 (idx=0) or  0,1,2,4 (idx=3).
4195 static SDValue getShuffleVectorZeroOrUndef(SDValue V2, unsigned Idx,
4196                                            bool IsZero,
4197                                            const X86Subtarget *Subtarget,
4198                                            SelectionDAG &DAG) {
4199   MVT VT = V2.getSimpleValueType();
4200   SDValue V1 = IsZero
4201     ? getZeroVector(VT, Subtarget, DAG, SDLoc(V2)) : DAG.getUNDEF(VT);
4202   unsigned NumElems = VT.getVectorNumElements();
4203   SmallVector<int, 16> MaskVec;
4204   for (unsigned i = 0; i != NumElems; ++i)
4205     // If this is the insertion idx, put the low elt of V2 here.
4206     MaskVec.push_back(i == Idx ? NumElems : i);
4207   return DAG.getVectorShuffle(VT, SDLoc(V2), V1, V2, &MaskVec[0]);
4208 }
4209
4210 /// getTargetShuffleMask - Calculates the shuffle mask corresponding to the
4211 /// target specific opcode. Returns true if the Mask could be calculated. Sets
4212 /// IsUnary to true if only uses one source. Note that this will set IsUnary for
4213 /// shuffles which use a single input multiple times, and in those cases it will
4214 /// adjust the mask to only have indices within that single input.
4215 static bool getTargetShuffleMask(SDNode *N, MVT VT,
4216                                  SmallVectorImpl<int> &Mask, bool &IsUnary) {
4217   unsigned NumElems = VT.getVectorNumElements();
4218   SDValue ImmN;
4219
4220   IsUnary = false;
4221   bool IsFakeUnary = false;
4222   switch(N->getOpcode()) {
4223   case X86ISD::BLENDI:
4224     ImmN = N->getOperand(N->getNumOperands()-1);
4225     DecodeBLENDMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4226     break;
4227   case X86ISD::SHUFP:
4228     ImmN = N->getOperand(N->getNumOperands()-1);
4229     DecodeSHUFPMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4230     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
4231     break;
4232   case X86ISD::UNPCKH:
4233     DecodeUNPCKHMask(VT, Mask);
4234     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
4235     break;
4236   case X86ISD::UNPCKL:
4237     DecodeUNPCKLMask(VT, Mask);
4238     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
4239     break;
4240   case X86ISD::MOVHLPS:
4241     DecodeMOVHLPSMask(NumElems, Mask);
4242     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
4243     break;
4244   case X86ISD::MOVLHPS:
4245     DecodeMOVLHPSMask(NumElems, Mask);
4246     IsUnary = IsFakeUnary = N->getOperand(0) == N->getOperand(1);
4247     break;
4248   case X86ISD::PALIGNR:
4249     ImmN = N->getOperand(N->getNumOperands()-1);
4250     DecodePALIGNRMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4251     break;
4252   case X86ISD::PSHUFD:
4253   case X86ISD::VPERMILPI:
4254     ImmN = N->getOperand(N->getNumOperands()-1);
4255     DecodePSHUFMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4256     IsUnary = true;
4257     break;
4258   case X86ISD::PSHUFHW:
4259     ImmN = N->getOperand(N->getNumOperands()-1);
4260     DecodePSHUFHWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4261     IsUnary = true;
4262     break;
4263   case X86ISD::PSHUFLW:
4264     ImmN = N->getOperand(N->getNumOperands()-1);
4265     DecodePSHUFLWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4266     IsUnary = true;
4267     break;
4268   case X86ISD::PSHUFB: {
4269     IsUnary = true;
4270     SDValue MaskNode = N->getOperand(1);
4271     while (MaskNode->getOpcode() == ISD::BITCAST)
4272       MaskNode = MaskNode->getOperand(0);
4273
4274     if (MaskNode->getOpcode() == ISD::BUILD_VECTOR) {
4275       // If we have a build-vector, then things are easy.
4276       EVT VT = MaskNode.getValueType();
4277       assert(VT.isVector() &&
4278              "Can't produce a non-vector with a build_vector!");
4279       if (!VT.isInteger())
4280         return false;
4281
4282       int NumBytesPerElement = VT.getVectorElementType().getSizeInBits() / 8;
4283
4284       SmallVector<uint64_t, 32> RawMask;
4285       for (int i = 0, e = MaskNode->getNumOperands(); i < e; ++i) {
4286         SDValue Op = MaskNode->getOperand(i);
4287         if (Op->getOpcode() == ISD::UNDEF) {
4288           RawMask.push_back((uint64_t)SM_SentinelUndef);
4289           continue;
4290         }
4291         auto *CN = dyn_cast<ConstantSDNode>(Op.getNode());
4292         if (!CN)
4293           return false;
4294         APInt MaskElement = CN->getAPIntValue();
4295
4296         // We now have to decode the element which could be any integer size and
4297         // extract each byte of it.
4298         for (int j = 0; j < NumBytesPerElement; ++j) {
4299           // Note that this is x86 and so always little endian: the low byte is
4300           // the first byte of the mask.
4301           RawMask.push_back(MaskElement.getLoBits(8).getZExtValue());
4302           MaskElement = MaskElement.lshr(8);
4303         }
4304       }
4305       DecodePSHUFBMask(RawMask, Mask);
4306       break;
4307     }
4308
4309     auto *MaskLoad = dyn_cast<LoadSDNode>(MaskNode);
4310     if (!MaskLoad)
4311       return false;
4312
4313     SDValue Ptr = MaskLoad->getBasePtr();
4314     if (Ptr->getOpcode() == X86ISD::Wrapper)
4315       Ptr = Ptr->getOperand(0);
4316
4317     auto *MaskCP = dyn_cast<ConstantPoolSDNode>(Ptr);
4318     if (!MaskCP || MaskCP->isMachineConstantPoolEntry())
4319       return false;
4320
4321     if (auto *C = dyn_cast<Constant>(MaskCP->getConstVal())) {
4322       DecodePSHUFBMask(C, Mask);
4323       if (Mask.empty())
4324         return false;
4325       break;
4326     }
4327
4328     return false;
4329   }
4330   case X86ISD::VPERMI:
4331     ImmN = N->getOperand(N->getNumOperands()-1);
4332     DecodeVPERMMask(cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4333     IsUnary = true;
4334     break;
4335   case X86ISD::MOVSS:
4336   case X86ISD::MOVSD:
4337     DecodeScalarMoveMask(VT, /* IsLoad */ false, Mask);
4338     break;
4339   case X86ISD::VPERM2X128:
4340     ImmN = N->getOperand(N->getNumOperands()-1);
4341     DecodeVPERM2X128Mask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4342     if (Mask.empty()) return false;
4343     break;
4344   case X86ISD::MOVSLDUP:
4345     DecodeMOVSLDUPMask(VT, Mask);
4346     IsUnary = true;
4347     break;
4348   case X86ISD::MOVSHDUP:
4349     DecodeMOVSHDUPMask(VT, Mask);
4350     IsUnary = true;
4351     break;
4352   case X86ISD::MOVDDUP:
4353     DecodeMOVDDUPMask(VT, Mask);
4354     IsUnary = true;
4355     break;
4356   case X86ISD::MOVLHPD:
4357   case X86ISD::MOVLPD:
4358   case X86ISD::MOVLPS:
4359     // Not yet implemented
4360     return false;
4361   default: llvm_unreachable("unknown target shuffle node");
4362   }
4363
4364   // If we have a fake unary shuffle, the shuffle mask is spread across two
4365   // inputs that are actually the same node. Re-map the mask to always point
4366   // into the first input.
4367   if (IsFakeUnary)
4368     for (int &M : Mask)
4369       if (M >= (int)Mask.size())
4370         M -= Mask.size();
4371
4372   return true;
4373 }
4374
4375 /// getShuffleScalarElt - Returns the scalar element that will make up the ith
4376 /// element of the result of the vector shuffle.
4377 static SDValue getShuffleScalarElt(SDNode *N, unsigned Index, SelectionDAG &DAG,
4378                                    unsigned Depth) {
4379   if (Depth == 6)
4380     return SDValue();  // Limit search depth.
4381
4382   SDValue V = SDValue(N, 0);
4383   EVT VT = V.getValueType();
4384   unsigned Opcode = V.getOpcode();
4385
4386   // Recurse into ISD::VECTOR_SHUFFLE node to find scalars.
4387   if (const ShuffleVectorSDNode *SV = dyn_cast<ShuffleVectorSDNode>(N)) {
4388     int Elt = SV->getMaskElt(Index);
4389
4390     if (Elt < 0)
4391       return DAG.getUNDEF(VT.getVectorElementType());
4392
4393     unsigned NumElems = VT.getVectorNumElements();
4394     SDValue NewV = (Elt < (int)NumElems) ? SV->getOperand(0)
4395                                          : SV->getOperand(1);
4396     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
4397   }
4398
4399   // Recurse into target specific vector shuffles to find scalars.
4400   if (isTargetShuffle(Opcode)) {
4401     MVT ShufVT = V.getSimpleValueType();
4402     unsigned NumElems = ShufVT.getVectorNumElements();
4403     SmallVector<int, 16> ShuffleMask;
4404     bool IsUnary;
4405
4406     if (!getTargetShuffleMask(N, ShufVT, ShuffleMask, IsUnary))
4407       return SDValue();
4408
4409     int Elt = ShuffleMask[Index];
4410     if (Elt < 0)
4411       return DAG.getUNDEF(ShufVT.getVectorElementType());
4412
4413     SDValue NewV = (Elt < (int)NumElems) ? N->getOperand(0)
4414                                          : N->getOperand(1);
4415     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
4416                                Depth+1);
4417   }
4418
4419   // Actual nodes that may contain scalar elements
4420   if (Opcode == ISD::BITCAST) {
4421     V = V.getOperand(0);
4422     EVT SrcVT = V.getValueType();
4423     unsigned NumElems = VT.getVectorNumElements();
4424
4425     if (!SrcVT.isVector() || SrcVT.getVectorNumElements() != NumElems)
4426       return SDValue();
4427   }
4428
4429   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR)
4430     return (Index == 0) ? V.getOperand(0)
4431                         : DAG.getUNDEF(VT.getVectorElementType());
4432
4433   if (V.getOpcode() == ISD::BUILD_VECTOR)
4434     return V.getOperand(Index);
4435
4436   return SDValue();
4437 }
4438
4439 /// LowerBuildVectorv16i8 - Custom lower build_vector of v16i8.
4440 ///
4441 static SDValue LowerBuildVectorv16i8(SDValue Op, unsigned NonZeros,
4442                                        unsigned NumNonZero, unsigned NumZero,
4443                                        SelectionDAG &DAG,
4444                                        const X86Subtarget* Subtarget,
4445                                        const TargetLowering &TLI) {
4446   if (NumNonZero > 8)
4447     return SDValue();
4448
4449   SDLoc dl(Op);
4450   SDValue V;
4451   bool First = true;
4452   for (unsigned i = 0; i < 16; ++i) {
4453     bool ThisIsNonZero = (NonZeros & (1 << i)) != 0;
4454     if (ThisIsNonZero && First) {
4455       if (NumZero)
4456         V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
4457       else
4458         V = DAG.getUNDEF(MVT::v8i16);
4459       First = false;
4460     }
4461
4462     if ((i & 1) != 0) {
4463       SDValue ThisElt, LastElt;
4464       bool LastIsNonZero = (NonZeros & (1 << (i-1))) != 0;
4465       if (LastIsNonZero) {
4466         LastElt = DAG.getNode(ISD::ZERO_EXTEND, dl,
4467                               MVT::i16, Op.getOperand(i-1));
4468       }
4469       if (ThisIsNonZero) {
4470         ThisElt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Op.getOperand(i));
4471         ThisElt = DAG.getNode(ISD::SHL, dl, MVT::i16,
4472                               ThisElt, DAG.getConstant(8, MVT::i8));
4473         if (LastIsNonZero)
4474           ThisElt = DAG.getNode(ISD::OR, dl, MVT::i16, ThisElt, LastElt);
4475       } else
4476         ThisElt = LastElt;
4477
4478       if (ThisElt.getNode())
4479         V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, V, ThisElt,
4480                         DAG.getIntPtrConstant(i/2));
4481     }
4482   }
4483
4484   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V);
4485 }
4486
4487 /// LowerBuildVectorv8i16 - Custom lower build_vector of v8i16.
4488 ///
4489 static SDValue LowerBuildVectorv8i16(SDValue Op, unsigned NonZeros,
4490                                      unsigned NumNonZero, unsigned NumZero,
4491                                      SelectionDAG &DAG,
4492                                      const X86Subtarget* Subtarget,
4493                                      const TargetLowering &TLI) {
4494   if (NumNonZero > 4)
4495     return SDValue();
4496
4497   SDLoc dl(Op);
4498   SDValue V;
4499   bool First = true;
4500   for (unsigned i = 0; i < 8; ++i) {
4501     bool isNonZero = (NonZeros & (1 << i)) != 0;
4502     if (isNonZero) {
4503       if (First) {
4504         if (NumZero)
4505           V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
4506         else
4507           V = DAG.getUNDEF(MVT::v8i16);
4508         First = false;
4509       }
4510       V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
4511                       MVT::v8i16, V, Op.getOperand(i),
4512                       DAG.getIntPtrConstant(i));
4513     }
4514   }
4515
4516   return V;
4517 }
4518
4519 /// LowerBuildVectorv4x32 - Custom lower build_vector of v4i32 or v4f32.
4520 static SDValue LowerBuildVectorv4x32(SDValue Op, SelectionDAG &DAG,
4521                                      const X86Subtarget *Subtarget,
4522                                      const TargetLowering &TLI) {
4523   // Find all zeroable elements.
4524   std::bitset<4> Zeroable;
4525   for (int i=0; i < 4; ++i) {
4526     SDValue Elt = Op->getOperand(i);
4527     Zeroable[i] = (Elt.getOpcode() == ISD::UNDEF || X86::isZeroNode(Elt));
4528   }
4529   assert(Zeroable.size() - Zeroable.count() > 1 &&
4530          "We expect at least two non-zero elements!");
4531
4532   // We only know how to deal with build_vector nodes where elements are either
4533   // zeroable or extract_vector_elt with constant index.
4534   SDValue FirstNonZero;
4535   unsigned FirstNonZeroIdx;
4536   for (unsigned i=0; i < 4; ++i) {
4537     if (Zeroable[i])
4538       continue;
4539     SDValue Elt = Op->getOperand(i);
4540     if (Elt.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
4541         !isa<ConstantSDNode>(Elt.getOperand(1)))
4542       return SDValue();
4543     // Make sure that this node is extracting from a 128-bit vector.
4544     MVT VT = Elt.getOperand(0).getSimpleValueType();
4545     if (!VT.is128BitVector())
4546       return SDValue();
4547     if (!FirstNonZero.getNode()) {
4548       FirstNonZero = Elt;
4549       FirstNonZeroIdx = i;
4550     }
4551   }
4552
4553   assert(FirstNonZero.getNode() && "Unexpected build vector of all zeros!");
4554   SDValue V1 = FirstNonZero.getOperand(0);
4555   MVT VT = V1.getSimpleValueType();
4556
4557   // See if this build_vector can be lowered as a blend with zero.
4558   SDValue Elt;
4559   unsigned EltMaskIdx, EltIdx;
4560   int Mask[4];
4561   for (EltIdx = 0; EltIdx < 4; ++EltIdx) {
4562     if (Zeroable[EltIdx]) {
4563       // The zero vector will be on the right hand side.
4564       Mask[EltIdx] = EltIdx+4;
4565       continue;
4566     }
4567
4568     Elt = Op->getOperand(EltIdx);
4569     // By construction, Elt is a EXTRACT_VECTOR_ELT with constant index.
4570     EltMaskIdx = cast<ConstantSDNode>(Elt.getOperand(1))->getZExtValue();
4571     if (Elt.getOperand(0) != V1 || EltMaskIdx != EltIdx)
4572       break;
4573     Mask[EltIdx] = EltIdx;
4574   }
4575
4576   if (EltIdx == 4) {
4577     // Let the shuffle legalizer deal with blend operations.
4578     SDValue VZero = getZeroVector(VT, Subtarget, DAG, SDLoc(Op));
4579     if (V1.getSimpleValueType() != VT)
4580       V1 = DAG.getNode(ISD::BITCAST, SDLoc(V1), VT, V1);
4581     return DAG.getVectorShuffle(VT, SDLoc(V1), V1, VZero, &Mask[0]);
4582   }
4583
4584   // See if we can lower this build_vector to a INSERTPS.
4585   if (!Subtarget->hasSSE41())
4586     return SDValue();
4587
4588   SDValue V2 = Elt.getOperand(0);
4589   if (Elt == FirstNonZero && EltIdx == FirstNonZeroIdx)
4590     V1 = SDValue();
4591
4592   bool CanFold = true;
4593   for (unsigned i = EltIdx + 1; i < 4 && CanFold; ++i) {
4594     if (Zeroable[i])
4595       continue;
4596
4597     SDValue Current = Op->getOperand(i);
4598     SDValue SrcVector = Current->getOperand(0);
4599     if (!V1.getNode())
4600       V1 = SrcVector;
4601     CanFold = SrcVector == V1 &&
4602       cast<ConstantSDNode>(Current.getOperand(1))->getZExtValue() == i;
4603   }
4604
4605   if (!CanFold)
4606     return SDValue();
4607
4608   assert(V1.getNode() && "Expected at least two non-zero elements!");
4609   if (V1.getSimpleValueType() != MVT::v4f32)
4610     V1 = DAG.getNode(ISD::BITCAST, SDLoc(V1), MVT::v4f32, V1);
4611   if (V2.getSimpleValueType() != MVT::v4f32)
4612     V2 = DAG.getNode(ISD::BITCAST, SDLoc(V2), MVT::v4f32, V2);
4613
4614   // Ok, we can emit an INSERTPS instruction.
4615   unsigned ZMask = Zeroable.to_ulong();
4616
4617   unsigned InsertPSMask = EltMaskIdx << 6 | EltIdx << 4 | ZMask;
4618   assert((InsertPSMask & ~0xFFu) == 0 && "Invalid mask!");
4619   SDValue Result = DAG.getNode(X86ISD::INSERTPS, SDLoc(Op), MVT::v4f32, V1, V2,
4620                                DAG.getIntPtrConstant(InsertPSMask));
4621   return DAG.getNode(ISD::BITCAST, SDLoc(Op), VT, Result);
4622 }
4623
4624 /// Return a vector logical shift node.
4625 static SDValue getVShift(bool isLeft, EVT VT, SDValue SrcOp,
4626                          unsigned NumBits, SelectionDAG &DAG,
4627                          const TargetLowering &TLI, SDLoc dl) {
4628   assert(VT.is128BitVector() && "Unknown type for VShift");
4629   MVT ShVT = MVT::v2i64;
4630   unsigned Opc = isLeft ? X86ISD::VSHLDQ : X86ISD::VSRLDQ;
4631   SrcOp = DAG.getNode(ISD::BITCAST, dl, ShVT, SrcOp);
4632   MVT ScalarShiftTy = TLI.getScalarShiftAmountTy(SrcOp.getValueType());
4633   assert(NumBits % 8 == 0 && "Only support byte sized shifts");
4634   SDValue ShiftVal = DAG.getConstant(NumBits/8, ScalarShiftTy);
4635   return DAG.getNode(ISD::BITCAST, dl, VT,
4636                      DAG.getNode(Opc, dl, ShVT, SrcOp, ShiftVal));
4637 }
4638
4639 static SDValue
4640 LowerAsSplatVectorLoad(SDValue SrcOp, MVT VT, SDLoc dl, SelectionDAG &DAG) {
4641
4642   // Check if the scalar load can be widened into a vector load. And if
4643   // the address is "base + cst" see if the cst can be "absorbed" into
4644   // the shuffle mask.
4645   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(SrcOp)) {
4646     SDValue Ptr = LD->getBasePtr();
4647     if (!ISD::isNormalLoad(LD) || LD->isVolatile())
4648       return SDValue();
4649     EVT PVT = LD->getValueType(0);
4650     if (PVT != MVT::i32 && PVT != MVT::f32)
4651       return SDValue();
4652
4653     int FI = -1;
4654     int64_t Offset = 0;
4655     if (FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr)) {
4656       FI = FINode->getIndex();
4657       Offset = 0;
4658     } else if (DAG.isBaseWithConstantOffset(Ptr) &&
4659                isa<FrameIndexSDNode>(Ptr.getOperand(0))) {
4660       FI = cast<FrameIndexSDNode>(Ptr.getOperand(0))->getIndex();
4661       Offset = Ptr.getConstantOperandVal(1);
4662       Ptr = Ptr.getOperand(0);
4663     } else {
4664       return SDValue();
4665     }
4666
4667     // FIXME: 256-bit vector instructions don't require a strict alignment,
4668     // improve this code to support it better.
4669     unsigned RequiredAlign = VT.getSizeInBits()/8;
4670     SDValue Chain = LD->getChain();
4671     // Make sure the stack object alignment is at least 16 or 32.
4672     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
4673     if (DAG.InferPtrAlignment(Ptr) < RequiredAlign) {
4674       if (MFI->isFixedObjectIndex(FI)) {
4675         // Can't change the alignment. FIXME: It's possible to compute
4676         // the exact stack offset and reference FI + adjust offset instead.
4677         // If someone *really* cares about this. That's the way to implement it.
4678         return SDValue();
4679       } else {
4680         MFI->setObjectAlignment(FI, RequiredAlign);
4681       }
4682     }
4683
4684     // (Offset % 16 or 32) must be multiple of 4. Then address is then
4685     // Ptr + (Offset & ~15).
4686     if (Offset < 0)
4687       return SDValue();
4688     if ((Offset % RequiredAlign) & 3)
4689       return SDValue();
4690     int64_t StartOffset = Offset & ~(RequiredAlign-1);
4691     if (StartOffset)
4692       Ptr = DAG.getNode(ISD::ADD, SDLoc(Ptr), Ptr.getValueType(),
4693                         Ptr,DAG.getConstant(StartOffset, Ptr.getValueType()));
4694
4695     int EltNo = (Offset - StartOffset) >> 2;
4696     unsigned NumElems = VT.getVectorNumElements();
4697
4698     EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
4699     SDValue V1 = DAG.getLoad(NVT, dl, Chain, Ptr,
4700                              LD->getPointerInfo().getWithOffset(StartOffset),
4701                              false, false, false, 0);
4702
4703     SmallVector<int, 8> Mask(NumElems, EltNo);
4704
4705     return DAG.getVectorShuffle(NVT, dl, V1, DAG.getUNDEF(NVT), &Mask[0]);
4706   }
4707
4708   return SDValue();
4709 }
4710
4711 /// Given the initializing elements 'Elts' of a vector of type 'VT', see if the
4712 /// elements can be replaced by a single large load which has the same value as
4713 /// a build_vector or insert_subvector whose loaded operands are 'Elts'.
4714 ///
4715 /// Example: <load i32 *a, load i32 *a+4, undef, undef> -> zextload a
4716 ///
4717 /// FIXME: we'd also like to handle the case where the last elements are zero
4718 /// rather than undef via VZEXT_LOAD, but we do not detect that case today.
4719 /// There's even a handy isZeroNode for that purpose.
4720 static SDValue EltsFromConsecutiveLoads(EVT VT, ArrayRef<SDValue> Elts,
4721                                         SDLoc &DL, SelectionDAG &DAG,
4722                                         bool isAfterLegalize) {
4723   unsigned NumElems = Elts.size();
4724
4725   LoadSDNode *LDBase = nullptr;
4726   unsigned LastLoadedElt = -1U;
4727
4728   // For each element in the initializer, see if we've found a load or an undef.
4729   // If we don't find an initial load element, or later load elements are
4730   // non-consecutive, bail out.
4731   for (unsigned i = 0; i < NumElems; ++i) {
4732     SDValue Elt = Elts[i];
4733     // Look through a bitcast.
4734     if (Elt.getNode() && Elt.getOpcode() == ISD::BITCAST)
4735       Elt = Elt.getOperand(0);
4736     if (!Elt.getNode() ||
4737         (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
4738       return SDValue();
4739     if (!LDBase) {
4740       if (Elt.getNode()->getOpcode() == ISD::UNDEF)
4741         return SDValue();
4742       LDBase = cast<LoadSDNode>(Elt.getNode());
4743       LastLoadedElt = i;
4744       continue;
4745     }
4746     if (Elt.getOpcode() == ISD::UNDEF)
4747       continue;
4748
4749     LoadSDNode *LD = cast<LoadSDNode>(Elt);
4750     EVT LdVT = Elt.getValueType();
4751     // Each loaded element must be the correct fractional portion of the
4752     // requested vector load.
4753     if (LdVT.getSizeInBits() != VT.getSizeInBits() / NumElems)
4754       return SDValue();
4755     if (!DAG.isConsecutiveLoad(LD, LDBase, LdVT.getSizeInBits() / 8, i))
4756       return SDValue();
4757     LastLoadedElt = i;
4758   }
4759
4760   // If we have found an entire vector of loads and undefs, then return a large
4761   // load of the entire vector width starting at the base pointer.  If we found
4762   // consecutive loads for the low half, generate a vzext_load node.
4763   if (LastLoadedElt == NumElems - 1) {
4764     assert(LDBase && "Did not find base load for merging consecutive loads");
4765     EVT EltVT = LDBase->getValueType(0);
4766     // Ensure that the input vector size for the merged loads matches the
4767     // cumulative size of the input elements.
4768     if (VT.getSizeInBits() != EltVT.getSizeInBits() * NumElems)
4769       return SDValue();
4770
4771     if (isAfterLegalize &&
4772         !DAG.getTargetLoweringInfo().isOperationLegal(ISD::LOAD, VT))
4773       return SDValue();
4774
4775     SDValue NewLd = SDValue();
4776
4777     NewLd = DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
4778                         LDBase->getPointerInfo(), LDBase->isVolatile(),
4779                         LDBase->isNonTemporal(), LDBase->isInvariant(),
4780                         LDBase->getAlignment());
4781
4782     if (LDBase->hasAnyUseOfValue(1)) {
4783       SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
4784                                      SDValue(LDBase, 1),
4785                                      SDValue(NewLd.getNode(), 1));
4786       DAG.ReplaceAllUsesOfValueWith(SDValue(LDBase, 1), NewChain);
4787       DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
4788                              SDValue(NewLd.getNode(), 1));
4789     }
4790
4791     return NewLd;
4792   }
4793
4794   //TODO: The code below fires only for for loading the low v2i32 / v2f32
4795   //of a v4i32 / v4f32. It's probably worth generalizing.
4796   EVT EltVT = VT.getVectorElementType();
4797   if (NumElems == 4 && LastLoadedElt == 1 && (EltVT.getSizeInBits() == 32) &&
4798       DAG.getTargetLoweringInfo().isTypeLegal(MVT::v2i64)) {
4799     SDVTList Tys = DAG.getVTList(MVT::v2i64, MVT::Other);
4800     SDValue Ops[] = { LDBase->getChain(), LDBase->getBasePtr() };
4801     SDValue ResNode =
4802         DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, DL, Tys, Ops, MVT::i64,
4803                                 LDBase->getPointerInfo(),
4804                                 LDBase->getAlignment(),
4805                                 false/*isVolatile*/, true/*ReadMem*/,
4806                                 false/*WriteMem*/);
4807
4808     // Make sure the newly-created LOAD is in the same position as LDBase in
4809     // terms of dependency. We create a TokenFactor for LDBase and ResNode, and
4810     // update uses of LDBase's output chain to use the TokenFactor.
4811     if (LDBase->hasAnyUseOfValue(1)) {
4812       SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
4813                              SDValue(LDBase, 1), SDValue(ResNode.getNode(), 1));
4814       DAG.ReplaceAllUsesOfValueWith(SDValue(LDBase, 1), NewChain);
4815       DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
4816                              SDValue(ResNode.getNode(), 1));
4817     }
4818
4819     return DAG.getNode(ISD::BITCAST, DL, VT, ResNode);
4820   }
4821   return SDValue();
4822 }
4823
4824 /// LowerVectorBroadcast - Attempt to use the vbroadcast instruction
4825 /// to generate a splat value for the following cases:
4826 /// 1. A splat BUILD_VECTOR which uses a single scalar load, or a constant.
4827 /// 2. A splat shuffle which uses a scalar_to_vector node which comes from
4828 /// a scalar load, or a constant.
4829 /// The VBROADCAST node is returned when a pattern is found,
4830 /// or SDValue() otherwise.
4831 static SDValue LowerVectorBroadcast(SDValue Op, const X86Subtarget* Subtarget,
4832                                     SelectionDAG &DAG) {
4833   // VBROADCAST requires AVX.
4834   // TODO: Splats could be generated for non-AVX CPUs using SSE
4835   // instructions, but there's less potential gain for only 128-bit vectors.
4836   if (!Subtarget->hasAVX())
4837     return SDValue();
4838
4839   MVT VT = Op.getSimpleValueType();
4840   SDLoc dl(Op);
4841
4842   assert((VT.is128BitVector() || VT.is256BitVector() || VT.is512BitVector()) &&
4843          "Unsupported vector type for broadcast.");
4844
4845   SDValue Ld;
4846   bool ConstSplatVal;
4847
4848   switch (Op.getOpcode()) {
4849     default:
4850       // Unknown pattern found.
4851       return SDValue();
4852
4853     case ISD::BUILD_VECTOR: {
4854       auto *BVOp = cast<BuildVectorSDNode>(Op.getNode());
4855       BitVector UndefElements;
4856       SDValue Splat = BVOp->getSplatValue(&UndefElements);
4857
4858       // We need a splat of a single value to use broadcast, and it doesn't
4859       // make any sense if the value is only in one element of the vector.
4860       if (!Splat || (VT.getVectorNumElements() - UndefElements.count()) <= 1)
4861         return SDValue();
4862
4863       Ld = Splat;
4864       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
4865                        Ld.getOpcode() == ISD::ConstantFP);
4866
4867       // Make sure that all of the users of a non-constant load are from the
4868       // BUILD_VECTOR node.
4869       if (!ConstSplatVal && !BVOp->isOnlyUserOf(Ld.getNode()))
4870         return SDValue();
4871       break;
4872     }
4873
4874     case ISD::VECTOR_SHUFFLE: {
4875       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
4876
4877       // Shuffles must have a splat mask where the first element is
4878       // broadcasted.
4879       if ((!SVOp->isSplat()) || SVOp->getMaskElt(0) != 0)
4880         return SDValue();
4881
4882       SDValue Sc = Op.getOperand(0);
4883       if (Sc.getOpcode() != ISD::SCALAR_TO_VECTOR &&
4884           Sc.getOpcode() != ISD::BUILD_VECTOR) {
4885
4886         if (!Subtarget->hasInt256())
4887           return SDValue();
4888
4889         // Use the register form of the broadcast instruction available on AVX2.
4890         if (VT.getSizeInBits() >= 256)
4891           Sc = Extract128BitVector(Sc, 0, DAG, dl);
4892         return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Sc);
4893       }
4894
4895       Ld = Sc.getOperand(0);
4896       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
4897                        Ld.getOpcode() == ISD::ConstantFP);
4898
4899       // The scalar_to_vector node and the suspected
4900       // load node must have exactly one user.
4901       // Constants may have multiple users.
4902
4903       // AVX-512 has register version of the broadcast
4904       bool hasRegVer = Subtarget->hasAVX512() && VT.is512BitVector() &&
4905         Ld.getValueType().getSizeInBits() >= 32;
4906       if (!ConstSplatVal && ((!Sc.hasOneUse() || !Ld.hasOneUse()) &&
4907           !hasRegVer))
4908         return SDValue();
4909       break;
4910     }
4911   }
4912
4913   unsigned ScalarSize = Ld.getValueType().getSizeInBits();
4914   bool IsGE256 = (VT.getSizeInBits() >= 256);
4915
4916   // When optimizing for size, generate up to 5 extra bytes for a broadcast
4917   // instruction to save 8 or more bytes of constant pool data.
4918   // TODO: If multiple splats are generated to load the same constant,
4919   // it may be detrimental to overall size. There needs to be a way to detect
4920   // that condition to know if this is truly a size win.
4921   const Function *F = DAG.getMachineFunction().getFunction();
4922   bool OptForSize = F->hasFnAttribute(Attribute::OptimizeForSize);
4923
4924   // Handle broadcasting a single constant scalar from the constant pool
4925   // into a vector.
4926   // On Sandybridge (no AVX2), it is still better to load a constant vector
4927   // from the constant pool and not to broadcast it from a scalar.
4928   // But override that restriction when optimizing for size.
4929   // TODO: Check if splatting is recommended for other AVX-capable CPUs.
4930   if (ConstSplatVal && (Subtarget->hasAVX2() || OptForSize)) {
4931     EVT CVT = Ld.getValueType();
4932     assert(!CVT.isVector() && "Must not broadcast a vector type");
4933
4934     // Splat f32, i32, v4f64, v4i64 in all cases with AVX2.
4935     // For size optimization, also splat v2f64 and v2i64, and for size opt
4936     // with AVX2, also splat i8 and i16.
4937     // With pattern matching, the VBROADCAST node may become a VMOVDDUP.
4938     if (ScalarSize == 32 || (IsGE256 && ScalarSize == 64) ||
4939         (OptForSize && (ScalarSize == 64 || Subtarget->hasAVX2()))) {
4940       const Constant *C = nullptr;
4941       if (ConstantSDNode *CI = dyn_cast<ConstantSDNode>(Ld))
4942         C = CI->getConstantIntValue();
4943       else if (ConstantFPSDNode *CF = dyn_cast<ConstantFPSDNode>(Ld))
4944         C = CF->getConstantFPValue();
4945
4946       assert(C && "Invalid constant type");
4947
4948       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
4949       SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
4950       unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
4951       Ld = DAG.getLoad(CVT, dl, DAG.getEntryNode(), CP,
4952                        MachinePointerInfo::getConstantPool(),
4953                        false, false, false, Alignment);
4954
4955       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
4956     }
4957   }
4958
4959   bool IsLoad = ISD::isNormalLoad(Ld.getNode());
4960
4961   // Handle AVX2 in-register broadcasts.
4962   if (!IsLoad && Subtarget->hasInt256() &&
4963       (ScalarSize == 32 || (IsGE256 && ScalarSize == 64)))
4964     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
4965
4966   // The scalar source must be a normal load.
4967   if (!IsLoad)
4968     return SDValue();
4969
4970   if (ScalarSize == 32 || (IsGE256 && ScalarSize == 64) ||
4971       (Subtarget->hasVLX() && ScalarSize == 64))
4972     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
4973
4974   // The integer check is needed for the 64-bit into 128-bit so it doesn't match
4975   // double since there is no vbroadcastsd xmm
4976   if (Subtarget->hasInt256() && Ld.getValueType().isInteger()) {
4977     if (ScalarSize == 8 || ScalarSize == 16 || ScalarSize == 64)
4978       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
4979   }
4980
4981   // Unsupported broadcast.
4982   return SDValue();
4983 }
4984
4985 /// \brief For an EXTRACT_VECTOR_ELT with a constant index return the real
4986 /// underlying vector and index.
4987 ///
4988 /// Modifies \p ExtractedFromVec to the real vector and returns the real
4989 /// index.
4990 static int getUnderlyingExtractedFromVec(SDValue &ExtractedFromVec,
4991                                          SDValue ExtIdx) {
4992   int Idx = cast<ConstantSDNode>(ExtIdx)->getZExtValue();
4993   if (!isa<ShuffleVectorSDNode>(ExtractedFromVec))
4994     return Idx;
4995
4996   // For 256-bit vectors, LowerEXTRACT_VECTOR_ELT_SSE4 may have already
4997   // lowered this:
4998   //   (extract_vector_elt (v8f32 %vreg1), Constant<6>)
4999   // to:
5000   //   (extract_vector_elt (vector_shuffle<2,u,u,u>
5001   //                           (extract_subvector (v8f32 %vreg0), Constant<4>),
5002   //                           undef)
5003   //                       Constant<0>)
5004   // In this case the vector is the extract_subvector expression and the index
5005   // is 2, as specified by the shuffle.
5006   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(ExtractedFromVec);
5007   SDValue ShuffleVec = SVOp->getOperand(0);
5008   MVT ShuffleVecVT = ShuffleVec.getSimpleValueType();
5009   assert(ShuffleVecVT.getVectorElementType() ==
5010          ExtractedFromVec.getSimpleValueType().getVectorElementType());
5011
5012   int ShuffleIdx = SVOp->getMaskElt(Idx);
5013   if (isUndefOrInRange(ShuffleIdx, 0, ShuffleVecVT.getVectorNumElements())) {
5014     ExtractedFromVec = ShuffleVec;
5015     return ShuffleIdx;
5016   }
5017   return Idx;
5018 }
5019
5020 static SDValue buildFromShuffleMostly(SDValue Op, SelectionDAG &DAG) {
5021   MVT VT = Op.getSimpleValueType();
5022
5023   // Skip if insert_vec_elt is not supported.
5024   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
5025   if (!TLI.isOperationLegalOrCustom(ISD::INSERT_VECTOR_ELT, VT))
5026     return SDValue();
5027
5028   SDLoc DL(Op);
5029   unsigned NumElems = Op.getNumOperands();
5030
5031   SDValue VecIn1;
5032   SDValue VecIn2;
5033   SmallVector<unsigned, 4> InsertIndices;
5034   SmallVector<int, 8> Mask(NumElems, -1);
5035
5036   for (unsigned i = 0; i != NumElems; ++i) {
5037     unsigned Opc = Op.getOperand(i).getOpcode();
5038
5039     if (Opc == ISD::UNDEF)
5040       continue;
5041
5042     if (Opc != ISD::EXTRACT_VECTOR_ELT) {
5043       // Quit if more than 1 elements need inserting.
5044       if (InsertIndices.size() > 1)
5045         return SDValue();
5046
5047       InsertIndices.push_back(i);
5048       continue;
5049     }
5050
5051     SDValue ExtractedFromVec = Op.getOperand(i).getOperand(0);
5052     SDValue ExtIdx = Op.getOperand(i).getOperand(1);
5053     // Quit if non-constant index.
5054     if (!isa<ConstantSDNode>(ExtIdx))
5055       return SDValue();
5056     int Idx = getUnderlyingExtractedFromVec(ExtractedFromVec, ExtIdx);
5057
5058     // Quit if extracted from vector of different type.
5059     if (ExtractedFromVec.getValueType() != VT)
5060       return SDValue();
5061
5062     if (!VecIn1.getNode())
5063       VecIn1 = ExtractedFromVec;
5064     else if (VecIn1 != ExtractedFromVec) {
5065       if (!VecIn2.getNode())
5066         VecIn2 = ExtractedFromVec;
5067       else if (VecIn2 != ExtractedFromVec)
5068         // Quit if more than 2 vectors to shuffle
5069         return SDValue();
5070     }
5071
5072     if (ExtractedFromVec == VecIn1)
5073       Mask[i] = Idx;
5074     else if (ExtractedFromVec == VecIn2)
5075       Mask[i] = Idx + NumElems;
5076   }
5077
5078   if (!VecIn1.getNode())
5079     return SDValue();
5080
5081   VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
5082   SDValue NV = DAG.getVectorShuffle(VT, DL, VecIn1, VecIn2, &Mask[0]);
5083   for (unsigned i = 0, e = InsertIndices.size(); i != e; ++i) {
5084     unsigned Idx = InsertIndices[i];
5085     NV = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, NV, Op.getOperand(Idx),
5086                      DAG.getIntPtrConstant(Idx));
5087   }
5088
5089   return NV;
5090 }
5091
5092 // Lower BUILD_VECTOR operation for v8i1 and v16i1 types.
5093 SDValue
5094 X86TargetLowering::LowerBUILD_VECTORvXi1(SDValue Op, SelectionDAG &DAG) const {
5095
5096   MVT VT = Op.getSimpleValueType();
5097   assert((VT.getVectorElementType() == MVT::i1) && (VT.getSizeInBits() <= 16) &&
5098          "Unexpected type in LowerBUILD_VECTORvXi1!");
5099
5100   SDLoc dl(Op);
5101   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
5102     SDValue Cst = DAG.getTargetConstant(0, MVT::i1);
5103     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Cst);
5104     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
5105   }
5106
5107   if (ISD::isBuildVectorAllOnes(Op.getNode())) {
5108     SDValue Cst = DAG.getTargetConstant(1, MVT::i1);
5109     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Cst);
5110     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
5111   }
5112
5113   bool AllContants = true;
5114   uint64_t Immediate = 0;
5115   int NonConstIdx = -1;
5116   bool IsSplat = true;
5117   unsigned NumNonConsts = 0;
5118   unsigned NumConsts = 0;
5119   for (unsigned idx = 0, e = Op.getNumOperands(); idx < e; ++idx) {
5120     SDValue In = Op.getOperand(idx);
5121     if (In.getOpcode() == ISD::UNDEF)
5122       continue;
5123     if (!isa<ConstantSDNode>(In)) {
5124       AllContants = false;
5125       NonConstIdx = idx;
5126       NumNonConsts++;
5127     } else {
5128       NumConsts++;
5129       if (cast<ConstantSDNode>(In)->getZExtValue())
5130       Immediate |= (1ULL << idx);
5131     }
5132     if (In != Op.getOperand(0))
5133       IsSplat = false;
5134   }
5135
5136   if (AllContants) {
5137     SDValue FullMask = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1,
5138       DAG.getConstant(Immediate, MVT::i16));
5139     return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, FullMask,
5140                        DAG.getIntPtrConstant(0));
5141   }
5142
5143   if (NumNonConsts == 1 && NonConstIdx != 0) {
5144     SDValue DstVec;
5145     if (NumConsts) {
5146       SDValue VecAsImm = DAG.getConstant(Immediate,
5147                                          MVT::getIntegerVT(VT.getSizeInBits()));
5148       DstVec = DAG.getNode(ISD::BITCAST, dl, VT, VecAsImm);
5149     }
5150     else
5151       DstVec = DAG.getUNDEF(VT);
5152     return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, DstVec,
5153                        Op.getOperand(NonConstIdx),
5154                        DAG.getIntPtrConstant(NonConstIdx));
5155   }
5156   if (!IsSplat && (NonConstIdx != 0))
5157     llvm_unreachable("Unsupported BUILD_VECTOR operation");
5158   MVT SelectVT = (VT == MVT::v16i1)? MVT::i16 : MVT::i8;
5159   SDValue Select;
5160   if (IsSplat)
5161     Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
5162                           DAG.getConstant(-1, SelectVT),
5163                           DAG.getConstant(0, SelectVT));
5164   else
5165     Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
5166                          DAG.getConstant((Immediate | 1), SelectVT),
5167                          DAG.getConstant(Immediate, SelectVT));
5168   return DAG.getNode(ISD::BITCAST, dl, VT, Select);
5169 }
5170
5171 /// \brief Return true if \p N implements a horizontal binop and return the
5172 /// operands for the horizontal binop into V0 and V1.
5173 ///
5174 /// This is a helper function of PerformBUILD_VECTORCombine.
5175 /// This function checks that the build_vector \p N in input implements a
5176 /// horizontal operation. Parameter \p Opcode defines the kind of horizontal
5177 /// operation to match.
5178 /// For example, if \p Opcode is equal to ISD::ADD, then this function
5179 /// checks if \p N implements a horizontal arithmetic add; if instead \p Opcode
5180 /// is equal to ISD::SUB, then this function checks if this is a horizontal
5181 /// arithmetic sub.
5182 ///
5183 /// This function only analyzes elements of \p N whose indices are
5184 /// in range [BaseIdx, LastIdx).
5185 static bool isHorizontalBinOp(const BuildVectorSDNode *N, unsigned Opcode,
5186                               SelectionDAG &DAG,
5187                               unsigned BaseIdx, unsigned LastIdx,
5188                               SDValue &V0, SDValue &V1) {
5189   EVT VT = N->getValueType(0);
5190
5191   assert(BaseIdx * 2 <= LastIdx && "Invalid Indices in input!");
5192   assert(VT.isVector() && VT.getVectorNumElements() >= LastIdx &&
5193          "Invalid Vector in input!");
5194
5195   bool IsCommutable = (Opcode == ISD::ADD || Opcode == ISD::FADD);
5196   bool CanFold = true;
5197   unsigned ExpectedVExtractIdx = BaseIdx;
5198   unsigned NumElts = LastIdx - BaseIdx;
5199   V0 = DAG.getUNDEF(VT);
5200   V1 = DAG.getUNDEF(VT);
5201
5202   // Check if N implements a horizontal binop.
5203   for (unsigned i = 0, e = NumElts; i != e && CanFold; ++i) {
5204     SDValue Op = N->getOperand(i + BaseIdx);
5205
5206     // Skip UNDEFs.
5207     if (Op->getOpcode() == ISD::UNDEF) {
5208       // Update the expected vector extract index.
5209       if (i * 2 == NumElts)
5210         ExpectedVExtractIdx = BaseIdx;
5211       ExpectedVExtractIdx += 2;
5212       continue;
5213     }
5214
5215     CanFold = Op->getOpcode() == Opcode && Op->hasOneUse();
5216
5217     if (!CanFold)
5218       break;
5219
5220     SDValue Op0 = Op.getOperand(0);
5221     SDValue Op1 = Op.getOperand(1);
5222
5223     // Try to match the following pattern:
5224     // (BINOP (extract_vector_elt A, I), (extract_vector_elt A, I+1))
5225     CanFold = (Op0.getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
5226         Op1.getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
5227         Op0.getOperand(0) == Op1.getOperand(0) &&
5228         isa<ConstantSDNode>(Op0.getOperand(1)) &&
5229         isa<ConstantSDNode>(Op1.getOperand(1)));
5230     if (!CanFold)
5231       break;
5232
5233     unsigned I0 = cast<ConstantSDNode>(Op0.getOperand(1))->getZExtValue();
5234     unsigned I1 = cast<ConstantSDNode>(Op1.getOperand(1))->getZExtValue();
5235
5236     if (i * 2 < NumElts) {
5237       if (V0.getOpcode() == ISD::UNDEF)
5238         V0 = Op0.getOperand(0);
5239     } else {
5240       if (V1.getOpcode() == ISD::UNDEF)
5241         V1 = Op0.getOperand(0);
5242       if (i * 2 == NumElts)
5243         ExpectedVExtractIdx = BaseIdx;
5244     }
5245
5246     SDValue Expected = (i * 2 < NumElts) ? V0 : V1;
5247     if (I0 == ExpectedVExtractIdx)
5248       CanFold = I1 == I0 + 1 && Op0.getOperand(0) == Expected;
5249     else if (IsCommutable && I1 == ExpectedVExtractIdx) {
5250       // Try to match the following dag sequence:
5251       // (BINOP (extract_vector_elt A, I+1), (extract_vector_elt A, I))
5252       CanFold = I0 == I1 + 1 && Op1.getOperand(0) == Expected;
5253     } else
5254       CanFold = false;
5255
5256     ExpectedVExtractIdx += 2;
5257   }
5258
5259   return CanFold;
5260 }
5261
5262 /// \brief Emit a sequence of two 128-bit horizontal add/sub followed by
5263 /// a concat_vector.
5264 ///
5265 /// This is a helper function of PerformBUILD_VECTORCombine.
5266 /// This function expects two 256-bit vectors called V0 and V1.
5267 /// At first, each vector is split into two separate 128-bit vectors.
5268 /// Then, the resulting 128-bit vectors are used to implement two
5269 /// horizontal binary operations.
5270 ///
5271 /// The kind of horizontal binary operation is defined by \p X86Opcode.
5272 ///
5273 /// \p Mode specifies how the 128-bit parts of V0 and V1 are passed in input to
5274 /// the two new horizontal binop.
5275 /// When Mode is set, the first horizontal binop dag node would take as input
5276 /// the lower 128-bit of V0 and the upper 128-bit of V0. The second
5277 /// horizontal binop dag node would take as input the lower 128-bit of V1
5278 /// and the upper 128-bit of V1.
5279 ///   Example:
5280 ///     HADD V0_LO, V0_HI
5281 ///     HADD V1_LO, V1_HI
5282 ///
5283 /// Otherwise, the first horizontal binop dag node takes as input the lower
5284 /// 128-bit of V0 and the lower 128-bit of V1, and the second horizontal binop
5285 /// dag node takes the the upper 128-bit of V0 and the upper 128-bit of V1.
5286 ///   Example:
5287 ///     HADD V0_LO, V1_LO
5288 ///     HADD V0_HI, V1_HI
5289 ///
5290 /// If \p isUndefLO is set, then the algorithm propagates UNDEF to the lower
5291 /// 128-bits of the result. If \p isUndefHI is set, then UNDEF is propagated to
5292 /// the upper 128-bits of the result.
5293 static SDValue ExpandHorizontalBinOp(const SDValue &V0, const SDValue &V1,
5294                                      SDLoc DL, SelectionDAG &DAG,
5295                                      unsigned X86Opcode, bool Mode,
5296                                      bool isUndefLO, bool isUndefHI) {
5297   EVT VT = V0.getValueType();
5298   assert(VT.is256BitVector() && VT == V1.getValueType() &&
5299          "Invalid nodes in input!");
5300
5301   unsigned NumElts = VT.getVectorNumElements();
5302   SDValue V0_LO = Extract128BitVector(V0, 0, DAG, DL);
5303   SDValue V0_HI = Extract128BitVector(V0, NumElts/2, DAG, DL);
5304   SDValue V1_LO = Extract128BitVector(V1, 0, DAG, DL);
5305   SDValue V1_HI = Extract128BitVector(V1, NumElts/2, DAG, DL);
5306   EVT NewVT = V0_LO.getValueType();
5307
5308   SDValue LO = DAG.getUNDEF(NewVT);
5309   SDValue HI = DAG.getUNDEF(NewVT);
5310
5311   if (Mode) {
5312     // Don't emit a horizontal binop if the result is expected to be UNDEF.
5313     if (!isUndefLO && V0->getOpcode() != ISD::UNDEF)
5314       LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V0_HI);
5315     if (!isUndefHI && V1->getOpcode() != ISD::UNDEF)
5316       HI = DAG.getNode(X86Opcode, DL, NewVT, V1_LO, V1_HI);
5317   } else {
5318     // Don't emit a horizontal binop if the result is expected to be UNDEF.
5319     if (!isUndefLO && (V0_LO->getOpcode() != ISD::UNDEF ||
5320                        V1_LO->getOpcode() != ISD::UNDEF))
5321       LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V1_LO);
5322
5323     if (!isUndefHI && (V0_HI->getOpcode() != ISD::UNDEF ||
5324                        V1_HI->getOpcode() != ISD::UNDEF))
5325       HI = DAG.getNode(X86Opcode, DL, NewVT, V0_HI, V1_HI);
5326   }
5327
5328   return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LO, HI);
5329 }
5330
5331 /// \brief Try to fold a build_vector that performs an 'addsub' into the
5332 /// sequence of 'vadd + vsub + blendi'.
5333 static SDValue matchAddSub(const BuildVectorSDNode *BV, SelectionDAG &DAG,
5334                            const X86Subtarget *Subtarget) {
5335   SDLoc DL(BV);
5336   EVT VT = BV->getValueType(0);
5337   unsigned NumElts = VT.getVectorNumElements();
5338   SDValue InVec0 = DAG.getUNDEF(VT);
5339   SDValue InVec1 = DAG.getUNDEF(VT);
5340
5341   assert((VT == MVT::v8f32 || VT == MVT::v4f64 || VT == MVT::v4f32 ||
5342           VT == MVT::v2f64) && "build_vector with an invalid type found!");
5343
5344   // Odd-numbered elements in the input build vector are obtained from
5345   // adding two integer/float elements.
5346   // Even-numbered elements in the input build vector are obtained from
5347   // subtracting two integer/float elements.
5348   unsigned ExpectedOpcode = ISD::FSUB;
5349   unsigned NextExpectedOpcode = ISD::FADD;
5350   bool AddFound = false;
5351   bool SubFound = false;
5352
5353   for (unsigned i = 0, e = NumElts; i != e; ++i) {
5354     SDValue Op = BV->getOperand(i);
5355
5356     // Skip 'undef' values.
5357     unsigned Opcode = Op.getOpcode();
5358     if (Opcode == ISD::UNDEF) {
5359       std::swap(ExpectedOpcode, NextExpectedOpcode);
5360       continue;
5361     }
5362
5363     // Early exit if we found an unexpected opcode.
5364     if (Opcode != ExpectedOpcode)
5365       return SDValue();
5366
5367     SDValue Op0 = Op.getOperand(0);
5368     SDValue Op1 = Op.getOperand(1);
5369
5370     // Try to match the following pattern:
5371     // (BINOP (extract_vector_elt A, i), (extract_vector_elt B, i))
5372     // Early exit if we cannot match that sequence.
5373     if (Op0.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
5374         Op1.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
5375         !isa<ConstantSDNode>(Op0.getOperand(1)) ||
5376         !isa<ConstantSDNode>(Op1.getOperand(1)) ||
5377         Op0.getOperand(1) != Op1.getOperand(1))
5378       return SDValue();
5379
5380     unsigned I0 = cast<ConstantSDNode>(Op0.getOperand(1))->getZExtValue();
5381     if (I0 != i)
5382       return SDValue();
5383
5384     // We found a valid add/sub node. Update the information accordingly.
5385     if (i & 1)
5386       AddFound = true;
5387     else
5388       SubFound = true;
5389
5390     // Update InVec0 and InVec1.
5391     if (InVec0.getOpcode() == ISD::UNDEF)
5392       InVec0 = Op0.getOperand(0);
5393     if (InVec1.getOpcode() == ISD::UNDEF)
5394       InVec1 = Op1.getOperand(0);
5395
5396     // Make sure that operands in input to each add/sub node always
5397     // come from a same pair of vectors.
5398     if (InVec0 != Op0.getOperand(0)) {
5399       if (ExpectedOpcode == ISD::FSUB)
5400         return SDValue();
5401
5402       // FADD is commutable. Try to commute the operands
5403       // and then test again.
5404       std::swap(Op0, Op1);
5405       if (InVec0 != Op0.getOperand(0))
5406         return SDValue();
5407     }
5408
5409     if (InVec1 != Op1.getOperand(0))
5410       return SDValue();
5411
5412     // Update the pair of expected opcodes.
5413     std::swap(ExpectedOpcode, NextExpectedOpcode);
5414   }
5415
5416   // Don't try to fold this build_vector into an ADDSUB if the inputs are undef.
5417   if (AddFound && SubFound && InVec0.getOpcode() != ISD::UNDEF &&
5418       InVec1.getOpcode() != ISD::UNDEF)
5419     return DAG.getNode(X86ISD::ADDSUB, DL, VT, InVec0, InVec1);
5420
5421   return SDValue();
5422 }
5423
5424 static SDValue PerformBUILD_VECTORCombine(SDNode *N, SelectionDAG &DAG,
5425                                           const X86Subtarget *Subtarget) {
5426   SDLoc DL(N);
5427   EVT VT = N->getValueType(0);
5428   unsigned NumElts = VT.getVectorNumElements();
5429   BuildVectorSDNode *BV = cast<BuildVectorSDNode>(N);
5430   SDValue InVec0, InVec1;
5431
5432   // Try to match an ADDSUB.
5433   if ((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
5434       (Subtarget->hasAVX() && (VT == MVT::v8f32 || VT == MVT::v4f64))) {
5435     SDValue Value = matchAddSub(BV, DAG, Subtarget);
5436     if (Value.getNode())
5437       return Value;
5438   }
5439
5440   // Try to match horizontal ADD/SUB.
5441   unsigned NumUndefsLO = 0;
5442   unsigned NumUndefsHI = 0;
5443   unsigned Half = NumElts/2;
5444
5445   // Count the number of UNDEF operands in the build_vector in input.
5446   for (unsigned i = 0, e = Half; i != e; ++i)
5447     if (BV->getOperand(i)->getOpcode() == ISD::UNDEF)
5448       NumUndefsLO++;
5449
5450   for (unsigned i = Half, e = NumElts; i != e; ++i)
5451     if (BV->getOperand(i)->getOpcode() == ISD::UNDEF)
5452       NumUndefsHI++;
5453
5454   // Early exit if this is either a build_vector of all UNDEFs or all the
5455   // operands but one are UNDEF.
5456   if (NumUndefsLO + NumUndefsHI + 1 >= NumElts)
5457     return SDValue();
5458
5459   if ((VT == MVT::v4f32 || VT == MVT::v2f64) && Subtarget->hasSSE3()) {
5460     // Try to match an SSE3 float HADD/HSUB.
5461     if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, NumElts, InVec0, InVec1))
5462       return DAG.getNode(X86ISD::FHADD, DL, VT, InVec0, InVec1);
5463
5464     if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, NumElts, InVec0, InVec1))
5465       return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
5466   } else if ((VT == MVT::v4i32 || VT == MVT::v8i16) && Subtarget->hasSSSE3()) {
5467     // Try to match an SSSE3 integer HADD/HSUB.
5468     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, NumElts, InVec0, InVec1))
5469       return DAG.getNode(X86ISD::HADD, DL, VT, InVec0, InVec1);
5470
5471     if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, NumElts, InVec0, InVec1))
5472       return DAG.getNode(X86ISD::HSUB, DL, VT, InVec0, InVec1);
5473   }
5474
5475   if (!Subtarget->hasAVX())
5476     return SDValue();
5477
5478   if ((VT == MVT::v8f32 || VT == MVT::v4f64)) {
5479     // Try to match an AVX horizontal add/sub of packed single/double
5480     // precision floating point values from 256-bit vectors.
5481     SDValue InVec2, InVec3;
5482     if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, Half, InVec0, InVec1) &&
5483         isHorizontalBinOp(BV, ISD::FADD, DAG, Half, NumElts, InVec2, InVec3) &&
5484         ((InVec0.getOpcode() == ISD::UNDEF ||
5485           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
5486         ((InVec1.getOpcode() == ISD::UNDEF ||
5487           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
5488       return DAG.getNode(X86ISD::FHADD, DL, VT, InVec0, InVec1);
5489
5490     if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, Half, InVec0, InVec1) &&
5491         isHorizontalBinOp(BV, ISD::FSUB, DAG, Half, NumElts, InVec2, InVec3) &&
5492         ((InVec0.getOpcode() == ISD::UNDEF ||
5493           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
5494         ((InVec1.getOpcode() == ISD::UNDEF ||
5495           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
5496       return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
5497   } else if (VT == MVT::v8i32 || VT == MVT::v16i16) {
5498     // Try to match an AVX2 horizontal add/sub of signed integers.
5499     SDValue InVec2, InVec3;
5500     unsigned X86Opcode;
5501     bool CanFold = true;
5502
5503     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, Half, InVec0, InVec1) &&
5504         isHorizontalBinOp(BV, ISD::ADD, DAG, Half, NumElts, InVec2, InVec3) &&
5505         ((InVec0.getOpcode() == ISD::UNDEF ||
5506           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
5507         ((InVec1.getOpcode() == ISD::UNDEF ||
5508           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
5509       X86Opcode = X86ISD::HADD;
5510     else if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, Half, InVec0, InVec1) &&
5511         isHorizontalBinOp(BV, ISD::SUB, DAG, Half, NumElts, InVec2, InVec3) &&
5512         ((InVec0.getOpcode() == ISD::UNDEF ||
5513           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
5514         ((InVec1.getOpcode() == ISD::UNDEF ||
5515           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
5516       X86Opcode = X86ISD::HSUB;
5517     else
5518       CanFold = false;
5519
5520     if (CanFold) {
5521       // Fold this build_vector into a single horizontal add/sub.
5522       // Do this only if the target has AVX2.
5523       if (Subtarget->hasAVX2())
5524         return DAG.getNode(X86Opcode, DL, VT, InVec0, InVec1);
5525
5526       // Do not try to expand this build_vector into a pair of horizontal
5527       // add/sub if we can emit a pair of scalar add/sub.
5528       if (NumUndefsLO + 1 == Half || NumUndefsHI + 1 == Half)
5529         return SDValue();
5530
5531       // Convert this build_vector into a pair of horizontal binop followed by
5532       // a concat vector.
5533       bool isUndefLO = NumUndefsLO == Half;
5534       bool isUndefHI = NumUndefsHI == Half;
5535       return ExpandHorizontalBinOp(InVec0, InVec1, DL, DAG, X86Opcode, false,
5536                                    isUndefLO, isUndefHI);
5537     }
5538   }
5539
5540   if ((VT == MVT::v8f32 || VT == MVT::v4f64 || VT == MVT::v8i32 ||
5541        VT == MVT::v16i16) && Subtarget->hasAVX()) {
5542     unsigned X86Opcode;
5543     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, NumElts, InVec0, InVec1))
5544       X86Opcode = X86ISD::HADD;
5545     else if (isHorizontalBinOp(BV, ISD::SUB, DAG, 0, NumElts, InVec0, InVec1))
5546       X86Opcode = X86ISD::HSUB;
5547     else if (isHorizontalBinOp(BV, ISD::FADD, DAG, 0, NumElts, InVec0, InVec1))
5548       X86Opcode = X86ISD::FHADD;
5549     else if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, NumElts, InVec0, InVec1))
5550       X86Opcode = X86ISD::FHSUB;
5551     else
5552       return SDValue();
5553
5554     // Don't try to expand this build_vector into a pair of horizontal add/sub
5555     // if we can simply emit a pair of scalar add/sub.
5556     if (NumUndefsLO + 1 == Half || NumUndefsHI + 1 == Half)
5557       return SDValue();
5558
5559     // Convert this build_vector into two horizontal add/sub followed by
5560     // a concat vector.
5561     bool isUndefLO = NumUndefsLO == Half;
5562     bool isUndefHI = NumUndefsHI == Half;
5563     return ExpandHorizontalBinOp(InVec0, InVec1, DL, DAG, X86Opcode, true,
5564                                  isUndefLO, isUndefHI);
5565   }
5566
5567   return SDValue();
5568 }
5569
5570 SDValue
5571 X86TargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const {
5572   SDLoc dl(Op);
5573
5574   MVT VT = Op.getSimpleValueType();
5575   MVT ExtVT = VT.getVectorElementType();
5576   unsigned NumElems = Op.getNumOperands();
5577
5578   // Generate vectors for predicate vectors.
5579   if (VT.getScalarType() == MVT::i1 && Subtarget->hasAVX512())
5580     return LowerBUILD_VECTORvXi1(Op, DAG);
5581
5582   // Vectors containing all zeros can be matched by pxor and xorps later
5583   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
5584     // Canonicalize this to <4 x i32> to 1) ensure the zero vectors are CSE'd
5585     // and 2) ensure that i64 scalars are eliminated on x86-32 hosts.
5586     if (VT == MVT::v4i32 || VT == MVT::v8i32 || VT == MVT::v16i32)
5587       return Op;
5588
5589     return getZeroVector(VT, Subtarget, DAG, dl);
5590   }
5591
5592   // Vectors containing all ones can be matched by pcmpeqd on 128-bit width
5593   // vectors or broken into v4i32 operations on 256-bit vectors. AVX2 can use
5594   // vpcmpeqd on 256-bit vectors.
5595   if (Subtarget->hasSSE2() && ISD::isBuildVectorAllOnes(Op.getNode())) {
5596     if (VT == MVT::v4i32 || (VT == MVT::v8i32 && Subtarget->hasInt256()))
5597       return Op;
5598
5599     if (!VT.is512BitVector())
5600       return getOnesVector(VT, Subtarget->hasInt256(), DAG, dl);
5601   }
5602
5603   if (SDValue Broadcast = LowerVectorBroadcast(Op, Subtarget, DAG))
5604     return Broadcast;
5605
5606   unsigned EVTBits = ExtVT.getSizeInBits();
5607
5608   unsigned NumZero  = 0;
5609   unsigned NumNonZero = 0;
5610   unsigned NonZeros = 0;
5611   bool IsAllConstants = true;
5612   SmallSet<SDValue, 8> Values;
5613   for (unsigned i = 0; i < NumElems; ++i) {
5614     SDValue Elt = Op.getOperand(i);
5615     if (Elt.getOpcode() == ISD::UNDEF)
5616       continue;
5617     Values.insert(Elt);
5618     if (Elt.getOpcode() != ISD::Constant &&
5619         Elt.getOpcode() != ISD::ConstantFP)
5620       IsAllConstants = false;
5621     if (X86::isZeroNode(Elt))
5622       NumZero++;
5623     else {
5624       NonZeros |= (1 << i);
5625       NumNonZero++;
5626     }
5627   }
5628
5629   // All undef vector. Return an UNDEF.  All zero vectors were handled above.
5630   if (NumNonZero == 0)
5631     return DAG.getUNDEF(VT);
5632
5633   // Special case for single non-zero, non-undef, element.
5634   if (NumNonZero == 1) {
5635     unsigned Idx = countTrailingZeros(NonZeros);
5636     SDValue Item = Op.getOperand(Idx);
5637
5638     // If this is an insertion of an i64 value on x86-32, and if the top bits of
5639     // the value are obviously zero, truncate the value to i32 and do the
5640     // insertion that way.  Only do this if the value is non-constant or if the
5641     // value is a constant being inserted into element 0.  It is cheaper to do
5642     // a constant pool load than it is to do a movd + shuffle.
5643     if (ExtVT == MVT::i64 && !Subtarget->is64Bit() &&
5644         (!IsAllConstants || Idx == 0)) {
5645       if (DAG.MaskedValueIsZero(Item, APInt::getBitsSet(64, 32, 64))) {
5646         // Handle SSE only.
5647         assert(VT == MVT::v2i64 && "Expected an SSE value type!");
5648         EVT VecVT = MVT::v4i32;
5649
5650         // Truncate the value (which may itself be a constant) to i32, and
5651         // convert it to a vector with movd (S2V+shuffle to zero extend).
5652         Item = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Item);
5653         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Item);
5654         return DAG.getNode(
5655             ISD::BITCAST, dl, VT,
5656             getShuffleVectorZeroOrUndef(Item, Idx * 2, true, Subtarget, DAG));
5657       }
5658     }
5659
5660     // If we have a constant or non-constant insertion into the low element of
5661     // a vector, we can do this with SCALAR_TO_VECTOR + shuffle of zero into
5662     // the rest of the elements.  This will be matched as movd/movq/movss/movsd
5663     // depending on what the source datatype is.
5664     if (Idx == 0) {
5665       if (NumZero == 0)
5666         return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5667
5668       if (ExtVT == MVT::i32 || ExtVT == MVT::f32 || ExtVT == MVT::f64 ||
5669           (ExtVT == MVT::i64 && Subtarget->is64Bit())) {
5670         if (VT.is512BitVector()) {
5671           SDValue ZeroVec = getZeroVector(VT, Subtarget, DAG, dl);
5672           return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, ZeroVec,
5673                              Item, DAG.getIntPtrConstant(0));
5674         }
5675         assert((VT.is128BitVector() || VT.is256BitVector()) &&
5676                "Expected an SSE value type!");
5677         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5678         // Turn it into a MOVL (i.e. movss, movsd, or movd) to a zero vector.
5679         return getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5680       }
5681
5682       // We can't directly insert an i8 or i16 into a vector, so zero extend
5683       // it to i32 first.
5684       if (ExtVT == MVT::i16 || ExtVT == MVT::i8) {
5685         Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
5686         if (VT.is256BitVector()) {
5687           if (Subtarget->hasAVX()) {
5688             Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v8i32, Item);
5689             Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5690           } else {
5691             // Without AVX, we need to extend to a 128-bit vector and then
5692             // insert into the 256-bit vector.
5693             Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Item);
5694             SDValue ZeroVec = getZeroVector(MVT::v8i32, Subtarget, DAG, dl);
5695             Item = Insert128BitVector(ZeroVec, Item, 0, DAG, dl);
5696           }
5697         } else {
5698           assert(VT.is128BitVector() && "Expected an SSE value type!");
5699           Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Item);
5700           Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5701         }
5702         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
5703       }
5704     }
5705
5706     // Is it a vector logical left shift?
5707     if (NumElems == 2 && Idx == 1 &&
5708         X86::isZeroNode(Op.getOperand(0)) &&
5709         !X86::isZeroNode(Op.getOperand(1))) {
5710       unsigned NumBits = VT.getSizeInBits();
5711       return getVShift(true, VT,
5712                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
5713                                    VT, Op.getOperand(1)),
5714                        NumBits/2, DAG, *this, dl);
5715     }
5716
5717     if (IsAllConstants) // Otherwise, it's better to do a constpool load.
5718       return SDValue();
5719
5720     // Otherwise, if this is a vector with i32 or f32 elements, and the element
5721     // is a non-constant being inserted into an element other than the low one,
5722     // we can't use a constant pool load.  Instead, use SCALAR_TO_VECTOR (aka
5723     // movd/movss) to move this into the low element, then shuffle it into
5724     // place.
5725     if (EVTBits == 32) {
5726       Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5727       return getShuffleVectorZeroOrUndef(Item, Idx, NumZero > 0, Subtarget, DAG);
5728     }
5729   }
5730
5731   // Splat is obviously ok. Let legalizer expand it to a shuffle.
5732   if (Values.size() == 1) {
5733     if (EVTBits == 32) {
5734       // Instead of a shuffle like this:
5735       // shuffle (scalar_to_vector (load (ptr + 4))), undef, <0, 0, 0, 0>
5736       // Check if it's possible to issue this instead.
5737       // shuffle (vload ptr)), undef, <1, 1, 1, 1>
5738       unsigned Idx = countTrailingZeros(NonZeros);
5739       SDValue Item = Op.getOperand(Idx);
5740       if (Op.getNode()->isOnlyUserOf(Item.getNode()))
5741         return LowerAsSplatVectorLoad(Item, VT, dl, DAG);
5742     }
5743     return SDValue();
5744   }
5745
5746   // A vector full of immediates; various special cases are already
5747   // handled, so this is best done with a single constant-pool load.
5748   if (IsAllConstants)
5749     return SDValue();
5750
5751   // For AVX-length vectors, see if we can use a vector load to get all of the
5752   // elements, otherwise build the individual 128-bit pieces and use
5753   // shuffles to put them in place.
5754   if (VT.is256BitVector() || VT.is512BitVector()) {
5755     SmallVector<SDValue, 64> V(Op->op_begin(), Op->op_begin() + NumElems);
5756
5757     // Check for a build vector of consecutive loads.
5758     if (SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG, false))
5759       return LD;
5760
5761     EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElems/2);
5762
5763     // Build both the lower and upper subvector.
5764     SDValue Lower = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT,
5765                                 makeArrayRef(&V[0], NumElems/2));
5766     SDValue Upper = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT,
5767                                 makeArrayRef(&V[NumElems / 2], NumElems/2));
5768
5769     // Recreate the wider vector with the lower and upper part.
5770     if (VT.is256BitVector())
5771       return Concat128BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
5772     return Concat256BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
5773   }
5774
5775   // Let legalizer expand 2-wide build_vectors.
5776   if (EVTBits == 64) {
5777     if (NumNonZero == 1) {
5778       // One half is zero or undef.
5779       unsigned Idx = countTrailingZeros(NonZeros);
5780       SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
5781                                  Op.getOperand(Idx));
5782       return getShuffleVectorZeroOrUndef(V2, Idx, true, Subtarget, DAG);
5783     }
5784     return SDValue();
5785   }
5786
5787   // If element VT is < 32 bits, convert it to inserts into a zero vector.
5788   if (EVTBits == 8 && NumElems == 16)
5789     if (SDValue V = LowerBuildVectorv16i8(Op, NonZeros,NumNonZero,NumZero, DAG,
5790                                         Subtarget, *this))
5791       return V;
5792
5793   if (EVTBits == 16 && NumElems == 8)
5794     if (SDValue V = LowerBuildVectorv8i16(Op, NonZeros,NumNonZero,NumZero, DAG,
5795                                       Subtarget, *this))
5796       return V;
5797
5798   // If element VT is == 32 bits and has 4 elems, try to generate an INSERTPS
5799   if (EVTBits == 32 && NumElems == 4)
5800     if (SDValue V = LowerBuildVectorv4x32(Op, DAG, Subtarget, *this))
5801       return V;
5802
5803   // If element VT is == 32 bits, turn it into a number of shuffles.
5804   SmallVector<SDValue, 8> V(NumElems);
5805   if (NumElems == 4 && NumZero > 0) {
5806     for (unsigned i = 0; i < 4; ++i) {
5807       bool isZero = !(NonZeros & (1 << i));
5808       if (isZero)
5809         V[i] = getZeroVector(VT, Subtarget, DAG, dl);
5810       else
5811         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
5812     }
5813
5814     for (unsigned i = 0; i < 2; ++i) {
5815       switch ((NonZeros & (0x3 << i*2)) >> (i*2)) {
5816         default: break;
5817         case 0:
5818           V[i] = V[i*2];  // Must be a zero vector.
5819           break;
5820         case 1:
5821           V[i] = getMOVL(DAG, dl, VT, V[i*2+1], V[i*2]);
5822           break;
5823         case 2:
5824           V[i] = getMOVL(DAG, dl, VT, V[i*2], V[i*2+1]);
5825           break;
5826         case 3:
5827           V[i] = getUnpackl(DAG, dl, VT, V[i*2], V[i*2+1]);
5828           break;
5829       }
5830     }
5831
5832     bool Reverse1 = (NonZeros & 0x3) == 2;
5833     bool Reverse2 = ((NonZeros & (0x3 << 2)) >> 2) == 2;
5834     int MaskVec[] = {
5835       Reverse1 ? 1 : 0,
5836       Reverse1 ? 0 : 1,
5837       static_cast<int>(Reverse2 ? NumElems+1 : NumElems),
5838       static_cast<int>(Reverse2 ? NumElems   : NumElems+1)
5839     };
5840     return DAG.getVectorShuffle(VT, dl, V[0], V[1], &MaskVec[0]);
5841   }
5842
5843   if (Values.size() > 1 && VT.is128BitVector()) {
5844     // Check for a build vector of consecutive loads.
5845     for (unsigned i = 0; i < NumElems; ++i)
5846       V[i] = Op.getOperand(i);
5847
5848     // Check for elements which are consecutive loads.
5849     if (SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG, false))
5850       return LD;
5851
5852     // Check for a build vector from mostly shuffle plus few inserting.
5853     if (SDValue Sh = buildFromShuffleMostly(Op, DAG))
5854       return Sh;
5855
5856     // For SSE 4.1, use insertps to put the high elements into the low element.
5857     if (Subtarget->hasSSE41()) {
5858       SDValue Result;
5859       if (Op.getOperand(0).getOpcode() != ISD::UNDEF)
5860         Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
5861       else
5862         Result = DAG.getUNDEF(VT);
5863
5864       for (unsigned i = 1; i < NumElems; ++i) {
5865         if (Op.getOperand(i).getOpcode() == ISD::UNDEF) continue;
5866         Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
5867                              Op.getOperand(i), DAG.getIntPtrConstant(i));
5868       }
5869       return Result;
5870     }
5871
5872     // Otherwise, expand into a number of unpckl*, start by extending each of
5873     // our (non-undef) elements to the full vector width with the element in the
5874     // bottom slot of the vector (which generates no code for SSE).
5875     for (unsigned i = 0; i < NumElems; ++i) {
5876       if (Op.getOperand(i).getOpcode() != ISD::UNDEF)
5877         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
5878       else
5879         V[i] = DAG.getUNDEF(VT);
5880     }
5881
5882     // Next, we iteratively mix elements, e.g. for v4f32:
5883     //   Step 1: unpcklps 0, 2 ==> X: <?, ?, 2, 0>
5884     //         : unpcklps 1, 3 ==> Y: <?, ?, 3, 1>
5885     //   Step 2: unpcklps X, Y ==>    <3, 2, 1, 0>
5886     unsigned EltStride = NumElems >> 1;
5887     while (EltStride != 0) {
5888       for (unsigned i = 0; i < EltStride; ++i) {
5889         // If V[i+EltStride] is undef and this is the first round of mixing,
5890         // then it is safe to just drop this shuffle: V[i] is already in the
5891         // right place, the one element (since it's the first round) being
5892         // inserted as undef can be dropped.  This isn't safe for successive
5893         // rounds because they will permute elements within both vectors.
5894         if (V[i+EltStride].getOpcode() == ISD::UNDEF &&
5895             EltStride == NumElems/2)
5896           continue;
5897
5898         V[i] = getUnpackl(DAG, dl, VT, V[i], V[i + EltStride]);
5899       }
5900       EltStride >>= 1;
5901     }
5902     return V[0];
5903   }
5904   return SDValue();
5905 }
5906
5907 // LowerAVXCONCAT_VECTORS - 256-bit AVX can use the vinsertf128 instruction
5908 // to create 256-bit vectors from two other 128-bit ones.
5909 static SDValue LowerAVXCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
5910   SDLoc dl(Op);
5911   MVT ResVT = Op.getSimpleValueType();
5912
5913   assert((ResVT.is256BitVector() ||
5914           ResVT.is512BitVector()) && "Value type must be 256-/512-bit wide");
5915
5916   SDValue V1 = Op.getOperand(0);
5917   SDValue V2 = Op.getOperand(1);
5918   unsigned NumElems = ResVT.getVectorNumElements();
5919   if (ResVT.is256BitVector())
5920     return Concat128BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
5921
5922   if (Op.getNumOperands() == 4) {
5923     MVT HalfVT = MVT::getVectorVT(ResVT.getScalarType(),
5924                                 ResVT.getVectorNumElements()/2);
5925     SDValue V3 = Op.getOperand(2);
5926     SDValue V4 = Op.getOperand(3);
5927     return Concat256BitVectors(Concat128BitVectors(V1, V2, HalfVT, NumElems/2, DAG, dl),
5928       Concat128BitVectors(V3, V4, HalfVT, NumElems/2, DAG, dl), ResVT, NumElems, DAG, dl);
5929   }
5930   return Concat256BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
5931 }
5932
5933 static SDValue LowerCONCAT_VECTORSvXi1(SDValue Op,
5934                                        const X86Subtarget *Subtarget,
5935                                        SelectionDAG & DAG) {
5936   SDLoc dl(Op);
5937   MVT ResVT = Op.getSimpleValueType();
5938   unsigned NumOfOperands = Op.getNumOperands();
5939
5940   assert(isPowerOf2_32(NumOfOperands) &&
5941          "Unexpected number of operands in CONCAT_VECTORS");
5942
5943   if (NumOfOperands > 2) {
5944     MVT HalfVT = MVT::getVectorVT(ResVT.getScalarType(),
5945                                   ResVT.getVectorNumElements()/2);
5946     SmallVector<SDValue, 2> Ops;
5947     for (unsigned i = 0; i < NumOfOperands/2; i++)
5948       Ops.push_back(Op.getOperand(i));
5949     SDValue Lo = DAG.getNode(ISD::CONCAT_VECTORS, dl, HalfVT, Ops);
5950     Ops.clear();
5951     for (unsigned i = NumOfOperands/2; i < NumOfOperands; i++)
5952       Ops.push_back(Op.getOperand(i));
5953     SDValue Hi = DAG.getNode(ISD::CONCAT_VECTORS, dl, HalfVT, Ops);
5954     return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
5955   }
5956
5957   SDValue V1 = Op.getOperand(0);
5958   SDValue V2 = Op.getOperand(1);
5959   bool IsZeroV1 = ISD::isBuildVectorAllZeros(V1.getNode());
5960   bool IsZeroV2 = ISD::isBuildVectorAllZeros(V2.getNode());
5961
5962   if (IsZeroV1 && IsZeroV2)
5963     return getZeroVector(ResVT, Subtarget, DAG, dl);
5964
5965   SDValue ZeroIdx = DAG.getIntPtrConstant(0);
5966   SDValue Undef = DAG.getUNDEF(ResVT);
5967   unsigned NumElems = ResVT.getVectorNumElements();
5968   SDValue ShiftBits = DAG.getConstant(NumElems/2, MVT::i8);
5969
5970   V2 = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResVT, Undef, V2, ZeroIdx);
5971   V2 = DAG.getNode(X86ISD::VSHLI, dl, ResVT, V2, ShiftBits);
5972   if (IsZeroV1)
5973     return V2;
5974
5975   V1 = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResVT, Undef, V1, ZeroIdx);
5976   // Zero the upper bits of V1
5977   V1 = DAG.getNode(X86ISD::VSHLI, dl, ResVT, V1, ShiftBits);
5978   V1 = DAG.getNode(X86ISD::VSRLI, dl, ResVT, V1, ShiftBits);
5979   if (IsZeroV2)
5980     return V1;
5981   return DAG.getNode(ISD::OR, dl, ResVT, V1, V2);
5982 }
5983
5984 static SDValue LowerCONCAT_VECTORS(SDValue Op,
5985                                    const X86Subtarget *Subtarget,
5986                                    SelectionDAG &DAG) {
5987   MVT VT = Op.getSimpleValueType();
5988   if (VT.getVectorElementType() == MVT::i1)
5989     return LowerCONCAT_VECTORSvXi1(Op, Subtarget, DAG);
5990
5991   assert((VT.is256BitVector() && Op.getNumOperands() == 2) ||
5992          (VT.is512BitVector() && (Op.getNumOperands() == 2 ||
5993           Op.getNumOperands() == 4)));
5994
5995   // AVX can use the vinsertf128 instruction to create 256-bit vectors
5996   // from two other 128-bit ones.
5997
5998   // 512-bit vector may contain 2 256-bit vectors or 4 128-bit vectors
5999   return LowerAVXCONCAT_VECTORS(Op, DAG);
6000 }
6001
6002
6003 //===----------------------------------------------------------------------===//
6004 // Vector shuffle lowering
6005 //
6006 // This is an experimental code path for lowering vector shuffles on x86. It is
6007 // designed to handle arbitrary vector shuffles and blends, gracefully
6008 // degrading performance as necessary. It works hard to recognize idiomatic
6009 // shuffles and lower them to optimal instruction patterns without leaving
6010 // a framework that allows reasonably efficient handling of all vector shuffle
6011 // patterns.
6012 //===----------------------------------------------------------------------===//
6013
6014 /// \brief Tiny helper function to identify a no-op mask.
6015 ///
6016 /// This is a somewhat boring predicate function. It checks whether the mask
6017 /// array input, which is assumed to be a single-input shuffle mask of the kind
6018 /// used by the X86 shuffle instructions (not a fully general
6019 /// ShuffleVectorSDNode mask) requires any shuffles to occur. Both undef and an
6020 /// in-place shuffle are 'no-op's.
6021 static bool isNoopShuffleMask(ArrayRef<int> Mask) {
6022   for (int i = 0, Size = Mask.size(); i < Size; ++i)
6023     if (Mask[i] != -1 && Mask[i] != i)
6024       return false;
6025   return true;
6026 }
6027
6028 /// \brief Helper function to classify a mask as a single-input mask.
6029 ///
6030 /// This isn't a generic single-input test because in the vector shuffle
6031 /// lowering we canonicalize single inputs to be the first input operand. This
6032 /// means we can more quickly test for a single input by only checking whether
6033 /// an input from the second operand exists. We also assume that the size of
6034 /// mask corresponds to the size of the input vectors which isn't true in the
6035 /// fully general case.
6036 static bool isSingleInputShuffleMask(ArrayRef<int> Mask) {
6037   for (int M : Mask)
6038     if (M >= (int)Mask.size())
6039       return false;
6040   return true;
6041 }
6042
6043 /// \brief Test whether there are elements crossing 128-bit lanes in this
6044 /// shuffle mask.
6045 ///
6046 /// X86 divides up its shuffles into in-lane and cross-lane shuffle operations
6047 /// and we routinely test for these.
6048 static bool is128BitLaneCrossingShuffleMask(MVT VT, ArrayRef<int> Mask) {
6049   int LaneSize = 128 / VT.getScalarSizeInBits();
6050   int Size = Mask.size();
6051   for (int i = 0; i < Size; ++i)
6052     if (Mask[i] >= 0 && (Mask[i] % Size) / LaneSize != i / LaneSize)
6053       return true;
6054   return false;
6055 }
6056
6057 /// \brief Test whether a shuffle mask is equivalent within each 128-bit lane.
6058 ///
6059 /// This checks a shuffle mask to see if it is performing the same
6060 /// 128-bit lane-relative shuffle in each 128-bit lane. This trivially implies
6061 /// that it is also not lane-crossing. It may however involve a blend from the
6062 /// same lane of a second vector.
6063 ///
6064 /// The specific repeated shuffle mask is populated in \p RepeatedMask, as it is
6065 /// non-trivial to compute in the face of undef lanes. The representation is
6066 /// *not* suitable for use with existing 128-bit shuffles as it will contain
6067 /// entries from both V1 and V2 inputs to the wider mask.
6068 static bool
6069 is128BitLaneRepeatedShuffleMask(MVT VT, ArrayRef<int> Mask,
6070                                 SmallVectorImpl<int> &RepeatedMask) {
6071   int LaneSize = 128 / VT.getScalarSizeInBits();
6072   RepeatedMask.resize(LaneSize, -1);
6073   int Size = Mask.size();
6074   for (int i = 0; i < Size; ++i) {
6075     if (Mask[i] < 0)
6076       continue;
6077     if ((Mask[i] % Size) / LaneSize != i / LaneSize)
6078       // This entry crosses lanes, so there is no way to model this shuffle.
6079       return false;
6080
6081     // Ok, handle the in-lane shuffles by detecting if and when they repeat.
6082     if (RepeatedMask[i % LaneSize] == -1)
6083       // This is the first non-undef entry in this slot of a 128-bit lane.
6084       RepeatedMask[i % LaneSize] =
6085           Mask[i] < Size ? Mask[i] % LaneSize : Mask[i] % LaneSize + Size;
6086     else if (RepeatedMask[i % LaneSize] + (i / LaneSize) * LaneSize != Mask[i])
6087       // Found a mismatch with the repeated mask.
6088       return false;
6089   }
6090   return true;
6091 }
6092
6093 /// \brief Checks whether a shuffle mask is equivalent to an explicit list of
6094 /// arguments.
6095 ///
6096 /// This is a fast way to test a shuffle mask against a fixed pattern:
6097 ///
6098 ///   if (isShuffleEquivalent(Mask, 3, 2, {1, 0})) { ... }
6099 ///
6100 /// It returns true if the mask is exactly as wide as the argument list, and
6101 /// each element of the mask is either -1 (signifying undef) or the value given
6102 /// in the argument.
6103 static bool isShuffleEquivalent(SDValue V1, SDValue V2, ArrayRef<int> Mask,
6104                                 ArrayRef<int> ExpectedMask) {
6105   if (Mask.size() != ExpectedMask.size())
6106     return false;
6107
6108   int Size = Mask.size();
6109
6110   // If the values are build vectors, we can look through them to find
6111   // equivalent inputs that make the shuffles equivalent.
6112   auto *BV1 = dyn_cast<BuildVectorSDNode>(V1);
6113   auto *BV2 = dyn_cast<BuildVectorSDNode>(V2);
6114
6115   for (int i = 0; i < Size; ++i)
6116     if (Mask[i] != -1 && Mask[i] != ExpectedMask[i]) {
6117       auto *MaskBV = Mask[i] < Size ? BV1 : BV2;
6118       auto *ExpectedBV = ExpectedMask[i] < Size ? BV1 : BV2;
6119       if (!MaskBV || !ExpectedBV ||
6120           MaskBV->getOperand(Mask[i] % Size) !=
6121               ExpectedBV->getOperand(ExpectedMask[i] % Size))
6122         return false;
6123     }
6124
6125   return true;
6126 }
6127
6128 /// \brief Get a 4-lane 8-bit shuffle immediate for a mask.
6129 ///
6130 /// This helper function produces an 8-bit shuffle immediate corresponding to
6131 /// the ubiquitous shuffle encoding scheme used in x86 instructions for
6132 /// shuffling 4 lanes. It can be used with most of the PSHUF instructions for
6133 /// example.
6134 ///
6135 /// NB: We rely heavily on "undef" masks preserving the input lane.
6136 static SDValue getV4X86ShuffleImm8ForMask(ArrayRef<int> Mask,
6137                                           SelectionDAG &DAG) {
6138   assert(Mask.size() == 4 && "Only 4-lane shuffle masks");
6139   assert(Mask[0] >= -1 && Mask[0] < 4 && "Out of bound mask element!");
6140   assert(Mask[1] >= -1 && Mask[1] < 4 && "Out of bound mask element!");
6141   assert(Mask[2] >= -1 && Mask[2] < 4 && "Out of bound mask element!");
6142   assert(Mask[3] >= -1 && Mask[3] < 4 && "Out of bound mask element!");
6143
6144   unsigned Imm = 0;
6145   Imm |= (Mask[0] == -1 ? 0 : Mask[0]) << 0;
6146   Imm |= (Mask[1] == -1 ? 1 : Mask[1]) << 2;
6147   Imm |= (Mask[2] == -1 ? 2 : Mask[2]) << 4;
6148   Imm |= (Mask[3] == -1 ? 3 : Mask[3]) << 6;
6149   return DAG.getConstant(Imm, MVT::i8);
6150 }
6151
6152 /// \brief Try to emit a blend instruction for a shuffle using bit math.
6153 ///
6154 /// This is used as a fallback approach when first class blend instructions are
6155 /// unavailable. Currently it is only suitable for integer vectors, but could
6156 /// be generalized for floating point vectors if desirable.
6157 static SDValue lowerVectorShuffleAsBitBlend(SDLoc DL, MVT VT, SDValue V1,
6158                                             SDValue V2, ArrayRef<int> Mask,
6159                                             SelectionDAG &DAG) {
6160   assert(VT.isInteger() && "Only supports integer vector types!");
6161   MVT EltVT = VT.getScalarType();
6162   int NumEltBits = EltVT.getSizeInBits();
6163   SDValue Zero = DAG.getConstant(0, EltVT);
6164   SDValue AllOnes = DAG.getConstant(APInt::getAllOnesValue(NumEltBits), EltVT);
6165   SmallVector<SDValue, 16> MaskOps;
6166   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
6167     if (Mask[i] != -1 && Mask[i] != i && Mask[i] != i + Size)
6168       return SDValue(); // Shuffled input!
6169     MaskOps.push_back(Mask[i] < Size ? AllOnes : Zero);
6170   }
6171
6172   SDValue V1Mask = DAG.getNode(ISD::BUILD_VECTOR, DL, VT, MaskOps);
6173   V1 = DAG.getNode(ISD::AND, DL, VT, V1, V1Mask);
6174   // We have to cast V2 around.
6175   MVT MaskVT = MVT::getVectorVT(MVT::i64, VT.getSizeInBits() / 64);
6176   V2 = DAG.getNode(ISD::BITCAST, DL, VT,
6177                    DAG.getNode(X86ISD::ANDNP, DL, MaskVT,
6178                                DAG.getNode(ISD::BITCAST, DL, MaskVT, V1Mask),
6179                                DAG.getNode(ISD::BITCAST, DL, MaskVT, V2)));
6180   return DAG.getNode(ISD::OR, DL, VT, V1, V2);
6181 }
6182
6183 /// \brief Try to emit a blend instruction for a shuffle.
6184 ///
6185 /// This doesn't do any checks for the availability of instructions for blending
6186 /// these values. It relies on the availability of the X86ISD::BLENDI pattern to
6187 /// be matched in the backend with the type given. What it does check for is
6188 /// that the shuffle mask is in fact a blend.
6189 static SDValue lowerVectorShuffleAsBlend(SDLoc DL, MVT VT, SDValue V1,
6190                                          SDValue V2, ArrayRef<int> Mask,
6191                                          const X86Subtarget *Subtarget,
6192                                          SelectionDAG &DAG) {
6193   unsigned BlendMask = 0;
6194   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
6195     if (Mask[i] >= Size) {
6196       if (Mask[i] != i + Size)
6197         return SDValue(); // Shuffled V2 input!
6198       BlendMask |= 1u << i;
6199       continue;
6200     }
6201     if (Mask[i] >= 0 && Mask[i] != i)
6202       return SDValue(); // Shuffled V1 input!
6203   }
6204   switch (VT.SimpleTy) {
6205   case MVT::v2f64:
6206   case MVT::v4f32:
6207   case MVT::v4f64:
6208   case MVT::v8f32:
6209     return DAG.getNode(X86ISD::BLENDI, DL, VT, V1, V2,
6210                        DAG.getConstant(BlendMask, MVT::i8));
6211
6212   case MVT::v4i64:
6213   case MVT::v8i32:
6214     assert(Subtarget->hasAVX2() && "256-bit integer blends require AVX2!");
6215     // FALLTHROUGH
6216   case MVT::v2i64:
6217   case MVT::v4i32:
6218     // If we have AVX2 it is faster to use VPBLENDD when the shuffle fits into
6219     // that instruction.
6220     if (Subtarget->hasAVX2()) {
6221       // Scale the blend by the number of 32-bit dwords per element.
6222       int Scale =  VT.getScalarSizeInBits() / 32;
6223       BlendMask = 0;
6224       for (int i = 0, Size = Mask.size(); i < Size; ++i)
6225         if (Mask[i] >= Size)
6226           for (int j = 0; j < Scale; ++j)
6227             BlendMask |= 1u << (i * Scale + j);
6228
6229       MVT BlendVT = VT.getSizeInBits() > 128 ? MVT::v8i32 : MVT::v4i32;
6230       V1 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V1);
6231       V2 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V2);
6232       return DAG.getNode(ISD::BITCAST, DL, VT,
6233                          DAG.getNode(X86ISD::BLENDI, DL, BlendVT, V1, V2,
6234                                      DAG.getConstant(BlendMask, MVT::i8)));
6235     }
6236     // FALLTHROUGH
6237   case MVT::v8i16: {
6238     // For integer shuffles we need to expand the mask and cast the inputs to
6239     // v8i16s prior to blending.
6240     int Scale = 8 / VT.getVectorNumElements();
6241     BlendMask = 0;
6242     for (int i = 0, Size = Mask.size(); i < Size; ++i)
6243       if (Mask[i] >= Size)
6244         for (int j = 0; j < Scale; ++j)
6245           BlendMask |= 1u << (i * Scale + j);
6246
6247     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1);
6248     V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V2);
6249     return DAG.getNode(ISD::BITCAST, DL, VT,
6250                        DAG.getNode(X86ISD::BLENDI, DL, MVT::v8i16, V1, V2,
6251                                    DAG.getConstant(BlendMask, MVT::i8)));
6252   }
6253
6254   case MVT::v16i16: {
6255     assert(Subtarget->hasAVX2() && "256-bit integer blends require AVX2!");
6256     SmallVector<int, 8> RepeatedMask;
6257     if (is128BitLaneRepeatedShuffleMask(MVT::v16i16, Mask, RepeatedMask)) {
6258       // We can lower these with PBLENDW which is mirrored across 128-bit lanes.
6259       assert(RepeatedMask.size() == 8 && "Repeated mask size doesn't match!");
6260       BlendMask = 0;
6261       for (int i = 0; i < 8; ++i)
6262         if (RepeatedMask[i] >= 16)
6263           BlendMask |= 1u << i;
6264       return DAG.getNode(X86ISD::BLENDI, DL, MVT::v16i16, V1, V2,
6265                          DAG.getConstant(BlendMask, MVT::i8));
6266     }
6267   }
6268     // FALLTHROUGH
6269   case MVT::v16i8:
6270   case MVT::v32i8: {
6271     assert((VT.getSizeInBits() == 128 || Subtarget->hasAVX2()) &&
6272            "256-bit byte-blends require AVX2 support!");
6273
6274     // Scale the blend by the number of bytes per element.
6275     int Scale = VT.getScalarSizeInBits() / 8;
6276
6277     // This form of blend is always done on bytes. Compute the byte vector
6278     // type.
6279     MVT BlendVT = MVT::getVectorVT(MVT::i8, VT.getSizeInBits() / 8);
6280
6281     // Compute the VSELECT mask. Note that VSELECT is really confusing in the
6282     // mix of LLVM's code generator and the x86 backend. We tell the code
6283     // generator that boolean values in the elements of an x86 vector register
6284     // are -1 for true and 0 for false. We then use the LLVM semantics of 'true'
6285     // mapping a select to operand #1, and 'false' mapping to operand #2. The
6286     // reality in x86 is that vector masks (pre-AVX-512) use only the high bit
6287     // of the element (the remaining are ignored) and 0 in that high bit would
6288     // mean operand #1 while 1 in the high bit would mean operand #2. So while
6289     // the LLVM model for boolean values in vector elements gets the relevant
6290     // bit set, it is set backwards and over constrained relative to x86's
6291     // actual model.
6292     SmallVector<SDValue, 32> VSELECTMask;
6293     for (int i = 0, Size = Mask.size(); i < Size; ++i)
6294       for (int j = 0; j < Scale; ++j)
6295         VSELECTMask.push_back(
6296             Mask[i] < 0 ? DAG.getUNDEF(MVT::i8)
6297                         : DAG.getConstant(Mask[i] < Size ? -1 : 0, MVT::i8));
6298
6299     V1 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V1);
6300     V2 = DAG.getNode(ISD::BITCAST, DL, BlendVT, V2);
6301     return DAG.getNode(
6302         ISD::BITCAST, DL, VT,
6303         DAG.getNode(ISD::VSELECT, DL, BlendVT,
6304                     DAG.getNode(ISD::BUILD_VECTOR, DL, BlendVT, VSELECTMask),
6305                     V1, V2));
6306   }
6307
6308   default:
6309     llvm_unreachable("Not a supported integer vector type!");
6310   }
6311 }
6312
6313 /// \brief Try to lower as a blend of elements from two inputs followed by
6314 /// a single-input permutation.
6315 ///
6316 /// This matches the pattern where we can blend elements from two inputs and
6317 /// then reduce the shuffle to a single-input permutation.
6318 static SDValue lowerVectorShuffleAsBlendAndPermute(SDLoc DL, MVT VT, SDValue V1,
6319                                                    SDValue V2,
6320                                                    ArrayRef<int> Mask,
6321                                                    SelectionDAG &DAG) {
6322   // We build up the blend mask while checking whether a blend is a viable way
6323   // to reduce the shuffle.
6324   SmallVector<int, 32> BlendMask(Mask.size(), -1);
6325   SmallVector<int, 32> PermuteMask(Mask.size(), -1);
6326
6327   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
6328     if (Mask[i] < 0)
6329       continue;
6330
6331     assert(Mask[i] < Size * 2 && "Shuffle input is out of bounds.");
6332
6333     if (BlendMask[Mask[i] % Size] == -1)
6334       BlendMask[Mask[i] % Size] = Mask[i];
6335     else if (BlendMask[Mask[i] % Size] != Mask[i])
6336       return SDValue(); // Can't blend in the needed input!
6337
6338     PermuteMask[i] = Mask[i] % Size;
6339   }
6340
6341   SDValue V = DAG.getVectorShuffle(VT, DL, V1, V2, BlendMask);
6342   return DAG.getVectorShuffle(VT, DL, V, DAG.getUNDEF(VT), PermuteMask);
6343 }
6344
6345 /// \brief Generic routine to decompose a shuffle and blend into indepndent
6346 /// blends and permutes.
6347 ///
6348 /// This matches the extremely common pattern for handling combined
6349 /// shuffle+blend operations on newer X86 ISAs where we have very fast blend
6350 /// operations. It will try to pick the best arrangement of shuffles and
6351 /// blends.
6352 static SDValue lowerVectorShuffleAsDecomposedShuffleBlend(SDLoc DL, MVT VT,
6353                                                           SDValue V1,
6354                                                           SDValue V2,
6355                                                           ArrayRef<int> Mask,
6356                                                           SelectionDAG &DAG) {
6357   // Shuffle the input elements into the desired positions in V1 and V2 and
6358   // blend them together.
6359   SmallVector<int, 32> V1Mask(Mask.size(), -1);
6360   SmallVector<int, 32> V2Mask(Mask.size(), -1);
6361   SmallVector<int, 32> BlendMask(Mask.size(), -1);
6362   for (int i = 0, Size = Mask.size(); i < Size; ++i)
6363     if (Mask[i] >= 0 && Mask[i] < Size) {
6364       V1Mask[i] = Mask[i];
6365       BlendMask[i] = i;
6366     } else if (Mask[i] >= Size) {
6367       V2Mask[i] = Mask[i] - Size;
6368       BlendMask[i] = i + Size;
6369     }
6370
6371   // Try to lower with the simpler initial blend strategy unless one of the
6372   // input shuffles would be a no-op. We prefer to shuffle inputs as the
6373   // shuffle may be able to fold with a load or other benefit. However, when
6374   // we'll have to do 2x as many shuffles in order to achieve this, blending
6375   // first is a better strategy.
6376   if (!isNoopShuffleMask(V1Mask) && !isNoopShuffleMask(V2Mask))
6377     if (SDValue BlendPerm =
6378             lowerVectorShuffleAsBlendAndPermute(DL, VT, V1, V2, Mask, DAG))
6379       return BlendPerm;
6380
6381   V1 = DAG.getVectorShuffle(VT, DL, V1, DAG.getUNDEF(VT), V1Mask);
6382   V2 = DAG.getVectorShuffle(VT, DL, V2, DAG.getUNDEF(VT), V2Mask);
6383   return DAG.getVectorShuffle(VT, DL, V1, V2, BlendMask);
6384 }
6385
6386 /// \brief Try to lower a vector shuffle as a byte rotation.
6387 ///
6388 /// SSSE3 has a generic PALIGNR instruction in x86 that will do an arbitrary
6389 /// byte-rotation of the concatenation of two vectors; pre-SSSE3 can use
6390 /// a PSRLDQ/PSLLDQ/POR pattern to get a similar effect. This routine will
6391 /// try to generically lower a vector shuffle through such an pattern. It
6392 /// does not check for the profitability of lowering either as PALIGNR or
6393 /// PSRLDQ/PSLLDQ/POR, only whether the mask is valid to lower in that form.
6394 /// This matches shuffle vectors that look like:
6395 ///
6396 ///   v8i16 [11, 12, 13, 14, 15, 0, 1, 2]
6397 ///
6398 /// Essentially it concatenates V1 and V2, shifts right by some number of
6399 /// elements, and takes the low elements as the result. Note that while this is
6400 /// specified as a *right shift* because x86 is little-endian, it is a *left
6401 /// rotate* of the vector lanes.
6402 static SDValue lowerVectorShuffleAsByteRotate(SDLoc DL, MVT VT, SDValue V1,
6403                                               SDValue V2,
6404                                               ArrayRef<int> Mask,
6405                                               const X86Subtarget *Subtarget,
6406                                               SelectionDAG &DAG) {
6407   assert(!isNoopShuffleMask(Mask) && "We shouldn't lower no-op shuffles!");
6408
6409   int NumElts = Mask.size();
6410   int NumLanes = VT.getSizeInBits() / 128;
6411   int NumLaneElts = NumElts / NumLanes;
6412
6413   // We need to detect various ways of spelling a rotation:
6414   //   [11, 12, 13, 14, 15,  0,  1,  2]
6415   //   [-1, 12, 13, 14, -1, -1,  1, -1]
6416   //   [-1, -1, -1, -1, -1, -1,  1,  2]
6417   //   [ 3,  4,  5,  6,  7,  8,  9, 10]
6418   //   [-1,  4,  5,  6, -1, -1,  9, -1]
6419   //   [-1,  4,  5,  6, -1, -1, -1, -1]
6420   int Rotation = 0;
6421   SDValue Lo, Hi;
6422   for (int l = 0; l < NumElts; l += NumLaneElts) {
6423     for (int i = 0; i < NumLaneElts; ++i) {
6424       if (Mask[l + i] == -1)
6425         continue;
6426       assert(Mask[l + i] >= 0 && "Only -1 is a valid negative mask element!");
6427
6428       // Get the mod-Size index and lane correct it.
6429       int LaneIdx = (Mask[l + i] % NumElts) - l;
6430       // Make sure it was in this lane.
6431       if (LaneIdx < 0 || LaneIdx >= NumLaneElts)
6432         return SDValue();
6433
6434       // Determine where a rotated vector would have started.
6435       int StartIdx = i - LaneIdx;
6436       if (StartIdx == 0)
6437         // The identity rotation isn't interesting, stop.
6438         return SDValue();
6439
6440       // If we found the tail of a vector the rotation must be the missing
6441       // front. If we found the head of a vector, it must be how much of the
6442       // head.
6443       int CandidateRotation = StartIdx < 0 ? -StartIdx : NumLaneElts - StartIdx;
6444
6445       if (Rotation == 0)
6446         Rotation = CandidateRotation;
6447       else if (Rotation != CandidateRotation)
6448         // The rotations don't match, so we can't match this mask.
6449         return SDValue();
6450
6451       // Compute which value this mask is pointing at.
6452       SDValue MaskV = Mask[l + i] < NumElts ? V1 : V2;
6453
6454       // Compute which of the two target values this index should be assigned
6455       // to. This reflects whether the high elements are remaining or the low
6456       // elements are remaining.
6457       SDValue &TargetV = StartIdx < 0 ? Hi : Lo;
6458
6459       // Either set up this value if we've not encountered it before, or check
6460       // that it remains consistent.
6461       if (!TargetV)
6462         TargetV = MaskV;
6463       else if (TargetV != MaskV)
6464         // This may be a rotation, but it pulls from the inputs in some
6465         // unsupported interleaving.
6466         return SDValue();
6467     }
6468   }
6469
6470   // Check that we successfully analyzed the mask, and normalize the results.
6471   assert(Rotation != 0 && "Failed to locate a viable rotation!");
6472   assert((Lo || Hi) && "Failed to find a rotated input vector!");
6473   if (!Lo)
6474     Lo = Hi;
6475   else if (!Hi)
6476     Hi = Lo;
6477
6478   // The actual rotate instruction rotates bytes, so we need to scale the
6479   // rotation based on how many bytes are in the vector lane.
6480   int Scale = 16 / NumLaneElts;
6481
6482   // SSSE3 targets can use the palignr instruction.
6483   if (Subtarget->hasSSSE3()) {
6484     // Cast the inputs to i8 vector of correct length to match PALIGNR.
6485     MVT AlignVT = MVT::getVectorVT(MVT::i8, 16 * NumLanes);
6486     Lo = DAG.getNode(ISD::BITCAST, DL, AlignVT, Lo);
6487     Hi = DAG.getNode(ISD::BITCAST, DL, AlignVT, Hi);
6488
6489     return DAG.getNode(ISD::BITCAST, DL, VT,
6490                        DAG.getNode(X86ISD::PALIGNR, DL, AlignVT, Hi, Lo,
6491                                    DAG.getConstant(Rotation * Scale, MVT::i8)));
6492   }
6493
6494   assert(VT.getSizeInBits() == 128 &&
6495          "Rotate-based lowering only supports 128-bit lowering!");
6496   assert(Mask.size() <= 16 &&
6497          "Can shuffle at most 16 bytes in a 128-bit vector!");
6498
6499   // Default SSE2 implementation
6500   int LoByteShift = 16 - Rotation * Scale;
6501   int HiByteShift = Rotation * Scale;
6502
6503   // Cast the inputs to v2i64 to match PSLLDQ/PSRLDQ.
6504   Lo = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Lo);
6505   Hi = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Hi);
6506
6507   SDValue LoShift = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v2i64, Lo,
6508                                 DAG.getConstant(LoByteShift, MVT::i8));
6509   SDValue HiShift = DAG.getNode(X86ISD::VSRLDQ, DL, MVT::v2i64, Hi,
6510                                 DAG.getConstant(HiByteShift, MVT::i8));
6511   return DAG.getNode(ISD::BITCAST, DL, VT,
6512                      DAG.getNode(ISD::OR, DL, MVT::v2i64, LoShift, HiShift));
6513 }
6514
6515 /// \brief Compute whether each element of a shuffle is zeroable.
6516 ///
6517 /// A "zeroable" vector shuffle element is one which can be lowered to zero.
6518 /// Either it is an undef element in the shuffle mask, the element of the input
6519 /// referenced is undef, or the element of the input referenced is known to be
6520 /// zero. Many x86 shuffles can zero lanes cheaply and we often want to handle
6521 /// as many lanes with this technique as possible to simplify the remaining
6522 /// shuffle.
6523 static SmallBitVector computeZeroableShuffleElements(ArrayRef<int> Mask,
6524                                                      SDValue V1, SDValue V2) {
6525   SmallBitVector Zeroable(Mask.size(), false);
6526
6527   while (V1.getOpcode() == ISD::BITCAST)
6528     V1 = V1->getOperand(0);
6529   while (V2.getOpcode() == ISD::BITCAST)
6530     V2 = V2->getOperand(0);
6531
6532   bool V1IsZero = ISD::isBuildVectorAllZeros(V1.getNode());
6533   bool V2IsZero = ISD::isBuildVectorAllZeros(V2.getNode());
6534
6535   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
6536     int M = Mask[i];
6537     // Handle the easy cases.
6538     if (M < 0 || (M >= 0 && M < Size && V1IsZero) || (M >= Size && V2IsZero)) {
6539       Zeroable[i] = true;
6540       continue;
6541     }
6542
6543     // If this is an index into a build_vector node (which has the same number
6544     // of elements), dig out the input value and use it.
6545     SDValue V = M < Size ? V1 : V2;
6546     if (V.getOpcode() != ISD::BUILD_VECTOR || Size != (int)V.getNumOperands())
6547       continue;
6548
6549     SDValue Input = V.getOperand(M % Size);
6550     // The UNDEF opcode check really should be dead code here, but not quite
6551     // worth asserting on (it isn't invalid, just unexpected).
6552     if (Input.getOpcode() == ISD::UNDEF || X86::isZeroNode(Input))
6553       Zeroable[i] = true;
6554   }
6555
6556   return Zeroable;
6557 }
6558
6559 /// \brief Try to emit a bitmask instruction for a shuffle.
6560 ///
6561 /// This handles cases where we can model a blend exactly as a bitmask due to
6562 /// one of the inputs being zeroable.
6563 static SDValue lowerVectorShuffleAsBitMask(SDLoc DL, MVT VT, SDValue V1,
6564                                            SDValue V2, ArrayRef<int> Mask,
6565                                            SelectionDAG &DAG) {
6566   MVT EltVT = VT.getScalarType();
6567   int NumEltBits = EltVT.getSizeInBits();
6568   MVT IntEltVT = MVT::getIntegerVT(NumEltBits);
6569   SDValue Zero = DAG.getConstant(0, IntEltVT);
6570   SDValue AllOnes = DAG.getConstant(APInt::getAllOnesValue(NumEltBits), IntEltVT);
6571   if (EltVT.isFloatingPoint()) {
6572     Zero = DAG.getNode(ISD::BITCAST, DL, EltVT, Zero);
6573     AllOnes = DAG.getNode(ISD::BITCAST, DL, EltVT, AllOnes);
6574   }
6575   SmallVector<SDValue, 16> VMaskOps(Mask.size(), Zero);
6576   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
6577   SDValue V;
6578   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
6579     if (Zeroable[i])
6580       continue;
6581     if (Mask[i] % Size != i)
6582       return SDValue(); // Not a blend.
6583     if (!V)
6584       V = Mask[i] < Size ? V1 : V2;
6585     else if (V != (Mask[i] < Size ? V1 : V2))
6586       return SDValue(); // Can only let one input through the mask.
6587
6588     VMaskOps[i] = AllOnes;
6589   }
6590   if (!V)
6591     return SDValue(); // No non-zeroable elements!
6592
6593   SDValue VMask = DAG.getNode(ISD::BUILD_VECTOR, DL, VT, VMaskOps);
6594   V = DAG.getNode(VT.isFloatingPoint()
6595                   ? (unsigned) X86ISD::FAND : (unsigned) ISD::AND,
6596                   DL, VT, V, VMask);
6597   return V;
6598 }
6599
6600 /// \brief Try to lower a vector shuffle as a bit shift (shifts in zeros).
6601 ///
6602 /// Attempts to match a shuffle mask against the PSLL(W/D/Q/DQ) and
6603 /// PSRL(W/D/Q/DQ) SSE2 and AVX2 logical bit-shift instructions. The function
6604 /// matches elements from one of the input vectors shuffled to the left or
6605 /// right with zeroable elements 'shifted in'. It handles both the strictly
6606 /// bit-wise element shifts and the byte shift across an entire 128-bit double
6607 /// quad word lane.
6608 ///
6609 /// PSHL : (little-endian) left bit shift.
6610 /// [ zz, 0, zz,  2 ]
6611 /// [ -1, 4, zz, -1 ]
6612 /// PSRL : (little-endian) right bit shift.
6613 /// [  1, zz,  3, zz]
6614 /// [ -1, -1,  7, zz]
6615 /// PSLLDQ : (little-endian) left byte shift
6616 /// [ zz,  0,  1,  2,  3,  4,  5,  6]
6617 /// [ zz, zz, -1, -1,  2,  3,  4, -1]
6618 /// [ zz, zz, zz, zz, zz, zz, -1,  1]
6619 /// PSRLDQ : (little-endian) right byte shift
6620 /// [  5, 6,  7, zz, zz, zz, zz, zz]
6621 /// [ -1, 5,  6,  7, zz, zz, zz, zz]
6622 /// [  1, 2, -1, -1, -1, -1, zz, zz]
6623 static SDValue lowerVectorShuffleAsShift(SDLoc DL, MVT VT, SDValue V1,
6624                                          SDValue V2, ArrayRef<int> Mask,
6625                                          SelectionDAG &DAG) {
6626   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
6627
6628   int Size = Mask.size();
6629   assert(Size == (int)VT.getVectorNumElements() && "Unexpected mask size");
6630
6631   auto CheckZeros = [&](int Shift, int Scale, bool Left) {
6632     for (int i = 0; i < Size; i += Scale)
6633       for (int j = 0; j < Shift; ++j)
6634         if (!Zeroable[i + j + (Left ? 0 : (Scale - Shift))])
6635           return false;
6636
6637     return true;
6638   };
6639
6640   auto MatchShift = [&](int Shift, int Scale, bool Left, SDValue V) {
6641     for (int i = 0; i != Size; i += Scale) {
6642       unsigned Pos = Left ? i + Shift : i;
6643       unsigned Low = Left ? i : i + Shift;
6644       unsigned Len = Scale - Shift;
6645       if (!isSequentialOrUndefInRange(Mask, Pos, Len,
6646                                       Low + (V == V1 ? 0 : Size)))
6647         return SDValue();
6648     }
6649
6650     int ShiftEltBits = VT.getScalarSizeInBits() * Scale;
6651     bool ByteShift = ShiftEltBits > 64;
6652     unsigned OpCode = Left ? (ByteShift ? X86ISD::VSHLDQ : X86ISD::VSHLI)
6653                            : (ByteShift ? X86ISD::VSRLDQ : X86ISD::VSRLI);
6654     int ShiftAmt = Shift * VT.getScalarSizeInBits() / (ByteShift ? 8 : 1);
6655
6656     // Normalize the scale for byte shifts to still produce an i64 element
6657     // type.
6658     Scale = ByteShift ? Scale / 2 : Scale;
6659
6660     // We need to round trip through the appropriate type for the shift.
6661     MVT ShiftSVT = MVT::getIntegerVT(VT.getScalarSizeInBits() * Scale);
6662     MVT ShiftVT = MVT::getVectorVT(ShiftSVT, Size / Scale);
6663     assert(DAG.getTargetLoweringInfo().isTypeLegal(ShiftVT) &&
6664            "Illegal integer vector type");
6665     V = DAG.getNode(ISD::BITCAST, DL, ShiftVT, V);
6666
6667     V = DAG.getNode(OpCode, DL, ShiftVT, V, DAG.getConstant(ShiftAmt, MVT::i8));
6668     return DAG.getNode(ISD::BITCAST, DL, VT, V);
6669   };
6670
6671   // SSE/AVX supports logical shifts up to 64-bit integers - so we can just
6672   // keep doubling the size of the integer elements up to that. We can
6673   // then shift the elements of the integer vector by whole multiples of
6674   // their width within the elements of the larger integer vector. Test each
6675   // multiple to see if we can find a match with the moved element indices
6676   // and that the shifted in elements are all zeroable.
6677   for (int Scale = 2; Scale * VT.getScalarSizeInBits() <= 128; Scale *= 2)
6678     for (int Shift = 1; Shift != Scale; ++Shift)
6679       for (bool Left : {true, false})
6680         if (CheckZeros(Shift, Scale, Left))
6681           for (SDValue V : {V1, V2})
6682             if (SDValue Match = MatchShift(Shift, Scale, Left, V))
6683               return Match;
6684
6685   // no match
6686   return SDValue();
6687 }
6688
6689 /// \brief Lower a vector shuffle as a zero or any extension.
6690 ///
6691 /// Given a specific number of elements, element bit width, and extension
6692 /// stride, produce either a zero or any extension based on the available
6693 /// features of the subtarget.
6694 static SDValue lowerVectorShuffleAsSpecificZeroOrAnyExtend(
6695     SDLoc DL, MVT VT, int Scale, bool AnyExt, SDValue InputV,
6696     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
6697   assert(Scale > 1 && "Need a scale to extend.");
6698   int NumElements = VT.getVectorNumElements();
6699   int EltBits = VT.getScalarSizeInBits();
6700   assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
6701          "Only 8, 16, and 32 bit elements can be extended.");
6702   assert(Scale * EltBits <= 64 && "Cannot zero extend past 64 bits.");
6703
6704   // Found a valid zext mask! Try various lowering strategies based on the
6705   // input type and available ISA extensions.
6706   if (Subtarget->hasSSE41()) {
6707     MVT ExtVT = MVT::getVectorVT(MVT::getIntegerVT(EltBits * Scale),
6708                                  NumElements / Scale);
6709     return DAG.getNode(ISD::BITCAST, DL, VT,
6710                        DAG.getNode(X86ISD::VZEXT, DL, ExtVT, InputV));
6711   }
6712
6713   // For any extends we can cheat for larger element sizes and use shuffle
6714   // instructions that can fold with a load and/or copy.
6715   if (AnyExt && EltBits == 32) {
6716     int PSHUFDMask[4] = {0, -1, 1, -1};
6717     return DAG.getNode(
6718         ISD::BITCAST, DL, VT,
6719         DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
6720                     DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, InputV),
6721                     getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
6722   }
6723   if (AnyExt && EltBits == 16 && Scale > 2) {
6724     int PSHUFDMask[4] = {0, -1, 0, -1};
6725     InputV = DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
6726                          DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, InputV),
6727                          getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG));
6728     int PSHUFHWMask[4] = {1, -1, -1, -1};
6729     return DAG.getNode(
6730         ISD::BITCAST, DL, VT,
6731         DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16,
6732                     DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, InputV),
6733                     getV4X86ShuffleImm8ForMask(PSHUFHWMask, DAG)));
6734   }
6735
6736   // If this would require more than 2 unpack instructions to expand, use
6737   // pshufb when available. We can only use more than 2 unpack instructions
6738   // when zero extending i8 elements which also makes it easier to use pshufb.
6739   if (Scale > 4 && EltBits == 8 && Subtarget->hasSSSE3()) {
6740     assert(NumElements == 16 && "Unexpected byte vector width!");
6741     SDValue PSHUFBMask[16];
6742     for (int i = 0; i < 16; ++i)
6743       PSHUFBMask[i] =
6744           DAG.getConstant((i % Scale == 0) ? i / Scale : 0x80, MVT::i8);
6745     InputV = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, InputV);
6746     return DAG.getNode(ISD::BITCAST, DL, VT,
6747                        DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, InputV,
6748                                    DAG.getNode(ISD::BUILD_VECTOR, DL,
6749                                                MVT::v16i8, PSHUFBMask)));
6750   }
6751
6752   // Otherwise emit a sequence of unpacks.
6753   do {
6754     MVT InputVT = MVT::getVectorVT(MVT::getIntegerVT(EltBits), NumElements);
6755     SDValue Ext = AnyExt ? DAG.getUNDEF(InputVT)
6756                          : getZeroVector(InputVT, Subtarget, DAG, DL);
6757     InputV = DAG.getNode(ISD::BITCAST, DL, InputVT, InputV);
6758     InputV = DAG.getNode(X86ISD::UNPCKL, DL, InputVT, InputV, Ext);
6759     Scale /= 2;
6760     EltBits *= 2;
6761     NumElements /= 2;
6762   } while (Scale > 1);
6763   return DAG.getNode(ISD::BITCAST, DL, VT, InputV);
6764 }
6765
6766 /// \brief Try to lower a vector shuffle as a zero extension on any microarch.
6767 ///
6768 /// This routine will try to do everything in its power to cleverly lower
6769 /// a shuffle which happens to match the pattern of a zero extend. It doesn't
6770 /// check for the profitability of this lowering,  it tries to aggressively
6771 /// match this pattern. It will use all of the micro-architectural details it
6772 /// can to emit an efficient lowering. It handles both blends with all-zero
6773 /// inputs to explicitly zero-extend and undef-lanes (sometimes undef due to
6774 /// masking out later).
6775 ///
6776 /// The reason we have dedicated lowering for zext-style shuffles is that they
6777 /// are both incredibly common and often quite performance sensitive.
6778 static SDValue lowerVectorShuffleAsZeroOrAnyExtend(
6779     SDLoc DL, MVT VT, SDValue V1, SDValue V2, ArrayRef<int> Mask,
6780     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
6781   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
6782
6783   int Bits = VT.getSizeInBits();
6784   int NumElements = VT.getVectorNumElements();
6785   assert(VT.getScalarSizeInBits() <= 32 &&
6786          "Exceeds 32-bit integer zero extension limit");
6787   assert((int)Mask.size() == NumElements && "Unexpected shuffle mask size");
6788
6789   // Define a helper function to check a particular ext-scale and lower to it if
6790   // valid.
6791   auto Lower = [&](int Scale) -> SDValue {
6792     SDValue InputV;
6793     bool AnyExt = true;
6794     for (int i = 0; i < NumElements; ++i) {
6795       if (Mask[i] == -1)
6796         continue; // Valid anywhere but doesn't tell us anything.
6797       if (i % Scale != 0) {
6798         // Each of the extended elements need to be zeroable.
6799         if (!Zeroable[i])
6800           return SDValue();
6801
6802         // We no longer are in the anyext case.
6803         AnyExt = false;
6804         continue;
6805       }
6806
6807       // Each of the base elements needs to be consecutive indices into the
6808       // same input vector.
6809       SDValue V = Mask[i] < NumElements ? V1 : V2;
6810       if (!InputV)
6811         InputV = V;
6812       else if (InputV != V)
6813         return SDValue(); // Flip-flopping inputs.
6814
6815       if (Mask[i] % NumElements != i / Scale)
6816         return SDValue(); // Non-consecutive strided elements.
6817     }
6818
6819     // If we fail to find an input, we have a zero-shuffle which should always
6820     // have already been handled.
6821     // FIXME: Maybe handle this here in case during blending we end up with one?
6822     if (!InputV)
6823       return SDValue();
6824
6825     return lowerVectorShuffleAsSpecificZeroOrAnyExtend(
6826         DL, VT, Scale, AnyExt, InputV, Subtarget, DAG);
6827   };
6828
6829   // The widest scale possible for extending is to a 64-bit integer.
6830   assert(Bits % 64 == 0 &&
6831          "The number of bits in a vector must be divisible by 64 on x86!");
6832   int NumExtElements = Bits / 64;
6833
6834   // Each iteration, try extending the elements half as much, but into twice as
6835   // many elements.
6836   for (; NumExtElements < NumElements; NumExtElements *= 2) {
6837     assert(NumElements % NumExtElements == 0 &&
6838            "The input vector size must be divisible by the extended size.");
6839     if (SDValue V = Lower(NumElements / NumExtElements))
6840       return V;
6841   }
6842
6843   // General extends failed, but 128-bit vectors may be able to use MOVQ.
6844   if (Bits != 128)
6845     return SDValue();
6846
6847   // Returns one of the source operands if the shuffle can be reduced to a
6848   // MOVQ, copying the lower 64-bits and zero-extending to the upper 64-bits.
6849   auto CanZExtLowHalf = [&]() {
6850     for (int i = NumElements / 2; i != NumElements; ++i)
6851       if (!Zeroable[i])
6852         return SDValue();
6853     if (isSequentialOrUndefInRange(Mask, 0, NumElements / 2, 0))
6854       return V1;
6855     if (isSequentialOrUndefInRange(Mask, 0, NumElements / 2, NumElements))
6856       return V2;
6857     return SDValue();
6858   };
6859
6860   if (SDValue V = CanZExtLowHalf()) {
6861     V = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, V);
6862     V = DAG.getNode(X86ISD::VZEXT_MOVL, DL, MVT::v2i64, V);
6863     return DAG.getNode(ISD::BITCAST, DL, VT, V);
6864   }
6865
6866   // No viable ext lowering found.
6867   return SDValue();
6868 }
6869
6870 /// \brief Try to get a scalar value for a specific element of a vector.
6871 ///
6872 /// Looks through BUILD_VECTOR and SCALAR_TO_VECTOR nodes to find a scalar.
6873 static SDValue getScalarValueForVectorElement(SDValue V, int Idx,
6874                                               SelectionDAG &DAG) {
6875   MVT VT = V.getSimpleValueType();
6876   MVT EltVT = VT.getVectorElementType();
6877   while (V.getOpcode() == ISD::BITCAST)
6878     V = V.getOperand(0);
6879   // If the bitcasts shift the element size, we can't extract an equivalent
6880   // element from it.
6881   MVT NewVT = V.getSimpleValueType();
6882   if (!NewVT.isVector() || NewVT.getScalarSizeInBits() != VT.getScalarSizeInBits())
6883     return SDValue();
6884
6885   if (V.getOpcode() == ISD::BUILD_VECTOR ||
6886       (Idx == 0 && V.getOpcode() == ISD::SCALAR_TO_VECTOR))
6887     return DAG.getNode(ISD::BITCAST, SDLoc(V), EltVT, V.getOperand(Idx));
6888
6889   return SDValue();
6890 }
6891
6892 /// \brief Helper to test for a load that can be folded with x86 shuffles.
6893 ///
6894 /// This is particularly important because the set of instructions varies
6895 /// significantly based on whether the operand is a load or not.
6896 static bool isShuffleFoldableLoad(SDValue V) {
6897   while (V.getOpcode() == ISD::BITCAST)
6898     V = V.getOperand(0);
6899
6900   return ISD::isNON_EXTLoad(V.getNode());
6901 }
6902
6903 /// \brief Try to lower insertion of a single element into a zero vector.
6904 ///
6905 /// This is a common pattern that we have especially efficient patterns to lower
6906 /// across all subtarget feature sets.
6907 static SDValue lowerVectorShuffleAsElementInsertion(
6908     SDLoc DL, MVT VT, SDValue V1, SDValue V2, ArrayRef<int> Mask,
6909     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
6910   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
6911   MVT ExtVT = VT;
6912   MVT EltVT = VT.getVectorElementType();
6913
6914   int V2Index = std::find_if(Mask.begin(), Mask.end(),
6915                              [&Mask](int M) { return M >= (int)Mask.size(); }) -
6916                 Mask.begin();
6917   bool IsV1Zeroable = true;
6918   for (int i = 0, Size = Mask.size(); i < Size; ++i)
6919     if (i != V2Index && !Zeroable[i]) {
6920       IsV1Zeroable = false;
6921       break;
6922     }
6923
6924   // Check for a single input from a SCALAR_TO_VECTOR node.
6925   // FIXME: All of this should be canonicalized into INSERT_VECTOR_ELT and
6926   // all the smarts here sunk into that routine. However, the current
6927   // lowering of BUILD_VECTOR makes that nearly impossible until the old
6928   // vector shuffle lowering is dead.
6929   if (SDValue V2S = getScalarValueForVectorElement(
6930           V2, Mask[V2Index] - Mask.size(), DAG)) {
6931     // We need to zext the scalar if it is smaller than an i32.
6932     V2S = DAG.getNode(ISD::BITCAST, DL, EltVT, V2S);
6933     if (EltVT == MVT::i8 || EltVT == MVT::i16) {
6934       // Using zext to expand a narrow element won't work for non-zero
6935       // insertions.
6936       if (!IsV1Zeroable)
6937         return SDValue();
6938
6939       // Zero-extend directly to i32.
6940       ExtVT = MVT::v4i32;
6941       V2S = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, V2S);
6942     }
6943     V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, ExtVT, V2S);
6944   } else if (Mask[V2Index] != (int)Mask.size() || EltVT == MVT::i8 ||
6945              EltVT == MVT::i16) {
6946     // Either not inserting from the low element of the input or the input
6947     // element size is too small to use VZEXT_MOVL to clear the high bits.
6948     return SDValue();
6949   }
6950
6951   if (!IsV1Zeroable) {
6952     // If V1 can't be treated as a zero vector we have fewer options to lower
6953     // this. We can't support integer vectors or non-zero targets cheaply, and
6954     // the V1 elements can't be permuted in any way.
6955     assert(VT == ExtVT && "Cannot change extended type when non-zeroable!");
6956     if (!VT.isFloatingPoint() || V2Index != 0)
6957       return SDValue();
6958     SmallVector<int, 8> V1Mask(Mask.begin(), Mask.end());
6959     V1Mask[V2Index] = -1;
6960     if (!isNoopShuffleMask(V1Mask))
6961       return SDValue();
6962     // This is essentially a special case blend operation, but if we have
6963     // general purpose blend operations, they are always faster. Bail and let
6964     // the rest of the lowering handle these as blends.
6965     if (Subtarget->hasSSE41())
6966       return SDValue();
6967
6968     // Otherwise, use MOVSD or MOVSS.
6969     assert((EltVT == MVT::f32 || EltVT == MVT::f64) &&
6970            "Only two types of floating point element types to handle!");
6971     return DAG.getNode(EltVT == MVT::f32 ? X86ISD::MOVSS : X86ISD::MOVSD, DL,
6972                        ExtVT, V1, V2);
6973   }
6974
6975   // This lowering only works for the low element with floating point vectors.
6976   if (VT.isFloatingPoint() && V2Index != 0)
6977     return SDValue();
6978
6979   V2 = DAG.getNode(X86ISD::VZEXT_MOVL, DL, ExtVT, V2);
6980   if (ExtVT != VT)
6981     V2 = DAG.getNode(ISD::BITCAST, DL, VT, V2);
6982
6983   if (V2Index != 0) {
6984     // If we have 4 or fewer lanes we can cheaply shuffle the element into
6985     // the desired position. Otherwise it is more efficient to do a vector
6986     // shift left. We know that we can do a vector shift left because all
6987     // the inputs are zero.
6988     if (VT.isFloatingPoint() || VT.getVectorNumElements() <= 4) {
6989       SmallVector<int, 4> V2Shuffle(Mask.size(), 1);
6990       V2Shuffle[V2Index] = 0;
6991       V2 = DAG.getVectorShuffle(VT, DL, V2, DAG.getUNDEF(VT), V2Shuffle);
6992     } else {
6993       V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, V2);
6994       V2 = DAG.getNode(
6995           X86ISD::VSHLDQ, DL, MVT::v2i64, V2,
6996           DAG.getConstant(
6997               V2Index * EltVT.getSizeInBits()/8,
6998               DAG.getTargetLoweringInfo().getScalarShiftAmountTy(MVT::v2i64)));
6999       V2 = DAG.getNode(ISD::BITCAST, DL, VT, V2);
7000     }
7001   }
7002   return V2;
7003 }
7004
7005 /// \brief Try to lower broadcast of a single element.
7006 ///
7007 /// For convenience, this code also bundles all of the subtarget feature set
7008 /// filtering. While a little annoying to re-dispatch on type here, there isn't
7009 /// a convenient way to factor it out.
7010 static SDValue lowerVectorShuffleAsBroadcast(SDLoc DL, MVT VT, SDValue V,
7011                                              ArrayRef<int> Mask,
7012                                              const X86Subtarget *Subtarget,
7013                                              SelectionDAG &DAG) {
7014   if (!Subtarget->hasAVX())
7015     return SDValue();
7016   if (VT.isInteger() && !Subtarget->hasAVX2())
7017     return SDValue();
7018
7019   // Check that the mask is a broadcast.
7020   int BroadcastIdx = -1;
7021   for (int M : Mask)
7022     if (M >= 0 && BroadcastIdx == -1)
7023       BroadcastIdx = M;
7024     else if (M >= 0 && M != BroadcastIdx)
7025       return SDValue();
7026
7027   assert(BroadcastIdx < (int)Mask.size() && "We only expect to be called with "
7028                                             "a sorted mask where the broadcast "
7029                                             "comes from V1.");
7030
7031   // Go up the chain of (vector) values to find a scalar load that we can
7032   // combine with the broadcast.
7033   for (;;) {
7034     switch (V.getOpcode()) {
7035     case ISD::CONCAT_VECTORS: {
7036       int OperandSize = Mask.size() / V.getNumOperands();
7037       V = V.getOperand(BroadcastIdx / OperandSize);
7038       BroadcastIdx %= OperandSize;
7039       continue;
7040     }
7041
7042     case ISD::INSERT_SUBVECTOR: {
7043       SDValue VOuter = V.getOperand(0), VInner = V.getOperand(1);
7044       auto ConstantIdx = dyn_cast<ConstantSDNode>(V.getOperand(2));
7045       if (!ConstantIdx)
7046         break;
7047
7048       int BeginIdx = (int)ConstantIdx->getZExtValue();
7049       int EndIdx =
7050           BeginIdx + (int)VInner.getValueType().getVectorNumElements();
7051       if (BroadcastIdx >= BeginIdx && BroadcastIdx < EndIdx) {
7052         BroadcastIdx -= BeginIdx;
7053         V = VInner;
7054       } else {
7055         V = VOuter;
7056       }
7057       continue;
7058     }
7059     }
7060     break;
7061   }
7062
7063   // Check if this is a broadcast of a scalar. We special case lowering
7064   // for scalars so that we can more effectively fold with loads.
7065   if (V.getOpcode() == ISD::BUILD_VECTOR ||
7066       (V.getOpcode() == ISD::SCALAR_TO_VECTOR && BroadcastIdx == 0)) {
7067     V = V.getOperand(BroadcastIdx);
7068
7069     // If the scalar isn't a load, we can't broadcast from it in AVX1.
7070     // Only AVX2 has register broadcasts.
7071     if (!Subtarget->hasAVX2() && !isShuffleFoldableLoad(V))
7072       return SDValue();
7073   } else if (BroadcastIdx != 0 || !Subtarget->hasAVX2()) {
7074     // We can't broadcast from a vector register without AVX2, and we can only
7075     // broadcast from the zero-element of a vector register.
7076     return SDValue();
7077   }
7078
7079   return DAG.getNode(X86ISD::VBROADCAST, DL, VT, V);
7080 }
7081
7082 // Check for whether we can use INSERTPS to perform the shuffle. We only use
7083 // INSERTPS when the V1 elements are already in the correct locations
7084 // because otherwise we can just always use two SHUFPS instructions which
7085 // are much smaller to encode than a SHUFPS and an INSERTPS. We can also
7086 // perform INSERTPS if a single V1 element is out of place and all V2
7087 // elements are zeroable.
7088 static SDValue lowerVectorShuffleAsInsertPS(SDValue Op, SDValue V1, SDValue V2,
7089                                             ArrayRef<int> Mask,
7090                                             SelectionDAG &DAG) {
7091   assert(Op.getSimpleValueType() == MVT::v4f32 && "Bad shuffle type!");
7092   assert(V1.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
7093   assert(V2.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
7094   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
7095
7096   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
7097
7098   unsigned ZMask = 0;
7099   int V1DstIndex = -1;
7100   int V2DstIndex = -1;
7101   bool V1UsedInPlace = false;
7102
7103   for (int i = 0; i < 4; ++i) {
7104     // Synthesize a zero mask from the zeroable elements (includes undefs).
7105     if (Zeroable[i]) {
7106       ZMask |= 1 << i;
7107       continue;
7108     }
7109
7110     // Flag if we use any V1 inputs in place.
7111     if (i == Mask[i]) {
7112       V1UsedInPlace = true;
7113       continue;
7114     }
7115
7116     // We can only insert a single non-zeroable element.
7117     if (V1DstIndex != -1 || V2DstIndex != -1)
7118       return SDValue();
7119
7120     if (Mask[i] < 4) {
7121       // V1 input out of place for insertion.
7122       V1DstIndex = i;
7123     } else {
7124       // V2 input for insertion.
7125       V2DstIndex = i;
7126     }
7127   }
7128
7129   // Don't bother if we have no (non-zeroable) element for insertion.
7130   if (V1DstIndex == -1 && V2DstIndex == -1)
7131     return SDValue();
7132
7133   // Determine element insertion src/dst indices. The src index is from the
7134   // start of the inserted vector, not the start of the concatenated vector.
7135   unsigned V2SrcIndex = 0;
7136   if (V1DstIndex != -1) {
7137     // If we have a V1 input out of place, we use V1 as the V2 element insertion
7138     // and don't use the original V2 at all.
7139     V2SrcIndex = Mask[V1DstIndex];
7140     V2DstIndex = V1DstIndex;
7141     V2 = V1;
7142   } else {
7143     V2SrcIndex = Mask[V2DstIndex] - 4;
7144   }
7145
7146   // If no V1 inputs are used in place, then the result is created only from
7147   // the zero mask and the V2 insertion - so remove V1 dependency.
7148   if (!V1UsedInPlace)
7149     V1 = DAG.getUNDEF(MVT::v4f32);
7150
7151   unsigned InsertPSMask = V2SrcIndex << 6 | V2DstIndex << 4 | ZMask;
7152   assert((InsertPSMask & ~0xFFu) == 0 && "Invalid mask!");
7153
7154   // Insert the V2 element into the desired position.
7155   SDLoc DL(Op);
7156   return DAG.getNode(X86ISD::INSERTPS, DL, MVT::v4f32, V1, V2,
7157                      DAG.getConstant(InsertPSMask, MVT::i8));
7158 }
7159
7160 /// \brief Try to lower a shuffle as a permute of the inputs followed by an
7161 /// UNPCK instruction.
7162 ///
7163 /// This specifically targets cases where we end up with alternating between
7164 /// the two inputs, and so can permute them into something that feeds a single
7165 /// UNPCK instruction. Note that this routine only targets integer vectors
7166 /// because for floating point vectors we have a generalized SHUFPS lowering
7167 /// strategy that handles everything that doesn't *exactly* match an unpack,
7168 /// making this clever lowering unnecessary.
7169 static SDValue lowerVectorShuffleAsUnpack(SDLoc DL, MVT VT, SDValue V1,
7170                                           SDValue V2, ArrayRef<int> Mask,
7171                                           SelectionDAG &DAG) {
7172   assert(!VT.isFloatingPoint() &&
7173          "This routine only supports integer vectors.");
7174   assert(!isSingleInputShuffleMask(Mask) &&
7175          "This routine should only be used when blending two inputs.");
7176   assert(Mask.size() >= 2 && "Single element masks are invalid.");
7177
7178   int Size = Mask.size();
7179
7180   int NumLoInputs = std::count_if(Mask.begin(), Mask.end(), [Size](int M) {
7181     return M >= 0 && M % Size < Size / 2;
7182   });
7183   int NumHiInputs = std::count_if(
7184       Mask.begin(), Mask.end(), [Size](int M) { return M % Size >= Size / 2; });
7185
7186   bool UnpackLo = NumLoInputs >= NumHiInputs;
7187
7188   auto TryUnpack = [&](MVT UnpackVT, int Scale) {
7189     SmallVector<int, 32> V1Mask(Mask.size(), -1);
7190     SmallVector<int, 32> V2Mask(Mask.size(), -1);
7191
7192     for (int i = 0; i < Size; ++i) {
7193       if (Mask[i] < 0)
7194         continue;
7195
7196       // Each element of the unpack contains Scale elements from this mask.
7197       int UnpackIdx = i / Scale;
7198
7199       // We only handle the case where V1 feeds the first slots of the unpack.
7200       // We rely on canonicalization to ensure this is the case.
7201       if ((UnpackIdx % 2 == 0) != (Mask[i] < Size))
7202         return SDValue();
7203
7204       // Setup the mask for this input. The indexing is tricky as we have to
7205       // handle the unpack stride.
7206       SmallVectorImpl<int> &VMask = (UnpackIdx % 2 == 0) ? V1Mask : V2Mask;
7207       VMask[(UnpackIdx / 2) * Scale + i % Scale + (UnpackLo ? 0 : Size / 2)] =
7208           Mask[i] % Size;
7209     }
7210
7211     // If we will have to shuffle both inputs to use the unpack, check whether
7212     // we can just unpack first and shuffle the result. If so, skip this unpack.
7213     if ((NumLoInputs == 0 || NumHiInputs == 0) && !isNoopShuffleMask(V1Mask) &&
7214         !isNoopShuffleMask(V2Mask))
7215       return SDValue();
7216
7217     // Shuffle the inputs into place.
7218     V1 = DAG.getVectorShuffle(VT, DL, V1, DAG.getUNDEF(VT), V1Mask);
7219     V2 = DAG.getVectorShuffle(VT, DL, V2, DAG.getUNDEF(VT), V2Mask);
7220
7221     // Cast the inputs to the type we will use to unpack them.
7222     V1 = DAG.getNode(ISD::BITCAST, DL, UnpackVT, V1);
7223     V2 = DAG.getNode(ISD::BITCAST, DL, UnpackVT, V2);
7224
7225     // Unpack the inputs and cast the result back to the desired type.
7226     return DAG.getNode(ISD::BITCAST, DL, VT,
7227                        DAG.getNode(UnpackLo ? X86ISD::UNPCKL : X86ISD::UNPCKH,
7228                                    DL, UnpackVT, V1, V2));
7229   };
7230
7231   // We try each unpack from the largest to the smallest to try and find one
7232   // that fits this mask.
7233   int OrigNumElements = VT.getVectorNumElements();
7234   int OrigScalarSize = VT.getScalarSizeInBits();
7235   for (int ScalarSize = 64; ScalarSize >= OrigScalarSize; ScalarSize /= 2) {
7236     int Scale = ScalarSize / OrigScalarSize;
7237     int NumElements = OrigNumElements / Scale;
7238     MVT UnpackVT = MVT::getVectorVT(MVT::getIntegerVT(ScalarSize), NumElements);
7239     if (SDValue Unpack = TryUnpack(UnpackVT, Scale))
7240       return Unpack;
7241   }
7242
7243   // If none of the unpack-rooted lowerings worked (or were profitable) try an
7244   // initial unpack.
7245   if (NumLoInputs == 0 || NumHiInputs == 0) {
7246     assert((NumLoInputs > 0 || NumHiInputs > 0) &&
7247            "We have to have *some* inputs!");
7248     int HalfOffset = NumLoInputs == 0 ? Size / 2 : 0;
7249
7250     // FIXME: We could consider the total complexity of the permute of each
7251     // possible unpacking. Or at the least we should consider how many
7252     // half-crossings are created.
7253     // FIXME: We could consider commuting the unpacks.
7254
7255     SmallVector<int, 32> PermMask;
7256     PermMask.assign(Size, -1);
7257     for (int i = 0; i < Size; ++i) {
7258       if (Mask[i] < 0)
7259         continue;
7260
7261       assert(Mask[i] % Size >= HalfOffset && "Found input from wrong half!");
7262
7263       PermMask[i] =
7264           2 * ((Mask[i] % Size) - HalfOffset) + (Mask[i] < Size ? 0 : 1);
7265     }
7266     return DAG.getVectorShuffle(
7267         VT, DL, DAG.getNode(NumLoInputs == 0 ? X86ISD::UNPCKH : X86ISD::UNPCKL,
7268                             DL, VT, V1, V2),
7269         DAG.getUNDEF(VT), PermMask);
7270   }
7271
7272   return SDValue();
7273 }
7274
7275 /// \brief Handle lowering of 2-lane 64-bit floating point shuffles.
7276 ///
7277 /// This is the basis function for the 2-lane 64-bit shuffles as we have full
7278 /// support for floating point shuffles but not integer shuffles. These
7279 /// instructions will incur a domain crossing penalty on some chips though so
7280 /// it is better to avoid lowering through this for integer vectors where
7281 /// possible.
7282 static SDValue lowerV2F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
7283                                        const X86Subtarget *Subtarget,
7284                                        SelectionDAG &DAG) {
7285   SDLoc DL(Op);
7286   assert(Op.getSimpleValueType() == MVT::v2f64 && "Bad shuffle type!");
7287   assert(V1.getSimpleValueType() == MVT::v2f64 && "Bad operand type!");
7288   assert(V2.getSimpleValueType() == MVT::v2f64 && "Bad operand type!");
7289   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
7290   ArrayRef<int> Mask = SVOp->getMask();
7291   assert(Mask.size() == 2 && "Unexpected mask size for v2 shuffle!");
7292
7293   if (isSingleInputShuffleMask(Mask)) {
7294     // Use low duplicate instructions for masks that match their pattern.
7295     if (Subtarget->hasSSE3())
7296       if (isShuffleEquivalent(V1, V2, Mask, {0, 0}))
7297         return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v2f64, V1);
7298
7299     // Straight shuffle of a single input vector. Simulate this by using the
7300     // single input as both of the "inputs" to this instruction..
7301     unsigned SHUFPDMask = (Mask[0] == 1) | ((Mask[1] == 1) << 1);
7302
7303     if (Subtarget->hasAVX()) {
7304       // If we have AVX, we can use VPERMILPS which will allow folding a load
7305       // into the shuffle.
7306       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v2f64, V1,
7307                          DAG.getConstant(SHUFPDMask, MVT::i8));
7308     }
7309
7310     return DAG.getNode(X86ISD::SHUFP, SDLoc(Op), MVT::v2f64, V1, V1,
7311                        DAG.getConstant(SHUFPDMask, MVT::i8));
7312   }
7313   assert(Mask[0] >= 0 && Mask[0] < 2 && "Non-canonicalized blend!");
7314   assert(Mask[1] >= 2 && "Non-canonicalized blend!");
7315
7316   // If we have a single input, insert that into V1 if we can do so cheaply.
7317   if ((Mask[0] >= 2) + (Mask[1] >= 2) == 1) {
7318     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
7319             DL, MVT::v2f64, V1, V2, Mask, Subtarget, DAG))
7320       return Insertion;
7321     // Try inverting the insertion since for v2 masks it is easy to do and we
7322     // can't reliably sort the mask one way or the other.
7323     int InverseMask[2] = {Mask[0] < 0 ? -1 : (Mask[0] ^ 2),
7324                           Mask[1] < 0 ? -1 : (Mask[1] ^ 2)};
7325     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
7326             DL, MVT::v2f64, V2, V1, InverseMask, Subtarget, DAG))
7327       return Insertion;
7328   }
7329
7330   // Try to use one of the special instruction patterns to handle two common
7331   // blend patterns if a zero-blend above didn't work.
7332   if (isShuffleEquivalent(V1, V2, Mask, {0, 3}) ||
7333       isShuffleEquivalent(V1, V2, Mask, {1, 3}))
7334     if (SDValue V1S = getScalarValueForVectorElement(V1, Mask[0], DAG))
7335       // We can either use a special instruction to load over the low double or
7336       // to move just the low double.
7337       return DAG.getNode(
7338           isShuffleFoldableLoad(V1S) ? X86ISD::MOVLPD : X86ISD::MOVSD,
7339           DL, MVT::v2f64, V2,
7340           DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64, V1S));
7341
7342   if (Subtarget->hasSSE41())
7343     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v2f64, V1, V2, Mask,
7344                                                   Subtarget, DAG))
7345       return Blend;
7346
7347   // Use dedicated unpack instructions for masks that match their pattern.
7348   if (isShuffleEquivalent(V1, V2, Mask, {0, 2}))
7349     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2f64, V1, V2);
7350   if (isShuffleEquivalent(V1, V2, Mask, {1, 3}))
7351     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v2f64, V1, V2);
7352
7353   unsigned SHUFPDMask = (Mask[0] == 1) | (((Mask[1] - 2) == 1) << 1);
7354   return DAG.getNode(X86ISD::SHUFP, SDLoc(Op), MVT::v2f64, V1, V2,
7355                      DAG.getConstant(SHUFPDMask, MVT::i8));
7356 }
7357
7358 /// \brief Handle lowering of 2-lane 64-bit integer shuffles.
7359 ///
7360 /// Tries to lower a 2-lane 64-bit shuffle using shuffle operations provided by
7361 /// the integer unit to minimize domain crossing penalties. However, for blends
7362 /// it falls back to the floating point shuffle operation with appropriate bit
7363 /// casting.
7364 static SDValue lowerV2I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
7365                                        const X86Subtarget *Subtarget,
7366                                        SelectionDAG &DAG) {
7367   SDLoc DL(Op);
7368   assert(Op.getSimpleValueType() == MVT::v2i64 && "Bad shuffle type!");
7369   assert(V1.getSimpleValueType() == MVT::v2i64 && "Bad operand type!");
7370   assert(V2.getSimpleValueType() == MVT::v2i64 && "Bad operand type!");
7371   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
7372   ArrayRef<int> Mask = SVOp->getMask();
7373   assert(Mask.size() == 2 && "Unexpected mask size for v2 shuffle!");
7374
7375   if (isSingleInputShuffleMask(Mask)) {
7376     // Check for being able to broadcast a single element.
7377     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v2i64, V1,
7378                                                           Mask, Subtarget, DAG))
7379       return Broadcast;
7380
7381     // Straight shuffle of a single input vector. For everything from SSE2
7382     // onward this has a single fast instruction with no scary immediates.
7383     // We have to map the mask as it is actually a v4i32 shuffle instruction.
7384     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V1);
7385     int WidenedMask[4] = {
7386         std::max(Mask[0], 0) * 2, std::max(Mask[0], 0) * 2 + 1,
7387         std::max(Mask[1], 0) * 2, std::max(Mask[1], 0) * 2 + 1};
7388     return DAG.getNode(
7389         ISD::BITCAST, DL, MVT::v2i64,
7390         DAG.getNode(X86ISD::PSHUFD, SDLoc(Op), MVT::v4i32, V1,
7391                     getV4X86ShuffleImm8ForMask(WidenedMask, DAG)));
7392   }
7393   assert(Mask[0] != -1 && "No undef lanes in multi-input v2 shuffles!");
7394   assert(Mask[1] != -1 && "No undef lanes in multi-input v2 shuffles!");
7395   assert(Mask[0] < 2 && "We sort V1 to be the first input.");
7396   assert(Mask[1] >= 2 && "We sort V2 to be the second input.");
7397
7398   // If we have a blend of two PACKUS operations an the blend aligns with the
7399   // low and half halves, we can just merge the PACKUS operations. This is
7400   // particularly important as it lets us merge shuffles that this routine itself
7401   // creates.
7402   auto GetPackNode = [](SDValue V) {
7403     while (V.getOpcode() == ISD::BITCAST)
7404       V = V.getOperand(0);
7405
7406     return V.getOpcode() == X86ISD::PACKUS ? V : SDValue();
7407   };
7408   if (SDValue V1Pack = GetPackNode(V1))
7409     if (SDValue V2Pack = GetPackNode(V2))
7410       return DAG.getNode(ISD::BITCAST, DL, MVT::v2i64,
7411                          DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8,
7412                                      Mask[0] == 0 ? V1Pack.getOperand(0)
7413                                                   : V1Pack.getOperand(1),
7414                                      Mask[1] == 2 ? V2Pack.getOperand(0)
7415                                                   : V2Pack.getOperand(1)));
7416
7417   // Try to use shift instructions.
7418   if (SDValue Shift =
7419           lowerVectorShuffleAsShift(DL, MVT::v2i64, V1, V2, Mask, DAG))
7420     return Shift;
7421
7422   // When loading a scalar and then shuffling it into a vector we can often do
7423   // the insertion cheaply.
7424   if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
7425           DL, MVT::v2i64, V1, V2, Mask, Subtarget, DAG))
7426     return Insertion;
7427   // Try inverting the insertion since for v2 masks it is easy to do and we
7428   // can't reliably sort the mask one way or the other.
7429   int InverseMask[2] = {Mask[0] ^ 2, Mask[1] ^ 2};
7430   if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
7431           DL, MVT::v2i64, V2, V1, InverseMask, Subtarget, DAG))
7432     return Insertion;
7433
7434   // We have different paths for blend lowering, but they all must use the
7435   // *exact* same predicate.
7436   bool IsBlendSupported = Subtarget->hasSSE41();
7437   if (IsBlendSupported)
7438     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v2i64, V1, V2, Mask,
7439                                                   Subtarget, DAG))
7440       return Blend;
7441
7442   // Use dedicated unpack instructions for masks that match their pattern.
7443   if (isShuffleEquivalent(V1, V2, Mask, {0, 2}))
7444     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2i64, V1, V2);
7445   if (isShuffleEquivalent(V1, V2, Mask, {1, 3}))
7446     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v2i64, V1, V2);
7447
7448   // Try to use byte rotation instructions.
7449   // Its more profitable for pre-SSSE3 to use shuffles/unpacks.
7450   if (Subtarget->hasSSSE3())
7451     if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
7452             DL, MVT::v2i64, V1, V2, Mask, Subtarget, DAG))
7453       return Rotate;
7454
7455   // If we have direct support for blends, we should lower by decomposing into
7456   // a permute. That will be faster than the domain cross.
7457   if (IsBlendSupported)
7458     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v2i64, V1, V2,
7459                                                       Mask, DAG);
7460
7461   // We implement this with SHUFPD which is pretty lame because it will likely
7462   // incur 2 cycles of stall for integer vectors on Nehalem and older chips.
7463   // However, all the alternatives are still more cycles and newer chips don't
7464   // have this problem. It would be really nice if x86 had better shuffles here.
7465   V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, V1);
7466   V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, V2);
7467   return DAG.getNode(ISD::BITCAST, DL, MVT::v2i64,
7468                      DAG.getVectorShuffle(MVT::v2f64, DL, V1, V2, Mask));
7469 }
7470
7471 /// \brief Test whether this can be lowered with a single SHUFPS instruction.
7472 ///
7473 /// This is used to disable more specialized lowerings when the shufps lowering
7474 /// will happen to be efficient.
7475 static bool isSingleSHUFPSMask(ArrayRef<int> Mask) {
7476   // This routine only handles 128-bit shufps.
7477   assert(Mask.size() == 4 && "Unsupported mask size!");
7478
7479   // To lower with a single SHUFPS we need to have the low half and high half
7480   // each requiring a single input.
7481   if (Mask[0] != -1 && Mask[1] != -1 && (Mask[0] < 4) != (Mask[1] < 4))
7482     return false;
7483   if (Mask[2] != -1 && Mask[3] != -1 && (Mask[2] < 4) != (Mask[3] < 4))
7484     return false;
7485
7486   return true;
7487 }
7488
7489 /// \brief Lower a vector shuffle using the SHUFPS instruction.
7490 ///
7491 /// This is a helper routine dedicated to lowering vector shuffles using SHUFPS.
7492 /// It makes no assumptions about whether this is the *best* lowering, it simply
7493 /// uses it.
7494 static SDValue lowerVectorShuffleWithSHUFPS(SDLoc DL, MVT VT,
7495                                             ArrayRef<int> Mask, SDValue V1,
7496                                             SDValue V2, SelectionDAG &DAG) {
7497   SDValue LowV = V1, HighV = V2;
7498   int NewMask[4] = {Mask[0], Mask[1], Mask[2], Mask[3]};
7499
7500   int NumV2Elements =
7501       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
7502
7503   if (NumV2Elements == 1) {
7504     int V2Index =
7505         std::find_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; }) -
7506         Mask.begin();
7507
7508     // Compute the index adjacent to V2Index and in the same half by toggling
7509     // the low bit.
7510     int V2AdjIndex = V2Index ^ 1;
7511
7512     if (Mask[V2AdjIndex] == -1) {
7513       // Handles all the cases where we have a single V2 element and an undef.
7514       // This will only ever happen in the high lanes because we commute the
7515       // vector otherwise.
7516       if (V2Index < 2)
7517         std::swap(LowV, HighV);
7518       NewMask[V2Index] -= 4;
7519     } else {
7520       // Handle the case where the V2 element ends up adjacent to a V1 element.
7521       // To make this work, blend them together as the first step.
7522       int V1Index = V2AdjIndex;
7523       int BlendMask[4] = {Mask[V2Index] - 4, 0, Mask[V1Index], 0};
7524       V2 = DAG.getNode(X86ISD::SHUFP, DL, VT, V2, V1,
7525                        getV4X86ShuffleImm8ForMask(BlendMask, DAG));
7526
7527       // Now proceed to reconstruct the final blend as we have the necessary
7528       // high or low half formed.
7529       if (V2Index < 2) {
7530         LowV = V2;
7531         HighV = V1;
7532       } else {
7533         HighV = V2;
7534       }
7535       NewMask[V1Index] = 2; // We put the V1 element in V2[2].
7536       NewMask[V2Index] = 0; // We shifted the V2 element into V2[0].
7537     }
7538   } else if (NumV2Elements == 2) {
7539     if (Mask[0] < 4 && Mask[1] < 4) {
7540       // Handle the easy case where we have V1 in the low lanes and V2 in the
7541       // high lanes.
7542       NewMask[2] -= 4;
7543       NewMask[3] -= 4;
7544     } else if (Mask[2] < 4 && Mask[3] < 4) {
7545       // We also handle the reversed case because this utility may get called
7546       // when we detect a SHUFPS pattern but can't easily commute the shuffle to
7547       // arrange things in the right direction.
7548       NewMask[0] -= 4;
7549       NewMask[1] -= 4;
7550       HighV = V1;
7551       LowV = V2;
7552     } else {
7553       // We have a mixture of V1 and V2 in both low and high lanes. Rather than
7554       // trying to place elements directly, just blend them and set up the final
7555       // shuffle to place them.
7556
7557       // The first two blend mask elements are for V1, the second two are for
7558       // V2.
7559       int BlendMask[4] = {Mask[0] < 4 ? Mask[0] : Mask[1],
7560                           Mask[2] < 4 ? Mask[2] : Mask[3],
7561                           (Mask[0] >= 4 ? Mask[0] : Mask[1]) - 4,
7562                           (Mask[2] >= 4 ? Mask[2] : Mask[3]) - 4};
7563       V1 = DAG.getNode(X86ISD::SHUFP, DL, VT, V1, V2,
7564                        getV4X86ShuffleImm8ForMask(BlendMask, DAG));
7565
7566       // Now we do a normal shuffle of V1 by giving V1 as both operands to
7567       // a blend.
7568       LowV = HighV = V1;
7569       NewMask[0] = Mask[0] < 4 ? 0 : 2;
7570       NewMask[1] = Mask[0] < 4 ? 2 : 0;
7571       NewMask[2] = Mask[2] < 4 ? 1 : 3;
7572       NewMask[3] = Mask[2] < 4 ? 3 : 1;
7573     }
7574   }
7575   return DAG.getNode(X86ISD::SHUFP, DL, VT, LowV, HighV,
7576                      getV4X86ShuffleImm8ForMask(NewMask, DAG));
7577 }
7578
7579 /// \brief Lower 4-lane 32-bit floating point shuffles.
7580 ///
7581 /// Uses instructions exclusively from the floating point unit to minimize
7582 /// domain crossing penalties, as these are sufficient to implement all v4f32
7583 /// shuffles.
7584 static SDValue lowerV4F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
7585                                        const X86Subtarget *Subtarget,
7586                                        SelectionDAG &DAG) {
7587   SDLoc DL(Op);
7588   assert(Op.getSimpleValueType() == MVT::v4f32 && "Bad shuffle type!");
7589   assert(V1.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
7590   assert(V2.getSimpleValueType() == MVT::v4f32 && "Bad operand type!");
7591   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
7592   ArrayRef<int> Mask = SVOp->getMask();
7593   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
7594
7595   int NumV2Elements =
7596       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
7597
7598   if (NumV2Elements == 0) {
7599     // Check for being able to broadcast a single element.
7600     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v4f32, V1,
7601                                                           Mask, Subtarget, DAG))
7602       return Broadcast;
7603
7604     // Use even/odd duplicate instructions for masks that match their pattern.
7605     if (Subtarget->hasSSE3()) {
7606       if (isShuffleEquivalent(V1, V2, Mask, {0, 0, 2, 2}))
7607         return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v4f32, V1);
7608       if (isShuffleEquivalent(V1, V2, Mask, {1, 1, 3, 3}))
7609         return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v4f32, V1);
7610     }
7611
7612     if (Subtarget->hasAVX()) {
7613       // If we have AVX, we can use VPERMILPS which will allow folding a load
7614       // into the shuffle.
7615       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f32, V1,
7616                          getV4X86ShuffleImm8ForMask(Mask, DAG));
7617     }
7618
7619     // Otherwise, use a straight shuffle of a single input vector. We pass the
7620     // input vector to both operands to simulate this with a SHUFPS.
7621     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f32, V1, V1,
7622                        getV4X86ShuffleImm8ForMask(Mask, DAG));
7623   }
7624
7625   // There are special ways we can lower some single-element blends. However, we
7626   // have custom ways we can lower more complex single-element blends below that
7627   // we defer to if both this and BLENDPS fail to match, so restrict this to
7628   // when the V2 input is targeting element 0 of the mask -- that is the fast
7629   // case here.
7630   if (NumV2Elements == 1 && Mask[0] >= 4)
7631     if (SDValue V = lowerVectorShuffleAsElementInsertion(DL, MVT::v4f32, V1, V2,
7632                                                          Mask, Subtarget, DAG))
7633       return V;
7634
7635   if (Subtarget->hasSSE41()) {
7636     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4f32, V1, V2, Mask,
7637                                                   Subtarget, DAG))
7638       return Blend;
7639
7640     // Use INSERTPS if we can complete the shuffle efficiently.
7641     if (SDValue V = lowerVectorShuffleAsInsertPS(Op, V1, V2, Mask, DAG))
7642       return V;
7643
7644     if (!isSingleSHUFPSMask(Mask))
7645       if (SDValue BlendPerm = lowerVectorShuffleAsBlendAndPermute(
7646               DL, MVT::v4f32, V1, V2, Mask, DAG))
7647         return BlendPerm;
7648   }
7649
7650   // Use dedicated unpack instructions for masks that match their pattern.
7651   if (isShuffleEquivalent(V1, V2, Mask, {0, 4, 1, 5}))
7652     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f32, V1, V2);
7653   if (isShuffleEquivalent(V1, V2, Mask, {2, 6, 3, 7}))
7654     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f32, V1, V2);
7655   if (isShuffleEquivalent(V1, V2, Mask, {4, 0, 5, 1}))
7656     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f32, V2, V1);
7657   if (isShuffleEquivalent(V1, V2, Mask, {6, 2, 7, 3}))
7658     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f32, V2, V1);
7659
7660   // Otherwise fall back to a SHUFPS lowering strategy.
7661   return lowerVectorShuffleWithSHUFPS(DL, MVT::v4f32, Mask, V1, V2, DAG);
7662 }
7663
7664 /// \brief Lower 4-lane i32 vector shuffles.
7665 ///
7666 /// We try to handle these with integer-domain shuffles where we can, but for
7667 /// blends we use the floating point domain blend instructions.
7668 static SDValue lowerV4I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
7669                                        const X86Subtarget *Subtarget,
7670                                        SelectionDAG &DAG) {
7671   SDLoc DL(Op);
7672   assert(Op.getSimpleValueType() == MVT::v4i32 && "Bad shuffle type!");
7673   assert(V1.getSimpleValueType() == MVT::v4i32 && "Bad operand type!");
7674   assert(V2.getSimpleValueType() == MVT::v4i32 && "Bad operand type!");
7675   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
7676   ArrayRef<int> Mask = SVOp->getMask();
7677   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
7678
7679   // Whenever we can lower this as a zext, that instruction is strictly faster
7680   // than any alternative. It also allows us to fold memory operands into the
7681   // shuffle in many cases.
7682   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v4i32, V1, V2,
7683                                                          Mask, Subtarget, DAG))
7684     return ZExt;
7685
7686   int NumV2Elements =
7687       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 4; });
7688
7689   if (NumV2Elements == 0) {
7690     // Check for being able to broadcast a single element.
7691     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v4i32, V1,
7692                                                           Mask, Subtarget, DAG))
7693       return Broadcast;
7694
7695     // Straight shuffle of a single input vector. For everything from SSE2
7696     // onward this has a single fast instruction with no scary immediates.
7697     // We coerce the shuffle pattern to be compatible with UNPCK instructions
7698     // but we aren't actually going to use the UNPCK instruction because doing
7699     // so prevents folding a load into this instruction or making a copy.
7700     const int UnpackLoMask[] = {0, 0, 1, 1};
7701     const int UnpackHiMask[] = {2, 2, 3, 3};
7702     if (isShuffleEquivalent(V1, V2, Mask, {0, 0, 1, 1}))
7703       Mask = UnpackLoMask;
7704     else if (isShuffleEquivalent(V1, V2, Mask, {2, 2, 3, 3}))
7705       Mask = UnpackHiMask;
7706
7707     return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V1,
7708                        getV4X86ShuffleImm8ForMask(Mask, DAG));
7709   }
7710
7711   // Try to use shift instructions.
7712   if (SDValue Shift =
7713           lowerVectorShuffleAsShift(DL, MVT::v4i32, V1, V2, Mask, DAG))
7714     return Shift;
7715
7716   // There are special ways we can lower some single-element blends.
7717   if (NumV2Elements == 1)
7718     if (SDValue V = lowerVectorShuffleAsElementInsertion(DL, MVT::v4i32, V1, V2,
7719                                                          Mask, Subtarget, DAG))
7720       return V;
7721
7722   // We have different paths for blend lowering, but they all must use the
7723   // *exact* same predicate.
7724   bool IsBlendSupported = Subtarget->hasSSE41();
7725   if (IsBlendSupported)
7726     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4i32, V1, V2, Mask,
7727                                                   Subtarget, DAG))
7728       return Blend;
7729
7730   if (SDValue Masked =
7731           lowerVectorShuffleAsBitMask(DL, MVT::v4i32, V1, V2, Mask, DAG))
7732     return Masked;
7733
7734   // Use dedicated unpack instructions for masks that match their pattern.
7735   if (isShuffleEquivalent(V1, V2, Mask, {0, 4, 1, 5}))
7736     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i32, V1, V2);
7737   if (isShuffleEquivalent(V1, V2, Mask, {2, 6, 3, 7}))
7738     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i32, V1, V2);
7739   if (isShuffleEquivalent(V1, V2, Mask, {4, 0, 5, 1}))
7740     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i32, V2, V1);
7741   if (isShuffleEquivalent(V1, V2, Mask, {6, 2, 7, 3}))
7742     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i32, V2, V1);
7743
7744   // Try to use byte rotation instructions.
7745   // Its more profitable for pre-SSSE3 to use shuffles/unpacks.
7746   if (Subtarget->hasSSSE3())
7747     if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
7748             DL, MVT::v4i32, V1, V2, Mask, Subtarget, DAG))
7749       return Rotate;
7750
7751   // If we have direct support for blends, we should lower by decomposing into
7752   // a permute. That will be faster than the domain cross.
7753   if (IsBlendSupported)
7754     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4i32, V1, V2,
7755                                                       Mask, DAG);
7756
7757   // Try to lower by permuting the inputs into an unpack instruction.
7758   if (SDValue Unpack =
7759           lowerVectorShuffleAsUnpack(DL, MVT::v4i32, V1, V2, Mask, DAG))
7760     return Unpack;
7761
7762   // We implement this with SHUFPS because it can blend from two vectors.
7763   // Because we're going to eventually use SHUFPS, we use SHUFPS even to build
7764   // up the inputs, bypassing domain shift penalties that we would encur if we
7765   // directly used PSHUFD on Nehalem and older. For newer chips, this isn't
7766   // relevant.
7767   return DAG.getNode(ISD::BITCAST, DL, MVT::v4i32,
7768                      DAG.getVectorShuffle(
7769                          MVT::v4f32, DL,
7770                          DAG.getNode(ISD::BITCAST, DL, MVT::v4f32, V1),
7771                          DAG.getNode(ISD::BITCAST, DL, MVT::v4f32, V2), Mask));
7772 }
7773
7774 /// \brief Lowering of single-input v8i16 shuffles is the cornerstone of SSE2
7775 /// shuffle lowering, and the most complex part.
7776 ///
7777 /// The lowering strategy is to try to form pairs of input lanes which are
7778 /// targeted at the same half of the final vector, and then use a dword shuffle
7779 /// to place them onto the right half, and finally unpack the paired lanes into
7780 /// their final position.
7781 ///
7782 /// The exact breakdown of how to form these dword pairs and align them on the
7783 /// correct sides is really tricky. See the comments within the function for
7784 /// more of the details.
7785 ///
7786 /// This code also handles repeated 128-bit lanes of v8i16 shuffles, but each
7787 /// lane must shuffle the *exact* same way. In fact, you must pass a v8 Mask to
7788 /// this routine for it to work correctly. To shuffle a 256-bit or 512-bit i16
7789 /// vector, form the analogous 128-bit 8-element Mask.
7790 static SDValue lowerV8I16GeneralSingleInputVectorShuffle(
7791     SDLoc DL, MVT VT, SDValue V, MutableArrayRef<int> Mask,
7792     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
7793   assert(VT.getScalarType() == MVT::i16 && "Bad input type!");
7794   MVT PSHUFDVT = MVT::getVectorVT(MVT::i32, VT.getVectorNumElements() / 2);
7795
7796   assert(Mask.size() == 8 && "Shuffle mask length doen't match!");
7797   MutableArrayRef<int> LoMask = Mask.slice(0, 4);
7798   MutableArrayRef<int> HiMask = Mask.slice(4, 4);
7799
7800   SmallVector<int, 4> LoInputs;
7801   std::copy_if(LoMask.begin(), LoMask.end(), std::back_inserter(LoInputs),
7802                [](int M) { return M >= 0; });
7803   std::sort(LoInputs.begin(), LoInputs.end());
7804   LoInputs.erase(std::unique(LoInputs.begin(), LoInputs.end()), LoInputs.end());
7805   SmallVector<int, 4> HiInputs;
7806   std::copy_if(HiMask.begin(), HiMask.end(), std::back_inserter(HiInputs),
7807                [](int M) { return M >= 0; });
7808   std::sort(HiInputs.begin(), HiInputs.end());
7809   HiInputs.erase(std::unique(HiInputs.begin(), HiInputs.end()), HiInputs.end());
7810   int NumLToL =
7811       std::lower_bound(LoInputs.begin(), LoInputs.end(), 4) - LoInputs.begin();
7812   int NumHToL = LoInputs.size() - NumLToL;
7813   int NumLToH =
7814       std::lower_bound(HiInputs.begin(), HiInputs.end(), 4) - HiInputs.begin();
7815   int NumHToH = HiInputs.size() - NumLToH;
7816   MutableArrayRef<int> LToLInputs(LoInputs.data(), NumLToL);
7817   MutableArrayRef<int> LToHInputs(HiInputs.data(), NumLToH);
7818   MutableArrayRef<int> HToLInputs(LoInputs.data() + NumLToL, NumHToL);
7819   MutableArrayRef<int> HToHInputs(HiInputs.data() + NumLToH, NumHToH);
7820
7821   // Simplify the 1-into-3 and 3-into-1 cases with a single pshufd. For all
7822   // such inputs we can swap two of the dwords across the half mark and end up
7823   // with <=2 inputs to each half in each half. Once there, we can fall through
7824   // to the generic code below. For example:
7825   //
7826   // Input: [a, b, c, d, e, f, g, h] -PSHUFD[0,2,1,3]-> [a, b, e, f, c, d, g, h]
7827   // Mask:  [0, 1, 2, 7, 4, 5, 6, 3] -----------------> [0, 1, 4, 7, 2, 3, 6, 5]
7828   //
7829   // However in some very rare cases we have a 1-into-3 or 3-into-1 on one half
7830   // and an existing 2-into-2 on the other half. In this case we may have to
7831   // pre-shuffle the 2-into-2 half to avoid turning it into a 3-into-1 or
7832   // 1-into-3 which could cause us to cycle endlessly fixing each side in turn.
7833   // Fortunately, we don't have to handle anything but a 2-into-2 pattern
7834   // because any other situation (including a 3-into-1 or 1-into-3 in the other
7835   // half than the one we target for fixing) will be fixed when we re-enter this
7836   // path. We will also combine away any sequence of PSHUFD instructions that
7837   // result into a single instruction. Here is an example of the tricky case:
7838   //
7839   // Input: [a, b, c, d, e, f, g, h] -PSHUFD[0,2,1,3]-> [a, b, e, f, c, d, g, h]
7840   // Mask:  [3, 7, 1, 0, 2, 7, 3, 5] -THIS-IS-BAD!!!!-> [5, 7, 1, 0, 4, 7, 5, 3]
7841   //
7842   // This now has a 1-into-3 in the high half! Instead, we do two shuffles:
7843   //
7844   // Input: [a, b, c, d, e, f, g, h] PSHUFHW[0,2,1,3]-> [a, b, c, d, e, g, f, h]
7845   // Mask:  [3, 7, 1, 0, 2, 7, 3, 5] -----------------> [3, 7, 1, 0, 2, 7, 3, 6]
7846   //
7847   // Input: [a, b, c, d, e, g, f, h] -PSHUFD[0,2,1,3]-> [a, b, e, g, c, d, f, h]
7848   // Mask:  [3, 7, 1, 0, 2, 7, 3, 6] -----------------> [5, 7, 1, 0, 4, 7, 5, 6]
7849   //
7850   // The result is fine to be handled by the generic logic.
7851   auto balanceSides = [&](ArrayRef<int> AToAInputs, ArrayRef<int> BToAInputs,
7852                           ArrayRef<int> BToBInputs, ArrayRef<int> AToBInputs,
7853                           int AOffset, int BOffset) {
7854     assert((AToAInputs.size() == 3 || AToAInputs.size() == 1) &&
7855            "Must call this with A having 3 or 1 inputs from the A half.");
7856     assert((BToAInputs.size() == 1 || BToAInputs.size() == 3) &&
7857            "Must call this with B having 1 or 3 inputs from the B half.");
7858     assert(AToAInputs.size() + BToAInputs.size() == 4 &&
7859            "Must call this with either 3:1 or 1:3 inputs (summing to 4).");
7860
7861     // Compute the index of dword with only one word among the three inputs in
7862     // a half by taking the sum of the half with three inputs and subtracting
7863     // the sum of the actual three inputs. The difference is the remaining
7864     // slot.
7865     int ADWord, BDWord;
7866     int &TripleDWord = AToAInputs.size() == 3 ? ADWord : BDWord;
7867     int &OneInputDWord = AToAInputs.size() == 3 ? BDWord : ADWord;
7868     int TripleInputOffset = AToAInputs.size() == 3 ? AOffset : BOffset;
7869     ArrayRef<int> TripleInputs = AToAInputs.size() == 3 ? AToAInputs : BToAInputs;
7870     int OneInput = AToAInputs.size() == 3 ? BToAInputs[0] : AToAInputs[0];
7871     int TripleInputSum = 0 + 1 + 2 + 3 + (4 * TripleInputOffset);
7872     int TripleNonInputIdx =
7873         TripleInputSum - std::accumulate(TripleInputs.begin(), TripleInputs.end(), 0);
7874     TripleDWord = TripleNonInputIdx / 2;
7875
7876     // We use xor with one to compute the adjacent DWord to whichever one the
7877     // OneInput is in.
7878     OneInputDWord = (OneInput / 2) ^ 1;
7879
7880     // Check for one tricky case: We're fixing a 3<-1 or a 1<-3 shuffle for AToA
7881     // and BToA inputs. If there is also such a problem with the BToB and AToB
7882     // inputs, we don't try to fix it necessarily -- we'll recurse and see it in
7883     // the next pass. However, if we have a 2<-2 in the BToB and AToB inputs, it
7884     // is essential that we don't *create* a 3<-1 as then we might oscillate.
7885     if (BToBInputs.size() == 2 && AToBInputs.size() == 2) {
7886       // Compute how many inputs will be flipped by swapping these DWords. We
7887       // need
7888       // to balance this to ensure we don't form a 3-1 shuffle in the other
7889       // half.
7890       int NumFlippedAToBInputs =
7891           std::count(AToBInputs.begin(), AToBInputs.end(), 2 * ADWord) +
7892           std::count(AToBInputs.begin(), AToBInputs.end(), 2 * ADWord + 1);
7893       int NumFlippedBToBInputs =
7894           std::count(BToBInputs.begin(), BToBInputs.end(), 2 * BDWord) +
7895           std::count(BToBInputs.begin(), BToBInputs.end(), 2 * BDWord + 1);
7896       if ((NumFlippedAToBInputs == 1 &&
7897            (NumFlippedBToBInputs == 0 || NumFlippedBToBInputs == 2)) ||
7898           (NumFlippedBToBInputs == 1 &&
7899            (NumFlippedAToBInputs == 0 || NumFlippedAToBInputs == 2))) {
7900         // We choose whether to fix the A half or B half based on whether that
7901         // half has zero flipped inputs. At zero, we may not be able to fix it
7902         // with that half. We also bias towards fixing the B half because that
7903         // will more commonly be the high half, and we have to bias one way.
7904         auto FixFlippedInputs = [&V, &DL, &Mask, &DAG](int PinnedIdx, int DWord,
7905                                                        ArrayRef<int> Inputs) {
7906           int FixIdx = PinnedIdx ^ 1; // The adjacent slot to the pinned slot.
7907           bool IsFixIdxInput = std::find(Inputs.begin(), Inputs.end(),
7908                                          PinnedIdx ^ 1) != Inputs.end();
7909           // Determine whether the free index is in the flipped dword or the
7910           // unflipped dword based on where the pinned index is. We use this bit
7911           // in an xor to conditionally select the adjacent dword.
7912           int FixFreeIdx = 2 * (DWord ^ (PinnedIdx / 2 == DWord));
7913           bool IsFixFreeIdxInput = std::find(Inputs.begin(), Inputs.end(),
7914                                              FixFreeIdx) != Inputs.end();
7915           if (IsFixIdxInput == IsFixFreeIdxInput)
7916             FixFreeIdx += 1;
7917           IsFixFreeIdxInput = std::find(Inputs.begin(), Inputs.end(),
7918                                         FixFreeIdx) != Inputs.end();
7919           assert(IsFixIdxInput != IsFixFreeIdxInput &&
7920                  "We need to be changing the number of flipped inputs!");
7921           int PSHUFHalfMask[] = {0, 1, 2, 3};
7922           std::swap(PSHUFHalfMask[FixFreeIdx % 4], PSHUFHalfMask[FixIdx % 4]);
7923           V = DAG.getNode(FixIdx < 4 ? X86ISD::PSHUFLW : X86ISD::PSHUFHW, DL,
7924                           MVT::v8i16, V,
7925                           getV4X86ShuffleImm8ForMask(PSHUFHalfMask, DAG));
7926
7927           for (int &M : Mask)
7928             if (M != -1 && M == FixIdx)
7929               M = FixFreeIdx;
7930             else if (M != -1 && M == FixFreeIdx)
7931               M = FixIdx;
7932         };
7933         if (NumFlippedBToBInputs != 0) {
7934           int BPinnedIdx =
7935               BToAInputs.size() == 3 ? TripleNonInputIdx : OneInput;
7936           FixFlippedInputs(BPinnedIdx, BDWord, BToBInputs);
7937         } else {
7938           assert(NumFlippedAToBInputs != 0 && "Impossible given predicates!");
7939           int APinnedIdx =
7940               AToAInputs.size() == 3 ? TripleNonInputIdx : OneInput;
7941           FixFlippedInputs(APinnedIdx, ADWord, AToBInputs);
7942         }
7943       }
7944     }
7945
7946     int PSHUFDMask[] = {0, 1, 2, 3};
7947     PSHUFDMask[ADWord] = BDWord;
7948     PSHUFDMask[BDWord] = ADWord;
7949     V = DAG.getNode(ISD::BITCAST, DL, VT,
7950                     DAG.getNode(X86ISD::PSHUFD, DL, PSHUFDVT,
7951                                 DAG.getNode(ISD::BITCAST, DL, PSHUFDVT, V),
7952                                 getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
7953
7954     // Adjust the mask to match the new locations of A and B.
7955     for (int &M : Mask)
7956       if (M != -1 && M/2 == ADWord)
7957         M = 2 * BDWord + M % 2;
7958       else if (M != -1 && M/2 == BDWord)
7959         M = 2 * ADWord + M % 2;
7960
7961     // Recurse back into this routine to re-compute state now that this isn't
7962     // a 3 and 1 problem.
7963     return lowerV8I16GeneralSingleInputVectorShuffle(DL, VT, V, Mask, Subtarget,
7964                                                      DAG);
7965   };
7966   if ((NumLToL == 3 && NumHToL == 1) || (NumLToL == 1 && NumHToL == 3))
7967     return balanceSides(LToLInputs, HToLInputs, HToHInputs, LToHInputs, 0, 4);
7968   else if ((NumHToH == 3 && NumLToH == 1) || (NumHToH == 1 && NumLToH == 3))
7969     return balanceSides(HToHInputs, LToHInputs, LToLInputs, HToLInputs, 4, 0);
7970
7971   // At this point there are at most two inputs to the low and high halves from
7972   // each half. That means the inputs can always be grouped into dwords and
7973   // those dwords can then be moved to the correct half with a dword shuffle.
7974   // We use at most one low and one high word shuffle to collect these paired
7975   // inputs into dwords, and finally a dword shuffle to place them.
7976   int PSHUFLMask[4] = {-1, -1, -1, -1};
7977   int PSHUFHMask[4] = {-1, -1, -1, -1};
7978   int PSHUFDMask[4] = {-1, -1, -1, -1};
7979
7980   // First fix the masks for all the inputs that are staying in their
7981   // original halves. This will then dictate the targets of the cross-half
7982   // shuffles.
7983   auto fixInPlaceInputs =
7984       [&PSHUFDMask](ArrayRef<int> InPlaceInputs, ArrayRef<int> IncomingInputs,
7985                     MutableArrayRef<int> SourceHalfMask,
7986                     MutableArrayRef<int> HalfMask, int HalfOffset) {
7987     if (InPlaceInputs.empty())
7988       return;
7989     if (InPlaceInputs.size() == 1) {
7990       SourceHalfMask[InPlaceInputs[0] - HalfOffset] =
7991           InPlaceInputs[0] - HalfOffset;
7992       PSHUFDMask[InPlaceInputs[0] / 2] = InPlaceInputs[0] / 2;
7993       return;
7994     }
7995     if (IncomingInputs.empty()) {
7996       // Just fix all of the in place inputs.
7997       for (int Input : InPlaceInputs) {
7998         SourceHalfMask[Input - HalfOffset] = Input - HalfOffset;
7999         PSHUFDMask[Input / 2] = Input / 2;
8000       }
8001       return;
8002     }
8003
8004     assert(InPlaceInputs.size() == 2 && "Cannot handle 3 or 4 inputs!");
8005     SourceHalfMask[InPlaceInputs[0] - HalfOffset] =
8006         InPlaceInputs[0] - HalfOffset;
8007     // Put the second input next to the first so that they are packed into
8008     // a dword. We find the adjacent index by toggling the low bit.
8009     int AdjIndex = InPlaceInputs[0] ^ 1;
8010     SourceHalfMask[AdjIndex - HalfOffset] = InPlaceInputs[1] - HalfOffset;
8011     std::replace(HalfMask.begin(), HalfMask.end(), InPlaceInputs[1], AdjIndex);
8012     PSHUFDMask[AdjIndex / 2] = AdjIndex / 2;
8013   };
8014   fixInPlaceInputs(LToLInputs, HToLInputs, PSHUFLMask, LoMask, 0);
8015   fixInPlaceInputs(HToHInputs, LToHInputs, PSHUFHMask, HiMask, 4);
8016
8017   // Now gather the cross-half inputs and place them into a free dword of
8018   // their target half.
8019   // FIXME: This operation could almost certainly be simplified dramatically to
8020   // look more like the 3-1 fixing operation.
8021   auto moveInputsToRightHalf = [&PSHUFDMask](
8022       MutableArrayRef<int> IncomingInputs, ArrayRef<int> ExistingInputs,
8023       MutableArrayRef<int> SourceHalfMask, MutableArrayRef<int> HalfMask,
8024       MutableArrayRef<int> FinalSourceHalfMask, int SourceOffset,
8025       int DestOffset) {
8026     auto isWordClobbered = [](ArrayRef<int> SourceHalfMask, int Word) {
8027       return SourceHalfMask[Word] != -1 && SourceHalfMask[Word] != Word;
8028     };
8029     auto isDWordClobbered = [&isWordClobbered](ArrayRef<int> SourceHalfMask,
8030                                                int Word) {
8031       int LowWord = Word & ~1;
8032       int HighWord = Word | 1;
8033       return isWordClobbered(SourceHalfMask, LowWord) ||
8034              isWordClobbered(SourceHalfMask, HighWord);
8035     };
8036
8037     if (IncomingInputs.empty())
8038       return;
8039
8040     if (ExistingInputs.empty()) {
8041       // Map any dwords with inputs from them into the right half.
8042       for (int Input : IncomingInputs) {
8043         // If the source half mask maps over the inputs, turn those into
8044         // swaps and use the swapped lane.
8045         if (isWordClobbered(SourceHalfMask, Input - SourceOffset)) {
8046           if (SourceHalfMask[SourceHalfMask[Input - SourceOffset]] == -1) {
8047             SourceHalfMask[SourceHalfMask[Input - SourceOffset]] =
8048                 Input - SourceOffset;
8049             // We have to swap the uses in our half mask in one sweep.
8050             for (int &M : HalfMask)
8051               if (M == SourceHalfMask[Input - SourceOffset] + SourceOffset)
8052                 M = Input;
8053               else if (M == Input)
8054                 M = SourceHalfMask[Input - SourceOffset] + SourceOffset;
8055           } else {
8056             assert(SourceHalfMask[SourceHalfMask[Input - SourceOffset]] ==
8057                        Input - SourceOffset &&
8058                    "Previous placement doesn't match!");
8059           }
8060           // Note that this correctly re-maps both when we do a swap and when
8061           // we observe the other side of the swap above. We rely on that to
8062           // avoid swapping the members of the input list directly.
8063           Input = SourceHalfMask[Input - SourceOffset] + SourceOffset;
8064         }
8065
8066         // Map the input's dword into the correct half.
8067         if (PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] == -1)
8068           PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] = Input / 2;
8069         else
8070           assert(PSHUFDMask[(Input - SourceOffset + DestOffset) / 2] ==
8071                      Input / 2 &&
8072                  "Previous placement doesn't match!");
8073       }
8074
8075       // And just directly shift any other-half mask elements to be same-half
8076       // as we will have mirrored the dword containing the element into the
8077       // same position within that half.
8078       for (int &M : HalfMask)
8079         if (M >= SourceOffset && M < SourceOffset + 4) {
8080           M = M - SourceOffset + DestOffset;
8081           assert(M >= 0 && "This should never wrap below zero!");
8082         }
8083       return;
8084     }
8085
8086     // Ensure we have the input in a viable dword of its current half. This
8087     // is particularly tricky because the original position may be clobbered
8088     // by inputs being moved and *staying* in that half.
8089     if (IncomingInputs.size() == 1) {
8090       if (isWordClobbered(SourceHalfMask, IncomingInputs[0] - SourceOffset)) {
8091         int InputFixed = std::find(std::begin(SourceHalfMask),
8092                                    std::end(SourceHalfMask), -1) -
8093                          std::begin(SourceHalfMask) + SourceOffset;
8094         SourceHalfMask[InputFixed - SourceOffset] =
8095             IncomingInputs[0] - SourceOffset;
8096         std::replace(HalfMask.begin(), HalfMask.end(), IncomingInputs[0],
8097                      InputFixed);
8098         IncomingInputs[0] = InputFixed;
8099       }
8100     } else if (IncomingInputs.size() == 2) {
8101       if (IncomingInputs[0] / 2 != IncomingInputs[1] / 2 ||
8102           isDWordClobbered(SourceHalfMask, IncomingInputs[0] - SourceOffset)) {
8103         // We have two non-adjacent or clobbered inputs we need to extract from
8104         // the source half. To do this, we need to map them into some adjacent
8105         // dword slot in the source mask.
8106         int InputsFixed[2] = {IncomingInputs[0] - SourceOffset,
8107                               IncomingInputs[1] - SourceOffset};
8108
8109         // If there is a free slot in the source half mask adjacent to one of
8110         // the inputs, place the other input in it. We use (Index XOR 1) to
8111         // compute an adjacent index.
8112         if (!isWordClobbered(SourceHalfMask, InputsFixed[0]) &&
8113             SourceHalfMask[InputsFixed[0] ^ 1] == -1) {
8114           SourceHalfMask[InputsFixed[0]] = InputsFixed[0];
8115           SourceHalfMask[InputsFixed[0] ^ 1] = InputsFixed[1];
8116           InputsFixed[1] = InputsFixed[0] ^ 1;
8117         } else if (!isWordClobbered(SourceHalfMask, InputsFixed[1]) &&
8118                    SourceHalfMask[InputsFixed[1] ^ 1] == -1) {
8119           SourceHalfMask[InputsFixed[1]] = InputsFixed[1];
8120           SourceHalfMask[InputsFixed[1] ^ 1] = InputsFixed[0];
8121           InputsFixed[0] = InputsFixed[1] ^ 1;
8122         } else if (SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1)] == -1 &&
8123                    SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1) + 1] == -1) {
8124           // The two inputs are in the same DWord but it is clobbered and the
8125           // adjacent DWord isn't used at all. Move both inputs to the free
8126           // slot.
8127           SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1)] = InputsFixed[0];
8128           SourceHalfMask[2 * ((InputsFixed[0] / 2) ^ 1) + 1] = InputsFixed[1];
8129           InputsFixed[0] = 2 * ((InputsFixed[0] / 2) ^ 1);
8130           InputsFixed[1] = 2 * ((InputsFixed[0] / 2) ^ 1) + 1;
8131         } else {
8132           // The only way we hit this point is if there is no clobbering
8133           // (because there are no off-half inputs to this half) and there is no
8134           // free slot adjacent to one of the inputs. In this case, we have to
8135           // swap an input with a non-input.
8136           for (int i = 0; i < 4; ++i)
8137             assert((SourceHalfMask[i] == -1 || SourceHalfMask[i] == i) &&
8138                    "We can't handle any clobbers here!");
8139           assert(InputsFixed[1] != (InputsFixed[0] ^ 1) &&
8140                  "Cannot have adjacent inputs here!");
8141
8142           SourceHalfMask[InputsFixed[0] ^ 1] = InputsFixed[1];
8143           SourceHalfMask[InputsFixed[1]] = InputsFixed[0] ^ 1;
8144
8145           // We also have to update the final source mask in this case because
8146           // it may need to undo the above swap.
8147           for (int &M : FinalSourceHalfMask)
8148             if (M == (InputsFixed[0] ^ 1) + SourceOffset)
8149               M = InputsFixed[1] + SourceOffset;
8150             else if (M == InputsFixed[1] + SourceOffset)
8151               M = (InputsFixed[0] ^ 1) + SourceOffset;
8152
8153           InputsFixed[1] = InputsFixed[0] ^ 1;
8154         }
8155
8156         // Point everything at the fixed inputs.
8157         for (int &M : HalfMask)
8158           if (M == IncomingInputs[0])
8159             M = InputsFixed[0] + SourceOffset;
8160           else if (M == IncomingInputs[1])
8161             M = InputsFixed[1] + SourceOffset;
8162
8163         IncomingInputs[0] = InputsFixed[0] + SourceOffset;
8164         IncomingInputs[1] = InputsFixed[1] + SourceOffset;
8165       }
8166     } else {
8167       llvm_unreachable("Unhandled input size!");
8168     }
8169
8170     // Now hoist the DWord down to the right half.
8171     int FreeDWord = (PSHUFDMask[DestOffset / 2] == -1 ? 0 : 1) + DestOffset / 2;
8172     assert(PSHUFDMask[FreeDWord] == -1 && "DWord not free");
8173     PSHUFDMask[FreeDWord] = IncomingInputs[0] / 2;
8174     for (int &M : HalfMask)
8175       for (int Input : IncomingInputs)
8176         if (M == Input)
8177           M = FreeDWord * 2 + Input % 2;
8178   };
8179   moveInputsToRightHalf(HToLInputs, LToLInputs, PSHUFHMask, LoMask, HiMask,
8180                         /*SourceOffset*/ 4, /*DestOffset*/ 0);
8181   moveInputsToRightHalf(LToHInputs, HToHInputs, PSHUFLMask, HiMask, LoMask,
8182                         /*SourceOffset*/ 0, /*DestOffset*/ 4);
8183
8184   // Now enact all the shuffles we've computed to move the inputs into their
8185   // target half.
8186   if (!isNoopShuffleMask(PSHUFLMask))
8187     V = DAG.getNode(X86ISD::PSHUFLW, DL, VT, V,
8188                     getV4X86ShuffleImm8ForMask(PSHUFLMask, DAG));
8189   if (!isNoopShuffleMask(PSHUFHMask))
8190     V = DAG.getNode(X86ISD::PSHUFHW, DL, VT, V,
8191                     getV4X86ShuffleImm8ForMask(PSHUFHMask, DAG));
8192   if (!isNoopShuffleMask(PSHUFDMask))
8193     V = DAG.getNode(ISD::BITCAST, DL, VT,
8194                     DAG.getNode(X86ISD::PSHUFD, DL, PSHUFDVT,
8195                                 DAG.getNode(ISD::BITCAST, DL, PSHUFDVT, V),
8196                                 getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
8197
8198   // At this point, each half should contain all its inputs, and we can then
8199   // just shuffle them into their final position.
8200   assert(std::count_if(LoMask.begin(), LoMask.end(),
8201                        [](int M) { return M >= 4; }) == 0 &&
8202          "Failed to lift all the high half inputs to the low mask!");
8203   assert(std::count_if(HiMask.begin(), HiMask.end(),
8204                        [](int M) { return M >= 0 && M < 4; }) == 0 &&
8205          "Failed to lift all the low half inputs to the high mask!");
8206
8207   // Do a half shuffle for the low mask.
8208   if (!isNoopShuffleMask(LoMask))
8209     V = DAG.getNode(X86ISD::PSHUFLW, DL, VT, V,
8210                     getV4X86ShuffleImm8ForMask(LoMask, DAG));
8211
8212   // Do a half shuffle with the high mask after shifting its values down.
8213   for (int &M : HiMask)
8214     if (M >= 0)
8215       M -= 4;
8216   if (!isNoopShuffleMask(HiMask))
8217     V = DAG.getNode(X86ISD::PSHUFHW, DL, VT, V,
8218                     getV4X86ShuffleImm8ForMask(HiMask, DAG));
8219
8220   return V;
8221 }
8222
8223 /// \brief Helper to form a PSHUFB-based shuffle+blend.
8224 static SDValue lowerVectorShuffleAsPSHUFB(SDLoc DL, MVT VT, SDValue V1,
8225                                           SDValue V2, ArrayRef<int> Mask,
8226                                           SelectionDAG &DAG, bool &V1InUse,
8227                                           bool &V2InUse) {
8228   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
8229   SDValue V1Mask[16];
8230   SDValue V2Mask[16];
8231   V1InUse = false;
8232   V2InUse = false;
8233
8234   int Size = Mask.size();
8235   int Scale = 16 / Size;
8236   for (int i = 0; i < 16; ++i) {
8237     if (Mask[i / Scale] == -1) {
8238       V1Mask[i] = V2Mask[i] = DAG.getUNDEF(MVT::i8);
8239     } else {
8240       const int ZeroMask = 0x80;
8241       int V1Idx = Mask[i / Scale] < Size ? Mask[i / Scale] * Scale + i % Scale
8242                                           : ZeroMask;
8243       int V2Idx = Mask[i / Scale] < Size
8244                       ? ZeroMask
8245                       : (Mask[i / Scale] - Size) * Scale + i % Scale;
8246       if (Zeroable[i / Scale])
8247         V1Idx = V2Idx = ZeroMask;
8248       V1Mask[i] = DAG.getConstant(V1Idx, MVT::i8);
8249       V2Mask[i] = DAG.getConstant(V2Idx, MVT::i8);
8250       V1InUse |= (ZeroMask != V1Idx);
8251       V2InUse |= (ZeroMask != V2Idx);
8252     }
8253   }
8254
8255   if (V1InUse)
8256     V1 = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8,
8257                      DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, V1),
8258                      DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, V1Mask));
8259   if (V2InUse)
8260     V2 = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8,
8261                      DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, V2),
8262                      DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v16i8, V2Mask));
8263
8264   // If we need shuffled inputs from both, blend the two.
8265   SDValue V;
8266   if (V1InUse && V2InUse)
8267     V = DAG.getNode(ISD::OR, DL, MVT::v16i8, V1, V2);
8268   else
8269     V = V1InUse ? V1 : V2;
8270
8271   // Cast the result back to the correct type.
8272   return DAG.getNode(ISD::BITCAST, DL, VT, V);
8273 }
8274
8275 /// \brief Generic lowering of 8-lane i16 shuffles.
8276 ///
8277 /// This handles both single-input shuffles and combined shuffle/blends with
8278 /// two inputs. The single input shuffles are immediately delegated to
8279 /// a dedicated lowering routine.
8280 ///
8281 /// The blends are lowered in one of three fundamental ways. If there are few
8282 /// enough inputs, it delegates to a basic UNPCK-based strategy. If the shuffle
8283 /// of the input is significantly cheaper when lowered as an interleaving of
8284 /// the two inputs, try to interleave them. Otherwise, blend the low and high
8285 /// halves of the inputs separately (making them have relatively few inputs)
8286 /// and then concatenate them.
8287 static SDValue lowerV8I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8288                                        const X86Subtarget *Subtarget,
8289                                        SelectionDAG &DAG) {
8290   SDLoc DL(Op);
8291   assert(Op.getSimpleValueType() == MVT::v8i16 && "Bad shuffle type!");
8292   assert(V1.getSimpleValueType() == MVT::v8i16 && "Bad operand type!");
8293   assert(V2.getSimpleValueType() == MVT::v8i16 && "Bad operand type!");
8294   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8295   ArrayRef<int> OrigMask = SVOp->getMask();
8296   int MaskStorage[8] = {OrigMask[0], OrigMask[1], OrigMask[2], OrigMask[3],
8297                         OrigMask[4], OrigMask[5], OrigMask[6], OrigMask[7]};
8298   MutableArrayRef<int> Mask(MaskStorage);
8299
8300   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
8301
8302   // Whenever we can lower this as a zext, that instruction is strictly faster
8303   // than any alternative.
8304   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(
8305           DL, MVT::v8i16, V1, V2, OrigMask, Subtarget, DAG))
8306     return ZExt;
8307
8308   auto isV1 = [](int M) { return M >= 0 && M < 8; };
8309   (void)isV1;
8310   auto isV2 = [](int M) { return M >= 8; };
8311
8312   int NumV2Inputs = std::count_if(Mask.begin(), Mask.end(), isV2);
8313
8314   if (NumV2Inputs == 0) {
8315     // Check for being able to broadcast a single element.
8316     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v8i16, V1,
8317                                                           Mask, Subtarget, DAG))
8318       return Broadcast;
8319
8320     // Try to use shift instructions.
8321     if (SDValue Shift =
8322             lowerVectorShuffleAsShift(DL, MVT::v8i16, V1, V1, Mask, DAG))
8323       return Shift;
8324
8325     // Use dedicated unpack instructions for masks that match their pattern.
8326     if (isShuffleEquivalent(V1, V1, Mask, {0, 0, 1, 1, 2, 2, 3, 3}))
8327       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, V1, V1);
8328     if (isShuffleEquivalent(V1, V1, Mask, {4, 4, 5, 5, 6, 6, 7, 7}))
8329       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i16, V1, V1);
8330
8331     // Try to use byte rotation instructions.
8332     if (SDValue Rotate = lowerVectorShuffleAsByteRotate(DL, MVT::v8i16, V1, V1,
8333                                                         Mask, Subtarget, DAG))
8334       return Rotate;
8335
8336     return lowerV8I16GeneralSingleInputVectorShuffle(DL, MVT::v8i16, V1, Mask,
8337                                                      Subtarget, DAG);
8338   }
8339
8340   assert(std::any_of(Mask.begin(), Mask.end(), isV1) &&
8341          "All single-input shuffles should be canonicalized to be V1-input "
8342          "shuffles.");
8343
8344   // Try to use shift instructions.
8345   if (SDValue Shift =
8346           lowerVectorShuffleAsShift(DL, MVT::v8i16, V1, V2, Mask, DAG))
8347     return Shift;
8348
8349   // There are special ways we can lower some single-element blends.
8350   if (NumV2Inputs == 1)
8351     if (SDValue V = lowerVectorShuffleAsElementInsertion(DL, MVT::v8i16, V1, V2,
8352                                                          Mask, Subtarget, DAG))
8353       return V;
8354
8355   // We have different paths for blend lowering, but they all must use the
8356   // *exact* same predicate.
8357   bool IsBlendSupported = Subtarget->hasSSE41();
8358   if (IsBlendSupported)
8359     if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8i16, V1, V2, Mask,
8360                                                   Subtarget, DAG))
8361       return Blend;
8362
8363   if (SDValue Masked =
8364           lowerVectorShuffleAsBitMask(DL, MVT::v8i16, V1, V2, Mask, DAG))
8365     return Masked;
8366
8367   // Use dedicated unpack instructions for masks that match their pattern.
8368   if (isShuffleEquivalent(V1, V2, Mask, {0, 8, 1, 9, 2, 10, 3, 11}))
8369     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, V1, V2);
8370   if (isShuffleEquivalent(V1, V2, Mask, {4, 12, 5, 13, 6, 14, 7, 15}))
8371     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i16, V1, V2);
8372
8373   // Try to use byte rotation instructions.
8374   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
8375           DL, MVT::v8i16, V1, V2, Mask, Subtarget, DAG))
8376     return Rotate;
8377
8378   if (SDValue BitBlend =
8379           lowerVectorShuffleAsBitBlend(DL, MVT::v8i16, V1, V2, Mask, DAG))
8380     return BitBlend;
8381
8382   if (SDValue Unpack =
8383           lowerVectorShuffleAsUnpack(DL, MVT::v8i16, V1, V2, Mask, DAG))
8384     return Unpack;
8385
8386   // If we can't directly blend but can use PSHUFB, that will be better as it
8387   // can both shuffle and set up the inefficient blend.
8388   if (!IsBlendSupported && Subtarget->hasSSSE3()) {
8389     bool V1InUse, V2InUse;
8390     return lowerVectorShuffleAsPSHUFB(DL, MVT::v8i16, V1, V2, Mask, DAG,
8391                                       V1InUse, V2InUse);
8392   }
8393
8394   // We can always bit-blend if we have to so the fallback strategy is to
8395   // decompose into single-input permutes and blends.
8396   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8i16, V1, V2,
8397                                                       Mask, DAG);
8398 }
8399
8400 /// \brief Check whether a compaction lowering can be done by dropping even
8401 /// elements and compute how many times even elements must be dropped.
8402 ///
8403 /// This handles shuffles which take every Nth element where N is a power of
8404 /// two. Example shuffle masks:
8405 ///
8406 ///  N = 1:  0,  2,  4,  6,  8, 10, 12, 14,  0,  2,  4,  6,  8, 10, 12, 14
8407 ///  N = 1:  0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30
8408 ///  N = 2:  0,  4,  8, 12,  0,  4,  8, 12,  0,  4,  8, 12,  0,  4,  8, 12
8409 ///  N = 2:  0,  4,  8, 12, 16, 20, 24, 28,  0,  4,  8, 12, 16, 20, 24, 28
8410 ///  N = 3:  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8,  0,  8
8411 ///  N = 3:  0,  8, 16, 24,  0,  8, 16, 24,  0,  8, 16, 24,  0,  8, 16, 24
8412 ///
8413 /// Any of these lanes can of course be undef.
8414 ///
8415 /// This routine only supports N <= 3.
8416 /// FIXME: Evaluate whether either AVX or AVX-512 have any opportunities here
8417 /// for larger N.
8418 ///
8419 /// \returns N above, or the number of times even elements must be dropped if
8420 /// there is such a number. Otherwise returns zero.
8421 static int canLowerByDroppingEvenElements(ArrayRef<int> Mask) {
8422   // Figure out whether we're looping over two inputs or just one.
8423   bool IsSingleInput = isSingleInputShuffleMask(Mask);
8424
8425   // The modulus for the shuffle vector entries is based on whether this is
8426   // a single input or not.
8427   int ShuffleModulus = Mask.size() * (IsSingleInput ? 1 : 2);
8428   assert(isPowerOf2_32((uint32_t)ShuffleModulus) &&
8429          "We should only be called with masks with a power-of-2 size!");
8430
8431   uint64_t ModMask = (uint64_t)ShuffleModulus - 1;
8432
8433   // We track whether the input is viable for all power-of-2 strides 2^1, 2^2,
8434   // and 2^3 simultaneously. This is because we may have ambiguity with
8435   // partially undef inputs.
8436   bool ViableForN[3] = {true, true, true};
8437
8438   for (int i = 0, e = Mask.size(); i < e; ++i) {
8439     // Ignore undef lanes, we'll optimistically collapse them to the pattern we
8440     // want.
8441     if (Mask[i] == -1)
8442       continue;
8443
8444     bool IsAnyViable = false;
8445     for (unsigned j = 0; j != array_lengthof(ViableForN); ++j)
8446       if (ViableForN[j]) {
8447         uint64_t N = j + 1;
8448
8449         // The shuffle mask must be equal to (i * 2^N) % M.
8450         if ((uint64_t)Mask[i] == (((uint64_t)i << N) & ModMask))
8451           IsAnyViable = true;
8452         else
8453           ViableForN[j] = false;
8454       }
8455     // Early exit if we exhaust the possible powers of two.
8456     if (!IsAnyViable)
8457       break;
8458   }
8459
8460   for (unsigned j = 0; j != array_lengthof(ViableForN); ++j)
8461     if (ViableForN[j])
8462       return j + 1;
8463
8464   // Return 0 as there is no viable power of two.
8465   return 0;
8466 }
8467
8468 /// \brief Generic lowering of v16i8 shuffles.
8469 ///
8470 /// This is a hybrid strategy to lower v16i8 vectors. It first attempts to
8471 /// detect any complexity reducing interleaving. If that doesn't help, it uses
8472 /// UNPCK to spread the i8 elements across two i16-element vectors, and uses
8473 /// the existing lowering for v8i16 blends on each half, finally PACK-ing them
8474 /// back together.
8475 static SDValue lowerV16I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8476                                        const X86Subtarget *Subtarget,
8477                                        SelectionDAG &DAG) {
8478   SDLoc DL(Op);
8479   assert(Op.getSimpleValueType() == MVT::v16i8 && "Bad shuffle type!");
8480   assert(V1.getSimpleValueType() == MVT::v16i8 && "Bad operand type!");
8481   assert(V2.getSimpleValueType() == MVT::v16i8 && "Bad operand type!");
8482   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
8483   ArrayRef<int> Mask = SVOp->getMask();
8484   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
8485
8486   // Try to use shift instructions.
8487   if (SDValue Shift =
8488           lowerVectorShuffleAsShift(DL, MVT::v16i8, V1, V2, Mask, DAG))
8489     return Shift;
8490
8491   // Try to use byte rotation instructions.
8492   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
8493           DL, MVT::v16i8, V1, V2, Mask, Subtarget, DAG))
8494     return Rotate;
8495
8496   // Try to use a zext lowering.
8497   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(
8498           DL, MVT::v16i8, V1, V2, Mask, Subtarget, DAG))
8499     return ZExt;
8500
8501   int NumV2Elements =
8502       std::count_if(Mask.begin(), Mask.end(), [](int M) { return M >= 16; });
8503
8504   // For single-input shuffles, there are some nicer lowering tricks we can use.
8505   if (NumV2Elements == 0) {
8506     // Check for being able to broadcast a single element.
8507     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v16i8, V1,
8508                                                           Mask, Subtarget, DAG))
8509       return Broadcast;
8510
8511     // Check whether we can widen this to an i16 shuffle by duplicating bytes.
8512     // Notably, this handles splat and partial-splat shuffles more efficiently.
8513     // However, it only makes sense if the pre-duplication shuffle simplifies
8514     // things significantly. Currently, this means we need to be able to
8515     // express the pre-duplication shuffle as an i16 shuffle.
8516     //
8517     // FIXME: We should check for other patterns which can be widened into an
8518     // i16 shuffle as well.
8519     auto canWidenViaDuplication = [](ArrayRef<int> Mask) {
8520       for (int i = 0; i < 16; i += 2)
8521         if (Mask[i] != -1 && Mask[i + 1] != -1 && Mask[i] != Mask[i + 1])
8522           return false;
8523
8524       return true;
8525     };
8526     auto tryToWidenViaDuplication = [&]() -> SDValue {
8527       if (!canWidenViaDuplication(Mask))
8528         return SDValue();
8529       SmallVector<int, 4> LoInputs;
8530       std::copy_if(Mask.begin(), Mask.end(), std::back_inserter(LoInputs),
8531                    [](int M) { return M >= 0 && M < 8; });
8532       std::sort(LoInputs.begin(), LoInputs.end());
8533       LoInputs.erase(std::unique(LoInputs.begin(), LoInputs.end()),
8534                      LoInputs.end());
8535       SmallVector<int, 4> HiInputs;
8536       std::copy_if(Mask.begin(), Mask.end(), std::back_inserter(HiInputs),
8537                    [](int M) { return M >= 8; });
8538       std::sort(HiInputs.begin(), HiInputs.end());
8539       HiInputs.erase(std::unique(HiInputs.begin(), HiInputs.end()),
8540                      HiInputs.end());
8541
8542       bool TargetLo = LoInputs.size() >= HiInputs.size();
8543       ArrayRef<int> InPlaceInputs = TargetLo ? LoInputs : HiInputs;
8544       ArrayRef<int> MovingInputs = TargetLo ? HiInputs : LoInputs;
8545
8546       int PreDupI16Shuffle[] = {-1, -1, -1, -1, -1, -1, -1, -1};
8547       SmallDenseMap<int, int, 8> LaneMap;
8548       for (int I : InPlaceInputs) {
8549         PreDupI16Shuffle[I/2] = I/2;
8550         LaneMap[I] = I;
8551       }
8552       int j = TargetLo ? 0 : 4, je = j + 4;
8553       for (int i = 0, ie = MovingInputs.size(); i < ie; ++i) {
8554         // Check if j is already a shuffle of this input. This happens when
8555         // there are two adjacent bytes after we move the low one.
8556         if (PreDupI16Shuffle[j] != MovingInputs[i] / 2) {
8557           // If we haven't yet mapped the input, search for a slot into which
8558           // we can map it.
8559           while (j < je && PreDupI16Shuffle[j] != -1)
8560             ++j;
8561
8562           if (j == je)
8563             // We can't place the inputs into a single half with a simple i16 shuffle, so bail.
8564             return SDValue();
8565
8566           // Map this input with the i16 shuffle.
8567           PreDupI16Shuffle[j] = MovingInputs[i] / 2;
8568         }
8569
8570         // Update the lane map based on the mapping we ended up with.
8571         LaneMap[MovingInputs[i]] = 2 * j + MovingInputs[i] % 2;
8572       }
8573       V1 = DAG.getNode(
8574           ISD::BITCAST, DL, MVT::v16i8,
8575           DAG.getVectorShuffle(MVT::v8i16, DL,
8576                                DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
8577                                DAG.getUNDEF(MVT::v8i16), PreDupI16Shuffle));
8578
8579       // Unpack the bytes to form the i16s that will be shuffled into place.
8580       V1 = DAG.getNode(TargetLo ? X86ISD::UNPCKL : X86ISD::UNPCKH, DL,
8581                        MVT::v16i8, V1, V1);
8582
8583       int PostDupI16Shuffle[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
8584       for (int i = 0; i < 16; ++i)
8585         if (Mask[i] != -1) {
8586           int MappedMask = LaneMap[Mask[i]] - (TargetLo ? 0 : 8);
8587           assert(MappedMask < 8 && "Invalid v8 shuffle mask!");
8588           if (PostDupI16Shuffle[i / 2] == -1)
8589             PostDupI16Shuffle[i / 2] = MappedMask;
8590           else
8591             assert(PostDupI16Shuffle[i / 2] == MappedMask &&
8592                    "Conflicting entrties in the original shuffle!");
8593         }
8594       return DAG.getNode(
8595           ISD::BITCAST, DL, MVT::v16i8,
8596           DAG.getVectorShuffle(MVT::v8i16, DL,
8597                                DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
8598                                DAG.getUNDEF(MVT::v8i16), PostDupI16Shuffle));
8599     };
8600     if (SDValue V = tryToWidenViaDuplication())
8601       return V;
8602   }
8603
8604   // Use dedicated unpack instructions for masks that match their pattern.
8605   if (isShuffleEquivalent(V1, V2, Mask, {// Low half.
8606                                          0, 16, 1, 17, 2, 18, 3, 19,
8607                                          // High half.
8608                                          4, 20, 5, 21, 6, 22, 7, 23}))
8609     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V1, V2);
8610   if (isShuffleEquivalent(V1, V2, Mask, {// Low half.
8611                                          8, 24, 9, 25, 10, 26, 11, 27,
8612                                          // High half.
8613                                          12, 28, 13, 29, 14, 30, 15, 31}))
8614     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V1, V2);
8615
8616   // Check for SSSE3 which lets us lower all v16i8 shuffles much more directly
8617   // with PSHUFB. It is important to do this before we attempt to generate any
8618   // blends but after all of the single-input lowerings. If the single input
8619   // lowerings can find an instruction sequence that is faster than a PSHUFB, we
8620   // want to preserve that and we can DAG combine any longer sequences into
8621   // a PSHUFB in the end. But once we start blending from multiple inputs,
8622   // the complexity of DAG combining bad patterns back into PSHUFB is too high,
8623   // and there are *very* few patterns that would actually be faster than the
8624   // PSHUFB approach because of its ability to zero lanes.
8625   //
8626   // FIXME: The only exceptions to the above are blends which are exact
8627   // interleavings with direct instructions supporting them. We currently don't
8628   // handle those well here.
8629   if (Subtarget->hasSSSE3()) {
8630     bool V1InUse = false;
8631     bool V2InUse = false;
8632
8633     SDValue PSHUFB = lowerVectorShuffleAsPSHUFB(DL, MVT::v16i8, V1, V2, Mask,
8634                                                 DAG, V1InUse, V2InUse);
8635
8636     // If both V1 and V2 are in use and we can use a direct blend or an unpack,
8637     // do so. This avoids using them to handle blends-with-zero which is
8638     // important as a single pshufb is significantly faster for that.
8639     if (V1InUse && V2InUse) {
8640       if (Subtarget->hasSSE41())
8641         if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v16i8, V1, V2,
8642                                                       Mask, Subtarget, DAG))
8643           return Blend;
8644
8645       // We can use an unpack to do the blending rather than an or in some
8646       // cases. Even though the or may be (very minorly) more efficient, we
8647       // preference this lowering because there are common cases where part of
8648       // the complexity of the shuffles goes away when we do the final blend as
8649       // an unpack.
8650       // FIXME: It might be worth trying to detect if the unpack-feeding
8651       // shuffles will both be pshufb, in which case we shouldn't bother with
8652       // this.
8653       if (SDValue Unpack =
8654               lowerVectorShuffleAsUnpack(DL, MVT::v16i8, V1, V2, Mask, DAG))
8655         return Unpack;
8656     }
8657
8658     return PSHUFB;
8659   }
8660
8661   // There are special ways we can lower some single-element blends.
8662   if (NumV2Elements == 1)
8663     if (SDValue V = lowerVectorShuffleAsElementInsertion(DL, MVT::v16i8, V1, V2,
8664                                                          Mask, Subtarget, DAG))
8665       return V;
8666
8667   if (SDValue BitBlend =
8668           lowerVectorShuffleAsBitBlend(DL, MVT::v16i8, V1, V2, Mask, DAG))
8669     return BitBlend;
8670
8671   // Check whether a compaction lowering can be done. This handles shuffles
8672   // which take every Nth element for some even N. See the helper function for
8673   // details.
8674   //
8675   // We special case these as they can be particularly efficiently handled with
8676   // the PACKUSB instruction on x86 and they show up in common patterns of
8677   // rearranging bytes to truncate wide elements.
8678   if (int NumEvenDrops = canLowerByDroppingEvenElements(Mask)) {
8679     // NumEvenDrops is the power of two stride of the elements. Another way of
8680     // thinking about it is that we need to drop the even elements this many
8681     // times to get the original input.
8682     bool IsSingleInput = isSingleInputShuffleMask(Mask);
8683
8684     // First we need to zero all the dropped bytes.
8685     assert(NumEvenDrops <= 3 &&
8686            "No support for dropping even elements more than 3 times.");
8687     // We use the mask type to pick which bytes are preserved based on how many
8688     // elements are dropped.
8689     MVT MaskVTs[] = { MVT::v8i16, MVT::v4i32, MVT::v2i64 };
8690     SDValue ByteClearMask =
8691         DAG.getNode(ISD::BITCAST, DL, MVT::v16i8,
8692                     DAG.getConstant(0xFF, MaskVTs[NumEvenDrops - 1]));
8693     V1 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V1, ByteClearMask);
8694     if (!IsSingleInput)
8695       V2 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V2, ByteClearMask);
8696
8697     // Now pack things back together.
8698     V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1);
8699     V2 = IsSingleInput ? V1 : DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V2);
8700     SDValue Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, V1, V2);
8701     for (int i = 1; i < NumEvenDrops; ++i) {
8702       Result = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, Result);
8703       Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, Result, Result);
8704     }
8705
8706     return Result;
8707   }
8708
8709   // Handle multi-input cases by blending single-input shuffles.
8710   if (NumV2Elements > 0)
8711     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v16i8, V1, V2,
8712                                                       Mask, DAG);
8713
8714   // The fallback path for single-input shuffles widens this into two v8i16
8715   // vectors with unpacks, shuffles those, and then pulls them back together
8716   // with a pack.
8717   SDValue V = V1;
8718
8719   int LoBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
8720   int HiBlendMask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
8721   for (int i = 0; i < 16; ++i)
8722     if (Mask[i] >= 0)
8723       (i < 8 ? LoBlendMask[i] : HiBlendMask[i % 8]) = Mask[i];
8724
8725   SDValue Zero = getZeroVector(MVT::v8i16, Subtarget, DAG, DL);
8726
8727   SDValue VLoHalf, VHiHalf;
8728   // Check if any of the odd lanes in the v16i8 are used. If not, we can mask
8729   // them out and avoid using UNPCK{L,H} to extract the elements of V as
8730   // i16s.
8731   if (std::none_of(std::begin(LoBlendMask), std::end(LoBlendMask),
8732                    [](int M) { return M >= 0 && M % 2 == 1; }) &&
8733       std::none_of(std::begin(HiBlendMask), std::end(HiBlendMask),
8734                    [](int M) { return M >= 0 && M % 2 == 1; })) {
8735     // Use a mask to drop the high bytes.
8736     VLoHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
8737     VLoHalf = DAG.getNode(ISD::AND, DL, MVT::v8i16, VLoHalf,
8738                      DAG.getConstant(0x00FF, MVT::v8i16));
8739
8740     // This will be a single vector shuffle instead of a blend so nuke VHiHalf.
8741     VHiHalf = DAG.getUNDEF(MVT::v8i16);
8742
8743     // Squash the masks to point directly into VLoHalf.
8744     for (int &M : LoBlendMask)
8745       if (M >= 0)
8746         M /= 2;
8747     for (int &M : HiBlendMask)
8748       if (M >= 0)
8749         M /= 2;
8750   } else {
8751     // Otherwise just unpack the low half of V into VLoHalf and the high half into
8752     // VHiHalf so that we can blend them as i16s.
8753     VLoHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
8754                      DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V, Zero));
8755     VHiHalf = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
8756                      DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V, Zero));
8757   }
8758
8759   SDValue LoV = DAG.getVectorShuffle(MVT::v8i16, DL, VLoHalf, VHiHalf, LoBlendMask);
8760   SDValue HiV = DAG.getVectorShuffle(MVT::v8i16, DL, VLoHalf, VHiHalf, HiBlendMask);
8761
8762   return DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, LoV, HiV);
8763 }
8764
8765 /// \brief Dispatching routine to lower various 128-bit x86 vector shuffles.
8766 ///
8767 /// This routine breaks down the specific type of 128-bit shuffle and
8768 /// dispatches to the lowering routines accordingly.
8769 static SDValue lower128BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
8770                                         MVT VT, const X86Subtarget *Subtarget,
8771                                         SelectionDAG &DAG) {
8772   switch (VT.SimpleTy) {
8773   case MVT::v2i64:
8774     return lowerV2I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
8775   case MVT::v2f64:
8776     return lowerV2F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
8777   case MVT::v4i32:
8778     return lowerV4I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
8779   case MVT::v4f32:
8780     return lowerV4F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
8781   case MVT::v8i16:
8782     return lowerV8I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
8783   case MVT::v16i8:
8784     return lowerV16I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
8785
8786   default:
8787     llvm_unreachable("Unimplemented!");
8788   }
8789 }
8790
8791 /// \brief Helper function to test whether a shuffle mask could be
8792 /// simplified by widening the elements being shuffled.
8793 ///
8794 /// Appends the mask for wider elements in WidenedMask if valid. Otherwise
8795 /// leaves it in an unspecified state.
8796 ///
8797 /// NOTE: This must handle normal vector shuffle masks and *target* vector
8798 /// shuffle masks. The latter have the special property of a '-2' representing
8799 /// a zero-ed lane of a vector.
8800 static bool canWidenShuffleElements(ArrayRef<int> Mask,
8801                                     SmallVectorImpl<int> &WidenedMask) {
8802   for (int i = 0, Size = Mask.size(); i < Size; i += 2) {
8803     // If both elements are undef, its trivial.
8804     if (Mask[i] == SM_SentinelUndef && Mask[i + 1] == SM_SentinelUndef) {
8805       WidenedMask.push_back(SM_SentinelUndef);
8806       continue;
8807     }
8808
8809     // Check for an undef mask and a mask value properly aligned to fit with
8810     // a pair of values. If we find such a case, use the non-undef mask's value.
8811     if (Mask[i] == SM_SentinelUndef && Mask[i + 1] >= 0 && Mask[i + 1] % 2 == 1) {
8812       WidenedMask.push_back(Mask[i + 1] / 2);
8813       continue;
8814     }
8815     if (Mask[i + 1] == SM_SentinelUndef && Mask[i] >= 0 && Mask[i] % 2 == 0) {
8816       WidenedMask.push_back(Mask[i] / 2);
8817       continue;
8818     }
8819
8820     // When zeroing, we need to spread the zeroing across both lanes to widen.
8821     if (Mask[i] == SM_SentinelZero || Mask[i + 1] == SM_SentinelZero) {
8822       if ((Mask[i] == SM_SentinelZero || Mask[i] == SM_SentinelUndef) &&
8823           (Mask[i + 1] == SM_SentinelZero || Mask[i + 1] == SM_SentinelUndef)) {
8824         WidenedMask.push_back(SM_SentinelZero);
8825         continue;
8826       }
8827       return false;
8828     }
8829
8830     // Finally check if the two mask values are adjacent and aligned with
8831     // a pair.
8832     if (Mask[i] != SM_SentinelUndef && Mask[i] % 2 == 0 && Mask[i] + 1 == Mask[i + 1]) {
8833       WidenedMask.push_back(Mask[i] / 2);
8834       continue;
8835     }
8836
8837     // Otherwise we can't safely widen the elements used in this shuffle.
8838     return false;
8839   }
8840   assert(WidenedMask.size() == Mask.size() / 2 &&
8841          "Incorrect size of mask after widening the elements!");
8842
8843   return true;
8844 }
8845
8846 /// \brief Generic routine to split vector shuffle into half-sized shuffles.
8847 ///
8848 /// This routine just extracts two subvectors, shuffles them independently, and
8849 /// then concatenates them back together. This should work effectively with all
8850 /// AVX vector shuffle types.
8851 static SDValue splitAndLowerVectorShuffle(SDLoc DL, MVT VT, SDValue V1,
8852                                           SDValue V2, ArrayRef<int> Mask,
8853                                           SelectionDAG &DAG) {
8854   assert(VT.getSizeInBits() >= 256 &&
8855          "Only for 256-bit or wider vector shuffles!");
8856   assert(V1.getSimpleValueType() == VT && "Bad operand type!");
8857   assert(V2.getSimpleValueType() == VT && "Bad operand type!");
8858
8859   ArrayRef<int> LoMask = Mask.slice(0, Mask.size() / 2);
8860   ArrayRef<int> HiMask = Mask.slice(Mask.size() / 2);
8861
8862   int NumElements = VT.getVectorNumElements();
8863   int SplitNumElements = NumElements / 2;
8864   MVT ScalarVT = VT.getScalarType();
8865   MVT SplitVT = MVT::getVectorVT(ScalarVT, NumElements / 2);
8866
8867   // Rather than splitting build-vectors, just build two narrower build
8868   // vectors. This helps shuffling with splats and zeros.
8869   auto SplitVector = [&](SDValue V) {
8870     while (V.getOpcode() == ISD::BITCAST)
8871       V = V->getOperand(0);
8872
8873     MVT OrigVT = V.getSimpleValueType();
8874     int OrigNumElements = OrigVT.getVectorNumElements();
8875     int OrigSplitNumElements = OrigNumElements / 2;
8876     MVT OrigScalarVT = OrigVT.getScalarType();
8877     MVT OrigSplitVT = MVT::getVectorVT(OrigScalarVT, OrigNumElements / 2);
8878
8879     SDValue LoV, HiV;
8880
8881     auto *BV = dyn_cast<BuildVectorSDNode>(V);
8882     if (!BV) {
8883       LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigSplitVT, V,
8884                         DAG.getIntPtrConstant(0));
8885       HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigSplitVT, V,
8886                         DAG.getIntPtrConstant(OrigSplitNumElements));
8887     } else {
8888
8889       SmallVector<SDValue, 16> LoOps, HiOps;
8890       for (int i = 0; i < OrigSplitNumElements; ++i) {
8891         LoOps.push_back(BV->getOperand(i));
8892         HiOps.push_back(BV->getOperand(i + OrigSplitNumElements));
8893       }
8894       LoV = DAG.getNode(ISD::BUILD_VECTOR, DL, OrigSplitVT, LoOps);
8895       HiV = DAG.getNode(ISD::BUILD_VECTOR, DL, OrigSplitVT, HiOps);
8896     }
8897     return std::make_pair(DAG.getNode(ISD::BITCAST, DL, SplitVT, LoV),
8898                           DAG.getNode(ISD::BITCAST, DL, SplitVT, HiV));
8899   };
8900
8901   SDValue LoV1, HiV1, LoV2, HiV2;
8902   std::tie(LoV1, HiV1) = SplitVector(V1);
8903   std::tie(LoV2, HiV2) = SplitVector(V2);
8904
8905   // Now create two 4-way blends of these half-width vectors.
8906   auto HalfBlend = [&](ArrayRef<int> HalfMask) {
8907     bool UseLoV1 = false, UseHiV1 = false, UseLoV2 = false, UseHiV2 = false;
8908     SmallVector<int, 32> V1BlendMask, V2BlendMask, BlendMask;
8909     for (int i = 0; i < SplitNumElements; ++i) {
8910       int M = HalfMask[i];
8911       if (M >= NumElements) {
8912         if (M >= NumElements + SplitNumElements)
8913           UseHiV2 = true;
8914         else
8915           UseLoV2 = true;
8916         V2BlendMask.push_back(M - NumElements);
8917         V1BlendMask.push_back(-1);
8918         BlendMask.push_back(SplitNumElements + i);
8919       } else if (M >= 0) {
8920         if (M >= SplitNumElements)
8921           UseHiV1 = true;
8922         else
8923           UseLoV1 = true;
8924         V2BlendMask.push_back(-1);
8925         V1BlendMask.push_back(M);
8926         BlendMask.push_back(i);
8927       } else {
8928         V2BlendMask.push_back(-1);
8929         V1BlendMask.push_back(-1);
8930         BlendMask.push_back(-1);
8931       }
8932     }
8933
8934     // Because the lowering happens after all combining takes place, we need to
8935     // manually combine these blend masks as much as possible so that we create
8936     // a minimal number of high-level vector shuffle nodes.
8937
8938     // First try just blending the halves of V1 or V2.
8939     if (!UseLoV1 && !UseHiV1 && !UseLoV2 && !UseHiV2)
8940       return DAG.getUNDEF(SplitVT);
8941     if (!UseLoV2 && !UseHiV2)
8942       return DAG.getVectorShuffle(SplitVT, DL, LoV1, HiV1, V1BlendMask);
8943     if (!UseLoV1 && !UseHiV1)
8944       return DAG.getVectorShuffle(SplitVT, DL, LoV2, HiV2, V2BlendMask);
8945
8946     SDValue V1Blend, V2Blend;
8947     if (UseLoV1 && UseHiV1) {
8948       V1Blend =
8949         DAG.getVectorShuffle(SplitVT, DL, LoV1, HiV1, V1BlendMask);
8950     } else {
8951       // We only use half of V1 so map the usage down into the final blend mask.
8952       V1Blend = UseLoV1 ? LoV1 : HiV1;
8953       for (int i = 0; i < SplitNumElements; ++i)
8954         if (BlendMask[i] >= 0 && BlendMask[i] < SplitNumElements)
8955           BlendMask[i] = V1BlendMask[i] - (UseLoV1 ? 0 : SplitNumElements);
8956     }
8957     if (UseLoV2 && UseHiV2) {
8958       V2Blend =
8959         DAG.getVectorShuffle(SplitVT, DL, LoV2, HiV2, V2BlendMask);
8960     } else {
8961       // We only use half of V2 so map the usage down into the final blend mask.
8962       V2Blend = UseLoV2 ? LoV2 : HiV2;
8963       for (int i = 0; i < SplitNumElements; ++i)
8964         if (BlendMask[i] >= SplitNumElements)
8965           BlendMask[i] = V2BlendMask[i] + (UseLoV2 ? SplitNumElements : 0);
8966     }
8967     return DAG.getVectorShuffle(SplitVT, DL, V1Blend, V2Blend, BlendMask);
8968   };
8969   SDValue Lo = HalfBlend(LoMask);
8970   SDValue Hi = HalfBlend(HiMask);
8971   return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
8972 }
8973
8974 /// \brief Either split a vector in halves or decompose the shuffles and the
8975 /// blend.
8976 ///
8977 /// This is provided as a good fallback for many lowerings of non-single-input
8978 /// shuffles with more than one 128-bit lane. In those cases, we want to select
8979 /// between splitting the shuffle into 128-bit components and stitching those
8980 /// back together vs. extracting the single-input shuffles and blending those
8981 /// results.
8982 static SDValue lowerVectorShuffleAsSplitOrBlend(SDLoc DL, MVT VT, SDValue V1,
8983                                                 SDValue V2, ArrayRef<int> Mask,
8984                                                 SelectionDAG &DAG) {
8985   assert(!isSingleInputShuffleMask(Mask) && "This routine must not be used to "
8986                                             "lower single-input shuffles as it "
8987                                             "could then recurse on itself.");
8988   int Size = Mask.size();
8989
8990   // If this can be modeled as a broadcast of two elements followed by a blend,
8991   // prefer that lowering. This is especially important because broadcasts can
8992   // often fold with memory operands.
8993   auto DoBothBroadcast = [&] {
8994     int V1BroadcastIdx = -1, V2BroadcastIdx = -1;
8995     for (int M : Mask)
8996       if (M >= Size) {
8997         if (V2BroadcastIdx == -1)
8998           V2BroadcastIdx = M - Size;
8999         else if (M - Size != V2BroadcastIdx)
9000           return false;
9001       } else if (M >= 0) {
9002         if (V1BroadcastIdx == -1)
9003           V1BroadcastIdx = M;
9004         else if (M != V1BroadcastIdx)
9005           return false;
9006       }
9007     return true;
9008   };
9009   if (DoBothBroadcast())
9010     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask,
9011                                                       DAG);
9012
9013   // If the inputs all stem from a single 128-bit lane of each input, then we
9014   // split them rather than blending because the split will decompose to
9015   // unusually few instructions.
9016   int LaneCount = VT.getSizeInBits() / 128;
9017   int LaneSize = Size / LaneCount;
9018   SmallBitVector LaneInputs[2];
9019   LaneInputs[0].resize(LaneCount, false);
9020   LaneInputs[1].resize(LaneCount, false);
9021   for (int i = 0; i < Size; ++i)
9022     if (Mask[i] >= 0)
9023       LaneInputs[Mask[i] / Size][(Mask[i] % Size) / LaneSize] = true;
9024   if (LaneInputs[0].count() <= 1 && LaneInputs[1].count() <= 1)
9025     return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
9026
9027   // Otherwise, just fall back to decomposed shuffles and a blend. This requires
9028   // that the decomposed single-input shuffles don't end up here.
9029   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask, DAG);
9030 }
9031
9032 /// \brief Lower a vector shuffle crossing multiple 128-bit lanes as
9033 /// a permutation and blend of those lanes.
9034 ///
9035 /// This essentially blends the out-of-lane inputs to each lane into the lane
9036 /// from a permuted copy of the vector. This lowering strategy results in four
9037 /// instructions in the worst case for a single-input cross lane shuffle which
9038 /// is lower than any other fully general cross-lane shuffle strategy I'm aware
9039 /// of. Special cases for each particular shuffle pattern should be handled
9040 /// prior to trying this lowering.
9041 static SDValue lowerVectorShuffleAsLanePermuteAndBlend(SDLoc DL, MVT VT,
9042                                                        SDValue V1, SDValue V2,
9043                                                        ArrayRef<int> Mask,
9044                                                        SelectionDAG &DAG) {
9045   // FIXME: This should probably be generalized for 512-bit vectors as well.
9046   assert(VT.getSizeInBits() == 256 && "Only for 256-bit vector shuffles!");
9047   int LaneSize = Mask.size() / 2;
9048
9049   // If there are only inputs from one 128-bit lane, splitting will in fact be
9050   // less expensive. The flags track whether the given lane contains an element
9051   // that crosses to another lane.
9052   bool LaneCrossing[2] = {false, false};
9053   for (int i = 0, Size = Mask.size(); i < Size; ++i)
9054     if (Mask[i] >= 0 && (Mask[i] % Size) / LaneSize != i / LaneSize)
9055       LaneCrossing[(Mask[i] % Size) / LaneSize] = true;
9056   if (!LaneCrossing[0] || !LaneCrossing[1])
9057     return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
9058
9059   if (isSingleInputShuffleMask(Mask)) {
9060     SmallVector<int, 32> FlippedBlendMask;
9061     for (int i = 0, Size = Mask.size(); i < Size; ++i)
9062       FlippedBlendMask.push_back(
9063           Mask[i] < 0 ? -1 : (((Mask[i] % Size) / LaneSize == i / LaneSize)
9064                                   ? Mask[i]
9065                                   : Mask[i] % LaneSize +
9066                                         (i / LaneSize) * LaneSize + Size));
9067
9068     // Flip the vector, and blend the results which should now be in-lane. The
9069     // VPERM2X128 mask uses the low 2 bits for the low source and bits 4 and
9070     // 5 for the high source. The value 3 selects the high half of source 2 and
9071     // the value 2 selects the low half of source 2. We only use source 2 to
9072     // allow folding it into a memory operand.
9073     unsigned PERMMask = 3 | 2 << 4;
9074     SDValue Flipped = DAG.getNode(X86ISD::VPERM2X128, DL, VT, DAG.getUNDEF(VT),
9075                                   V1, DAG.getConstant(PERMMask, MVT::i8));
9076     return DAG.getVectorShuffle(VT, DL, V1, Flipped, FlippedBlendMask);
9077   }
9078
9079   // This now reduces to two single-input shuffles of V1 and V2 which at worst
9080   // will be handled by the above logic and a blend of the results, much like
9081   // other patterns in AVX.
9082   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, VT, V1, V2, Mask, DAG);
9083 }
9084
9085 /// \brief Handle lowering 2-lane 128-bit shuffles.
9086 static SDValue lowerV2X128VectorShuffle(SDLoc DL, MVT VT, SDValue V1,
9087                                         SDValue V2, ArrayRef<int> Mask,
9088                                         const X86Subtarget *Subtarget,
9089                                         SelectionDAG &DAG) {
9090   // TODO: If minimizing size and one of the inputs is a zero vector and the
9091   // the zero vector has only one use, we could use a VPERM2X128 to save the
9092   // instruction bytes needed to explicitly generate the zero vector.
9093
9094   // Blends are faster and handle all the non-lane-crossing cases.
9095   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, VT, V1, V2, Mask,
9096                                                 Subtarget, DAG))
9097     return Blend;
9098
9099   bool IsV1Zero = ISD::isBuildVectorAllZeros(V1.getNode());
9100   bool IsV2Zero = ISD::isBuildVectorAllZeros(V2.getNode());
9101
9102   // If either input operand is a zero vector, use VPERM2X128 because its mask
9103   // allows us to replace the zero input with an implicit zero.
9104   if (!IsV1Zero && !IsV2Zero) {
9105     // Check for patterns which can be matched with a single insert of a 128-bit
9106     // subvector.
9107     bool OnlyUsesV1 = isShuffleEquivalent(V1, V2, Mask, {0, 1, 0, 1});
9108     if (OnlyUsesV1 || isShuffleEquivalent(V1, V2, Mask, {0, 1, 4, 5})) {
9109       MVT SubVT = MVT::getVectorVT(VT.getVectorElementType(),
9110                                    VT.getVectorNumElements() / 2);
9111       SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
9112                                 DAG.getIntPtrConstant(0));
9113       SDValue HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT,
9114                                 OnlyUsesV1 ? V1 : V2, DAG.getIntPtrConstant(0));
9115       return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LoV, HiV);
9116     }
9117   }
9118
9119   // Otherwise form a 128-bit permutation. After accounting for undefs,
9120   // convert the 64-bit shuffle mask selection values into 128-bit
9121   // selection bits by dividing the indexes by 2 and shifting into positions
9122   // defined by a vperm2*128 instruction's immediate control byte.
9123
9124   // The immediate permute control byte looks like this:
9125   //    [1:0] - select 128 bits from sources for low half of destination
9126   //    [2]   - ignore
9127   //    [3]   - zero low half of destination
9128   //    [5:4] - select 128 bits from sources for high half of destination
9129   //    [6]   - ignore
9130   //    [7]   - zero high half of destination
9131
9132   int MaskLO = Mask[0];
9133   if (MaskLO == SM_SentinelUndef)
9134     MaskLO = Mask[1] == SM_SentinelUndef ? 0 : Mask[1];
9135
9136   int MaskHI = Mask[2];
9137   if (MaskHI == SM_SentinelUndef)
9138     MaskHI = Mask[3] == SM_SentinelUndef ? 0 : Mask[3];
9139
9140   unsigned PermMask = MaskLO / 2 | (MaskHI / 2) << 4;
9141
9142   // If either input is a zero vector, replace it with an undef input.
9143   // Shuffle mask values <  4 are selecting elements of V1.
9144   // Shuffle mask values >= 4 are selecting elements of V2.
9145   // Adjust each half of the permute mask by clearing the half that was
9146   // selecting the zero vector and setting the zero mask bit.
9147   if (IsV1Zero) {
9148     V1 = DAG.getUNDEF(VT);
9149     if (MaskLO < 4)
9150       PermMask = (PermMask & 0xf0) | 0x08;
9151     if (MaskHI < 4)
9152       PermMask = (PermMask & 0x0f) | 0x80;
9153   }
9154   if (IsV2Zero) {
9155     V2 = DAG.getUNDEF(VT);
9156     if (MaskLO >= 4)
9157       PermMask = (PermMask & 0xf0) | 0x08;
9158     if (MaskHI >= 4)
9159       PermMask = (PermMask & 0x0f) | 0x80;
9160   }
9161
9162   return DAG.getNode(X86ISD::VPERM2X128, DL, VT, V1, V2,
9163                      DAG.getConstant(PermMask, MVT::i8));
9164 }
9165
9166 /// \brief Lower a vector shuffle by first fixing the 128-bit lanes and then
9167 /// shuffling each lane.
9168 ///
9169 /// This will only succeed when the result of fixing the 128-bit lanes results
9170 /// in a single-input non-lane-crossing shuffle with a repeating shuffle mask in
9171 /// each 128-bit lanes. This handles many cases where we can quickly blend away
9172 /// the lane crosses early and then use simpler shuffles within each lane.
9173 ///
9174 /// FIXME: It might be worthwhile at some point to support this without
9175 /// requiring the 128-bit lane-relative shuffles to be repeating, but currently
9176 /// in x86 only floating point has interesting non-repeating shuffles, and even
9177 /// those are still *marginally* more expensive.
9178 static SDValue lowerVectorShuffleByMerging128BitLanes(
9179     SDLoc DL, MVT VT, SDValue V1, SDValue V2, ArrayRef<int> Mask,
9180     const X86Subtarget *Subtarget, SelectionDAG &DAG) {
9181   assert(!isSingleInputShuffleMask(Mask) &&
9182          "This is only useful with multiple inputs.");
9183
9184   int Size = Mask.size();
9185   int LaneSize = 128 / VT.getScalarSizeInBits();
9186   int NumLanes = Size / LaneSize;
9187   assert(NumLanes > 1 && "Only handles 256-bit and wider shuffles.");
9188
9189   // See if we can build a hypothetical 128-bit lane-fixing shuffle mask. Also
9190   // check whether the in-128-bit lane shuffles share a repeating pattern.
9191   SmallVector<int, 4> Lanes;
9192   Lanes.resize(NumLanes, -1);
9193   SmallVector<int, 4> InLaneMask;
9194   InLaneMask.resize(LaneSize, -1);
9195   for (int i = 0; i < Size; ++i) {
9196     if (Mask[i] < 0)
9197       continue;
9198
9199     int j = i / LaneSize;
9200
9201     if (Lanes[j] < 0) {
9202       // First entry we've seen for this lane.
9203       Lanes[j] = Mask[i] / LaneSize;
9204     } else if (Lanes[j] != Mask[i] / LaneSize) {
9205       // This doesn't match the lane selected previously!
9206       return SDValue();
9207     }
9208
9209     // Check that within each lane we have a consistent shuffle mask.
9210     int k = i % LaneSize;
9211     if (InLaneMask[k] < 0) {
9212       InLaneMask[k] = Mask[i] % LaneSize;
9213     } else if (InLaneMask[k] != Mask[i] % LaneSize) {
9214       // This doesn't fit a repeating in-lane mask.
9215       return SDValue();
9216     }
9217   }
9218
9219   // First shuffle the lanes into place.
9220   MVT LaneVT = MVT::getVectorVT(VT.isFloatingPoint() ? MVT::f64 : MVT::i64,
9221                                 VT.getSizeInBits() / 64);
9222   SmallVector<int, 8> LaneMask;
9223   LaneMask.resize(NumLanes * 2, -1);
9224   for (int i = 0; i < NumLanes; ++i)
9225     if (Lanes[i] >= 0) {
9226       LaneMask[2 * i + 0] = 2*Lanes[i] + 0;
9227       LaneMask[2 * i + 1] = 2*Lanes[i] + 1;
9228     }
9229
9230   V1 = DAG.getNode(ISD::BITCAST, DL, LaneVT, V1);
9231   V2 = DAG.getNode(ISD::BITCAST, DL, LaneVT, V2);
9232   SDValue LaneShuffle = DAG.getVectorShuffle(LaneVT, DL, V1, V2, LaneMask);
9233
9234   // Cast it back to the type we actually want.
9235   LaneShuffle = DAG.getNode(ISD::BITCAST, DL, VT, LaneShuffle);
9236
9237   // Now do a simple shuffle that isn't lane crossing.
9238   SmallVector<int, 8> NewMask;
9239   NewMask.resize(Size, -1);
9240   for (int i = 0; i < Size; ++i)
9241     if (Mask[i] >= 0)
9242       NewMask[i] = (i / LaneSize) * LaneSize + Mask[i] % LaneSize;
9243   assert(!is128BitLaneCrossingShuffleMask(VT, NewMask) &&
9244          "Must not introduce lane crosses at this point!");
9245
9246   return DAG.getVectorShuffle(VT, DL, LaneShuffle, DAG.getUNDEF(VT), NewMask);
9247 }
9248
9249 /// \brief Test whether the specified input (0 or 1) is in-place blended by the
9250 /// given mask.
9251 ///
9252 /// This returns true if the elements from a particular input are already in the
9253 /// slot required by the given mask and require no permutation.
9254 static bool isShuffleMaskInputInPlace(int Input, ArrayRef<int> Mask) {
9255   assert((Input == 0 || Input == 1) && "Only two inputs to shuffles.");
9256   int Size = Mask.size();
9257   for (int i = 0; i < Size; ++i)
9258     if (Mask[i] >= 0 && Mask[i] / Size == Input && Mask[i] % Size != i)
9259       return false;
9260
9261   return true;
9262 }
9263
9264 /// \brief Handle lowering of 4-lane 64-bit floating point shuffles.
9265 ///
9266 /// Also ends up handling lowering of 4-lane 64-bit integer shuffles when AVX2
9267 /// isn't available.
9268 static SDValue lowerV4F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9269                                        const X86Subtarget *Subtarget,
9270                                        SelectionDAG &DAG) {
9271   SDLoc DL(Op);
9272   assert(V1.getSimpleValueType() == MVT::v4f64 && "Bad operand type!");
9273   assert(V2.getSimpleValueType() == MVT::v4f64 && "Bad operand type!");
9274   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9275   ArrayRef<int> Mask = SVOp->getMask();
9276   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
9277
9278   SmallVector<int, 4> WidenedMask;
9279   if (canWidenShuffleElements(Mask, WidenedMask))
9280     return lowerV2X128VectorShuffle(DL, MVT::v4f64, V1, V2, Mask, Subtarget,
9281                                     DAG);
9282
9283   if (isSingleInputShuffleMask(Mask)) {
9284     // Check for being able to broadcast a single element.
9285     if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v4f64, V1,
9286                                                           Mask, Subtarget, DAG))
9287       return Broadcast;
9288
9289     // Use low duplicate instructions for masks that match their pattern.
9290     if (isShuffleEquivalent(V1, V2, Mask, {0, 0, 2, 2}))
9291       return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v4f64, V1);
9292
9293     if (!is128BitLaneCrossingShuffleMask(MVT::v4f64, Mask)) {
9294       // Non-half-crossing single input shuffles can be lowerid with an
9295       // interleaved permutation.
9296       unsigned VPERMILPMask = (Mask[0] == 1) | ((Mask[1] == 1) << 1) |
9297                               ((Mask[2] == 3) << 2) | ((Mask[3] == 3) << 3);
9298       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f64, V1,
9299                          DAG.getConstant(VPERMILPMask, MVT::i8));
9300     }
9301
9302     // With AVX2 we have direct support for this permutation.
9303     if (Subtarget->hasAVX2())
9304       return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4f64, V1,
9305                          getV4X86ShuffleImm8ForMask(Mask, DAG));
9306
9307     // Otherwise, fall back.
9308     return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v4f64, V1, V2, Mask,
9309                                                    DAG);
9310   }
9311
9312   // X86 has dedicated unpack instructions that can handle specific blend
9313   // operations: UNPCKH and UNPCKL.
9314   if (isShuffleEquivalent(V1, V2, Mask, {0, 4, 2, 6}))
9315     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f64, V1, V2);
9316   if (isShuffleEquivalent(V1, V2, Mask, {1, 5, 3, 7}))
9317     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f64, V1, V2);
9318   if (isShuffleEquivalent(V1, V2, Mask, {4, 0, 6, 2}))
9319     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4f64, V2, V1);
9320   if (isShuffleEquivalent(V1, V2, Mask, {5, 1, 7, 3}))
9321     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4f64, V2, V1);
9322
9323   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4f64, V1, V2, Mask,
9324                                                 Subtarget, DAG))
9325     return Blend;
9326
9327   // Check if the blend happens to exactly fit that of SHUFPD.
9328   if ((Mask[0] == -1 || Mask[0] < 2) &&
9329       (Mask[1] == -1 || (Mask[1] >= 4 && Mask[1] < 6)) &&
9330       (Mask[2] == -1 || (Mask[2] >= 2 && Mask[2] < 4)) &&
9331       (Mask[3] == -1 || Mask[3] >= 6)) {
9332     unsigned SHUFPDMask = (Mask[0] == 1) | ((Mask[1] == 5) << 1) |
9333                           ((Mask[2] == 3) << 2) | ((Mask[3] == 7) << 3);
9334     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f64, V1, V2,
9335                        DAG.getConstant(SHUFPDMask, MVT::i8));
9336   }
9337   if ((Mask[0] == -1 || (Mask[0] >= 4 && Mask[0] < 6)) &&
9338       (Mask[1] == -1 || Mask[1] < 2) &&
9339       (Mask[2] == -1 || Mask[2] >= 6) &&
9340       (Mask[3] == -1 || (Mask[3] >= 2 && Mask[3] < 4))) {
9341     unsigned SHUFPDMask = (Mask[0] == 5) | ((Mask[1] == 1) << 1) |
9342                           ((Mask[2] == 7) << 2) | ((Mask[3] == 3) << 3);
9343     return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f64, V2, V1,
9344                        DAG.getConstant(SHUFPDMask, MVT::i8));
9345   }
9346
9347   // Try to simplify this by merging 128-bit lanes to enable a lane-based
9348   // shuffle. However, if we have AVX2 and either inputs are already in place,
9349   // we will be able to shuffle even across lanes the other input in a single
9350   // instruction so skip this pattern.
9351   if (!(Subtarget->hasAVX2() && (isShuffleMaskInputInPlace(0, Mask) ||
9352                                  isShuffleMaskInputInPlace(1, Mask))))
9353     if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
9354             DL, MVT::v4f64, V1, V2, Mask, Subtarget, DAG))
9355       return Result;
9356
9357   // If we have AVX2 then we always want to lower with a blend because an v4 we
9358   // can fully permute the elements.
9359   if (Subtarget->hasAVX2())
9360     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4f64, V1, V2,
9361                                                       Mask, DAG);
9362
9363   // Otherwise fall back on generic lowering.
9364   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v4f64, V1, V2, Mask, DAG);
9365 }
9366
9367 /// \brief Handle lowering of 4-lane 64-bit integer shuffles.
9368 ///
9369 /// This routine is only called when we have AVX2 and thus a reasonable
9370 /// instruction set for v4i64 shuffling..
9371 static SDValue lowerV4I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9372                                        const X86Subtarget *Subtarget,
9373                                        SelectionDAG &DAG) {
9374   SDLoc DL(Op);
9375   assert(V1.getSimpleValueType() == MVT::v4i64 && "Bad operand type!");
9376   assert(V2.getSimpleValueType() == MVT::v4i64 && "Bad operand type!");
9377   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9378   ArrayRef<int> Mask = SVOp->getMask();
9379   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
9380   assert(Subtarget->hasAVX2() && "We can only lower v4i64 with AVX2!");
9381
9382   SmallVector<int, 4> WidenedMask;
9383   if (canWidenShuffleElements(Mask, WidenedMask))
9384     return lowerV2X128VectorShuffle(DL, MVT::v4i64, V1, V2, Mask, Subtarget,
9385                                     DAG);
9386
9387   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v4i64, V1, V2, Mask,
9388                                                 Subtarget, DAG))
9389     return Blend;
9390
9391   // Check for being able to broadcast a single element.
9392   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v4i64, V1,
9393                                                         Mask, Subtarget, DAG))
9394     return Broadcast;
9395
9396   // When the shuffle is mirrored between the 128-bit lanes of the unit, we can
9397   // use lower latency instructions that will operate on both 128-bit lanes.
9398   SmallVector<int, 2> RepeatedMask;
9399   if (is128BitLaneRepeatedShuffleMask(MVT::v4i64, Mask, RepeatedMask)) {
9400     if (isSingleInputShuffleMask(Mask)) {
9401       int PSHUFDMask[] = {-1, -1, -1, -1};
9402       for (int i = 0; i < 2; ++i)
9403         if (RepeatedMask[i] >= 0) {
9404           PSHUFDMask[2 * i] = 2 * RepeatedMask[i];
9405           PSHUFDMask[2 * i + 1] = 2 * RepeatedMask[i] + 1;
9406         }
9407       return DAG.getNode(
9408           ISD::BITCAST, DL, MVT::v4i64,
9409           DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32,
9410                       DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, V1),
9411                       getV4X86ShuffleImm8ForMask(PSHUFDMask, DAG)));
9412     }
9413   }
9414
9415   // AVX2 provides a direct instruction for permuting a single input across
9416   // lanes.
9417   if (isSingleInputShuffleMask(Mask))
9418     return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4i64, V1,
9419                        getV4X86ShuffleImm8ForMask(Mask, DAG));
9420
9421   // Try to use shift instructions.
9422   if (SDValue Shift =
9423           lowerVectorShuffleAsShift(DL, MVT::v4i64, V1, V2, Mask, DAG))
9424     return Shift;
9425
9426   // Use dedicated unpack instructions for masks that match their pattern.
9427   if (isShuffleEquivalent(V1, V2, Mask, {0, 4, 2, 6}))
9428     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i64, V1, V2);
9429   if (isShuffleEquivalent(V1, V2, Mask, {1, 5, 3, 7}))
9430     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i64, V1, V2);
9431   if (isShuffleEquivalent(V1, V2, Mask, {4, 0, 6, 2}))
9432     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v4i64, V2, V1);
9433   if (isShuffleEquivalent(V1, V2, Mask, {5, 1, 7, 3}))
9434     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v4i64, V2, V1);
9435
9436   // Try to simplify this by merging 128-bit lanes to enable a lane-based
9437   // shuffle. However, if we have AVX2 and either inputs are already in place,
9438   // we will be able to shuffle even across lanes the other input in a single
9439   // instruction so skip this pattern.
9440   if (!(Subtarget->hasAVX2() && (isShuffleMaskInputInPlace(0, Mask) ||
9441                                  isShuffleMaskInputInPlace(1, Mask))))
9442     if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
9443             DL, MVT::v4i64, V1, V2, Mask, Subtarget, DAG))
9444       return Result;
9445
9446   // Otherwise fall back on generic blend lowering.
9447   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v4i64, V1, V2,
9448                                                     Mask, DAG);
9449 }
9450
9451 /// \brief Handle lowering of 8-lane 32-bit floating point shuffles.
9452 ///
9453 /// Also ends up handling lowering of 8-lane 32-bit integer shuffles when AVX2
9454 /// isn't available.
9455 static SDValue lowerV8F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9456                                        const X86Subtarget *Subtarget,
9457                                        SelectionDAG &DAG) {
9458   SDLoc DL(Op);
9459   assert(V1.getSimpleValueType() == MVT::v8f32 && "Bad operand type!");
9460   assert(V2.getSimpleValueType() == MVT::v8f32 && "Bad operand type!");
9461   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9462   ArrayRef<int> Mask = SVOp->getMask();
9463   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
9464
9465   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8f32, V1, V2, Mask,
9466                                                 Subtarget, DAG))
9467     return Blend;
9468
9469   // Check for being able to broadcast a single element.
9470   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v8f32, V1,
9471                                                         Mask, Subtarget, DAG))
9472     return Broadcast;
9473
9474   // If the shuffle mask is repeated in each 128-bit lane, we have many more
9475   // options to efficiently lower the shuffle.
9476   SmallVector<int, 4> RepeatedMask;
9477   if (is128BitLaneRepeatedShuffleMask(MVT::v8f32, Mask, RepeatedMask)) {
9478     assert(RepeatedMask.size() == 4 &&
9479            "Repeated masks must be half the mask width!");
9480
9481     // Use even/odd duplicate instructions for masks that match their pattern.
9482     if (isShuffleEquivalent(V1, V2, Mask, {0, 0, 2, 2, 4, 4, 6, 6}))
9483       return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v8f32, V1);
9484     if (isShuffleEquivalent(V1, V2, Mask, {1, 1, 3, 3, 5, 5, 7, 7}))
9485       return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v8f32, V1);
9486
9487     if (isSingleInputShuffleMask(Mask))
9488       return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v8f32, V1,
9489                          getV4X86ShuffleImm8ForMask(RepeatedMask, DAG));
9490
9491     // Use dedicated unpack instructions for masks that match their pattern.
9492     if (isShuffleEquivalent(V1, V2, Mask, {0, 8, 1, 9, 4, 12, 5, 13}))
9493       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f32, V1, V2);
9494     if (isShuffleEquivalent(V1, V2, Mask, {2, 10, 3, 11, 6, 14, 7, 15}))
9495       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f32, V1, V2);
9496     if (isShuffleEquivalent(V1, V2, Mask, {8, 0, 9, 1, 12, 4, 13, 5}))
9497       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f32, V2, V1);
9498     if (isShuffleEquivalent(V1, V2, Mask, {10, 2, 11, 3, 14, 6, 15, 7}))
9499       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f32, V2, V1);
9500
9501     // Otherwise, fall back to a SHUFPS sequence. Here it is important that we
9502     // have already handled any direct blends. We also need to squash the
9503     // repeated mask into a simulated v4f32 mask.
9504     for (int i = 0; i < 4; ++i)
9505       if (RepeatedMask[i] >= 8)
9506         RepeatedMask[i] -= 4;
9507     return lowerVectorShuffleWithSHUFPS(DL, MVT::v8f32, RepeatedMask, V1, V2, DAG);
9508   }
9509
9510   // If we have a single input shuffle with different shuffle patterns in the
9511   // two 128-bit lanes use the variable mask to VPERMILPS.
9512   if (isSingleInputShuffleMask(Mask)) {
9513     SDValue VPermMask[8];
9514     for (int i = 0; i < 8; ++i)
9515       VPermMask[i] = Mask[i] < 0 ? DAG.getUNDEF(MVT::i32)
9516                                  : DAG.getConstant(Mask[i], MVT::i32);
9517     if (!is128BitLaneCrossingShuffleMask(MVT::v8f32, Mask))
9518       return DAG.getNode(
9519           X86ISD::VPERMILPV, DL, MVT::v8f32, V1,
9520           DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v8i32, VPermMask));
9521
9522     if (Subtarget->hasAVX2())
9523       return DAG.getNode(X86ISD::VPERMV, DL, MVT::v8f32,
9524                          DAG.getNode(ISD::BITCAST, DL, MVT::v8f32,
9525                                      DAG.getNode(ISD::BUILD_VECTOR, DL,
9526                                                  MVT::v8i32, VPermMask)),
9527                          V1);
9528
9529     // Otherwise, fall back.
9530     return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v8f32, V1, V2, Mask,
9531                                                    DAG);
9532   }
9533
9534   // Try to simplify this by merging 128-bit lanes to enable a lane-based
9535   // shuffle.
9536   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
9537           DL, MVT::v8f32, V1, V2, Mask, Subtarget, DAG))
9538     return Result;
9539
9540   // If we have AVX2 then we always want to lower with a blend because at v8 we
9541   // can fully permute the elements.
9542   if (Subtarget->hasAVX2())
9543     return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8f32, V1, V2,
9544                                                       Mask, DAG);
9545
9546   // Otherwise fall back on generic lowering.
9547   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v8f32, V1, V2, Mask, DAG);
9548 }
9549
9550 /// \brief Handle lowering of 8-lane 32-bit integer shuffles.
9551 ///
9552 /// This routine is only called when we have AVX2 and thus a reasonable
9553 /// instruction set for v8i32 shuffling..
9554 static SDValue lowerV8I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9555                                        const X86Subtarget *Subtarget,
9556                                        SelectionDAG &DAG) {
9557   SDLoc DL(Op);
9558   assert(V1.getSimpleValueType() == MVT::v8i32 && "Bad operand type!");
9559   assert(V2.getSimpleValueType() == MVT::v8i32 && "Bad operand type!");
9560   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9561   ArrayRef<int> Mask = SVOp->getMask();
9562   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
9563   assert(Subtarget->hasAVX2() && "We can only lower v8i32 with AVX2!");
9564
9565   // Whenever we can lower this as a zext, that instruction is strictly faster
9566   // than any alternative. It also allows us to fold memory operands into the
9567   // shuffle in many cases.
9568   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v8i32, V1, V2,
9569                                                          Mask, Subtarget, DAG))
9570     return ZExt;
9571
9572   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v8i32, V1, V2, Mask,
9573                                                 Subtarget, DAG))
9574     return Blend;
9575
9576   // Check for being able to broadcast a single element.
9577   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v8i32, V1,
9578                                                         Mask, Subtarget, DAG))
9579     return Broadcast;
9580
9581   // If the shuffle mask is repeated in each 128-bit lane we can use more
9582   // efficient instructions that mirror the shuffles across the two 128-bit
9583   // lanes.
9584   SmallVector<int, 4> RepeatedMask;
9585   if (is128BitLaneRepeatedShuffleMask(MVT::v8i32, Mask, RepeatedMask)) {
9586     assert(RepeatedMask.size() == 4 && "Unexpected repeated mask size!");
9587     if (isSingleInputShuffleMask(Mask))
9588       return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32, V1,
9589                          getV4X86ShuffleImm8ForMask(RepeatedMask, DAG));
9590
9591     // Use dedicated unpack instructions for masks that match their pattern.
9592     if (isShuffleEquivalent(V1, V2, Mask, {0, 8, 1, 9, 4, 12, 5, 13}))
9593       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i32, V1, V2);
9594     if (isShuffleEquivalent(V1, V2, Mask, {2, 10, 3, 11, 6, 14, 7, 15}))
9595       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i32, V1, V2);
9596     if (isShuffleEquivalent(V1, V2, Mask, {8, 0, 9, 1, 12, 4, 13, 5}))
9597       return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i32, V2, V1);
9598     if (isShuffleEquivalent(V1, V2, Mask, {10, 2, 11, 3, 14, 6, 15, 7}))
9599       return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i32, V2, V1);
9600   }
9601
9602   // Try to use shift instructions.
9603   if (SDValue Shift =
9604           lowerVectorShuffleAsShift(DL, MVT::v8i32, V1, V2, Mask, DAG))
9605     return Shift;
9606
9607   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9608           DL, MVT::v8i32, V1, V2, Mask, Subtarget, DAG))
9609     return Rotate;
9610
9611   // If the shuffle patterns aren't repeated but it is a single input, directly
9612   // generate a cross-lane VPERMD instruction.
9613   if (isSingleInputShuffleMask(Mask)) {
9614     SDValue VPermMask[8];
9615     for (int i = 0; i < 8; ++i)
9616       VPermMask[i] = Mask[i] < 0 ? DAG.getUNDEF(MVT::i32)
9617                                  : DAG.getConstant(Mask[i], MVT::i32);
9618     return DAG.getNode(
9619         X86ISD::VPERMV, DL, MVT::v8i32,
9620         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v8i32, VPermMask), V1);
9621   }
9622
9623   // Try to simplify this by merging 128-bit lanes to enable a lane-based
9624   // shuffle.
9625   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
9626           DL, MVT::v8i32, V1, V2, Mask, Subtarget, DAG))
9627     return Result;
9628
9629   // Otherwise fall back on generic blend lowering.
9630   return lowerVectorShuffleAsDecomposedShuffleBlend(DL, MVT::v8i32, V1, V2,
9631                                                     Mask, DAG);
9632 }
9633
9634 /// \brief Handle lowering of 16-lane 16-bit integer shuffles.
9635 ///
9636 /// This routine is only called when we have AVX2 and thus a reasonable
9637 /// instruction set for v16i16 shuffling..
9638 static SDValue lowerV16I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9639                                         const X86Subtarget *Subtarget,
9640                                         SelectionDAG &DAG) {
9641   SDLoc DL(Op);
9642   assert(V1.getSimpleValueType() == MVT::v16i16 && "Bad operand type!");
9643   assert(V2.getSimpleValueType() == MVT::v16i16 && "Bad operand type!");
9644   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9645   ArrayRef<int> Mask = SVOp->getMask();
9646   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
9647   assert(Subtarget->hasAVX2() && "We can only lower v16i16 with AVX2!");
9648
9649   // Whenever we can lower this as a zext, that instruction is strictly faster
9650   // than any alternative. It also allows us to fold memory operands into the
9651   // shuffle in many cases.
9652   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v16i16, V1, V2,
9653                                                          Mask, Subtarget, DAG))
9654     return ZExt;
9655
9656   // Check for being able to broadcast a single element.
9657   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v16i16, V1,
9658                                                         Mask, Subtarget, DAG))
9659     return Broadcast;
9660
9661   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v16i16, V1, V2, Mask,
9662                                                 Subtarget, DAG))
9663     return Blend;
9664
9665   // Use dedicated unpack instructions for masks that match their pattern.
9666   if (isShuffleEquivalent(V1, V2, Mask,
9667                           {// First 128-bit lane:
9668                            0, 16, 1, 17, 2, 18, 3, 19,
9669                            // Second 128-bit lane:
9670                            8, 24, 9, 25, 10, 26, 11, 27}))
9671     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i16, V1, V2);
9672   if (isShuffleEquivalent(V1, V2, Mask,
9673                           {// First 128-bit lane:
9674                            4, 20, 5, 21, 6, 22, 7, 23,
9675                            // Second 128-bit lane:
9676                            12, 28, 13, 29, 14, 30, 15, 31}))
9677     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i16, V1, V2);
9678
9679   // Try to use shift instructions.
9680   if (SDValue Shift =
9681           lowerVectorShuffleAsShift(DL, MVT::v16i16, V1, V2, Mask, DAG))
9682     return Shift;
9683
9684   // Try to use byte rotation instructions.
9685   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9686           DL, MVT::v16i16, V1, V2, Mask, Subtarget, DAG))
9687     return Rotate;
9688
9689   if (isSingleInputShuffleMask(Mask)) {
9690     // There are no generalized cross-lane shuffle operations available on i16
9691     // element types.
9692     if (is128BitLaneCrossingShuffleMask(MVT::v16i16, Mask))
9693       return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v16i16, V1, V2,
9694                                                      Mask, DAG);
9695
9696     SmallVector<int, 8> RepeatedMask;
9697     if (is128BitLaneRepeatedShuffleMask(MVT::v16i16, Mask, RepeatedMask)) {
9698       // As this is a single-input shuffle, the repeated mask should be
9699       // a strictly valid v8i16 mask that we can pass through to the v8i16
9700       // lowering to handle even the v16 case.
9701       return lowerV8I16GeneralSingleInputVectorShuffle(
9702           DL, MVT::v16i16, V1, RepeatedMask, Subtarget, DAG);
9703     }
9704
9705     SDValue PSHUFBMask[32];
9706     for (int i = 0; i < 16; ++i) {
9707       if (Mask[i] == -1) {
9708         PSHUFBMask[2 * i] = PSHUFBMask[2 * i + 1] = DAG.getUNDEF(MVT::i8);
9709         continue;
9710       }
9711
9712       int M = i < 8 ? Mask[i] : Mask[i] - 8;
9713       assert(M >= 0 && M < 8 && "Invalid single-input mask!");
9714       PSHUFBMask[2 * i] = DAG.getConstant(2 * M, MVT::i8);
9715       PSHUFBMask[2 * i + 1] = DAG.getConstant(2 * M + 1, MVT::i8);
9716     }
9717     return DAG.getNode(
9718         ISD::BITCAST, DL, MVT::v16i16,
9719         DAG.getNode(
9720             X86ISD::PSHUFB, DL, MVT::v32i8,
9721             DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, V1),
9722             DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, PSHUFBMask)));
9723   }
9724
9725   // Try to simplify this by merging 128-bit lanes to enable a lane-based
9726   // shuffle.
9727   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
9728           DL, MVT::v16i16, V1, V2, Mask, Subtarget, DAG))
9729     return Result;
9730
9731   // Otherwise fall back on generic lowering.
9732   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v16i16, V1, V2, Mask, DAG);
9733 }
9734
9735 /// \brief Handle lowering of 32-lane 8-bit integer shuffles.
9736 ///
9737 /// This routine is only called when we have AVX2 and thus a reasonable
9738 /// instruction set for v32i8 shuffling..
9739 static SDValue lowerV32I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9740                                        const X86Subtarget *Subtarget,
9741                                        SelectionDAG &DAG) {
9742   SDLoc DL(Op);
9743   assert(V1.getSimpleValueType() == MVT::v32i8 && "Bad operand type!");
9744   assert(V2.getSimpleValueType() == MVT::v32i8 && "Bad operand type!");
9745   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9746   ArrayRef<int> Mask = SVOp->getMask();
9747   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
9748   assert(Subtarget->hasAVX2() && "We can only lower v32i8 with AVX2!");
9749
9750   // Whenever we can lower this as a zext, that instruction is strictly faster
9751   // than any alternative. It also allows us to fold memory operands into the
9752   // shuffle in many cases.
9753   if (SDValue ZExt = lowerVectorShuffleAsZeroOrAnyExtend(DL, MVT::v32i8, V1, V2,
9754                                                          Mask, Subtarget, DAG))
9755     return ZExt;
9756
9757   // Check for being able to broadcast a single element.
9758   if (SDValue Broadcast = lowerVectorShuffleAsBroadcast(DL, MVT::v32i8, V1,
9759                                                         Mask, Subtarget, DAG))
9760     return Broadcast;
9761
9762   if (SDValue Blend = lowerVectorShuffleAsBlend(DL, MVT::v32i8, V1, V2, Mask,
9763                                                 Subtarget, DAG))
9764     return Blend;
9765
9766   // Use dedicated unpack instructions for masks that match their pattern.
9767   // Note that these are repeated 128-bit lane unpacks, not unpacks across all
9768   // 256-bit lanes.
9769   if (isShuffleEquivalent(
9770           V1, V2, Mask,
9771           {// First 128-bit lane:
9772            0, 32, 1, 33, 2, 34, 3, 35, 4, 36, 5, 37, 6, 38, 7, 39,
9773            // Second 128-bit lane:
9774            16, 48, 17, 49, 18, 50, 19, 51, 20, 52, 21, 53, 22, 54, 23, 55}))
9775     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v32i8, V1, V2);
9776   if (isShuffleEquivalent(
9777           V1, V2, Mask,
9778           {// First 128-bit lane:
9779            8, 40, 9, 41, 10, 42, 11, 43, 12, 44, 13, 45, 14, 46, 15, 47,
9780            // Second 128-bit lane:
9781            24, 56, 25, 57, 26, 58, 27, 59, 28, 60, 29, 61, 30, 62, 31, 63}))
9782     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v32i8, V1, V2);
9783
9784   // Try to use shift instructions.
9785   if (SDValue Shift =
9786           lowerVectorShuffleAsShift(DL, MVT::v32i8, V1, V2, Mask, DAG))
9787     return Shift;
9788
9789   // Try to use byte rotation instructions.
9790   if (SDValue Rotate = lowerVectorShuffleAsByteRotate(
9791           DL, MVT::v32i8, V1, V2, Mask, Subtarget, DAG))
9792     return Rotate;
9793
9794   if (isSingleInputShuffleMask(Mask)) {
9795     // There are no generalized cross-lane shuffle operations available on i8
9796     // element types.
9797     if (is128BitLaneCrossingShuffleMask(MVT::v32i8, Mask))
9798       return lowerVectorShuffleAsLanePermuteAndBlend(DL, MVT::v32i8, V1, V2,
9799                                                      Mask, DAG);
9800
9801     SDValue PSHUFBMask[32];
9802     for (int i = 0; i < 32; ++i)
9803       PSHUFBMask[i] =
9804           Mask[i] < 0
9805               ? DAG.getUNDEF(MVT::i8)
9806               : DAG.getConstant(Mask[i] < 16 ? Mask[i] : Mask[i] - 16, MVT::i8);
9807
9808     return DAG.getNode(
9809         X86ISD::PSHUFB, DL, MVT::v32i8, V1,
9810         DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, PSHUFBMask));
9811   }
9812
9813   // Try to simplify this by merging 128-bit lanes to enable a lane-based
9814   // shuffle.
9815   if (SDValue Result = lowerVectorShuffleByMerging128BitLanes(
9816           DL, MVT::v32i8, V1, V2, Mask, Subtarget, DAG))
9817     return Result;
9818
9819   // Otherwise fall back on generic lowering.
9820   return lowerVectorShuffleAsSplitOrBlend(DL, MVT::v32i8, V1, V2, Mask, DAG);
9821 }
9822
9823 /// \brief High-level routine to lower various 256-bit x86 vector shuffles.
9824 ///
9825 /// This routine either breaks down the specific type of a 256-bit x86 vector
9826 /// shuffle or splits it into two 128-bit shuffles and fuses the results back
9827 /// together based on the available instructions.
9828 static SDValue lower256BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9829                                         MVT VT, const X86Subtarget *Subtarget,
9830                                         SelectionDAG &DAG) {
9831   SDLoc DL(Op);
9832   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9833   ArrayRef<int> Mask = SVOp->getMask();
9834
9835   // If we have a single input to the zero element, insert that into V1 if we
9836   // can do so cheaply.
9837   int NumElts = VT.getVectorNumElements();
9838   int NumV2Elements = std::count_if(Mask.begin(), Mask.end(), [NumElts](int M) {
9839     return M >= NumElts;
9840   });
9841
9842   if (NumV2Elements == 1 && Mask[0] >= NumElts)
9843     if (SDValue Insertion = lowerVectorShuffleAsElementInsertion(
9844                               DL, VT, V1, V2, Mask, Subtarget, DAG))
9845       return Insertion;
9846
9847   // There is a really nice hard cut-over between AVX1 and AVX2 that means we can
9848   // check for those subtargets here and avoid much of the subtarget querying in
9849   // the per-vector-type lowering routines. With AVX1 we have essentially *zero*
9850   // ability to manipulate a 256-bit vector with integer types. Since we'll use
9851   // floating point types there eventually, just immediately cast everything to
9852   // a float and operate entirely in that domain.
9853   if (VT.isInteger() && !Subtarget->hasAVX2()) {
9854     int ElementBits = VT.getScalarSizeInBits();
9855     if (ElementBits < 32)
9856       // No floating point type available, decompose into 128-bit vectors.
9857       return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
9858
9859     MVT FpVT = MVT::getVectorVT(MVT::getFloatingPointVT(ElementBits),
9860                                 VT.getVectorNumElements());
9861     V1 = DAG.getNode(ISD::BITCAST, DL, FpVT, V1);
9862     V2 = DAG.getNode(ISD::BITCAST, DL, FpVT, V2);
9863     return DAG.getNode(ISD::BITCAST, DL, VT,
9864                        DAG.getVectorShuffle(FpVT, DL, V1, V2, Mask));
9865   }
9866
9867   switch (VT.SimpleTy) {
9868   case MVT::v4f64:
9869     return lowerV4F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
9870   case MVT::v4i64:
9871     return lowerV4I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
9872   case MVT::v8f32:
9873     return lowerV8F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
9874   case MVT::v8i32:
9875     return lowerV8I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
9876   case MVT::v16i16:
9877     return lowerV16I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
9878   case MVT::v32i8:
9879     return lowerV32I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
9880
9881   default:
9882     llvm_unreachable("Not a valid 256-bit x86 vector type!");
9883   }
9884 }
9885
9886 /// \brief Handle lowering of 8-lane 64-bit floating point shuffles.
9887 static SDValue lowerV8F64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9888                                        const X86Subtarget *Subtarget,
9889                                        SelectionDAG &DAG) {
9890   SDLoc DL(Op);
9891   assert(V1.getSimpleValueType() == MVT::v8f64 && "Bad operand type!");
9892   assert(V2.getSimpleValueType() == MVT::v8f64 && "Bad operand type!");
9893   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9894   ArrayRef<int> Mask = SVOp->getMask();
9895   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
9896
9897   // X86 has dedicated unpack instructions that can handle specific blend
9898   // operations: UNPCKH and UNPCKL.
9899   if (isShuffleEquivalent(V1, V2, Mask, {0, 8, 2, 10, 4, 12, 6, 14}))
9900     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8f64, V1, V2);
9901   if (isShuffleEquivalent(V1, V2, Mask, {1, 9, 3, 11, 5, 13, 7, 15}))
9902     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8f64, V1, V2);
9903
9904   // FIXME: Implement direct support for this type!
9905   return splitAndLowerVectorShuffle(DL, MVT::v8f64, V1, V2, Mask, DAG);
9906 }
9907
9908 /// \brief Handle lowering of 16-lane 32-bit floating point shuffles.
9909 static SDValue lowerV16F32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9910                                        const X86Subtarget *Subtarget,
9911                                        SelectionDAG &DAG) {
9912   SDLoc DL(Op);
9913   assert(V1.getSimpleValueType() == MVT::v16f32 && "Bad operand type!");
9914   assert(V2.getSimpleValueType() == MVT::v16f32 && "Bad operand type!");
9915   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9916   ArrayRef<int> Mask = SVOp->getMask();
9917   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
9918
9919   // Use dedicated unpack instructions for masks that match their pattern.
9920   if (isShuffleEquivalent(V1, V2, Mask,
9921                           {// First 128-bit lane.
9922                            0, 16, 1, 17, 4, 20, 5, 21,
9923                            // Second 128-bit lane.
9924                            8, 24, 9, 25, 12, 28, 13, 29}))
9925     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16f32, V1, V2);
9926   if (isShuffleEquivalent(V1, V2, Mask,
9927                           {// First 128-bit lane.
9928                            2, 18, 3, 19, 6, 22, 7, 23,
9929                            // Second 128-bit lane.
9930                            10, 26, 11, 27, 14, 30, 15, 31}))
9931     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16f32, V1, V2);
9932
9933   // FIXME: Implement direct support for this type!
9934   return splitAndLowerVectorShuffle(DL, MVT::v16f32, V1, V2, Mask, DAG);
9935 }
9936
9937 /// \brief Handle lowering of 8-lane 64-bit integer shuffles.
9938 static SDValue lowerV8I64VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9939                                        const X86Subtarget *Subtarget,
9940                                        SelectionDAG &DAG) {
9941   SDLoc DL(Op);
9942   assert(V1.getSimpleValueType() == MVT::v8i64 && "Bad operand type!");
9943   assert(V2.getSimpleValueType() == MVT::v8i64 && "Bad operand type!");
9944   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9945   ArrayRef<int> Mask = SVOp->getMask();
9946   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
9947
9948   // X86 has dedicated unpack instructions that can handle specific blend
9949   // operations: UNPCKH and UNPCKL.
9950   if (isShuffleEquivalent(V1, V2, Mask, {0, 8, 2, 10, 4, 12, 6, 14}))
9951     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i64, V1, V2);
9952   if (isShuffleEquivalent(V1, V2, Mask, {1, 9, 3, 11, 5, 13, 7, 15}))
9953     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v8i64, V1, V2);
9954
9955   // FIXME: Implement direct support for this type!
9956   return splitAndLowerVectorShuffle(DL, MVT::v8i64, V1, V2, Mask, DAG);
9957 }
9958
9959 /// \brief Handle lowering of 16-lane 32-bit integer shuffles.
9960 static SDValue lowerV16I32VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9961                                        const X86Subtarget *Subtarget,
9962                                        SelectionDAG &DAG) {
9963   SDLoc DL(Op);
9964   assert(V1.getSimpleValueType() == MVT::v16i32 && "Bad operand type!");
9965   assert(V2.getSimpleValueType() == MVT::v16i32 && "Bad operand type!");
9966   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9967   ArrayRef<int> Mask = SVOp->getMask();
9968   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
9969
9970   // Use dedicated unpack instructions for masks that match their pattern.
9971   if (isShuffleEquivalent(V1, V2, Mask,
9972                           {// First 128-bit lane.
9973                            0, 16, 1, 17, 4, 20, 5, 21,
9974                            // Second 128-bit lane.
9975                            8, 24, 9, 25, 12, 28, 13, 29}))
9976     return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i32, V1, V2);
9977   if (isShuffleEquivalent(V1, V2, Mask,
9978                           {// First 128-bit lane.
9979                            2, 18, 3, 19, 6, 22, 7, 23,
9980                            // Second 128-bit lane.
9981                            10, 26, 11, 27, 14, 30, 15, 31}))
9982     return DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i32, V1, V2);
9983
9984   // FIXME: Implement direct support for this type!
9985   return splitAndLowerVectorShuffle(DL, MVT::v16i32, V1, V2, Mask, DAG);
9986 }
9987
9988 /// \brief Handle lowering of 32-lane 16-bit integer shuffles.
9989 static SDValue lowerV32I16VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
9990                                         const X86Subtarget *Subtarget,
9991                                         SelectionDAG &DAG) {
9992   SDLoc DL(Op);
9993   assert(V1.getSimpleValueType() == MVT::v32i16 && "Bad operand type!");
9994   assert(V2.getSimpleValueType() == MVT::v32i16 && "Bad operand type!");
9995   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
9996   ArrayRef<int> Mask = SVOp->getMask();
9997   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
9998   assert(Subtarget->hasBWI() && "We can only lower v32i16 with AVX-512-BWI!");
9999
10000   // FIXME: Implement direct support for this type!
10001   return splitAndLowerVectorShuffle(DL, MVT::v32i16, V1, V2, Mask, DAG);
10002 }
10003
10004 /// \brief Handle lowering of 64-lane 8-bit integer shuffles.
10005 static SDValue lowerV64I8VectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10006                                        const X86Subtarget *Subtarget,
10007                                        SelectionDAG &DAG) {
10008   SDLoc DL(Op);
10009   assert(V1.getSimpleValueType() == MVT::v64i8 && "Bad operand type!");
10010   assert(V2.getSimpleValueType() == MVT::v64i8 && "Bad operand type!");
10011   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10012   ArrayRef<int> Mask = SVOp->getMask();
10013   assert(Mask.size() == 64 && "Unexpected mask size for v64 shuffle!");
10014   assert(Subtarget->hasBWI() && "We can only lower v64i8 with AVX-512-BWI!");
10015
10016   // FIXME: Implement direct support for this type!
10017   return splitAndLowerVectorShuffle(DL, MVT::v64i8, V1, V2, Mask, DAG);
10018 }
10019
10020 /// \brief High-level routine to lower various 512-bit x86 vector shuffles.
10021 ///
10022 /// This routine either breaks down the specific type of a 512-bit x86 vector
10023 /// shuffle or splits it into two 256-bit shuffles and fuses the results back
10024 /// together based on the available instructions.
10025 static SDValue lower512BitVectorShuffle(SDValue Op, SDValue V1, SDValue V2,
10026                                         MVT VT, const X86Subtarget *Subtarget,
10027                                         SelectionDAG &DAG) {
10028   SDLoc DL(Op);
10029   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10030   ArrayRef<int> Mask = SVOp->getMask();
10031   assert(Subtarget->hasAVX512() &&
10032          "Cannot lower 512-bit vectors w/ basic ISA!");
10033
10034   // Check for being able to broadcast a single element.
10035   if (SDValue Broadcast =
10036           lowerVectorShuffleAsBroadcast(DL, VT, V1, Mask, Subtarget, DAG))
10037     return Broadcast;
10038
10039   // Dispatch to each element type for lowering. If we don't have supprot for
10040   // specific element type shuffles at 512 bits, immediately split them and
10041   // lower them. Each lowering routine of a given type is allowed to assume that
10042   // the requisite ISA extensions for that element type are available.
10043   switch (VT.SimpleTy) {
10044   case MVT::v8f64:
10045     return lowerV8F64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10046   case MVT::v16f32:
10047     return lowerV16F32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10048   case MVT::v8i64:
10049     return lowerV8I64VectorShuffle(Op, V1, V2, Subtarget, DAG);
10050   case MVT::v16i32:
10051     return lowerV16I32VectorShuffle(Op, V1, V2, Subtarget, DAG);
10052   case MVT::v32i16:
10053     if (Subtarget->hasBWI())
10054       return lowerV32I16VectorShuffle(Op, V1, V2, Subtarget, DAG);
10055     break;
10056   case MVT::v64i8:
10057     if (Subtarget->hasBWI())
10058       return lowerV64I8VectorShuffle(Op, V1, V2, Subtarget, DAG);
10059     break;
10060
10061   default:
10062     llvm_unreachable("Not a valid 512-bit x86 vector type!");
10063   }
10064
10065   // Otherwise fall back on splitting.
10066   return splitAndLowerVectorShuffle(DL, VT, V1, V2, Mask, DAG);
10067 }
10068
10069 /// \brief Top-level lowering for x86 vector shuffles.
10070 ///
10071 /// This handles decomposition, canonicalization, and lowering of all x86
10072 /// vector shuffles. Most of the specific lowering strategies are encapsulated
10073 /// above in helper routines. The canonicalization attempts to widen shuffles
10074 /// to involve fewer lanes of wider elements, consolidate symmetric patterns
10075 /// s.t. only one of the two inputs needs to be tested, etc.
10076 static SDValue lowerVectorShuffle(SDValue Op, const X86Subtarget *Subtarget,
10077                                   SelectionDAG &DAG) {
10078   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
10079   ArrayRef<int> Mask = SVOp->getMask();
10080   SDValue V1 = Op.getOperand(0);
10081   SDValue V2 = Op.getOperand(1);
10082   MVT VT = Op.getSimpleValueType();
10083   int NumElements = VT.getVectorNumElements();
10084   SDLoc dl(Op);
10085
10086   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
10087
10088   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
10089   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
10090   if (V1IsUndef && V2IsUndef)
10091     return DAG.getUNDEF(VT);
10092
10093   // When we create a shuffle node we put the UNDEF node to second operand,
10094   // but in some cases the first operand may be transformed to UNDEF.
10095   // In this case we should just commute the node.
10096   if (V1IsUndef)
10097     return DAG.getCommutedVectorShuffle(*SVOp);
10098
10099   // Check for non-undef masks pointing at an undef vector and make the masks
10100   // undef as well. This makes it easier to match the shuffle based solely on
10101   // the mask.
10102   if (V2IsUndef)
10103     for (int M : Mask)
10104       if (M >= NumElements) {
10105         SmallVector<int, 8> NewMask(Mask.begin(), Mask.end());
10106         for (int &M : NewMask)
10107           if (M >= NumElements)
10108             M = -1;
10109         return DAG.getVectorShuffle(VT, dl, V1, V2, NewMask);
10110       }
10111
10112   // We actually see shuffles that are entirely re-arrangements of a set of
10113   // zero inputs. This mostly happens while decomposing complex shuffles into
10114   // simple ones. Directly lower these as a buildvector of zeros.
10115   SmallBitVector Zeroable = computeZeroableShuffleElements(Mask, V1, V2);
10116   if (Zeroable.all())
10117     return getZeroVector(VT, Subtarget, DAG, dl);
10118
10119   // Try to collapse shuffles into using a vector type with fewer elements but
10120   // wider element types. We cap this to not form integers or floating point
10121   // elements wider than 64 bits, but it might be interesting to form i128
10122   // integers to handle flipping the low and high halves of AVX 256-bit vectors.
10123   SmallVector<int, 16> WidenedMask;
10124   if (VT.getScalarSizeInBits() < 64 &&
10125       canWidenShuffleElements(Mask, WidenedMask)) {
10126     MVT NewEltVT = VT.isFloatingPoint()
10127                        ? MVT::getFloatingPointVT(VT.getScalarSizeInBits() * 2)
10128                        : MVT::getIntegerVT(VT.getScalarSizeInBits() * 2);
10129     MVT NewVT = MVT::getVectorVT(NewEltVT, VT.getVectorNumElements() / 2);
10130     // Make sure that the new vector type is legal. For example, v2f64 isn't
10131     // legal on SSE1.
10132     if (DAG.getTargetLoweringInfo().isTypeLegal(NewVT)) {
10133       V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, V1);
10134       V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, V2);
10135       return DAG.getNode(ISD::BITCAST, dl, VT,
10136                          DAG.getVectorShuffle(NewVT, dl, V1, V2, WidenedMask));
10137     }
10138   }
10139
10140   int NumV1Elements = 0, NumUndefElements = 0, NumV2Elements = 0;
10141   for (int M : SVOp->getMask())
10142     if (M < 0)
10143       ++NumUndefElements;
10144     else if (M < NumElements)
10145       ++NumV1Elements;
10146     else
10147       ++NumV2Elements;
10148
10149   // Commute the shuffle as needed such that more elements come from V1 than
10150   // V2. This allows us to match the shuffle pattern strictly on how many
10151   // elements come from V1 without handling the symmetric cases.
10152   if (NumV2Elements > NumV1Elements)
10153     return DAG.getCommutedVectorShuffle(*SVOp);
10154
10155   // When the number of V1 and V2 elements are the same, try to minimize the
10156   // number of uses of V2 in the low half of the vector. When that is tied,
10157   // ensure that the sum of indices for V1 is equal to or lower than the sum
10158   // indices for V2. When those are equal, try to ensure that the number of odd
10159   // indices for V1 is lower than the number of odd indices for V2.
10160   if (NumV1Elements == NumV2Elements) {
10161     int LowV1Elements = 0, LowV2Elements = 0;
10162     for (int M : SVOp->getMask().slice(0, NumElements / 2))
10163       if (M >= NumElements)
10164         ++LowV2Elements;
10165       else if (M >= 0)
10166         ++LowV1Elements;
10167     if (LowV2Elements > LowV1Elements) {
10168       return DAG.getCommutedVectorShuffle(*SVOp);
10169     } else if (LowV2Elements == LowV1Elements) {
10170       int SumV1Indices = 0, SumV2Indices = 0;
10171       for (int i = 0, Size = SVOp->getMask().size(); i < Size; ++i)
10172         if (SVOp->getMask()[i] >= NumElements)
10173           SumV2Indices += i;
10174         else if (SVOp->getMask()[i] >= 0)
10175           SumV1Indices += i;
10176       if (SumV2Indices < SumV1Indices) {
10177         return DAG.getCommutedVectorShuffle(*SVOp);
10178       } else if (SumV2Indices == SumV1Indices) {
10179         int NumV1OddIndices = 0, NumV2OddIndices = 0;
10180         for (int i = 0, Size = SVOp->getMask().size(); i < Size; ++i)
10181           if (SVOp->getMask()[i] >= NumElements)
10182             NumV2OddIndices += i % 2;
10183           else if (SVOp->getMask()[i] >= 0)
10184             NumV1OddIndices += i % 2;
10185         if (NumV2OddIndices < NumV1OddIndices)
10186           return DAG.getCommutedVectorShuffle(*SVOp);
10187       }
10188     }
10189   }
10190
10191   // For each vector width, delegate to a specialized lowering routine.
10192   if (VT.getSizeInBits() == 128)
10193     return lower128BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
10194
10195   if (VT.getSizeInBits() == 256)
10196     return lower256BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
10197
10198   // Force AVX-512 vectors to be scalarized for now.
10199   // FIXME: Implement AVX-512 support!
10200   if (VT.getSizeInBits() == 512)
10201     return lower512BitVectorShuffle(Op, V1, V2, VT, Subtarget, DAG);
10202
10203   llvm_unreachable("Unimplemented!");
10204 }
10205
10206 // This function assumes its argument is a BUILD_VECTOR of constants or
10207 // undef SDNodes. i.e: ISD::isBuildVectorOfConstantSDNodes(BuildVector) is
10208 // true.
10209 static bool BUILD_VECTORtoBlendMask(BuildVectorSDNode *BuildVector,
10210                                     unsigned &MaskValue) {
10211   MaskValue = 0;
10212   unsigned NumElems = BuildVector->getNumOperands();
10213   // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
10214   unsigned NumLanes = (NumElems - 1) / 8 + 1;
10215   unsigned NumElemsInLane = NumElems / NumLanes;
10216
10217   // Blend for v16i16 should be symetric for the both lanes.
10218   for (unsigned i = 0; i < NumElemsInLane; ++i) {
10219     SDValue EltCond = BuildVector->getOperand(i);
10220     SDValue SndLaneEltCond =
10221         (NumLanes == 2) ? BuildVector->getOperand(i + NumElemsInLane) : EltCond;
10222
10223     int Lane1Cond = -1, Lane2Cond = -1;
10224     if (isa<ConstantSDNode>(EltCond))
10225       Lane1Cond = !isZero(EltCond);
10226     if (isa<ConstantSDNode>(SndLaneEltCond))
10227       Lane2Cond = !isZero(SndLaneEltCond);
10228
10229     if (Lane1Cond == Lane2Cond || Lane2Cond < 0)
10230       // Lane1Cond != 0, means we want the first argument.
10231       // Lane1Cond == 0, means we want the second argument.
10232       // The encoding of this argument is 0 for the first argument, 1
10233       // for the second. Therefore, invert the condition.
10234       MaskValue |= !Lane1Cond << i;
10235     else if (Lane1Cond < 0)
10236       MaskValue |= !Lane2Cond << i;
10237     else
10238       return false;
10239   }
10240   return true;
10241 }
10242
10243 /// \brief Try to lower a VSELECT instruction to a vector shuffle.
10244 static SDValue lowerVSELECTtoVectorShuffle(SDValue Op,
10245                                            const X86Subtarget *Subtarget,
10246                                            SelectionDAG &DAG) {
10247   SDValue Cond = Op.getOperand(0);
10248   SDValue LHS = Op.getOperand(1);
10249   SDValue RHS = Op.getOperand(2);
10250   SDLoc dl(Op);
10251   MVT VT = Op.getSimpleValueType();
10252
10253   if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
10254     return SDValue();
10255   auto *CondBV = cast<BuildVectorSDNode>(Cond);
10256
10257   // Only non-legal VSELECTs reach this lowering, convert those into generic
10258   // shuffles and re-use the shuffle lowering path for blends.
10259   SmallVector<int, 32> Mask;
10260   for (int i = 0, Size = VT.getVectorNumElements(); i < Size; ++i) {
10261     SDValue CondElt = CondBV->getOperand(i);
10262     Mask.push_back(
10263         isa<ConstantSDNode>(CondElt) ? i + (isZero(CondElt) ? Size : 0) : -1);
10264   }
10265   return DAG.getVectorShuffle(VT, dl, LHS, RHS, Mask);
10266 }
10267
10268 SDValue X86TargetLowering::LowerVSELECT(SDValue Op, SelectionDAG &DAG) const {
10269   // A vselect where all conditions and data are constants can be optimized into
10270   // a single vector load by SelectionDAGLegalize::ExpandBUILD_VECTOR().
10271   if (ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(0).getNode()) &&
10272       ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(1).getNode()) &&
10273       ISD::isBuildVectorOfConstantSDNodes(Op.getOperand(2).getNode()))
10274     return SDValue();
10275
10276   // Try to lower this to a blend-style vector shuffle. This can handle all
10277   // constant condition cases.
10278   if (SDValue BlendOp = lowerVSELECTtoVectorShuffle(Op, Subtarget, DAG))
10279     return BlendOp;
10280
10281   // Variable blends are only legal from SSE4.1 onward.
10282   if (!Subtarget->hasSSE41())
10283     return SDValue();
10284
10285   // Only some types will be legal on some subtargets. If we can emit a legal
10286   // VSELECT-matching blend, return Op, and but if we need to expand, return
10287   // a null value.
10288   switch (Op.getSimpleValueType().SimpleTy) {
10289   default:
10290     // Most of the vector types have blends past SSE4.1.
10291     return Op;
10292
10293   case MVT::v32i8:
10294     // The byte blends for AVX vectors were introduced only in AVX2.
10295     if (Subtarget->hasAVX2())
10296       return Op;
10297
10298     return SDValue();
10299
10300   case MVT::v8i16:
10301   case MVT::v16i16:
10302     // AVX-512 BWI and VLX features support VSELECT with i16 elements.
10303     if (Subtarget->hasBWI() && Subtarget->hasVLX())
10304       return Op;
10305
10306     // FIXME: We should custom lower this by fixing the condition and using i8
10307     // blends.
10308     return SDValue();
10309   }
10310 }
10311
10312 static SDValue LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG) {
10313   MVT VT = Op.getSimpleValueType();
10314   SDLoc dl(Op);
10315
10316   if (!Op.getOperand(0).getSimpleValueType().is128BitVector())
10317     return SDValue();
10318
10319   if (VT.getSizeInBits() == 8) {
10320     SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
10321                                   Op.getOperand(0), Op.getOperand(1));
10322     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
10323                                   DAG.getValueType(VT));
10324     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
10325   }
10326
10327   if (VT.getSizeInBits() == 16) {
10328     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
10329     // If Idx is 0, it's cheaper to do a move instead of a pextrw.
10330     if (Idx == 0)
10331       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
10332                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
10333                                      DAG.getNode(ISD::BITCAST, dl,
10334                                                  MVT::v4i32,
10335                                                  Op.getOperand(0)),
10336                                      Op.getOperand(1)));
10337     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
10338                                   Op.getOperand(0), Op.getOperand(1));
10339     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
10340                                   DAG.getValueType(VT));
10341     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
10342   }
10343
10344   if (VT == MVT::f32) {
10345     // EXTRACTPS outputs to a GPR32 register which will require a movd to copy
10346     // the result back to FR32 register. It's only worth matching if the
10347     // result has a single use which is a store or a bitcast to i32.  And in
10348     // the case of a store, it's not worth it if the index is a constant 0,
10349     // because a MOVSSmr can be used instead, which is smaller and faster.
10350     if (!Op.hasOneUse())
10351       return SDValue();
10352     SDNode *User = *Op.getNode()->use_begin();
10353     if ((User->getOpcode() != ISD::STORE ||
10354          (isa<ConstantSDNode>(Op.getOperand(1)) &&
10355           cast<ConstantSDNode>(Op.getOperand(1))->isNullValue())) &&
10356         (User->getOpcode() != ISD::BITCAST ||
10357          User->getValueType(0) != MVT::i32))
10358       return SDValue();
10359     SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
10360                                   DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
10361                                               Op.getOperand(0)),
10362                                               Op.getOperand(1));
10363     return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
10364   }
10365
10366   if (VT == MVT::i32 || VT == MVT::i64) {
10367     // ExtractPS/pextrq works with constant index.
10368     if (isa<ConstantSDNode>(Op.getOperand(1)))
10369       return Op;
10370   }
10371   return SDValue();
10372 }
10373
10374 /// Extract one bit from mask vector, like v16i1 or v8i1.
10375 /// AVX-512 feature.
10376 SDValue
10377 X86TargetLowering::ExtractBitFromMaskVector(SDValue Op, SelectionDAG &DAG) const {
10378   SDValue Vec = Op.getOperand(0);
10379   SDLoc dl(Vec);
10380   MVT VecVT = Vec.getSimpleValueType();
10381   SDValue Idx = Op.getOperand(1);
10382   MVT EltVT = Op.getSimpleValueType();
10383
10384   assert((EltVT == MVT::i1) && "Unexpected operands in ExtractBitFromMaskVector");
10385   assert((VecVT.getVectorNumElements() <= 16 || Subtarget->hasBWI()) &&
10386          "Unexpected vector type in ExtractBitFromMaskVector");
10387
10388   // variable index can't be handled in mask registers,
10389   // extend vector to VR512
10390   if (!isa<ConstantSDNode>(Idx)) {
10391     MVT ExtVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
10392     SDValue Ext = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, Vec);
10393     SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
10394                               ExtVT.getVectorElementType(), Ext, Idx);
10395     return DAG.getNode(ISD::TRUNCATE, dl, EltVT, Elt);
10396   }
10397
10398   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
10399   const TargetRegisterClass* rc = getRegClassFor(VecVT);
10400   if (!Subtarget->hasDQI() && (VecVT.getVectorNumElements() <= 8))
10401     rc = getRegClassFor(MVT::v16i1);
10402   unsigned MaxSift = rc->getSize()*8 - 1;
10403   Vec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, Vec,
10404                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
10405   Vec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, Vec,
10406                     DAG.getConstant(MaxSift, MVT::i8));
10407   return DAG.getNode(X86ISD::VEXTRACT, dl, MVT::i1, Vec,
10408                        DAG.getIntPtrConstant(0));
10409 }
10410
10411 SDValue
10412 X86TargetLowering::LowerEXTRACT_VECTOR_ELT(SDValue Op,
10413                                            SelectionDAG &DAG) const {
10414   SDLoc dl(Op);
10415   SDValue Vec = Op.getOperand(0);
10416   MVT VecVT = Vec.getSimpleValueType();
10417   SDValue Idx = Op.getOperand(1);
10418
10419   if (Op.getSimpleValueType() == MVT::i1)
10420     return ExtractBitFromMaskVector(Op, DAG);
10421
10422   if (!isa<ConstantSDNode>(Idx)) {
10423     if (VecVT.is512BitVector() ||
10424         (VecVT.is256BitVector() && Subtarget->hasInt256() &&
10425          VecVT.getVectorElementType().getSizeInBits() == 32)) {
10426
10427       MVT MaskEltVT =
10428         MVT::getIntegerVT(VecVT.getVectorElementType().getSizeInBits());
10429       MVT MaskVT = MVT::getVectorVT(MaskEltVT, VecVT.getSizeInBits() /
10430                                     MaskEltVT.getSizeInBits());
10431
10432       Idx = DAG.getZExtOrTrunc(Idx, dl, MaskEltVT);
10433       SDValue Mask = DAG.getNode(X86ISD::VINSERT, dl, MaskVT,
10434                                 getZeroVector(MaskVT, Subtarget, DAG, dl),
10435                                 Idx, DAG.getConstant(0, getPointerTy()));
10436       SDValue Perm = DAG.getNode(X86ISD::VPERMV, dl, VecVT, Mask, Vec);
10437       return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(),
10438                         Perm, DAG.getConstant(0, getPointerTy()));
10439     }
10440     return SDValue();
10441   }
10442
10443   // If this is a 256-bit vector result, first extract the 128-bit vector and
10444   // then extract the element from the 128-bit vector.
10445   if (VecVT.is256BitVector() || VecVT.is512BitVector()) {
10446
10447     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
10448     // Get the 128-bit vector.
10449     Vec = Extract128BitVector(Vec, IdxVal, DAG, dl);
10450     MVT EltVT = VecVT.getVectorElementType();
10451
10452     unsigned ElemsPerChunk = 128 / EltVT.getSizeInBits();
10453
10454     //if (IdxVal >= NumElems/2)
10455     //  IdxVal -= NumElems/2;
10456     IdxVal -= (IdxVal/ElemsPerChunk)*ElemsPerChunk;
10457     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
10458                        DAG.getConstant(IdxVal, MVT::i32));
10459   }
10460
10461   assert(VecVT.is128BitVector() && "Unexpected vector length");
10462
10463   if (Subtarget->hasSSE41()) {
10464     SDValue Res = LowerEXTRACT_VECTOR_ELT_SSE4(Op, DAG);
10465     if (Res.getNode())
10466       return Res;
10467   }
10468
10469   MVT VT = Op.getSimpleValueType();
10470   // TODO: handle v16i8.
10471   if (VT.getSizeInBits() == 16) {
10472     SDValue Vec = Op.getOperand(0);
10473     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
10474     if (Idx == 0)
10475       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
10476                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
10477                                      DAG.getNode(ISD::BITCAST, dl,
10478                                                  MVT::v4i32, Vec),
10479                                      Op.getOperand(1)));
10480     // Transform it so it match pextrw which produces a 32-bit result.
10481     MVT EltVT = MVT::i32;
10482     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
10483                                   Op.getOperand(0), Op.getOperand(1));
10484     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
10485                                   DAG.getValueType(VT));
10486     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
10487   }
10488
10489   if (VT.getSizeInBits() == 32) {
10490     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
10491     if (Idx == 0)
10492       return Op;
10493
10494     // SHUFPS the element to the lowest double word, then movss.
10495     int Mask[4] = { static_cast<int>(Idx), -1, -1, -1 };
10496     MVT VVT = Op.getOperand(0).getSimpleValueType();
10497     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
10498                                        DAG.getUNDEF(VVT), Mask);
10499     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
10500                        DAG.getIntPtrConstant(0));
10501   }
10502
10503   if (VT.getSizeInBits() == 64) {
10504     // FIXME: .td only matches this for <2 x f64>, not <2 x i64> on 32b
10505     // FIXME: seems like this should be unnecessary if mov{h,l}pd were taught
10506     //        to match extract_elt for f64.
10507     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
10508     if (Idx == 0)
10509       return Op;
10510
10511     // UNPCKHPD the element to the lowest double word, then movsd.
10512     // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
10513     // to a f64mem, the whole operation is folded into a single MOVHPDmr.
10514     int Mask[2] = { 1, -1 };
10515     MVT VVT = Op.getOperand(0).getSimpleValueType();
10516     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
10517                                        DAG.getUNDEF(VVT), Mask);
10518     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
10519                        DAG.getIntPtrConstant(0));
10520   }
10521
10522   return SDValue();
10523 }
10524
10525 /// Insert one bit to mask vector, like v16i1 or v8i1.
10526 /// AVX-512 feature.
10527 SDValue
10528 X86TargetLowering::InsertBitToMaskVector(SDValue Op, SelectionDAG &DAG) const {
10529   SDLoc dl(Op);
10530   SDValue Vec = Op.getOperand(0);
10531   SDValue Elt = Op.getOperand(1);
10532   SDValue Idx = Op.getOperand(2);
10533   MVT VecVT = Vec.getSimpleValueType();
10534
10535   if (!isa<ConstantSDNode>(Idx)) {
10536     // Non constant index. Extend source and destination,
10537     // insert element and then truncate the result.
10538     MVT ExtVecVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
10539     MVT ExtEltVT = (VecVT == MVT::v8i1 ?  MVT::i64 : MVT::i32);
10540     SDValue ExtOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, ExtVecVT,
10541       DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVecVT, Vec),
10542       DAG.getNode(ISD::ZERO_EXTEND, dl, ExtEltVT, Elt), Idx);
10543     return DAG.getNode(ISD::TRUNCATE, dl, VecVT, ExtOp);
10544   }
10545
10546   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
10547   SDValue EltInVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Elt);
10548   if (Vec.getOpcode() == ISD::UNDEF)
10549     return DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
10550                        DAG.getConstant(IdxVal, MVT::i8));
10551   const TargetRegisterClass* rc = getRegClassFor(VecVT);
10552   unsigned MaxSift = rc->getSize()*8 - 1;
10553   EltInVec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
10554                     DAG.getConstant(MaxSift, MVT::i8));
10555   EltInVec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, EltInVec,
10556                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
10557   return DAG.getNode(ISD::OR, dl, VecVT, Vec, EltInVec);
10558 }
10559
10560 SDValue X86TargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op,
10561                                                   SelectionDAG &DAG) const {
10562   MVT VT = Op.getSimpleValueType();
10563   MVT EltVT = VT.getVectorElementType();
10564
10565   if (EltVT == MVT::i1)
10566     return InsertBitToMaskVector(Op, DAG);
10567
10568   SDLoc dl(Op);
10569   SDValue N0 = Op.getOperand(0);
10570   SDValue N1 = Op.getOperand(1);
10571   SDValue N2 = Op.getOperand(2);
10572   if (!isa<ConstantSDNode>(N2))
10573     return SDValue();
10574   auto *N2C = cast<ConstantSDNode>(N2);
10575   unsigned IdxVal = N2C->getZExtValue();
10576
10577   // If the vector is wider than 128 bits, extract the 128-bit subvector, insert
10578   // into that, and then insert the subvector back into the result.
10579   if (VT.is256BitVector() || VT.is512BitVector()) {
10580     // With a 256-bit vector, we can insert into the zero element efficiently
10581     // using a blend if we have AVX or AVX2 and the right data type.
10582     if (VT.is256BitVector() && IdxVal == 0) {
10583       // TODO: It is worthwhile to cast integer to floating point and back
10584       // and incur a domain crossing penalty if that's what we'll end up
10585       // doing anyway after extracting to a 128-bit vector.
10586       if ((Subtarget->hasAVX() && (EltVT == MVT::f64 || EltVT == MVT::f32)) ||
10587           (Subtarget->hasAVX2() && EltVT == MVT::i32)) {
10588         SDValue N1Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, N1);
10589         N2 = DAG.getIntPtrConstant(1);
10590         return DAG.getNode(X86ISD::BLENDI, dl, VT, N0, N1Vec, N2);
10591       }
10592     }
10593
10594     // Get the desired 128-bit vector chunk.
10595     SDValue V = Extract128BitVector(N0, IdxVal, DAG, dl);
10596
10597     // Insert the element into the desired chunk.
10598     unsigned NumEltsIn128 = 128 / EltVT.getSizeInBits();
10599     unsigned IdxIn128 = IdxVal - (IdxVal / NumEltsIn128) * NumEltsIn128;
10600
10601     V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V, N1,
10602                     DAG.getConstant(IdxIn128, MVT::i32));
10603
10604     // Insert the changed part back into the bigger vector
10605     return Insert128BitVector(N0, V, IdxVal, DAG, dl);
10606   }
10607   assert(VT.is128BitVector() && "Only 128-bit vector types should be left!");
10608
10609   if (Subtarget->hasSSE41()) {
10610     if (EltVT.getSizeInBits() == 8 || EltVT.getSizeInBits() == 16) {
10611       unsigned Opc;
10612       if (VT == MVT::v8i16) {
10613         Opc = X86ISD::PINSRW;
10614       } else {
10615         assert(VT == MVT::v16i8);
10616         Opc = X86ISD::PINSRB;
10617       }
10618
10619       // Transform it so it match pinsr{b,w} which expects a GR32 as its second
10620       // argument.
10621       if (N1.getValueType() != MVT::i32)
10622         N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
10623       if (N2.getValueType() != MVT::i32)
10624         N2 = DAG.getIntPtrConstant(IdxVal);
10625       return DAG.getNode(Opc, dl, VT, N0, N1, N2);
10626     }
10627
10628     if (EltVT == MVT::f32) {
10629       // Bits [7:6] of the constant are the source select. This will always be
10630       //   zero here. The DAG Combiner may combine an extract_elt index into
10631       //   these bits. For example (insert (extract, 3), 2) could be matched by
10632       //   putting the '3' into bits [7:6] of X86ISD::INSERTPS.
10633       // Bits [5:4] of the constant are the destination select. This is the
10634       //   value of the incoming immediate.
10635       // Bits [3:0] of the constant are the zero mask. The DAG Combiner may
10636       //   combine either bitwise AND or insert of float 0.0 to set these bits.
10637
10638       const Function *F = DAG.getMachineFunction().getFunction();
10639       bool MinSize = F->hasFnAttribute(Attribute::MinSize);
10640       if (IdxVal == 0 && (!MinSize || !MayFoldLoad(N1))) {
10641         // If this is an insertion of 32-bits into the low 32-bits of
10642         // a vector, we prefer to generate a blend with immediate rather
10643         // than an insertps. Blends are simpler operations in hardware and so
10644         // will always have equal or better performance than insertps.
10645         // But if optimizing for size and there's a load folding opportunity,
10646         // generate insertps because blendps does not have a 32-bit memory
10647         // operand form.
10648         N2 = DAG.getIntPtrConstant(1);
10649         N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
10650         return DAG.getNode(X86ISD::BLENDI, dl, VT, N0, N1, N2);
10651       }
10652       N2 = DAG.getIntPtrConstant(IdxVal << 4);
10653       // Create this as a scalar to vector..
10654       N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
10655       return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
10656     }
10657
10658     if (EltVT == MVT::i32 || EltVT == MVT::i64) {
10659       // PINSR* works with constant index.
10660       return Op;
10661     }
10662   }
10663
10664   if (EltVT == MVT::i8)
10665     return SDValue();
10666
10667   if (EltVT.getSizeInBits() == 16) {
10668     // Transform it so it match pinsrw which expects a 16-bit value in a GR32
10669     // as its second argument.
10670     if (N1.getValueType() != MVT::i32)
10671       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
10672     if (N2.getValueType() != MVT::i32)
10673       N2 = DAG.getIntPtrConstant(IdxVal);
10674     return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
10675   }
10676   return SDValue();
10677 }
10678
10679 static SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) {
10680   SDLoc dl(Op);
10681   MVT OpVT = Op.getSimpleValueType();
10682
10683   // If this is a 256-bit vector result, first insert into a 128-bit
10684   // vector and then insert into the 256-bit vector.
10685   if (!OpVT.is128BitVector()) {
10686     // Insert into a 128-bit vector.
10687     unsigned SizeFactor = OpVT.getSizeInBits()/128;
10688     MVT VT128 = MVT::getVectorVT(OpVT.getVectorElementType(),
10689                                  OpVT.getVectorNumElements() / SizeFactor);
10690
10691     Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
10692
10693     // Insert the 128-bit vector.
10694     return Insert128BitVector(DAG.getUNDEF(OpVT), Op, 0, DAG, dl);
10695   }
10696
10697   if (OpVT == MVT::v1i64 &&
10698       Op.getOperand(0).getValueType() == MVT::i64)
10699     return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
10700
10701   SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
10702   assert(OpVT.is128BitVector() && "Expected an SSE type!");
10703   return DAG.getNode(ISD::BITCAST, dl, OpVT,
10704                      DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
10705 }
10706
10707 // Lower a node with an EXTRACT_SUBVECTOR opcode.  This may result in
10708 // a simple subregister reference or explicit instructions to grab
10709 // upper bits of a vector.
10710 static SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
10711                                       SelectionDAG &DAG) {
10712   SDLoc dl(Op);
10713   SDValue In =  Op.getOperand(0);
10714   SDValue Idx = Op.getOperand(1);
10715   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
10716   MVT ResVT   = Op.getSimpleValueType();
10717   MVT InVT    = In.getSimpleValueType();
10718
10719   if (Subtarget->hasFp256()) {
10720     if (ResVT.is128BitVector() &&
10721         (InVT.is256BitVector() || InVT.is512BitVector()) &&
10722         isa<ConstantSDNode>(Idx)) {
10723       return Extract128BitVector(In, IdxVal, DAG, dl);
10724     }
10725     if (ResVT.is256BitVector() && InVT.is512BitVector() &&
10726         isa<ConstantSDNode>(Idx)) {
10727       return Extract256BitVector(In, IdxVal, DAG, dl);
10728     }
10729   }
10730   return SDValue();
10731 }
10732
10733 // Lower a node with an INSERT_SUBVECTOR opcode.  This may result in a
10734 // simple superregister reference or explicit instructions to insert
10735 // the upper bits of a vector.
10736 static SDValue LowerINSERT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
10737                                      SelectionDAG &DAG) {
10738   if (!Subtarget->hasAVX())
10739     return SDValue();
10740
10741   SDLoc dl(Op);
10742   SDValue Vec = Op.getOperand(0);
10743   SDValue SubVec = Op.getOperand(1);
10744   SDValue Idx = Op.getOperand(2);
10745
10746   if (!isa<ConstantSDNode>(Idx))
10747     return SDValue();
10748
10749   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
10750   MVT OpVT = Op.getSimpleValueType();
10751   MVT SubVecVT = SubVec.getSimpleValueType();
10752
10753   // Fold two 16-byte subvector loads into one 32-byte load:
10754   // (insert_subvector (insert_subvector undef, (load addr), 0),
10755   //                   (load addr + 16), Elts/2)
10756   // --> load32 addr
10757   if ((IdxVal == OpVT.getVectorNumElements() / 2) &&
10758       Vec.getOpcode() == ISD::INSERT_SUBVECTOR &&
10759       OpVT.is256BitVector() && SubVecVT.is128BitVector() &&
10760       !Subtarget->isUnalignedMem32Slow()) {
10761     SDValue SubVec2 = Vec.getOperand(1);
10762     if (auto *Idx2 = dyn_cast<ConstantSDNode>(Vec.getOperand(2))) {
10763       if (Idx2->getZExtValue() == 0) {
10764         SDValue Ops[] = { SubVec2, SubVec };
10765         SDValue LD = EltsFromConsecutiveLoads(OpVT, Ops, dl, DAG, false);
10766         if (LD.getNode())
10767           return LD;
10768       }
10769     }
10770   }
10771
10772   if ((OpVT.is256BitVector() || OpVT.is512BitVector()) &&
10773       SubVecVT.is128BitVector())
10774     return Insert128BitVector(Vec, SubVec, IdxVal, DAG, dl);
10775
10776   if (OpVT.is512BitVector() && SubVecVT.is256BitVector())
10777     return Insert256BitVector(Vec, SubVec, IdxVal, DAG, dl);
10778
10779   if (OpVT.getVectorElementType() == MVT::i1) {
10780     if (IdxVal == 0  && Vec.getOpcode() == ISD::UNDEF) // the operation is legal
10781       return Op;
10782     SDValue ZeroIdx = DAG.getIntPtrConstant(0);
10783     SDValue Undef = DAG.getUNDEF(OpVT);
10784     unsigned NumElems = OpVT.getVectorNumElements();
10785     SDValue ShiftBits = DAG.getConstant(NumElems/2, MVT::i8);
10786
10787     if (IdxVal == OpVT.getVectorNumElements() / 2) {
10788       // Zero upper bits of the Vec
10789       Vec = DAG.getNode(X86ISD::VSHLI, dl, OpVT, Vec, ShiftBits);
10790       Vec = DAG.getNode(X86ISD::VSRLI, dl, OpVT, Vec, ShiftBits);
10791
10792       SDValue Vec2 = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, OpVT, Undef,
10793                                  SubVec, ZeroIdx);
10794       Vec2 = DAG.getNode(X86ISD::VSHLI, dl, OpVT, Vec2, ShiftBits);
10795       return DAG.getNode(ISD::OR, dl, OpVT, Vec, Vec2);
10796     }
10797     if (IdxVal == 0) {
10798       SDValue Vec2 = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, OpVT, Undef,
10799                                  SubVec, ZeroIdx);
10800       // Zero upper bits of the Vec2
10801       Vec2 = DAG.getNode(X86ISD::VSHLI, dl, OpVT, Vec2, ShiftBits);
10802       Vec2 = DAG.getNode(X86ISD::VSRLI, dl, OpVT, Vec2, ShiftBits);
10803       // Zero lower bits of the Vec
10804       Vec = DAG.getNode(X86ISD::VSRLI, dl, OpVT, Vec, ShiftBits);
10805       Vec = DAG.getNode(X86ISD::VSHLI, dl, OpVT, Vec, ShiftBits);
10806       // Merge them together
10807       return DAG.getNode(ISD::OR, dl, OpVT, Vec, Vec2);
10808     }
10809   }
10810   return SDValue();
10811 }
10812
10813 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
10814 // their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is
10815 // one of the above mentioned nodes. It has to be wrapped because otherwise
10816 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
10817 // be used to form addressing mode. These wrapped nodes will be selected
10818 // into MOV32ri.
10819 SDValue
10820 X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
10821   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
10822
10823   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
10824   // global base reg.
10825   unsigned char OpFlag = 0;
10826   unsigned WrapperKind = X86ISD::Wrapper;
10827   CodeModel::Model M = DAG.getTarget().getCodeModel();
10828
10829   if (Subtarget->isPICStyleRIPRel() &&
10830       (M == CodeModel::Small || M == CodeModel::Kernel))
10831     WrapperKind = X86ISD::WrapperRIP;
10832   else if (Subtarget->isPICStyleGOT())
10833     OpFlag = X86II::MO_GOTOFF;
10834   else if (Subtarget->isPICStyleStubPIC())
10835     OpFlag = X86II::MO_PIC_BASE_OFFSET;
10836
10837   SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(), getPointerTy(),
10838                                              CP->getAlignment(),
10839                                              CP->getOffset(), OpFlag);
10840   SDLoc DL(CP);
10841   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
10842   // With PIC, the address is actually $g + Offset.
10843   if (OpFlag) {
10844     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10845                          DAG.getNode(X86ISD::GlobalBaseReg,
10846                                      SDLoc(), getPointerTy()),
10847                          Result);
10848   }
10849
10850   return Result;
10851 }
10852
10853 SDValue X86TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
10854   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
10855
10856   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
10857   // global base reg.
10858   unsigned char OpFlag = 0;
10859   unsigned WrapperKind = X86ISD::Wrapper;
10860   CodeModel::Model M = DAG.getTarget().getCodeModel();
10861
10862   if (Subtarget->isPICStyleRIPRel() &&
10863       (M == CodeModel::Small || M == CodeModel::Kernel))
10864     WrapperKind = X86ISD::WrapperRIP;
10865   else if (Subtarget->isPICStyleGOT())
10866     OpFlag = X86II::MO_GOTOFF;
10867   else if (Subtarget->isPICStyleStubPIC())
10868     OpFlag = X86II::MO_PIC_BASE_OFFSET;
10869
10870   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy(),
10871                                           OpFlag);
10872   SDLoc DL(JT);
10873   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
10874
10875   // With PIC, the address is actually $g + Offset.
10876   if (OpFlag)
10877     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10878                          DAG.getNode(X86ISD::GlobalBaseReg,
10879                                      SDLoc(), getPointerTy()),
10880                          Result);
10881
10882   return Result;
10883 }
10884
10885 SDValue
10886 X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const {
10887   const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
10888
10889   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
10890   // global base reg.
10891   unsigned char OpFlag = 0;
10892   unsigned WrapperKind = X86ISD::Wrapper;
10893   CodeModel::Model M = DAG.getTarget().getCodeModel();
10894
10895   if (Subtarget->isPICStyleRIPRel() &&
10896       (M == CodeModel::Small || M == CodeModel::Kernel)) {
10897     if (Subtarget->isTargetDarwin() || Subtarget->isTargetELF())
10898       OpFlag = X86II::MO_GOTPCREL;
10899     WrapperKind = X86ISD::WrapperRIP;
10900   } else if (Subtarget->isPICStyleGOT()) {
10901     OpFlag = X86II::MO_GOT;
10902   } else if (Subtarget->isPICStyleStubPIC()) {
10903     OpFlag = X86II::MO_DARWIN_NONLAZY_PIC_BASE;
10904   } else if (Subtarget->isPICStyleStubNoDynamic()) {
10905     OpFlag = X86II::MO_DARWIN_NONLAZY;
10906   }
10907
10908   SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlag);
10909
10910   SDLoc DL(Op);
10911   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
10912
10913   // With PIC, the address is actually $g + Offset.
10914   if (DAG.getTarget().getRelocationModel() == Reloc::PIC_ &&
10915       !Subtarget->is64Bit()) {
10916     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10917                          DAG.getNode(X86ISD::GlobalBaseReg,
10918                                      SDLoc(), getPointerTy()),
10919                          Result);
10920   }
10921
10922   // For symbols that require a load from a stub to get the address, emit the
10923   // load.
10924   if (isGlobalStubReference(OpFlag))
10925     Result = DAG.getLoad(getPointerTy(), DL, DAG.getEntryNode(), Result,
10926                          MachinePointerInfo::getGOT(), false, false, false, 0);
10927
10928   return Result;
10929 }
10930
10931 SDValue
10932 X86TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
10933   // Create the TargetBlockAddressAddress node.
10934   unsigned char OpFlags =
10935     Subtarget->ClassifyBlockAddressReference();
10936   CodeModel::Model M = DAG.getTarget().getCodeModel();
10937   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
10938   int64_t Offset = cast<BlockAddressSDNode>(Op)->getOffset();
10939   SDLoc dl(Op);
10940   SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy(), Offset,
10941                                              OpFlags);
10942
10943   if (Subtarget->isPICStyleRIPRel() &&
10944       (M == CodeModel::Small || M == CodeModel::Kernel))
10945     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
10946   else
10947     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
10948
10949   // With PIC, the address is actually $g + Offset.
10950   if (isGlobalRelativeToPICBase(OpFlags)) {
10951     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
10952                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
10953                          Result);
10954   }
10955
10956   return Result;
10957 }
10958
10959 SDValue
10960 X86TargetLowering::LowerGlobalAddress(const GlobalValue *GV, SDLoc dl,
10961                                       int64_t Offset, SelectionDAG &DAG) const {
10962   // Create the TargetGlobalAddress node, folding in the constant
10963   // offset if it is legal.
10964   unsigned char OpFlags =
10965       Subtarget->ClassifyGlobalReference(GV, DAG.getTarget());
10966   CodeModel::Model M = DAG.getTarget().getCodeModel();
10967   SDValue Result;
10968   if (OpFlags == X86II::MO_NO_FLAG &&
10969       X86::isOffsetSuitableForCodeModel(Offset, M)) {
10970     // A direct static reference to a global.
10971     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
10972     Offset = 0;
10973   } else {
10974     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
10975   }
10976
10977   if (Subtarget->isPICStyleRIPRel() &&
10978       (M == CodeModel::Small || M == CodeModel::Kernel))
10979     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
10980   else
10981     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
10982
10983   // With PIC, the address is actually $g + Offset.
10984   if (isGlobalRelativeToPICBase(OpFlags)) {
10985     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
10986                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
10987                          Result);
10988   }
10989
10990   // For globals that require a load from a stub to get the address, emit the
10991   // load.
10992   if (isGlobalStubReference(OpFlags))
10993     Result = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Result,
10994                          MachinePointerInfo::getGOT(), false, false, false, 0);
10995
10996   // If there was a non-zero offset that we didn't fold, create an explicit
10997   // addition for it.
10998   if (Offset != 0)
10999     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
11000                          DAG.getConstant(Offset, getPointerTy()));
11001
11002   return Result;
11003 }
11004
11005 SDValue
11006 X86TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
11007   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
11008   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
11009   return LowerGlobalAddress(GV, SDLoc(Op), Offset, DAG);
11010 }
11011
11012 static SDValue
11013 GetTLSADDR(SelectionDAG &DAG, SDValue Chain, GlobalAddressSDNode *GA,
11014            SDValue *InFlag, const EVT PtrVT, unsigned ReturnReg,
11015            unsigned char OperandFlags, bool LocalDynamic = false) {
11016   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
11017   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
11018   SDLoc dl(GA);
11019   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
11020                                            GA->getValueType(0),
11021                                            GA->getOffset(),
11022                                            OperandFlags);
11023
11024   X86ISD::NodeType CallType = LocalDynamic ? X86ISD::TLSBASEADDR
11025                                            : X86ISD::TLSADDR;
11026
11027   if (InFlag) {
11028     SDValue Ops[] = { Chain,  TGA, *InFlag };
11029     Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
11030   } else {
11031     SDValue Ops[]  = { Chain, TGA };
11032     Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
11033   }
11034
11035   // TLSADDR will be codegen'ed as call. Inform MFI that function has calls.
11036   MFI->setAdjustsStack(true);
11037   MFI->setHasCalls(true);
11038
11039   SDValue Flag = Chain.getValue(1);
11040   return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Flag);
11041 }
11042
11043 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 32 bit
11044 static SDValue
11045 LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
11046                                 const EVT PtrVT) {
11047   SDValue InFlag;
11048   SDLoc dl(GA);  // ? function entry point might be better
11049   SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
11050                                    DAG.getNode(X86ISD::GlobalBaseReg,
11051                                                SDLoc(), PtrVT), InFlag);
11052   InFlag = Chain.getValue(1);
11053
11054   return GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX, X86II::MO_TLSGD);
11055 }
11056
11057 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 64 bit
11058 static SDValue
11059 LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
11060                                 const EVT PtrVT) {
11061   return GetTLSADDR(DAG, DAG.getEntryNode(), GA, nullptr, PtrVT,
11062                     X86::RAX, X86II::MO_TLSGD);
11063 }
11064
11065 static SDValue LowerToTLSLocalDynamicModel(GlobalAddressSDNode *GA,
11066                                            SelectionDAG &DAG,
11067                                            const EVT PtrVT,
11068                                            bool is64Bit) {
11069   SDLoc dl(GA);
11070
11071   // Get the start address of the TLS block for this module.
11072   X86MachineFunctionInfo* MFI = DAG.getMachineFunction()
11073       .getInfo<X86MachineFunctionInfo>();
11074   MFI->incNumLocalDynamicTLSAccesses();
11075
11076   SDValue Base;
11077   if (is64Bit) {
11078     Base = GetTLSADDR(DAG, DAG.getEntryNode(), GA, nullptr, PtrVT, X86::RAX,
11079                       X86II::MO_TLSLD, /*LocalDynamic=*/true);
11080   } else {
11081     SDValue InFlag;
11082     SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
11083         DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT), InFlag);
11084     InFlag = Chain.getValue(1);
11085     Base = GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX,
11086                       X86II::MO_TLSLDM, /*LocalDynamic=*/true);
11087   }
11088
11089   // Note: the CleanupLocalDynamicTLSPass will remove redundant computations
11090   // of Base.
11091
11092   // Build x@dtpoff.
11093   unsigned char OperandFlags = X86II::MO_DTPOFF;
11094   unsigned WrapperKind = X86ISD::Wrapper;
11095   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
11096                                            GA->getValueType(0),
11097                                            GA->getOffset(), OperandFlags);
11098   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
11099
11100   // Add x@dtpoff with the base.
11101   return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
11102 }
11103
11104 // Lower ISD::GlobalTLSAddress using the "initial exec" or "local exec" model.
11105 static SDValue LowerToTLSExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG,
11106                                    const EVT PtrVT, TLSModel::Model model,
11107                                    bool is64Bit, bool isPIC) {
11108   SDLoc dl(GA);
11109
11110   // Get the Thread Pointer, which is %gs:0 (32-bit) or %fs:0 (64-bit).
11111   Value *Ptr = Constant::getNullValue(Type::getInt8PtrTy(*DAG.getContext(),
11112                                                          is64Bit ? 257 : 256));
11113
11114   SDValue ThreadPointer =
11115       DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), DAG.getIntPtrConstant(0),
11116                   MachinePointerInfo(Ptr), false, false, false, 0);
11117
11118   unsigned char OperandFlags = 0;
11119   // Most TLS accesses are not RIP relative, even on x86-64.  One exception is
11120   // initialexec.
11121   unsigned WrapperKind = X86ISD::Wrapper;
11122   if (model == TLSModel::LocalExec) {
11123     OperandFlags = is64Bit ? X86II::MO_TPOFF : X86II::MO_NTPOFF;
11124   } else if (model == TLSModel::InitialExec) {
11125     if (is64Bit) {
11126       OperandFlags = X86II::MO_GOTTPOFF;
11127       WrapperKind = X86ISD::WrapperRIP;
11128     } else {
11129       OperandFlags = isPIC ? X86II::MO_GOTNTPOFF : X86II::MO_INDNTPOFF;
11130     }
11131   } else {
11132     llvm_unreachable("Unexpected model");
11133   }
11134
11135   // emit "addl x@ntpoff,%eax" (local exec)
11136   // or "addl x@indntpoff,%eax" (initial exec)
11137   // or "addl x@gotntpoff(%ebx) ,%eax" (initial exec, 32-bit pic)
11138   SDValue TGA =
11139       DAG.getTargetGlobalAddress(GA->getGlobal(), dl, GA->getValueType(0),
11140                                  GA->getOffset(), OperandFlags);
11141   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
11142
11143   if (model == TLSModel::InitialExec) {
11144     if (isPIC && !is64Bit) {
11145       Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
11146                            DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT),
11147                            Offset);
11148     }
11149
11150     Offset = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Offset,
11151                          MachinePointerInfo::getGOT(), false, false, false, 0);
11152   }
11153
11154   // The address of the thread local variable is the add of the thread
11155   // pointer with the offset of the variable.
11156   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
11157 }
11158
11159 SDValue
11160 X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
11161
11162   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
11163   const GlobalValue *GV = GA->getGlobal();
11164
11165   if (Subtarget->isTargetELF()) {
11166     TLSModel::Model model = DAG.getTarget().getTLSModel(GV);
11167
11168     switch (model) {
11169       case TLSModel::GeneralDynamic:
11170         if (Subtarget->is64Bit())
11171           return LowerToTLSGeneralDynamicModel64(GA, DAG, getPointerTy());
11172         return LowerToTLSGeneralDynamicModel32(GA, DAG, getPointerTy());
11173       case TLSModel::LocalDynamic:
11174         return LowerToTLSLocalDynamicModel(GA, DAG, getPointerTy(),
11175                                            Subtarget->is64Bit());
11176       case TLSModel::InitialExec:
11177       case TLSModel::LocalExec:
11178         return LowerToTLSExecModel(
11179             GA, DAG, getPointerTy(), model, Subtarget->is64Bit(),
11180             DAG.getTarget().getRelocationModel() == Reloc::PIC_);
11181     }
11182     llvm_unreachable("Unknown TLS model.");
11183   }
11184
11185   if (Subtarget->isTargetDarwin()) {
11186     // Darwin only has one model of TLS.  Lower to that.
11187     unsigned char OpFlag = 0;
11188     unsigned WrapperKind = Subtarget->isPICStyleRIPRel() ?
11189                            X86ISD::WrapperRIP : X86ISD::Wrapper;
11190
11191     // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
11192     // global base reg.
11193     bool PIC32 = (DAG.getTarget().getRelocationModel() == Reloc::PIC_) &&
11194                  !Subtarget->is64Bit();
11195     if (PIC32)
11196       OpFlag = X86II::MO_TLVP_PIC_BASE;
11197     else
11198       OpFlag = X86II::MO_TLVP;
11199     SDLoc DL(Op);
11200     SDValue Result = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
11201                                                 GA->getValueType(0),
11202                                                 GA->getOffset(), OpFlag);
11203     SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
11204
11205     // With PIC32, the address is actually $g + Offset.
11206     if (PIC32)
11207       Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
11208                            DAG.getNode(X86ISD::GlobalBaseReg,
11209                                        SDLoc(), getPointerTy()),
11210                            Offset);
11211
11212     // Lowering the machine isd will make sure everything is in the right
11213     // location.
11214     SDValue Chain = DAG.getEntryNode();
11215     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
11216     SDValue Args[] = { Chain, Offset };
11217     Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args);
11218
11219     // TLSCALL will be codegen'ed as call. Inform MFI that function has calls.
11220     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
11221     MFI->setAdjustsStack(true);
11222
11223     // And our return value (tls address) is in the standard call return value
11224     // location.
11225     unsigned Reg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
11226     return DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy(),
11227                               Chain.getValue(1));
11228   }
11229
11230   if (Subtarget->isTargetKnownWindowsMSVC() ||
11231       Subtarget->isTargetWindowsGNU()) {
11232     // Just use the implicit TLS architecture
11233     // Need to generate someting similar to:
11234     //   mov     rdx, qword [gs:abs 58H]; Load pointer to ThreadLocalStorage
11235     //                                  ; from TEB
11236     //   mov     ecx, dword [rel _tls_index]: Load index (from C runtime)
11237     //   mov     rcx, qword [rdx+rcx*8]
11238     //   mov     eax, .tls$:tlsvar
11239     //   [rax+rcx] contains the address
11240     // Windows 64bit: gs:0x58
11241     // Windows 32bit: fs:__tls_array
11242
11243     SDLoc dl(GA);
11244     SDValue Chain = DAG.getEntryNode();
11245
11246     // Get the Thread Pointer, which is %fs:__tls_array (32-bit) or
11247     // %gs:0x58 (64-bit). On MinGW, __tls_array is not available, so directly
11248     // use its literal value of 0x2C.
11249     Value *Ptr = Constant::getNullValue(Subtarget->is64Bit()
11250                                         ? Type::getInt8PtrTy(*DAG.getContext(),
11251                                                              256)
11252                                         : Type::getInt32PtrTy(*DAG.getContext(),
11253                                                               257));
11254
11255     SDValue TlsArray =
11256         Subtarget->is64Bit()
11257             ? DAG.getIntPtrConstant(0x58)
11258             : (Subtarget->isTargetWindowsGNU()
11259                    ? DAG.getIntPtrConstant(0x2C)
11260                    : DAG.getExternalSymbol("_tls_array", getPointerTy()));
11261
11262     SDValue ThreadPointer =
11263         DAG.getLoad(getPointerTy(), dl, Chain, TlsArray,
11264                     MachinePointerInfo(Ptr), false, false, false, 0);
11265
11266     // Load the _tls_index variable
11267     SDValue IDX = DAG.getExternalSymbol("_tls_index", getPointerTy());
11268     if (Subtarget->is64Bit())
11269       IDX = DAG.getExtLoad(ISD::ZEXTLOAD, dl, getPointerTy(), Chain,
11270                            IDX, MachinePointerInfo(), MVT::i32,
11271                            false, false, false, 0);
11272     else
11273       IDX = DAG.getLoad(getPointerTy(), dl, Chain, IDX, MachinePointerInfo(),
11274                         false, false, false, 0);
11275
11276     SDValue Scale = DAG.getConstant(Log2_64_Ceil(TD->getPointerSize()),
11277                                     getPointerTy());
11278     IDX = DAG.getNode(ISD::SHL, dl, getPointerTy(), IDX, Scale);
11279
11280     SDValue res = DAG.getNode(ISD::ADD, dl, getPointerTy(), ThreadPointer, IDX);
11281     res = DAG.getLoad(getPointerTy(), dl, Chain, res, MachinePointerInfo(),
11282                       false, false, false, 0);
11283
11284     // Get the offset of start of .tls section
11285     SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
11286                                              GA->getValueType(0),
11287                                              GA->getOffset(), X86II::MO_SECREL);
11288     SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), TGA);
11289
11290     // The address of the thread local variable is the add of the thread
11291     // pointer with the offset of the variable.
11292     return DAG.getNode(ISD::ADD, dl, getPointerTy(), res, Offset);
11293   }
11294
11295   llvm_unreachable("TLS not implemented for this target.");
11296 }
11297
11298 /// LowerShiftParts - Lower SRA_PARTS and friends, which return two i32 values
11299 /// and take a 2 x i32 value to shift plus a shift amount.
11300 static SDValue LowerShiftParts(SDValue Op, SelectionDAG &DAG) {
11301   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
11302   MVT VT = Op.getSimpleValueType();
11303   unsigned VTBits = VT.getSizeInBits();
11304   SDLoc dl(Op);
11305   bool isSRA = Op.getOpcode() == ISD::SRA_PARTS;
11306   SDValue ShOpLo = Op.getOperand(0);
11307   SDValue ShOpHi = Op.getOperand(1);
11308   SDValue ShAmt  = Op.getOperand(2);
11309   // X86ISD::SHLD and X86ISD::SHRD have defined overflow behavior but the
11310   // generic ISD nodes haven't. Insert an AND to be safe, it's optimized away
11311   // during isel.
11312   SDValue SafeShAmt = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
11313                                   DAG.getConstant(VTBits - 1, MVT::i8));
11314   SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
11315                                      DAG.getConstant(VTBits - 1, MVT::i8))
11316                        : DAG.getConstant(0, VT);
11317
11318   SDValue Tmp2, Tmp3;
11319   if (Op.getOpcode() == ISD::SHL_PARTS) {
11320     Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
11321     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, SafeShAmt);
11322   } else {
11323     Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
11324     Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, SafeShAmt);
11325   }
11326
11327   // If the shift amount is larger or equal than the width of a part we can't
11328   // rely on the results of shld/shrd. Insert a test and select the appropriate
11329   // values for large shift amounts.
11330   SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
11331                                 DAG.getConstant(VTBits, MVT::i8));
11332   SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
11333                              AndNode, DAG.getConstant(0, MVT::i8));
11334
11335   SDValue Hi, Lo;
11336   SDValue CC = DAG.getConstant(X86::COND_NE, MVT::i8);
11337   SDValue Ops0[4] = { Tmp2, Tmp3, CC, Cond };
11338   SDValue Ops1[4] = { Tmp3, Tmp1, CC, Cond };
11339
11340   if (Op.getOpcode() == ISD::SHL_PARTS) {
11341     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
11342     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
11343   } else {
11344     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
11345     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
11346   }
11347
11348   SDValue Ops[2] = { Lo, Hi };
11349   return DAG.getMergeValues(Ops, dl);
11350 }
11351
11352 SDValue X86TargetLowering::LowerSINT_TO_FP(SDValue Op,
11353                                            SelectionDAG &DAG) const {
11354   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
11355   SDLoc dl(Op);
11356
11357   if (SrcVT.isVector()) {
11358     if (SrcVT.getVectorElementType() == MVT::i1) {
11359       MVT IntegerVT = MVT::getVectorVT(MVT::i32, SrcVT.getVectorNumElements());
11360       return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
11361                          DAG.getNode(ISD::SIGN_EXTEND, dl, IntegerVT,
11362                                      Op.getOperand(0)));
11363     }
11364     return SDValue();
11365   }
11366
11367   assert(SrcVT <= MVT::i64 && SrcVT >= MVT::i16 &&
11368          "Unknown SINT_TO_FP to lower!");
11369
11370   // These are really Legal; return the operand so the caller accepts it as
11371   // Legal.
11372   if (SrcVT == MVT::i32 && isScalarFPTypeInSSEReg(Op.getValueType()))
11373     return Op;
11374   if (SrcVT == MVT::i64 && isScalarFPTypeInSSEReg(Op.getValueType()) &&
11375       Subtarget->is64Bit()) {
11376     return Op;
11377   }
11378
11379   unsigned Size = SrcVT.getSizeInBits()/8;
11380   MachineFunction &MF = DAG.getMachineFunction();
11381   int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size, false);
11382   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
11383   SDValue Chain = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
11384                                StackSlot,
11385                                MachinePointerInfo::getFixedStack(SSFI),
11386                                false, false, 0);
11387   return BuildFILD(Op, SrcVT, Chain, StackSlot, DAG);
11388 }
11389
11390 SDValue X86TargetLowering::BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain,
11391                                      SDValue StackSlot,
11392                                      SelectionDAG &DAG) const {
11393   // Build the FILD
11394   SDLoc DL(Op);
11395   SDVTList Tys;
11396   bool useSSE = isScalarFPTypeInSSEReg(Op.getValueType());
11397   if (useSSE)
11398     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Glue);
11399   else
11400     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
11401
11402   unsigned ByteSize = SrcVT.getSizeInBits()/8;
11403
11404   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(StackSlot);
11405   MachineMemOperand *MMO;
11406   if (FI) {
11407     int SSFI = FI->getIndex();
11408     MMO =
11409       DAG.getMachineFunction()
11410       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
11411                             MachineMemOperand::MOLoad, ByteSize, ByteSize);
11412   } else {
11413     MMO = cast<LoadSDNode>(StackSlot)->getMemOperand();
11414     StackSlot = StackSlot.getOperand(1);
11415   }
11416   SDValue Ops[] = { Chain, StackSlot, DAG.getValueType(SrcVT) };
11417   SDValue Result = DAG.getMemIntrinsicNode(useSSE ? X86ISD::FILD_FLAG :
11418                                            X86ISD::FILD, DL,
11419                                            Tys, Ops, SrcVT, MMO);
11420
11421   if (useSSE) {
11422     Chain = Result.getValue(1);
11423     SDValue InFlag = Result.getValue(2);
11424
11425     // FIXME: Currently the FST is flagged to the FILD_FLAG. This
11426     // shouldn't be necessary except that RFP cannot be live across
11427     // multiple blocks. When stackifier is fixed, they can be uncoupled.
11428     MachineFunction &MF = DAG.getMachineFunction();
11429     unsigned SSFISize = Op.getValueType().getSizeInBits()/8;
11430     int SSFI = MF.getFrameInfo()->CreateStackObject(SSFISize, SSFISize, false);
11431     SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
11432     Tys = DAG.getVTList(MVT::Other);
11433     SDValue Ops[] = {
11434       Chain, Result, StackSlot, DAG.getValueType(Op.getValueType()), InFlag
11435     };
11436     MachineMemOperand *MMO =
11437       DAG.getMachineFunction()
11438       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
11439                             MachineMemOperand::MOStore, SSFISize, SSFISize);
11440
11441     Chain = DAG.getMemIntrinsicNode(X86ISD::FST, DL, Tys,
11442                                     Ops, Op.getValueType(), MMO);
11443     Result = DAG.getLoad(Op.getValueType(), DL, Chain, StackSlot,
11444                          MachinePointerInfo::getFixedStack(SSFI),
11445                          false, false, false, 0);
11446   }
11447
11448   return Result;
11449 }
11450
11451 // LowerUINT_TO_FP_i64 - 64-bit unsigned integer to double expansion.
11452 SDValue X86TargetLowering::LowerUINT_TO_FP_i64(SDValue Op,
11453                                                SelectionDAG &DAG) const {
11454   // This algorithm is not obvious. Here it is what we're trying to output:
11455   /*
11456      movq       %rax,  %xmm0
11457      punpckldq  (c0),  %xmm0  // c0: (uint4){ 0x43300000U, 0x45300000U, 0U, 0U }
11458      subpd      (c1),  %xmm0  // c1: (double2){ 0x1.0p52, 0x1.0p52 * 0x1.0p32 }
11459      #ifdef __SSE3__
11460        haddpd   %xmm0, %xmm0
11461      #else
11462        pshufd   $0x4e, %xmm0, %xmm1
11463        addpd    %xmm1, %xmm0
11464      #endif
11465   */
11466
11467   SDLoc dl(Op);
11468   LLVMContext *Context = DAG.getContext();
11469
11470   // Build some magic constants.
11471   static const uint32_t CV0[] = { 0x43300000, 0x45300000, 0, 0 };
11472   Constant *C0 = ConstantDataVector::get(*Context, CV0);
11473   SDValue CPIdx0 = DAG.getConstantPool(C0, getPointerTy(), 16);
11474
11475   SmallVector<Constant*,2> CV1;
11476   CV1.push_back(
11477     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
11478                                       APInt(64, 0x4330000000000000ULL))));
11479   CV1.push_back(
11480     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
11481                                       APInt(64, 0x4530000000000000ULL))));
11482   Constant *C1 = ConstantVector::get(CV1);
11483   SDValue CPIdx1 = DAG.getConstantPool(C1, getPointerTy(), 16);
11484
11485   // Load the 64-bit value into an XMM register.
11486   SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
11487                             Op.getOperand(0));
11488   SDValue CLod0 = DAG.getLoad(MVT::v4i32, dl, DAG.getEntryNode(), CPIdx0,
11489                               MachinePointerInfo::getConstantPool(),
11490                               false, false, false, 16);
11491   SDValue Unpck1 = getUnpackl(DAG, dl, MVT::v4i32,
11492                               DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, XR1),
11493                               CLod0);
11494
11495   SDValue CLod1 = DAG.getLoad(MVT::v2f64, dl, CLod0.getValue(1), CPIdx1,
11496                               MachinePointerInfo::getConstantPool(),
11497                               false, false, false, 16);
11498   SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck1);
11499   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
11500   SDValue Result;
11501
11502   if (Subtarget->hasSSE3()) {
11503     // FIXME: The 'haddpd' instruction may be slower than 'movhlps + addsd'.
11504     Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
11505   } else {
11506     SDValue S2F = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Sub);
11507     SDValue Shuffle = getTargetShuffleNode(X86ISD::PSHUFD, dl, MVT::v4i32,
11508                                            S2F, 0x4E, DAG);
11509     Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64,
11510                          DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Shuffle),
11511                          Sub);
11512   }
11513
11514   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
11515                      DAG.getIntPtrConstant(0));
11516 }
11517
11518 // LowerUINT_TO_FP_i32 - 32-bit unsigned integer to float expansion.
11519 SDValue X86TargetLowering::LowerUINT_TO_FP_i32(SDValue Op,
11520                                                SelectionDAG &DAG) const {
11521   SDLoc dl(Op);
11522   // FP constant to bias correct the final result.
11523   SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
11524                                    MVT::f64);
11525
11526   // Load the 32-bit value into an XMM register.
11527   SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
11528                              Op.getOperand(0));
11529
11530   // Zero out the upper parts of the register.
11531   Load = getShuffleVectorZeroOrUndef(Load, 0, true, Subtarget, DAG);
11532
11533   Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
11534                      DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
11535                      DAG.getIntPtrConstant(0));
11536
11537   // Or the load with the bias.
11538   SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
11539                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
11540                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
11541                                                    MVT::v2f64, Load)),
11542                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
11543                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
11544                                                    MVT::v2f64, Bias)));
11545   Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
11546                    DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
11547                    DAG.getIntPtrConstant(0));
11548
11549   // Subtract the bias.
11550   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
11551
11552   // Handle final rounding.
11553   EVT DestVT = Op.getValueType();
11554
11555   if (DestVT.bitsLT(MVT::f64))
11556     return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
11557                        DAG.getIntPtrConstant(0));
11558   if (DestVT.bitsGT(MVT::f64))
11559     return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
11560
11561   // Handle final rounding.
11562   return Sub;
11563 }
11564
11565 static SDValue lowerUINT_TO_FP_vXi32(SDValue Op, SelectionDAG &DAG,
11566                                      const X86Subtarget &Subtarget) {
11567   // The algorithm is the following:
11568   // #ifdef __SSE4_1__
11569   //     uint4 lo = _mm_blend_epi16( v, (uint4) 0x4b000000, 0xaa);
11570   //     uint4 hi = _mm_blend_epi16( _mm_srli_epi32(v,16),
11571   //                                 (uint4) 0x53000000, 0xaa);
11572   // #else
11573   //     uint4 lo = (v & (uint4) 0xffff) | (uint4) 0x4b000000;
11574   //     uint4 hi = (v >> 16) | (uint4) 0x53000000;
11575   // #endif
11576   //     float4 fhi = (float4) hi - (0x1.0p39f + 0x1.0p23f);
11577   //     return (float4) lo + fhi;
11578
11579   SDLoc DL(Op);
11580   SDValue V = Op->getOperand(0);
11581   EVT VecIntVT = V.getValueType();
11582   bool Is128 = VecIntVT == MVT::v4i32;
11583   EVT VecFloatVT = Is128 ? MVT::v4f32 : MVT::v8f32;
11584   // If we convert to something else than the supported type, e.g., to v4f64,
11585   // abort early.
11586   if (VecFloatVT != Op->getValueType(0))
11587     return SDValue();
11588
11589   unsigned NumElts = VecIntVT.getVectorNumElements();
11590   assert((VecIntVT == MVT::v4i32 || VecIntVT == MVT::v8i32) &&
11591          "Unsupported custom type");
11592   assert(NumElts <= 8 && "The size of the constant array must be fixed");
11593
11594   // In the #idef/#else code, we have in common:
11595   // - The vector of constants:
11596   // -- 0x4b000000
11597   // -- 0x53000000
11598   // - A shift:
11599   // -- v >> 16
11600
11601   // Create the splat vector for 0x4b000000.
11602   SDValue CstLow = DAG.getConstant(0x4b000000, MVT::i32);
11603   SDValue CstLowArray[] = {CstLow, CstLow, CstLow, CstLow,
11604                            CstLow, CstLow, CstLow, CstLow};
11605   SDValue VecCstLow = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
11606                                   makeArrayRef(&CstLowArray[0], NumElts));
11607   // Create the splat vector for 0x53000000.
11608   SDValue CstHigh = DAG.getConstant(0x53000000, MVT::i32);
11609   SDValue CstHighArray[] = {CstHigh, CstHigh, CstHigh, CstHigh,
11610                             CstHigh, CstHigh, CstHigh, CstHigh};
11611   SDValue VecCstHigh = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
11612                                    makeArrayRef(&CstHighArray[0], NumElts));
11613
11614   // Create the right shift.
11615   SDValue CstShift = DAG.getConstant(16, MVT::i32);
11616   SDValue CstShiftArray[] = {CstShift, CstShift, CstShift, CstShift,
11617                              CstShift, CstShift, CstShift, CstShift};
11618   SDValue VecCstShift = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT,
11619                                     makeArrayRef(&CstShiftArray[0], NumElts));
11620   SDValue HighShift = DAG.getNode(ISD::SRL, DL, VecIntVT, V, VecCstShift);
11621
11622   SDValue Low, High;
11623   if (Subtarget.hasSSE41()) {
11624     EVT VecI16VT = Is128 ? MVT::v8i16 : MVT::v16i16;
11625     //     uint4 lo = _mm_blend_epi16( v, (uint4) 0x4b000000, 0xaa);
11626     SDValue VecCstLowBitcast =
11627         DAG.getNode(ISD::BITCAST, DL, VecI16VT, VecCstLow);
11628     SDValue VecBitcast = DAG.getNode(ISD::BITCAST, DL, VecI16VT, V);
11629     // Low will be bitcasted right away, so do not bother bitcasting back to its
11630     // original type.
11631     Low = DAG.getNode(X86ISD::BLENDI, DL, VecI16VT, VecBitcast,
11632                       VecCstLowBitcast, DAG.getConstant(0xaa, MVT::i32));
11633     //     uint4 hi = _mm_blend_epi16( _mm_srli_epi32(v,16),
11634     //                                 (uint4) 0x53000000, 0xaa);
11635     SDValue VecCstHighBitcast =
11636         DAG.getNode(ISD::BITCAST, DL, VecI16VT, VecCstHigh);
11637     SDValue VecShiftBitcast =
11638         DAG.getNode(ISD::BITCAST, DL, VecI16VT, HighShift);
11639     // High will be bitcasted right away, so do not bother bitcasting back to
11640     // its original type.
11641     High = DAG.getNode(X86ISD::BLENDI, DL, VecI16VT, VecShiftBitcast,
11642                        VecCstHighBitcast, DAG.getConstant(0xaa, MVT::i32));
11643   } else {
11644     SDValue CstMask = DAG.getConstant(0xffff, MVT::i32);
11645     SDValue VecCstMask = DAG.getNode(ISD::BUILD_VECTOR, DL, VecIntVT, CstMask,
11646                                      CstMask, CstMask, CstMask);
11647     //     uint4 lo = (v & (uint4) 0xffff) | (uint4) 0x4b000000;
11648     SDValue LowAnd = DAG.getNode(ISD::AND, DL, VecIntVT, V, VecCstMask);
11649     Low = DAG.getNode(ISD::OR, DL, VecIntVT, LowAnd, VecCstLow);
11650
11651     //     uint4 hi = (v >> 16) | (uint4) 0x53000000;
11652     High = DAG.getNode(ISD::OR, DL, VecIntVT, HighShift, VecCstHigh);
11653   }
11654
11655   // Create the vector constant for -(0x1.0p39f + 0x1.0p23f).
11656   SDValue CstFAdd = DAG.getConstantFP(
11657       APFloat(APFloat::IEEEsingle, APInt(32, 0xD3000080)), MVT::f32);
11658   SDValue CstFAddArray[] = {CstFAdd, CstFAdd, CstFAdd, CstFAdd,
11659                             CstFAdd, CstFAdd, CstFAdd, CstFAdd};
11660   SDValue VecCstFAdd = DAG.getNode(ISD::BUILD_VECTOR, DL, VecFloatVT,
11661                                    makeArrayRef(&CstFAddArray[0], NumElts));
11662
11663   //     float4 fhi = (float4) hi - (0x1.0p39f + 0x1.0p23f);
11664   SDValue HighBitcast = DAG.getNode(ISD::BITCAST, DL, VecFloatVT, High);
11665   SDValue FHigh =
11666       DAG.getNode(ISD::FADD, DL, VecFloatVT, HighBitcast, VecCstFAdd);
11667   //     return (float4) lo + fhi;
11668   SDValue LowBitcast = DAG.getNode(ISD::BITCAST, DL, VecFloatVT, Low);
11669   return DAG.getNode(ISD::FADD, DL, VecFloatVT, LowBitcast, FHigh);
11670 }
11671
11672 SDValue X86TargetLowering::lowerUINT_TO_FP_vec(SDValue Op,
11673                                                SelectionDAG &DAG) const {
11674   SDValue N0 = Op.getOperand(0);
11675   MVT SVT = N0.getSimpleValueType();
11676   SDLoc dl(Op);
11677
11678   switch (SVT.SimpleTy) {
11679   default:
11680     llvm_unreachable("Custom UINT_TO_FP is not supported!");
11681   case MVT::v4i8:
11682   case MVT::v4i16:
11683   case MVT::v8i8:
11684   case MVT::v8i16: {
11685     MVT NVT = MVT::getVectorVT(MVT::i32, SVT.getVectorNumElements());
11686     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
11687                        DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N0));
11688   }
11689   case MVT::v4i32:
11690   case MVT::v8i32:
11691     return lowerUINT_TO_FP_vXi32(Op, DAG, *Subtarget);
11692   }
11693   llvm_unreachable(nullptr);
11694 }
11695
11696 SDValue X86TargetLowering::LowerUINT_TO_FP(SDValue Op,
11697                                            SelectionDAG &DAG) const {
11698   SDValue N0 = Op.getOperand(0);
11699   SDLoc dl(Op);
11700
11701   if (Op.getValueType().isVector())
11702     return lowerUINT_TO_FP_vec(Op, DAG);
11703
11704   // Since UINT_TO_FP is legal (it's marked custom), dag combiner won't
11705   // optimize it to a SINT_TO_FP when the sign bit is known zero. Perform
11706   // the optimization here.
11707   if (DAG.SignBitIsZero(N0))
11708     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
11709
11710   MVT SrcVT = N0.getSimpleValueType();
11711   MVT DstVT = Op.getSimpleValueType();
11712   if (SrcVT == MVT::i64 && DstVT == MVT::f64 && X86ScalarSSEf64)
11713     return LowerUINT_TO_FP_i64(Op, DAG);
11714   if (SrcVT == MVT::i32 && X86ScalarSSEf64)
11715     return LowerUINT_TO_FP_i32(Op, DAG);
11716   if (Subtarget->is64Bit() && SrcVT == MVT::i64 && DstVT == MVT::f32)
11717     return SDValue();
11718
11719   // Make a 64-bit buffer, and use it to build an FILD.
11720   SDValue StackSlot = DAG.CreateStackTemporary(MVT::i64);
11721   if (SrcVT == MVT::i32) {
11722     SDValue WordOff = DAG.getConstant(4, getPointerTy());
11723     SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
11724                                      getPointerTy(), StackSlot, WordOff);
11725     SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
11726                                   StackSlot, MachinePointerInfo(),
11727                                   false, false, 0);
11728     SDValue Store2 = DAG.getStore(Store1, dl, DAG.getConstant(0, MVT::i32),
11729                                   OffsetSlot, MachinePointerInfo(),
11730                                   false, false, 0);
11731     SDValue Fild = BuildFILD(Op, MVT::i64, Store2, StackSlot, DAG);
11732     return Fild;
11733   }
11734
11735   assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
11736   SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
11737                                StackSlot, MachinePointerInfo(),
11738                                false, false, 0);
11739   // For i64 source, we need to add the appropriate power of 2 if the input
11740   // was negative.  This is the same as the optimization in
11741   // DAGTypeLegalizer::ExpandIntOp_UNIT_TO_FP, and for it to be safe here,
11742   // we must be careful to do the computation in x87 extended precision, not
11743   // in SSE. (The generic code can't know it's OK to do this, or how to.)
11744   int SSFI = cast<FrameIndexSDNode>(StackSlot)->getIndex();
11745   MachineMemOperand *MMO =
11746     DAG.getMachineFunction()
11747     .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
11748                           MachineMemOperand::MOLoad, 8, 8);
11749
11750   SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other);
11751   SDValue Ops[] = { Store, StackSlot, DAG.getValueType(MVT::i64) };
11752   SDValue Fild = DAG.getMemIntrinsicNode(X86ISD::FILD, dl, Tys, Ops,
11753                                          MVT::i64, MMO);
11754
11755   APInt FF(32, 0x5F800000ULL);
11756
11757   // Check whether the sign bit is set.
11758   SDValue SignSet = DAG.getSetCC(dl,
11759                                  getSetCCResultType(*DAG.getContext(), MVT::i64),
11760                                  Op.getOperand(0), DAG.getConstant(0, MVT::i64),
11761                                  ISD::SETLT);
11762
11763   // Build a 64 bit pair (0, FF) in the constant pool, with FF in the lo bits.
11764   SDValue FudgePtr = DAG.getConstantPool(
11765                              ConstantInt::get(*DAG.getContext(), FF.zext(64)),
11766                                          getPointerTy());
11767
11768   // Get a pointer to FF if the sign bit was set, or to 0 otherwise.
11769   SDValue Zero = DAG.getIntPtrConstant(0);
11770   SDValue Four = DAG.getIntPtrConstant(4);
11771   SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
11772                                Zero, Four);
11773   FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
11774
11775   // Load the value out, extending it from f32 to f80.
11776   // FIXME: Avoid the extend by constructing the right constant pool?
11777   SDValue Fudge = DAG.getExtLoad(ISD::EXTLOAD, dl, MVT::f80, DAG.getEntryNode(),
11778                                  FudgePtr, MachinePointerInfo::getConstantPool(),
11779                                  MVT::f32, false, false, false, 4);
11780   // Extend everything to 80 bits to force it to be done on x87.
11781   SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
11782   return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
11783 }
11784
11785 std::pair<SDValue,SDValue>
11786 X86TargetLowering:: FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG,
11787                                     bool IsSigned, bool IsReplace) const {
11788   SDLoc DL(Op);
11789
11790   EVT DstTy = Op.getValueType();
11791
11792   if (!IsSigned && !isIntegerTypeFTOL(DstTy)) {
11793     assert(DstTy == MVT::i32 && "Unexpected FP_TO_UINT");
11794     DstTy = MVT::i64;
11795   }
11796
11797   assert(DstTy.getSimpleVT() <= MVT::i64 &&
11798          DstTy.getSimpleVT() >= MVT::i16 &&
11799          "Unknown FP_TO_INT to lower!");
11800
11801   // These are really Legal.
11802   if (DstTy == MVT::i32 &&
11803       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
11804     return std::make_pair(SDValue(), SDValue());
11805   if (Subtarget->is64Bit() &&
11806       DstTy == MVT::i64 &&
11807       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
11808     return std::make_pair(SDValue(), SDValue());
11809
11810   // We lower FP->int64 either into FISTP64 followed by a load from a temporary
11811   // stack slot, or into the FTOL runtime function.
11812   MachineFunction &MF = DAG.getMachineFunction();
11813   unsigned MemSize = DstTy.getSizeInBits()/8;
11814   int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
11815   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
11816
11817   unsigned Opc;
11818   if (!IsSigned && isIntegerTypeFTOL(DstTy))
11819     Opc = X86ISD::WIN_FTOL;
11820   else
11821     switch (DstTy.getSimpleVT().SimpleTy) {
11822     default: llvm_unreachable("Invalid FP_TO_SINT to lower!");
11823     case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
11824     case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
11825     case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
11826     }
11827
11828   SDValue Chain = DAG.getEntryNode();
11829   SDValue Value = Op.getOperand(0);
11830   EVT TheVT = Op.getOperand(0).getValueType();
11831   // FIXME This causes a redundant load/store if the SSE-class value is already
11832   // in memory, such as if it is on the callstack.
11833   if (isScalarFPTypeInSSEReg(TheVT)) {
11834     assert(DstTy == MVT::i64 && "Invalid FP_TO_SINT to lower!");
11835     Chain = DAG.getStore(Chain, DL, Value, StackSlot,
11836                          MachinePointerInfo::getFixedStack(SSFI),
11837                          false, false, 0);
11838     SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other);
11839     SDValue Ops[] = {
11840       Chain, StackSlot, DAG.getValueType(TheVT)
11841     };
11842
11843     MachineMemOperand *MMO =
11844       MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
11845                               MachineMemOperand::MOLoad, MemSize, MemSize);
11846     Value = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops, DstTy, MMO);
11847     Chain = Value.getValue(1);
11848     SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
11849     StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
11850   }
11851
11852   MachineMemOperand *MMO =
11853     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
11854                             MachineMemOperand::MOStore, MemSize, MemSize);
11855
11856   if (Opc != X86ISD::WIN_FTOL) {
11857     // Build the FP_TO_INT*_IN_MEM
11858     SDValue Ops[] = { Chain, Value, StackSlot };
11859     SDValue FIST = DAG.getMemIntrinsicNode(Opc, DL, DAG.getVTList(MVT::Other),
11860                                            Ops, DstTy, MMO);
11861     return std::make_pair(FIST, StackSlot);
11862   } else {
11863     SDValue ftol = DAG.getNode(X86ISD::WIN_FTOL, DL,
11864       DAG.getVTList(MVT::Other, MVT::Glue),
11865       Chain, Value);
11866     SDValue eax = DAG.getCopyFromReg(ftol, DL, X86::EAX,
11867       MVT::i32, ftol.getValue(1));
11868     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), DL, X86::EDX,
11869       MVT::i32, eax.getValue(2));
11870     SDValue Ops[] = { eax, edx };
11871     SDValue pair = IsReplace
11872       ? DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops)
11873       : DAG.getMergeValues(Ops, DL);
11874     return std::make_pair(pair, SDValue());
11875   }
11876 }
11877
11878 static SDValue LowerAVXExtend(SDValue Op, SelectionDAG &DAG,
11879                               const X86Subtarget *Subtarget) {
11880   MVT VT = Op->getSimpleValueType(0);
11881   SDValue In = Op->getOperand(0);
11882   MVT InVT = In.getSimpleValueType();
11883   SDLoc dl(Op);
11884
11885   // Optimize vectors in AVX mode:
11886   //
11887   //   v8i16 -> v8i32
11888   //   Use vpunpcklwd for 4 lower elements  v8i16 -> v4i32.
11889   //   Use vpunpckhwd for 4 upper elements  v8i16 -> v4i32.
11890   //   Concat upper and lower parts.
11891   //
11892   //   v4i32 -> v4i64
11893   //   Use vpunpckldq for 4 lower elements  v4i32 -> v2i64.
11894   //   Use vpunpckhdq for 4 upper elements  v4i32 -> v2i64.
11895   //   Concat upper and lower parts.
11896   //
11897
11898   if (((VT != MVT::v16i16) || (InVT != MVT::v16i8)) &&
11899       ((VT != MVT::v8i32) || (InVT != MVT::v8i16)) &&
11900       ((VT != MVT::v4i64) || (InVT != MVT::v4i32)))
11901     return SDValue();
11902
11903   if (Subtarget->hasInt256())
11904     return DAG.getNode(X86ISD::VZEXT, dl, VT, In);
11905
11906   SDValue ZeroVec = getZeroVector(InVT, Subtarget, DAG, dl);
11907   SDValue Undef = DAG.getUNDEF(InVT);
11908   bool NeedZero = Op.getOpcode() == ISD::ZERO_EXTEND;
11909   SDValue OpLo = getUnpackl(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
11910   SDValue OpHi = getUnpackh(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
11911
11912   MVT HVT = MVT::getVectorVT(VT.getVectorElementType(),
11913                              VT.getVectorNumElements()/2);
11914
11915   OpLo = DAG.getNode(ISD::BITCAST, dl, HVT, OpLo);
11916   OpHi = DAG.getNode(ISD::BITCAST, dl, HVT, OpHi);
11917
11918   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
11919 }
11920
11921 static  SDValue LowerZERO_EXTEND_AVX512(SDValue Op,
11922                                         SelectionDAG &DAG) {
11923   MVT VT = Op->getSimpleValueType(0);
11924   SDValue In = Op->getOperand(0);
11925   MVT InVT = In.getSimpleValueType();
11926   SDLoc DL(Op);
11927   unsigned int NumElts = VT.getVectorNumElements();
11928   if (NumElts != 8 && NumElts != 16)
11929     return SDValue();
11930
11931   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1)
11932     return DAG.getNode(X86ISD::VZEXT, DL, VT, In);
11933
11934   EVT ExtVT = (NumElts == 8)? MVT::v8i64 : MVT::v16i32;
11935   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
11936   // Now we have only mask extension
11937   assert(InVT.getVectorElementType() == MVT::i1);
11938   SDValue Cst = DAG.getTargetConstant(1, ExtVT.getScalarType());
11939   const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
11940   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
11941   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
11942   SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
11943                            MachinePointerInfo::getConstantPool(),
11944                            false, false, false, Alignment);
11945
11946   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, DL, ExtVT, In, Ld);
11947   if (VT.is512BitVector())
11948     return Brcst;
11949   return DAG.getNode(X86ISD::VTRUNC, DL, VT, Brcst);
11950 }
11951
11952 static SDValue LowerANY_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
11953                                SelectionDAG &DAG) {
11954   if (Subtarget->hasFp256()) {
11955     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
11956     if (Res.getNode())
11957       return Res;
11958   }
11959
11960   return SDValue();
11961 }
11962
11963 static SDValue LowerZERO_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
11964                                 SelectionDAG &DAG) {
11965   SDLoc DL(Op);
11966   MVT VT = Op.getSimpleValueType();
11967   SDValue In = Op.getOperand(0);
11968   MVT SVT = In.getSimpleValueType();
11969
11970   if (VT.is512BitVector() || SVT.getVectorElementType() == MVT::i1)
11971     return LowerZERO_EXTEND_AVX512(Op, DAG);
11972
11973   if (Subtarget->hasFp256()) {
11974     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
11975     if (Res.getNode())
11976       return Res;
11977   }
11978
11979   assert(!VT.is256BitVector() || !SVT.is128BitVector() ||
11980          VT.getVectorNumElements() != SVT.getVectorNumElements());
11981   return SDValue();
11982 }
11983
11984 SDValue X86TargetLowering::LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const {
11985   SDLoc DL(Op);
11986   MVT VT = Op.getSimpleValueType();
11987   SDValue In = Op.getOperand(0);
11988   MVT InVT = In.getSimpleValueType();
11989
11990   if (VT == MVT::i1) {
11991     assert((InVT.isInteger() && (InVT.getSizeInBits() <= 64)) &&
11992            "Invalid scalar TRUNCATE operation");
11993     if (InVT.getSizeInBits() >= 32)
11994       return SDValue();
11995     In = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, In);
11996     return DAG.getNode(ISD::TRUNCATE, DL, VT, In);
11997   }
11998   assert(VT.getVectorNumElements() == InVT.getVectorNumElements() &&
11999          "Invalid TRUNCATE operation");
12000
12001   if (InVT.is512BitVector() || VT.getVectorElementType() == MVT::i1) {
12002     if (VT.getVectorElementType().getSizeInBits() >=8)
12003       return DAG.getNode(X86ISD::VTRUNC, DL, VT, In);
12004
12005     assert(VT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
12006     unsigned NumElts = InVT.getVectorNumElements();
12007     assert ((NumElts == 8 || NumElts == 16) && "Unexpected vector type");
12008     if (InVT.getSizeInBits() < 512) {
12009       MVT ExtVT = (NumElts == 16)? MVT::v16i32 : MVT::v8i64;
12010       In = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, In);
12011       InVT = ExtVT;
12012     }
12013
12014     SDValue Cst = DAG.getTargetConstant(1, InVT.getVectorElementType());
12015     const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
12016     SDValue CP = DAG.getConstantPool(C, getPointerTy());
12017     unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
12018     SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
12019                            MachinePointerInfo::getConstantPool(),
12020                            false, false, false, Alignment);
12021     SDValue OneV = DAG.getNode(X86ISD::VBROADCAST, DL, InVT, Ld);
12022     SDValue And = DAG.getNode(ISD::AND, DL, InVT, OneV, In);
12023     return DAG.getNode(X86ISD::TESTM, DL, VT, And, And);
12024   }
12025
12026   if ((VT == MVT::v4i32) && (InVT == MVT::v4i64)) {
12027     // On AVX2, v4i64 -> v4i32 becomes VPERMD.
12028     if (Subtarget->hasInt256()) {
12029       static const int ShufMask[] = {0, 2, 4, 6, -1, -1, -1, -1};
12030       In = DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, In);
12031       In = DAG.getVectorShuffle(MVT::v8i32, DL, In, DAG.getUNDEF(MVT::v8i32),
12032                                 ShufMask);
12033       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, In,
12034                          DAG.getIntPtrConstant(0));
12035     }
12036
12037     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
12038                                DAG.getIntPtrConstant(0));
12039     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
12040                                DAG.getIntPtrConstant(2));
12041     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
12042     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
12043     static const int ShufMask[] = {0, 2, 4, 6};
12044     return DAG.getVectorShuffle(VT, DL, OpLo, OpHi, ShufMask);
12045   }
12046
12047   if ((VT == MVT::v8i16) && (InVT == MVT::v8i32)) {
12048     // On AVX2, v8i32 -> v8i16 becomed PSHUFB.
12049     if (Subtarget->hasInt256()) {
12050       In = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, In);
12051
12052       SmallVector<SDValue,32> pshufbMask;
12053       for (unsigned i = 0; i < 2; ++i) {
12054         pshufbMask.push_back(DAG.getConstant(0x0, MVT::i8));
12055         pshufbMask.push_back(DAG.getConstant(0x1, MVT::i8));
12056         pshufbMask.push_back(DAG.getConstant(0x4, MVT::i8));
12057         pshufbMask.push_back(DAG.getConstant(0x5, MVT::i8));
12058         pshufbMask.push_back(DAG.getConstant(0x8, MVT::i8));
12059         pshufbMask.push_back(DAG.getConstant(0x9, MVT::i8));
12060         pshufbMask.push_back(DAG.getConstant(0xc, MVT::i8));
12061         pshufbMask.push_back(DAG.getConstant(0xd, MVT::i8));
12062         for (unsigned j = 0; j < 8; ++j)
12063           pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
12064       }
12065       SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, pshufbMask);
12066       In = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v32i8, In, BV);
12067       In = DAG.getNode(ISD::BITCAST, DL, MVT::v4i64, In);
12068
12069       static const int ShufMask[] = {0,  2,  -1,  -1};
12070       In = DAG.getVectorShuffle(MVT::v4i64, DL,  In, DAG.getUNDEF(MVT::v4i64),
12071                                 &ShufMask[0]);
12072       In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
12073                        DAG.getIntPtrConstant(0));
12074       return DAG.getNode(ISD::BITCAST, DL, VT, In);
12075     }
12076
12077     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
12078                                DAG.getIntPtrConstant(0));
12079
12080     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
12081                                DAG.getIntPtrConstant(4));
12082
12083     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpLo);
12084     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpHi);
12085
12086     // The PSHUFB mask:
12087     static const int ShufMask1[] = {0,  1,  4,  5,  8,  9, 12, 13,
12088                                    -1, -1, -1, -1, -1, -1, -1, -1};
12089
12090     SDValue Undef = DAG.getUNDEF(MVT::v16i8);
12091     OpLo = DAG.getVectorShuffle(MVT::v16i8, DL, OpLo, Undef, ShufMask1);
12092     OpHi = DAG.getVectorShuffle(MVT::v16i8, DL, OpHi, Undef, ShufMask1);
12093
12094     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
12095     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
12096
12097     // The MOVLHPS Mask:
12098     static const int ShufMask2[] = {0, 1, 4, 5};
12099     SDValue res = DAG.getVectorShuffle(MVT::v4i32, DL, OpLo, OpHi, ShufMask2);
12100     return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, res);
12101   }
12102
12103   // Handle truncation of V256 to V128 using shuffles.
12104   if (!VT.is128BitVector() || !InVT.is256BitVector())
12105     return SDValue();
12106
12107   assert(Subtarget->hasFp256() && "256-bit vector without AVX!");
12108
12109   unsigned NumElems = VT.getVectorNumElements();
12110   MVT NVT = MVT::getVectorVT(VT.getVectorElementType(), NumElems * 2);
12111
12112   SmallVector<int, 16> MaskVec(NumElems * 2, -1);
12113   // Prepare truncation shuffle mask
12114   for (unsigned i = 0; i != NumElems; ++i)
12115     MaskVec[i] = i * 2;
12116   SDValue V = DAG.getVectorShuffle(NVT, DL,
12117                                    DAG.getNode(ISD::BITCAST, DL, NVT, In),
12118                                    DAG.getUNDEF(NVT), &MaskVec[0]);
12119   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, V,
12120                      DAG.getIntPtrConstant(0));
12121 }
12122
12123 SDValue X86TargetLowering::LowerFP_TO_SINT(SDValue Op,
12124                                            SelectionDAG &DAG) const {
12125   assert(!Op.getSimpleValueType().isVector());
12126
12127   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
12128     /*IsSigned=*/ true, /*IsReplace=*/ false);
12129   SDValue FIST = Vals.first, StackSlot = Vals.second;
12130   // If FP_TO_INTHelper failed, the node is actually supposed to be Legal.
12131   if (!FIST.getNode()) return Op;
12132
12133   if (StackSlot.getNode())
12134     // Load the result.
12135     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
12136                        FIST, StackSlot, MachinePointerInfo(),
12137                        false, false, false, 0);
12138
12139   // The node is the result.
12140   return FIST;
12141 }
12142
12143 SDValue X86TargetLowering::LowerFP_TO_UINT(SDValue Op,
12144                                            SelectionDAG &DAG) const {
12145   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
12146     /*IsSigned=*/ false, /*IsReplace=*/ false);
12147   SDValue FIST = Vals.first, StackSlot = Vals.second;
12148   assert(FIST.getNode() && "Unexpected failure");
12149
12150   if (StackSlot.getNode())
12151     // Load the result.
12152     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
12153                        FIST, StackSlot, MachinePointerInfo(),
12154                        false, false, false, 0);
12155
12156   // The node is the result.
12157   return FIST;
12158 }
12159
12160 static SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) {
12161   SDLoc DL(Op);
12162   MVT VT = Op.getSimpleValueType();
12163   SDValue In = Op.getOperand(0);
12164   MVT SVT = In.getSimpleValueType();
12165
12166   assert(SVT == MVT::v2f32 && "Only customize MVT::v2f32 type legalization!");
12167
12168   return DAG.getNode(X86ISD::VFPEXT, DL, VT,
12169                      DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4f32,
12170                                  In, DAG.getUNDEF(SVT)));
12171 }
12172
12173 /// The only differences between FABS and FNEG are the mask and the logic op.
12174 /// FNEG also has a folding opportunity for FNEG(FABS(x)).
12175 static SDValue LowerFABSorFNEG(SDValue Op, SelectionDAG &DAG) {
12176   assert((Op.getOpcode() == ISD::FABS || Op.getOpcode() == ISD::FNEG) &&
12177          "Wrong opcode for lowering FABS or FNEG.");
12178
12179   bool IsFABS = (Op.getOpcode() == ISD::FABS);
12180
12181   // If this is a FABS and it has an FNEG user, bail out to fold the combination
12182   // into an FNABS. We'll lower the FABS after that if it is still in use.
12183   if (IsFABS)
12184     for (SDNode *User : Op->uses())
12185       if (User->getOpcode() == ISD::FNEG)
12186         return Op;
12187
12188   SDValue Op0 = Op.getOperand(0);
12189   bool IsFNABS = !IsFABS && (Op0.getOpcode() == ISD::FABS);
12190
12191   SDLoc dl(Op);
12192   MVT VT = Op.getSimpleValueType();
12193   // Assume scalar op for initialization; update for vector if needed.
12194   // Note that there are no scalar bitwise logical SSE/AVX instructions, so we
12195   // generate a 16-byte vector constant and logic op even for the scalar case.
12196   // Using a 16-byte mask allows folding the load of the mask with
12197   // the logic op, so it can save (~4 bytes) on code size.
12198   MVT EltVT = VT;
12199   unsigned NumElts = VT == MVT::f64 ? 2 : 4;
12200   // FIXME: Use function attribute "OptimizeForSize" and/or CodeGenOpt::Level to
12201   // decide if we should generate a 16-byte constant mask when we only need 4 or
12202   // 8 bytes for the scalar case.
12203   if (VT.isVector()) {
12204     EltVT = VT.getVectorElementType();
12205     NumElts = VT.getVectorNumElements();
12206   }
12207
12208   unsigned EltBits = EltVT.getSizeInBits();
12209   LLVMContext *Context = DAG.getContext();
12210   // For FABS, mask is 0x7f...; for FNEG, mask is 0x80...
12211   APInt MaskElt =
12212     IsFABS ? APInt::getSignedMaxValue(EltBits) : APInt::getSignBit(EltBits);
12213   Constant *C = ConstantInt::get(*Context, MaskElt);
12214   C = ConstantVector::getSplat(NumElts, C);
12215   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
12216   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy());
12217   unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment();
12218   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
12219                              MachinePointerInfo::getConstantPool(),
12220                              false, false, false, Alignment);
12221
12222   if (VT.isVector()) {
12223     // For a vector, cast operands to a vector type, perform the logic op,
12224     // and cast the result back to the original value type.
12225     MVT VecVT = MVT::getVectorVT(MVT::i64, VT.getSizeInBits() / 64);
12226     SDValue MaskCasted = DAG.getNode(ISD::BITCAST, dl, VecVT, Mask);
12227     SDValue Operand = IsFNABS ?
12228       DAG.getNode(ISD::BITCAST, dl, VecVT, Op0.getOperand(0)) :
12229       DAG.getNode(ISD::BITCAST, dl, VecVT, Op0);
12230     unsigned BitOp = IsFABS ? ISD::AND : IsFNABS ? ISD::OR : ISD::XOR;
12231     return DAG.getNode(ISD::BITCAST, dl, VT,
12232                        DAG.getNode(BitOp, dl, VecVT, Operand, MaskCasted));
12233   }
12234
12235   // If not vector, then scalar.
12236   unsigned BitOp = IsFABS ? X86ISD::FAND : IsFNABS ? X86ISD::FOR : X86ISD::FXOR;
12237   SDValue Operand = IsFNABS ? Op0.getOperand(0) : Op0;
12238   return DAG.getNode(BitOp, dl, VT, Operand, Mask);
12239 }
12240
12241 static SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) {
12242   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
12243   LLVMContext *Context = DAG.getContext();
12244   SDValue Op0 = Op.getOperand(0);
12245   SDValue Op1 = Op.getOperand(1);
12246   SDLoc dl(Op);
12247   MVT VT = Op.getSimpleValueType();
12248   MVT SrcVT = Op1.getSimpleValueType();
12249
12250   // If second operand is smaller, extend it first.
12251   if (SrcVT.bitsLT(VT)) {
12252     Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
12253     SrcVT = VT;
12254   }
12255   // And if it is bigger, shrink it first.
12256   if (SrcVT.bitsGT(VT)) {
12257     Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
12258     SrcVT = VT;
12259   }
12260
12261   // At this point the operands and the result should have the same
12262   // type, and that won't be f80 since that is not custom lowered.
12263
12264   const fltSemantics &Sem =
12265       VT == MVT::f64 ? APFloat::IEEEdouble : APFloat::IEEEsingle;
12266   const unsigned SizeInBits = VT.getSizeInBits();
12267
12268   SmallVector<Constant *, 4> CV(
12269       VT == MVT::f64 ? 2 : 4,
12270       ConstantFP::get(*Context, APFloat(Sem, APInt(SizeInBits, 0))));
12271
12272   // First, clear all bits but the sign bit from the second operand (sign).
12273   CV[0] = ConstantFP::get(*Context,
12274                           APFloat(Sem, APInt::getHighBitsSet(SizeInBits, 1)));
12275   Constant *C = ConstantVector::get(CV);
12276   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
12277   SDValue Mask1 = DAG.getLoad(SrcVT, dl, DAG.getEntryNode(), CPIdx,
12278                               MachinePointerInfo::getConstantPool(),
12279                               false, false, false, 16);
12280   SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
12281
12282   // Next, clear the sign bit from the first operand (magnitude).
12283   // If it's a constant, we can clear it here.
12284   if (ConstantFPSDNode *Op0CN = dyn_cast<ConstantFPSDNode>(Op0)) {
12285     APFloat APF = Op0CN->getValueAPF();
12286     // If the magnitude is a positive zero, the sign bit alone is enough.
12287     if (APF.isPosZero())
12288       return SignBit;
12289     APF.clearSign();
12290     CV[0] = ConstantFP::get(*Context, APF);
12291   } else {
12292     CV[0] = ConstantFP::get(
12293         *Context,
12294         APFloat(Sem, APInt::getLowBitsSet(SizeInBits, SizeInBits - 1)));
12295   }
12296   C = ConstantVector::get(CV);
12297   CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
12298   SDValue Val = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
12299                             MachinePointerInfo::getConstantPool(),
12300                             false, false, false, 16);
12301   // If the magnitude operand wasn't a constant, we need to AND out the sign.
12302   if (!isa<ConstantFPSDNode>(Op0))
12303     Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Val);
12304
12305   // OR the magnitude value with the sign bit.
12306   return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
12307 }
12308
12309 static SDValue LowerFGETSIGN(SDValue Op, SelectionDAG &DAG) {
12310   SDValue N0 = Op.getOperand(0);
12311   SDLoc dl(Op);
12312   MVT VT = Op.getSimpleValueType();
12313
12314   // Lower ISD::FGETSIGN to (AND (X86ISD::FGETSIGNx86 ...) 1).
12315   SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
12316                                   DAG.getConstant(1, VT));
12317   return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
12318 }
12319
12320 // Check whether an OR'd tree is PTEST-able.
12321 static SDValue LowerVectorAllZeroTest(SDValue Op, const X86Subtarget *Subtarget,
12322                                       SelectionDAG &DAG) {
12323   assert(Op.getOpcode() == ISD::OR && "Only check OR'd tree.");
12324
12325   if (!Subtarget->hasSSE41())
12326     return SDValue();
12327
12328   if (!Op->hasOneUse())
12329     return SDValue();
12330
12331   SDNode *N = Op.getNode();
12332   SDLoc DL(N);
12333
12334   SmallVector<SDValue, 8> Opnds;
12335   DenseMap<SDValue, unsigned> VecInMap;
12336   SmallVector<SDValue, 8> VecIns;
12337   EVT VT = MVT::Other;
12338
12339   // Recognize a special case where a vector is casted into wide integer to
12340   // test all 0s.
12341   Opnds.push_back(N->getOperand(0));
12342   Opnds.push_back(N->getOperand(1));
12343
12344   for (unsigned Slot = 0, e = Opnds.size(); Slot < e; ++Slot) {
12345     SmallVectorImpl<SDValue>::const_iterator I = Opnds.begin() + Slot;
12346     // BFS traverse all OR'd operands.
12347     if (I->getOpcode() == ISD::OR) {
12348       Opnds.push_back(I->getOperand(0));
12349       Opnds.push_back(I->getOperand(1));
12350       // Re-evaluate the number of nodes to be traversed.
12351       e += 2; // 2 more nodes (LHS and RHS) are pushed.
12352       continue;
12353     }
12354
12355     // Quit if a non-EXTRACT_VECTOR_ELT
12356     if (I->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
12357       return SDValue();
12358
12359     // Quit if without a constant index.
12360     SDValue Idx = I->getOperand(1);
12361     if (!isa<ConstantSDNode>(Idx))
12362       return SDValue();
12363
12364     SDValue ExtractedFromVec = I->getOperand(0);
12365     DenseMap<SDValue, unsigned>::iterator M = VecInMap.find(ExtractedFromVec);
12366     if (M == VecInMap.end()) {
12367       VT = ExtractedFromVec.getValueType();
12368       // Quit if not 128/256-bit vector.
12369       if (!VT.is128BitVector() && !VT.is256BitVector())
12370         return SDValue();
12371       // Quit if not the same type.
12372       if (VecInMap.begin() != VecInMap.end() &&
12373           VT != VecInMap.begin()->first.getValueType())
12374         return SDValue();
12375       M = VecInMap.insert(std::make_pair(ExtractedFromVec, 0)).first;
12376       VecIns.push_back(ExtractedFromVec);
12377     }
12378     M->second |= 1U << cast<ConstantSDNode>(Idx)->getZExtValue();
12379   }
12380
12381   assert((VT.is128BitVector() || VT.is256BitVector()) &&
12382          "Not extracted from 128-/256-bit vector.");
12383
12384   unsigned FullMask = (1U << VT.getVectorNumElements()) - 1U;
12385
12386   for (DenseMap<SDValue, unsigned>::const_iterator
12387         I = VecInMap.begin(), E = VecInMap.end(); I != E; ++I) {
12388     // Quit if not all elements are used.
12389     if (I->second != FullMask)
12390       return SDValue();
12391   }
12392
12393   EVT TestVT = VT.is128BitVector() ? MVT::v2i64 : MVT::v4i64;
12394
12395   // Cast all vectors into TestVT for PTEST.
12396   for (unsigned i = 0, e = VecIns.size(); i < e; ++i)
12397     VecIns[i] = DAG.getNode(ISD::BITCAST, DL, TestVT, VecIns[i]);
12398
12399   // If more than one full vectors are evaluated, OR them first before PTEST.
12400   for (unsigned Slot = 0, e = VecIns.size(); e - Slot > 1; Slot += 2, e += 1) {
12401     // Each iteration will OR 2 nodes and append the result until there is only
12402     // 1 node left, i.e. the final OR'd value of all vectors.
12403     SDValue LHS = VecIns[Slot];
12404     SDValue RHS = VecIns[Slot + 1];
12405     VecIns.push_back(DAG.getNode(ISD::OR, DL, TestVT, LHS, RHS));
12406   }
12407
12408   return DAG.getNode(X86ISD::PTEST, DL, MVT::i32,
12409                      VecIns.back(), VecIns.back());
12410 }
12411
12412 /// \brief return true if \c Op has a use that doesn't just read flags.
12413 static bool hasNonFlagsUse(SDValue Op) {
12414   for (SDNode::use_iterator UI = Op->use_begin(), UE = Op->use_end(); UI != UE;
12415        ++UI) {
12416     SDNode *User = *UI;
12417     unsigned UOpNo = UI.getOperandNo();
12418     if (User->getOpcode() == ISD::TRUNCATE && User->hasOneUse()) {
12419       // Look pass truncate.
12420       UOpNo = User->use_begin().getOperandNo();
12421       User = *User->use_begin();
12422     }
12423
12424     if (User->getOpcode() != ISD::BRCOND && User->getOpcode() != ISD::SETCC &&
12425         !(User->getOpcode() == ISD::SELECT && UOpNo == 0))
12426       return true;
12427   }
12428   return false;
12429 }
12430
12431 /// Emit nodes that will be selected as "test Op0,Op0", or something
12432 /// equivalent.
12433 SDValue X86TargetLowering::EmitTest(SDValue Op, unsigned X86CC, SDLoc dl,
12434                                     SelectionDAG &DAG) const {
12435   if (Op.getValueType() == MVT::i1) {
12436     SDValue ExtOp = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i8, Op);
12437     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, ExtOp,
12438                        DAG.getConstant(0, MVT::i8));
12439   }
12440   // CF and OF aren't always set the way we want. Determine which
12441   // of these we need.
12442   bool NeedCF = false;
12443   bool NeedOF = false;
12444   switch (X86CC) {
12445   default: break;
12446   case X86::COND_A: case X86::COND_AE:
12447   case X86::COND_B: case X86::COND_BE:
12448     NeedCF = true;
12449     break;
12450   case X86::COND_G: case X86::COND_GE:
12451   case X86::COND_L: case X86::COND_LE:
12452   case X86::COND_O: case X86::COND_NO: {
12453     // Check if we really need to set the
12454     // Overflow flag. If NoSignedWrap is present
12455     // that is not actually needed.
12456     switch (Op->getOpcode()) {
12457     case ISD::ADD:
12458     case ISD::SUB:
12459     case ISD::MUL:
12460     case ISD::SHL: {
12461       const BinaryWithFlagsSDNode *BinNode =
12462           cast<BinaryWithFlagsSDNode>(Op.getNode());
12463       if (BinNode->hasNoSignedWrap())
12464         break;
12465     }
12466     default:
12467       NeedOF = true;
12468       break;
12469     }
12470     break;
12471   }
12472   }
12473   // See if we can use the EFLAGS value from the operand instead of
12474   // doing a separate TEST. TEST always sets OF and CF to 0, so unless
12475   // we prove that the arithmetic won't overflow, we can't use OF or CF.
12476   if (Op.getResNo() != 0 || NeedOF || NeedCF) {
12477     // Emit a CMP with 0, which is the TEST pattern.
12478     //if (Op.getValueType() == MVT::i1)
12479     //  return DAG.getNode(X86ISD::CMP, dl, MVT::i1, Op,
12480     //                     DAG.getConstant(0, MVT::i1));
12481     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
12482                        DAG.getConstant(0, Op.getValueType()));
12483   }
12484   unsigned Opcode = 0;
12485   unsigned NumOperands = 0;
12486
12487   // Truncate operations may prevent the merge of the SETCC instruction
12488   // and the arithmetic instruction before it. Attempt to truncate the operands
12489   // of the arithmetic instruction and use a reduced bit-width instruction.
12490   bool NeedTruncation = false;
12491   SDValue ArithOp = Op;
12492   if (Op->getOpcode() == ISD::TRUNCATE && Op->hasOneUse()) {
12493     SDValue Arith = Op->getOperand(0);
12494     // Both the trunc and the arithmetic op need to have one user each.
12495     if (Arith->hasOneUse())
12496       switch (Arith.getOpcode()) {
12497         default: break;
12498         case ISD::ADD:
12499         case ISD::SUB:
12500         case ISD::AND:
12501         case ISD::OR:
12502         case ISD::XOR: {
12503           NeedTruncation = true;
12504           ArithOp = Arith;
12505         }
12506       }
12507   }
12508
12509   // NOTICE: In the code below we use ArithOp to hold the arithmetic operation
12510   // which may be the result of a CAST.  We use the variable 'Op', which is the
12511   // non-casted variable when we check for possible users.
12512   switch (ArithOp.getOpcode()) {
12513   case ISD::ADD:
12514     // Due to an isel shortcoming, be conservative if this add is likely to be
12515     // selected as part of a load-modify-store instruction. When the root node
12516     // in a match is a store, isel doesn't know how to remap non-chain non-flag
12517     // uses of other nodes in the match, such as the ADD in this case. This
12518     // leads to the ADD being left around and reselected, with the result being
12519     // two adds in the output.  Alas, even if none our users are stores, that
12520     // doesn't prove we're O.K.  Ergo, if we have any parents that aren't
12521     // CopyToReg or SETCC, eschew INC/DEC.  A better fix seems to require
12522     // climbing the DAG back to the root, and it doesn't seem to be worth the
12523     // effort.
12524     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
12525          UE = Op.getNode()->use_end(); UI != UE; ++UI)
12526       if (UI->getOpcode() != ISD::CopyToReg &&
12527           UI->getOpcode() != ISD::SETCC &&
12528           UI->getOpcode() != ISD::STORE)
12529         goto default_case;
12530
12531     if (ConstantSDNode *C =
12532         dyn_cast<ConstantSDNode>(ArithOp.getNode()->getOperand(1))) {
12533       // An add of one will be selected as an INC.
12534       if (C->getAPIntValue() == 1 && !Subtarget->slowIncDec()) {
12535         Opcode = X86ISD::INC;
12536         NumOperands = 1;
12537         break;
12538       }
12539
12540       // An add of negative one (subtract of one) will be selected as a DEC.
12541       if (C->getAPIntValue().isAllOnesValue() && !Subtarget->slowIncDec()) {
12542         Opcode = X86ISD::DEC;
12543         NumOperands = 1;
12544         break;
12545       }
12546     }
12547
12548     // Otherwise use a regular EFLAGS-setting add.
12549     Opcode = X86ISD::ADD;
12550     NumOperands = 2;
12551     break;
12552   case ISD::SHL:
12553   case ISD::SRL:
12554     // If we have a constant logical shift that's only used in a comparison
12555     // against zero turn it into an equivalent AND. This allows turning it into
12556     // a TEST instruction later.
12557     if ((X86CC == X86::COND_E || X86CC == X86::COND_NE) && Op->hasOneUse() &&
12558         isa<ConstantSDNode>(Op->getOperand(1)) && !hasNonFlagsUse(Op)) {
12559       EVT VT = Op.getValueType();
12560       unsigned BitWidth = VT.getSizeInBits();
12561       unsigned ShAmt = Op->getConstantOperandVal(1);
12562       if (ShAmt >= BitWidth) // Avoid undefined shifts.
12563         break;
12564       APInt Mask = ArithOp.getOpcode() == ISD::SRL
12565                        ? APInt::getHighBitsSet(BitWidth, BitWidth - ShAmt)
12566                        : APInt::getLowBitsSet(BitWidth, BitWidth - ShAmt);
12567       if (!Mask.isSignedIntN(32)) // Avoid large immediates.
12568         break;
12569       SDValue New = DAG.getNode(ISD::AND, dl, VT, Op->getOperand(0),
12570                                 DAG.getConstant(Mask, VT));
12571       DAG.ReplaceAllUsesWith(Op, New);
12572       Op = New;
12573     }
12574     break;
12575
12576   case ISD::AND:
12577     // If the primary and result isn't used, don't bother using X86ISD::AND,
12578     // because a TEST instruction will be better.
12579     if (!hasNonFlagsUse(Op))
12580       break;
12581     // FALL THROUGH
12582   case ISD::SUB:
12583   case ISD::OR:
12584   case ISD::XOR:
12585     // Due to the ISEL shortcoming noted above, be conservative if this op is
12586     // likely to be selected as part of a load-modify-store instruction.
12587     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
12588            UE = Op.getNode()->use_end(); UI != UE; ++UI)
12589       if (UI->getOpcode() == ISD::STORE)
12590         goto default_case;
12591
12592     // Otherwise use a regular EFLAGS-setting instruction.
12593     switch (ArithOp.getOpcode()) {
12594     default: llvm_unreachable("unexpected operator!");
12595     case ISD::SUB: Opcode = X86ISD::SUB; break;
12596     case ISD::XOR: Opcode = X86ISD::XOR; break;
12597     case ISD::AND: Opcode = X86ISD::AND; break;
12598     case ISD::OR: {
12599       if (!NeedTruncation && (X86CC == X86::COND_E || X86CC == X86::COND_NE)) {
12600         SDValue EFLAGS = LowerVectorAllZeroTest(Op, Subtarget, DAG);
12601         if (EFLAGS.getNode())
12602           return EFLAGS;
12603       }
12604       Opcode = X86ISD::OR;
12605       break;
12606     }
12607     }
12608
12609     NumOperands = 2;
12610     break;
12611   case X86ISD::ADD:
12612   case X86ISD::SUB:
12613   case X86ISD::INC:
12614   case X86ISD::DEC:
12615   case X86ISD::OR:
12616   case X86ISD::XOR:
12617   case X86ISD::AND:
12618     return SDValue(Op.getNode(), 1);
12619   default:
12620   default_case:
12621     break;
12622   }
12623
12624   // If we found that truncation is beneficial, perform the truncation and
12625   // update 'Op'.
12626   if (NeedTruncation) {
12627     EVT VT = Op.getValueType();
12628     SDValue WideVal = Op->getOperand(0);
12629     EVT WideVT = WideVal.getValueType();
12630     unsigned ConvertedOp = 0;
12631     // Use a target machine opcode to prevent further DAGCombine
12632     // optimizations that may separate the arithmetic operations
12633     // from the setcc node.
12634     switch (WideVal.getOpcode()) {
12635       default: break;
12636       case ISD::ADD: ConvertedOp = X86ISD::ADD; break;
12637       case ISD::SUB: ConvertedOp = X86ISD::SUB; break;
12638       case ISD::AND: ConvertedOp = X86ISD::AND; break;
12639       case ISD::OR:  ConvertedOp = X86ISD::OR;  break;
12640       case ISD::XOR: ConvertedOp = X86ISD::XOR; break;
12641     }
12642
12643     if (ConvertedOp) {
12644       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
12645       if (TLI.isOperationLegal(WideVal.getOpcode(), WideVT)) {
12646         SDValue V0 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(0));
12647         SDValue V1 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(1));
12648         Op = DAG.getNode(ConvertedOp, dl, VT, V0, V1);
12649       }
12650     }
12651   }
12652
12653   if (Opcode == 0)
12654     // Emit a CMP with 0, which is the TEST pattern.
12655     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
12656                        DAG.getConstant(0, Op.getValueType()));
12657
12658   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
12659   SmallVector<SDValue, 4> Ops(Op->op_begin(), Op->op_begin() + NumOperands);
12660
12661   SDValue New = DAG.getNode(Opcode, dl, VTs, Ops);
12662   DAG.ReplaceAllUsesWith(Op, New);
12663   return SDValue(New.getNode(), 1);
12664 }
12665
12666 /// Emit nodes that will be selected as "cmp Op0,Op1", or something
12667 /// equivalent.
12668 SDValue X86TargetLowering::EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC,
12669                                    SDLoc dl, SelectionDAG &DAG) const {
12670   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op1)) {
12671     if (C->getAPIntValue() == 0)
12672       return EmitTest(Op0, X86CC, dl, DAG);
12673
12674      if (Op0.getValueType() == MVT::i1)
12675        llvm_unreachable("Unexpected comparison operation for MVT::i1 operands");
12676   }
12677
12678   if ((Op0.getValueType() == MVT::i8 || Op0.getValueType() == MVT::i16 ||
12679        Op0.getValueType() == MVT::i32 || Op0.getValueType() == MVT::i64)) {
12680     // Do the comparison at i32 if it's smaller, besides the Atom case.
12681     // This avoids subregister aliasing issues. Keep the smaller reference
12682     // if we're optimizing for size, however, as that'll allow better folding
12683     // of memory operations.
12684     if (Op0.getValueType() != MVT::i32 && Op0.getValueType() != MVT::i64 &&
12685         !DAG.getMachineFunction().getFunction()->hasFnAttribute(
12686             Attribute::MinSize) &&
12687         !Subtarget->isAtom()) {
12688       unsigned ExtendOp =
12689           isX86CCUnsigned(X86CC) ? ISD::ZERO_EXTEND : ISD::SIGN_EXTEND;
12690       Op0 = DAG.getNode(ExtendOp, dl, MVT::i32, Op0);
12691       Op1 = DAG.getNode(ExtendOp, dl, MVT::i32, Op1);
12692     }
12693     // Use SUB instead of CMP to enable CSE between SUB and CMP.
12694     SDVTList VTs = DAG.getVTList(Op0.getValueType(), MVT::i32);
12695     SDValue Sub = DAG.getNode(X86ISD::SUB, dl, VTs,
12696                               Op0, Op1);
12697     return SDValue(Sub.getNode(), 1);
12698   }
12699   return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
12700 }
12701
12702 /// Convert a comparison if required by the subtarget.
12703 SDValue X86TargetLowering::ConvertCmpIfNecessary(SDValue Cmp,
12704                                                  SelectionDAG &DAG) const {
12705   // If the subtarget does not support the FUCOMI instruction, floating-point
12706   // comparisons have to be converted.
12707   if (Subtarget->hasCMov() ||
12708       Cmp.getOpcode() != X86ISD::CMP ||
12709       !Cmp.getOperand(0).getValueType().isFloatingPoint() ||
12710       !Cmp.getOperand(1).getValueType().isFloatingPoint())
12711     return Cmp;
12712
12713   // The instruction selector will select an FUCOM instruction instead of
12714   // FUCOMI, which writes the comparison result to FPSW instead of EFLAGS. Hence
12715   // build an SDNode sequence that transfers the result from FPSW into EFLAGS:
12716   // (X86sahf (trunc (srl (X86fp_stsw (trunc (X86cmp ...)), 8))))
12717   SDLoc dl(Cmp);
12718   SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
12719   SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
12720   SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
12721                             DAG.getConstant(8, MVT::i8));
12722   SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
12723   return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
12724 }
12725
12726 /// The minimum architected relative accuracy is 2^-12. We need one
12727 /// Newton-Raphson step to have a good float result (24 bits of precision).
12728 SDValue X86TargetLowering::getRsqrtEstimate(SDValue Op,
12729                                             DAGCombinerInfo &DCI,
12730                                             unsigned &RefinementSteps,
12731                                             bool &UseOneConstNR) const {
12732   // FIXME: We should use instruction latency models to calculate the cost of
12733   // each potential sequence, but this is very hard to do reliably because
12734   // at least Intel's Core* chips have variable timing based on the number of
12735   // significant digits in the divisor and/or sqrt operand.
12736   if (!Subtarget->useSqrtEst())
12737     return SDValue();
12738
12739   EVT VT = Op.getValueType();
12740
12741   // SSE1 has rsqrtss and rsqrtps.
12742   // TODO: Add support for AVX512 (v16f32).
12743   // It is likely not profitable to do this for f64 because a double-precision
12744   // rsqrt estimate with refinement on x86 prior to FMA requires at least 16
12745   // instructions: convert to single, rsqrtss, convert back to double, refine
12746   // (3 steps = at least 13 insts). If an 'rsqrtsd' variant was added to the ISA
12747   // along with FMA, this could be a throughput win.
12748   if ((Subtarget->hasSSE1() && (VT == MVT::f32 || VT == MVT::v4f32)) ||
12749       (Subtarget->hasAVX() && VT == MVT::v8f32)) {
12750     RefinementSteps = 1;
12751     UseOneConstNR = false;
12752     return DCI.DAG.getNode(X86ISD::FRSQRT, SDLoc(Op), VT, Op);
12753   }
12754   return SDValue();
12755 }
12756
12757 /// The minimum architected relative accuracy is 2^-12. We need one
12758 /// Newton-Raphson step to have a good float result (24 bits of precision).
12759 SDValue X86TargetLowering::getRecipEstimate(SDValue Op,
12760                                             DAGCombinerInfo &DCI,
12761                                             unsigned &RefinementSteps) const {
12762   // FIXME: We should use instruction latency models to calculate the cost of
12763   // each potential sequence, but this is very hard to do reliably because
12764   // at least Intel's Core* chips have variable timing based on the number of
12765   // significant digits in the divisor.
12766   if (!Subtarget->useReciprocalEst())
12767     return SDValue();
12768
12769   EVT VT = Op.getValueType();
12770
12771   // SSE1 has rcpss and rcpps. AVX adds a 256-bit variant for rcpps.
12772   // TODO: Add support for AVX512 (v16f32).
12773   // It is likely not profitable to do this for f64 because a double-precision
12774   // reciprocal estimate with refinement on x86 prior to FMA requires
12775   // 15 instructions: convert to single, rcpss, convert back to double, refine
12776   // (3 steps = 12 insts). If an 'rcpsd' variant was added to the ISA
12777   // along with FMA, this could be a throughput win.
12778   if ((Subtarget->hasSSE1() && (VT == MVT::f32 || VT == MVT::v4f32)) ||
12779       (Subtarget->hasAVX() && VT == MVT::v8f32)) {
12780     RefinementSteps = ReciprocalEstimateRefinementSteps;
12781     return DCI.DAG.getNode(X86ISD::FRCP, SDLoc(Op), VT, Op);
12782   }
12783   return SDValue();
12784 }
12785
12786 static bool isAllOnes(SDValue V) {
12787   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
12788   return C && C->isAllOnesValue();
12789 }
12790
12791 /// LowerToBT - Result of 'and' is compared against zero. Turn it into a BT node
12792 /// if it's possible.
12793 SDValue X86TargetLowering::LowerToBT(SDValue And, ISD::CondCode CC,
12794                                      SDLoc dl, SelectionDAG &DAG) const {
12795   SDValue Op0 = And.getOperand(0);
12796   SDValue Op1 = And.getOperand(1);
12797   if (Op0.getOpcode() == ISD::TRUNCATE)
12798     Op0 = Op0.getOperand(0);
12799   if (Op1.getOpcode() == ISD::TRUNCATE)
12800     Op1 = Op1.getOperand(0);
12801
12802   SDValue LHS, RHS;
12803   if (Op1.getOpcode() == ISD::SHL)
12804     std::swap(Op0, Op1);
12805   if (Op0.getOpcode() == ISD::SHL) {
12806     if (ConstantSDNode *And00C = dyn_cast<ConstantSDNode>(Op0.getOperand(0)))
12807       if (And00C->getZExtValue() == 1) {
12808         // If we looked past a truncate, check that it's only truncating away
12809         // known zeros.
12810         unsigned BitWidth = Op0.getValueSizeInBits();
12811         unsigned AndBitWidth = And.getValueSizeInBits();
12812         if (BitWidth > AndBitWidth) {
12813           APInt Zeros, Ones;
12814           DAG.computeKnownBits(Op0, Zeros, Ones);
12815           if (Zeros.countLeadingOnes() < BitWidth - AndBitWidth)
12816             return SDValue();
12817         }
12818         LHS = Op1;
12819         RHS = Op0.getOperand(1);
12820       }
12821   } else if (Op1.getOpcode() == ISD::Constant) {
12822     ConstantSDNode *AndRHS = cast<ConstantSDNode>(Op1);
12823     uint64_t AndRHSVal = AndRHS->getZExtValue();
12824     SDValue AndLHS = Op0;
12825
12826     if (AndRHSVal == 1 && AndLHS.getOpcode() == ISD::SRL) {
12827       LHS = AndLHS.getOperand(0);
12828       RHS = AndLHS.getOperand(1);
12829     }
12830
12831     // Use BT if the immediate can't be encoded in a TEST instruction.
12832     if (!isUInt<32>(AndRHSVal) && isPowerOf2_64(AndRHSVal)) {
12833       LHS = AndLHS;
12834       RHS = DAG.getConstant(Log2_64_Ceil(AndRHSVal), LHS.getValueType());
12835     }
12836   }
12837
12838   if (LHS.getNode()) {
12839     // If LHS is i8, promote it to i32 with any_extend.  There is no i8 BT
12840     // instruction.  Since the shift amount is in-range-or-undefined, we know
12841     // that doing a bittest on the i32 value is ok.  We extend to i32 because
12842     // the encoding for the i16 version is larger than the i32 version.
12843     // Also promote i16 to i32 for performance / code size reason.
12844     if (LHS.getValueType() == MVT::i8 ||
12845         LHS.getValueType() == MVT::i16)
12846       LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
12847
12848     // If the operand types disagree, extend the shift amount to match.  Since
12849     // BT ignores high bits (like shifts) we can use anyextend.
12850     if (LHS.getValueType() != RHS.getValueType())
12851       RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
12852
12853     SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
12854     X86::CondCode Cond = CC == ISD::SETEQ ? X86::COND_AE : X86::COND_B;
12855     return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
12856                        DAG.getConstant(Cond, MVT::i8), BT);
12857   }
12858
12859   return SDValue();
12860 }
12861
12862 /// \brief - Turns an ISD::CondCode into a value suitable for SSE floating point
12863 /// mask CMPs.
12864 static int translateX86FSETCC(ISD::CondCode SetCCOpcode, SDValue &Op0,
12865                               SDValue &Op1) {
12866   unsigned SSECC;
12867   bool Swap = false;
12868
12869   // SSE Condition code mapping:
12870   //  0 - EQ
12871   //  1 - LT
12872   //  2 - LE
12873   //  3 - UNORD
12874   //  4 - NEQ
12875   //  5 - NLT
12876   //  6 - NLE
12877   //  7 - ORD
12878   switch (SetCCOpcode) {
12879   default: llvm_unreachable("Unexpected SETCC condition");
12880   case ISD::SETOEQ:
12881   case ISD::SETEQ:  SSECC = 0; break;
12882   case ISD::SETOGT:
12883   case ISD::SETGT:  Swap = true; // Fallthrough
12884   case ISD::SETLT:
12885   case ISD::SETOLT: SSECC = 1; break;
12886   case ISD::SETOGE:
12887   case ISD::SETGE:  Swap = true; // Fallthrough
12888   case ISD::SETLE:
12889   case ISD::SETOLE: SSECC = 2; break;
12890   case ISD::SETUO:  SSECC = 3; break;
12891   case ISD::SETUNE:
12892   case ISD::SETNE:  SSECC = 4; break;
12893   case ISD::SETULE: Swap = true; // Fallthrough
12894   case ISD::SETUGE: SSECC = 5; break;
12895   case ISD::SETULT: Swap = true; // Fallthrough
12896   case ISD::SETUGT: SSECC = 6; break;
12897   case ISD::SETO:   SSECC = 7; break;
12898   case ISD::SETUEQ:
12899   case ISD::SETONE: SSECC = 8; break;
12900   }
12901   if (Swap)
12902     std::swap(Op0, Op1);
12903
12904   return SSECC;
12905 }
12906
12907 // Lower256IntVSETCC - Break a VSETCC 256-bit integer VSETCC into two new 128
12908 // ones, and then concatenate the result back.
12909 static SDValue Lower256IntVSETCC(SDValue Op, SelectionDAG &DAG) {
12910   MVT VT = Op.getSimpleValueType();
12911
12912   assert(VT.is256BitVector() && Op.getOpcode() == ISD::SETCC &&
12913          "Unsupported value type for operation");
12914
12915   unsigned NumElems = VT.getVectorNumElements();
12916   SDLoc dl(Op);
12917   SDValue CC = Op.getOperand(2);
12918
12919   // Extract the LHS vectors
12920   SDValue LHS = Op.getOperand(0);
12921   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
12922   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
12923
12924   // Extract the RHS vectors
12925   SDValue RHS = Op.getOperand(1);
12926   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
12927   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
12928
12929   // Issue the operation on the smaller types and concatenate the result back
12930   MVT EltVT = VT.getVectorElementType();
12931   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
12932   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
12933                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
12934                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
12935 }
12936
12937 static SDValue LowerIntVSETCC_AVX512(SDValue Op, SelectionDAG &DAG,
12938                                      const X86Subtarget *Subtarget) {
12939   SDValue Op0 = Op.getOperand(0);
12940   SDValue Op1 = Op.getOperand(1);
12941   SDValue CC = Op.getOperand(2);
12942   MVT VT = Op.getSimpleValueType();
12943   SDLoc dl(Op);
12944
12945   assert(Op0.getValueType().getVectorElementType().getSizeInBits() >= 8 &&
12946          Op.getValueType().getScalarType() == MVT::i1 &&
12947          "Cannot set masked compare for this operation");
12948
12949   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
12950   unsigned  Opc = 0;
12951   bool Unsigned = false;
12952   bool Swap = false;
12953   unsigned SSECC;
12954   switch (SetCCOpcode) {
12955   default: llvm_unreachable("Unexpected SETCC condition");
12956   case ISD::SETNE:  SSECC = 4; break;
12957   case ISD::SETEQ:  Opc = X86ISD::PCMPEQM; break;
12958   case ISD::SETUGT: SSECC = 6; Unsigned = true; break;
12959   case ISD::SETLT:  Swap = true; //fall-through
12960   case ISD::SETGT:  Opc = X86ISD::PCMPGTM; break;
12961   case ISD::SETULT: SSECC = 1; Unsigned = true; break;
12962   case ISD::SETUGE: SSECC = 5; Unsigned = true; break; //NLT
12963   case ISD::SETGE:  Swap = true; SSECC = 2; break; // LE + swap
12964   case ISD::SETULE: Unsigned = true; //fall-through
12965   case ISD::SETLE:  SSECC = 2; break;
12966   }
12967
12968   if (Swap)
12969     std::swap(Op0, Op1);
12970   if (Opc)
12971     return DAG.getNode(Opc, dl, VT, Op0, Op1);
12972   Opc = Unsigned ? X86ISD::CMPMU: X86ISD::CMPM;
12973   return DAG.getNode(Opc, dl, VT, Op0, Op1,
12974                      DAG.getConstant(SSECC, MVT::i8));
12975 }
12976
12977 /// \brief Try to turn a VSETULT into a VSETULE by modifying its second
12978 /// operand \p Op1.  If non-trivial (for example because it's not constant)
12979 /// return an empty value.
12980 static SDValue ChangeVSETULTtoVSETULE(SDLoc dl, SDValue Op1, SelectionDAG &DAG)
12981 {
12982   BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Op1.getNode());
12983   if (!BV)
12984     return SDValue();
12985
12986   MVT VT = Op1.getSimpleValueType();
12987   MVT EVT = VT.getVectorElementType();
12988   unsigned n = VT.getVectorNumElements();
12989   SmallVector<SDValue, 8> ULTOp1;
12990
12991   for (unsigned i = 0; i < n; ++i) {
12992     ConstantSDNode *Elt = dyn_cast<ConstantSDNode>(BV->getOperand(i));
12993     if (!Elt || Elt->isOpaque() || Elt->getValueType(0) != EVT)
12994       return SDValue();
12995
12996     // Avoid underflow.
12997     APInt Val = Elt->getAPIntValue();
12998     if (Val == 0)
12999       return SDValue();
13000
13001     ULTOp1.push_back(DAG.getConstant(Val - 1, EVT));
13002   }
13003
13004   return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, ULTOp1);
13005 }
13006
13007 static SDValue LowerVSETCC(SDValue Op, const X86Subtarget *Subtarget,
13008                            SelectionDAG &DAG) {
13009   SDValue Op0 = Op.getOperand(0);
13010   SDValue Op1 = Op.getOperand(1);
13011   SDValue CC = Op.getOperand(2);
13012   MVT VT = Op.getSimpleValueType();
13013   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
13014   bool isFP = Op.getOperand(1).getSimpleValueType().isFloatingPoint();
13015   SDLoc dl(Op);
13016
13017   if (isFP) {
13018 #ifndef NDEBUG
13019     MVT EltVT = Op0.getSimpleValueType().getVectorElementType();
13020     assert(EltVT == MVT::f32 || EltVT == MVT::f64);
13021 #endif
13022
13023     unsigned SSECC = translateX86FSETCC(SetCCOpcode, Op0, Op1);
13024     unsigned Opc = X86ISD::CMPP;
13025     if (Subtarget->hasAVX512() && VT.getVectorElementType() == MVT::i1) {
13026       assert(VT.getVectorNumElements() <= 16);
13027       Opc = X86ISD::CMPM;
13028     }
13029     // In the two special cases we can't handle, emit two comparisons.
13030     if (SSECC == 8) {
13031       unsigned CC0, CC1;
13032       unsigned CombineOpc;
13033       if (SetCCOpcode == ISD::SETUEQ) {
13034         CC0 = 3; CC1 = 0; CombineOpc = ISD::OR;
13035       } else {
13036         assert(SetCCOpcode == ISD::SETONE);
13037         CC0 = 7; CC1 = 4; CombineOpc = ISD::AND;
13038       }
13039
13040       SDValue Cmp0 = DAG.getNode(Opc, dl, VT, Op0, Op1,
13041                                  DAG.getConstant(CC0, MVT::i8));
13042       SDValue Cmp1 = DAG.getNode(Opc, dl, VT, Op0, Op1,
13043                                  DAG.getConstant(CC1, MVT::i8));
13044       return DAG.getNode(CombineOpc, dl, VT, Cmp0, Cmp1);
13045     }
13046     // Handle all other FP comparisons here.
13047     return DAG.getNode(Opc, dl, VT, Op0, Op1,
13048                        DAG.getConstant(SSECC, MVT::i8));
13049   }
13050
13051   // Break 256-bit integer vector compare into smaller ones.
13052   if (VT.is256BitVector() && !Subtarget->hasInt256())
13053     return Lower256IntVSETCC(Op, DAG);
13054
13055   bool MaskResult = (VT.getVectorElementType() == MVT::i1);
13056   EVT OpVT = Op1.getValueType();
13057   if (Subtarget->hasAVX512()) {
13058     if (Op1.getValueType().is512BitVector() ||
13059         (Subtarget->hasBWI() && Subtarget->hasVLX()) ||
13060         (MaskResult && OpVT.getVectorElementType().getSizeInBits() >= 32))
13061       return LowerIntVSETCC_AVX512(Op, DAG, Subtarget);
13062
13063     // In AVX-512 architecture setcc returns mask with i1 elements,
13064     // But there is no compare instruction for i8 and i16 elements in KNL.
13065     // We are not talking about 512-bit operands in this case, these
13066     // types are illegal.
13067     if (MaskResult &&
13068         (OpVT.getVectorElementType().getSizeInBits() < 32 &&
13069          OpVT.getVectorElementType().getSizeInBits() >= 8))
13070       return DAG.getNode(ISD::TRUNCATE, dl, VT,
13071                          DAG.getNode(ISD::SETCC, dl, OpVT, Op0, Op1, CC));
13072   }
13073
13074   // We are handling one of the integer comparisons here.  Since SSE only has
13075   // GT and EQ comparisons for integer, swapping operands and multiple
13076   // operations may be required for some comparisons.
13077   unsigned Opc;
13078   bool Swap = false, Invert = false, FlipSigns = false, MinMax = false;
13079   bool Subus = false;
13080
13081   switch (SetCCOpcode) {
13082   default: llvm_unreachable("Unexpected SETCC condition");
13083   case ISD::SETNE:  Invert = true;
13084   case ISD::SETEQ:  Opc = X86ISD::PCMPEQ; break;
13085   case ISD::SETLT:  Swap = true;
13086   case ISD::SETGT:  Opc = X86ISD::PCMPGT; break;
13087   case ISD::SETGE:  Swap = true;
13088   case ISD::SETLE:  Opc = X86ISD::PCMPGT;
13089                     Invert = true; break;
13090   case ISD::SETULT: Swap = true;
13091   case ISD::SETUGT: Opc = X86ISD::PCMPGT;
13092                     FlipSigns = true; break;
13093   case ISD::SETUGE: Swap = true;
13094   case ISD::SETULE: Opc = X86ISD::PCMPGT;
13095                     FlipSigns = true; Invert = true; break;
13096   }
13097
13098   // Special case: Use min/max operations for SETULE/SETUGE
13099   MVT VET = VT.getVectorElementType();
13100   bool hasMinMax =
13101        (Subtarget->hasSSE41() && (VET >= MVT::i8 && VET <= MVT::i32))
13102     || (Subtarget->hasSSE2()  && (VET == MVT::i8));
13103
13104   if (hasMinMax) {
13105     switch (SetCCOpcode) {
13106     default: break;
13107     case ISD::SETULE: Opc = X86ISD::UMIN; MinMax = true; break;
13108     case ISD::SETUGE: Opc = X86ISD::UMAX; MinMax = true; break;
13109     }
13110
13111     if (MinMax) { Swap = false; Invert = false; FlipSigns = false; }
13112   }
13113
13114   bool hasSubus = Subtarget->hasSSE2() && (VET == MVT::i8 || VET == MVT::i16);
13115   if (!MinMax && hasSubus) {
13116     // As another special case, use PSUBUS[BW] when it's profitable. E.g. for
13117     // Op0 u<= Op1:
13118     //   t = psubus Op0, Op1
13119     //   pcmpeq t, <0..0>
13120     switch (SetCCOpcode) {
13121     default: break;
13122     case ISD::SETULT: {
13123       // If the comparison is against a constant we can turn this into a
13124       // setule.  With psubus, setule does not require a swap.  This is
13125       // beneficial because the constant in the register is no longer
13126       // destructed as the destination so it can be hoisted out of a loop.
13127       // Only do this pre-AVX since vpcmp* is no longer destructive.
13128       if (Subtarget->hasAVX())
13129         break;
13130       SDValue ULEOp1 = ChangeVSETULTtoVSETULE(dl, Op1, DAG);
13131       if (ULEOp1.getNode()) {
13132         Op1 = ULEOp1;
13133         Subus = true; Invert = false; Swap = false;
13134       }
13135       break;
13136     }
13137     // Psubus is better than flip-sign because it requires no inversion.
13138     case ISD::SETUGE: Subus = true; Invert = false; Swap = true;  break;
13139     case ISD::SETULE: Subus = true; Invert = false; Swap = false; break;
13140     }
13141
13142     if (Subus) {
13143       Opc = X86ISD::SUBUS;
13144       FlipSigns = false;
13145     }
13146   }
13147
13148   if (Swap)
13149     std::swap(Op0, Op1);
13150
13151   // Check that the operation in question is available (most are plain SSE2,
13152   // but PCMPGTQ and PCMPEQQ have different requirements).
13153   if (VT == MVT::v2i64) {
13154     if (Opc == X86ISD::PCMPGT && !Subtarget->hasSSE42()) {
13155       assert(Subtarget->hasSSE2() && "Don't know how to lower!");
13156
13157       // First cast everything to the right type.
13158       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
13159       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
13160
13161       // Since SSE has no unsigned integer comparisons, we need to flip the sign
13162       // bits of the inputs before performing those operations. The lower
13163       // compare is always unsigned.
13164       SDValue SB;
13165       if (FlipSigns) {
13166         SB = DAG.getConstant(0x80000000U, MVT::v4i32);
13167       } else {
13168         SDValue Sign = DAG.getConstant(0x80000000U, MVT::i32);
13169         SDValue Zero = DAG.getConstant(0x00000000U, MVT::i32);
13170         SB = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
13171                          Sign, Zero, Sign, Zero);
13172       }
13173       Op0 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op0, SB);
13174       Op1 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op1, SB);
13175
13176       // Emulate PCMPGTQ with (hi1 > hi2) | ((hi1 == hi2) & (lo1 > lo2))
13177       SDValue GT = DAG.getNode(X86ISD::PCMPGT, dl, MVT::v4i32, Op0, Op1);
13178       SDValue EQ = DAG.getNode(X86ISD::PCMPEQ, dl, MVT::v4i32, Op0, Op1);
13179
13180       // Create masks for only the low parts/high parts of the 64 bit integers.
13181       static const int MaskHi[] = { 1, 1, 3, 3 };
13182       static const int MaskLo[] = { 0, 0, 2, 2 };
13183       SDValue EQHi = DAG.getVectorShuffle(MVT::v4i32, dl, EQ, EQ, MaskHi);
13184       SDValue GTLo = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskLo);
13185       SDValue GTHi = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskHi);
13186
13187       SDValue Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, EQHi, GTLo);
13188       Result = DAG.getNode(ISD::OR, dl, MVT::v4i32, Result, GTHi);
13189
13190       if (Invert)
13191         Result = DAG.getNOT(dl, Result, MVT::v4i32);
13192
13193       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
13194     }
13195
13196     if (Opc == X86ISD::PCMPEQ && !Subtarget->hasSSE41()) {
13197       // If pcmpeqq is missing but pcmpeqd is available synthesize pcmpeqq with
13198       // pcmpeqd + pshufd + pand.
13199       assert(Subtarget->hasSSE2() && !FlipSigns && "Don't know how to lower!");
13200
13201       // First cast everything to the right type.
13202       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
13203       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
13204
13205       // Do the compare.
13206       SDValue Result = DAG.getNode(Opc, dl, MVT::v4i32, Op0, Op1);
13207
13208       // Make sure the lower and upper halves are both all-ones.
13209       static const int Mask[] = { 1, 0, 3, 2 };
13210       SDValue Shuf = DAG.getVectorShuffle(MVT::v4i32, dl, Result, Result, Mask);
13211       Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, Result, Shuf);
13212
13213       if (Invert)
13214         Result = DAG.getNOT(dl, Result, MVT::v4i32);
13215
13216       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
13217     }
13218   }
13219
13220   // Since SSE has no unsigned integer comparisons, we need to flip the sign
13221   // bits of the inputs before performing those operations.
13222   if (FlipSigns) {
13223     EVT EltVT = VT.getVectorElementType();
13224     SDValue SB = DAG.getConstant(APInt::getSignBit(EltVT.getSizeInBits()), VT);
13225     Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SB);
13226     Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SB);
13227   }
13228
13229   SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
13230
13231   // If the logical-not of the result is required, perform that now.
13232   if (Invert)
13233     Result = DAG.getNOT(dl, Result, VT);
13234
13235   if (MinMax)
13236     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Op0, Result);
13237
13238   if (Subus)
13239     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Result,
13240                          getZeroVector(VT, Subtarget, DAG, dl));
13241
13242   return Result;
13243 }
13244
13245 SDValue X86TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
13246
13247   MVT VT = Op.getSimpleValueType();
13248
13249   if (VT.isVector()) return LowerVSETCC(Op, Subtarget, DAG);
13250
13251   assert(((!Subtarget->hasAVX512() && VT == MVT::i8) || (VT == MVT::i1))
13252          && "SetCC type must be 8-bit or 1-bit integer");
13253   SDValue Op0 = Op.getOperand(0);
13254   SDValue Op1 = Op.getOperand(1);
13255   SDLoc dl(Op);
13256   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
13257
13258   // Optimize to BT if possible.
13259   // Lower (X & (1 << N)) == 0 to BT(X, N).
13260   // Lower ((X >>u N) & 1) != 0 to BT(X, N).
13261   // Lower ((X >>s N) & 1) != 0 to BT(X, N).
13262   if (Op0.getOpcode() == ISD::AND && Op0.hasOneUse() &&
13263       Op1.getOpcode() == ISD::Constant &&
13264       cast<ConstantSDNode>(Op1)->isNullValue() &&
13265       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
13266     SDValue NewSetCC = LowerToBT(Op0, CC, dl, DAG);
13267     if (NewSetCC.getNode()) {
13268       if (VT == MVT::i1)
13269         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewSetCC);
13270       return NewSetCC;
13271     }
13272   }
13273
13274   // Look for X == 0, X == 1, X != 0, or X != 1.  We can simplify some forms of
13275   // these.
13276   if (Op1.getOpcode() == ISD::Constant &&
13277       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1 ||
13278        cast<ConstantSDNode>(Op1)->isNullValue()) &&
13279       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
13280
13281     // If the input is a setcc, then reuse the input setcc or use a new one with
13282     // the inverted condition.
13283     if (Op0.getOpcode() == X86ISD::SETCC) {
13284       X86::CondCode CCode = (X86::CondCode)Op0.getConstantOperandVal(0);
13285       bool Invert = (CC == ISD::SETNE) ^
13286         cast<ConstantSDNode>(Op1)->isNullValue();
13287       if (!Invert)
13288         return Op0;
13289
13290       CCode = X86::GetOppositeBranchCondition(CCode);
13291       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
13292                                   DAG.getConstant(CCode, MVT::i8),
13293                                   Op0.getOperand(1));
13294       if (VT == MVT::i1)
13295         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
13296       return SetCC;
13297     }
13298   }
13299   if ((Op0.getValueType() == MVT::i1) && (Op1.getOpcode() == ISD::Constant) &&
13300       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1) &&
13301       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
13302
13303     ISD::CondCode NewCC = ISD::getSetCCInverse(CC, true);
13304     return DAG.getSetCC(dl, VT, Op0, DAG.getConstant(0, MVT::i1), NewCC);
13305   }
13306
13307   bool isFP = Op1.getSimpleValueType().isFloatingPoint();
13308   unsigned X86CC = TranslateX86CC(CC, isFP, Op0, Op1, DAG);
13309   if (X86CC == X86::COND_INVALID)
13310     return SDValue();
13311
13312   SDValue EFLAGS = EmitCmp(Op0, Op1, X86CC, dl, DAG);
13313   EFLAGS = ConvertCmpIfNecessary(EFLAGS, DAG);
13314   SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
13315                               DAG.getConstant(X86CC, MVT::i8), EFLAGS);
13316   if (VT == MVT::i1)
13317     return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
13318   return SetCC;
13319 }
13320
13321 // isX86LogicalCmp - Return true if opcode is a X86 logical comparison.
13322 static bool isX86LogicalCmp(SDValue Op) {
13323   unsigned Opc = Op.getNode()->getOpcode();
13324   if (Opc == X86ISD::CMP || Opc == X86ISD::COMI || Opc == X86ISD::UCOMI ||
13325       Opc == X86ISD::SAHF)
13326     return true;
13327   if (Op.getResNo() == 1 &&
13328       (Opc == X86ISD::ADD ||
13329        Opc == X86ISD::SUB ||
13330        Opc == X86ISD::ADC ||
13331        Opc == X86ISD::SBB ||
13332        Opc == X86ISD::SMUL ||
13333        Opc == X86ISD::UMUL ||
13334        Opc == X86ISD::INC ||
13335        Opc == X86ISD::DEC ||
13336        Opc == X86ISD::OR ||
13337        Opc == X86ISD::XOR ||
13338        Opc == X86ISD::AND))
13339     return true;
13340
13341   if (Op.getResNo() == 2 && Opc == X86ISD::UMUL)
13342     return true;
13343
13344   return false;
13345 }
13346
13347 static bool isTruncWithZeroHighBitsInput(SDValue V, SelectionDAG &DAG) {
13348   if (V.getOpcode() != ISD::TRUNCATE)
13349     return false;
13350
13351   SDValue VOp0 = V.getOperand(0);
13352   unsigned InBits = VOp0.getValueSizeInBits();
13353   unsigned Bits = V.getValueSizeInBits();
13354   return DAG.MaskedValueIsZero(VOp0, APInt::getHighBitsSet(InBits,InBits-Bits));
13355 }
13356
13357 SDValue X86TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
13358   bool addTest = true;
13359   SDValue Cond  = Op.getOperand(0);
13360   SDValue Op1 = Op.getOperand(1);
13361   SDValue Op2 = Op.getOperand(2);
13362   SDLoc DL(Op);
13363   EVT VT = Op1.getValueType();
13364   SDValue CC;
13365
13366   // Lower FP selects into a CMP/AND/ANDN/OR sequence when the necessary SSE ops
13367   // are available or VBLENDV if AVX is available.
13368   // Otherwise FP cmovs get lowered into a less efficient branch sequence later.
13369   if (Cond.getOpcode() == ISD::SETCC &&
13370       ((Subtarget->hasSSE2() && (VT == MVT::f32 || VT == MVT::f64)) ||
13371        (Subtarget->hasSSE1() && VT == MVT::f32)) &&
13372       VT == Cond.getOperand(0).getValueType() && Cond->hasOneUse()) {
13373     SDValue CondOp0 = Cond.getOperand(0), CondOp1 = Cond.getOperand(1);
13374     int SSECC = translateX86FSETCC(
13375         cast<CondCodeSDNode>(Cond.getOperand(2))->get(), CondOp0, CondOp1);
13376
13377     if (SSECC != 8) {
13378       if (Subtarget->hasAVX512()) {
13379         SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CondOp0, CondOp1,
13380                                   DAG.getConstant(SSECC, MVT::i8));
13381         return DAG.getNode(X86ISD::SELECT, DL, VT, Cmp, Op1, Op2);
13382       }
13383
13384       SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, VT, CondOp0, CondOp1,
13385                                 DAG.getConstant(SSECC, MVT::i8));
13386
13387       // If we have AVX, we can use a variable vector select (VBLENDV) instead
13388       // of 3 logic instructions for size savings and potentially speed.
13389       // Unfortunately, there is no scalar form of VBLENDV.
13390
13391       // If either operand is a constant, don't try this. We can expect to
13392       // optimize away at least one of the logic instructions later in that
13393       // case, so that sequence would be faster than a variable blend.
13394
13395       // BLENDV was introduced with SSE 4.1, but the 2 register form implicitly
13396       // uses XMM0 as the selection register. That may need just as many
13397       // instructions as the AND/ANDN/OR sequence due to register moves, so
13398       // don't bother.
13399
13400       if (Subtarget->hasAVX() &&
13401           !isa<ConstantFPSDNode>(Op1) && !isa<ConstantFPSDNode>(Op2)) {
13402
13403         // Convert to vectors, do a VSELECT, and convert back to scalar.
13404         // All of the conversions should be optimized away.
13405
13406         EVT VecVT = VT == MVT::f32 ? MVT::v4f32 : MVT::v2f64;
13407         SDValue VOp1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VecVT, Op1);
13408         SDValue VOp2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VecVT, Op2);
13409         SDValue VCmp = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VecVT, Cmp);
13410
13411         EVT VCmpVT = VT == MVT::f32 ? MVT::v4i32 : MVT::v2i64;
13412         VCmp = DAG.getNode(ISD::BITCAST, DL, VCmpVT, VCmp);
13413
13414         SDValue VSel = DAG.getNode(ISD::VSELECT, DL, VecVT, VCmp, VOp1, VOp2);
13415
13416         return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT,
13417                            VSel, DAG.getIntPtrConstant(0));
13418       }
13419       SDValue AndN = DAG.getNode(X86ISD::FANDN, DL, VT, Cmp, Op2);
13420       SDValue And = DAG.getNode(X86ISD::FAND, DL, VT, Cmp, Op1);
13421       return DAG.getNode(X86ISD::FOR, DL, VT, AndN, And);
13422     }
13423   }
13424
13425   if (Cond.getOpcode() == ISD::SETCC) {
13426     SDValue NewCond = LowerSETCC(Cond, DAG);
13427     if (NewCond.getNode())
13428       Cond = NewCond;
13429   }
13430
13431   // (select (x == 0), -1, y) -> (sign_bit (x - 1)) | y
13432   // (select (x == 0), y, -1) -> ~(sign_bit (x - 1)) | y
13433   // (select (x != 0), y, -1) -> (sign_bit (x - 1)) | y
13434   // (select (x != 0), -1, y) -> ~(sign_bit (x - 1)) | y
13435   if (Cond.getOpcode() == X86ISD::SETCC &&
13436       Cond.getOperand(1).getOpcode() == X86ISD::CMP &&
13437       isZero(Cond.getOperand(1).getOperand(1))) {
13438     SDValue Cmp = Cond.getOperand(1);
13439
13440     unsigned CondCode =cast<ConstantSDNode>(Cond.getOperand(0))->getZExtValue();
13441
13442     if ((isAllOnes(Op1) || isAllOnes(Op2)) &&
13443         (CondCode == X86::COND_E || CondCode == X86::COND_NE)) {
13444       SDValue Y = isAllOnes(Op2) ? Op1 : Op2;
13445
13446       SDValue CmpOp0 = Cmp.getOperand(0);
13447       // Apply further optimizations for special cases
13448       // (select (x != 0), -1, 0) -> neg & sbb
13449       // (select (x == 0), 0, -1) -> neg & sbb
13450       if (ConstantSDNode *YC = dyn_cast<ConstantSDNode>(Y))
13451         if (YC->isNullValue() &&
13452             (isAllOnes(Op1) == (CondCode == X86::COND_NE))) {
13453           SDVTList VTs = DAG.getVTList(CmpOp0.getValueType(), MVT::i32);
13454           SDValue Neg = DAG.getNode(X86ISD::SUB, DL, VTs,
13455                                     DAG.getConstant(0, CmpOp0.getValueType()),
13456                                     CmpOp0);
13457           SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
13458                                     DAG.getConstant(X86::COND_B, MVT::i8),
13459                                     SDValue(Neg.getNode(), 1));
13460           return Res;
13461         }
13462
13463       Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
13464                         CmpOp0, DAG.getConstant(1, CmpOp0.getValueType()));
13465       Cmp = ConvertCmpIfNecessary(Cmp, DAG);
13466
13467       SDValue Res =   // Res = 0 or -1.
13468         DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
13469                     DAG.getConstant(X86::COND_B, MVT::i8), Cmp);
13470
13471       if (isAllOnes(Op1) != (CondCode == X86::COND_E))
13472         Res = DAG.getNOT(DL, Res, Res.getValueType());
13473
13474       ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(Op2);
13475       if (!N2C || !N2C->isNullValue())
13476         Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
13477       return Res;
13478     }
13479   }
13480
13481   // Look past (and (setcc_carry (cmp ...)), 1).
13482   if (Cond.getOpcode() == ISD::AND &&
13483       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
13484     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
13485     if (C && C->getAPIntValue() == 1)
13486       Cond = Cond.getOperand(0);
13487   }
13488
13489   // If condition flag is set by a X86ISD::CMP, then use it as the condition
13490   // setting operand in place of the X86ISD::SETCC.
13491   unsigned CondOpcode = Cond.getOpcode();
13492   if (CondOpcode == X86ISD::SETCC ||
13493       CondOpcode == X86ISD::SETCC_CARRY) {
13494     CC = Cond.getOperand(0);
13495
13496     SDValue Cmp = Cond.getOperand(1);
13497     unsigned Opc = Cmp.getOpcode();
13498     MVT VT = Op.getSimpleValueType();
13499
13500     bool IllegalFPCMov = false;
13501     if (VT.isFloatingPoint() && !VT.isVector() &&
13502         !isScalarFPTypeInSSEReg(VT))  // FPStack?
13503       IllegalFPCMov = !hasFPCMov(cast<ConstantSDNode>(CC)->getSExtValue());
13504
13505     if ((isX86LogicalCmp(Cmp) && !IllegalFPCMov) ||
13506         Opc == X86ISD::BT) { // FIXME
13507       Cond = Cmp;
13508       addTest = false;
13509     }
13510   } else if (CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
13511              CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
13512              ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
13513               Cond.getOperand(0).getValueType() != MVT::i8)) {
13514     SDValue LHS = Cond.getOperand(0);
13515     SDValue RHS = Cond.getOperand(1);
13516     unsigned X86Opcode;
13517     unsigned X86Cond;
13518     SDVTList VTs;
13519     switch (CondOpcode) {
13520     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
13521     case ISD::SADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
13522     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
13523     case ISD::SSUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
13524     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
13525     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
13526     default: llvm_unreachable("unexpected overflowing operator");
13527     }
13528     if (CondOpcode == ISD::UMULO)
13529       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
13530                           MVT::i32);
13531     else
13532       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
13533
13534     SDValue X86Op = DAG.getNode(X86Opcode, DL, VTs, LHS, RHS);
13535
13536     if (CondOpcode == ISD::UMULO)
13537       Cond = X86Op.getValue(2);
13538     else
13539       Cond = X86Op.getValue(1);
13540
13541     CC = DAG.getConstant(X86Cond, MVT::i8);
13542     addTest = false;
13543   }
13544
13545   if (addTest) {
13546     // Look pass the truncate if the high bits are known zero.
13547     if (isTruncWithZeroHighBitsInput(Cond, DAG))
13548         Cond = Cond.getOperand(0);
13549
13550     // We know the result of AND is compared against zero. Try to match
13551     // it to BT.
13552     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
13553       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, DL, DAG);
13554       if (NewSetCC.getNode()) {
13555         CC = NewSetCC.getOperand(0);
13556         Cond = NewSetCC.getOperand(1);
13557         addTest = false;
13558       }
13559     }
13560   }
13561
13562   if (addTest) {
13563     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
13564     Cond = EmitTest(Cond, X86::COND_NE, DL, DAG);
13565   }
13566
13567   // a <  b ? -1 :  0 -> RES = ~setcc_carry
13568   // a <  b ?  0 : -1 -> RES = setcc_carry
13569   // a >= b ? -1 :  0 -> RES = setcc_carry
13570   // a >= b ?  0 : -1 -> RES = ~setcc_carry
13571   if (Cond.getOpcode() == X86ISD::SUB) {
13572     Cond = ConvertCmpIfNecessary(Cond, DAG);
13573     unsigned CondCode = cast<ConstantSDNode>(CC)->getZExtValue();
13574
13575     if ((CondCode == X86::COND_AE || CondCode == X86::COND_B) &&
13576         (isAllOnes(Op1) || isAllOnes(Op2)) && (isZero(Op1) || isZero(Op2))) {
13577       SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
13578                                 DAG.getConstant(X86::COND_B, MVT::i8), Cond);
13579       if (isAllOnes(Op1) != (CondCode == X86::COND_B))
13580         return DAG.getNOT(DL, Res, Res.getValueType());
13581       return Res;
13582     }
13583   }
13584
13585   // X86 doesn't have an i8 cmov. If both operands are the result of a truncate
13586   // widen the cmov and push the truncate through. This avoids introducing a new
13587   // branch during isel and doesn't add any extensions.
13588   if (Op.getValueType() == MVT::i8 &&
13589       Op1.getOpcode() == ISD::TRUNCATE && Op2.getOpcode() == ISD::TRUNCATE) {
13590     SDValue T1 = Op1.getOperand(0), T2 = Op2.getOperand(0);
13591     if (T1.getValueType() == T2.getValueType() &&
13592         // Blacklist CopyFromReg to avoid partial register stalls.
13593         T1.getOpcode() != ISD::CopyFromReg && T2.getOpcode()!=ISD::CopyFromReg){
13594       SDVTList VTs = DAG.getVTList(T1.getValueType(), MVT::Glue);
13595       SDValue Cmov = DAG.getNode(X86ISD::CMOV, DL, VTs, T2, T1, CC, Cond);
13596       return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
13597     }
13598   }
13599
13600   // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
13601   // condition is true.
13602   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
13603   SDValue Ops[] = { Op2, Op1, CC, Cond };
13604   return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops);
13605 }
13606
13607 static SDValue LowerSIGN_EXTEND_AVX512(SDValue Op, const X86Subtarget *Subtarget,
13608                                        SelectionDAG &DAG) {
13609   MVT VT = Op->getSimpleValueType(0);
13610   SDValue In = Op->getOperand(0);
13611   MVT InVT = In.getSimpleValueType();
13612   MVT VTElt = VT.getVectorElementType();
13613   MVT InVTElt = InVT.getVectorElementType();
13614   SDLoc dl(Op);
13615
13616   // SKX processor
13617   if ((InVTElt == MVT::i1) &&
13618       (((Subtarget->hasBWI() && Subtarget->hasVLX() &&
13619         VT.getSizeInBits() <= 256 && VTElt.getSizeInBits() <= 16)) ||
13620
13621        ((Subtarget->hasBWI() && VT.is512BitVector() &&
13622         VTElt.getSizeInBits() <= 16)) ||
13623
13624        ((Subtarget->hasDQI() && Subtarget->hasVLX() &&
13625         VT.getSizeInBits() <= 256 && VTElt.getSizeInBits() >= 32)) ||
13626
13627        ((Subtarget->hasDQI() && VT.is512BitVector() &&
13628         VTElt.getSizeInBits() >= 32))))
13629     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
13630
13631   unsigned int NumElts = VT.getVectorNumElements();
13632
13633   if (NumElts != 8 && NumElts != 16)
13634     return SDValue();
13635
13636   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1) {
13637     if (In.getOpcode() == X86ISD::VSEXT || In.getOpcode() == X86ISD::VZEXT)
13638       return DAG.getNode(In.getOpcode(), dl, VT, In.getOperand(0));
13639     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
13640   }
13641
13642   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13643   assert (InVT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
13644
13645   MVT ExtVT = (NumElts == 8) ? MVT::v8i64 : MVT::v16i32;
13646   Constant *C = ConstantInt::get(*DAG.getContext(),
13647     APInt::getAllOnesValue(ExtVT.getScalarType().getSizeInBits()));
13648
13649   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
13650   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
13651   SDValue Ld = DAG.getLoad(ExtVT.getScalarType(), dl, DAG.getEntryNode(), CP,
13652                           MachinePointerInfo::getConstantPool(),
13653                           false, false, false, Alignment);
13654   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, dl, ExtVT, In, Ld);
13655   if (VT.is512BitVector())
13656     return Brcst;
13657   return DAG.getNode(X86ISD::VTRUNC, dl, VT, Brcst);
13658 }
13659
13660 static SDValue LowerSIGN_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
13661                                 SelectionDAG &DAG) {
13662   MVT VT = Op->getSimpleValueType(0);
13663   SDValue In = Op->getOperand(0);
13664   MVT InVT = In.getSimpleValueType();
13665   SDLoc dl(Op);
13666
13667   if (VT.is512BitVector() || InVT.getVectorElementType() == MVT::i1)
13668     return LowerSIGN_EXTEND_AVX512(Op, Subtarget, DAG);
13669
13670   if ((VT != MVT::v4i64 || InVT != MVT::v4i32) &&
13671       (VT != MVT::v8i32 || InVT != MVT::v8i16) &&
13672       (VT != MVT::v16i16 || InVT != MVT::v16i8))
13673     return SDValue();
13674
13675   if (Subtarget->hasInt256())
13676     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
13677
13678   // Optimize vectors in AVX mode
13679   // Sign extend  v8i16 to v8i32 and
13680   //              v4i32 to v4i64
13681   //
13682   // Divide input vector into two parts
13683   // for v4i32 the shuffle mask will be { 0, 1, -1, -1} {2, 3, -1, -1}
13684   // use vpmovsx instruction to extend v4i32 -> v2i64; v8i16 -> v4i32
13685   // concat the vectors to original VT
13686
13687   unsigned NumElems = InVT.getVectorNumElements();
13688   SDValue Undef = DAG.getUNDEF(InVT);
13689
13690   SmallVector<int,8> ShufMask1(NumElems, -1);
13691   for (unsigned i = 0; i != NumElems/2; ++i)
13692     ShufMask1[i] = i;
13693
13694   SDValue OpLo = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask1[0]);
13695
13696   SmallVector<int,8> ShufMask2(NumElems, -1);
13697   for (unsigned i = 0; i != NumElems/2; ++i)
13698     ShufMask2[i] = i + NumElems/2;
13699
13700   SDValue OpHi = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask2[0]);
13701
13702   MVT HalfVT = MVT::getVectorVT(VT.getScalarType(),
13703                                 VT.getVectorNumElements()/2);
13704
13705   OpLo = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpLo);
13706   OpHi = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpHi);
13707
13708   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
13709 }
13710
13711 // Lower vector extended loads using a shuffle. If SSSE3 is not available we
13712 // may emit an illegal shuffle but the expansion is still better than scalar
13713 // code. We generate X86ISD::VSEXT for SEXTLOADs if it's available, otherwise
13714 // we'll emit a shuffle and a arithmetic shift.
13715 // FIXME: Is the expansion actually better than scalar code? It doesn't seem so.
13716 // TODO: It is possible to support ZExt by zeroing the undef values during
13717 // the shuffle phase or after the shuffle.
13718 static SDValue LowerExtendedLoad(SDValue Op, const X86Subtarget *Subtarget,
13719                                  SelectionDAG &DAG) {
13720   MVT RegVT = Op.getSimpleValueType();
13721   assert(RegVT.isVector() && "We only custom lower vector sext loads.");
13722   assert(RegVT.isInteger() &&
13723          "We only custom lower integer vector sext loads.");
13724
13725   // Nothing useful we can do without SSE2 shuffles.
13726   assert(Subtarget->hasSSE2() && "We only custom lower sext loads with SSE2.");
13727
13728   LoadSDNode *Ld = cast<LoadSDNode>(Op.getNode());
13729   SDLoc dl(Ld);
13730   EVT MemVT = Ld->getMemoryVT();
13731   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13732   unsigned RegSz = RegVT.getSizeInBits();
13733
13734   ISD::LoadExtType Ext = Ld->getExtensionType();
13735
13736   assert((Ext == ISD::EXTLOAD || Ext == ISD::SEXTLOAD)
13737          && "Only anyext and sext are currently implemented.");
13738   assert(MemVT != RegVT && "Cannot extend to the same type");
13739   assert(MemVT.isVector() && "Must load a vector from memory");
13740
13741   unsigned NumElems = RegVT.getVectorNumElements();
13742   unsigned MemSz = MemVT.getSizeInBits();
13743   assert(RegSz > MemSz && "Register size must be greater than the mem size");
13744
13745   if (Ext == ISD::SEXTLOAD && RegSz == 256 && !Subtarget->hasInt256()) {
13746     // The only way in which we have a legal 256-bit vector result but not the
13747     // integer 256-bit operations needed to directly lower a sextload is if we
13748     // have AVX1 but not AVX2. In that case, we can always emit a sextload to
13749     // a 128-bit vector and a normal sign_extend to 256-bits that should get
13750     // correctly legalized. We do this late to allow the canonical form of
13751     // sextload to persist throughout the rest of the DAG combiner -- it wants
13752     // to fold together any extensions it can, and so will fuse a sign_extend
13753     // of an sextload into a sextload targeting a wider value.
13754     SDValue Load;
13755     if (MemSz == 128) {
13756       // Just switch this to a normal load.
13757       assert(TLI.isTypeLegal(MemVT) && "If the memory type is a 128-bit type, "
13758                                        "it must be a legal 128-bit vector "
13759                                        "type!");
13760       Load = DAG.getLoad(MemVT, dl, Ld->getChain(), Ld->getBasePtr(),
13761                   Ld->getPointerInfo(), Ld->isVolatile(), Ld->isNonTemporal(),
13762                   Ld->isInvariant(), Ld->getAlignment());
13763     } else {
13764       assert(MemSz < 128 &&
13765              "Can't extend a type wider than 128 bits to a 256 bit vector!");
13766       // Do an sext load to a 128-bit vector type. We want to use the same
13767       // number of elements, but elements half as wide. This will end up being
13768       // recursively lowered by this routine, but will succeed as we definitely
13769       // have all the necessary features if we're using AVX1.
13770       EVT HalfEltVT =
13771           EVT::getIntegerVT(*DAG.getContext(), RegVT.getScalarSizeInBits() / 2);
13772       EVT HalfVecVT = EVT::getVectorVT(*DAG.getContext(), HalfEltVT, NumElems);
13773       Load =
13774           DAG.getExtLoad(Ext, dl, HalfVecVT, Ld->getChain(), Ld->getBasePtr(),
13775                          Ld->getPointerInfo(), MemVT, Ld->isVolatile(),
13776                          Ld->isNonTemporal(), Ld->isInvariant(),
13777                          Ld->getAlignment());
13778     }
13779
13780     // Replace chain users with the new chain.
13781     assert(Load->getNumValues() == 2 && "Loads must carry a chain!");
13782     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), Load.getValue(1));
13783
13784     // Finally, do a normal sign-extend to the desired register.
13785     return DAG.getSExtOrTrunc(Load, dl, RegVT);
13786   }
13787
13788   // All sizes must be a power of two.
13789   assert(isPowerOf2_32(RegSz * MemSz * NumElems) &&
13790          "Non-power-of-two elements are not custom lowered!");
13791
13792   // Attempt to load the original value using scalar loads.
13793   // Find the largest scalar type that divides the total loaded size.
13794   MVT SclrLoadTy = MVT::i8;
13795   for (MVT Tp : MVT::integer_valuetypes()) {
13796     if (TLI.isTypeLegal(Tp) && ((MemSz % Tp.getSizeInBits()) == 0)) {
13797       SclrLoadTy = Tp;
13798     }
13799   }
13800
13801   // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
13802   if (TLI.isTypeLegal(MVT::f64) && SclrLoadTy.getSizeInBits() < 64 &&
13803       (64 <= MemSz))
13804     SclrLoadTy = MVT::f64;
13805
13806   // Calculate the number of scalar loads that we need to perform
13807   // in order to load our vector from memory.
13808   unsigned NumLoads = MemSz / SclrLoadTy.getSizeInBits();
13809
13810   assert((Ext != ISD::SEXTLOAD || NumLoads == 1) &&
13811          "Can only lower sext loads with a single scalar load!");
13812
13813   unsigned loadRegZize = RegSz;
13814   if (Ext == ISD::SEXTLOAD && RegSz == 256)
13815     loadRegZize /= 2;
13816
13817   // Represent our vector as a sequence of elements which are the
13818   // largest scalar that we can load.
13819   EVT LoadUnitVecVT = EVT::getVectorVT(
13820       *DAG.getContext(), SclrLoadTy, loadRegZize / SclrLoadTy.getSizeInBits());
13821
13822   // Represent the data using the same element type that is stored in
13823   // memory. In practice, we ''widen'' MemVT.
13824   EVT WideVecVT =
13825       EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
13826                        loadRegZize / MemVT.getScalarType().getSizeInBits());
13827
13828   assert(WideVecVT.getSizeInBits() == LoadUnitVecVT.getSizeInBits() &&
13829          "Invalid vector type");
13830
13831   // We can't shuffle using an illegal type.
13832   assert(TLI.isTypeLegal(WideVecVT) &&
13833          "We only lower types that form legal widened vector types");
13834
13835   SmallVector<SDValue, 8> Chains;
13836   SDValue Ptr = Ld->getBasePtr();
13837   SDValue Increment =
13838       DAG.getConstant(SclrLoadTy.getSizeInBits() / 8, TLI.getPointerTy());
13839   SDValue Res = DAG.getUNDEF(LoadUnitVecVT);
13840
13841   for (unsigned i = 0; i < NumLoads; ++i) {
13842     // Perform a single load.
13843     SDValue ScalarLoad =
13844         DAG.getLoad(SclrLoadTy, dl, Ld->getChain(), Ptr, Ld->getPointerInfo(),
13845                     Ld->isVolatile(), Ld->isNonTemporal(), Ld->isInvariant(),
13846                     Ld->getAlignment());
13847     Chains.push_back(ScalarLoad.getValue(1));
13848     // Create the first element type using SCALAR_TO_VECTOR in order to avoid
13849     // another round of DAGCombining.
13850     if (i == 0)
13851       Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoadUnitVecVT, ScalarLoad);
13852     else
13853       Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, LoadUnitVecVT, Res,
13854                         ScalarLoad, DAG.getIntPtrConstant(i));
13855
13856     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
13857   }
13858
13859   SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
13860
13861   // Bitcast the loaded value to a vector of the original element type, in
13862   // the size of the target vector type.
13863   SDValue SlicedVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Res);
13864   unsigned SizeRatio = RegSz / MemSz;
13865
13866   if (Ext == ISD::SEXTLOAD) {
13867     // If we have SSE4.1, we can directly emit a VSEXT node.
13868     if (Subtarget->hasSSE41()) {
13869       SDValue Sext = DAG.getNode(X86ISD::VSEXT, dl, RegVT, SlicedVec);
13870       DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
13871       return Sext;
13872     }
13873
13874     // Otherwise we'll shuffle the small elements in the high bits of the
13875     // larger type and perform an arithmetic shift. If the shift is not legal
13876     // it's better to scalarize.
13877     assert(TLI.isOperationLegalOrCustom(ISD::SRA, RegVT) &&
13878            "We can't implement a sext load without an arithmetic right shift!");
13879
13880     // Redistribute the loaded elements into the different locations.
13881     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
13882     for (unsigned i = 0; i != NumElems; ++i)
13883       ShuffleVec[i * SizeRatio + SizeRatio - 1] = i;
13884
13885     SDValue Shuff = DAG.getVectorShuffle(
13886         WideVecVT, dl, SlicedVec, DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
13887
13888     Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
13889
13890     // Build the arithmetic shift.
13891     unsigned Amt = RegVT.getVectorElementType().getSizeInBits() -
13892                    MemVT.getVectorElementType().getSizeInBits();
13893     Shuff =
13894         DAG.getNode(ISD::SRA, dl, RegVT, Shuff, DAG.getConstant(Amt, RegVT));
13895
13896     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
13897     return Shuff;
13898   }
13899
13900   // Redistribute the loaded elements into the different locations.
13901   SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
13902   for (unsigned i = 0; i != NumElems; ++i)
13903     ShuffleVec[i * SizeRatio] = i;
13904
13905   SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, SlicedVec,
13906                                        DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
13907
13908   // Bitcast to the requested type.
13909   Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
13910   DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
13911   return Shuff;
13912 }
13913
13914 // isAndOrOfSingleUseSetCCs - Return true if node is an ISD::AND or
13915 // ISD::OR of two X86ISD::SETCC nodes each of which has no other use apart
13916 // from the AND / OR.
13917 static bool isAndOrOfSetCCs(SDValue Op, unsigned &Opc) {
13918   Opc = Op.getOpcode();
13919   if (Opc != ISD::OR && Opc != ISD::AND)
13920     return false;
13921   return (Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
13922           Op.getOperand(0).hasOneUse() &&
13923           Op.getOperand(1).getOpcode() == X86ISD::SETCC &&
13924           Op.getOperand(1).hasOneUse());
13925 }
13926
13927 // isXor1OfSetCC - Return true if node is an ISD::XOR of a X86ISD::SETCC and
13928 // 1 and that the SETCC node has a single use.
13929 static bool isXor1OfSetCC(SDValue Op) {
13930   if (Op.getOpcode() != ISD::XOR)
13931     return false;
13932   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
13933   if (N1C && N1C->getAPIntValue() == 1) {
13934     return Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
13935       Op.getOperand(0).hasOneUse();
13936   }
13937   return false;
13938 }
13939
13940 SDValue X86TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
13941   bool addTest = true;
13942   SDValue Chain = Op.getOperand(0);
13943   SDValue Cond  = Op.getOperand(1);
13944   SDValue Dest  = Op.getOperand(2);
13945   SDLoc dl(Op);
13946   SDValue CC;
13947   bool Inverted = false;
13948
13949   if (Cond.getOpcode() == ISD::SETCC) {
13950     // Check for setcc([su]{add,sub,mul}o == 0).
13951     if (cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETEQ &&
13952         isa<ConstantSDNode>(Cond.getOperand(1)) &&
13953         cast<ConstantSDNode>(Cond.getOperand(1))->isNullValue() &&
13954         Cond.getOperand(0).getResNo() == 1 &&
13955         (Cond.getOperand(0).getOpcode() == ISD::SADDO ||
13956          Cond.getOperand(0).getOpcode() == ISD::UADDO ||
13957          Cond.getOperand(0).getOpcode() == ISD::SSUBO ||
13958          Cond.getOperand(0).getOpcode() == ISD::USUBO ||
13959          Cond.getOperand(0).getOpcode() == ISD::SMULO ||
13960          Cond.getOperand(0).getOpcode() == ISD::UMULO)) {
13961       Inverted = true;
13962       Cond = Cond.getOperand(0);
13963     } else {
13964       SDValue NewCond = LowerSETCC(Cond, DAG);
13965       if (NewCond.getNode())
13966         Cond = NewCond;
13967     }
13968   }
13969 #if 0
13970   // FIXME: LowerXALUO doesn't handle these!!
13971   else if (Cond.getOpcode() == X86ISD::ADD  ||
13972            Cond.getOpcode() == X86ISD::SUB  ||
13973            Cond.getOpcode() == X86ISD::SMUL ||
13974            Cond.getOpcode() == X86ISD::UMUL)
13975     Cond = LowerXALUO(Cond, DAG);
13976 #endif
13977
13978   // Look pass (and (setcc_carry (cmp ...)), 1).
13979   if (Cond.getOpcode() == ISD::AND &&
13980       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
13981     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
13982     if (C && C->getAPIntValue() == 1)
13983       Cond = Cond.getOperand(0);
13984   }
13985
13986   // If condition flag is set by a X86ISD::CMP, then use it as the condition
13987   // setting operand in place of the X86ISD::SETCC.
13988   unsigned CondOpcode = Cond.getOpcode();
13989   if (CondOpcode == X86ISD::SETCC ||
13990       CondOpcode == X86ISD::SETCC_CARRY) {
13991     CC = Cond.getOperand(0);
13992
13993     SDValue Cmp = Cond.getOperand(1);
13994     unsigned Opc = Cmp.getOpcode();
13995     // FIXME: WHY THE SPECIAL CASING OF LogicalCmp??
13996     if (isX86LogicalCmp(Cmp) || Opc == X86ISD::BT) {
13997       Cond = Cmp;
13998       addTest = false;
13999     } else {
14000       switch (cast<ConstantSDNode>(CC)->getZExtValue()) {
14001       default: break;
14002       case X86::COND_O:
14003       case X86::COND_B:
14004         // These can only come from an arithmetic instruction with overflow,
14005         // e.g. SADDO, UADDO.
14006         Cond = Cond.getNode()->getOperand(1);
14007         addTest = false;
14008         break;
14009       }
14010     }
14011   }
14012   CondOpcode = Cond.getOpcode();
14013   if (CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
14014       CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
14015       ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
14016        Cond.getOperand(0).getValueType() != MVT::i8)) {
14017     SDValue LHS = Cond.getOperand(0);
14018     SDValue RHS = Cond.getOperand(1);
14019     unsigned X86Opcode;
14020     unsigned X86Cond;
14021     SDVTList VTs;
14022     // Keep this in sync with LowerXALUO, otherwise we might create redundant
14023     // instructions that can't be removed afterwards (i.e. X86ISD::ADD and
14024     // X86ISD::INC).
14025     switch (CondOpcode) {
14026     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
14027     case ISD::SADDO:
14028       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
14029         if (C->isOne()) {
14030           X86Opcode = X86ISD::INC; X86Cond = X86::COND_O;
14031           break;
14032         }
14033       X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
14034     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
14035     case ISD::SSUBO:
14036       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
14037         if (C->isOne()) {
14038           X86Opcode = X86ISD::DEC; X86Cond = X86::COND_O;
14039           break;
14040         }
14041       X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
14042     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
14043     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
14044     default: llvm_unreachable("unexpected overflowing operator");
14045     }
14046     if (Inverted)
14047       X86Cond = X86::GetOppositeBranchCondition((X86::CondCode)X86Cond);
14048     if (CondOpcode == ISD::UMULO)
14049       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
14050                           MVT::i32);
14051     else
14052       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
14053
14054     SDValue X86Op = DAG.getNode(X86Opcode, dl, VTs, LHS, RHS);
14055
14056     if (CondOpcode == ISD::UMULO)
14057       Cond = X86Op.getValue(2);
14058     else
14059       Cond = X86Op.getValue(1);
14060
14061     CC = DAG.getConstant(X86Cond, MVT::i8);
14062     addTest = false;
14063   } else {
14064     unsigned CondOpc;
14065     if (Cond.hasOneUse() && isAndOrOfSetCCs(Cond, CondOpc)) {
14066       SDValue Cmp = Cond.getOperand(0).getOperand(1);
14067       if (CondOpc == ISD::OR) {
14068         // Also, recognize the pattern generated by an FCMP_UNE. We can emit
14069         // two branches instead of an explicit OR instruction with a
14070         // separate test.
14071         if (Cmp == Cond.getOperand(1).getOperand(1) &&
14072             isX86LogicalCmp(Cmp)) {
14073           CC = Cond.getOperand(0).getOperand(0);
14074           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
14075                               Chain, Dest, CC, Cmp);
14076           CC = Cond.getOperand(1).getOperand(0);
14077           Cond = Cmp;
14078           addTest = false;
14079         }
14080       } else { // ISD::AND
14081         // Also, recognize the pattern generated by an FCMP_OEQ. We can emit
14082         // two branches instead of an explicit AND instruction with a
14083         // separate test. However, we only do this if this block doesn't
14084         // have a fall-through edge, because this requires an explicit
14085         // jmp when the condition is false.
14086         if (Cmp == Cond.getOperand(1).getOperand(1) &&
14087             isX86LogicalCmp(Cmp) &&
14088             Op.getNode()->hasOneUse()) {
14089           X86::CondCode CCode =
14090             (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
14091           CCode = X86::GetOppositeBranchCondition(CCode);
14092           CC = DAG.getConstant(CCode, MVT::i8);
14093           SDNode *User = *Op.getNode()->use_begin();
14094           // Look for an unconditional branch following this conditional branch.
14095           // We need this because we need to reverse the successors in order
14096           // to implement FCMP_OEQ.
14097           if (User->getOpcode() == ISD::BR) {
14098             SDValue FalseBB = User->getOperand(1);
14099             SDNode *NewBR =
14100               DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
14101             assert(NewBR == User);
14102             (void)NewBR;
14103             Dest = FalseBB;
14104
14105             Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
14106                                 Chain, Dest, CC, Cmp);
14107             X86::CondCode CCode =
14108               (X86::CondCode)Cond.getOperand(1).getConstantOperandVal(0);
14109             CCode = X86::GetOppositeBranchCondition(CCode);
14110             CC = DAG.getConstant(CCode, MVT::i8);
14111             Cond = Cmp;
14112             addTest = false;
14113           }
14114         }
14115       }
14116     } else if (Cond.hasOneUse() && isXor1OfSetCC(Cond)) {
14117       // Recognize for xorb (setcc), 1 patterns. The xor inverts the condition.
14118       // It should be transformed during dag combiner except when the condition
14119       // is set by a arithmetics with overflow node.
14120       X86::CondCode CCode =
14121         (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
14122       CCode = X86::GetOppositeBranchCondition(CCode);
14123       CC = DAG.getConstant(CCode, MVT::i8);
14124       Cond = Cond.getOperand(0).getOperand(1);
14125       addTest = false;
14126     } else if (Cond.getOpcode() == ISD::SETCC &&
14127                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETOEQ) {
14128       // For FCMP_OEQ, we can emit
14129       // two branches instead of an explicit AND instruction with a
14130       // separate test. However, we only do this if this block doesn't
14131       // have a fall-through edge, because this requires an explicit
14132       // jmp when the condition is false.
14133       if (Op.getNode()->hasOneUse()) {
14134         SDNode *User = *Op.getNode()->use_begin();
14135         // Look for an unconditional branch following this conditional branch.
14136         // We need this because we need to reverse the successors in order
14137         // to implement FCMP_OEQ.
14138         if (User->getOpcode() == ISD::BR) {
14139           SDValue FalseBB = User->getOperand(1);
14140           SDNode *NewBR =
14141             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
14142           assert(NewBR == User);
14143           (void)NewBR;
14144           Dest = FalseBB;
14145
14146           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
14147                                     Cond.getOperand(0), Cond.getOperand(1));
14148           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
14149           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
14150           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
14151                               Chain, Dest, CC, Cmp);
14152           CC = DAG.getConstant(X86::COND_P, MVT::i8);
14153           Cond = Cmp;
14154           addTest = false;
14155         }
14156       }
14157     } else if (Cond.getOpcode() == ISD::SETCC &&
14158                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETUNE) {
14159       // For FCMP_UNE, we can emit
14160       // two branches instead of an explicit AND instruction with a
14161       // separate test. However, we only do this if this block doesn't
14162       // have a fall-through edge, because this requires an explicit
14163       // jmp when the condition is false.
14164       if (Op.getNode()->hasOneUse()) {
14165         SDNode *User = *Op.getNode()->use_begin();
14166         // Look for an unconditional branch following this conditional branch.
14167         // We need this because we need to reverse the successors in order
14168         // to implement FCMP_UNE.
14169         if (User->getOpcode() == ISD::BR) {
14170           SDValue FalseBB = User->getOperand(1);
14171           SDNode *NewBR =
14172             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
14173           assert(NewBR == User);
14174           (void)NewBR;
14175
14176           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
14177                                     Cond.getOperand(0), Cond.getOperand(1));
14178           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
14179           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
14180           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
14181                               Chain, Dest, CC, Cmp);
14182           CC = DAG.getConstant(X86::COND_NP, MVT::i8);
14183           Cond = Cmp;
14184           addTest = false;
14185           Dest = FalseBB;
14186         }
14187       }
14188     }
14189   }
14190
14191   if (addTest) {
14192     // Look pass the truncate if the high bits are known zero.
14193     if (isTruncWithZeroHighBitsInput(Cond, DAG))
14194         Cond = Cond.getOperand(0);
14195
14196     // We know the result of AND is compared against zero. Try to match
14197     // it to BT.
14198     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
14199       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, dl, DAG);
14200       if (NewSetCC.getNode()) {
14201         CC = NewSetCC.getOperand(0);
14202         Cond = NewSetCC.getOperand(1);
14203         addTest = false;
14204       }
14205     }
14206   }
14207
14208   if (addTest) {
14209     X86::CondCode X86Cond = Inverted ? X86::COND_E : X86::COND_NE;
14210     CC = DAG.getConstant(X86Cond, MVT::i8);
14211     Cond = EmitTest(Cond, X86Cond, dl, DAG);
14212   }
14213   Cond = ConvertCmpIfNecessary(Cond, DAG);
14214   return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
14215                      Chain, Dest, CC, Cond);
14216 }
14217
14218 // Lower dynamic stack allocation to _alloca call for Cygwin/Mingw targets.
14219 // Calls to _alloca are needed to probe the stack when allocating more than 4k
14220 // bytes in one go. Touching the stack at 4K increments is necessary to ensure
14221 // that the guard pages used by the OS virtual memory manager are allocated in
14222 // correct sequence.
14223 SDValue
14224 X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
14225                                            SelectionDAG &DAG) const {
14226   MachineFunction &MF = DAG.getMachineFunction();
14227   bool SplitStack = MF.shouldSplitStack();
14228   bool Lower = (Subtarget->isOSWindows() && !Subtarget->isTargetMachO()) ||
14229                SplitStack;
14230   SDLoc dl(Op);
14231
14232   if (!Lower) {
14233     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14234     SDNode* Node = Op.getNode();
14235
14236     unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore();
14237     assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and"
14238         " not tell us which reg is the stack pointer!");
14239     EVT VT = Node->getValueType(0);
14240     SDValue Tmp1 = SDValue(Node, 0);
14241     SDValue Tmp2 = SDValue(Node, 1);
14242     SDValue Tmp3 = Node->getOperand(2);
14243     SDValue Chain = Tmp1.getOperand(0);
14244
14245     // Chain the dynamic stack allocation so that it doesn't modify the stack
14246     // pointer when other instructions are using the stack.
14247     Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true),
14248         SDLoc(Node));
14249
14250     SDValue Size = Tmp2.getOperand(1);
14251     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
14252     Chain = SP.getValue(1);
14253     unsigned Align = cast<ConstantSDNode>(Tmp3)->getZExtValue();
14254     const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
14255     unsigned StackAlign = TFI.getStackAlignment();
14256     Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
14257     if (Align > StackAlign)
14258       Tmp1 = DAG.getNode(ISD::AND, dl, VT, Tmp1,
14259           DAG.getConstant(-(uint64_t)Align, VT));
14260     Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain
14261
14262     Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true),
14263         DAG.getIntPtrConstant(0, true), SDValue(),
14264         SDLoc(Node));
14265
14266     SDValue Ops[2] = { Tmp1, Tmp2 };
14267     return DAG.getMergeValues(Ops, dl);
14268   }
14269
14270   // Get the inputs.
14271   SDValue Chain = Op.getOperand(0);
14272   SDValue Size  = Op.getOperand(1);
14273   unsigned Align = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue();
14274   EVT VT = Op.getNode()->getValueType(0);
14275
14276   bool Is64Bit = Subtarget->is64Bit();
14277   EVT SPTy = getPointerTy();
14278
14279   if (SplitStack) {
14280     MachineRegisterInfo &MRI = MF.getRegInfo();
14281
14282     if (Is64Bit) {
14283       // The 64 bit implementation of segmented stacks needs to clobber both r10
14284       // r11. This makes it impossible to use it along with nested parameters.
14285       const Function *F = MF.getFunction();
14286
14287       for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
14288            I != E; ++I)
14289         if (I->hasNestAttr())
14290           report_fatal_error("Cannot use segmented stacks with functions that "
14291                              "have nested arguments.");
14292     }
14293
14294     const TargetRegisterClass *AddrRegClass =
14295       getRegClassFor(getPointerTy());
14296     unsigned Vreg = MRI.createVirtualRegister(AddrRegClass);
14297     Chain = DAG.getCopyToReg(Chain, dl, Vreg, Size);
14298     SDValue Value = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
14299                                 DAG.getRegister(Vreg, SPTy));
14300     SDValue Ops1[2] = { Value, Chain };
14301     return DAG.getMergeValues(Ops1, dl);
14302   } else {
14303     SDValue Flag;
14304     const unsigned Reg = (Subtarget->isTarget64BitLP64() ? X86::RAX : X86::EAX);
14305
14306     Chain = DAG.getCopyToReg(Chain, dl, Reg, Size, Flag);
14307     Flag = Chain.getValue(1);
14308     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
14309
14310     Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
14311
14312     const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
14313     unsigned SPReg = RegInfo->getStackRegister();
14314     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, SPTy);
14315     Chain = SP.getValue(1);
14316
14317     if (Align) {
14318       SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
14319                        DAG.getConstant(-(uint64_t)Align, VT));
14320       Chain = DAG.getCopyToReg(Chain, dl, SPReg, SP);
14321     }
14322
14323     SDValue Ops1[2] = { SP, Chain };
14324     return DAG.getMergeValues(Ops1, dl);
14325   }
14326 }
14327
14328 SDValue X86TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
14329   MachineFunction &MF = DAG.getMachineFunction();
14330   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
14331
14332   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
14333   SDLoc DL(Op);
14334
14335   if (!Subtarget->is64Bit() || Subtarget->isTargetWin64()) {
14336     // vastart just stores the address of the VarArgsFrameIndex slot into the
14337     // memory location argument.
14338     SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
14339                                    getPointerTy());
14340     return DAG.getStore(Op.getOperand(0), DL, FR, Op.getOperand(1),
14341                         MachinePointerInfo(SV), false, false, 0);
14342   }
14343
14344   // __va_list_tag:
14345   //   gp_offset         (0 - 6 * 8)
14346   //   fp_offset         (48 - 48 + 8 * 16)
14347   //   overflow_arg_area (point to parameters coming in memory).
14348   //   reg_save_area
14349   SmallVector<SDValue, 8> MemOps;
14350   SDValue FIN = Op.getOperand(1);
14351   // Store gp_offset
14352   SDValue Store = DAG.getStore(Op.getOperand(0), DL,
14353                                DAG.getConstant(FuncInfo->getVarArgsGPOffset(),
14354                                                MVT::i32),
14355                                FIN, MachinePointerInfo(SV), false, false, 0);
14356   MemOps.push_back(Store);
14357
14358   // Store fp_offset
14359   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
14360                     FIN, DAG.getIntPtrConstant(4));
14361   Store = DAG.getStore(Op.getOperand(0), DL,
14362                        DAG.getConstant(FuncInfo->getVarArgsFPOffset(),
14363                                        MVT::i32),
14364                        FIN, MachinePointerInfo(SV, 4), false, false, 0);
14365   MemOps.push_back(Store);
14366
14367   // Store ptr to overflow_arg_area
14368   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
14369                     FIN, DAG.getIntPtrConstant(4));
14370   SDValue OVFIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
14371                                     getPointerTy());
14372   Store = DAG.getStore(Op.getOperand(0), DL, OVFIN, FIN,
14373                        MachinePointerInfo(SV, 8),
14374                        false, false, 0);
14375   MemOps.push_back(Store);
14376
14377   // Store ptr to reg_save_area.
14378   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
14379                     FIN, DAG.getIntPtrConstant(8));
14380   SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
14381                                     getPointerTy());
14382   Store = DAG.getStore(Op.getOperand(0), DL, RSFIN, FIN,
14383                        MachinePointerInfo(SV, 16), false, false, 0);
14384   MemOps.push_back(Store);
14385   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
14386 }
14387
14388 SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
14389   assert(Subtarget->is64Bit() &&
14390          "LowerVAARG only handles 64-bit va_arg!");
14391   assert((Subtarget->isTargetLinux() ||
14392           Subtarget->isTargetDarwin()) &&
14393           "Unhandled target in LowerVAARG");
14394   assert(Op.getNode()->getNumOperands() == 4);
14395   SDValue Chain = Op.getOperand(0);
14396   SDValue SrcPtr = Op.getOperand(1);
14397   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
14398   unsigned Align = Op.getConstantOperandVal(3);
14399   SDLoc dl(Op);
14400
14401   EVT ArgVT = Op.getNode()->getValueType(0);
14402   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
14403   uint32_t ArgSize = getDataLayout()->getTypeAllocSize(ArgTy);
14404   uint8_t ArgMode;
14405
14406   // Decide which area this value should be read from.
14407   // TODO: Implement the AMD64 ABI in its entirety. This simple
14408   // selection mechanism works only for the basic types.
14409   if (ArgVT == MVT::f80) {
14410     llvm_unreachable("va_arg for f80 not yet implemented");
14411   } else if (ArgVT.isFloatingPoint() && ArgSize <= 16 /*bytes*/) {
14412     ArgMode = 2;  // Argument passed in XMM register. Use fp_offset.
14413   } else if (ArgVT.isInteger() && ArgSize <= 32 /*bytes*/) {
14414     ArgMode = 1;  // Argument passed in GPR64 register(s). Use gp_offset.
14415   } else {
14416     llvm_unreachable("Unhandled argument type in LowerVAARG");
14417   }
14418
14419   if (ArgMode == 2) {
14420     // Sanity Check: Make sure using fp_offset makes sense.
14421     assert(!DAG.getTarget().Options.UseSoftFloat &&
14422            !(DAG.getMachineFunction().getFunction()->hasFnAttribute(
14423                Attribute::NoImplicitFloat)) &&
14424            Subtarget->hasSSE1());
14425   }
14426
14427   // Insert VAARG_64 node into the DAG
14428   // VAARG_64 returns two values: Variable Argument Address, Chain
14429   SDValue InstOps[] = {Chain, SrcPtr, DAG.getConstant(ArgSize, MVT::i32),
14430                        DAG.getConstant(ArgMode, MVT::i8),
14431                        DAG.getConstant(Align, MVT::i32)};
14432   SDVTList VTs = DAG.getVTList(getPointerTy(), MVT::Other);
14433   SDValue VAARG = DAG.getMemIntrinsicNode(X86ISD::VAARG_64, dl,
14434                                           VTs, InstOps, MVT::i64,
14435                                           MachinePointerInfo(SV),
14436                                           /*Align=*/0,
14437                                           /*Volatile=*/false,
14438                                           /*ReadMem=*/true,
14439                                           /*WriteMem=*/true);
14440   Chain = VAARG.getValue(1);
14441
14442   // Load the next argument and return it
14443   return DAG.getLoad(ArgVT, dl,
14444                      Chain,
14445                      VAARG,
14446                      MachinePointerInfo(),
14447                      false, false, false, 0);
14448 }
14449
14450 static SDValue LowerVACOPY(SDValue Op, const X86Subtarget *Subtarget,
14451                            SelectionDAG &DAG) {
14452   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
14453   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_copy!");
14454   SDValue Chain = Op.getOperand(0);
14455   SDValue DstPtr = Op.getOperand(1);
14456   SDValue SrcPtr = Op.getOperand(2);
14457   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
14458   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
14459   SDLoc DL(Op);
14460
14461   return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr,
14462                        DAG.getIntPtrConstant(24), 8, /*isVolatile*/false,
14463                        false,
14464                        MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV));
14465 }
14466
14467 // getTargetVShiftByConstNode - Handle vector element shifts where the shift
14468 // amount is a constant. Takes immediate version of shift as input.
14469 static SDValue getTargetVShiftByConstNode(unsigned Opc, SDLoc dl, MVT VT,
14470                                           SDValue SrcOp, uint64_t ShiftAmt,
14471                                           SelectionDAG &DAG) {
14472   MVT ElementType = VT.getVectorElementType();
14473
14474   // Fold this packed shift into its first operand if ShiftAmt is 0.
14475   if (ShiftAmt == 0)
14476     return SrcOp;
14477
14478   // Check for ShiftAmt >= element width
14479   if (ShiftAmt >= ElementType.getSizeInBits()) {
14480     if (Opc == X86ISD::VSRAI)
14481       ShiftAmt = ElementType.getSizeInBits() - 1;
14482     else
14483       return DAG.getConstant(0, VT);
14484   }
14485
14486   assert((Opc == X86ISD::VSHLI || Opc == X86ISD::VSRLI || Opc == X86ISD::VSRAI)
14487          && "Unknown target vector shift-by-constant node");
14488
14489   // Fold this packed vector shift into a build vector if SrcOp is a
14490   // vector of Constants or UNDEFs, and SrcOp valuetype is the same as VT.
14491   if (VT == SrcOp.getSimpleValueType() &&
14492       ISD::isBuildVectorOfConstantSDNodes(SrcOp.getNode())) {
14493     SmallVector<SDValue, 8> Elts;
14494     unsigned NumElts = SrcOp->getNumOperands();
14495     ConstantSDNode *ND;
14496
14497     switch(Opc) {
14498     default: llvm_unreachable(nullptr);
14499     case X86ISD::VSHLI:
14500       for (unsigned i=0; i!=NumElts; ++i) {
14501         SDValue CurrentOp = SrcOp->getOperand(i);
14502         if (CurrentOp->getOpcode() == ISD::UNDEF) {
14503           Elts.push_back(CurrentOp);
14504           continue;
14505         }
14506         ND = cast<ConstantSDNode>(CurrentOp);
14507         const APInt &C = ND->getAPIntValue();
14508         Elts.push_back(DAG.getConstant(C.shl(ShiftAmt), ElementType));
14509       }
14510       break;
14511     case X86ISD::VSRLI:
14512       for (unsigned i=0; i!=NumElts; ++i) {
14513         SDValue CurrentOp = SrcOp->getOperand(i);
14514         if (CurrentOp->getOpcode() == ISD::UNDEF) {
14515           Elts.push_back(CurrentOp);
14516           continue;
14517         }
14518         ND = cast<ConstantSDNode>(CurrentOp);
14519         const APInt &C = ND->getAPIntValue();
14520         Elts.push_back(DAG.getConstant(C.lshr(ShiftAmt), ElementType));
14521       }
14522       break;
14523     case X86ISD::VSRAI:
14524       for (unsigned i=0; i!=NumElts; ++i) {
14525         SDValue CurrentOp = SrcOp->getOperand(i);
14526         if (CurrentOp->getOpcode() == ISD::UNDEF) {
14527           Elts.push_back(CurrentOp);
14528           continue;
14529         }
14530         ND = cast<ConstantSDNode>(CurrentOp);
14531         const APInt &C = ND->getAPIntValue();
14532         Elts.push_back(DAG.getConstant(C.ashr(ShiftAmt), ElementType));
14533       }
14534       break;
14535     }
14536
14537     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
14538   }
14539
14540   return DAG.getNode(Opc, dl, VT, SrcOp, DAG.getConstant(ShiftAmt, MVT::i8));
14541 }
14542
14543 // getTargetVShiftNode - Handle vector element shifts where the shift amount
14544 // may or may not be a constant. Takes immediate version of shift as input.
14545 static SDValue getTargetVShiftNode(unsigned Opc, SDLoc dl, MVT VT,
14546                                    SDValue SrcOp, SDValue ShAmt,
14547                                    SelectionDAG &DAG) {
14548   MVT SVT = ShAmt.getSimpleValueType();
14549   assert((SVT == MVT::i32 || SVT == MVT::i64) && "Unexpected value type!");
14550
14551   // Catch shift-by-constant.
14552   if (ConstantSDNode *CShAmt = dyn_cast<ConstantSDNode>(ShAmt))
14553     return getTargetVShiftByConstNode(Opc, dl, VT, SrcOp,
14554                                       CShAmt->getZExtValue(), DAG);
14555
14556   // Change opcode to non-immediate version
14557   switch (Opc) {
14558     default: llvm_unreachable("Unknown target vector shift node");
14559     case X86ISD::VSHLI: Opc = X86ISD::VSHL; break;
14560     case X86ISD::VSRLI: Opc = X86ISD::VSRL; break;
14561     case X86ISD::VSRAI: Opc = X86ISD::VSRA; break;
14562   }
14563
14564   const X86Subtarget &Subtarget =
14565       static_cast<const X86Subtarget &>(DAG.getSubtarget());
14566   if (Subtarget.hasSSE41() && ShAmt.getOpcode() == ISD::ZERO_EXTEND &&
14567       ShAmt.getOperand(0).getSimpleValueType() == MVT::i16) {
14568     // Let the shuffle legalizer expand this shift amount node.
14569     SDValue Op0 = ShAmt.getOperand(0);
14570     Op0 = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(Op0), MVT::v8i16, Op0);
14571     ShAmt = getShuffleVectorZeroOrUndef(Op0, 0, true, &Subtarget, DAG);
14572   } else {
14573     // Need to build a vector containing shift amount.
14574     // SSE/AVX packed shifts only use the lower 64-bit of the shift count.
14575     SmallVector<SDValue, 4> ShOps;
14576     ShOps.push_back(ShAmt);
14577     if (SVT == MVT::i32) {
14578       ShOps.push_back(DAG.getConstant(0, SVT));
14579       ShOps.push_back(DAG.getUNDEF(SVT));
14580     }
14581     ShOps.push_back(DAG.getUNDEF(SVT));
14582
14583     MVT BVT = SVT == MVT::i32 ? MVT::v4i32 : MVT::v2i64;
14584     ShAmt = DAG.getNode(ISD::BUILD_VECTOR, dl, BVT, ShOps);
14585   }
14586
14587   // The return type has to be a 128-bit type with the same element
14588   // type as the input type.
14589   MVT EltVT = VT.getVectorElementType();
14590   EVT ShVT = MVT::getVectorVT(EltVT, 128/EltVT.getSizeInBits());
14591
14592   ShAmt = DAG.getNode(ISD::BITCAST, dl, ShVT, ShAmt);
14593   return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
14594 }
14595
14596 /// \brief Return (and \p Op, \p Mask) for compare instructions or
14597 /// (vselect \p Mask, \p Op, \p PreservedSrc) for others along with the
14598 /// necessary casting for \p Mask when lowering masking intrinsics.
14599 static SDValue getVectorMaskingNode(SDValue Op, SDValue Mask,
14600                                     SDValue PreservedSrc,
14601                                     const X86Subtarget *Subtarget,
14602                                     SelectionDAG &DAG) {
14603     EVT VT = Op.getValueType();
14604     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(),
14605                                   MVT::i1, VT.getVectorNumElements());
14606     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
14607                                      Mask.getValueType().getSizeInBits());
14608     SDLoc dl(Op);
14609
14610     assert(MaskVT.isSimple() && "invalid mask type");
14611
14612     if (isAllOnes(Mask))
14613       return Op;
14614
14615     // In case when MaskVT equals v2i1 or v4i1, low 2 or 4 elements
14616     // are extracted by EXTRACT_SUBVECTOR.
14617     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
14618                               DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
14619                               DAG.getIntPtrConstant(0));
14620
14621     switch (Op.getOpcode()) {
14622       default: break;
14623       case X86ISD::PCMPEQM:
14624       case X86ISD::PCMPGTM:
14625       case X86ISD::CMPM:
14626       case X86ISD::CMPMU:
14627         return DAG.getNode(ISD::AND, dl, VT, Op, VMask);
14628     }
14629     if (PreservedSrc.getOpcode() == ISD::UNDEF)
14630       PreservedSrc = getZeroVector(VT, Subtarget, DAG, dl);
14631     return DAG.getNode(ISD::VSELECT, dl, VT, VMask, Op, PreservedSrc);
14632 }
14633
14634 /// \brief Creates an SDNode for a predicated scalar operation.
14635 /// \returns (X86vselect \p Mask, \p Op, \p PreservedSrc).
14636 /// The mask is comming as MVT::i8 and it should be truncated
14637 /// to MVT::i1 while lowering masking intrinsics.
14638 /// The main difference between ScalarMaskingNode and VectorMaskingNode is using
14639 /// "X86select" instead of "vselect". We just can't create the "vselect" node for
14640 /// a scalar instruction.
14641 static SDValue getScalarMaskingNode(SDValue Op, SDValue Mask,
14642                                     SDValue PreservedSrc,
14643                                     const X86Subtarget *Subtarget,
14644                                     SelectionDAG &DAG) {
14645     if (isAllOnes(Mask))
14646       return Op;
14647
14648     EVT VT = Op.getValueType();
14649     SDLoc dl(Op);
14650     // The mask should be of type MVT::i1
14651     SDValue IMask = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, Mask);
14652
14653     if (PreservedSrc.getOpcode() == ISD::UNDEF)
14654       PreservedSrc = getZeroVector(VT, Subtarget, DAG, dl);
14655     return DAG.getNode(X86ISD::SELECT, dl, VT, IMask, Op, PreservedSrc);
14656 }
14657
14658 static SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
14659                                        SelectionDAG &DAG) {
14660   SDLoc dl(Op);
14661   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
14662   EVT VT = Op.getValueType();
14663   const IntrinsicData* IntrData = getIntrinsicWithoutChain(IntNo);
14664   if (IntrData) {
14665     switch(IntrData->Type) {
14666     case INTR_TYPE_1OP:
14667       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1));
14668     case INTR_TYPE_2OP:
14669       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1),
14670         Op.getOperand(2));
14671     case INTR_TYPE_3OP:
14672       return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1),
14673         Op.getOperand(2), Op.getOperand(3));
14674     case INTR_TYPE_1OP_MASK_RM: {
14675       SDValue Src = Op.getOperand(1);
14676       SDValue Src0 = Op.getOperand(2);
14677       SDValue Mask = Op.getOperand(3);
14678       SDValue RoundingMode = Op.getOperand(4);
14679       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src,
14680                                               RoundingMode),
14681                                   Mask, Src0, Subtarget, DAG);
14682     }
14683     case INTR_TYPE_SCALAR_MASK_RM: {
14684       SDValue Src1 = Op.getOperand(1);
14685       SDValue Src2 = Op.getOperand(2);
14686       SDValue Src0 = Op.getOperand(3);
14687       SDValue Mask = Op.getOperand(4);
14688       // There are 2 kinds of intrinsics in this group:
14689       // (1) With supress-all-exceptions (sae) - 6 operands
14690       // (2) With rounding mode and sae - 7 operands.
14691       if (Op.getNumOperands() == 6) {
14692         SDValue Sae  = Op.getOperand(5);
14693         return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2,
14694                                                 Sae),
14695                                     Mask, Src0, Subtarget, DAG);
14696       }
14697       assert(Op.getNumOperands() == 7 && "Unexpected intrinsic form");
14698       SDValue RoundingMode  = Op.getOperand(5);
14699       SDValue Sae  = Op.getOperand(6);
14700       return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2,
14701                                               RoundingMode, Sae),
14702                                   Mask, Src0, Subtarget, DAG);
14703     }
14704     case INTR_TYPE_2OP_MASK: {
14705       SDValue Src1 = Op.getOperand(1);
14706       SDValue Src2 = Op.getOperand(2);
14707       SDValue PassThru = Op.getOperand(3);
14708       SDValue Mask = Op.getOperand(4);
14709       // We specify 2 possible opcodes for intrinsics with rounding modes.
14710       // First, we check if the intrinsic may have non-default rounding mode,
14711       // (IntrData->Opc1 != 0), then we check the rounding mode operand.
14712       unsigned IntrWithRoundingModeOpcode = IntrData->Opc1;
14713       if (IntrWithRoundingModeOpcode != 0) {
14714         SDValue Rnd = Op.getOperand(5);
14715         unsigned Round = cast<ConstantSDNode>(Rnd)->getZExtValue();
14716         if (Round != X86::STATIC_ROUNDING::CUR_DIRECTION) {
14717           return getVectorMaskingNode(DAG.getNode(IntrWithRoundingModeOpcode,
14718                                       dl, Op.getValueType(),
14719                                       Src1, Src2, Rnd),
14720                                       Mask, PassThru, Subtarget, DAG);
14721         }
14722       }
14723       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT,
14724                                               Src1,Src2),
14725                                   Mask, PassThru, Subtarget, DAG);
14726     }
14727     case FMA_OP_MASK: {
14728       SDValue Src1 = Op.getOperand(1);
14729       SDValue Src2 = Op.getOperand(2);
14730       SDValue Src3 = Op.getOperand(3);
14731       SDValue Mask = Op.getOperand(4);
14732       // We specify 2 possible opcodes for intrinsics with rounding modes.
14733       // First, we check if the intrinsic may have non-default rounding mode,
14734       // (IntrData->Opc1 != 0), then we check the rounding mode operand.
14735       unsigned IntrWithRoundingModeOpcode = IntrData->Opc1;
14736       if (IntrWithRoundingModeOpcode != 0) {
14737         SDValue Rnd = Op.getOperand(5);
14738         if (cast<ConstantSDNode>(Rnd)->getZExtValue() !=
14739             X86::STATIC_ROUNDING::CUR_DIRECTION)
14740           return getVectorMaskingNode(DAG.getNode(IntrWithRoundingModeOpcode,
14741                                                   dl, Op.getValueType(),
14742                                                   Src1, Src2, Src3, Rnd),
14743                                       Mask, Src1, Subtarget, DAG);
14744       }
14745       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0,
14746                                               dl, Op.getValueType(),
14747                                               Src1, Src2, Src3),
14748                                   Mask, Src1, Subtarget, DAG);
14749     }
14750     case CMP_MASK:
14751     case CMP_MASK_CC: {
14752       // Comparison intrinsics with masks.
14753       // Example of transformation:
14754       // (i8 (int_x86_avx512_mask_pcmpeq_q_128
14755       //             (v2i64 %a), (v2i64 %b), (i8 %mask))) ->
14756       // (i8 (bitcast
14757       //   (v8i1 (insert_subvector undef,
14758       //           (v2i1 (and (PCMPEQM %a, %b),
14759       //                      (extract_subvector
14760       //                         (v8i1 (bitcast %mask)), 0))), 0))))
14761       EVT VT = Op.getOperand(1).getValueType();
14762       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
14763                                     VT.getVectorNumElements());
14764       SDValue Mask = Op.getOperand((IntrData->Type == CMP_MASK_CC) ? 4 : 3);
14765       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
14766                                        Mask.getValueType().getSizeInBits());
14767       SDValue Cmp;
14768       if (IntrData->Type == CMP_MASK_CC) {
14769         Cmp = DAG.getNode(IntrData->Opc0, dl, MaskVT, Op.getOperand(1),
14770                     Op.getOperand(2), Op.getOperand(3));
14771       } else {
14772         assert(IntrData->Type == CMP_MASK && "Unexpected intrinsic type!");
14773         Cmp = DAG.getNode(IntrData->Opc0, dl, MaskVT, Op.getOperand(1),
14774                     Op.getOperand(2));
14775       }
14776       SDValue CmpMask = getVectorMaskingNode(Cmp, Mask,
14777                                              DAG.getTargetConstant(0, MaskVT),
14778                                              Subtarget, DAG);
14779       SDValue Res = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, BitcastVT,
14780                                 DAG.getUNDEF(BitcastVT), CmpMask,
14781                                 DAG.getIntPtrConstant(0));
14782       return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
14783     }
14784     case COMI: { // Comparison intrinsics
14785       ISD::CondCode CC = (ISD::CondCode)IntrData->Opc1;
14786       SDValue LHS = Op.getOperand(1);
14787       SDValue RHS = Op.getOperand(2);
14788       unsigned X86CC = TranslateX86CC(CC, true, LHS, RHS, DAG);
14789       assert(X86CC != X86::COND_INVALID && "Unexpected illegal condition!");
14790       SDValue Cond = DAG.getNode(IntrData->Opc0, dl, MVT::i32, LHS, RHS);
14791       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
14792                                   DAG.getConstant(X86CC, MVT::i8), Cond);
14793       return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
14794     }
14795     case VSHIFT:
14796       return getTargetVShiftNode(IntrData->Opc0, dl, Op.getSimpleValueType(),
14797                                  Op.getOperand(1), Op.getOperand(2), DAG);
14798     case VSHIFT_MASK:
14799       return getVectorMaskingNode(getTargetVShiftNode(IntrData->Opc0, dl,
14800                                                       Op.getSimpleValueType(),
14801                                                       Op.getOperand(1),
14802                                                       Op.getOperand(2), DAG),
14803                                   Op.getOperand(4), Op.getOperand(3), Subtarget,
14804                                   DAG);
14805     case COMPRESS_EXPAND_IN_REG: {
14806       SDValue Mask = Op.getOperand(3);
14807       SDValue DataToCompress = Op.getOperand(1);
14808       SDValue PassThru = Op.getOperand(2);
14809       if (isAllOnes(Mask)) // return data as is
14810         return Op.getOperand(1);
14811       EVT VT = Op.getValueType();
14812       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
14813                                     VT.getVectorNumElements());
14814       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
14815                                        Mask.getValueType().getSizeInBits());
14816       SDLoc dl(Op);
14817       SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
14818                                   DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
14819                                   DAG.getIntPtrConstant(0));
14820
14821       return DAG.getNode(IntrData->Opc0, dl, VT, VMask, DataToCompress,
14822                          PassThru);
14823     }
14824     case BLEND: {
14825       SDValue Mask = Op.getOperand(3);
14826       EVT VT = Op.getValueType();
14827       EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
14828                                     VT.getVectorNumElements());
14829       EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
14830                                        Mask.getValueType().getSizeInBits());
14831       SDLoc dl(Op);
14832       SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
14833                                   DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
14834                                   DAG.getIntPtrConstant(0));
14835       return DAG.getNode(IntrData->Opc0, dl, VT, VMask, Op.getOperand(1),
14836                          Op.getOperand(2));
14837     }
14838     default:
14839       break;
14840     }
14841   }
14842
14843   switch (IntNo) {
14844   default: return SDValue();    // Don't custom lower most intrinsics.
14845
14846   case Intrinsic::x86_avx2_permd:
14847   case Intrinsic::x86_avx2_permps:
14848     // Operands intentionally swapped. Mask is last operand to intrinsic,
14849     // but second operand for node/instruction.
14850     return DAG.getNode(X86ISD::VPERMV, dl, Op.getValueType(),
14851                        Op.getOperand(2), Op.getOperand(1));
14852
14853   case Intrinsic::x86_avx512_mask_valign_q_512:
14854   case Intrinsic::x86_avx512_mask_valign_d_512:
14855     // Vector source operands are swapped.
14856     return getVectorMaskingNode(DAG.getNode(X86ISD::VALIGN, dl,
14857                                             Op.getValueType(), Op.getOperand(2),
14858                                             Op.getOperand(1),
14859                                             Op.getOperand(3)),
14860                                 Op.getOperand(5), Op.getOperand(4),
14861                                 Subtarget, DAG);
14862
14863   // ptest and testp intrinsics. The intrinsic these come from are designed to
14864   // return an integer value, not just an instruction so lower it to the ptest
14865   // or testp pattern and a setcc for the result.
14866   case Intrinsic::x86_sse41_ptestz:
14867   case Intrinsic::x86_sse41_ptestc:
14868   case Intrinsic::x86_sse41_ptestnzc:
14869   case Intrinsic::x86_avx_ptestz_256:
14870   case Intrinsic::x86_avx_ptestc_256:
14871   case Intrinsic::x86_avx_ptestnzc_256:
14872   case Intrinsic::x86_avx_vtestz_ps:
14873   case Intrinsic::x86_avx_vtestc_ps:
14874   case Intrinsic::x86_avx_vtestnzc_ps:
14875   case Intrinsic::x86_avx_vtestz_pd:
14876   case Intrinsic::x86_avx_vtestc_pd:
14877   case Intrinsic::x86_avx_vtestnzc_pd:
14878   case Intrinsic::x86_avx_vtestz_ps_256:
14879   case Intrinsic::x86_avx_vtestc_ps_256:
14880   case Intrinsic::x86_avx_vtestnzc_ps_256:
14881   case Intrinsic::x86_avx_vtestz_pd_256:
14882   case Intrinsic::x86_avx_vtestc_pd_256:
14883   case Intrinsic::x86_avx_vtestnzc_pd_256: {
14884     bool IsTestPacked = false;
14885     unsigned X86CC;
14886     switch (IntNo) {
14887     default: llvm_unreachable("Bad fallthrough in Intrinsic lowering.");
14888     case Intrinsic::x86_avx_vtestz_ps:
14889     case Intrinsic::x86_avx_vtestz_pd:
14890     case Intrinsic::x86_avx_vtestz_ps_256:
14891     case Intrinsic::x86_avx_vtestz_pd_256:
14892       IsTestPacked = true; // Fallthrough
14893     case Intrinsic::x86_sse41_ptestz:
14894     case Intrinsic::x86_avx_ptestz_256:
14895       // ZF = 1
14896       X86CC = X86::COND_E;
14897       break;
14898     case Intrinsic::x86_avx_vtestc_ps:
14899     case Intrinsic::x86_avx_vtestc_pd:
14900     case Intrinsic::x86_avx_vtestc_ps_256:
14901     case Intrinsic::x86_avx_vtestc_pd_256:
14902       IsTestPacked = true; // Fallthrough
14903     case Intrinsic::x86_sse41_ptestc:
14904     case Intrinsic::x86_avx_ptestc_256:
14905       // CF = 1
14906       X86CC = X86::COND_B;
14907       break;
14908     case Intrinsic::x86_avx_vtestnzc_ps:
14909     case Intrinsic::x86_avx_vtestnzc_pd:
14910     case Intrinsic::x86_avx_vtestnzc_ps_256:
14911     case Intrinsic::x86_avx_vtestnzc_pd_256:
14912       IsTestPacked = true; // Fallthrough
14913     case Intrinsic::x86_sse41_ptestnzc:
14914     case Intrinsic::x86_avx_ptestnzc_256:
14915       // ZF and CF = 0
14916       X86CC = X86::COND_A;
14917       break;
14918     }
14919
14920     SDValue LHS = Op.getOperand(1);
14921     SDValue RHS = Op.getOperand(2);
14922     unsigned TestOpc = IsTestPacked ? X86ISD::TESTP : X86ISD::PTEST;
14923     SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
14924     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
14925     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
14926     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
14927   }
14928   case Intrinsic::x86_avx512_kortestz_w:
14929   case Intrinsic::x86_avx512_kortestc_w: {
14930     unsigned X86CC = (IntNo == Intrinsic::x86_avx512_kortestz_w)? X86::COND_E: X86::COND_B;
14931     SDValue LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(1));
14932     SDValue RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(2));
14933     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
14934     SDValue Test = DAG.getNode(X86ISD::KORTEST, dl, MVT::i32, LHS, RHS);
14935     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i1, CC, Test);
14936     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
14937   }
14938
14939   case Intrinsic::x86_sse42_pcmpistria128:
14940   case Intrinsic::x86_sse42_pcmpestria128:
14941   case Intrinsic::x86_sse42_pcmpistric128:
14942   case Intrinsic::x86_sse42_pcmpestric128:
14943   case Intrinsic::x86_sse42_pcmpistrio128:
14944   case Intrinsic::x86_sse42_pcmpestrio128:
14945   case Intrinsic::x86_sse42_pcmpistris128:
14946   case Intrinsic::x86_sse42_pcmpestris128:
14947   case Intrinsic::x86_sse42_pcmpistriz128:
14948   case Intrinsic::x86_sse42_pcmpestriz128: {
14949     unsigned Opcode;
14950     unsigned X86CC;
14951     switch (IntNo) {
14952     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
14953     case Intrinsic::x86_sse42_pcmpistria128:
14954       Opcode = X86ISD::PCMPISTRI;
14955       X86CC = X86::COND_A;
14956       break;
14957     case Intrinsic::x86_sse42_pcmpestria128:
14958       Opcode = X86ISD::PCMPESTRI;
14959       X86CC = X86::COND_A;
14960       break;
14961     case Intrinsic::x86_sse42_pcmpistric128:
14962       Opcode = X86ISD::PCMPISTRI;
14963       X86CC = X86::COND_B;
14964       break;
14965     case Intrinsic::x86_sse42_pcmpestric128:
14966       Opcode = X86ISD::PCMPESTRI;
14967       X86CC = X86::COND_B;
14968       break;
14969     case Intrinsic::x86_sse42_pcmpistrio128:
14970       Opcode = X86ISD::PCMPISTRI;
14971       X86CC = X86::COND_O;
14972       break;
14973     case Intrinsic::x86_sse42_pcmpestrio128:
14974       Opcode = X86ISD::PCMPESTRI;
14975       X86CC = X86::COND_O;
14976       break;
14977     case Intrinsic::x86_sse42_pcmpistris128:
14978       Opcode = X86ISD::PCMPISTRI;
14979       X86CC = X86::COND_S;
14980       break;
14981     case Intrinsic::x86_sse42_pcmpestris128:
14982       Opcode = X86ISD::PCMPESTRI;
14983       X86CC = X86::COND_S;
14984       break;
14985     case Intrinsic::x86_sse42_pcmpistriz128:
14986       Opcode = X86ISD::PCMPISTRI;
14987       X86CC = X86::COND_E;
14988       break;
14989     case Intrinsic::x86_sse42_pcmpestriz128:
14990       Opcode = X86ISD::PCMPESTRI;
14991       X86CC = X86::COND_E;
14992       break;
14993     }
14994     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
14995     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
14996     SDValue PCMP = DAG.getNode(Opcode, dl, VTs, NewOps);
14997     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
14998                                 DAG.getConstant(X86CC, MVT::i8),
14999                                 SDValue(PCMP.getNode(), 1));
15000     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
15001   }
15002
15003   case Intrinsic::x86_sse42_pcmpistri128:
15004   case Intrinsic::x86_sse42_pcmpestri128: {
15005     unsigned Opcode;
15006     if (IntNo == Intrinsic::x86_sse42_pcmpistri128)
15007       Opcode = X86ISD::PCMPISTRI;
15008     else
15009       Opcode = X86ISD::PCMPESTRI;
15010
15011     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
15012     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
15013     return DAG.getNode(Opcode, dl, VTs, NewOps);
15014   }
15015   }
15016 }
15017
15018 static SDValue getGatherNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
15019                               SDValue Src, SDValue Mask, SDValue Base,
15020                               SDValue Index, SDValue ScaleOp, SDValue Chain,
15021                               const X86Subtarget * Subtarget) {
15022   SDLoc dl(Op);
15023   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
15024   assert(C && "Invalid scale type");
15025   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
15026   EVT MaskVT = MVT::getVectorVT(MVT::i1,
15027                              Index.getSimpleValueType().getVectorNumElements());
15028   SDValue MaskInReg;
15029   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
15030   if (MaskC)
15031     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
15032   else
15033     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
15034   SDVTList VTs = DAG.getVTList(Op.getValueType(), MaskVT, MVT::Other);
15035   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
15036   SDValue Segment = DAG.getRegister(0, MVT::i32);
15037   if (Src.getOpcode() == ISD::UNDEF)
15038     Src = getZeroVector(Op.getValueType(), Subtarget, DAG, dl);
15039   SDValue Ops[] = {Src, MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
15040   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
15041   SDValue RetOps[] = { SDValue(Res, 0), SDValue(Res, 2) };
15042   return DAG.getMergeValues(RetOps, dl);
15043 }
15044
15045 static SDValue getScatterNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
15046                                SDValue Src, SDValue Mask, SDValue Base,
15047                                SDValue Index, SDValue ScaleOp, SDValue Chain) {
15048   SDLoc dl(Op);
15049   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
15050   assert(C && "Invalid scale type");
15051   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
15052   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
15053   SDValue Segment = DAG.getRegister(0, MVT::i32);
15054   EVT MaskVT = MVT::getVectorVT(MVT::i1,
15055                              Index.getSimpleValueType().getVectorNumElements());
15056   SDValue MaskInReg;
15057   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
15058   if (MaskC)
15059     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
15060   else
15061     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
15062   SDVTList VTs = DAG.getVTList(MaskVT, MVT::Other);
15063   SDValue Ops[] = {Base, Scale, Index, Disp, Segment, MaskInReg, Src, Chain};
15064   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
15065   return SDValue(Res, 1);
15066 }
15067
15068 static SDValue getPrefetchNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
15069                                SDValue Mask, SDValue Base, SDValue Index,
15070                                SDValue ScaleOp, SDValue Chain) {
15071   SDLoc dl(Op);
15072   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
15073   assert(C && "Invalid scale type");
15074   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
15075   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
15076   SDValue Segment = DAG.getRegister(0, MVT::i32);
15077   EVT MaskVT =
15078     MVT::getVectorVT(MVT::i1, Index.getSimpleValueType().getVectorNumElements());
15079   SDValue MaskInReg;
15080   ConstantSDNode *MaskC = dyn_cast<ConstantSDNode>(Mask);
15081   if (MaskC)
15082     MaskInReg = DAG.getTargetConstant(MaskC->getSExtValue(), MaskVT);
15083   else
15084     MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
15085   //SDVTList VTs = DAG.getVTList(MVT::Other);
15086   SDValue Ops[] = {MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
15087   SDNode *Res = DAG.getMachineNode(Opc, dl, MVT::Other, Ops);
15088   return SDValue(Res, 0);
15089 }
15090
15091 // getReadPerformanceCounter - Handles the lowering of builtin intrinsics that
15092 // read performance monitor counters (x86_rdpmc).
15093 static void getReadPerformanceCounter(SDNode *N, SDLoc DL,
15094                               SelectionDAG &DAG, const X86Subtarget *Subtarget,
15095                               SmallVectorImpl<SDValue> &Results) {
15096   assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
15097   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
15098   SDValue LO, HI;
15099
15100   // The ECX register is used to select the index of the performance counter
15101   // to read.
15102   SDValue Chain = DAG.getCopyToReg(N->getOperand(0), DL, X86::ECX,
15103                                    N->getOperand(2));
15104   SDValue rd = DAG.getNode(X86ISD::RDPMC_DAG, DL, Tys, Chain);
15105
15106   // Reads the content of a 64-bit performance counter and returns it in the
15107   // registers EDX:EAX.
15108   if (Subtarget->is64Bit()) {
15109     LO = DAG.getCopyFromReg(rd, DL, X86::RAX, MVT::i64, rd.getValue(1));
15110     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::RDX, MVT::i64,
15111                             LO.getValue(2));
15112   } else {
15113     LO = DAG.getCopyFromReg(rd, DL, X86::EAX, MVT::i32, rd.getValue(1));
15114     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::EDX, MVT::i32,
15115                             LO.getValue(2));
15116   }
15117   Chain = HI.getValue(1);
15118
15119   if (Subtarget->is64Bit()) {
15120     // The EAX register is loaded with the low-order 32 bits. The EDX register
15121     // is loaded with the supported high-order bits of the counter.
15122     SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
15123                               DAG.getConstant(32, MVT::i8));
15124     Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
15125     Results.push_back(Chain);
15126     return;
15127   }
15128
15129   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
15130   SDValue Ops[] = { LO, HI };
15131   SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
15132   Results.push_back(Pair);
15133   Results.push_back(Chain);
15134 }
15135
15136 // getReadTimeStampCounter - Handles the lowering of builtin intrinsics that
15137 // read the time stamp counter (x86_rdtsc and x86_rdtscp). This function is
15138 // also used to custom lower READCYCLECOUNTER nodes.
15139 static void getReadTimeStampCounter(SDNode *N, SDLoc DL, unsigned Opcode,
15140                               SelectionDAG &DAG, const X86Subtarget *Subtarget,
15141                               SmallVectorImpl<SDValue> &Results) {
15142   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
15143   SDValue rd = DAG.getNode(Opcode, DL, Tys, N->getOperand(0));
15144   SDValue LO, HI;
15145
15146   // The processor's time-stamp counter (a 64-bit MSR) is stored into the
15147   // EDX:EAX registers. EDX is loaded with the high-order 32 bits of the MSR
15148   // and the EAX register is loaded with the low-order 32 bits.
15149   if (Subtarget->is64Bit()) {
15150     LO = DAG.getCopyFromReg(rd, DL, X86::RAX, MVT::i64, rd.getValue(1));
15151     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::RDX, MVT::i64,
15152                             LO.getValue(2));
15153   } else {
15154     LO = DAG.getCopyFromReg(rd, DL, X86::EAX, MVT::i32, rd.getValue(1));
15155     HI = DAG.getCopyFromReg(LO.getValue(1), DL, X86::EDX, MVT::i32,
15156                             LO.getValue(2));
15157   }
15158   SDValue Chain = HI.getValue(1);
15159
15160   if (Opcode == X86ISD::RDTSCP_DAG) {
15161     assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
15162
15163     // Instruction RDTSCP loads the IA32:TSC_AUX_MSR (address C000_0103H) into
15164     // the ECX register. Add 'ecx' explicitly to the chain.
15165     SDValue ecx = DAG.getCopyFromReg(Chain, DL, X86::ECX, MVT::i32,
15166                                      HI.getValue(2));
15167     // Explicitly store the content of ECX at the location passed in input
15168     // to the 'rdtscp' intrinsic.
15169     Chain = DAG.getStore(ecx.getValue(1), DL, ecx, N->getOperand(2),
15170                          MachinePointerInfo(), false, false, 0);
15171   }
15172
15173   if (Subtarget->is64Bit()) {
15174     // The EDX register is loaded with the high-order 32 bits of the MSR, and
15175     // the EAX register is loaded with the low-order 32 bits.
15176     SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
15177                               DAG.getConstant(32, MVT::i8));
15178     Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
15179     Results.push_back(Chain);
15180     return;
15181   }
15182
15183   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
15184   SDValue Ops[] = { LO, HI };
15185   SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
15186   Results.push_back(Pair);
15187   Results.push_back(Chain);
15188 }
15189
15190 static SDValue LowerREADCYCLECOUNTER(SDValue Op, const X86Subtarget *Subtarget,
15191                                      SelectionDAG &DAG) {
15192   SmallVector<SDValue, 2> Results;
15193   SDLoc DL(Op);
15194   getReadTimeStampCounter(Op.getNode(), DL, X86ISD::RDTSC_DAG, DAG, Subtarget,
15195                           Results);
15196   return DAG.getMergeValues(Results, DL);
15197 }
15198
15199
15200 static SDValue LowerINTRINSIC_W_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
15201                                       SelectionDAG &DAG) {
15202   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
15203
15204   const IntrinsicData* IntrData = getIntrinsicWithChain(IntNo);
15205   if (!IntrData)
15206     return SDValue();
15207
15208   SDLoc dl(Op);
15209   switch(IntrData->Type) {
15210   default:
15211     llvm_unreachable("Unknown Intrinsic Type");
15212     break;
15213   case RDSEED:
15214   case RDRAND: {
15215     // Emit the node with the right value type.
15216     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Glue, MVT::Other);
15217     SDValue Result = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(0));
15218
15219     // If the value returned by RDRAND/RDSEED was valid (CF=1), return 1.
15220     // Otherwise return the value from Rand, which is always 0, casted to i32.
15221     SDValue Ops[] = { DAG.getZExtOrTrunc(Result, dl, Op->getValueType(1)),
15222                       DAG.getConstant(1, Op->getValueType(1)),
15223                       DAG.getConstant(X86::COND_B, MVT::i32),
15224                       SDValue(Result.getNode(), 1) };
15225     SDValue isValid = DAG.getNode(X86ISD::CMOV, dl,
15226                                   DAG.getVTList(Op->getValueType(1), MVT::Glue),
15227                                   Ops);
15228
15229     // Return { result, isValid, chain }.
15230     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
15231                        SDValue(Result.getNode(), 2));
15232   }
15233   case GATHER: {
15234   //gather(v1, mask, index, base, scale);
15235     SDValue Chain = Op.getOperand(0);
15236     SDValue Src   = Op.getOperand(2);
15237     SDValue Base  = Op.getOperand(3);
15238     SDValue Index = Op.getOperand(4);
15239     SDValue Mask  = Op.getOperand(5);
15240     SDValue Scale = Op.getOperand(6);
15241     return getGatherNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index, Scale, Chain,
15242                           Subtarget);
15243   }
15244   case SCATTER: {
15245   //scatter(base, mask, index, v1, scale);
15246     SDValue Chain = Op.getOperand(0);
15247     SDValue Base  = Op.getOperand(2);
15248     SDValue Mask  = Op.getOperand(3);
15249     SDValue Index = Op.getOperand(4);
15250     SDValue Src   = Op.getOperand(5);
15251     SDValue Scale = Op.getOperand(6);
15252     return getScatterNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index, Scale, Chain);
15253   }
15254   case PREFETCH: {
15255     SDValue Hint = Op.getOperand(6);
15256     unsigned HintVal;
15257     if (dyn_cast<ConstantSDNode> (Hint) == nullptr ||
15258         (HintVal = dyn_cast<ConstantSDNode> (Hint)->getZExtValue()) > 1)
15259       llvm_unreachable("Wrong prefetch hint in intrinsic: should be 0 or 1");
15260     unsigned Opcode = (HintVal ? IntrData->Opc1 : IntrData->Opc0);
15261     SDValue Chain = Op.getOperand(0);
15262     SDValue Mask  = Op.getOperand(2);
15263     SDValue Index = Op.getOperand(3);
15264     SDValue Base  = Op.getOperand(4);
15265     SDValue Scale = Op.getOperand(5);
15266     return getPrefetchNode(Opcode, Op, DAG, Mask, Base, Index, Scale, Chain);
15267   }
15268   // Read Time Stamp Counter (RDTSC) and Processor ID (RDTSCP).
15269   case RDTSC: {
15270     SmallVector<SDValue, 2> Results;
15271     getReadTimeStampCounter(Op.getNode(), dl, IntrData->Opc0, DAG, Subtarget, Results);
15272     return DAG.getMergeValues(Results, dl);
15273   }
15274   // Read Performance Monitoring Counters.
15275   case RDPMC: {
15276     SmallVector<SDValue, 2> Results;
15277     getReadPerformanceCounter(Op.getNode(), dl, DAG, Subtarget, Results);
15278     return DAG.getMergeValues(Results, dl);
15279   }
15280   // XTEST intrinsics.
15281   case XTEST: {
15282     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
15283     SDValue InTrans = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(0));
15284     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
15285                                 DAG.getConstant(X86::COND_NE, MVT::i8),
15286                                 InTrans);
15287     SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
15288     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(),
15289                        Ret, SDValue(InTrans.getNode(), 1));
15290   }
15291   // ADC/ADCX/SBB
15292   case ADX: {
15293     SmallVector<SDValue, 2> Results;
15294     SDVTList CFVTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
15295     SDVTList VTs = DAG.getVTList(Op.getOperand(3)->getValueType(0), MVT::Other);
15296     SDValue GenCF = DAG.getNode(X86ISD::ADD, dl, CFVTs, Op.getOperand(2),
15297                                 DAG.getConstant(-1, MVT::i8));
15298     SDValue Res = DAG.getNode(IntrData->Opc0, dl, VTs, Op.getOperand(3),
15299                               Op.getOperand(4), GenCF.getValue(1));
15300     SDValue Store = DAG.getStore(Op.getOperand(0), dl, Res.getValue(0),
15301                                  Op.getOperand(5), MachinePointerInfo(),
15302                                  false, false, 0);
15303     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
15304                                 DAG.getConstant(X86::COND_B, MVT::i8),
15305                                 Res.getValue(1));
15306     Results.push_back(SetCC);
15307     Results.push_back(Store);
15308     return DAG.getMergeValues(Results, dl);
15309   }
15310   case COMPRESS_TO_MEM: {
15311     SDLoc dl(Op);
15312     SDValue Mask = Op.getOperand(4);
15313     SDValue DataToCompress = Op.getOperand(3);
15314     SDValue Addr = Op.getOperand(2);
15315     SDValue Chain = Op.getOperand(0);
15316
15317     if (isAllOnes(Mask)) // return just a store
15318       return DAG.getStore(Chain, dl, DataToCompress, Addr,
15319                           MachinePointerInfo(), false, false, 0);
15320
15321     EVT VT = DataToCompress.getValueType();
15322     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
15323                                   VT.getVectorNumElements());
15324     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
15325                                      Mask.getValueType().getSizeInBits());
15326     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
15327                                 DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
15328                                 DAG.getIntPtrConstant(0));
15329
15330     SDValue Compressed =  DAG.getNode(IntrData->Opc0, dl, VT, VMask,
15331                                       DataToCompress, DAG.getUNDEF(VT));
15332     return DAG.getStore(Chain, dl, Compressed, Addr,
15333                         MachinePointerInfo(), false, false, 0);
15334   }
15335   case EXPAND_FROM_MEM: {
15336     SDLoc dl(Op);
15337     SDValue Mask = Op.getOperand(4);
15338     SDValue PathThru = Op.getOperand(3);
15339     SDValue Addr = Op.getOperand(2);
15340     SDValue Chain = Op.getOperand(0);
15341     EVT VT = Op.getValueType();
15342
15343     if (isAllOnes(Mask)) // return just a load
15344       return DAG.getLoad(VT, dl, Chain, Addr, MachinePointerInfo(), false, false,
15345                          false, 0);
15346     EVT MaskVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
15347                                   VT.getVectorNumElements());
15348     EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
15349                                      Mask.getValueType().getSizeInBits());
15350     SDValue VMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
15351                                 DAG.getNode(ISD::BITCAST, dl, BitcastVT, Mask),
15352                                 DAG.getIntPtrConstant(0));
15353
15354     SDValue DataToExpand = DAG.getLoad(VT, dl, Chain, Addr, MachinePointerInfo(),
15355                                    false, false, false, 0);
15356
15357     SDValue Results[] = {
15358         DAG.getNode(IntrData->Opc0, dl, VT, VMask, DataToExpand, PathThru),
15359         Chain};
15360     return DAG.getMergeValues(Results, dl);
15361   }
15362   }
15363 }
15364
15365 SDValue X86TargetLowering::LowerRETURNADDR(SDValue Op,
15366                                            SelectionDAG &DAG) const {
15367   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
15368   MFI->setReturnAddressIsTaken(true);
15369
15370   if (verifyReturnAddressArgumentIsConstant(Op, DAG))
15371     return SDValue();
15372
15373   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
15374   SDLoc dl(Op);
15375   EVT PtrVT = getPointerTy();
15376
15377   if (Depth > 0) {
15378     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
15379     const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
15380     SDValue Offset = DAG.getConstant(RegInfo->getSlotSize(), PtrVT);
15381     return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
15382                        DAG.getNode(ISD::ADD, dl, PtrVT,
15383                                    FrameAddr, Offset),
15384                        MachinePointerInfo(), false, false, false, 0);
15385   }
15386
15387   // Just load the return address.
15388   SDValue RetAddrFI = getReturnAddressFrameIndex(DAG);
15389   return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
15390                      RetAddrFI, MachinePointerInfo(), false, false, false, 0);
15391 }
15392
15393 SDValue X86TargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
15394   MachineFunction &MF = DAG.getMachineFunction();
15395   MachineFrameInfo *MFI = MF.getFrameInfo();
15396   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
15397   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
15398   EVT VT = Op.getValueType();
15399
15400   MFI->setFrameAddressIsTaken(true);
15401
15402   if (MF.getTarget().getMCAsmInfo()->usesWindowsCFI()) {
15403     // Depth > 0 makes no sense on targets which use Windows unwind codes.  It
15404     // is not possible to crawl up the stack without looking at the unwind codes
15405     // simultaneously.
15406     int FrameAddrIndex = FuncInfo->getFAIndex();
15407     if (!FrameAddrIndex) {
15408       // Set up a frame object for the return address.
15409       unsigned SlotSize = RegInfo->getSlotSize();
15410       FrameAddrIndex = MF.getFrameInfo()->CreateFixedObject(
15411           SlotSize, /*Offset=*/INT64_MIN, /*IsImmutable=*/false);
15412       FuncInfo->setFAIndex(FrameAddrIndex);
15413     }
15414     return DAG.getFrameIndex(FrameAddrIndex, VT);
15415   }
15416
15417   unsigned FrameReg =
15418       RegInfo->getPtrSizedFrameRegister(DAG.getMachineFunction());
15419   SDLoc dl(Op);  // FIXME probably not meaningful
15420   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
15421   assert(((FrameReg == X86::RBP && VT == MVT::i64) ||
15422           (FrameReg == X86::EBP && VT == MVT::i32)) &&
15423          "Invalid Frame Register!");
15424   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
15425   while (Depth--)
15426     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
15427                             MachinePointerInfo(),
15428                             false, false, false, 0);
15429   return FrameAddr;
15430 }
15431
15432 // FIXME? Maybe this could be a TableGen attribute on some registers and
15433 // this table could be generated automatically from RegInfo.
15434 unsigned X86TargetLowering::getRegisterByName(const char* RegName,
15435                                               EVT VT) const {
15436   unsigned Reg = StringSwitch<unsigned>(RegName)
15437                        .Case("esp", X86::ESP)
15438                        .Case("rsp", X86::RSP)
15439                        .Default(0);
15440   if (Reg)
15441     return Reg;
15442   report_fatal_error("Invalid register name global variable");
15443 }
15444
15445 SDValue X86TargetLowering::LowerFRAME_TO_ARGS_OFFSET(SDValue Op,
15446                                                      SelectionDAG &DAG) const {
15447   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
15448   return DAG.getIntPtrConstant(2 * RegInfo->getSlotSize());
15449 }
15450
15451 SDValue X86TargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
15452   SDValue Chain     = Op.getOperand(0);
15453   SDValue Offset    = Op.getOperand(1);
15454   SDValue Handler   = Op.getOperand(2);
15455   SDLoc dl      (Op);
15456
15457   EVT PtrVT = getPointerTy();
15458   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
15459   unsigned FrameReg = RegInfo->getFrameRegister(DAG.getMachineFunction());
15460   assert(((FrameReg == X86::RBP && PtrVT == MVT::i64) ||
15461           (FrameReg == X86::EBP && PtrVT == MVT::i32)) &&
15462          "Invalid Frame Register!");
15463   SDValue Frame = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, PtrVT);
15464   unsigned StoreAddrReg = (PtrVT == MVT::i64) ? X86::RCX : X86::ECX;
15465
15466   SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, Frame,
15467                                  DAG.getIntPtrConstant(RegInfo->getSlotSize()));
15468   StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, StoreAddr, Offset);
15469   Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo(),
15470                        false, false, 0);
15471   Chain = DAG.getCopyToReg(Chain, dl, StoreAddrReg, StoreAddr);
15472
15473   return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
15474                      DAG.getRegister(StoreAddrReg, PtrVT));
15475 }
15476
15477 SDValue X86TargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op,
15478                                                SelectionDAG &DAG) const {
15479   SDLoc DL(Op);
15480   return DAG.getNode(X86ISD::EH_SJLJ_SETJMP, DL,
15481                      DAG.getVTList(MVT::i32, MVT::Other),
15482                      Op.getOperand(0), Op.getOperand(1));
15483 }
15484
15485 SDValue X86TargetLowering::lowerEH_SJLJ_LONGJMP(SDValue Op,
15486                                                 SelectionDAG &DAG) const {
15487   SDLoc DL(Op);
15488   return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
15489                      Op.getOperand(0), Op.getOperand(1));
15490 }
15491
15492 static SDValue LowerADJUST_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) {
15493   return Op.getOperand(0);
15494 }
15495
15496 SDValue X86TargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
15497                                                 SelectionDAG &DAG) const {
15498   SDValue Root = Op.getOperand(0);
15499   SDValue Trmp = Op.getOperand(1); // trampoline
15500   SDValue FPtr = Op.getOperand(2); // nested function
15501   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
15502   SDLoc dl (Op);
15503
15504   const Value *TrmpAddr = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
15505   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
15506
15507   if (Subtarget->is64Bit()) {
15508     SDValue OutChains[6];
15509
15510     // Large code-model.
15511     const unsigned char JMP64r  = 0xFF; // 64-bit jmp through register opcode.
15512     const unsigned char MOV64ri = 0xB8; // X86::MOV64ri opcode.
15513
15514     const unsigned char N86R10 = TRI->getEncodingValue(X86::R10) & 0x7;
15515     const unsigned char N86R11 = TRI->getEncodingValue(X86::R11) & 0x7;
15516
15517     const unsigned char REX_WB = 0x40 | 0x08 | 0x01; // REX prefix
15518
15519     // Load the pointer to the nested function into R11.
15520     unsigned OpCode = ((MOV64ri | N86R11) << 8) | REX_WB; // movabsq r11
15521     SDValue Addr = Trmp;
15522     OutChains[0] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
15523                                 Addr, MachinePointerInfo(TrmpAddr),
15524                                 false, false, 0);
15525
15526     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
15527                        DAG.getConstant(2, MVT::i64));
15528     OutChains[1] = DAG.getStore(Root, dl, FPtr, Addr,
15529                                 MachinePointerInfo(TrmpAddr, 2),
15530                                 false, false, 2);
15531
15532     // Load the 'nest' parameter value into R10.
15533     // R10 is specified in X86CallingConv.td
15534     OpCode = ((MOV64ri | N86R10) << 8) | REX_WB; // movabsq r10
15535     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
15536                        DAG.getConstant(10, MVT::i64));
15537     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
15538                                 Addr, MachinePointerInfo(TrmpAddr, 10),
15539                                 false, false, 0);
15540
15541     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
15542                        DAG.getConstant(12, MVT::i64));
15543     OutChains[3] = DAG.getStore(Root, dl, Nest, Addr,
15544                                 MachinePointerInfo(TrmpAddr, 12),
15545                                 false, false, 2);
15546
15547     // Jump to the nested function.
15548     OpCode = (JMP64r << 8) | REX_WB; // jmpq *...
15549     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
15550                        DAG.getConstant(20, MVT::i64));
15551     OutChains[4] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
15552                                 Addr, MachinePointerInfo(TrmpAddr, 20),
15553                                 false, false, 0);
15554
15555     unsigned char ModRM = N86R11 | (4 << 3) | (3 << 6); // ...r11
15556     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
15557                        DAG.getConstant(22, MVT::i64));
15558     OutChains[5] = DAG.getStore(Root, dl, DAG.getConstant(ModRM, MVT::i8), Addr,
15559                                 MachinePointerInfo(TrmpAddr, 22),
15560                                 false, false, 0);
15561
15562     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
15563   } else {
15564     const Function *Func =
15565       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
15566     CallingConv::ID CC = Func->getCallingConv();
15567     unsigned NestReg;
15568
15569     switch (CC) {
15570     default:
15571       llvm_unreachable("Unsupported calling convention");
15572     case CallingConv::C:
15573     case CallingConv::X86_StdCall: {
15574       // Pass 'nest' parameter in ECX.
15575       // Must be kept in sync with X86CallingConv.td
15576       NestReg = X86::ECX;
15577
15578       // Check that ECX wasn't needed by an 'inreg' parameter.
15579       FunctionType *FTy = Func->getFunctionType();
15580       const AttributeSet &Attrs = Func->getAttributes();
15581
15582       if (!Attrs.isEmpty() && !Func->isVarArg()) {
15583         unsigned InRegCount = 0;
15584         unsigned Idx = 1;
15585
15586         for (FunctionType::param_iterator I = FTy->param_begin(),
15587              E = FTy->param_end(); I != E; ++I, ++Idx)
15588           if (Attrs.hasAttribute(Idx, Attribute::InReg))
15589             // FIXME: should only count parameters that are lowered to integers.
15590             InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
15591
15592         if (InRegCount > 2) {
15593           report_fatal_error("Nest register in use - reduce number of inreg"
15594                              " parameters!");
15595         }
15596       }
15597       break;
15598     }
15599     case CallingConv::X86_FastCall:
15600     case CallingConv::X86_ThisCall:
15601     case CallingConv::Fast:
15602       // Pass 'nest' parameter in EAX.
15603       // Must be kept in sync with X86CallingConv.td
15604       NestReg = X86::EAX;
15605       break;
15606     }
15607
15608     SDValue OutChains[4];
15609     SDValue Addr, Disp;
15610
15611     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
15612                        DAG.getConstant(10, MVT::i32));
15613     Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
15614
15615     // This is storing the opcode for MOV32ri.
15616     const unsigned char MOV32ri = 0xB8; // X86::MOV32ri's opcode byte.
15617     const unsigned char N86Reg = TRI->getEncodingValue(NestReg) & 0x7;
15618     OutChains[0] = DAG.getStore(Root, dl,
15619                                 DAG.getConstant(MOV32ri|N86Reg, MVT::i8),
15620                                 Trmp, MachinePointerInfo(TrmpAddr),
15621                                 false, false, 0);
15622
15623     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
15624                        DAG.getConstant(1, MVT::i32));
15625     OutChains[1] = DAG.getStore(Root, dl, Nest, Addr,
15626                                 MachinePointerInfo(TrmpAddr, 1),
15627                                 false, false, 1);
15628
15629     const unsigned char JMP = 0xE9; // jmp <32bit dst> opcode.
15630     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
15631                        DAG.getConstant(5, MVT::i32));
15632     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(JMP, MVT::i8), Addr,
15633                                 MachinePointerInfo(TrmpAddr, 5),
15634                                 false, false, 1);
15635
15636     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
15637                        DAG.getConstant(6, MVT::i32));
15638     OutChains[3] = DAG.getStore(Root, dl, Disp, Addr,
15639                                 MachinePointerInfo(TrmpAddr, 6),
15640                                 false, false, 1);
15641
15642     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
15643   }
15644 }
15645
15646 SDValue X86TargetLowering::LowerFLT_ROUNDS_(SDValue Op,
15647                                             SelectionDAG &DAG) const {
15648   /*
15649    The rounding mode is in bits 11:10 of FPSR, and has the following
15650    settings:
15651      00 Round to nearest
15652      01 Round to -inf
15653      10 Round to +inf
15654      11 Round to 0
15655
15656   FLT_ROUNDS, on the other hand, expects the following:
15657     -1 Undefined
15658      0 Round to 0
15659      1 Round to nearest
15660      2 Round to +inf
15661      3 Round to -inf
15662
15663   To perform the conversion, we do:
15664     (((((FPSR & 0x800) >> 11) | ((FPSR & 0x400) >> 9)) + 1) & 3)
15665   */
15666
15667   MachineFunction &MF = DAG.getMachineFunction();
15668   const TargetFrameLowering &TFI = *Subtarget->getFrameLowering();
15669   unsigned StackAlignment = TFI.getStackAlignment();
15670   MVT VT = Op.getSimpleValueType();
15671   SDLoc DL(Op);
15672
15673   // Save FP Control Word to stack slot
15674   int SSFI = MF.getFrameInfo()->CreateStackObject(2, StackAlignment, false);
15675   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
15676
15677   MachineMemOperand *MMO =
15678    MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
15679                            MachineMemOperand::MOStore, 2, 2);
15680
15681   SDValue Ops[] = { DAG.getEntryNode(), StackSlot };
15682   SDValue Chain = DAG.getMemIntrinsicNode(X86ISD::FNSTCW16m, DL,
15683                                           DAG.getVTList(MVT::Other),
15684                                           Ops, MVT::i16, MMO);
15685
15686   // Load FP Control Word from stack slot
15687   SDValue CWD = DAG.getLoad(MVT::i16, DL, Chain, StackSlot,
15688                             MachinePointerInfo(), false, false, false, 0);
15689
15690   // Transform as necessary
15691   SDValue CWD1 =
15692     DAG.getNode(ISD::SRL, DL, MVT::i16,
15693                 DAG.getNode(ISD::AND, DL, MVT::i16,
15694                             CWD, DAG.getConstant(0x800, MVT::i16)),
15695                 DAG.getConstant(11, MVT::i8));
15696   SDValue CWD2 =
15697     DAG.getNode(ISD::SRL, DL, MVT::i16,
15698                 DAG.getNode(ISD::AND, DL, MVT::i16,
15699                             CWD, DAG.getConstant(0x400, MVT::i16)),
15700                 DAG.getConstant(9, MVT::i8));
15701
15702   SDValue RetVal =
15703     DAG.getNode(ISD::AND, DL, MVT::i16,
15704                 DAG.getNode(ISD::ADD, DL, MVT::i16,
15705                             DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
15706                             DAG.getConstant(1, MVT::i16)),
15707                 DAG.getConstant(3, MVT::i16));
15708
15709   return DAG.getNode((VT.getSizeInBits() < 16 ?
15710                       ISD::TRUNCATE : ISD::ZERO_EXTEND), DL, VT, RetVal);
15711 }
15712
15713 static SDValue LowerCTLZ(SDValue Op, SelectionDAG &DAG) {
15714   MVT VT = Op.getSimpleValueType();
15715   EVT OpVT = VT;
15716   unsigned NumBits = VT.getSizeInBits();
15717   SDLoc dl(Op);
15718
15719   Op = Op.getOperand(0);
15720   if (VT == MVT::i8) {
15721     // Zero extend to i32 since there is not an i8 bsr.
15722     OpVT = MVT::i32;
15723     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
15724   }
15725
15726   // Issue a bsr (scan bits in reverse) which also sets EFLAGS.
15727   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
15728   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
15729
15730   // If src is zero (i.e. bsr sets ZF), returns NumBits.
15731   SDValue Ops[] = {
15732     Op,
15733     DAG.getConstant(NumBits+NumBits-1, OpVT),
15734     DAG.getConstant(X86::COND_E, MVT::i8),
15735     Op.getValue(1)
15736   };
15737   Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops);
15738
15739   // Finally xor with NumBits-1.
15740   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
15741
15742   if (VT == MVT::i8)
15743     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
15744   return Op;
15745 }
15746
15747 static SDValue LowerCTLZ_ZERO_UNDEF(SDValue Op, SelectionDAG &DAG) {
15748   MVT VT = Op.getSimpleValueType();
15749   EVT OpVT = VT;
15750   unsigned NumBits = VT.getSizeInBits();
15751   SDLoc dl(Op);
15752
15753   Op = Op.getOperand(0);
15754   if (VT == MVT::i8) {
15755     // Zero extend to i32 since there is not an i8 bsr.
15756     OpVT = MVT::i32;
15757     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
15758   }
15759
15760   // Issue a bsr (scan bits in reverse).
15761   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
15762   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
15763
15764   // And xor with NumBits-1.
15765   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
15766
15767   if (VT == MVT::i8)
15768     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
15769   return Op;
15770 }
15771
15772 static SDValue LowerCTTZ(SDValue Op, SelectionDAG &DAG) {
15773   MVT VT = Op.getSimpleValueType();
15774   unsigned NumBits = VT.getSizeInBits();
15775   SDLoc dl(Op);
15776   Op = Op.getOperand(0);
15777
15778   // Issue a bsf (scan bits forward) which also sets EFLAGS.
15779   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
15780   Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
15781
15782   // If src is zero (i.e. bsf sets ZF), returns NumBits.
15783   SDValue Ops[] = {
15784     Op,
15785     DAG.getConstant(NumBits, VT),
15786     DAG.getConstant(X86::COND_E, MVT::i8),
15787     Op.getValue(1)
15788   };
15789   return DAG.getNode(X86ISD::CMOV, dl, VT, Ops);
15790 }
15791
15792 // Lower256IntArith - Break a 256-bit integer operation into two new 128-bit
15793 // ones, and then concatenate the result back.
15794 static SDValue Lower256IntArith(SDValue Op, SelectionDAG &DAG) {
15795   MVT VT = Op.getSimpleValueType();
15796
15797   assert(VT.is256BitVector() && VT.isInteger() &&
15798          "Unsupported value type for operation");
15799
15800   unsigned NumElems = VT.getVectorNumElements();
15801   SDLoc dl(Op);
15802
15803   // Extract the LHS vectors
15804   SDValue LHS = Op.getOperand(0);
15805   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
15806   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
15807
15808   // Extract the RHS vectors
15809   SDValue RHS = Op.getOperand(1);
15810   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
15811   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
15812
15813   MVT EltVT = VT.getVectorElementType();
15814   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
15815
15816   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
15817                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
15818                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
15819 }
15820
15821 static SDValue LowerADD(SDValue Op, SelectionDAG &DAG) {
15822   assert(Op.getSimpleValueType().is256BitVector() &&
15823          Op.getSimpleValueType().isInteger() &&
15824          "Only handle AVX 256-bit vector integer operation");
15825   return Lower256IntArith(Op, DAG);
15826 }
15827
15828 static SDValue LowerSUB(SDValue Op, SelectionDAG &DAG) {
15829   assert(Op.getSimpleValueType().is256BitVector() &&
15830          Op.getSimpleValueType().isInteger() &&
15831          "Only handle AVX 256-bit vector integer operation");
15832   return Lower256IntArith(Op, DAG);
15833 }
15834
15835 static SDValue LowerMUL(SDValue Op, const X86Subtarget *Subtarget,
15836                         SelectionDAG &DAG) {
15837   SDLoc dl(Op);
15838   MVT VT = Op.getSimpleValueType();
15839
15840   // Decompose 256-bit ops into smaller 128-bit ops.
15841   if (VT.is256BitVector() && !Subtarget->hasInt256())
15842     return Lower256IntArith(Op, DAG);
15843
15844   SDValue A = Op.getOperand(0);
15845   SDValue B = Op.getOperand(1);
15846
15847   // Lower v4i32 mul as 2x shuffle, 2x pmuludq, 2x shuffle.
15848   if (VT == MVT::v4i32) {
15849     assert(Subtarget->hasSSE2() && !Subtarget->hasSSE41() &&
15850            "Should not custom lower when pmuldq is available!");
15851
15852     // Extract the odd parts.
15853     static const int UnpackMask[] = { 1, -1, 3, -1 };
15854     SDValue Aodds = DAG.getVectorShuffle(VT, dl, A, A, UnpackMask);
15855     SDValue Bodds = DAG.getVectorShuffle(VT, dl, B, B, UnpackMask);
15856
15857     // Multiply the even parts.
15858     SDValue Evens = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, A, B);
15859     // Now multiply odd parts.
15860     SDValue Odds = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, Aodds, Bodds);
15861
15862     Evens = DAG.getNode(ISD::BITCAST, dl, VT, Evens);
15863     Odds = DAG.getNode(ISD::BITCAST, dl, VT, Odds);
15864
15865     // Merge the two vectors back together with a shuffle. This expands into 2
15866     // shuffles.
15867     static const int ShufMask[] = { 0, 4, 2, 6 };
15868     return DAG.getVectorShuffle(VT, dl, Evens, Odds, ShufMask);
15869   }
15870
15871   assert((VT == MVT::v2i64 || VT == MVT::v4i64 || VT == MVT::v8i64) &&
15872          "Only know how to lower V2I64/V4I64/V8I64 multiply");
15873
15874   //  Ahi = psrlqi(a, 32);
15875   //  Bhi = psrlqi(b, 32);
15876   //
15877   //  AloBlo = pmuludq(a, b);
15878   //  AloBhi = pmuludq(a, Bhi);
15879   //  AhiBlo = pmuludq(Ahi, b);
15880
15881   //  AloBhi = psllqi(AloBhi, 32);
15882   //  AhiBlo = psllqi(AhiBlo, 32);
15883   //  return AloBlo + AloBhi + AhiBlo;
15884
15885   SDValue Ahi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, A, 32, DAG);
15886   SDValue Bhi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, B, 32, DAG);
15887
15888   // Bit cast to 32-bit vectors for MULUDQ
15889   EVT MulVT = (VT == MVT::v2i64) ? MVT::v4i32 :
15890                                   (VT == MVT::v4i64) ? MVT::v8i32 : MVT::v16i32;
15891   A = DAG.getNode(ISD::BITCAST, dl, MulVT, A);
15892   B = DAG.getNode(ISD::BITCAST, dl, MulVT, B);
15893   Ahi = DAG.getNode(ISD::BITCAST, dl, MulVT, Ahi);
15894   Bhi = DAG.getNode(ISD::BITCAST, dl, MulVT, Bhi);
15895
15896   SDValue AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
15897   SDValue AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
15898   SDValue AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
15899
15900   AloBhi = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AloBhi, 32, DAG);
15901   AhiBlo = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AhiBlo, 32, DAG);
15902
15903   SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
15904   return DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
15905 }
15906
15907 SDValue X86TargetLowering::LowerWin64_i128OP(SDValue Op, SelectionDAG &DAG) const {
15908   assert(Subtarget->isTargetWin64() && "Unexpected target");
15909   EVT VT = Op.getValueType();
15910   assert(VT.isInteger() && VT.getSizeInBits() == 128 &&
15911          "Unexpected return type for lowering");
15912
15913   RTLIB::Libcall LC;
15914   bool isSigned;
15915   switch (Op->getOpcode()) {
15916   default: llvm_unreachable("Unexpected request for libcall!");
15917   case ISD::SDIV:      isSigned = true;  LC = RTLIB::SDIV_I128;    break;
15918   case ISD::UDIV:      isSigned = false; LC = RTLIB::UDIV_I128;    break;
15919   case ISD::SREM:      isSigned = true;  LC = RTLIB::SREM_I128;    break;
15920   case ISD::UREM:      isSigned = false; LC = RTLIB::UREM_I128;    break;
15921   case ISD::SDIVREM:   isSigned = true;  LC = RTLIB::SDIVREM_I128; break;
15922   case ISD::UDIVREM:   isSigned = false; LC = RTLIB::UDIVREM_I128; break;
15923   }
15924
15925   SDLoc dl(Op);
15926   SDValue InChain = DAG.getEntryNode();
15927
15928   TargetLowering::ArgListTy Args;
15929   TargetLowering::ArgListEntry Entry;
15930   for (unsigned i = 0, e = Op->getNumOperands(); i != e; ++i) {
15931     EVT ArgVT = Op->getOperand(i).getValueType();
15932     assert(ArgVT.isInteger() && ArgVT.getSizeInBits() == 128 &&
15933            "Unexpected argument type for lowering");
15934     SDValue StackPtr = DAG.CreateStackTemporary(ArgVT, 16);
15935     Entry.Node = StackPtr;
15936     InChain = DAG.getStore(InChain, dl, Op->getOperand(i), StackPtr, MachinePointerInfo(),
15937                            false, false, 16);
15938     Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
15939     Entry.Ty = PointerType::get(ArgTy,0);
15940     Entry.isSExt = false;
15941     Entry.isZExt = false;
15942     Args.push_back(Entry);
15943   }
15944
15945   SDValue Callee = DAG.getExternalSymbol(getLibcallName(LC),
15946                                          getPointerTy());
15947
15948   TargetLowering::CallLoweringInfo CLI(DAG);
15949   CLI.setDebugLoc(dl).setChain(InChain)
15950     .setCallee(getLibcallCallingConv(LC),
15951                static_cast<EVT>(MVT::v2i64).getTypeForEVT(*DAG.getContext()),
15952                Callee, std::move(Args), 0)
15953     .setInRegister().setSExtResult(isSigned).setZExtResult(!isSigned);
15954
15955   std::pair<SDValue, SDValue> CallInfo = LowerCallTo(CLI);
15956   return DAG.getNode(ISD::BITCAST, dl, VT, CallInfo.first);
15957 }
15958
15959 static SDValue LowerMUL_LOHI(SDValue Op, const X86Subtarget *Subtarget,
15960                              SelectionDAG &DAG) {
15961   SDValue Op0 = Op.getOperand(0), Op1 = Op.getOperand(1);
15962   EVT VT = Op0.getValueType();
15963   SDLoc dl(Op);
15964
15965   assert((VT == MVT::v4i32 && Subtarget->hasSSE2()) ||
15966          (VT == MVT::v8i32 && Subtarget->hasInt256()));
15967
15968   // PMULxD operations multiply each even value (starting at 0) of LHS with
15969   // the related value of RHS and produce a widen result.
15970   // E.g., PMULUDQ <4 x i32> <a|b|c|d>, <4 x i32> <e|f|g|h>
15971   // => <2 x i64> <ae|cg>
15972   //
15973   // In other word, to have all the results, we need to perform two PMULxD:
15974   // 1. one with the even values.
15975   // 2. one with the odd values.
15976   // To achieve #2, with need to place the odd values at an even position.
15977   //
15978   // Place the odd value at an even position (basically, shift all values 1
15979   // step to the left):
15980   const int Mask[] = {1, -1, 3, -1, 5, -1, 7, -1};
15981   // <a|b|c|d> => <b|undef|d|undef>
15982   SDValue Odd0 = DAG.getVectorShuffle(VT, dl, Op0, Op0, Mask);
15983   // <e|f|g|h> => <f|undef|h|undef>
15984   SDValue Odd1 = DAG.getVectorShuffle(VT, dl, Op1, Op1, Mask);
15985
15986   // Emit two multiplies, one for the lower 2 ints and one for the higher 2
15987   // ints.
15988   MVT MulVT = VT == MVT::v4i32 ? MVT::v2i64 : MVT::v4i64;
15989   bool IsSigned = Op->getOpcode() == ISD::SMUL_LOHI;
15990   unsigned Opcode =
15991       (!IsSigned || !Subtarget->hasSSE41()) ? X86ISD::PMULUDQ : X86ISD::PMULDQ;
15992   // PMULUDQ <4 x i32> <a|b|c|d>, <4 x i32> <e|f|g|h>
15993   // => <2 x i64> <ae|cg>
15994   SDValue Mul1 = DAG.getNode(ISD::BITCAST, dl, VT,
15995                              DAG.getNode(Opcode, dl, MulVT, Op0, Op1));
15996   // PMULUDQ <4 x i32> <b|undef|d|undef>, <4 x i32> <f|undef|h|undef>
15997   // => <2 x i64> <bf|dh>
15998   SDValue Mul2 = DAG.getNode(ISD::BITCAST, dl, VT,
15999                              DAG.getNode(Opcode, dl, MulVT, Odd0, Odd1));
16000
16001   // Shuffle it back into the right order.
16002   SDValue Highs, Lows;
16003   if (VT == MVT::v8i32) {
16004     const int HighMask[] = {1, 9, 3, 11, 5, 13, 7, 15};
16005     Highs = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, HighMask);
16006     const int LowMask[] = {0, 8, 2, 10, 4, 12, 6, 14};
16007     Lows = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, LowMask);
16008   } else {
16009     const int HighMask[] = {1, 5, 3, 7};
16010     Highs = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, HighMask);
16011     const int LowMask[] = {0, 4, 2, 6};
16012     Lows = DAG.getVectorShuffle(VT, dl, Mul1, Mul2, LowMask);
16013   }
16014
16015   // If we have a signed multiply but no PMULDQ fix up the high parts of a
16016   // unsigned multiply.
16017   if (IsSigned && !Subtarget->hasSSE41()) {
16018     SDValue ShAmt =
16019         DAG.getConstant(31, DAG.getTargetLoweringInfo().getShiftAmountTy(VT));
16020     SDValue T1 = DAG.getNode(ISD::AND, dl, VT,
16021                              DAG.getNode(ISD::SRA, dl, VT, Op0, ShAmt), Op1);
16022     SDValue T2 = DAG.getNode(ISD::AND, dl, VT,
16023                              DAG.getNode(ISD::SRA, dl, VT, Op1, ShAmt), Op0);
16024
16025     SDValue Fixup = DAG.getNode(ISD::ADD, dl, VT, T1, T2);
16026     Highs = DAG.getNode(ISD::SUB, dl, VT, Highs, Fixup);
16027   }
16028
16029   // The first result of MUL_LOHI is actually the low value, followed by the
16030   // high value.
16031   SDValue Ops[] = {Lows, Highs};
16032   return DAG.getMergeValues(Ops, dl);
16033 }
16034
16035 static SDValue LowerScalarImmediateShift(SDValue Op, SelectionDAG &DAG,
16036                                          const X86Subtarget *Subtarget) {
16037   MVT VT = Op.getSimpleValueType();
16038   SDLoc dl(Op);
16039   SDValue R = Op.getOperand(0);
16040   SDValue Amt = Op.getOperand(1);
16041
16042   // Optimize shl/srl/sra with constant shift amount.
16043   if (auto *BVAmt = dyn_cast<BuildVectorSDNode>(Amt)) {
16044     if (auto *ShiftConst = BVAmt->getConstantSplatNode()) {
16045       uint64_t ShiftAmt = ShiftConst->getZExtValue();
16046
16047       if (VT == MVT::v2i64 || VT == MVT::v4i32 || VT == MVT::v8i16 ||
16048           (Subtarget->hasInt256() &&
16049            (VT == MVT::v4i64 || VT == MVT::v8i32 || VT == MVT::v16i16)) ||
16050           (Subtarget->hasAVX512() &&
16051            (VT == MVT::v8i64 || VT == MVT::v16i32))) {
16052         if (Op.getOpcode() == ISD::SHL)
16053           return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
16054                                             DAG);
16055         if (Op.getOpcode() == ISD::SRL)
16056           return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
16057                                             DAG);
16058         if (Op.getOpcode() == ISD::SRA && VT != MVT::v2i64 && VT != MVT::v4i64)
16059           return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
16060                                             DAG);
16061       }
16062
16063       if (VT == MVT::v16i8 || (Subtarget->hasInt256() && VT == MVT::v32i8)) {
16064         unsigned NumElts = VT.getVectorNumElements();
16065         MVT ShiftVT = MVT::getVectorVT(MVT::i16, NumElts / 2);
16066
16067         if (Op.getOpcode() == ISD::SHL) {
16068           // Make a large shift.
16069           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, ShiftVT,
16070                                                    R, ShiftAmt, DAG);
16071           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
16072           // Zero out the rightmost bits.
16073           SmallVector<SDValue, 32> V(
16074               NumElts, DAG.getConstant(uint8_t(-1U << ShiftAmt), MVT::i8));
16075           return DAG.getNode(ISD::AND, dl, VT, SHL,
16076                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
16077         }
16078         if (Op.getOpcode() == ISD::SRL) {
16079           // Make a large shift.
16080           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, ShiftVT,
16081                                                    R, ShiftAmt, DAG);
16082           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
16083           // Zero out the leftmost bits.
16084           SmallVector<SDValue, 32> V(
16085               NumElts, DAG.getConstant(uint8_t(-1U) >> ShiftAmt, MVT::i8));
16086           return DAG.getNode(ISD::AND, dl, VT, SRL,
16087                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
16088         }
16089         if (Op.getOpcode() == ISD::SRA) {
16090           if (ShiftAmt == 7) {
16091             // R s>> 7  ===  R s< 0
16092             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
16093             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
16094           }
16095
16096           // R s>> a === ((R u>> a) ^ m) - m
16097           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
16098           SmallVector<SDValue, 32> V(NumElts,
16099                                      DAG.getConstant(128 >> ShiftAmt, MVT::i8));
16100           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
16101           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
16102           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
16103           return Res;
16104         }
16105         llvm_unreachable("Unknown shift opcode.");
16106       }
16107     }
16108   }
16109
16110   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
16111   if (!Subtarget->is64Bit() &&
16112       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64)) &&
16113       Amt.getOpcode() == ISD::BITCAST &&
16114       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
16115     Amt = Amt.getOperand(0);
16116     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
16117                      VT.getVectorNumElements();
16118     unsigned RatioInLog2 = Log2_32_Ceil(Ratio);
16119     uint64_t ShiftAmt = 0;
16120     for (unsigned i = 0; i != Ratio; ++i) {
16121       ConstantSDNode *C = dyn_cast<ConstantSDNode>(Amt.getOperand(i));
16122       if (!C)
16123         return SDValue();
16124       // 6 == Log2(64)
16125       ShiftAmt |= C->getZExtValue() << (i * (1 << (6 - RatioInLog2)));
16126     }
16127     // Check remaining shift amounts.
16128     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
16129       uint64_t ShAmt = 0;
16130       for (unsigned j = 0; j != Ratio; ++j) {
16131         ConstantSDNode *C =
16132           dyn_cast<ConstantSDNode>(Amt.getOperand(i + j));
16133         if (!C)
16134           return SDValue();
16135         // 6 == Log2(64)
16136         ShAmt |= C->getZExtValue() << (j * (1 << (6 - RatioInLog2)));
16137       }
16138       if (ShAmt != ShiftAmt)
16139         return SDValue();
16140     }
16141     switch (Op.getOpcode()) {
16142     default:
16143       llvm_unreachable("Unknown shift opcode!");
16144     case ISD::SHL:
16145       return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
16146                                         DAG);
16147     case ISD::SRL:
16148       return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
16149                                         DAG);
16150     case ISD::SRA:
16151       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
16152                                         DAG);
16153     }
16154   }
16155
16156   return SDValue();
16157 }
16158
16159 static SDValue LowerScalarVariableShift(SDValue Op, SelectionDAG &DAG,
16160                                         const X86Subtarget* Subtarget) {
16161   MVT VT = Op.getSimpleValueType();
16162   SDLoc dl(Op);
16163   SDValue R = Op.getOperand(0);
16164   SDValue Amt = Op.getOperand(1);
16165
16166   if ((VT == MVT::v2i64 && Op.getOpcode() != ISD::SRA) ||
16167       VT == MVT::v4i32 || VT == MVT::v8i16 ||
16168       (Subtarget->hasInt256() &&
16169        ((VT == MVT::v4i64 && Op.getOpcode() != ISD::SRA) ||
16170         VT == MVT::v8i32 || VT == MVT::v16i16)) ||
16171        (Subtarget->hasAVX512() && (VT == MVT::v8i64 || VT == MVT::v16i32))) {
16172     SDValue BaseShAmt;
16173     EVT EltVT = VT.getVectorElementType();
16174
16175     if (BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Amt)) {
16176       // Check if this build_vector node is doing a splat.
16177       // If so, then set BaseShAmt equal to the splat value.
16178       BaseShAmt = BV->getSplatValue();
16179       if (BaseShAmt && BaseShAmt.getOpcode() == ISD::UNDEF)
16180         BaseShAmt = SDValue();
16181     } else {
16182       if (Amt.getOpcode() == ISD::EXTRACT_SUBVECTOR)
16183         Amt = Amt.getOperand(0);
16184
16185       ShuffleVectorSDNode *SVN = dyn_cast<ShuffleVectorSDNode>(Amt);
16186       if (SVN && SVN->isSplat()) {
16187         unsigned SplatIdx = (unsigned)SVN->getSplatIndex();
16188         SDValue InVec = Amt.getOperand(0);
16189         if (InVec.getOpcode() == ISD::BUILD_VECTOR) {
16190           assert((SplatIdx < InVec.getValueType().getVectorNumElements()) &&
16191                  "Unexpected shuffle index found!");
16192           BaseShAmt = InVec.getOperand(SplatIdx);
16193         } else if (InVec.getOpcode() == ISD::INSERT_VECTOR_ELT) {
16194            if (ConstantSDNode *C =
16195                dyn_cast<ConstantSDNode>(InVec.getOperand(2))) {
16196              if (C->getZExtValue() == SplatIdx)
16197                BaseShAmt = InVec.getOperand(1);
16198            }
16199         }
16200
16201         if (!BaseShAmt)
16202           // Avoid introducing an extract element from a shuffle.
16203           BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InVec,
16204                                     DAG.getIntPtrConstant(SplatIdx));
16205       }
16206     }
16207
16208     if (BaseShAmt.getNode()) {
16209       assert(EltVT.bitsLE(MVT::i64) && "Unexpected element type!");
16210       if (EltVT != MVT::i64 && EltVT.bitsGT(MVT::i32))
16211         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, BaseShAmt);
16212       else if (EltVT.bitsLT(MVT::i32))
16213         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
16214
16215       switch (Op.getOpcode()) {
16216       default:
16217         llvm_unreachable("Unknown shift opcode!");
16218       case ISD::SHL:
16219         switch (VT.SimpleTy) {
16220         default: return SDValue();
16221         case MVT::v2i64:
16222         case MVT::v4i32:
16223         case MVT::v8i16:
16224         case MVT::v4i64:
16225         case MVT::v8i32:
16226         case MVT::v16i16:
16227         case MVT::v16i32:
16228         case MVT::v8i64:
16229           return getTargetVShiftNode(X86ISD::VSHLI, dl, VT, R, BaseShAmt, DAG);
16230         }
16231       case ISD::SRA:
16232         switch (VT.SimpleTy) {
16233         default: return SDValue();
16234         case MVT::v4i32:
16235         case MVT::v8i16:
16236         case MVT::v8i32:
16237         case MVT::v16i16:
16238         case MVT::v16i32:
16239         case MVT::v8i64:
16240           return getTargetVShiftNode(X86ISD::VSRAI, dl, VT, R, BaseShAmt, DAG);
16241         }
16242       case ISD::SRL:
16243         switch (VT.SimpleTy) {
16244         default: return SDValue();
16245         case MVT::v2i64:
16246         case MVT::v4i32:
16247         case MVT::v8i16:
16248         case MVT::v4i64:
16249         case MVT::v8i32:
16250         case MVT::v16i16:
16251         case MVT::v16i32:
16252         case MVT::v8i64:
16253           return getTargetVShiftNode(X86ISD::VSRLI, dl, VT, R, BaseShAmt, DAG);
16254         }
16255       }
16256     }
16257   }
16258
16259   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
16260   if (!Subtarget->is64Bit() &&
16261       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64) ||
16262       (Subtarget->hasAVX512() && VT == MVT::v8i64)) &&
16263       Amt.getOpcode() == ISD::BITCAST &&
16264       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
16265     Amt = Amt.getOperand(0);
16266     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
16267                      VT.getVectorNumElements();
16268     std::vector<SDValue> Vals(Ratio);
16269     for (unsigned i = 0; i != Ratio; ++i)
16270       Vals[i] = Amt.getOperand(i);
16271     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
16272       for (unsigned j = 0; j != Ratio; ++j)
16273         if (Vals[j] != Amt.getOperand(i + j))
16274           return SDValue();
16275     }
16276     switch (Op.getOpcode()) {
16277     default:
16278       llvm_unreachable("Unknown shift opcode!");
16279     case ISD::SHL:
16280       return DAG.getNode(X86ISD::VSHL, dl, VT, R, Op.getOperand(1));
16281     case ISD::SRL:
16282       return DAG.getNode(X86ISD::VSRL, dl, VT, R, Op.getOperand(1));
16283     case ISD::SRA:
16284       return DAG.getNode(X86ISD::VSRA, dl, VT, R, Op.getOperand(1));
16285     }
16286   }
16287
16288   return SDValue();
16289 }
16290
16291 static SDValue LowerShift(SDValue Op, const X86Subtarget* Subtarget,
16292                           SelectionDAG &DAG) {
16293   MVT VT = Op.getSimpleValueType();
16294   SDLoc dl(Op);
16295   SDValue R = Op.getOperand(0);
16296   SDValue Amt = Op.getOperand(1);
16297
16298   assert(VT.isVector() && "Custom lowering only for vector shifts!");
16299   assert(Subtarget->hasSSE2() && "Only custom lower when we have SSE2!");
16300
16301   if (SDValue V = LowerScalarImmediateShift(Op, DAG, Subtarget))
16302     return V;
16303
16304   if (SDValue V = LowerScalarVariableShift(Op, DAG, Subtarget))
16305       return V;
16306
16307   if (Subtarget->hasAVX512() && (VT == MVT::v16i32 || VT == MVT::v8i64))
16308     return Op;
16309
16310   // AVX2 has VPSLLV/VPSRAV/VPSRLV.
16311   if (Subtarget->hasInt256()) {
16312     if (Op.getOpcode() == ISD::SRL &&
16313         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
16314          VT == MVT::v4i64 || VT == MVT::v8i32))
16315       return Op;
16316     if (Op.getOpcode() == ISD::SHL &&
16317         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
16318          VT == MVT::v4i64 || VT == MVT::v8i32))
16319       return Op;
16320     if (Op.getOpcode() == ISD::SRA && (VT == MVT::v4i32 || VT == MVT::v8i32))
16321       return Op;
16322   }
16323
16324   // 2i64 vector logical shifts can efficiently avoid scalarization - do the
16325   // shifts per-lane and then shuffle the partial results back together.
16326   if (VT == MVT::v2i64 && Op.getOpcode() != ISD::SRA) {
16327     // Splat the shift amounts so the scalar shifts above will catch it.
16328     SDValue Amt0 = DAG.getVectorShuffle(VT, dl, Amt, Amt, {0, 0});
16329     SDValue Amt1 = DAG.getVectorShuffle(VT, dl, Amt, Amt, {1, 1});
16330     SDValue R0 = DAG.getNode(Op->getOpcode(), dl, VT, R, Amt0);
16331     SDValue R1 = DAG.getNode(Op->getOpcode(), dl, VT, R, Amt1);
16332     return DAG.getVectorShuffle(VT, dl, R0, R1, {0, 3});
16333   }
16334
16335   // If possible, lower this packed shift into a vector multiply instead of
16336   // expanding it into a sequence of scalar shifts.
16337   // Do this only if the vector shift count is a constant build_vector.
16338   if (Op.getOpcode() == ISD::SHL &&
16339       (VT == MVT::v8i16 || VT == MVT::v4i32 ||
16340        (Subtarget->hasInt256() && VT == MVT::v16i16)) &&
16341       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
16342     SmallVector<SDValue, 8> Elts;
16343     EVT SVT = VT.getScalarType();
16344     unsigned SVTBits = SVT.getSizeInBits();
16345     const APInt &One = APInt(SVTBits, 1);
16346     unsigned NumElems = VT.getVectorNumElements();
16347
16348     for (unsigned i=0; i !=NumElems; ++i) {
16349       SDValue Op = Amt->getOperand(i);
16350       if (Op->getOpcode() == ISD::UNDEF) {
16351         Elts.push_back(Op);
16352         continue;
16353       }
16354
16355       ConstantSDNode *ND = cast<ConstantSDNode>(Op);
16356       const APInt &C = APInt(SVTBits, ND->getAPIntValue().getZExtValue());
16357       uint64_t ShAmt = C.getZExtValue();
16358       if (ShAmt >= SVTBits) {
16359         Elts.push_back(DAG.getUNDEF(SVT));
16360         continue;
16361       }
16362       Elts.push_back(DAG.getConstant(One.shl(ShAmt), SVT));
16363     }
16364     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
16365     return DAG.getNode(ISD::MUL, dl, VT, R, BV);
16366   }
16367
16368   // Lower SHL with variable shift amount.
16369   if (VT == MVT::v4i32 && Op->getOpcode() == ISD::SHL) {
16370     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, VT));
16371
16372     Op = DAG.getNode(ISD::ADD, dl, VT, Op, DAG.getConstant(0x3f800000U, VT));
16373     Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
16374     Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
16375     return DAG.getNode(ISD::MUL, dl, VT, Op, R);
16376   }
16377
16378   // If possible, lower this shift as a sequence of two shifts by
16379   // constant plus a MOVSS/MOVSD instead of scalarizing it.
16380   // Example:
16381   //   (v4i32 (srl A, (build_vector < X, Y, Y, Y>)))
16382   //
16383   // Could be rewritten as:
16384   //   (v4i32 (MOVSS (srl A, <Y,Y,Y,Y>), (srl A, <X,X,X,X>)))
16385   //
16386   // The advantage is that the two shifts from the example would be
16387   // lowered as X86ISD::VSRLI nodes. This would be cheaper than scalarizing
16388   // the vector shift into four scalar shifts plus four pairs of vector
16389   // insert/extract.
16390   if ((VT == MVT::v8i16 || VT == MVT::v4i32) &&
16391       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
16392     unsigned TargetOpcode = X86ISD::MOVSS;
16393     bool CanBeSimplified;
16394     // The splat value for the first packed shift (the 'X' from the example).
16395     SDValue Amt1 = Amt->getOperand(0);
16396     // The splat value for the second packed shift (the 'Y' from the example).
16397     SDValue Amt2 = (VT == MVT::v4i32) ? Amt->getOperand(1) :
16398                                         Amt->getOperand(2);
16399
16400     // See if it is possible to replace this node with a sequence of
16401     // two shifts followed by a MOVSS/MOVSD
16402     if (VT == MVT::v4i32) {
16403       // Check if it is legal to use a MOVSS.
16404       CanBeSimplified = Amt2 == Amt->getOperand(2) &&
16405                         Amt2 == Amt->getOperand(3);
16406       if (!CanBeSimplified) {
16407         // Otherwise, check if we can still simplify this node using a MOVSD.
16408         CanBeSimplified = Amt1 == Amt->getOperand(1) &&
16409                           Amt->getOperand(2) == Amt->getOperand(3);
16410         TargetOpcode = X86ISD::MOVSD;
16411         Amt2 = Amt->getOperand(2);
16412       }
16413     } else {
16414       // Do similar checks for the case where the machine value type
16415       // is MVT::v8i16.
16416       CanBeSimplified = Amt1 == Amt->getOperand(1);
16417       for (unsigned i=3; i != 8 && CanBeSimplified; ++i)
16418         CanBeSimplified = Amt2 == Amt->getOperand(i);
16419
16420       if (!CanBeSimplified) {
16421         TargetOpcode = X86ISD::MOVSD;
16422         CanBeSimplified = true;
16423         Amt2 = Amt->getOperand(4);
16424         for (unsigned i=0; i != 4 && CanBeSimplified; ++i)
16425           CanBeSimplified = Amt1 == Amt->getOperand(i);
16426         for (unsigned j=4; j != 8 && CanBeSimplified; ++j)
16427           CanBeSimplified = Amt2 == Amt->getOperand(j);
16428       }
16429     }
16430
16431     if (CanBeSimplified && isa<ConstantSDNode>(Amt1) &&
16432         isa<ConstantSDNode>(Amt2)) {
16433       // Replace this node with two shifts followed by a MOVSS/MOVSD.
16434       EVT CastVT = MVT::v4i32;
16435       SDValue Splat1 =
16436         DAG.getConstant(cast<ConstantSDNode>(Amt1)->getAPIntValue(), VT);
16437       SDValue Shift1 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat1);
16438       SDValue Splat2 =
16439         DAG.getConstant(cast<ConstantSDNode>(Amt2)->getAPIntValue(), VT);
16440       SDValue Shift2 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat2);
16441       if (TargetOpcode == X86ISD::MOVSD)
16442         CastVT = MVT::v2i64;
16443       SDValue BitCast1 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift1);
16444       SDValue BitCast2 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift2);
16445       SDValue Result = getTargetShuffleNode(TargetOpcode, dl, CastVT, BitCast2,
16446                                             BitCast1, DAG);
16447       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
16448     }
16449   }
16450
16451   if (VT == MVT::v16i8 && Op->getOpcode() == ISD::SHL) {
16452     assert(Subtarget->hasSSE2() && "Need SSE2 for pslli/pcmpeq.");
16453
16454     // a = a << 5;
16455     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(5, VT));
16456     Op = DAG.getNode(ISD::BITCAST, dl, VT, Op);
16457
16458     // Turn 'a' into a mask suitable for VSELECT
16459     SDValue VSelM = DAG.getConstant(0x80, VT);
16460     SDValue OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
16461     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
16462
16463     SDValue CM1 = DAG.getConstant(0x0f, VT);
16464     SDValue CM2 = DAG.getConstant(0x3f, VT);
16465
16466     // r = VSELECT(r, psllw(r & (char16)15, 4), a);
16467     SDValue M = DAG.getNode(ISD::AND, dl, VT, R, CM1);
16468     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 4, DAG);
16469     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
16470     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
16471
16472     // a += a
16473     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
16474     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
16475     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
16476
16477     // r = VSELECT(r, psllw(r & (char16)63, 2), a);
16478     M = DAG.getNode(ISD::AND, dl, VT, R, CM2);
16479     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 2, DAG);
16480     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
16481     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
16482
16483     // a += a
16484     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
16485     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
16486     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
16487
16488     // return VSELECT(r, r+r, a);
16489     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel,
16490                     DAG.getNode(ISD::ADD, dl, VT, R, R), R);
16491     return R;
16492   }
16493
16494   // It's worth extending once and using the v8i32 shifts for 16-bit types, but
16495   // the extra overheads to get from v16i8 to v8i32 make the existing SSE
16496   // solution better.
16497   if (Subtarget->hasInt256() && VT == MVT::v8i16) {
16498     MVT NewVT = VT == MVT::v8i16 ? MVT::v8i32 : MVT::v16i16;
16499     unsigned ExtOpc =
16500         Op.getOpcode() == ISD::SRA ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
16501     R = DAG.getNode(ExtOpc, dl, NewVT, R);
16502     Amt = DAG.getNode(ISD::ANY_EXTEND, dl, NewVT, Amt);
16503     return DAG.getNode(ISD::TRUNCATE, dl, VT,
16504                        DAG.getNode(Op.getOpcode(), dl, NewVT, R, Amt));
16505   }
16506
16507   // Decompose 256-bit shifts into smaller 128-bit shifts.
16508   if (VT.is256BitVector()) {
16509     unsigned NumElems = VT.getVectorNumElements();
16510     MVT EltVT = VT.getVectorElementType();
16511     EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
16512
16513     // Extract the two vectors
16514     SDValue V1 = Extract128BitVector(R, 0, DAG, dl);
16515     SDValue V2 = Extract128BitVector(R, NumElems/2, DAG, dl);
16516
16517     // Recreate the shift amount vectors
16518     SDValue Amt1, Amt2;
16519     if (Amt.getOpcode() == ISD::BUILD_VECTOR) {
16520       // Constant shift amount
16521       SmallVector<SDValue, 8> Ops(Amt->op_begin(), Amt->op_begin() + NumElems);
16522       ArrayRef<SDValue> Amt1Csts = makeArrayRef(Ops).slice(0, NumElems / 2);
16523       ArrayRef<SDValue> Amt2Csts = makeArrayRef(Ops).slice(NumElems / 2);
16524
16525       Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt1Csts);
16526       Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt2Csts);
16527     } else {
16528       // Variable shift amount
16529       Amt1 = Extract128BitVector(Amt, 0, DAG, dl);
16530       Amt2 = Extract128BitVector(Amt, NumElems/2, DAG, dl);
16531     }
16532
16533     // Issue new vector shifts for the smaller types
16534     V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
16535     V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
16536
16537     // Concatenate the result back
16538     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
16539   }
16540
16541   return SDValue();
16542 }
16543
16544 static SDValue LowerXALUO(SDValue Op, SelectionDAG &DAG) {
16545   // Lower the "add/sub/mul with overflow" instruction into a regular ins plus
16546   // a "setcc" instruction that checks the overflow flag. The "brcond" lowering
16547   // looks for this combo and may remove the "setcc" instruction if the "setcc"
16548   // has only one use.
16549   SDNode *N = Op.getNode();
16550   SDValue LHS = N->getOperand(0);
16551   SDValue RHS = N->getOperand(1);
16552   unsigned BaseOp = 0;
16553   unsigned Cond = 0;
16554   SDLoc DL(Op);
16555   switch (Op.getOpcode()) {
16556   default: llvm_unreachable("Unknown ovf instruction!");
16557   case ISD::SADDO:
16558     // A subtract of one will be selected as a INC. Note that INC doesn't
16559     // set CF, so we can't do this for UADDO.
16560     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
16561       if (C->isOne()) {
16562         BaseOp = X86ISD::INC;
16563         Cond = X86::COND_O;
16564         break;
16565       }
16566     BaseOp = X86ISD::ADD;
16567     Cond = X86::COND_O;
16568     break;
16569   case ISD::UADDO:
16570     BaseOp = X86ISD::ADD;
16571     Cond = X86::COND_B;
16572     break;
16573   case ISD::SSUBO:
16574     // A subtract of one will be selected as a DEC. Note that DEC doesn't
16575     // set CF, so we can't do this for USUBO.
16576     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
16577       if (C->isOne()) {
16578         BaseOp = X86ISD::DEC;
16579         Cond = X86::COND_O;
16580         break;
16581       }
16582     BaseOp = X86ISD::SUB;
16583     Cond = X86::COND_O;
16584     break;
16585   case ISD::USUBO:
16586     BaseOp = X86ISD::SUB;
16587     Cond = X86::COND_B;
16588     break;
16589   case ISD::SMULO:
16590     BaseOp = N->getValueType(0) == MVT::i8 ? X86ISD::SMUL8 : X86ISD::SMUL;
16591     Cond = X86::COND_O;
16592     break;
16593   case ISD::UMULO: { // i64, i8 = umulo lhs, rhs --> i64, i64, i32 umul lhs,rhs
16594     if (N->getValueType(0) == MVT::i8) {
16595       BaseOp = X86ISD::UMUL8;
16596       Cond = X86::COND_O;
16597       break;
16598     }
16599     SDVTList VTs = DAG.getVTList(N->getValueType(0), N->getValueType(0),
16600                                  MVT::i32);
16601     SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
16602
16603     SDValue SetCC =
16604       DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
16605                   DAG.getConstant(X86::COND_O, MVT::i32),
16606                   SDValue(Sum.getNode(), 2));
16607
16608     return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
16609   }
16610   }
16611
16612   // Also sets EFLAGS.
16613   SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::i32);
16614   SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
16615
16616   SDValue SetCC =
16617     DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
16618                 DAG.getConstant(Cond, MVT::i32),
16619                 SDValue(Sum.getNode(), 1));
16620
16621   return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
16622 }
16623
16624 /// Returns true if the operand type is exactly twice the native width, and
16625 /// the corresponding cmpxchg8b or cmpxchg16b instruction is available.
16626 /// Used to know whether to use cmpxchg8/16b when expanding atomic operations
16627 /// (otherwise we leave them alone to become __sync_fetch_and_... calls).
16628 bool X86TargetLowering::needsCmpXchgNb(const Type *MemType) const {
16629   unsigned OpWidth = MemType->getPrimitiveSizeInBits();
16630
16631   if (OpWidth == 64)
16632     return !Subtarget->is64Bit(); // FIXME this should be Subtarget.hasCmpxchg8b
16633   else if (OpWidth == 128)
16634     return Subtarget->hasCmpxchg16b();
16635   else
16636     return false;
16637 }
16638
16639 bool X86TargetLowering::shouldExpandAtomicStoreInIR(StoreInst *SI) const {
16640   return needsCmpXchgNb(SI->getValueOperand()->getType());
16641 }
16642
16643 // Note: this turns large loads into lock cmpxchg8b/16b.
16644 // FIXME: On 32 bits x86, fild/movq might be faster than lock cmpxchg8b.
16645 bool X86TargetLowering::shouldExpandAtomicLoadInIR(LoadInst *LI) const {
16646   auto PTy = cast<PointerType>(LI->getPointerOperand()->getType());
16647   return needsCmpXchgNb(PTy->getElementType());
16648 }
16649
16650 TargetLoweringBase::AtomicRMWExpansionKind
16651 X86TargetLowering::shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const {
16652   unsigned NativeWidth = Subtarget->is64Bit() ? 64 : 32;
16653   const Type *MemType = AI->getType();
16654
16655   // If the operand is too big, we must see if cmpxchg8/16b is available
16656   // and default to library calls otherwise.
16657   if (MemType->getPrimitiveSizeInBits() > NativeWidth) {
16658     return needsCmpXchgNb(MemType) ? AtomicRMWExpansionKind::CmpXChg
16659                                    : AtomicRMWExpansionKind::None;
16660   }
16661
16662   AtomicRMWInst::BinOp Op = AI->getOperation();
16663   switch (Op) {
16664   default:
16665     llvm_unreachable("Unknown atomic operation");
16666   case AtomicRMWInst::Xchg:
16667   case AtomicRMWInst::Add:
16668   case AtomicRMWInst::Sub:
16669     // It's better to use xadd, xsub or xchg for these in all cases.
16670     return AtomicRMWExpansionKind::None;
16671   case AtomicRMWInst::Or:
16672   case AtomicRMWInst::And:
16673   case AtomicRMWInst::Xor:
16674     // If the atomicrmw's result isn't actually used, we can just add a "lock"
16675     // prefix to a normal instruction for these operations.
16676     return !AI->use_empty() ? AtomicRMWExpansionKind::CmpXChg
16677                             : AtomicRMWExpansionKind::None;
16678   case AtomicRMWInst::Nand:
16679   case AtomicRMWInst::Max:
16680   case AtomicRMWInst::Min:
16681   case AtomicRMWInst::UMax:
16682   case AtomicRMWInst::UMin:
16683     // These always require a non-trivial set of data operations on x86. We must
16684     // use a cmpxchg loop.
16685     return AtomicRMWExpansionKind::CmpXChg;
16686   }
16687 }
16688
16689 static bool hasMFENCE(const X86Subtarget& Subtarget) {
16690   // Use mfence if we have SSE2 or we're on x86-64 (even if we asked for
16691   // no-sse2). There isn't any reason to disable it if the target processor
16692   // supports it.
16693   return Subtarget.hasSSE2() || Subtarget.is64Bit();
16694 }
16695
16696 LoadInst *
16697 X86TargetLowering::lowerIdempotentRMWIntoFencedLoad(AtomicRMWInst *AI) const {
16698   unsigned NativeWidth = Subtarget->is64Bit() ? 64 : 32;
16699   const Type *MemType = AI->getType();
16700   // Accesses larger than the native width are turned into cmpxchg/libcalls, so
16701   // there is no benefit in turning such RMWs into loads, and it is actually
16702   // harmful as it introduces a mfence.
16703   if (MemType->getPrimitiveSizeInBits() > NativeWidth)
16704     return nullptr;
16705
16706   auto Builder = IRBuilder<>(AI);
16707   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
16708   auto SynchScope = AI->getSynchScope();
16709   // We must restrict the ordering to avoid generating loads with Release or
16710   // ReleaseAcquire orderings.
16711   auto Order = AtomicCmpXchgInst::getStrongestFailureOrdering(AI->getOrdering());
16712   auto Ptr = AI->getPointerOperand();
16713
16714   // Before the load we need a fence. Here is an example lifted from
16715   // http://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf showing why a fence
16716   // is required:
16717   // Thread 0:
16718   //   x.store(1, relaxed);
16719   //   r1 = y.fetch_add(0, release);
16720   // Thread 1:
16721   //   y.fetch_add(42, acquire);
16722   //   r2 = x.load(relaxed);
16723   // r1 = r2 = 0 is impossible, but becomes possible if the idempotent rmw is
16724   // lowered to just a load without a fence. A mfence flushes the store buffer,
16725   // making the optimization clearly correct.
16726   // FIXME: it is required if isAtLeastRelease(Order) but it is not clear
16727   // otherwise, we might be able to be more agressive on relaxed idempotent
16728   // rmw. In practice, they do not look useful, so we don't try to be
16729   // especially clever.
16730   if (SynchScope == SingleThread) {
16731     // FIXME: we could just insert an X86ISD::MEMBARRIER here, except we are at
16732     // the IR level, so we must wrap it in an intrinsic.
16733     return nullptr;
16734   } else if (hasMFENCE(*Subtarget)) {
16735     Function *MFence = llvm::Intrinsic::getDeclaration(M,
16736             Intrinsic::x86_sse2_mfence);
16737     Builder.CreateCall(MFence);
16738   } else {
16739     // FIXME: it might make sense to use a locked operation here but on a
16740     // different cache-line to prevent cache-line bouncing. In practice it
16741     // is probably a small win, and x86 processors without mfence are rare
16742     // enough that we do not bother.
16743     return nullptr;
16744   }
16745
16746   // Finally we can emit the atomic load.
16747   LoadInst *Loaded = Builder.CreateAlignedLoad(Ptr,
16748           AI->getType()->getPrimitiveSizeInBits());
16749   Loaded->setAtomic(Order, SynchScope);
16750   AI->replaceAllUsesWith(Loaded);
16751   AI->eraseFromParent();
16752   return Loaded;
16753 }
16754
16755 static SDValue LowerATOMIC_FENCE(SDValue Op, const X86Subtarget *Subtarget,
16756                                  SelectionDAG &DAG) {
16757   SDLoc dl(Op);
16758   AtomicOrdering FenceOrdering = static_cast<AtomicOrdering>(
16759     cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue());
16760   SynchronizationScope FenceScope = static_cast<SynchronizationScope>(
16761     cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue());
16762
16763   // The only fence that needs an instruction is a sequentially-consistent
16764   // cross-thread fence.
16765   if (FenceOrdering == SequentiallyConsistent && FenceScope == CrossThread) {
16766     if (hasMFENCE(*Subtarget))
16767       return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
16768
16769     SDValue Chain = Op.getOperand(0);
16770     SDValue Zero = DAG.getConstant(0, MVT::i32);
16771     SDValue Ops[] = {
16772       DAG.getRegister(X86::ESP, MVT::i32), // Base
16773       DAG.getTargetConstant(1, MVT::i8),   // Scale
16774       DAG.getRegister(0, MVT::i32),        // Index
16775       DAG.getTargetConstant(0, MVT::i32),  // Disp
16776       DAG.getRegister(0, MVT::i32),        // Segment.
16777       Zero,
16778       Chain
16779     };
16780     SDNode *Res = DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops);
16781     return SDValue(Res, 0);
16782   }
16783
16784   // MEMBARRIER is a compiler barrier; it codegens to a no-op.
16785   return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
16786 }
16787
16788 static SDValue LowerCMP_SWAP(SDValue Op, const X86Subtarget *Subtarget,
16789                              SelectionDAG &DAG) {
16790   MVT T = Op.getSimpleValueType();
16791   SDLoc DL(Op);
16792   unsigned Reg = 0;
16793   unsigned size = 0;
16794   switch(T.SimpleTy) {
16795   default: llvm_unreachable("Invalid value type!");
16796   case MVT::i8:  Reg = X86::AL;  size = 1; break;
16797   case MVT::i16: Reg = X86::AX;  size = 2; break;
16798   case MVT::i32: Reg = X86::EAX; size = 4; break;
16799   case MVT::i64:
16800     assert(Subtarget->is64Bit() && "Node not type legal!");
16801     Reg = X86::RAX; size = 8;
16802     break;
16803   }
16804   SDValue cpIn = DAG.getCopyToReg(Op.getOperand(0), DL, Reg,
16805                                   Op.getOperand(2), SDValue());
16806   SDValue Ops[] = { cpIn.getValue(0),
16807                     Op.getOperand(1),
16808                     Op.getOperand(3),
16809                     DAG.getTargetConstant(size, MVT::i8),
16810                     cpIn.getValue(1) };
16811   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
16812   MachineMemOperand *MMO = cast<AtomicSDNode>(Op)->getMemOperand();
16813   SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG_DAG, DL, Tys,
16814                                            Ops, T, MMO);
16815
16816   SDValue cpOut =
16817     DAG.getCopyFromReg(Result.getValue(0), DL, Reg, T, Result.getValue(1));
16818   SDValue EFLAGS = DAG.getCopyFromReg(cpOut.getValue(1), DL, X86::EFLAGS,
16819                                       MVT::i32, cpOut.getValue(2));
16820   SDValue Success = DAG.getNode(X86ISD::SETCC, DL, Op->getValueType(1),
16821                                 DAG.getConstant(X86::COND_E, MVT::i8), EFLAGS);
16822
16823   DAG.ReplaceAllUsesOfValueWith(Op.getValue(0), cpOut);
16824   DAG.ReplaceAllUsesOfValueWith(Op.getValue(1), Success);
16825   DAG.ReplaceAllUsesOfValueWith(Op.getValue(2), EFLAGS.getValue(1));
16826   return SDValue();
16827 }
16828
16829 static SDValue LowerBITCAST(SDValue Op, const X86Subtarget *Subtarget,
16830                             SelectionDAG &DAG) {
16831   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
16832   MVT DstVT = Op.getSimpleValueType();
16833
16834   if (SrcVT == MVT::v2i32 || SrcVT == MVT::v4i16 || SrcVT == MVT::v8i8) {
16835     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
16836     if (DstVT != MVT::f64)
16837       // This conversion needs to be expanded.
16838       return SDValue();
16839
16840     SDValue InVec = Op->getOperand(0);
16841     SDLoc dl(Op);
16842     unsigned NumElts = SrcVT.getVectorNumElements();
16843     EVT SVT = SrcVT.getVectorElementType();
16844
16845     // Widen the vector in input in the case of MVT::v2i32.
16846     // Example: from MVT::v2i32 to MVT::v4i32.
16847     SmallVector<SDValue, 16> Elts;
16848     for (unsigned i = 0, e = NumElts; i != e; ++i)
16849       Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT, InVec,
16850                                  DAG.getIntPtrConstant(i)));
16851
16852     // Explicitly mark the extra elements as Undef.
16853     Elts.append(NumElts, DAG.getUNDEF(SVT));
16854
16855     EVT NewVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumElts * 2);
16856     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Elts);
16857     SDValue ToV2F64 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, BV);
16858     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, ToV2F64,
16859                        DAG.getIntPtrConstant(0));
16860   }
16861
16862   assert(Subtarget->is64Bit() && !Subtarget->hasSSE2() &&
16863          Subtarget->hasMMX() && "Unexpected custom BITCAST");
16864   assert((DstVT == MVT::i64 ||
16865           (DstVT.isVector() && DstVT.getSizeInBits()==64)) &&
16866          "Unexpected custom BITCAST");
16867   // i64 <=> MMX conversions are Legal.
16868   if (SrcVT==MVT::i64 && DstVT.isVector())
16869     return Op;
16870   if (DstVT==MVT::i64 && SrcVT.isVector())
16871     return Op;
16872   // MMX <=> MMX conversions are Legal.
16873   if (SrcVT.isVector() && DstVT.isVector())
16874     return Op;
16875   // All other conversions need to be expanded.
16876   return SDValue();
16877 }
16878
16879 static SDValue LowerCTPOP(SDValue Op, const X86Subtarget *Subtarget,
16880                           SelectionDAG &DAG) {
16881   SDNode *Node = Op.getNode();
16882   SDLoc dl(Node);
16883
16884   Op = Op.getOperand(0);
16885   EVT VT = Op.getValueType();
16886   assert((VT.is128BitVector() || VT.is256BitVector()) &&
16887          "CTPOP lowering only implemented for 128/256-bit wide vector types");
16888
16889   unsigned NumElts = VT.getVectorNumElements();
16890   EVT EltVT = VT.getVectorElementType();
16891   unsigned Len = EltVT.getSizeInBits();
16892
16893   // This is the vectorized version of the "best" algorithm from
16894   // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
16895   // with a minor tweak to use a series of adds + shifts instead of vector
16896   // multiplications. Implemented for the v2i64, v4i64, v4i32, v8i32 types:
16897   //
16898   //  v2i64, v4i64, v4i32 => Only profitable w/ popcnt disabled
16899   //  v8i32 => Always profitable
16900   //
16901   // FIXME: There a couple of possible improvements:
16902   //
16903   // 1) Support for i8 and i16 vectors (needs measurements if popcnt enabled).
16904   // 2) Use strategies from http://wm.ite.pl/articles/sse-popcount.html
16905   //
16906   assert(EltVT.isInteger() && (Len == 32 || Len == 64) && Len % 8 == 0 &&
16907          "CTPOP not implemented for this vector element type.");
16908
16909   // X86 canonicalize ANDs to vXi64, generate the appropriate bitcasts to avoid
16910   // extra legalization.
16911   bool NeedsBitcast = EltVT == MVT::i32;
16912   MVT BitcastVT = VT.is256BitVector() ? MVT::v4i64 : MVT::v2i64;
16913
16914   SDValue Cst55 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x55)), EltVT);
16915   SDValue Cst33 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x33)), EltVT);
16916   SDValue Cst0F = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x0F)), EltVT);
16917
16918   // v = v - ((v >> 1) & 0x55555555...)
16919   SmallVector<SDValue, 8> Ones(NumElts, DAG.getConstant(1, EltVT));
16920   SDValue OnesV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ones);
16921   SDValue Srl = DAG.getNode(ISD::SRL, dl, VT, Op, OnesV);
16922   if (NeedsBitcast)
16923     Srl = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Srl);
16924
16925   SmallVector<SDValue, 8> Mask55(NumElts, Cst55);
16926   SDValue M55 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask55);
16927   if (NeedsBitcast)
16928     M55 = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M55);
16929
16930   SDValue And = DAG.getNode(ISD::AND, dl, Srl.getValueType(), Srl, M55);
16931   if (VT != And.getValueType())
16932     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
16933   SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, Op, And);
16934
16935   // v = (v & 0x33333333...) + ((v >> 2) & 0x33333333...)
16936   SmallVector<SDValue, 8> Mask33(NumElts, Cst33);
16937   SDValue M33 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask33);
16938   SmallVector<SDValue, 8> Twos(NumElts, DAG.getConstant(2, EltVT));
16939   SDValue TwosV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Twos);
16940
16941   Srl = DAG.getNode(ISD::SRL, dl, VT, Sub, TwosV);
16942   if (NeedsBitcast) {
16943     Srl = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Srl);
16944     M33 = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M33);
16945     Sub = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Sub);
16946   }
16947
16948   SDValue AndRHS = DAG.getNode(ISD::AND, dl, M33.getValueType(), Srl, M33);
16949   SDValue AndLHS = DAG.getNode(ISD::AND, dl, M33.getValueType(), Sub, M33);
16950   if (VT != AndRHS.getValueType()) {
16951     AndRHS = DAG.getNode(ISD::BITCAST, dl, VT, AndRHS);
16952     AndLHS = DAG.getNode(ISD::BITCAST, dl, VT, AndLHS);
16953   }
16954   SDValue Add = DAG.getNode(ISD::ADD, dl, VT, AndLHS, AndRHS);
16955
16956   // v = (v + (v >> 4)) & 0x0F0F0F0F...
16957   SmallVector<SDValue, 8> Fours(NumElts, DAG.getConstant(4, EltVT));
16958   SDValue FoursV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Fours);
16959   Srl = DAG.getNode(ISD::SRL, dl, VT, Add, FoursV);
16960   Add = DAG.getNode(ISD::ADD, dl, VT, Add, Srl);
16961
16962   SmallVector<SDValue, 8> Mask0F(NumElts, Cst0F);
16963   SDValue M0F = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Mask0F);
16964   if (NeedsBitcast) {
16965     Add = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Add);
16966     M0F = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M0F);
16967   }
16968   And = DAG.getNode(ISD::AND, dl, M0F.getValueType(), Add, M0F);
16969   if (VT != And.getValueType())
16970     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
16971
16972   // The algorithm mentioned above uses:
16973   //    v = (v * 0x01010101...) >> (Len - 8)
16974   //
16975   // Change it to use vector adds + vector shifts which yield faster results on
16976   // Haswell than using vector integer multiplication.
16977   //
16978   // For i32 elements:
16979   //    v = v + (v >> 8)
16980   //    v = v + (v >> 16)
16981   //
16982   // For i64 elements:
16983   //    v = v + (v >> 8)
16984   //    v = v + (v >> 16)
16985   //    v = v + (v >> 32)
16986   //
16987   Add = And;
16988   SmallVector<SDValue, 8> Csts;
16989   for (unsigned i = 8; i <= Len/2; i *= 2) {
16990     Csts.assign(NumElts, DAG.getConstant(i, EltVT));
16991     SDValue CstsV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Csts);
16992     Srl = DAG.getNode(ISD::SRL, dl, VT, Add, CstsV);
16993     Add = DAG.getNode(ISD::ADD, dl, VT, Add, Srl);
16994     Csts.clear();
16995   }
16996
16997   // The result is on the least significant 6-bits on i32 and 7-bits on i64.
16998   SDValue Cst3F = DAG.getConstant(APInt(Len, Len == 32 ? 0x3F : 0x7F), EltVT);
16999   SmallVector<SDValue, 8> Cst3FV(NumElts, Cst3F);
17000   SDValue M3F = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Cst3FV);
17001   if (NeedsBitcast) {
17002     Add = DAG.getNode(ISD::BITCAST, dl, BitcastVT, Add);
17003     M3F = DAG.getNode(ISD::BITCAST, dl, BitcastVT, M3F);
17004   }
17005   And = DAG.getNode(ISD::AND, dl, M3F.getValueType(), Add, M3F);
17006   if (VT != And.getValueType())
17007     And = DAG.getNode(ISD::BITCAST, dl, VT, And);
17008
17009   return And;
17010 }
17011
17012 static SDValue LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) {
17013   SDNode *Node = Op.getNode();
17014   SDLoc dl(Node);
17015   EVT T = Node->getValueType(0);
17016   SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
17017                               DAG.getConstant(0, T), Node->getOperand(2));
17018   return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, dl,
17019                        cast<AtomicSDNode>(Node)->getMemoryVT(),
17020                        Node->getOperand(0),
17021                        Node->getOperand(1), negOp,
17022                        cast<AtomicSDNode>(Node)->getMemOperand(),
17023                        cast<AtomicSDNode>(Node)->getOrdering(),
17024                        cast<AtomicSDNode>(Node)->getSynchScope());
17025 }
17026
17027 static SDValue LowerATOMIC_STORE(SDValue Op, SelectionDAG &DAG) {
17028   SDNode *Node = Op.getNode();
17029   SDLoc dl(Node);
17030   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
17031
17032   // Convert seq_cst store -> xchg
17033   // Convert wide store -> swap (-> cmpxchg8b/cmpxchg16b)
17034   // FIXME: On 32-bit, store -> fist or movq would be more efficient
17035   //        (The only way to get a 16-byte store is cmpxchg16b)
17036   // FIXME: 16-byte ATOMIC_SWAP isn't actually hooked up at the moment.
17037   if (cast<AtomicSDNode>(Node)->getOrdering() == SequentiallyConsistent ||
17038       !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
17039     SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
17040                                  cast<AtomicSDNode>(Node)->getMemoryVT(),
17041                                  Node->getOperand(0),
17042                                  Node->getOperand(1), Node->getOperand(2),
17043                                  cast<AtomicSDNode>(Node)->getMemOperand(),
17044                                  cast<AtomicSDNode>(Node)->getOrdering(),
17045                                  cast<AtomicSDNode>(Node)->getSynchScope());
17046     return Swap.getValue(1);
17047   }
17048   // Other atomic stores have a simple pattern.
17049   return Op;
17050 }
17051
17052 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
17053   EVT VT = Op.getNode()->getSimpleValueType(0);
17054
17055   // Let legalize expand this if it isn't a legal type yet.
17056   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
17057     return SDValue();
17058
17059   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
17060
17061   unsigned Opc;
17062   bool ExtraOp = false;
17063   switch (Op.getOpcode()) {
17064   default: llvm_unreachable("Invalid code");
17065   case ISD::ADDC: Opc = X86ISD::ADD; break;
17066   case ISD::ADDE: Opc = X86ISD::ADC; ExtraOp = true; break;
17067   case ISD::SUBC: Opc = X86ISD::SUB; break;
17068   case ISD::SUBE: Opc = X86ISD::SBB; ExtraOp = true; break;
17069   }
17070
17071   if (!ExtraOp)
17072     return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
17073                        Op.getOperand(1));
17074   return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
17075                      Op.getOperand(1), Op.getOperand(2));
17076 }
17077
17078 static SDValue LowerFSINCOS(SDValue Op, const X86Subtarget *Subtarget,
17079                             SelectionDAG &DAG) {
17080   assert(Subtarget->isTargetDarwin() && Subtarget->is64Bit());
17081
17082   // For MacOSX, we want to call an alternative entry point: __sincos_stret,
17083   // which returns the values as { float, float } (in XMM0) or
17084   // { double, double } (which is returned in XMM0, XMM1).
17085   SDLoc dl(Op);
17086   SDValue Arg = Op.getOperand(0);
17087   EVT ArgVT = Arg.getValueType();
17088   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
17089
17090   TargetLowering::ArgListTy Args;
17091   TargetLowering::ArgListEntry Entry;
17092
17093   Entry.Node = Arg;
17094   Entry.Ty = ArgTy;
17095   Entry.isSExt = false;
17096   Entry.isZExt = false;
17097   Args.push_back(Entry);
17098
17099   bool isF64 = ArgVT == MVT::f64;
17100   // Only optimize x86_64 for now. i386 is a bit messy. For f32,
17101   // the small struct {f32, f32} is returned in (eax, edx). For f64,
17102   // the results are returned via SRet in memory.
17103   const char *LibcallName =  isF64 ? "__sincos_stret" : "__sincosf_stret";
17104   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
17105   SDValue Callee = DAG.getExternalSymbol(LibcallName, TLI.getPointerTy());
17106
17107   Type *RetTy = isF64
17108     ? (Type*)StructType::get(ArgTy, ArgTy, nullptr)
17109     : (Type*)VectorType::get(ArgTy, 4);
17110
17111   TargetLowering::CallLoweringInfo CLI(DAG);
17112   CLI.setDebugLoc(dl).setChain(DAG.getEntryNode())
17113     .setCallee(CallingConv::C, RetTy, Callee, std::move(Args), 0);
17114
17115   std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
17116
17117   if (isF64)
17118     // Returned in xmm0 and xmm1.
17119     return CallResult.first;
17120
17121   // Returned in bits 0:31 and 32:64 xmm0.
17122   SDValue SinVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
17123                                CallResult.first, DAG.getIntPtrConstant(0));
17124   SDValue CosVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
17125                                CallResult.first, DAG.getIntPtrConstant(1));
17126   SDVTList Tys = DAG.getVTList(ArgVT, ArgVT);
17127   return DAG.getNode(ISD::MERGE_VALUES, dl, Tys, SinVal, CosVal);
17128 }
17129
17130 /// LowerOperation - Provide custom lowering hooks for some operations.
17131 ///
17132 SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
17133   switch (Op.getOpcode()) {
17134   default: llvm_unreachable("Should not custom lower this!");
17135   case ISD::ATOMIC_FENCE:       return LowerATOMIC_FENCE(Op, Subtarget, DAG);
17136   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS:
17137     return LowerCMP_SWAP(Op, Subtarget, DAG);
17138   case ISD::CTPOP:              return LowerCTPOP(Op, Subtarget, DAG);
17139   case ISD::ATOMIC_LOAD_SUB:    return LowerLOAD_SUB(Op,DAG);
17140   case ISD::ATOMIC_STORE:       return LowerATOMIC_STORE(Op,DAG);
17141   case ISD::BUILD_VECTOR:       return LowerBUILD_VECTOR(Op, DAG);
17142   case ISD::CONCAT_VECTORS:     return LowerCONCAT_VECTORS(Op, Subtarget, DAG);
17143   case ISD::VECTOR_SHUFFLE:     return lowerVectorShuffle(Op, Subtarget, DAG);
17144   case ISD::VSELECT:            return LowerVSELECT(Op, DAG);
17145   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
17146   case ISD::INSERT_VECTOR_ELT:  return LowerINSERT_VECTOR_ELT(Op, DAG);
17147   case ISD::EXTRACT_SUBVECTOR:  return LowerEXTRACT_SUBVECTOR(Op,Subtarget,DAG);
17148   case ISD::INSERT_SUBVECTOR:   return LowerINSERT_SUBVECTOR(Op, Subtarget,DAG);
17149   case ISD::SCALAR_TO_VECTOR:   return LowerSCALAR_TO_VECTOR(Op, DAG);
17150   case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
17151   case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
17152   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
17153   case ISD::ExternalSymbol:     return LowerExternalSymbol(Op, DAG);
17154   case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
17155   case ISD::SHL_PARTS:
17156   case ISD::SRA_PARTS:
17157   case ISD::SRL_PARTS:          return LowerShiftParts(Op, DAG);
17158   case ISD::SINT_TO_FP:         return LowerSINT_TO_FP(Op, DAG);
17159   case ISD::UINT_TO_FP:         return LowerUINT_TO_FP(Op, DAG);
17160   case ISD::TRUNCATE:           return LowerTRUNCATE(Op, DAG);
17161   case ISD::ZERO_EXTEND:        return LowerZERO_EXTEND(Op, Subtarget, DAG);
17162   case ISD::SIGN_EXTEND:        return LowerSIGN_EXTEND(Op, Subtarget, DAG);
17163   case ISD::ANY_EXTEND:         return LowerANY_EXTEND(Op, Subtarget, DAG);
17164   case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
17165   case ISD::FP_TO_UINT:         return LowerFP_TO_UINT(Op, DAG);
17166   case ISD::FP_EXTEND:          return LowerFP_EXTEND(Op, DAG);
17167   case ISD::LOAD:               return LowerExtendedLoad(Op, Subtarget, DAG);
17168   case ISD::FABS:
17169   case ISD::FNEG:               return LowerFABSorFNEG(Op, DAG);
17170   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
17171   case ISD::FGETSIGN:           return LowerFGETSIGN(Op, DAG);
17172   case ISD::SETCC:              return LowerSETCC(Op, DAG);
17173   case ISD::SELECT:             return LowerSELECT(Op, DAG);
17174   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
17175   case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
17176   case ISD::VASTART:            return LowerVASTART(Op, DAG);
17177   case ISD::VAARG:              return LowerVAARG(Op, DAG);
17178   case ISD::VACOPY:             return LowerVACOPY(Op, Subtarget, DAG);
17179   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, Subtarget, DAG);
17180   case ISD::INTRINSIC_VOID:
17181   case ISD::INTRINSIC_W_CHAIN:  return LowerINTRINSIC_W_CHAIN(Op, Subtarget, DAG);
17182   case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
17183   case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
17184   case ISD::FRAME_TO_ARGS_OFFSET:
17185                                 return LowerFRAME_TO_ARGS_OFFSET(Op, DAG);
17186   case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
17187   case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
17188   case ISD::EH_SJLJ_SETJMP:     return lowerEH_SJLJ_SETJMP(Op, DAG);
17189   case ISD::EH_SJLJ_LONGJMP:    return lowerEH_SJLJ_LONGJMP(Op, DAG);
17190   case ISD::INIT_TRAMPOLINE:    return LowerINIT_TRAMPOLINE(Op, DAG);
17191   case ISD::ADJUST_TRAMPOLINE:  return LowerADJUST_TRAMPOLINE(Op, DAG);
17192   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
17193   case ISD::CTLZ:               return LowerCTLZ(Op, DAG);
17194   case ISD::CTLZ_ZERO_UNDEF:    return LowerCTLZ_ZERO_UNDEF(Op, DAG);
17195   case ISD::CTTZ:               return LowerCTTZ(Op, DAG);
17196   case ISD::MUL:                return LowerMUL(Op, Subtarget, DAG);
17197   case ISD::UMUL_LOHI:
17198   case ISD::SMUL_LOHI:          return LowerMUL_LOHI(Op, Subtarget, DAG);
17199   case ISD::SRA:
17200   case ISD::SRL:
17201   case ISD::SHL:                return LowerShift(Op, Subtarget, DAG);
17202   case ISD::SADDO:
17203   case ISD::UADDO:
17204   case ISD::SSUBO:
17205   case ISD::USUBO:
17206   case ISD::SMULO:
17207   case ISD::UMULO:              return LowerXALUO(Op, DAG);
17208   case ISD::READCYCLECOUNTER:   return LowerREADCYCLECOUNTER(Op, Subtarget,DAG);
17209   case ISD::BITCAST:            return LowerBITCAST(Op, Subtarget, DAG);
17210   case ISD::ADDC:
17211   case ISD::ADDE:
17212   case ISD::SUBC:
17213   case ISD::SUBE:               return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
17214   case ISD::ADD:                return LowerADD(Op, DAG);
17215   case ISD::SUB:                return LowerSUB(Op, DAG);
17216   case ISD::FSINCOS:            return LowerFSINCOS(Op, Subtarget, DAG);
17217   }
17218 }
17219
17220 /// ReplaceNodeResults - Replace a node with an illegal result type
17221 /// with a new node built out of custom code.
17222 void X86TargetLowering::ReplaceNodeResults(SDNode *N,
17223                                            SmallVectorImpl<SDValue>&Results,
17224                                            SelectionDAG &DAG) const {
17225   SDLoc dl(N);
17226   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
17227   switch (N->getOpcode()) {
17228   default:
17229     llvm_unreachable("Do not know how to custom type legalize this operation!");
17230   // We might have generated v2f32 FMIN/FMAX operations. Widen them to v4f32.
17231   case X86ISD::FMINC:
17232   case X86ISD::FMIN:
17233   case X86ISD::FMAXC:
17234   case X86ISD::FMAX: {
17235     EVT VT = N->getValueType(0);
17236     if (VT != MVT::v2f32)
17237       llvm_unreachable("Unexpected type (!= v2f32) on FMIN/FMAX.");
17238     SDValue UNDEF = DAG.getUNDEF(VT);
17239     SDValue LHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
17240                               N->getOperand(0), UNDEF);
17241     SDValue RHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
17242                               N->getOperand(1), UNDEF);
17243     Results.push_back(DAG.getNode(N->getOpcode(), dl, MVT::v4f32, LHS, RHS));
17244     return;
17245   }
17246   case ISD::SIGN_EXTEND_INREG:
17247   case ISD::ADDC:
17248   case ISD::ADDE:
17249   case ISD::SUBC:
17250   case ISD::SUBE:
17251     // We don't want to expand or promote these.
17252     return;
17253   case ISD::SDIV:
17254   case ISD::UDIV:
17255   case ISD::SREM:
17256   case ISD::UREM:
17257   case ISD::SDIVREM:
17258   case ISD::UDIVREM: {
17259     SDValue V = LowerWin64_i128OP(SDValue(N,0), DAG);
17260     Results.push_back(V);
17261     return;
17262   }
17263   case ISD::FP_TO_SINT:
17264   case ISD::FP_TO_UINT: {
17265     bool IsSigned = N->getOpcode() == ISD::FP_TO_SINT;
17266
17267     if (!IsSigned && !isIntegerTypeFTOL(SDValue(N, 0).getValueType()))
17268       return;
17269
17270     std::pair<SDValue,SDValue> Vals =
17271         FP_TO_INTHelper(SDValue(N, 0), DAG, IsSigned, /*IsReplace=*/ true);
17272     SDValue FIST = Vals.first, StackSlot = Vals.second;
17273     if (FIST.getNode()) {
17274       EVT VT = N->getValueType(0);
17275       // Return a load from the stack slot.
17276       if (StackSlot.getNode())
17277         Results.push_back(DAG.getLoad(VT, dl, FIST, StackSlot,
17278                                       MachinePointerInfo(),
17279                                       false, false, false, 0));
17280       else
17281         Results.push_back(FIST);
17282     }
17283     return;
17284   }
17285   case ISD::UINT_TO_FP: {
17286     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
17287     if (N->getOperand(0).getValueType() != MVT::v2i32 ||
17288         N->getValueType(0) != MVT::v2f32)
17289       return;
17290     SDValue ZExtIn = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v2i64,
17291                                  N->getOperand(0));
17292     SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
17293                                      MVT::f64);
17294     SDValue VBias = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2f64, Bias, Bias);
17295     SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64, ZExtIn,
17296                              DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, VBias));
17297     Or = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or);
17298     SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, Or, VBias);
17299     Results.push_back(DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, Sub));
17300     return;
17301   }
17302   case ISD::FP_ROUND: {
17303     if (!TLI.isTypeLegal(N->getOperand(0).getValueType()))
17304         return;
17305     SDValue V = DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, N->getOperand(0));
17306     Results.push_back(V);
17307     return;
17308   }
17309   case ISD::INTRINSIC_W_CHAIN: {
17310     unsigned IntNo = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue();
17311     switch (IntNo) {
17312     default : llvm_unreachable("Do not know how to custom type "
17313                                "legalize this intrinsic operation!");
17314     case Intrinsic::x86_rdtsc:
17315       return getReadTimeStampCounter(N, dl, X86ISD::RDTSC_DAG, DAG, Subtarget,
17316                                      Results);
17317     case Intrinsic::x86_rdtscp:
17318       return getReadTimeStampCounter(N, dl, X86ISD::RDTSCP_DAG, DAG, Subtarget,
17319                                      Results);
17320     case Intrinsic::x86_rdpmc:
17321       return getReadPerformanceCounter(N, dl, DAG, Subtarget, Results);
17322     }
17323   }
17324   case ISD::READCYCLECOUNTER: {
17325     return getReadTimeStampCounter(N, dl, X86ISD::RDTSC_DAG, DAG, Subtarget,
17326                                    Results);
17327   }
17328   case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: {
17329     EVT T = N->getValueType(0);
17330     assert((T == MVT::i64 || T == MVT::i128) && "can only expand cmpxchg pair");
17331     bool Regs64bit = T == MVT::i128;
17332     EVT HalfT = Regs64bit ? MVT::i64 : MVT::i32;
17333     SDValue cpInL, cpInH;
17334     cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
17335                         DAG.getConstant(0, HalfT));
17336     cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
17337                         DAG.getConstant(1, HalfT));
17338     cpInL = DAG.getCopyToReg(N->getOperand(0), dl,
17339                              Regs64bit ? X86::RAX : X86::EAX,
17340                              cpInL, SDValue());
17341     cpInH = DAG.getCopyToReg(cpInL.getValue(0), dl,
17342                              Regs64bit ? X86::RDX : X86::EDX,
17343                              cpInH, cpInL.getValue(1));
17344     SDValue swapInL, swapInH;
17345     swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
17346                           DAG.getConstant(0, HalfT));
17347     swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
17348                           DAG.getConstant(1, HalfT));
17349     swapInL = DAG.getCopyToReg(cpInH.getValue(0), dl,
17350                                Regs64bit ? X86::RBX : X86::EBX,
17351                                swapInL, cpInH.getValue(1));
17352     swapInH = DAG.getCopyToReg(swapInL.getValue(0), dl,
17353                                Regs64bit ? X86::RCX : X86::ECX,
17354                                swapInH, swapInL.getValue(1));
17355     SDValue Ops[] = { swapInH.getValue(0),
17356                       N->getOperand(1),
17357                       swapInH.getValue(1) };
17358     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
17359     MachineMemOperand *MMO = cast<AtomicSDNode>(N)->getMemOperand();
17360     unsigned Opcode = Regs64bit ? X86ISD::LCMPXCHG16_DAG :
17361                                   X86ISD::LCMPXCHG8_DAG;
17362     SDValue Result = DAG.getMemIntrinsicNode(Opcode, dl, Tys, Ops, T, MMO);
17363     SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), dl,
17364                                         Regs64bit ? X86::RAX : X86::EAX,
17365                                         HalfT, Result.getValue(1));
17366     SDValue cpOutH = DAG.getCopyFromReg(cpOutL.getValue(1), dl,
17367                                         Regs64bit ? X86::RDX : X86::EDX,
17368                                         HalfT, cpOutL.getValue(2));
17369     SDValue OpsF[] = { cpOutL.getValue(0), cpOutH.getValue(0)};
17370
17371     SDValue EFLAGS = DAG.getCopyFromReg(cpOutH.getValue(1), dl, X86::EFLAGS,
17372                                         MVT::i32, cpOutH.getValue(2));
17373     SDValue Success =
17374         DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
17375                     DAG.getConstant(X86::COND_E, MVT::i8), EFLAGS);
17376     Success = DAG.getZExtOrTrunc(Success, dl, N->getValueType(1));
17377
17378     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF));
17379     Results.push_back(Success);
17380     Results.push_back(EFLAGS.getValue(1));
17381     return;
17382   }
17383   case ISD::ATOMIC_SWAP:
17384   case ISD::ATOMIC_LOAD_ADD:
17385   case ISD::ATOMIC_LOAD_SUB:
17386   case ISD::ATOMIC_LOAD_AND:
17387   case ISD::ATOMIC_LOAD_OR:
17388   case ISD::ATOMIC_LOAD_XOR:
17389   case ISD::ATOMIC_LOAD_NAND:
17390   case ISD::ATOMIC_LOAD_MIN:
17391   case ISD::ATOMIC_LOAD_MAX:
17392   case ISD::ATOMIC_LOAD_UMIN:
17393   case ISD::ATOMIC_LOAD_UMAX:
17394   case ISD::ATOMIC_LOAD: {
17395     // Delegate to generic TypeLegalization. Situations we can really handle
17396     // should have already been dealt with by AtomicExpandPass.cpp.
17397     break;
17398   }
17399   case ISD::BITCAST: {
17400     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
17401     EVT DstVT = N->getValueType(0);
17402     EVT SrcVT = N->getOperand(0)->getValueType(0);
17403
17404     if (SrcVT != MVT::f64 ||
17405         (DstVT != MVT::v2i32 && DstVT != MVT::v4i16 && DstVT != MVT::v8i8))
17406       return;
17407
17408     unsigned NumElts = DstVT.getVectorNumElements();
17409     EVT SVT = DstVT.getVectorElementType();
17410     EVT WiderVT = EVT::getVectorVT(*DAG.getContext(), SVT, NumElts * 2);
17411     SDValue Expanded = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
17412                                    MVT::v2f64, N->getOperand(0));
17413     SDValue ToVecInt = DAG.getNode(ISD::BITCAST, dl, WiderVT, Expanded);
17414
17415     if (ExperimentalVectorWideningLegalization) {
17416       // If we are legalizing vectors by widening, we already have the desired
17417       // legal vector type, just return it.
17418       Results.push_back(ToVecInt);
17419       return;
17420     }
17421
17422     SmallVector<SDValue, 8> Elts;
17423     for (unsigned i = 0, e = NumElts; i != e; ++i)
17424       Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT,
17425                                    ToVecInt, DAG.getIntPtrConstant(i)));
17426
17427     Results.push_back(DAG.getNode(ISD::BUILD_VECTOR, dl, DstVT, Elts));
17428   }
17429   }
17430 }
17431
17432 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
17433   switch (Opcode) {
17434   default: return nullptr;
17435   case X86ISD::BSF:                return "X86ISD::BSF";
17436   case X86ISD::BSR:                return "X86ISD::BSR";
17437   case X86ISD::SHLD:               return "X86ISD::SHLD";
17438   case X86ISD::SHRD:               return "X86ISD::SHRD";
17439   case X86ISD::FAND:               return "X86ISD::FAND";
17440   case X86ISD::FANDN:              return "X86ISD::FANDN";
17441   case X86ISD::FOR:                return "X86ISD::FOR";
17442   case X86ISD::FXOR:               return "X86ISD::FXOR";
17443   case X86ISD::FSRL:               return "X86ISD::FSRL";
17444   case X86ISD::FILD:               return "X86ISD::FILD";
17445   case X86ISD::FILD_FLAG:          return "X86ISD::FILD_FLAG";
17446   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
17447   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
17448   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
17449   case X86ISD::FLD:                return "X86ISD::FLD";
17450   case X86ISD::FST:                return "X86ISD::FST";
17451   case X86ISD::CALL:               return "X86ISD::CALL";
17452   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
17453   case X86ISD::RDTSCP_DAG:         return "X86ISD::RDTSCP_DAG";
17454   case X86ISD::RDPMC_DAG:          return "X86ISD::RDPMC_DAG";
17455   case X86ISD::BT:                 return "X86ISD::BT";
17456   case X86ISD::CMP:                return "X86ISD::CMP";
17457   case X86ISD::COMI:               return "X86ISD::COMI";
17458   case X86ISD::UCOMI:              return "X86ISD::UCOMI";
17459   case X86ISD::CMPM:               return "X86ISD::CMPM";
17460   case X86ISD::CMPMU:              return "X86ISD::CMPMU";
17461   case X86ISD::SETCC:              return "X86ISD::SETCC";
17462   case X86ISD::SETCC_CARRY:        return "X86ISD::SETCC_CARRY";
17463   case X86ISD::FSETCC:             return "X86ISD::FSETCC";
17464   case X86ISD::CMOV:               return "X86ISD::CMOV";
17465   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
17466   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
17467   case X86ISD::REP_STOS:           return "X86ISD::REP_STOS";
17468   case X86ISD::REP_MOVS:           return "X86ISD::REP_MOVS";
17469   case X86ISD::GlobalBaseReg:      return "X86ISD::GlobalBaseReg";
17470   case X86ISD::Wrapper:            return "X86ISD::Wrapper";
17471   case X86ISD::WrapperRIP:         return "X86ISD::WrapperRIP";
17472   case X86ISD::PEXTRB:             return "X86ISD::PEXTRB";
17473   case X86ISD::PEXTRW:             return "X86ISD::PEXTRW";
17474   case X86ISD::INSERTPS:           return "X86ISD::INSERTPS";
17475   case X86ISD::PINSRB:             return "X86ISD::PINSRB";
17476   case X86ISD::PINSRW:             return "X86ISD::PINSRW";
17477   case X86ISD::PSHUFB:             return "X86ISD::PSHUFB";
17478   case X86ISD::ANDNP:              return "X86ISD::ANDNP";
17479   case X86ISD::PSIGN:              return "X86ISD::PSIGN";
17480   case X86ISD::BLENDI:             return "X86ISD::BLENDI";
17481   case X86ISD::SHRUNKBLEND:        return "X86ISD::SHRUNKBLEND";
17482   case X86ISD::SUBUS:              return "X86ISD::SUBUS";
17483   case X86ISD::HADD:               return "X86ISD::HADD";
17484   case X86ISD::HSUB:               return "X86ISD::HSUB";
17485   case X86ISD::FHADD:              return "X86ISD::FHADD";
17486   case X86ISD::FHSUB:              return "X86ISD::FHSUB";
17487   case X86ISD::UMAX:               return "X86ISD::UMAX";
17488   case X86ISD::UMIN:               return "X86ISD::UMIN";
17489   case X86ISD::SMAX:               return "X86ISD::SMAX";
17490   case X86ISD::SMIN:               return "X86ISD::SMIN";
17491   case X86ISD::FMAX:               return "X86ISD::FMAX";
17492   case X86ISD::FMIN:               return "X86ISD::FMIN";
17493   case X86ISD::FMAXC:              return "X86ISD::FMAXC";
17494   case X86ISD::FMINC:              return "X86ISD::FMINC";
17495   case X86ISD::FRSQRT:             return "X86ISD::FRSQRT";
17496   case X86ISD::FRCP:               return "X86ISD::FRCP";
17497   case X86ISD::TLSADDR:            return "X86ISD::TLSADDR";
17498   case X86ISD::TLSBASEADDR:        return "X86ISD::TLSBASEADDR";
17499   case X86ISD::TLSCALL:            return "X86ISD::TLSCALL";
17500   case X86ISD::EH_SJLJ_SETJMP:     return "X86ISD::EH_SJLJ_SETJMP";
17501   case X86ISD::EH_SJLJ_LONGJMP:    return "X86ISD::EH_SJLJ_LONGJMP";
17502   case X86ISD::EH_RETURN:          return "X86ISD::EH_RETURN";
17503   case X86ISD::TC_RETURN:          return "X86ISD::TC_RETURN";
17504   case X86ISD::FNSTCW16m:          return "X86ISD::FNSTCW16m";
17505   case X86ISD::FNSTSW16r:          return "X86ISD::FNSTSW16r";
17506   case X86ISD::LCMPXCHG_DAG:       return "X86ISD::LCMPXCHG_DAG";
17507   case X86ISD::LCMPXCHG8_DAG:      return "X86ISD::LCMPXCHG8_DAG";
17508   case X86ISD::LCMPXCHG16_DAG:     return "X86ISD::LCMPXCHG16_DAG";
17509   case X86ISD::VZEXT_MOVL:         return "X86ISD::VZEXT_MOVL";
17510   case X86ISD::VZEXT_LOAD:         return "X86ISD::VZEXT_LOAD";
17511   case X86ISD::VZEXT:              return "X86ISD::VZEXT";
17512   case X86ISD::VSEXT:              return "X86ISD::VSEXT";
17513   case X86ISD::VTRUNC:             return "X86ISD::VTRUNC";
17514   case X86ISD::VTRUNCM:            return "X86ISD::VTRUNCM";
17515   case X86ISD::VINSERT:            return "X86ISD::VINSERT";
17516   case X86ISD::VFPEXT:             return "X86ISD::VFPEXT";
17517   case X86ISD::VFPROUND:           return "X86ISD::VFPROUND";
17518   case X86ISD::VSHLDQ:             return "X86ISD::VSHLDQ";
17519   case X86ISD::VSRLDQ:             return "X86ISD::VSRLDQ";
17520   case X86ISD::VSHL:               return "X86ISD::VSHL";
17521   case X86ISD::VSRL:               return "X86ISD::VSRL";
17522   case X86ISD::VSRA:               return "X86ISD::VSRA";
17523   case X86ISD::VSHLI:              return "X86ISD::VSHLI";
17524   case X86ISD::VSRLI:              return "X86ISD::VSRLI";
17525   case X86ISD::VSRAI:              return "X86ISD::VSRAI";
17526   case X86ISD::CMPP:               return "X86ISD::CMPP";
17527   case X86ISD::PCMPEQ:             return "X86ISD::PCMPEQ";
17528   case X86ISD::PCMPGT:             return "X86ISD::PCMPGT";
17529   case X86ISD::PCMPEQM:            return "X86ISD::PCMPEQM";
17530   case X86ISD::PCMPGTM:            return "X86ISD::PCMPGTM";
17531   case X86ISD::ADD:                return "X86ISD::ADD";
17532   case X86ISD::SUB:                return "X86ISD::SUB";
17533   case X86ISD::ADC:                return "X86ISD::ADC";
17534   case X86ISD::SBB:                return "X86ISD::SBB";
17535   case X86ISD::SMUL:               return "X86ISD::SMUL";
17536   case X86ISD::UMUL:               return "X86ISD::UMUL";
17537   case X86ISD::SMUL8:              return "X86ISD::SMUL8";
17538   case X86ISD::UMUL8:              return "X86ISD::UMUL8";
17539   case X86ISD::SDIVREM8_SEXT_HREG: return "X86ISD::SDIVREM8_SEXT_HREG";
17540   case X86ISD::UDIVREM8_ZEXT_HREG: return "X86ISD::UDIVREM8_ZEXT_HREG";
17541   case X86ISD::INC:                return "X86ISD::INC";
17542   case X86ISD::DEC:                return "X86ISD::DEC";
17543   case X86ISD::OR:                 return "X86ISD::OR";
17544   case X86ISD::XOR:                return "X86ISD::XOR";
17545   case X86ISD::AND:                return "X86ISD::AND";
17546   case X86ISD::BEXTR:              return "X86ISD::BEXTR";
17547   case X86ISD::MUL_IMM:            return "X86ISD::MUL_IMM";
17548   case X86ISD::PTEST:              return "X86ISD::PTEST";
17549   case X86ISD::TESTP:              return "X86ISD::TESTP";
17550   case X86ISD::TESTM:              return "X86ISD::TESTM";
17551   case X86ISD::TESTNM:             return "X86ISD::TESTNM";
17552   case X86ISD::KORTEST:            return "X86ISD::KORTEST";
17553   case X86ISD::PACKSS:             return "X86ISD::PACKSS";
17554   case X86ISD::PACKUS:             return "X86ISD::PACKUS";
17555   case X86ISD::PALIGNR:            return "X86ISD::PALIGNR";
17556   case X86ISD::VALIGN:             return "X86ISD::VALIGN";
17557   case X86ISD::PSHUFD:             return "X86ISD::PSHUFD";
17558   case X86ISD::PSHUFHW:            return "X86ISD::PSHUFHW";
17559   case X86ISD::PSHUFLW:            return "X86ISD::PSHUFLW";
17560   case X86ISD::SHUFP:              return "X86ISD::SHUFP";
17561   case X86ISD::MOVLHPS:            return "X86ISD::MOVLHPS";
17562   case X86ISD::MOVLHPD:            return "X86ISD::MOVLHPD";
17563   case X86ISD::MOVHLPS:            return "X86ISD::MOVHLPS";
17564   case X86ISD::MOVLPS:             return "X86ISD::MOVLPS";
17565   case X86ISD::MOVLPD:             return "X86ISD::MOVLPD";
17566   case X86ISD::MOVDDUP:            return "X86ISD::MOVDDUP";
17567   case X86ISD::MOVSHDUP:           return "X86ISD::MOVSHDUP";
17568   case X86ISD::MOVSLDUP:           return "X86ISD::MOVSLDUP";
17569   case X86ISD::MOVSD:              return "X86ISD::MOVSD";
17570   case X86ISD::MOVSS:              return "X86ISD::MOVSS";
17571   case X86ISD::UNPCKL:             return "X86ISD::UNPCKL";
17572   case X86ISD::UNPCKH:             return "X86ISD::UNPCKH";
17573   case X86ISD::VBROADCAST:         return "X86ISD::VBROADCAST";
17574   case X86ISD::VBROADCASTM:        return "X86ISD::VBROADCASTM";
17575   case X86ISD::VEXTRACT:           return "X86ISD::VEXTRACT";
17576   case X86ISD::VPERMILPI:          return "X86ISD::VPERMILPI";
17577   case X86ISD::VPERM2X128:         return "X86ISD::VPERM2X128";
17578   case X86ISD::VPERMV:             return "X86ISD::VPERMV";
17579   case X86ISD::VPERMV3:            return "X86ISD::VPERMV3";
17580   case X86ISD::VPERMIV3:           return "X86ISD::VPERMIV3";
17581   case X86ISD::VPERMI:             return "X86ISD::VPERMI";
17582   case X86ISD::PMULUDQ:            return "X86ISD::PMULUDQ";
17583   case X86ISD::PMULDQ:             return "X86ISD::PMULDQ";
17584   case X86ISD::VASTART_SAVE_XMM_REGS: return "X86ISD::VASTART_SAVE_XMM_REGS";
17585   case X86ISD::VAARG_64:           return "X86ISD::VAARG_64";
17586   case X86ISD::WIN_ALLOCA:         return "X86ISD::WIN_ALLOCA";
17587   case X86ISD::MEMBARRIER:         return "X86ISD::MEMBARRIER";
17588   case X86ISD::SEG_ALLOCA:         return "X86ISD::SEG_ALLOCA";
17589   case X86ISD::WIN_FTOL:           return "X86ISD::WIN_FTOL";
17590   case X86ISD::SAHF:               return "X86ISD::SAHF";
17591   case X86ISD::RDRAND:             return "X86ISD::RDRAND";
17592   case X86ISD::RDSEED:             return "X86ISD::RDSEED";
17593   case X86ISD::FMADD:              return "X86ISD::FMADD";
17594   case X86ISD::FMSUB:              return "X86ISD::FMSUB";
17595   case X86ISD::FNMADD:             return "X86ISD::FNMADD";
17596   case X86ISD::FNMSUB:             return "X86ISD::FNMSUB";
17597   case X86ISD::FMADDSUB:           return "X86ISD::FMADDSUB";
17598   case X86ISD::FMSUBADD:           return "X86ISD::FMSUBADD";
17599   case X86ISD::PCMPESTRI:          return "X86ISD::PCMPESTRI";
17600   case X86ISD::PCMPISTRI:          return "X86ISD::PCMPISTRI";
17601   case X86ISD::XTEST:              return "X86ISD::XTEST";
17602   case X86ISD::COMPRESS:           return "X86ISD::COMPRESS";
17603   case X86ISD::EXPAND:             return "X86ISD::EXPAND";
17604   case X86ISD::SELECT:             return "X86ISD::SELECT";
17605   case X86ISD::ADDSUB:             return "X86ISD::ADDSUB";
17606   case X86ISD::RCP28:              return "X86ISD::RCP28";
17607   case X86ISD::RSQRT28:            return "X86ISD::RSQRT28";
17608   case X86ISD::FADD_RND:           return "X86ISD::FADD_RND";
17609   case X86ISD::FSUB_RND:           return "X86ISD::FSUB_RND";
17610   case X86ISD::FMUL_RND:           return "X86ISD::FMUL_RND";
17611   case X86ISD::FDIV_RND:           return "X86ISD::FDIV_RND";
17612   }
17613 }
17614
17615 // isLegalAddressingMode - Return true if the addressing mode represented
17616 // by AM is legal for this target, for a load/store of the specified type.
17617 bool X86TargetLowering::isLegalAddressingMode(const AddrMode &AM,
17618                                               Type *Ty) const {
17619   // X86 supports extremely general addressing modes.
17620   CodeModel::Model M = getTargetMachine().getCodeModel();
17621   Reloc::Model R = getTargetMachine().getRelocationModel();
17622
17623   // X86 allows a sign-extended 32-bit immediate field as a displacement.
17624   if (!X86::isOffsetSuitableForCodeModel(AM.BaseOffs, M, AM.BaseGV != nullptr))
17625     return false;
17626
17627   if (AM.BaseGV) {
17628     unsigned GVFlags =
17629       Subtarget->ClassifyGlobalReference(AM.BaseGV, getTargetMachine());
17630
17631     // If a reference to this global requires an extra load, we can't fold it.
17632     if (isGlobalStubReference(GVFlags))
17633       return false;
17634
17635     // If BaseGV requires a register for the PIC base, we cannot also have a
17636     // BaseReg specified.
17637     if (AM.HasBaseReg && isGlobalRelativeToPICBase(GVFlags))
17638       return false;
17639
17640     // If lower 4G is not available, then we must use rip-relative addressing.
17641     if ((M != CodeModel::Small || R != Reloc::Static) &&
17642         Subtarget->is64Bit() && (AM.BaseOffs || AM.Scale > 1))
17643       return false;
17644   }
17645
17646   switch (AM.Scale) {
17647   case 0:
17648   case 1:
17649   case 2:
17650   case 4:
17651   case 8:
17652     // These scales always work.
17653     break;
17654   case 3:
17655   case 5:
17656   case 9:
17657     // These scales are formed with basereg+scalereg.  Only accept if there is
17658     // no basereg yet.
17659     if (AM.HasBaseReg)
17660       return false;
17661     break;
17662   default:  // Other stuff never works.
17663     return false;
17664   }
17665
17666   return true;
17667 }
17668
17669 bool X86TargetLowering::isVectorShiftByScalarCheap(Type *Ty) const {
17670   unsigned Bits = Ty->getScalarSizeInBits();
17671
17672   // 8-bit shifts are always expensive, but versions with a scalar amount aren't
17673   // particularly cheaper than those without.
17674   if (Bits == 8)
17675     return false;
17676
17677   // On AVX2 there are new vpsllv[dq] instructions (and other shifts), that make
17678   // variable shifts just as cheap as scalar ones.
17679   if (Subtarget->hasInt256() && (Bits == 32 || Bits == 64))
17680     return false;
17681
17682   // Otherwise, it's significantly cheaper to shift by a scalar amount than by a
17683   // fully general vector.
17684   return true;
17685 }
17686
17687 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
17688   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
17689     return false;
17690   unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
17691   unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
17692   return NumBits1 > NumBits2;
17693 }
17694
17695 bool X86TargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
17696   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
17697     return false;
17698
17699   if (!isTypeLegal(EVT::getEVT(Ty1)))
17700     return false;
17701
17702   assert(Ty1->getPrimitiveSizeInBits() <= 64 && "i128 is probably not a noop");
17703
17704   // Assuming the caller doesn't have a zeroext or signext return parameter,
17705   // truncation all the way down to i1 is valid.
17706   return true;
17707 }
17708
17709 bool X86TargetLowering::isLegalICmpImmediate(int64_t Imm) const {
17710   return isInt<32>(Imm);
17711 }
17712
17713 bool X86TargetLowering::isLegalAddImmediate(int64_t Imm) const {
17714   // Can also use sub to handle negated immediates.
17715   return isInt<32>(Imm);
17716 }
17717
17718 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
17719   if (!VT1.isInteger() || !VT2.isInteger())
17720     return false;
17721   unsigned NumBits1 = VT1.getSizeInBits();
17722   unsigned NumBits2 = VT2.getSizeInBits();
17723   return NumBits1 > NumBits2;
17724 }
17725
17726 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
17727   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
17728   return Ty1->isIntegerTy(32) && Ty2->isIntegerTy(64) && Subtarget->is64Bit();
17729 }
17730
17731 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
17732   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
17733   return VT1 == MVT::i32 && VT2 == MVT::i64 && Subtarget->is64Bit();
17734 }
17735
17736 bool X86TargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
17737   EVT VT1 = Val.getValueType();
17738   if (isZExtFree(VT1, VT2))
17739     return true;
17740
17741   if (Val.getOpcode() != ISD::LOAD)
17742     return false;
17743
17744   if (!VT1.isSimple() || !VT1.isInteger() ||
17745       !VT2.isSimple() || !VT2.isInteger())
17746     return false;
17747
17748   switch (VT1.getSimpleVT().SimpleTy) {
17749   default: break;
17750   case MVT::i8:
17751   case MVT::i16:
17752   case MVT::i32:
17753     // X86 has 8, 16, and 32-bit zero-extending loads.
17754     return true;
17755   }
17756
17757   return false;
17758 }
17759
17760 bool X86TargetLowering::isVectorLoadExtDesirable(SDValue) const { return true; }
17761
17762 bool
17763 X86TargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
17764   if (!(Subtarget->hasFMA() || Subtarget->hasFMA4()))
17765     return false;
17766
17767   VT = VT.getScalarType();
17768
17769   if (!VT.isSimple())
17770     return false;
17771
17772   switch (VT.getSimpleVT().SimpleTy) {
17773   case MVT::f32:
17774   case MVT::f64:
17775     return true;
17776   default:
17777     break;
17778   }
17779
17780   return false;
17781 }
17782
17783 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
17784   // i16 instructions are longer (0x66 prefix) and potentially slower.
17785   return !(VT1 == MVT::i32 && VT2 == MVT::i16);
17786 }
17787
17788 /// isShuffleMaskLegal - Targets can use this to indicate that they only
17789 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
17790 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
17791 /// are assumed to be legal.
17792 bool
17793 X86TargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
17794                                       EVT VT) const {
17795   if (!VT.isSimple())
17796     return false;
17797
17798   // Very little shuffling can be done for 64-bit vectors right now.
17799   if (VT.getSizeInBits() == 64)
17800     return false;
17801
17802   // We only care that the types being shuffled are legal. The lowering can
17803   // handle any possible shuffle mask that results.
17804   return isTypeLegal(VT.getSimpleVT());
17805 }
17806
17807 bool
17808 X86TargetLowering::isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
17809                                           EVT VT) const {
17810   // Just delegate to the generic legality, clear masks aren't special.
17811   return isShuffleMaskLegal(Mask, VT);
17812 }
17813
17814 //===----------------------------------------------------------------------===//
17815 //                           X86 Scheduler Hooks
17816 //===----------------------------------------------------------------------===//
17817
17818 /// Utility function to emit xbegin specifying the start of an RTM region.
17819 static MachineBasicBlock *EmitXBegin(MachineInstr *MI, MachineBasicBlock *MBB,
17820                                      const TargetInstrInfo *TII) {
17821   DebugLoc DL = MI->getDebugLoc();
17822
17823   const BasicBlock *BB = MBB->getBasicBlock();
17824   MachineFunction::iterator I = MBB;
17825   ++I;
17826
17827   // For the v = xbegin(), we generate
17828   //
17829   // thisMBB:
17830   //  xbegin sinkMBB
17831   //
17832   // mainMBB:
17833   //  eax = -1
17834   //
17835   // sinkMBB:
17836   //  v = eax
17837
17838   MachineBasicBlock *thisMBB = MBB;
17839   MachineFunction *MF = MBB->getParent();
17840   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
17841   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
17842   MF->insert(I, mainMBB);
17843   MF->insert(I, sinkMBB);
17844
17845   // Transfer the remainder of BB and its successor edges to sinkMBB.
17846   sinkMBB->splice(sinkMBB->begin(), MBB,
17847                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
17848   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
17849
17850   // thisMBB:
17851   //  xbegin sinkMBB
17852   //  # fallthrough to mainMBB
17853   //  # abortion to sinkMBB
17854   BuildMI(thisMBB, DL, TII->get(X86::XBEGIN_4)).addMBB(sinkMBB);
17855   thisMBB->addSuccessor(mainMBB);
17856   thisMBB->addSuccessor(sinkMBB);
17857
17858   // mainMBB:
17859   //  EAX = -1
17860   BuildMI(mainMBB, DL, TII->get(X86::MOV32ri), X86::EAX).addImm(-1);
17861   mainMBB->addSuccessor(sinkMBB);
17862
17863   // sinkMBB:
17864   // EAX is live into the sinkMBB
17865   sinkMBB->addLiveIn(X86::EAX);
17866   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
17867           TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
17868     .addReg(X86::EAX);
17869
17870   MI->eraseFromParent();
17871   return sinkMBB;
17872 }
17873
17874 // FIXME: When we get size specific XMM0 registers, i.e. XMM0_V16I8
17875 // or XMM0_V32I8 in AVX all of this code can be replaced with that
17876 // in the .td file.
17877 static MachineBasicBlock *EmitPCMPSTRM(MachineInstr *MI, MachineBasicBlock *BB,
17878                                        const TargetInstrInfo *TII) {
17879   unsigned Opc;
17880   switch (MI->getOpcode()) {
17881   default: llvm_unreachable("illegal opcode!");
17882   case X86::PCMPISTRM128REG:  Opc = X86::PCMPISTRM128rr;  break;
17883   case X86::VPCMPISTRM128REG: Opc = X86::VPCMPISTRM128rr; break;
17884   case X86::PCMPISTRM128MEM:  Opc = X86::PCMPISTRM128rm;  break;
17885   case X86::VPCMPISTRM128MEM: Opc = X86::VPCMPISTRM128rm; break;
17886   case X86::PCMPESTRM128REG:  Opc = X86::PCMPESTRM128rr;  break;
17887   case X86::VPCMPESTRM128REG: Opc = X86::VPCMPESTRM128rr; break;
17888   case X86::PCMPESTRM128MEM:  Opc = X86::PCMPESTRM128rm;  break;
17889   case X86::VPCMPESTRM128MEM: Opc = X86::VPCMPESTRM128rm; break;
17890   }
17891
17892   DebugLoc dl = MI->getDebugLoc();
17893   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
17894
17895   unsigned NumArgs = MI->getNumOperands();
17896   for (unsigned i = 1; i < NumArgs; ++i) {
17897     MachineOperand &Op = MI->getOperand(i);
17898     if (!(Op.isReg() && Op.isImplicit()))
17899       MIB.addOperand(Op);
17900   }
17901   if (MI->hasOneMemOperand())
17902     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
17903
17904   BuildMI(*BB, MI, dl,
17905     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
17906     .addReg(X86::XMM0);
17907
17908   MI->eraseFromParent();
17909   return BB;
17910 }
17911
17912 // FIXME: Custom handling because TableGen doesn't support multiple implicit
17913 // defs in an instruction pattern
17914 static MachineBasicBlock *EmitPCMPSTRI(MachineInstr *MI, MachineBasicBlock *BB,
17915                                        const TargetInstrInfo *TII) {
17916   unsigned Opc;
17917   switch (MI->getOpcode()) {
17918   default: llvm_unreachable("illegal opcode!");
17919   case X86::PCMPISTRIREG:  Opc = X86::PCMPISTRIrr;  break;
17920   case X86::VPCMPISTRIREG: Opc = X86::VPCMPISTRIrr; break;
17921   case X86::PCMPISTRIMEM:  Opc = X86::PCMPISTRIrm;  break;
17922   case X86::VPCMPISTRIMEM: Opc = X86::VPCMPISTRIrm; break;
17923   case X86::PCMPESTRIREG:  Opc = X86::PCMPESTRIrr;  break;
17924   case X86::VPCMPESTRIREG: Opc = X86::VPCMPESTRIrr; break;
17925   case X86::PCMPESTRIMEM:  Opc = X86::PCMPESTRIrm;  break;
17926   case X86::VPCMPESTRIMEM: Opc = X86::VPCMPESTRIrm; break;
17927   }
17928
17929   DebugLoc dl = MI->getDebugLoc();
17930   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
17931
17932   unsigned NumArgs = MI->getNumOperands(); // remove the results
17933   for (unsigned i = 1; i < NumArgs; ++i) {
17934     MachineOperand &Op = MI->getOperand(i);
17935     if (!(Op.isReg() && Op.isImplicit()))
17936       MIB.addOperand(Op);
17937   }
17938   if (MI->hasOneMemOperand())
17939     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
17940
17941   BuildMI(*BB, MI, dl,
17942     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
17943     .addReg(X86::ECX);
17944
17945   MI->eraseFromParent();
17946   return BB;
17947 }
17948
17949 static MachineBasicBlock *EmitMonitor(MachineInstr *MI, MachineBasicBlock *BB,
17950                                       const X86Subtarget *Subtarget) {
17951   DebugLoc dl = MI->getDebugLoc();
17952   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
17953   // Address into RAX/EAX, other two args into ECX, EDX.
17954   unsigned MemOpc = Subtarget->is64Bit() ? X86::LEA64r : X86::LEA32r;
17955   unsigned MemReg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
17956   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(MemOpc), MemReg);
17957   for (int i = 0; i < X86::AddrNumOperands; ++i)
17958     MIB.addOperand(MI->getOperand(i));
17959
17960   unsigned ValOps = X86::AddrNumOperands;
17961   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::ECX)
17962     .addReg(MI->getOperand(ValOps).getReg());
17963   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::EDX)
17964     .addReg(MI->getOperand(ValOps+1).getReg());
17965
17966   // The instruction doesn't actually take any operands though.
17967   BuildMI(*BB, MI, dl, TII->get(X86::MONITORrrr));
17968
17969   MI->eraseFromParent(); // The pseudo is gone now.
17970   return BB;
17971 }
17972
17973 MachineBasicBlock *
17974 X86TargetLowering::EmitVAARG64WithCustomInserter(MachineInstr *MI,
17975                                                  MachineBasicBlock *MBB) const {
17976   // Emit va_arg instruction on X86-64.
17977
17978   // Operands to this pseudo-instruction:
17979   // 0  ) Output        : destination address (reg)
17980   // 1-5) Input         : va_list address (addr, i64mem)
17981   // 6  ) ArgSize       : Size (in bytes) of vararg type
17982   // 7  ) ArgMode       : 0=overflow only, 1=use gp_offset, 2=use fp_offset
17983   // 8  ) Align         : Alignment of type
17984   // 9  ) EFLAGS (implicit-def)
17985
17986   assert(MI->getNumOperands() == 10 && "VAARG_64 should have 10 operands!");
17987   static_assert(X86::AddrNumOperands == 5,
17988                 "VAARG_64 assumes 5 address operands");
17989
17990   unsigned DestReg = MI->getOperand(0).getReg();
17991   MachineOperand &Base = MI->getOperand(1);
17992   MachineOperand &Scale = MI->getOperand(2);
17993   MachineOperand &Index = MI->getOperand(3);
17994   MachineOperand &Disp = MI->getOperand(4);
17995   MachineOperand &Segment = MI->getOperand(5);
17996   unsigned ArgSize = MI->getOperand(6).getImm();
17997   unsigned ArgMode = MI->getOperand(7).getImm();
17998   unsigned Align = MI->getOperand(8).getImm();
17999
18000   // Memory Reference
18001   assert(MI->hasOneMemOperand() && "Expected VAARG_64 to have one memoperand");
18002   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
18003   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
18004
18005   // Machine Information
18006   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
18007   MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
18008   const TargetRegisterClass *AddrRegClass = getRegClassFor(MVT::i64);
18009   const TargetRegisterClass *OffsetRegClass = getRegClassFor(MVT::i32);
18010   DebugLoc DL = MI->getDebugLoc();
18011
18012   // struct va_list {
18013   //   i32   gp_offset
18014   //   i32   fp_offset
18015   //   i64   overflow_area (address)
18016   //   i64   reg_save_area (address)
18017   // }
18018   // sizeof(va_list) = 24
18019   // alignment(va_list) = 8
18020
18021   unsigned TotalNumIntRegs = 6;
18022   unsigned TotalNumXMMRegs = 8;
18023   bool UseGPOffset = (ArgMode == 1);
18024   bool UseFPOffset = (ArgMode == 2);
18025   unsigned MaxOffset = TotalNumIntRegs * 8 +
18026                        (UseFPOffset ? TotalNumXMMRegs * 16 : 0);
18027
18028   /* Align ArgSize to a multiple of 8 */
18029   unsigned ArgSizeA8 = (ArgSize + 7) & ~7;
18030   bool NeedsAlign = (Align > 8);
18031
18032   MachineBasicBlock *thisMBB = MBB;
18033   MachineBasicBlock *overflowMBB;
18034   MachineBasicBlock *offsetMBB;
18035   MachineBasicBlock *endMBB;
18036
18037   unsigned OffsetDestReg = 0;    // Argument address computed by offsetMBB
18038   unsigned OverflowDestReg = 0;  // Argument address computed by overflowMBB
18039   unsigned OffsetReg = 0;
18040
18041   if (!UseGPOffset && !UseFPOffset) {
18042     // If we only pull from the overflow region, we don't create a branch.
18043     // We don't need to alter control flow.
18044     OffsetDestReg = 0; // unused
18045     OverflowDestReg = DestReg;
18046
18047     offsetMBB = nullptr;
18048     overflowMBB = thisMBB;
18049     endMBB = thisMBB;
18050   } else {
18051     // First emit code to check if gp_offset (or fp_offset) is below the bound.
18052     // If so, pull the argument from reg_save_area. (branch to offsetMBB)
18053     // If not, pull from overflow_area. (branch to overflowMBB)
18054     //
18055     //       thisMBB
18056     //         |     .
18057     //         |        .
18058     //     offsetMBB   overflowMBB
18059     //         |        .
18060     //         |     .
18061     //        endMBB
18062
18063     // Registers for the PHI in endMBB
18064     OffsetDestReg = MRI.createVirtualRegister(AddrRegClass);
18065     OverflowDestReg = MRI.createVirtualRegister(AddrRegClass);
18066
18067     const BasicBlock *LLVM_BB = MBB->getBasicBlock();
18068     MachineFunction *MF = MBB->getParent();
18069     overflowMBB = MF->CreateMachineBasicBlock(LLVM_BB);
18070     offsetMBB = MF->CreateMachineBasicBlock(LLVM_BB);
18071     endMBB = MF->CreateMachineBasicBlock(LLVM_BB);
18072
18073     MachineFunction::iterator MBBIter = MBB;
18074     ++MBBIter;
18075
18076     // Insert the new basic blocks
18077     MF->insert(MBBIter, offsetMBB);
18078     MF->insert(MBBIter, overflowMBB);
18079     MF->insert(MBBIter, endMBB);
18080
18081     // Transfer the remainder of MBB and its successor edges to endMBB.
18082     endMBB->splice(endMBB->begin(), thisMBB,
18083                    std::next(MachineBasicBlock::iterator(MI)), thisMBB->end());
18084     endMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
18085
18086     // Make offsetMBB and overflowMBB successors of thisMBB
18087     thisMBB->addSuccessor(offsetMBB);
18088     thisMBB->addSuccessor(overflowMBB);
18089
18090     // endMBB is a successor of both offsetMBB and overflowMBB
18091     offsetMBB->addSuccessor(endMBB);
18092     overflowMBB->addSuccessor(endMBB);
18093
18094     // Load the offset value into a register
18095     OffsetReg = MRI.createVirtualRegister(OffsetRegClass);
18096     BuildMI(thisMBB, DL, TII->get(X86::MOV32rm), OffsetReg)
18097       .addOperand(Base)
18098       .addOperand(Scale)
18099       .addOperand(Index)
18100       .addDisp(Disp, UseFPOffset ? 4 : 0)
18101       .addOperand(Segment)
18102       .setMemRefs(MMOBegin, MMOEnd);
18103
18104     // Check if there is enough room left to pull this argument.
18105     BuildMI(thisMBB, DL, TII->get(X86::CMP32ri))
18106       .addReg(OffsetReg)
18107       .addImm(MaxOffset + 8 - ArgSizeA8);
18108
18109     // Branch to "overflowMBB" if offset >= max
18110     // Fall through to "offsetMBB" otherwise
18111     BuildMI(thisMBB, DL, TII->get(X86::GetCondBranchFromCond(X86::COND_AE)))
18112       .addMBB(overflowMBB);
18113   }
18114
18115   // In offsetMBB, emit code to use the reg_save_area.
18116   if (offsetMBB) {
18117     assert(OffsetReg != 0);
18118
18119     // Read the reg_save_area address.
18120     unsigned RegSaveReg = MRI.createVirtualRegister(AddrRegClass);
18121     BuildMI(offsetMBB, DL, TII->get(X86::MOV64rm), RegSaveReg)
18122       .addOperand(Base)
18123       .addOperand(Scale)
18124       .addOperand(Index)
18125       .addDisp(Disp, 16)
18126       .addOperand(Segment)
18127       .setMemRefs(MMOBegin, MMOEnd);
18128
18129     // Zero-extend the offset
18130     unsigned OffsetReg64 = MRI.createVirtualRegister(AddrRegClass);
18131       BuildMI(offsetMBB, DL, TII->get(X86::SUBREG_TO_REG), OffsetReg64)
18132         .addImm(0)
18133         .addReg(OffsetReg)
18134         .addImm(X86::sub_32bit);
18135
18136     // Add the offset to the reg_save_area to get the final address.
18137     BuildMI(offsetMBB, DL, TII->get(X86::ADD64rr), OffsetDestReg)
18138       .addReg(OffsetReg64)
18139       .addReg(RegSaveReg);
18140
18141     // Compute the offset for the next argument
18142     unsigned NextOffsetReg = MRI.createVirtualRegister(OffsetRegClass);
18143     BuildMI(offsetMBB, DL, TII->get(X86::ADD32ri), NextOffsetReg)
18144       .addReg(OffsetReg)
18145       .addImm(UseFPOffset ? 16 : 8);
18146
18147     // Store it back into the va_list.
18148     BuildMI(offsetMBB, DL, TII->get(X86::MOV32mr))
18149       .addOperand(Base)
18150       .addOperand(Scale)
18151       .addOperand(Index)
18152       .addDisp(Disp, UseFPOffset ? 4 : 0)
18153       .addOperand(Segment)
18154       .addReg(NextOffsetReg)
18155       .setMemRefs(MMOBegin, MMOEnd);
18156
18157     // Jump to endMBB
18158     BuildMI(offsetMBB, DL, TII->get(X86::JMP_1))
18159       .addMBB(endMBB);
18160   }
18161
18162   //
18163   // Emit code to use overflow area
18164   //
18165
18166   // Load the overflow_area address into a register.
18167   unsigned OverflowAddrReg = MRI.createVirtualRegister(AddrRegClass);
18168   BuildMI(overflowMBB, DL, TII->get(X86::MOV64rm), OverflowAddrReg)
18169     .addOperand(Base)
18170     .addOperand(Scale)
18171     .addOperand(Index)
18172     .addDisp(Disp, 8)
18173     .addOperand(Segment)
18174     .setMemRefs(MMOBegin, MMOEnd);
18175
18176   // If we need to align it, do so. Otherwise, just copy the address
18177   // to OverflowDestReg.
18178   if (NeedsAlign) {
18179     // Align the overflow address
18180     assert((Align & (Align-1)) == 0 && "Alignment must be a power of 2");
18181     unsigned TmpReg = MRI.createVirtualRegister(AddrRegClass);
18182
18183     // aligned_addr = (addr + (align-1)) & ~(align-1)
18184     BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), TmpReg)
18185       .addReg(OverflowAddrReg)
18186       .addImm(Align-1);
18187
18188     BuildMI(overflowMBB, DL, TII->get(X86::AND64ri32), OverflowDestReg)
18189       .addReg(TmpReg)
18190       .addImm(~(uint64_t)(Align-1));
18191   } else {
18192     BuildMI(overflowMBB, DL, TII->get(TargetOpcode::COPY), OverflowDestReg)
18193       .addReg(OverflowAddrReg);
18194   }
18195
18196   // Compute the next overflow address after this argument.
18197   // (the overflow address should be kept 8-byte aligned)
18198   unsigned NextAddrReg = MRI.createVirtualRegister(AddrRegClass);
18199   BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), NextAddrReg)
18200     .addReg(OverflowDestReg)
18201     .addImm(ArgSizeA8);
18202
18203   // Store the new overflow address.
18204   BuildMI(overflowMBB, DL, TII->get(X86::MOV64mr))
18205     .addOperand(Base)
18206     .addOperand(Scale)
18207     .addOperand(Index)
18208     .addDisp(Disp, 8)
18209     .addOperand(Segment)
18210     .addReg(NextAddrReg)
18211     .setMemRefs(MMOBegin, MMOEnd);
18212
18213   // If we branched, emit the PHI to the front of endMBB.
18214   if (offsetMBB) {
18215     BuildMI(*endMBB, endMBB->begin(), DL,
18216             TII->get(X86::PHI), DestReg)
18217       .addReg(OffsetDestReg).addMBB(offsetMBB)
18218       .addReg(OverflowDestReg).addMBB(overflowMBB);
18219   }
18220
18221   // Erase the pseudo instruction
18222   MI->eraseFromParent();
18223
18224   return endMBB;
18225 }
18226
18227 MachineBasicBlock *
18228 X86TargetLowering::EmitVAStartSaveXMMRegsWithCustomInserter(
18229                                                  MachineInstr *MI,
18230                                                  MachineBasicBlock *MBB) const {
18231   // Emit code to save XMM registers to the stack. The ABI says that the
18232   // number of registers to save is given in %al, so it's theoretically
18233   // possible to do an indirect jump trick to avoid saving all of them,
18234   // however this code takes a simpler approach and just executes all
18235   // of the stores if %al is non-zero. It's less code, and it's probably
18236   // easier on the hardware branch predictor, and stores aren't all that
18237   // expensive anyway.
18238
18239   // Create the new basic blocks. One block contains all the XMM stores,
18240   // and one block is the final destination regardless of whether any
18241   // stores were performed.
18242   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
18243   MachineFunction *F = MBB->getParent();
18244   MachineFunction::iterator MBBIter = MBB;
18245   ++MBBIter;
18246   MachineBasicBlock *XMMSaveMBB = F->CreateMachineBasicBlock(LLVM_BB);
18247   MachineBasicBlock *EndMBB = F->CreateMachineBasicBlock(LLVM_BB);
18248   F->insert(MBBIter, XMMSaveMBB);
18249   F->insert(MBBIter, EndMBB);
18250
18251   // Transfer the remainder of MBB and its successor edges to EndMBB.
18252   EndMBB->splice(EndMBB->begin(), MBB,
18253                  std::next(MachineBasicBlock::iterator(MI)), MBB->end());
18254   EndMBB->transferSuccessorsAndUpdatePHIs(MBB);
18255
18256   // The original block will now fall through to the XMM save block.
18257   MBB->addSuccessor(XMMSaveMBB);
18258   // The XMMSaveMBB will fall through to the end block.
18259   XMMSaveMBB->addSuccessor(EndMBB);
18260
18261   // Now add the instructions.
18262   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
18263   DebugLoc DL = MI->getDebugLoc();
18264
18265   unsigned CountReg = MI->getOperand(0).getReg();
18266   int64_t RegSaveFrameIndex = MI->getOperand(1).getImm();
18267   int64_t VarArgsFPOffset = MI->getOperand(2).getImm();
18268
18269   if (!Subtarget->isTargetWin64()) {
18270     // If %al is 0, branch around the XMM save block.
18271     BuildMI(MBB, DL, TII->get(X86::TEST8rr)).addReg(CountReg).addReg(CountReg);
18272     BuildMI(MBB, DL, TII->get(X86::JE_1)).addMBB(EndMBB);
18273     MBB->addSuccessor(EndMBB);
18274   }
18275
18276   // Make sure the last operand is EFLAGS, which gets clobbered by the branch
18277   // that was just emitted, but clearly shouldn't be "saved".
18278   assert((MI->getNumOperands() <= 3 ||
18279           !MI->getOperand(MI->getNumOperands() - 1).isReg() ||
18280           MI->getOperand(MI->getNumOperands() - 1).getReg() == X86::EFLAGS)
18281          && "Expected last argument to be EFLAGS");
18282   unsigned MOVOpc = Subtarget->hasFp256() ? X86::VMOVAPSmr : X86::MOVAPSmr;
18283   // In the XMM save block, save all the XMM argument registers.
18284   for (int i = 3, e = MI->getNumOperands() - 1; i != e; ++i) {
18285     int64_t Offset = (i - 3) * 16 + VarArgsFPOffset;
18286     MachineMemOperand *MMO =
18287       F->getMachineMemOperand(
18288           MachinePointerInfo::getFixedStack(RegSaveFrameIndex, Offset),
18289         MachineMemOperand::MOStore,
18290         /*Size=*/16, /*Align=*/16);
18291     BuildMI(XMMSaveMBB, DL, TII->get(MOVOpc))
18292       .addFrameIndex(RegSaveFrameIndex)
18293       .addImm(/*Scale=*/1)
18294       .addReg(/*IndexReg=*/0)
18295       .addImm(/*Disp=*/Offset)
18296       .addReg(/*Segment=*/0)
18297       .addReg(MI->getOperand(i).getReg())
18298       .addMemOperand(MMO);
18299   }
18300
18301   MI->eraseFromParent();   // The pseudo instruction is gone now.
18302
18303   return EndMBB;
18304 }
18305
18306 // The EFLAGS operand of SelectItr might be missing a kill marker
18307 // because there were multiple uses of EFLAGS, and ISel didn't know
18308 // which to mark. Figure out whether SelectItr should have had a
18309 // kill marker, and set it if it should. Returns the correct kill
18310 // marker value.
18311 static bool checkAndUpdateEFLAGSKill(MachineBasicBlock::iterator SelectItr,
18312                                      MachineBasicBlock* BB,
18313                                      const TargetRegisterInfo* TRI) {
18314   // Scan forward through BB for a use/def of EFLAGS.
18315   MachineBasicBlock::iterator miI(std::next(SelectItr));
18316   for (MachineBasicBlock::iterator miE = BB->end(); miI != miE; ++miI) {
18317     const MachineInstr& mi = *miI;
18318     if (mi.readsRegister(X86::EFLAGS))
18319       return false;
18320     if (mi.definesRegister(X86::EFLAGS))
18321       break; // Should have kill-flag - update below.
18322   }
18323
18324   // If we hit the end of the block, check whether EFLAGS is live into a
18325   // successor.
18326   if (miI == BB->end()) {
18327     for (MachineBasicBlock::succ_iterator sItr = BB->succ_begin(),
18328                                           sEnd = BB->succ_end();
18329          sItr != sEnd; ++sItr) {
18330       MachineBasicBlock* succ = *sItr;
18331       if (succ->isLiveIn(X86::EFLAGS))
18332         return false;
18333     }
18334   }
18335
18336   // We found a def, or hit the end of the basic block and EFLAGS wasn't live
18337   // out. SelectMI should have a kill flag on EFLAGS.
18338   SelectItr->addRegisterKilled(X86::EFLAGS, TRI);
18339   return true;
18340 }
18341
18342 MachineBasicBlock *
18343 X86TargetLowering::EmitLoweredSelect(MachineInstr *MI,
18344                                      MachineBasicBlock *BB) const {
18345   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
18346   DebugLoc DL = MI->getDebugLoc();
18347
18348   // To "insert" a SELECT_CC instruction, we actually have to insert the
18349   // diamond control-flow pattern.  The incoming instruction knows the
18350   // destination vreg to set, the condition code register to branch on, the
18351   // true/false values to select between, and a branch opcode to use.
18352   const BasicBlock *LLVM_BB = BB->getBasicBlock();
18353   MachineFunction::iterator It = BB;
18354   ++It;
18355
18356   //  thisMBB:
18357   //  ...
18358   //   TrueVal = ...
18359   //   cmpTY ccX, r1, r2
18360   //   bCC copy1MBB
18361   //   fallthrough --> copy0MBB
18362   MachineBasicBlock *thisMBB = BB;
18363   MachineFunction *F = BB->getParent();
18364
18365   // We also lower double CMOVs:
18366   //   (CMOV (CMOV F, T, cc1), T, cc2)
18367   // to two successives branches.  For that, we look for another CMOV as the
18368   // following instruction.
18369   //
18370   // Without this, we would add a PHI between the two jumps, which ends up
18371   // creating a few copies all around. For instance, for
18372   //
18373   //    (sitofp (zext (fcmp une)))
18374   //
18375   // we would generate:
18376   //
18377   //         ucomiss %xmm1, %xmm0
18378   //         movss  <1.0f>, %xmm0
18379   //         movaps  %xmm0, %xmm1
18380   //         jne     .LBB5_2
18381   //         xorps   %xmm1, %xmm1
18382   // .LBB5_2:
18383   //         jp      .LBB5_4
18384   //         movaps  %xmm1, %xmm0
18385   // .LBB5_4:
18386   //         retq
18387   //
18388   // because this custom-inserter would have generated:
18389   //
18390   //   A
18391   //   | \
18392   //   |  B
18393   //   | /
18394   //   C
18395   //   | \
18396   //   |  D
18397   //   | /
18398   //   E
18399   //
18400   // A: X = ...; Y = ...
18401   // B: empty
18402   // C: Z = PHI [X, A], [Y, B]
18403   // D: empty
18404   // E: PHI [X, C], [Z, D]
18405   //
18406   // If we lower both CMOVs in a single step, we can instead generate:
18407   //
18408   //   A
18409   //   | \
18410   //   |  C
18411   //   | /|
18412   //   |/ |
18413   //   |  |
18414   //   |  D
18415   //   | /
18416   //   E
18417   //
18418   // A: X = ...; Y = ...
18419   // D: empty
18420   // E: PHI [X, A], [X, C], [Y, D]
18421   //
18422   // Which, in our sitofp/fcmp example, gives us something like:
18423   //
18424   //         ucomiss %xmm1, %xmm0
18425   //         movss  <1.0f>, %xmm0
18426   //         jne     .LBB5_4
18427   //         jp      .LBB5_4
18428   //         xorps   %xmm0, %xmm0
18429   // .LBB5_4:
18430   //         retq
18431   //
18432   MachineInstr *NextCMOV = nullptr;
18433   MachineBasicBlock::iterator NextMIIt =
18434       std::next(MachineBasicBlock::iterator(MI));
18435   if (NextMIIt != BB->end() && NextMIIt->getOpcode() == MI->getOpcode() &&
18436       NextMIIt->getOperand(2).getReg() == MI->getOperand(2).getReg() &&
18437       NextMIIt->getOperand(1).getReg() == MI->getOperand(0).getReg())
18438     NextCMOV = &*NextMIIt;
18439
18440   MachineBasicBlock *jcc1MBB = nullptr;
18441
18442   // If we have a double CMOV, we lower it to two successive branches to
18443   // the same block.  EFLAGS is used by both, so mark it as live in the second.
18444   if (NextCMOV) {
18445     jcc1MBB = F->CreateMachineBasicBlock(LLVM_BB);
18446     F->insert(It, jcc1MBB);
18447     jcc1MBB->addLiveIn(X86::EFLAGS);
18448   }
18449
18450   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
18451   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
18452   F->insert(It, copy0MBB);
18453   F->insert(It, sinkMBB);
18454
18455   // If the EFLAGS register isn't dead in the terminator, then claim that it's
18456   // live into the sink and copy blocks.
18457   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
18458
18459   MachineInstr *LastEFLAGSUser = NextCMOV ? NextCMOV : MI;
18460   if (!LastEFLAGSUser->killsRegister(X86::EFLAGS) &&
18461       !checkAndUpdateEFLAGSKill(LastEFLAGSUser, BB, TRI)) {
18462     copy0MBB->addLiveIn(X86::EFLAGS);
18463     sinkMBB->addLiveIn(X86::EFLAGS);
18464   }
18465
18466   // Transfer the remainder of BB and its successor edges to sinkMBB.
18467   sinkMBB->splice(sinkMBB->begin(), BB,
18468                   std::next(MachineBasicBlock::iterator(MI)), BB->end());
18469   sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
18470
18471   // Add the true and fallthrough blocks as its successors.
18472   if (NextCMOV) {
18473     // The fallthrough block may be jcc1MBB, if we have a double CMOV.
18474     BB->addSuccessor(jcc1MBB);
18475
18476     // In that case, jcc1MBB will itself fallthrough the copy0MBB, and
18477     // jump to the sinkMBB.
18478     jcc1MBB->addSuccessor(copy0MBB);
18479     jcc1MBB->addSuccessor(sinkMBB);
18480   } else {
18481     BB->addSuccessor(copy0MBB);
18482   }
18483
18484   // The true block target of the first (or only) branch is always sinkMBB.
18485   BB->addSuccessor(sinkMBB);
18486
18487   // Create the conditional branch instruction.
18488   unsigned Opc =
18489     X86::GetCondBranchFromCond((X86::CondCode)MI->getOperand(3).getImm());
18490   BuildMI(BB, DL, TII->get(Opc)).addMBB(sinkMBB);
18491
18492   if (NextCMOV) {
18493     unsigned Opc2 = X86::GetCondBranchFromCond(
18494         (X86::CondCode)NextCMOV->getOperand(3).getImm());
18495     BuildMI(jcc1MBB, DL, TII->get(Opc2)).addMBB(sinkMBB);
18496   }
18497
18498   //  copy0MBB:
18499   //   %FalseValue = ...
18500   //   # fallthrough to sinkMBB
18501   copy0MBB->addSuccessor(sinkMBB);
18502
18503   //  sinkMBB:
18504   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
18505   //  ...
18506   MachineInstrBuilder MIB =
18507       BuildMI(*sinkMBB, sinkMBB->begin(), DL, TII->get(X86::PHI),
18508               MI->getOperand(0).getReg())
18509           .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
18510           .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
18511
18512   // If we have a double CMOV, the second Jcc provides the same incoming
18513   // value as the first Jcc (the True operand of the SELECT_CC/CMOV nodes).
18514   if (NextCMOV) {
18515     MIB.addReg(MI->getOperand(2).getReg()).addMBB(jcc1MBB);
18516     // Copy the PHI result to the register defined by the second CMOV.
18517     BuildMI(*sinkMBB, std::next(MachineBasicBlock::iterator(MIB.getInstr())),
18518             DL, TII->get(TargetOpcode::COPY), NextCMOV->getOperand(0).getReg())
18519         .addReg(MI->getOperand(0).getReg());
18520     NextCMOV->eraseFromParent();
18521   }
18522
18523   MI->eraseFromParent();   // The pseudo instruction is gone now.
18524   return sinkMBB;
18525 }
18526
18527 MachineBasicBlock *
18528 X86TargetLowering::EmitLoweredSegAlloca(MachineInstr *MI,
18529                                         MachineBasicBlock *BB) const {
18530   MachineFunction *MF = BB->getParent();
18531   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
18532   DebugLoc DL = MI->getDebugLoc();
18533   const BasicBlock *LLVM_BB = BB->getBasicBlock();
18534
18535   assert(MF->shouldSplitStack());
18536
18537   const bool Is64Bit = Subtarget->is64Bit();
18538   const bool IsLP64 = Subtarget->isTarget64BitLP64();
18539
18540   const unsigned TlsReg = Is64Bit ? X86::FS : X86::GS;
18541   const unsigned TlsOffset = IsLP64 ? 0x70 : Is64Bit ? 0x40 : 0x30;
18542
18543   // BB:
18544   //  ... [Till the alloca]
18545   // If stacklet is not large enough, jump to mallocMBB
18546   //
18547   // bumpMBB:
18548   //  Allocate by subtracting from RSP
18549   //  Jump to continueMBB
18550   //
18551   // mallocMBB:
18552   //  Allocate by call to runtime
18553   //
18554   // continueMBB:
18555   //  ...
18556   //  [rest of original BB]
18557   //
18558
18559   MachineBasicBlock *mallocMBB = MF->CreateMachineBasicBlock(LLVM_BB);
18560   MachineBasicBlock *bumpMBB = MF->CreateMachineBasicBlock(LLVM_BB);
18561   MachineBasicBlock *continueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
18562
18563   MachineRegisterInfo &MRI = MF->getRegInfo();
18564   const TargetRegisterClass *AddrRegClass =
18565     getRegClassFor(getPointerTy());
18566
18567   unsigned mallocPtrVReg = MRI.createVirtualRegister(AddrRegClass),
18568     bumpSPPtrVReg = MRI.createVirtualRegister(AddrRegClass),
18569     tmpSPVReg = MRI.createVirtualRegister(AddrRegClass),
18570     SPLimitVReg = MRI.createVirtualRegister(AddrRegClass),
18571     sizeVReg = MI->getOperand(1).getReg(),
18572     physSPReg = IsLP64 || Subtarget->isTargetNaCl64() ? X86::RSP : X86::ESP;
18573
18574   MachineFunction::iterator MBBIter = BB;
18575   ++MBBIter;
18576
18577   MF->insert(MBBIter, bumpMBB);
18578   MF->insert(MBBIter, mallocMBB);
18579   MF->insert(MBBIter, continueMBB);
18580
18581   continueMBB->splice(continueMBB->begin(), BB,
18582                       std::next(MachineBasicBlock::iterator(MI)), BB->end());
18583   continueMBB->transferSuccessorsAndUpdatePHIs(BB);
18584
18585   // Add code to the main basic block to check if the stack limit has been hit,
18586   // and if so, jump to mallocMBB otherwise to bumpMBB.
18587   BuildMI(BB, DL, TII->get(TargetOpcode::COPY), tmpSPVReg).addReg(physSPReg);
18588   BuildMI(BB, DL, TII->get(IsLP64 ? X86::SUB64rr:X86::SUB32rr), SPLimitVReg)
18589     .addReg(tmpSPVReg).addReg(sizeVReg);
18590   BuildMI(BB, DL, TII->get(IsLP64 ? X86::CMP64mr:X86::CMP32mr))
18591     .addReg(0).addImm(1).addReg(0).addImm(TlsOffset).addReg(TlsReg)
18592     .addReg(SPLimitVReg);
18593   BuildMI(BB, DL, TII->get(X86::JG_1)).addMBB(mallocMBB);
18594
18595   // bumpMBB simply decreases the stack pointer, since we know the current
18596   // stacklet has enough space.
18597   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), physSPReg)
18598     .addReg(SPLimitVReg);
18599   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), bumpSPPtrVReg)
18600     .addReg(SPLimitVReg);
18601   BuildMI(bumpMBB, DL, TII->get(X86::JMP_1)).addMBB(continueMBB);
18602
18603   // Calls into a routine in libgcc to allocate more space from the heap.
18604   const uint32_t *RegMask =
18605       Subtarget->getRegisterInfo()->getCallPreservedMask(*MF, CallingConv::C);
18606   if (IsLP64) {
18607     BuildMI(mallocMBB, DL, TII->get(X86::MOV64rr), X86::RDI)
18608       .addReg(sizeVReg);
18609     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
18610       .addExternalSymbol("__morestack_allocate_stack_space")
18611       .addRegMask(RegMask)
18612       .addReg(X86::RDI, RegState::Implicit)
18613       .addReg(X86::RAX, RegState::ImplicitDefine);
18614   } else if (Is64Bit) {
18615     BuildMI(mallocMBB, DL, TII->get(X86::MOV32rr), X86::EDI)
18616       .addReg(sizeVReg);
18617     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
18618       .addExternalSymbol("__morestack_allocate_stack_space")
18619       .addRegMask(RegMask)
18620       .addReg(X86::EDI, RegState::Implicit)
18621       .addReg(X86::EAX, RegState::ImplicitDefine);
18622   } else {
18623     BuildMI(mallocMBB, DL, TII->get(X86::SUB32ri), physSPReg).addReg(physSPReg)
18624       .addImm(12);
18625     BuildMI(mallocMBB, DL, TII->get(X86::PUSH32r)).addReg(sizeVReg);
18626     BuildMI(mallocMBB, DL, TII->get(X86::CALLpcrel32))
18627       .addExternalSymbol("__morestack_allocate_stack_space")
18628       .addRegMask(RegMask)
18629       .addReg(X86::EAX, RegState::ImplicitDefine);
18630   }
18631
18632   if (!Is64Bit)
18633     BuildMI(mallocMBB, DL, TII->get(X86::ADD32ri), physSPReg).addReg(physSPReg)
18634       .addImm(16);
18635
18636   BuildMI(mallocMBB, DL, TII->get(TargetOpcode::COPY), mallocPtrVReg)
18637     .addReg(IsLP64 ? X86::RAX : X86::EAX);
18638   BuildMI(mallocMBB, DL, TII->get(X86::JMP_1)).addMBB(continueMBB);
18639
18640   // Set up the CFG correctly.
18641   BB->addSuccessor(bumpMBB);
18642   BB->addSuccessor(mallocMBB);
18643   mallocMBB->addSuccessor(continueMBB);
18644   bumpMBB->addSuccessor(continueMBB);
18645
18646   // Take care of the PHI nodes.
18647   BuildMI(*continueMBB, continueMBB->begin(), DL, TII->get(X86::PHI),
18648           MI->getOperand(0).getReg())
18649     .addReg(mallocPtrVReg).addMBB(mallocMBB)
18650     .addReg(bumpSPPtrVReg).addMBB(bumpMBB);
18651
18652   // Delete the original pseudo instruction.
18653   MI->eraseFromParent();
18654
18655   // And we're done.
18656   return continueMBB;
18657 }
18658
18659 MachineBasicBlock *
18660 X86TargetLowering::EmitLoweredWinAlloca(MachineInstr *MI,
18661                                         MachineBasicBlock *BB) const {
18662   DebugLoc DL = MI->getDebugLoc();
18663
18664   assert(!Subtarget->isTargetMachO());
18665
18666   X86FrameLowering::emitStackProbeCall(*BB->getParent(), *BB, MI, DL);
18667
18668   MI->eraseFromParent();   // The pseudo instruction is gone now.
18669   return BB;
18670 }
18671
18672 MachineBasicBlock *
18673 X86TargetLowering::EmitLoweredTLSCall(MachineInstr *MI,
18674                                       MachineBasicBlock *BB) const {
18675   // This is pretty easy.  We're taking the value that we received from
18676   // our load from the relocation, sticking it in either RDI (x86-64)
18677   // or EAX and doing an indirect call.  The return value will then
18678   // be in the normal return register.
18679   MachineFunction *F = BB->getParent();
18680   const X86InstrInfo *TII = Subtarget->getInstrInfo();
18681   DebugLoc DL = MI->getDebugLoc();
18682
18683   assert(Subtarget->isTargetDarwin() && "Darwin only instr emitted?");
18684   assert(MI->getOperand(3).isGlobal() && "This should be a global");
18685
18686   // Get a register mask for the lowered call.
18687   // FIXME: The 32-bit calls have non-standard calling conventions. Use a
18688   // proper register mask.
18689   const uint32_t *RegMask =
18690       Subtarget->getRegisterInfo()->getCallPreservedMask(*F, CallingConv::C);
18691   if (Subtarget->is64Bit()) {
18692     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
18693                                       TII->get(X86::MOV64rm), X86::RDI)
18694     .addReg(X86::RIP)
18695     .addImm(0).addReg(0)
18696     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
18697                       MI->getOperand(3).getTargetFlags())
18698     .addReg(0);
18699     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL64m));
18700     addDirectMem(MIB, X86::RDI);
18701     MIB.addReg(X86::RAX, RegState::ImplicitDefine).addRegMask(RegMask);
18702   } else if (F->getTarget().getRelocationModel() != Reloc::PIC_) {
18703     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
18704                                       TII->get(X86::MOV32rm), X86::EAX)
18705     .addReg(0)
18706     .addImm(0).addReg(0)
18707     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
18708                       MI->getOperand(3).getTargetFlags())
18709     .addReg(0);
18710     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
18711     addDirectMem(MIB, X86::EAX);
18712     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
18713   } else {
18714     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
18715                                       TII->get(X86::MOV32rm), X86::EAX)
18716     .addReg(TII->getGlobalBaseReg(F))
18717     .addImm(0).addReg(0)
18718     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
18719                       MI->getOperand(3).getTargetFlags())
18720     .addReg(0);
18721     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
18722     addDirectMem(MIB, X86::EAX);
18723     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
18724   }
18725
18726   MI->eraseFromParent(); // The pseudo instruction is gone now.
18727   return BB;
18728 }
18729
18730 MachineBasicBlock *
18731 X86TargetLowering::emitEHSjLjSetJmp(MachineInstr *MI,
18732                                     MachineBasicBlock *MBB) const {
18733   DebugLoc DL = MI->getDebugLoc();
18734   MachineFunction *MF = MBB->getParent();
18735   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
18736   MachineRegisterInfo &MRI = MF->getRegInfo();
18737
18738   const BasicBlock *BB = MBB->getBasicBlock();
18739   MachineFunction::iterator I = MBB;
18740   ++I;
18741
18742   // Memory Reference
18743   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
18744   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
18745
18746   unsigned DstReg;
18747   unsigned MemOpndSlot = 0;
18748
18749   unsigned CurOp = 0;
18750
18751   DstReg = MI->getOperand(CurOp++).getReg();
18752   const TargetRegisterClass *RC = MRI.getRegClass(DstReg);
18753   assert(RC->hasType(MVT::i32) && "Invalid destination!");
18754   unsigned mainDstReg = MRI.createVirtualRegister(RC);
18755   unsigned restoreDstReg = MRI.createVirtualRegister(RC);
18756
18757   MemOpndSlot = CurOp;
18758
18759   MVT PVT = getPointerTy();
18760   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
18761          "Invalid Pointer Size!");
18762
18763   // For v = setjmp(buf), we generate
18764   //
18765   // thisMBB:
18766   //  buf[LabelOffset] = restoreMBB
18767   //  SjLjSetup restoreMBB
18768   //
18769   // mainMBB:
18770   //  v_main = 0
18771   //
18772   // sinkMBB:
18773   //  v = phi(main, restore)
18774   //
18775   // restoreMBB:
18776   //  if base pointer being used, load it from frame
18777   //  v_restore = 1
18778
18779   MachineBasicBlock *thisMBB = MBB;
18780   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
18781   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
18782   MachineBasicBlock *restoreMBB = MF->CreateMachineBasicBlock(BB);
18783   MF->insert(I, mainMBB);
18784   MF->insert(I, sinkMBB);
18785   MF->push_back(restoreMBB);
18786
18787   MachineInstrBuilder MIB;
18788
18789   // Transfer the remainder of BB and its successor edges to sinkMBB.
18790   sinkMBB->splice(sinkMBB->begin(), MBB,
18791                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
18792   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
18793
18794   // thisMBB:
18795   unsigned PtrStoreOpc = 0;
18796   unsigned LabelReg = 0;
18797   const int64_t LabelOffset = 1 * PVT.getStoreSize();
18798   Reloc::Model RM = MF->getTarget().getRelocationModel();
18799   bool UseImmLabel = (MF->getTarget().getCodeModel() == CodeModel::Small) &&
18800                      (RM == Reloc::Static || RM == Reloc::DynamicNoPIC);
18801
18802   // Prepare IP either in reg or imm.
18803   if (!UseImmLabel) {
18804     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mr : X86::MOV32mr;
18805     const TargetRegisterClass *PtrRC = getRegClassFor(PVT);
18806     LabelReg = MRI.createVirtualRegister(PtrRC);
18807     if (Subtarget->is64Bit()) {
18808       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA64r), LabelReg)
18809               .addReg(X86::RIP)
18810               .addImm(0)
18811               .addReg(0)
18812               .addMBB(restoreMBB)
18813               .addReg(0);
18814     } else {
18815       const X86InstrInfo *XII = static_cast<const X86InstrInfo*>(TII);
18816       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA32r), LabelReg)
18817               .addReg(XII->getGlobalBaseReg(MF))
18818               .addImm(0)
18819               .addReg(0)
18820               .addMBB(restoreMBB, Subtarget->ClassifyBlockAddressReference())
18821               .addReg(0);
18822     }
18823   } else
18824     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mi32 : X86::MOV32mi;
18825   // Store IP
18826   MIB = BuildMI(*thisMBB, MI, DL, TII->get(PtrStoreOpc));
18827   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
18828     if (i == X86::AddrDisp)
18829       MIB.addDisp(MI->getOperand(MemOpndSlot + i), LabelOffset);
18830     else
18831       MIB.addOperand(MI->getOperand(MemOpndSlot + i));
18832   }
18833   if (!UseImmLabel)
18834     MIB.addReg(LabelReg);
18835   else
18836     MIB.addMBB(restoreMBB);
18837   MIB.setMemRefs(MMOBegin, MMOEnd);
18838   // Setup
18839   MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::EH_SjLj_Setup))
18840           .addMBB(restoreMBB);
18841
18842   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18843   MIB.addRegMask(RegInfo->getNoPreservedMask());
18844   thisMBB->addSuccessor(mainMBB);
18845   thisMBB->addSuccessor(restoreMBB);
18846
18847   // mainMBB:
18848   //  EAX = 0
18849   BuildMI(mainMBB, DL, TII->get(X86::MOV32r0), mainDstReg);
18850   mainMBB->addSuccessor(sinkMBB);
18851
18852   // sinkMBB:
18853   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
18854           TII->get(X86::PHI), DstReg)
18855     .addReg(mainDstReg).addMBB(mainMBB)
18856     .addReg(restoreDstReg).addMBB(restoreMBB);
18857
18858   // restoreMBB:
18859   if (RegInfo->hasBasePointer(*MF)) {
18860     const bool Uses64BitFramePtr =
18861         Subtarget->isTarget64BitLP64() || Subtarget->isTargetNaCl64();
18862     X86MachineFunctionInfo *X86FI = MF->getInfo<X86MachineFunctionInfo>();
18863     X86FI->setRestoreBasePointer(MF);
18864     unsigned FramePtr = RegInfo->getFrameRegister(*MF);
18865     unsigned BasePtr = RegInfo->getBaseRegister();
18866     unsigned Opm = Uses64BitFramePtr ? X86::MOV64rm : X86::MOV32rm;
18867     addRegOffset(BuildMI(restoreMBB, DL, TII->get(Opm), BasePtr),
18868                  FramePtr, true, X86FI->getRestoreBasePointerOffset())
18869       .setMIFlag(MachineInstr::FrameSetup);
18870   }
18871   BuildMI(restoreMBB, DL, TII->get(X86::MOV32ri), restoreDstReg).addImm(1);
18872   BuildMI(restoreMBB, DL, TII->get(X86::JMP_1)).addMBB(sinkMBB);
18873   restoreMBB->addSuccessor(sinkMBB);
18874
18875   MI->eraseFromParent();
18876   return sinkMBB;
18877 }
18878
18879 MachineBasicBlock *
18880 X86TargetLowering::emitEHSjLjLongJmp(MachineInstr *MI,
18881                                      MachineBasicBlock *MBB) const {
18882   DebugLoc DL = MI->getDebugLoc();
18883   MachineFunction *MF = MBB->getParent();
18884   const TargetInstrInfo *TII = Subtarget->getInstrInfo();
18885   MachineRegisterInfo &MRI = MF->getRegInfo();
18886
18887   // Memory Reference
18888   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
18889   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
18890
18891   MVT PVT = getPointerTy();
18892   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
18893          "Invalid Pointer Size!");
18894
18895   const TargetRegisterClass *RC =
18896     (PVT == MVT::i64) ? &X86::GR64RegClass : &X86::GR32RegClass;
18897   unsigned Tmp = MRI.createVirtualRegister(RC);
18898   // Since FP is only updated here but NOT referenced, it's treated as GPR.
18899   const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
18900   unsigned FP = (PVT == MVT::i64) ? X86::RBP : X86::EBP;
18901   unsigned SP = RegInfo->getStackRegister();
18902
18903   MachineInstrBuilder MIB;
18904
18905   const int64_t LabelOffset = 1 * PVT.getStoreSize();
18906   const int64_t SPOffset = 2 * PVT.getStoreSize();
18907
18908   unsigned PtrLoadOpc = (PVT == MVT::i64) ? X86::MOV64rm : X86::MOV32rm;
18909   unsigned IJmpOpc = (PVT == MVT::i64) ? X86::JMP64r : X86::JMP32r;
18910
18911   // Reload FP
18912   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), FP);
18913   for (unsigned i = 0; i < X86::AddrNumOperands; ++i)
18914     MIB.addOperand(MI->getOperand(i));
18915   MIB.setMemRefs(MMOBegin, MMOEnd);
18916   // Reload IP
18917   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), Tmp);
18918   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
18919     if (i == X86::AddrDisp)
18920       MIB.addDisp(MI->getOperand(i), LabelOffset);
18921     else
18922       MIB.addOperand(MI->getOperand(i));
18923   }
18924   MIB.setMemRefs(MMOBegin, MMOEnd);
18925   // Reload SP
18926   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), SP);
18927   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
18928     if (i == X86::AddrDisp)
18929       MIB.addDisp(MI->getOperand(i), SPOffset);
18930     else
18931       MIB.addOperand(MI->getOperand(i));
18932   }
18933   MIB.setMemRefs(MMOBegin, MMOEnd);
18934   // Jump
18935   BuildMI(*MBB, MI, DL, TII->get(IJmpOpc)).addReg(Tmp);
18936
18937   MI->eraseFromParent();
18938   return MBB;
18939 }
18940
18941 // Replace 213-type (isel default) FMA3 instructions with 231-type for
18942 // accumulator loops. Writing back to the accumulator allows the coalescer
18943 // to remove extra copies in the loop.
18944 MachineBasicBlock *
18945 X86TargetLowering::emitFMA3Instr(MachineInstr *MI,
18946                                  MachineBasicBlock *MBB) const {
18947   MachineOperand &AddendOp = MI->getOperand(3);
18948
18949   // Bail out early if the addend isn't a register - we can't switch these.
18950   if (!AddendOp.isReg())
18951     return MBB;
18952
18953   MachineFunction &MF = *MBB->getParent();
18954   MachineRegisterInfo &MRI = MF.getRegInfo();
18955
18956   // Check whether the addend is defined by a PHI:
18957   assert(MRI.hasOneDef(AddendOp.getReg()) && "Multiple defs in SSA?");
18958   MachineInstr &AddendDef = *MRI.def_instr_begin(AddendOp.getReg());
18959   if (!AddendDef.isPHI())
18960     return MBB;
18961
18962   // Look for the following pattern:
18963   // loop:
18964   //   %addend = phi [%entry, 0], [%loop, %result]
18965   //   ...
18966   //   %result<tied1> = FMA213 %m2<tied0>, %m1, %addend
18967
18968   // Replace with:
18969   //   loop:
18970   //   %addend = phi [%entry, 0], [%loop, %result]
18971   //   ...
18972   //   %result<tied1> = FMA231 %addend<tied0>, %m1, %m2
18973
18974   for (unsigned i = 1, e = AddendDef.getNumOperands(); i < e; i += 2) {
18975     assert(AddendDef.getOperand(i).isReg());
18976     MachineOperand PHISrcOp = AddendDef.getOperand(i);
18977     MachineInstr &PHISrcInst = *MRI.def_instr_begin(PHISrcOp.getReg());
18978     if (&PHISrcInst == MI) {
18979       // Found a matching instruction.
18980       unsigned NewFMAOpc = 0;
18981       switch (MI->getOpcode()) {
18982         case X86::VFMADDPDr213r: NewFMAOpc = X86::VFMADDPDr231r; break;
18983         case X86::VFMADDPSr213r: NewFMAOpc = X86::VFMADDPSr231r; break;
18984         case X86::VFMADDSDr213r: NewFMAOpc = X86::VFMADDSDr231r; break;
18985         case X86::VFMADDSSr213r: NewFMAOpc = X86::VFMADDSSr231r; break;
18986         case X86::VFMSUBPDr213r: NewFMAOpc = X86::VFMSUBPDr231r; break;
18987         case X86::VFMSUBPSr213r: NewFMAOpc = X86::VFMSUBPSr231r; break;
18988         case X86::VFMSUBSDr213r: NewFMAOpc = X86::VFMSUBSDr231r; break;
18989         case X86::VFMSUBSSr213r: NewFMAOpc = X86::VFMSUBSSr231r; break;
18990         case X86::VFNMADDPDr213r: NewFMAOpc = X86::VFNMADDPDr231r; break;
18991         case X86::VFNMADDPSr213r: NewFMAOpc = X86::VFNMADDPSr231r; break;
18992         case X86::VFNMADDSDr213r: NewFMAOpc = X86::VFNMADDSDr231r; break;
18993         case X86::VFNMADDSSr213r: NewFMAOpc = X86::VFNMADDSSr231r; break;
18994         case X86::VFNMSUBPDr213r: NewFMAOpc = X86::VFNMSUBPDr231r; break;
18995         case X86::VFNMSUBPSr213r: NewFMAOpc = X86::VFNMSUBPSr231r; break;
18996         case X86::VFNMSUBSDr213r: NewFMAOpc = X86::VFNMSUBSDr231r; break;
18997         case X86::VFNMSUBSSr213r: NewFMAOpc = X86::VFNMSUBSSr231r; break;
18998         case X86::VFMADDSUBPDr213r: NewFMAOpc = X86::VFMADDSUBPDr231r; break;
18999         case X86::VFMADDSUBPSr213r: NewFMAOpc = X86::VFMADDSUBPSr231r; break;
19000         case X86::VFMSUBADDPDr213r: NewFMAOpc = X86::VFMSUBADDPDr231r; break;
19001         case X86::VFMSUBADDPSr213r: NewFMAOpc = X86::VFMSUBADDPSr231r; break;
19002
19003         case X86::VFMADDPDr213rY: NewFMAOpc = X86::VFMADDPDr231rY; break;
19004         case X86::VFMADDPSr213rY: NewFMAOpc = X86::VFMADDPSr231rY; break;
19005         case X86::VFMSUBPDr213rY: NewFMAOpc = X86::VFMSUBPDr231rY; break;
19006         case X86::VFMSUBPSr213rY: NewFMAOpc = X86::VFMSUBPSr231rY; break;
19007         case X86::VFNMADDPDr213rY: NewFMAOpc = X86::VFNMADDPDr231rY; break;
19008         case X86::VFNMADDPSr213rY: NewFMAOpc = X86::VFNMADDPSr231rY; break;
19009         case X86::VFNMSUBPDr213rY: NewFMAOpc = X86::VFNMSUBPDr231rY; break;
19010         case X86::VFNMSUBPSr213rY: NewFMAOpc = X86::VFNMSUBPSr231rY; break;
19011         case X86::VFMADDSUBPDr213rY: NewFMAOpc = X86::VFMADDSUBPDr231rY; break;
19012         case X86::VFMADDSUBPSr213rY: NewFMAOpc = X86::VFMADDSUBPSr231rY; break;
19013         case X86::VFMSUBADDPDr213rY: NewFMAOpc = X86::VFMSUBADDPDr231rY; break;
19014         case X86::VFMSUBADDPSr213rY: NewFMAOpc = X86::VFMSUBADDPSr231rY; break;
19015         default: llvm_unreachable("Unrecognized FMA variant.");
19016       }
19017
19018       const TargetInstrInfo &TII = *Subtarget->getInstrInfo();
19019       MachineInstrBuilder MIB =
19020         BuildMI(MF, MI->getDebugLoc(), TII.get(NewFMAOpc))
19021         .addOperand(MI->getOperand(0))
19022         .addOperand(MI->getOperand(3))
19023         .addOperand(MI->getOperand(2))
19024         .addOperand(MI->getOperand(1));
19025       MBB->insert(MachineBasicBlock::iterator(MI), MIB);
19026       MI->eraseFromParent();
19027     }
19028   }
19029
19030   return MBB;
19031 }
19032
19033 MachineBasicBlock *
19034 X86TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
19035                                                MachineBasicBlock *BB) const {
19036   switch (MI->getOpcode()) {
19037   default: llvm_unreachable("Unexpected instr type to insert");
19038   case X86::TAILJMPd64:
19039   case X86::TAILJMPr64:
19040   case X86::TAILJMPm64:
19041   case X86::TAILJMPd64_REX:
19042   case X86::TAILJMPr64_REX:
19043   case X86::TAILJMPm64_REX:
19044     llvm_unreachable("TAILJMP64 would not be touched here.");
19045   case X86::TCRETURNdi64:
19046   case X86::TCRETURNri64:
19047   case X86::TCRETURNmi64:
19048     return BB;
19049   case X86::WIN_ALLOCA:
19050     return EmitLoweredWinAlloca(MI, BB);
19051   case X86::SEG_ALLOCA_32:
19052   case X86::SEG_ALLOCA_64:
19053     return EmitLoweredSegAlloca(MI, BB);
19054   case X86::TLSCall_32:
19055   case X86::TLSCall_64:
19056     return EmitLoweredTLSCall(MI, BB);
19057   case X86::CMOV_GR8:
19058   case X86::CMOV_FR32:
19059   case X86::CMOV_FR64:
19060   case X86::CMOV_V4F32:
19061   case X86::CMOV_V2F64:
19062   case X86::CMOV_V2I64:
19063   case X86::CMOV_V8F32:
19064   case X86::CMOV_V4F64:
19065   case X86::CMOV_V4I64:
19066   case X86::CMOV_V16F32:
19067   case X86::CMOV_V8F64:
19068   case X86::CMOV_V8I64:
19069   case X86::CMOV_GR16:
19070   case X86::CMOV_GR32:
19071   case X86::CMOV_RFP32:
19072   case X86::CMOV_RFP64:
19073   case X86::CMOV_RFP80:
19074     return EmitLoweredSelect(MI, BB);
19075
19076   case X86::FP32_TO_INT16_IN_MEM:
19077   case X86::FP32_TO_INT32_IN_MEM:
19078   case X86::FP32_TO_INT64_IN_MEM:
19079   case X86::FP64_TO_INT16_IN_MEM:
19080   case X86::FP64_TO_INT32_IN_MEM:
19081   case X86::FP64_TO_INT64_IN_MEM:
19082   case X86::FP80_TO_INT16_IN_MEM:
19083   case X86::FP80_TO_INT32_IN_MEM:
19084   case X86::FP80_TO_INT64_IN_MEM: {
19085     MachineFunction *F = BB->getParent();
19086     const TargetInstrInfo *TII = Subtarget->getInstrInfo();
19087     DebugLoc DL = MI->getDebugLoc();
19088
19089     // Change the floating point control register to use "round towards zero"
19090     // mode when truncating to an integer value.
19091     int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2, false);
19092     addFrameReference(BuildMI(*BB, MI, DL,
19093                               TII->get(X86::FNSTCW16m)), CWFrameIdx);
19094
19095     // Load the old value of the high byte of the control word...
19096     unsigned OldCW =
19097       F->getRegInfo().createVirtualRegister(&X86::GR16RegClass);
19098     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16rm), OldCW),
19099                       CWFrameIdx);
19100
19101     // Set the high part to be round to zero...
19102     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mi)), CWFrameIdx)
19103       .addImm(0xC7F);
19104
19105     // Reload the modified control word now...
19106     addFrameReference(BuildMI(*BB, MI, DL,
19107                               TII->get(X86::FLDCW16m)), CWFrameIdx);
19108
19109     // Restore the memory image of control word to original value
19110     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mr)), CWFrameIdx)
19111       .addReg(OldCW);
19112
19113     // Get the X86 opcode to use.
19114     unsigned Opc;
19115     switch (MI->getOpcode()) {
19116     default: llvm_unreachable("illegal opcode!");
19117     case X86::FP32_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m32; break;
19118     case X86::FP32_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m32; break;
19119     case X86::FP32_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m32; break;
19120     case X86::FP64_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m64; break;
19121     case X86::FP64_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m64; break;
19122     case X86::FP64_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m64; break;
19123     case X86::FP80_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m80; break;
19124     case X86::FP80_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m80; break;
19125     case X86::FP80_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m80; break;
19126     }
19127
19128     X86AddressMode AM;
19129     MachineOperand &Op = MI->getOperand(0);
19130     if (Op.isReg()) {
19131       AM.BaseType = X86AddressMode::RegBase;
19132       AM.Base.Reg = Op.getReg();
19133     } else {
19134       AM.BaseType = X86AddressMode::FrameIndexBase;
19135       AM.Base.FrameIndex = Op.getIndex();
19136     }
19137     Op = MI->getOperand(1);
19138     if (Op.isImm())
19139       AM.Scale = Op.getImm();
19140     Op = MI->getOperand(2);
19141     if (Op.isImm())
19142       AM.IndexReg = Op.getImm();
19143     Op = MI->getOperand(3);
19144     if (Op.isGlobal()) {
19145       AM.GV = Op.getGlobal();
19146     } else {
19147       AM.Disp = Op.getImm();
19148     }
19149     addFullAddress(BuildMI(*BB, MI, DL, TII->get(Opc)), AM)
19150                       .addReg(MI->getOperand(X86::AddrNumOperands).getReg());
19151
19152     // Reload the original control word now.
19153     addFrameReference(BuildMI(*BB, MI, DL,
19154                               TII->get(X86::FLDCW16m)), CWFrameIdx);
19155
19156     MI->eraseFromParent();   // The pseudo instruction is gone now.
19157     return BB;
19158   }
19159     // String/text processing lowering.
19160   case X86::PCMPISTRM128REG:
19161   case X86::VPCMPISTRM128REG:
19162   case X86::PCMPISTRM128MEM:
19163   case X86::VPCMPISTRM128MEM:
19164   case X86::PCMPESTRM128REG:
19165   case X86::VPCMPESTRM128REG:
19166   case X86::PCMPESTRM128MEM:
19167   case X86::VPCMPESTRM128MEM:
19168     assert(Subtarget->hasSSE42() &&
19169            "Target must have SSE4.2 or AVX features enabled");
19170     return EmitPCMPSTRM(MI, BB, Subtarget->getInstrInfo());
19171
19172   // String/text processing lowering.
19173   case X86::PCMPISTRIREG:
19174   case X86::VPCMPISTRIREG:
19175   case X86::PCMPISTRIMEM:
19176   case X86::VPCMPISTRIMEM:
19177   case X86::PCMPESTRIREG:
19178   case X86::VPCMPESTRIREG:
19179   case X86::PCMPESTRIMEM:
19180   case X86::VPCMPESTRIMEM:
19181     assert(Subtarget->hasSSE42() &&
19182            "Target must have SSE4.2 or AVX features enabled");
19183     return EmitPCMPSTRI(MI, BB, Subtarget->getInstrInfo());
19184
19185   // Thread synchronization.
19186   case X86::MONITOR:
19187     return EmitMonitor(MI, BB, Subtarget);
19188
19189   // xbegin
19190   case X86::XBEGIN:
19191     return EmitXBegin(MI, BB, Subtarget->getInstrInfo());
19192
19193   case X86::VASTART_SAVE_XMM_REGS:
19194     return EmitVAStartSaveXMMRegsWithCustomInserter(MI, BB);
19195
19196   case X86::VAARG_64:
19197     return EmitVAARG64WithCustomInserter(MI, BB);
19198
19199   case X86::EH_SjLj_SetJmp32:
19200   case X86::EH_SjLj_SetJmp64:
19201     return emitEHSjLjSetJmp(MI, BB);
19202
19203   case X86::EH_SjLj_LongJmp32:
19204   case X86::EH_SjLj_LongJmp64:
19205     return emitEHSjLjLongJmp(MI, BB);
19206
19207   case TargetOpcode::STATEPOINT:
19208     // As an implementation detail, STATEPOINT shares the STACKMAP format at
19209     // this point in the process.  We diverge later.
19210     return emitPatchPoint(MI, BB);
19211
19212   case TargetOpcode::STACKMAP:
19213   case TargetOpcode::PATCHPOINT:
19214     return emitPatchPoint(MI, BB);
19215
19216   case X86::VFMADDPDr213r:
19217   case X86::VFMADDPSr213r:
19218   case X86::VFMADDSDr213r:
19219   case X86::VFMADDSSr213r:
19220   case X86::VFMSUBPDr213r:
19221   case X86::VFMSUBPSr213r:
19222   case X86::VFMSUBSDr213r:
19223   case X86::VFMSUBSSr213r:
19224   case X86::VFNMADDPDr213r:
19225   case X86::VFNMADDPSr213r:
19226   case X86::VFNMADDSDr213r:
19227   case X86::VFNMADDSSr213r:
19228   case X86::VFNMSUBPDr213r:
19229   case X86::VFNMSUBPSr213r:
19230   case X86::VFNMSUBSDr213r:
19231   case X86::VFNMSUBSSr213r:
19232   case X86::VFMADDSUBPDr213r:
19233   case X86::VFMADDSUBPSr213r:
19234   case X86::VFMSUBADDPDr213r:
19235   case X86::VFMSUBADDPSr213r:
19236   case X86::VFMADDPDr213rY:
19237   case X86::VFMADDPSr213rY:
19238   case X86::VFMSUBPDr213rY:
19239   case X86::VFMSUBPSr213rY:
19240   case X86::VFNMADDPDr213rY:
19241   case X86::VFNMADDPSr213rY:
19242   case X86::VFNMSUBPDr213rY:
19243   case X86::VFNMSUBPSr213rY:
19244   case X86::VFMADDSUBPDr213rY:
19245   case X86::VFMADDSUBPSr213rY:
19246   case X86::VFMSUBADDPDr213rY:
19247   case X86::VFMSUBADDPSr213rY:
19248     return emitFMA3Instr(MI, BB);
19249   }
19250 }
19251
19252 //===----------------------------------------------------------------------===//
19253 //                           X86 Optimization Hooks
19254 //===----------------------------------------------------------------------===//
19255
19256 void X86TargetLowering::computeKnownBitsForTargetNode(const SDValue Op,
19257                                                       APInt &KnownZero,
19258                                                       APInt &KnownOne,
19259                                                       const SelectionDAG &DAG,
19260                                                       unsigned Depth) const {
19261   unsigned BitWidth = KnownZero.getBitWidth();
19262   unsigned Opc = Op.getOpcode();
19263   assert((Opc >= ISD::BUILTIN_OP_END ||
19264           Opc == ISD::INTRINSIC_WO_CHAIN ||
19265           Opc == ISD::INTRINSIC_W_CHAIN ||
19266           Opc == ISD::INTRINSIC_VOID) &&
19267          "Should use MaskedValueIsZero if you don't know whether Op"
19268          " is a target node!");
19269
19270   KnownZero = KnownOne = APInt(BitWidth, 0);   // Don't know anything.
19271   switch (Opc) {
19272   default: break;
19273   case X86ISD::ADD:
19274   case X86ISD::SUB:
19275   case X86ISD::ADC:
19276   case X86ISD::SBB:
19277   case X86ISD::SMUL:
19278   case X86ISD::UMUL:
19279   case X86ISD::INC:
19280   case X86ISD::DEC:
19281   case X86ISD::OR:
19282   case X86ISD::XOR:
19283   case X86ISD::AND:
19284     // These nodes' second result is a boolean.
19285     if (Op.getResNo() == 0)
19286       break;
19287     // Fallthrough
19288   case X86ISD::SETCC:
19289     KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
19290     break;
19291   case ISD::INTRINSIC_WO_CHAIN: {
19292     unsigned IntId = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
19293     unsigned NumLoBits = 0;
19294     switch (IntId) {
19295     default: break;
19296     case Intrinsic::x86_sse_movmsk_ps:
19297     case Intrinsic::x86_avx_movmsk_ps_256:
19298     case Intrinsic::x86_sse2_movmsk_pd:
19299     case Intrinsic::x86_avx_movmsk_pd_256:
19300     case Intrinsic::x86_mmx_pmovmskb:
19301     case Intrinsic::x86_sse2_pmovmskb_128:
19302     case Intrinsic::x86_avx2_pmovmskb: {
19303       // High bits of movmskp{s|d}, pmovmskb are known zero.
19304       switch (IntId) {
19305         default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
19306         case Intrinsic::x86_sse_movmsk_ps:      NumLoBits = 4; break;
19307         case Intrinsic::x86_avx_movmsk_ps_256:  NumLoBits = 8; break;
19308         case Intrinsic::x86_sse2_movmsk_pd:     NumLoBits = 2; break;
19309         case Intrinsic::x86_avx_movmsk_pd_256:  NumLoBits = 4; break;
19310         case Intrinsic::x86_mmx_pmovmskb:       NumLoBits = 8; break;
19311         case Intrinsic::x86_sse2_pmovmskb_128:  NumLoBits = 16; break;
19312         case Intrinsic::x86_avx2_pmovmskb:      NumLoBits = 32; break;
19313       }
19314       KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - NumLoBits);
19315       break;
19316     }
19317     }
19318     break;
19319   }
19320   }
19321 }
19322
19323 unsigned X86TargetLowering::ComputeNumSignBitsForTargetNode(
19324   SDValue Op,
19325   const SelectionDAG &,
19326   unsigned Depth) const {
19327   // SETCC_CARRY sets the dest to ~0 for true or 0 for false.
19328   if (Op.getOpcode() == X86ISD::SETCC_CARRY)
19329     return Op.getValueType().getScalarType().getSizeInBits();
19330
19331   // Fallback case.
19332   return 1;
19333 }
19334
19335 /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
19336 /// node is a GlobalAddress + offset.
19337 bool X86TargetLowering::isGAPlusOffset(SDNode *N,
19338                                        const GlobalValue* &GA,
19339                                        int64_t &Offset) const {
19340   if (N->getOpcode() == X86ISD::Wrapper) {
19341     if (isa<GlobalAddressSDNode>(N->getOperand(0))) {
19342       GA = cast<GlobalAddressSDNode>(N->getOperand(0))->getGlobal();
19343       Offset = cast<GlobalAddressSDNode>(N->getOperand(0))->getOffset();
19344       return true;
19345     }
19346   }
19347   return TargetLowering::isGAPlusOffset(N, GA, Offset);
19348 }
19349
19350 /// isShuffleHigh128VectorInsertLow - Checks whether the shuffle node is the
19351 /// same as extracting the high 128-bit part of 256-bit vector and then
19352 /// inserting the result into the low part of a new 256-bit vector
19353 static bool isShuffleHigh128VectorInsertLow(ShuffleVectorSDNode *SVOp) {
19354   EVT VT = SVOp->getValueType(0);
19355   unsigned NumElems = VT.getVectorNumElements();
19356
19357   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
19358   for (unsigned i = 0, j = NumElems/2; i != NumElems/2; ++i, ++j)
19359     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
19360         SVOp->getMaskElt(j) >= 0)
19361       return false;
19362
19363   return true;
19364 }
19365
19366 /// isShuffleLow128VectorInsertHigh - Checks whether the shuffle node is the
19367 /// same as extracting the low 128-bit part of 256-bit vector and then
19368 /// inserting the result into the high part of a new 256-bit vector
19369 static bool isShuffleLow128VectorInsertHigh(ShuffleVectorSDNode *SVOp) {
19370   EVT VT = SVOp->getValueType(0);
19371   unsigned NumElems = VT.getVectorNumElements();
19372
19373   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
19374   for (unsigned i = NumElems/2, j = 0; i != NumElems; ++i, ++j)
19375     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
19376         SVOp->getMaskElt(j) >= 0)
19377       return false;
19378
19379   return true;
19380 }
19381
19382 /// PerformShuffleCombine256 - Performs shuffle combines for 256-bit vectors.
19383 static SDValue PerformShuffleCombine256(SDNode *N, SelectionDAG &DAG,
19384                                         TargetLowering::DAGCombinerInfo &DCI,
19385                                         const X86Subtarget* Subtarget) {
19386   SDLoc dl(N);
19387   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
19388   SDValue V1 = SVOp->getOperand(0);
19389   SDValue V2 = SVOp->getOperand(1);
19390   EVT VT = SVOp->getValueType(0);
19391   unsigned NumElems = VT.getVectorNumElements();
19392
19393   if (V1.getOpcode() == ISD::CONCAT_VECTORS &&
19394       V2.getOpcode() == ISD::CONCAT_VECTORS) {
19395     //
19396     //                   0,0,0,...
19397     //                      |
19398     //    V      UNDEF    BUILD_VECTOR    UNDEF
19399     //     \      /           \           /
19400     //  CONCAT_VECTOR         CONCAT_VECTOR
19401     //         \                  /
19402     //          \                /
19403     //          RESULT: V + zero extended
19404     //
19405     if (V2.getOperand(0).getOpcode() != ISD::BUILD_VECTOR ||
19406         V2.getOperand(1).getOpcode() != ISD::UNDEF ||
19407         V1.getOperand(1).getOpcode() != ISD::UNDEF)
19408       return SDValue();
19409
19410     if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
19411       return SDValue();
19412
19413     // To match the shuffle mask, the first half of the mask should
19414     // be exactly the first vector, and all the rest a splat with the
19415     // first element of the second one.
19416     for (unsigned i = 0; i != NumElems/2; ++i)
19417       if (!isUndefOrEqual(SVOp->getMaskElt(i), i) ||
19418           !isUndefOrEqual(SVOp->getMaskElt(i+NumElems/2), NumElems))
19419         return SDValue();
19420
19421     // If V1 is coming from a vector load then just fold to a VZEXT_LOAD.
19422     if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(V1.getOperand(0))) {
19423       if (Ld->hasNUsesOfValue(1, 0)) {
19424         SDVTList Tys = DAG.getVTList(MVT::v4i64, MVT::Other);
19425         SDValue Ops[] = { Ld->getChain(), Ld->getBasePtr() };
19426         SDValue ResNode =
19427           DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, dl, Tys, Ops,
19428                                   Ld->getMemoryVT(),
19429                                   Ld->getPointerInfo(),
19430                                   Ld->getAlignment(),
19431                                   false/*isVolatile*/, true/*ReadMem*/,
19432                                   false/*WriteMem*/);
19433
19434         // Make sure the newly-created LOAD is in the same position as Ld in
19435         // terms of dependency. We create a TokenFactor for Ld and ResNode,
19436         // and update uses of Ld's output chain to use the TokenFactor.
19437         if (Ld->hasAnyUseOfValue(1)) {
19438           SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
19439                              SDValue(Ld, 1), SDValue(ResNode.getNode(), 1));
19440           DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), NewChain);
19441           DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(Ld, 1),
19442                                  SDValue(ResNode.getNode(), 1));
19443         }
19444
19445         return DAG.getNode(ISD::BITCAST, dl, VT, ResNode);
19446       }
19447     }
19448
19449     // Emit a zeroed vector and insert the desired subvector on its
19450     // first half.
19451     SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
19452     SDValue InsV = Insert128BitVector(Zeros, V1.getOperand(0), 0, DAG, dl);
19453     return DCI.CombineTo(N, InsV);
19454   }
19455
19456   //===--------------------------------------------------------------------===//
19457   // Combine some shuffles into subvector extracts and inserts:
19458   //
19459
19460   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
19461   if (isShuffleHigh128VectorInsertLow(SVOp)) {
19462     SDValue V = Extract128BitVector(V1, NumElems/2, DAG, dl);
19463     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, 0, DAG, dl);
19464     return DCI.CombineTo(N, InsV);
19465   }
19466
19467   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
19468   if (isShuffleLow128VectorInsertHigh(SVOp)) {
19469     SDValue V = Extract128BitVector(V1, 0, DAG, dl);
19470     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, NumElems/2, DAG, dl);
19471     return DCI.CombineTo(N, InsV);
19472   }
19473
19474   return SDValue();
19475 }
19476
19477 /// \brief Combine an arbitrary chain of shuffles into a single instruction if
19478 /// possible.
19479 ///
19480 /// This is the leaf of the recursive combinine below. When we have found some
19481 /// chain of single-use x86 shuffle instructions and accumulated the combined
19482 /// shuffle mask represented by them, this will try to pattern match that mask
19483 /// into either a single instruction if there is a special purpose instruction
19484 /// for this operation, or into a PSHUFB instruction which is a fully general
19485 /// instruction but should only be used to replace chains over a certain depth.
19486 static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef<int> Mask,
19487                                    int Depth, bool HasPSHUFB, SelectionDAG &DAG,
19488                                    TargetLowering::DAGCombinerInfo &DCI,
19489                                    const X86Subtarget *Subtarget) {
19490   assert(!Mask.empty() && "Cannot combine an empty shuffle mask!");
19491
19492   // Find the operand that enters the chain. Note that multiple uses are OK
19493   // here, we're not going to remove the operand we find.
19494   SDValue Input = Op.getOperand(0);
19495   while (Input.getOpcode() == ISD::BITCAST)
19496     Input = Input.getOperand(0);
19497
19498   MVT VT = Input.getSimpleValueType();
19499   MVT RootVT = Root.getSimpleValueType();
19500   SDLoc DL(Root);
19501
19502   // Just remove no-op shuffle masks.
19503   if (Mask.size() == 1) {
19504     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Input),
19505                   /*AddTo*/ true);
19506     return true;
19507   }
19508
19509   // Use the float domain if the operand type is a floating point type.
19510   bool FloatDomain = VT.isFloatingPoint();
19511
19512   // For floating point shuffles, we don't have free copies in the shuffle
19513   // instructions or the ability to load as part of the instruction, so
19514   // canonicalize their shuffles to UNPCK or MOV variants.
19515   //
19516   // Note that even with AVX we prefer the PSHUFD form of shuffle for integer
19517   // vectors because it can have a load folded into it that UNPCK cannot. This
19518   // doesn't preclude something switching to the shorter encoding post-RA.
19519   //
19520   // FIXME: Should teach these routines about AVX vector widths.
19521   if (FloatDomain && VT.getSizeInBits() == 128) {
19522     if (Mask.equals({0, 0}) || Mask.equals({1, 1})) {
19523       bool Lo = Mask.equals({0, 0});
19524       unsigned Shuffle;
19525       MVT ShuffleVT;
19526       // Check if we have SSE3 which will let us use MOVDDUP. That instruction
19527       // is no slower than UNPCKLPD but has the option to fold the input operand
19528       // into even an unaligned memory load.
19529       if (Lo && Subtarget->hasSSE3()) {
19530         Shuffle = X86ISD::MOVDDUP;
19531         ShuffleVT = MVT::v2f64;
19532       } else {
19533         // We have MOVLHPS and MOVHLPS throughout SSE and they encode smaller
19534         // than the UNPCK variants.
19535         Shuffle = Lo ? X86ISD::MOVLHPS : X86ISD::MOVHLPS;
19536         ShuffleVT = MVT::v4f32;
19537       }
19538       if (Depth == 1 && Root->getOpcode() == Shuffle)
19539         return false; // Nothing to do!
19540       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
19541       DCI.AddToWorklist(Op.getNode());
19542       if (Shuffle == X86ISD::MOVDDUP)
19543         Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op);
19544       else
19545         Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
19546       DCI.AddToWorklist(Op.getNode());
19547       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
19548                     /*AddTo*/ true);
19549       return true;
19550     }
19551     if (Subtarget->hasSSE3() &&
19552         (Mask.equals({0, 0, 2, 2}) || Mask.equals({1, 1, 3, 3}))) {
19553       bool Lo = Mask.equals({0, 0, 2, 2});
19554       unsigned Shuffle = Lo ? X86ISD::MOVSLDUP : X86ISD::MOVSHDUP;
19555       MVT ShuffleVT = MVT::v4f32;
19556       if (Depth == 1 && Root->getOpcode() == Shuffle)
19557         return false; // Nothing to do!
19558       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
19559       DCI.AddToWorklist(Op.getNode());
19560       Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op);
19561       DCI.AddToWorklist(Op.getNode());
19562       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
19563                     /*AddTo*/ true);
19564       return true;
19565     }
19566     if (Mask.equals({0, 0, 1, 1}) || Mask.equals({2, 2, 3, 3})) {
19567       bool Lo = Mask.equals({0, 0, 1, 1});
19568       unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
19569       MVT ShuffleVT = MVT::v4f32;
19570       if (Depth == 1 && Root->getOpcode() == Shuffle)
19571         return false; // Nothing to do!
19572       Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
19573       DCI.AddToWorklist(Op.getNode());
19574       Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
19575       DCI.AddToWorklist(Op.getNode());
19576       DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
19577                     /*AddTo*/ true);
19578       return true;
19579     }
19580   }
19581
19582   // We always canonicalize the 8 x i16 and 16 x i8 shuffles into their UNPCK
19583   // variants as none of these have single-instruction variants that are
19584   // superior to the UNPCK formulation.
19585   if (!FloatDomain && VT.getSizeInBits() == 128 &&
19586       (Mask.equals({0, 0, 1, 1, 2, 2, 3, 3}) ||
19587        Mask.equals({4, 4, 5, 5, 6, 6, 7, 7}) ||
19588        Mask.equals({0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7}) ||
19589        Mask.equals(
19590            {8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15}))) {
19591     bool Lo = Mask[0] == 0;
19592     unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
19593     if (Depth == 1 && Root->getOpcode() == Shuffle)
19594       return false; // Nothing to do!
19595     MVT ShuffleVT;
19596     switch (Mask.size()) {
19597     case 8:
19598       ShuffleVT = MVT::v8i16;
19599       break;
19600     case 16:
19601       ShuffleVT = MVT::v16i8;
19602       break;
19603     default:
19604       llvm_unreachable("Impossible mask size!");
19605     };
19606     Op = DAG.getNode(ISD::BITCAST, DL, ShuffleVT, Input);
19607     DCI.AddToWorklist(Op.getNode());
19608     Op = DAG.getNode(Shuffle, DL, ShuffleVT, Op, Op);
19609     DCI.AddToWorklist(Op.getNode());
19610     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
19611                   /*AddTo*/ true);
19612     return true;
19613   }
19614
19615   // Don't try to re-form single instruction chains under any circumstances now
19616   // that we've done encoding canonicalization for them.
19617   if (Depth < 2)
19618     return false;
19619
19620   // If we have 3 or more shuffle instructions or a chain involving PSHUFB, we
19621   // can replace them with a single PSHUFB instruction profitably. Intel's
19622   // manuals suggest only using PSHUFB if doing so replacing 5 instructions, but
19623   // in practice PSHUFB tends to be *very* fast so we're more aggressive.
19624   if ((Depth >= 3 || HasPSHUFB) && Subtarget->hasSSSE3()) {
19625     SmallVector<SDValue, 16> PSHUFBMask;
19626     int NumBytes = VT.getSizeInBits() / 8;
19627     int Ratio = NumBytes / Mask.size();
19628     for (int i = 0; i < NumBytes; ++i) {
19629       if (Mask[i / Ratio] == SM_SentinelUndef) {
19630         PSHUFBMask.push_back(DAG.getUNDEF(MVT::i8));
19631         continue;
19632       }
19633       int M = Mask[i / Ratio] != SM_SentinelZero
19634                   ? Ratio * Mask[i / Ratio] + i % Ratio
19635                   : 255;
19636       PSHUFBMask.push_back(DAG.getConstant(M, MVT::i8));
19637     }
19638     MVT ByteVT = MVT::getVectorVT(MVT::i8, NumBytes);
19639     Op = DAG.getNode(ISD::BITCAST, DL, ByteVT, Input);
19640     DCI.AddToWorklist(Op.getNode());
19641     SDValue PSHUFBMaskOp =
19642         DAG.getNode(ISD::BUILD_VECTOR, DL, ByteVT, PSHUFBMask);
19643     DCI.AddToWorklist(PSHUFBMaskOp.getNode());
19644     Op = DAG.getNode(X86ISD::PSHUFB, DL, ByteVT, Op, PSHUFBMaskOp);
19645     DCI.AddToWorklist(Op.getNode());
19646     DCI.CombineTo(Root.getNode(), DAG.getNode(ISD::BITCAST, DL, RootVT, Op),
19647                   /*AddTo*/ true);
19648     return true;
19649   }
19650
19651   // Failed to find any combines.
19652   return false;
19653 }
19654
19655 /// \brief Fully generic combining of x86 shuffle instructions.
19656 ///
19657 /// This should be the last combine run over the x86 shuffle instructions. Once
19658 /// they have been fully optimized, this will recursively consider all chains
19659 /// of single-use shuffle instructions, build a generic model of the cumulative
19660 /// shuffle operation, and check for simpler instructions which implement this
19661 /// operation. We use this primarily for two purposes:
19662 ///
19663 /// 1) Collapse generic shuffles to specialized single instructions when
19664 ///    equivalent. In most cases, this is just an encoding size win, but
19665 ///    sometimes we will collapse multiple generic shuffles into a single
19666 ///    special-purpose shuffle.
19667 /// 2) Look for sequences of shuffle instructions with 3 or more total
19668 ///    instructions, and replace them with the slightly more expensive SSSE3
19669 ///    PSHUFB instruction if available. We do this as the last combining step
19670 ///    to ensure we avoid using PSHUFB if we can implement the shuffle with
19671 ///    a suitable short sequence of other instructions. The PHUFB will either
19672 ///    use a register or have to read from memory and so is slightly (but only
19673 ///    slightly) more expensive than the other shuffle instructions.
19674 ///
19675 /// Because this is inherently a quadratic operation (for each shuffle in
19676 /// a chain, we recurse up the chain), the depth is limited to 8 instructions.
19677 /// This should never be an issue in practice as the shuffle lowering doesn't
19678 /// produce sequences of more than 8 instructions.
19679 ///
19680 /// FIXME: We will currently miss some cases where the redundant shuffling
19681 /// would simplify under the threshold for PSHUFB formation because of
19682 /// combine-ordering. To fix this, we should do the redundant instruction
19683 /// combining in this recursive walk.
19684 static bool combineX86ShufflesRecursively(SDValue Op, SDValue Root,
19685                                           ArrayRef<int> RootMask,
19686                                           int Depth, bool HasPSHUFB,
19687                                           SelectionDAG &DAG,
19688                                           TargetLowering::DAGCombinerInfo &DCI,
19689                                           const X86Subtarget *Subtarget) {
19690   // Bound the depth of our recursive combine because this is ultimately
19691   // quadratic in nature.
19692   if (Depth > 8)
19693     return false;
19694
19695   // Directly rip through bitcasts to find the underlying operand.
19696   while (Op.getOpcode() == ISD::BITCAST && Op.getOperand(0).hasOneUse())
19697     Op = Op.getOperand(0);
19698
19699   MVT VT = Op.getSimpleValueType();
19700   if (!VT.isVector())
19701     return false; // Bail if we hit a non-vector.
19702
19703   assert(Root.getSimpleValueType().isVector() &&
19704          "Shuffles operate on vector types!");
19705   assert(VT.getSizeInBits() == Root.getSimpleValueType().getSizeInBits() &&
19706          "Can only combine shuffles of the same vector register size.");
19707
19708   if (!isTargetShuffle(Op.getOpcode()))
19709     return false;
19710   SmallVector<int, 16> OpMask;
19711   bool IsUnary;
19712   bool HaveMask = getTargetShuffleMask(Op.getNode(), VT, OpMask, IsUnary);
19713   // We only can combine unary shuffles which we can decode the mask for.
19714   if (!HaveMask || !IsUnary)
19715     return false;
19716
19717   assert(VT.getVectorNumElements() == OpMask.size() &&
19718          "Different mask size from vector size!");
19719   assert(((RootMask.size() > OpMask.size() &&
19720            RootMask.size() % OpMask.size() == 0) ||
19721           (OpMask.size() > RootMask.size() &&
19722            OpMask.size() % RootMask.size() == 0) ||
19723           OpMask.size() == RootMask.size()) &&
19724          "The smaller number of elements must divide the larger.");
19725   int RootRatio = std::max<int>(1, OpMask.size() / RootMask.size());
19726   int OpRatio = std::max<int>(1, RootMask.size() / OpMask.size());
19727   assert(((RootRatio == 1 && OpRatio == 1) ||
19728           (RootRatio == 1) != (OpRatio == 1)) &&
19729          "Must not have a ratio for both incoming and op masks!");
19730
19731   SmallVector<int, 16> Mask;
19732   Mask.reserve(std::max(OpMask.size(), RootMask.size()));
19733
19734   // Merge this shuffle operation's mask into our accumulated mask. Note that
19735   // this shuffle's mask will be the first applied to the input, followed by the
19736   // root mask to get us all the way to the root value arrangement. The reason
19737   // for this order is that we are recursing up the operation chain.
19738   for (int i = 0, e = std::max(OpMask.size(), RootMask.size()); i < e; ++i) {
19739     int RootIdx = i / RootRatio;
19740     if (RootMask[RootIdx] < 0) {
19741       // This is a zero or undef lane, we're done.
19742       Mask.push_back(RootMask[RootIdx]);
19743       continue;
19744     }
19745
19746     int RootMaskedIdx = RootMask[RootIdx] * RootRatio + i % RootRatio;
19747     int OpIdx = RootMaskedIdx / OpRatio;
19748     if (OpMask[OpIdx] < 0) {
19749       // The incoming lanes are zero or undef, it doesn't matter which ones we
19750       // are using.
19751       Mask.push_back(OpMask[OpIdx]);
19752       continue;
19753     }
19754
19755     // Ok, we have non-zero lanes, map them through.
19756     Mask.push_back(OpMask[OpIdx] * OpRatio +
19757                    RootMaskedIdx % OpRatio);
19758   }
19759
19760   // See if we can recurse into the operand to combine more things.
19761   switch (Op.getOpcode()) {
19762     case X86ISD::PSHUFB:
19763       HasPSHUFB = true;
19764     case X86ISD::PSHUFD:
19765     case X86ISD::PSHUFHW:
19766     case X86ISD::PSHUFLW:
19767       if (Op.getOperand(0).hasOneUse() &&
19768           combineX86ShufflesRecursively(Op.getOperand(0), Root, Mask, Depth + 1,
19769                                         HasPSHUFB, DAG, DCI, Subtarget))
19770         return true;
19771       break;
19772
19773     case X86ISD::UNPCKL:
19774     case X86ISD::UNPCKH:
19775       assert(Op.getOperand(0) == Op.getOperand(1) && "We only combine unary shuffles!");
19776       // We can't check for single use, we have to check that this shuffle is the only user.
19777       if (Op->isOnlyUserOf(Op.getOperand(0).getNode()) &&
19778           combineX86ShufflesRecursively(Op.getOperand(0), Root, Mask, Depth + 1,
19779                                         HasPSHUFB, DAG, DCI, Subtarget))
19780           return true;
19781       break;
19782   }
19783
19784   // Minor canonicalization of the accumulated shuffle mask to make it easier
19785   // to match below. All this does is detect masks with squential pairs of
19786   // elements, and shrink them to the half-width mask. It does this in a loop
19787   // so it will reduce the size of the mask to the minimal width mask which
19788   // performs an equivalent shuffle.
19789   SmallVector<int, 16> WidenedMask;
19790   while (Mask.size() > 1 && canWidenShuffleElements(Mask, WidenedMask)) {
19791     Mask = std::move(WidenedMask);
19792     WidenedMask.clear();
19793   }
19794
19795   return combineX86ShuffleChain(Op, Root, Mask, Depth, HasPSHUFB, DAG, DCI,
19796                                 Subtarget);
19797 }
19798
19799 /// \brief Get the PSHUF-style mask from PSHUF node.
19800 ///
19801 /// This is a very minor wrapper around getTargetShuffleMask to easy forming v4
19802 /// PSHUF-style masks that can be reused with such instructions.
19803 static SmallVector<int, 4> getPSHUFShuffleMask(SDValue N) {
19804   MVT VT = N.getSimpleValueType();
19805   SmallVector<int, 4> Mask;
19806   bool IsUnary;
19807   bool HaveMask = getTargetShuffleMask(N.getNode(), VT, Mask, IsUnary);
19808   (void)HaveMask;
19809   assert(HaveMask);
19810
19811   // If we have more than 128-bits, only the low 128-bits of shuffle mask
19812   // matter. Check that the upper masks are repeats and remove them.
19813   if (VT.getSizeInBits() > 128) {
19814     int LaneElts = 128 / VT.getScalarSizeInBits();
19815 #ifndef NDEBUG
19816     for (int i = 1, NumLanes = VT.getSizeInBits() / 128; i < NumLanes; ++i)
19817       for (int j = 0; j < LaneElts; ++j)
19818         assert(Mask[j] == Mask[i * LaneElts + j] - LaneElts &&
19819                "Mask doesn't repeat in high 128-bit lanes!");
19820 #endif
19821     Mask.resize(LaneElts);
19822   }
19823
19824   switch (N.getOpcode()) {
19825   case X86ISD::PSHUFD:
19826     return Mask;
19827   case X86ISD::PSHUFLW:
19828     Mask.resize(4);
19829     return Mask;
19830   case X86ISD::PSHUFHW:
19831     Mask.erase(Mask.begin(), Mask.begin() + 4);
19832     for (int &M : Mask)
19833       M -= 4;
19834     return Mask;
19835   default:
19836     llvm_unreachable("No valid shuffle instruction found!");
19837   }
19838 }
19839
19840 /// \brief Search for a combinable shuffle across a chain ending in pshufd.
19841 ///
19842 /// We walk up the chain and look for a combinable shuffle, skipping over
19843 /// shuffles that we could hoist this shuffle's transformation past without
19844 /// altering anything.
19845 static SDValue
19846 combineRedundantDWordShuffle(SDValue N, MutableArrayRef<int> Mask,
19847                              SelectionDAG &DAG,
19848                              TargetLowering::DAGCombinerInfo &DCI) {
19849   assert(N.getOpcode() == X86ISD::PSHUFD &&
19850          "Called with something other than an x86 128-bit half shuffle!");
19851   SDLoc DL(N);
19852
19853   // Walk up a single-use chain looking for a combinable shuffle. Keep a stack
19854   // of the shuffles in the chain so that we can form a fresh chain to replace
19855   // this one.
19856   SmallVector<SDValue, 8> Chain;
19857   SDValue V = N.getOperand(0);
19858   for (; V.hasOneUse(); V = V.getOperand(0)) {
19859     switch (V.getOpcode()) {
19860     default:
19861       return SDValue(); // Nothing combined!
19862
19863     case ISD::BITCAST:
19864       // Skip bitcasts as we always know the type for the target specific
19865       // instructions.
19866       continue;
19867
19868     case X86ISD::PSHUFD:
19869       // Found another dword shuffle.
19870       break;
19871
19872     case X86ISD::PSHUFLW:
19873       // Check that the low words (being shuffled) are the identity in the
19874       // dword shuffle, and the high words are self-contained.
19875       if (Mask[0] != 0 || Mask[1] != 1 ||
19876           !(Mask[2] >= 2 && Mask[2] < 4 && Mask[3] >= 2 && Mask[3] < 4))
19877         return SDValue();
19878
19879       Chain.push_back(V);
19880       continue;
19881
19882     case X86ISD::PSHUFHW:
19883       // Check that the high words (being shuffled) are the identity in the
19884       // dword shuffle, and the low words are self-contained.
19885       if (Mask[2] != 2 || Mask[3] != 3 ||
19886           !(Mask[0] >= 0 && Mask[0] < 2 && Mask[1] >= 0 && Mask[1] < 2))
19887         return SDValue();
19888
19889       Chain.push_back(V);
19890       continue;
19891
19892     case X86ISD::UNPCKL:
19893     case X86ISD::UNPCKH:
19894       // For either i8 -> i16 or i16 -> i32 unpacks, we can combine a dword
19895       // shuffle into a preceding word shuffle.
19896       if (V.getSimpleValueType().getScalarType() != MVT::i8 &&
19897           V.getSimpleValueType().getScalarType() != MVT::i16)
19898         return SDValue();
19899
19900       // Search for a half-shuffle which we can combine with.
19901       unsigned CombineOp =
19902           V.getOpcode() == X86ISD::UNPCKL ? X86ISD::PSHUFLW : X86ISD::PSHUFHW;
19903       if (V.getOperand(0) != V.getOperand(1) ||
19904           !V->isOnlyUserOf(V.getOperand(0).getNode()))
19905         return SDValue();
19906       Chain.push_back(V);
19907       V = V.getOperand(0);
19908       do {
19909         switch (V.getOpcode()) {
19910         default:
19911           return SDValue(); // Nothing to combine.
19912
19913         case X86ISD::PSHUFLW:
19914         case X86ISD::PSHUFHW:
19915           if (V.getOpcode() == CombineOp)
19916             break;
19917
19918           Chain.push_back(V);
19919
19920           // Fallthrough!
19921         case ISD::BITCAST:
19922           V = V.getOperand(0);
19923           continue;
19924         }
19925         break;
19926       } while (V.hasOneUse());
19927       break;
19928     }
19929     // Break out of the loop if we break out of the switch.
19930     break;
19931   }
19932
19933   if (!V.hasOneUse())
19934     // We fell out of the loop without finding a viable combining instruction.
19935     return SDValue();
19936
19937   // Merge this node's mask and our incoming mask.
19938   SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
19939   for (int &M : Mask)
19940     M = VMask[M];
19941   V = DAG.getNode(V.getOpcode(), DL, V.getValueType(), V.getOperand(0),
19942                   getV4X86ShuffleImm8ForMask(Mask, DAG));
19943
19944   // Rebuild the chain around this new shuffle.
19945   while (!Chain.empty()) {
19946     SDValue W = Chain.pop_back_val();
19947
19948     if (V.getValueType() != W.getOperand(0).getValueType())
19949       V = DAG.getNode(ISD::BITCAST, DL, W.getOperand(0).getValueType(), V);
19950
19951     switch (W.getOpcode()) {
19952     default:
19953       llvm_unreachable("Only PSHUF and UNPCK instructions get here!");
19954
19955     case X86ISD::UNPCKL:
19956     case X86ISD::UNPCKH:
19957       V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, V);
19958       break;
19959
19960     case X86ISD::PSHUFD:
19961     case X86ISD::PSHUFLW:
19962     case X86ISD::PSHUFHW:
19963       V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, W.getOperand(1));
19964       break;
19965     }
19966   }
19967   if (V.getValueType() != N.getValueType())
19968     V = DAG.getNode(ISD::BITCAST, DL, N.getValueType(), V);
19969
19970   // Return the new chain to replace N.
19971   return V;
19972 }
19973
19974 /// \brief Search for a combinable shuffle across a chain ending in pshuflw or pshufhw.
19975 ///
19976 /// We walk up the chain, skipping shuffles of the other half and looking
19977 /// through shuffles which switch halves trying to find a shuffle of the same
19978 /// pair of dwords.
19979 static bool combineRedundantHalfShuffle(SDValue N, MutableArrayRef<int> Mask,
19980                                         SelectionDAG &DAG,
19981                                         TargetLowering::DAGCombinerInfo &DCI) {
19982   assert(
19983       (N.getOpcode() == X86ISD::PSHUFLW || N.getOpcode() == X86ISD::PSHUFHW) &&
19984       "Called with something other than an x86 128-bit half shuffle!");
19985   SDLoc DL(N);
19986   unsigned CombineOpcode = N.getOpcode();
19987
19988   // Walk up a single-use chain looking for a combinable shuffle.
19989   SDValue V = N.getOperand(0);
19990   for (; V.hasOneUse(); V = V.getOperand(0)) {
19991     switch (V.getOpcode()) {
19992     default:
19993       return false; // Nothing combined!
19994
19995     case ISD::BITCAST:
19996       // Skip bitcasts as we always know the type for the target specific
19997       // instructions.
19998       continue;
19999
20000     case X86ISD::PSHUFLW:
20001     case X86ISD::PSHUFHW:
20002       if (V.getOpcode() == CombineOpcode)
20003         break;
20004
20005       // Other-half shuffles are no-ops.
20006       continue;
20007     }
20008     // Break out of the loop if we break out of the switch.
20009     break;
20010   }
20011
20012   if (!V.hasOneUse())
20013     // We fell out of the loop without finding a viable combining instruction.
20014     return false;
20015
20016   // Combine away the bottom node as its shuffle will be accumulated into
20017   // a preceding shuffle.
20018   DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
20019
20020   // Record the old value.
20021   SDValue Old = V;
20022
20023   // Merge this node's mask and our incoming mask (adjusted to account for all
20024   // the pshufd instructions encountered).
20025   SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
20026   for (int &M : Mask)
20027     M = VMask[M];
20028   V = DAG.getNode(V.getOpcode(), DL, MVT::v8i16, V.getOperand(0),
20029                   getV4X86ShuffleImm8ForMask(Mask, DAG));
20030
20031   // Check that the shuffles didn't cancel each other out. If not, we need to
20032   // combine to the new one.
20033   if (Old != V)
20034     // Replace the combinable shuffle with the combined one, updating all users
20035     // so that we re-evaluate the chain here.
20036     DCI.CombineTo(Old.getNode(), V, /*AddTo*/ true);
20037
20038   return true;
20039 }
20040
20041 /// \brief Try to combine x86 target specific shuffles.
20042 static SDValue PerformTargetShuffleCombine(SDValue N, SelectionDAG &DAG,
20043                                            TargetLowering::DAGCombinerInfo &DCI,
20044                                            const X86Subtarget *Subtarget) {
20045   SDLoc DL(N);
20046   MVT VT = N.getSimpleValueType();
20047   SmallVector<int, 4> Mask;
20048
20049   switch (N.getOpcode()) {
20050   case X86ISD::PSHUFD:
20051   case X86ISD::PSHUFLW:
20052   case X86ISD::PSHUFHW:
20053     Mask = getPSHUFShuffleMask(N);
20054     assert(Mask.size() == 4);
20055     break;
20056   default:
20057     return SDValue();
20058   }
20059
20060   // Nuke no-op shuffles that show up after combining.
20061   if (isNoopShuffleMask(Mask))
20062     return DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
20063
20064   // Look for simplifications involving one or two shuffle instructions.
20065   SDValue V = N.getOperand(0);
20066   switch (N.getOpcode()) {
20067   default:
20068     break;
20069   case X86ISD::PSHUFLW:
20070   case X86ISD::PSHUFHW:
20071     assert(VT.getScalarType() == MVT::i16 && "Bad word shuffle type!");
20072
20073     if (combineRedundantHalfShuffle(N, Mask, DAG, DCI))
20074       return SDValue(); // We combined away this shuffle, so we're done.
20075
20076     // See if this reduces to a PSHUFD which is no more expensive and can
20077     // combine with more operations. Note that it has to at least flip the
20078     // dwords as otherwise it would have been removed as a no-op.
20079     if (makeArrayRef(Mask).equals({2, 3, 0, 1})) {
20080       int DMask[] = {0, 1, 2, 3};
20081       int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2;
20082       DMask[DOffset + 0] = DOffset + 1;
20083       DMask[DOffset + 1] = DOffset + 0;
20084       MVT DVT = MVT::getVectorVT(MVT::i32, VT.getVectorNumElements() / 2);
20085       V = DAG.getNode(ISD::BITCAST, DL, DVT, V);
20086       DCI.AddToWorklist(V.getNode());
20087       V = DAG.getNode(X86ISD::PSHUFD, DL, DVT, V,
20088                       getV4X86ShuffleImm8ForMask(DMask, DAG));
20089       DCI.AddToWorklist(V.getNode());
20090       return DAG.getNode(ISD::BITCAST, DL, VT, V);
20091     }
20092
20093     // Look for shuffle patterns which can be implemented as a single unpack.
20094     // FIXME: This doesn't handle the location of the PSHUFD generically, and
20095     // only works when we have a PSHUFD followed by two half-shuffles.
20096     if (Mask[0] == Mask[1] && Mask[2] == Mask[3] &&
20097         (V.getOpcode() == X86ISD::PSHUFLW ||
20098          V.getOpcode() == X86ISD::PSHUFHW) &&
20099         V.getOpcode() != N.getOpcode() &&
20100         V.hasOneUse()) {
20101       SDValue D = V.getOperand(0);
20102       while (D.getOpcode() == ISD::BITCAST && D.hasOneUse())
20103         D = D.getOperand(0);
20104       if (D.getOpcode() == X86ISD::PSHUFD && D.hasOneUse()) {
20105         SmallVector<int, 4> VMask = getPSHUFShuffleMask(V);
20106         SmallVector<int, 4> DMask = getPSHUFShuffleMask(D);
20107         int NOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 4;
20108         int VOffset = V.getOpcode() == X86ISD::PSHUFLW ? 0 : 4;
20109         int WordMask[8];
20110         for (int i = 0; i < 4; ++i) {
20111           WordMask[i + NOffset] = Mask[i] + NOffset;
20112           WordMask[i + VOffset] = VMask[i] + VOffset;
20113         }
20114         // Map the word mask through the DWord mask.
20115         int MappedMask[8];
20116         for (int i = 0; i < 8; ++i)
20117           MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2;
20118         if (makeArrayRef(MappedMask).equals({0, 0, 1, 1, 2, 2, 3, 3}) ||
20119             makeArrayRef(MappedMask).equals({4, 4, 5, 5, 6, 6, 7, 7})) {
20120           // We can replace all three shuffles with an unpack.
20121           V = DAG.getNode(ISD::BITCAST, DL, VT, D.getOperand(0));
20122           DCI.AddToWorklist(V.getNode());
20123           return DAG.getNode(MappedMask[0] == 0 ? X86ISD::UNPCKL
20124                                                 : X86ISD::UNPCKH,
20125                              DL, VT, V, V);
20126         }
20127       }
20128     }
20129
20130     break;
20131
20132   case X86ISD::PSHUFD:
20133     if (SDValue NewN = combineRedundantDWordShuffle(N, Mask, DAG, DCI))
20134       return NewN;
20135
20136     break;
20137   }
20138
20139   return SDValue();
20140 }
20141
20142 /// \brief Try to combine a shuffle into a target-specific add-sub node.
20143 ///
20144 /// We combine this directly on the abstract vector shuffle nodes so it is
20145 /// easier to generically match. We also insert dummy vector shuffle nodes for
20146 /// the operands which explicitly discard the lanes which are unused by this
20147 /// operation to try to flow through the rest of the combiner the fact that
20148 /// they're unused.
20149 static SDValue combineShuffleToAddSub(SDNode *N, SelectionDAG &DAG) {
20150   SDLoc DL(N);
20151   EVT VT = N->getValueType(0);
20152
20153   // We only handle target-independent shuffles.
20154   // FIXME: It would be easy and harmless to use the target shuffle mask
20155   // extraction tool to support more.
20156   if (N->getOpcode() != ISD::VECTOR_SHUFFLE)
20157     return SDValue();
20158
20159   auto *SVN = cast<ShuffleVectorSDNode>(N);
20160   ArrayRef<int> Mask = SVN->getMask();
20161   SDValue V1 = N->getOperand(0);
20162   SDValue V2 = N->getOperand(1);
20163
20164   // We require the first shuffle operand to be the SUB node, and the second to
20165   // be the ADD node.
20166   // FIXME: We should support the commuted patterns.
20167   if (V1->getOpcode() != ISD::FSUB || V2->getOpcode() != ISD::FADD)
20168     return SDValue();
20169
20170   // If there are other uses of these operations we can't fold them.
20171   if (!V1->hasOneUse() || !V2->hasOneUse())
20172     return SDValue();
20173
20174   // Ensure that both operations have the same operands. Note that we can
20175   // commute the FADD operands.
20176   SDValue LHS = V1->getOperand(0), RHS = V1->getOperand(1);
20177   if ((V2->getOperand(0) != LHS || V2->getOperand(1) != RHS) &&
20178       (V2->getOperand(0) != RHS || V2->getOperand(1) != LHS))
20179     return SDValue();
20180
20181   // We're looking for blends between FADD and FSUB nodes. We insist on these
20182   // nodes being lined up in a specific expected pattern.
20183   if (!(isShuffleEquivalent(V1, V2, Mask, {0, 3}) ||
20184         isShuffleEquivalent(V1, V2, Mask, {0, 5, 2, 7}) ||
20185         isShuffleEquivalent(V1, V2, Mask, {0, 9, 2, 11, 4, 13, 6, 15})))
20186     return SDValue();
20187
20188   // Only specific types are legal at this point, assert so we notice if and
20189   // when these change.
20190   assert((VT == MVT::v4f32 || VT == MVT::v2f64 || VT == MVT::v8f32 ||
20191           VT == MVT::v4f64) &&
20192          "Unknown vector type encountered!");
20193
20194   return DAG.getNode(X86ISD::ADDSUB, DL, VT, LHS, RHS);
20195 }
20196
20197 /// PerformShuffleCombine - Performs several different shuffle combines.
20198 static SDValue PerformShuffleCombine(SDNode *N, SelectionDAG &DAG,
20199                                      TargetLowering::DAGCombinerInfo &DCI,
20200                                      const X86Subtarget *Subtarget) {
20201   SDLoc dl(N);
20202   SDValue N0 = N->getOperand(0);
20203   SDValue N1 = N->getOperand(1);
20204   EVT VT = N->getValueType(0);
20205
20206   // Don't create instructions with illegal types after legalize types has run.
20207   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20208   if (!DCI.isBeforeLegalize() && !TLI.isTypeLegal(VT.getVectorElementType()))
20209     return SDValue();
20210
20211   // If we have legalized the vector types, look for blends of FADD and FSUB
20212   // nodes that we can fuse into an ADDSUB node.
20213   if (TLI.isTypeLegal(VT) && Subtarget->hasSSE3())
20214     if (SDValue AddSub = combineShuffleToAddSub(N, DAG))
20215       return AddSub;
20216
20217   // Combine 256-bit vector shuffles. This is only profitable when in AVX mode
20218   if (Subtarget->hasFp256() && VT.is256BitVector() &&
20219       N->getOpcode() == ISD::VECTOR_SHUFFLE)
20220     return PerformShuffleCombine256(N, DAG, DCI, Subtarget);
20221
20222   // During Type Legalization, when promoting illegal vector types,
20223   // the backend might introduce new shuffle dag nodes and bitcasts.
20224   //
20225   // This code performs the following transformation:
20226   // fold: (shuffle (bitcast (BINOP A, B)), Undef, <Mask>) ->
20227   //       (shuffle (BINOP (bitcast A), (bitcast B)), Undef, <Mask>)
20228   //
20229   // We do this only if both the bitcast and the BINOP dag nodes have
20230   // one use. Also, perform this transformation only if the new binary
20231   // operation is legal. This is to avoid introducing dag nodes that
20232   // potentially need to be further expanded (or custom lowered) into a
20233   // less optimal sequence of dag nodes.
20234   if (!DCI.isBeforeLegalize() && DCI.isBeforeLegalizeOps() &&
20235       N1.getOpcode() == ISD::UNDEF && N0.hasOneUse() &&
20236       N0.getOpcode() == ISD::BITCAST) {
20237     SDValue BC0 = N0.getOperand(0);
20238     EVT SVT = BC0.getValueType();
20239     unsigned Opcode = BC0.getOpcode();
20240     unsigned NumElts = VT.getVectorNumElements();
20241
20242     if (BC0.hasOneUse() && SVT.isVector() &&
20243         SVT.getVectorNumElements() * 2 == NumElts &&
20244         TLI.isOperationLegal(Opcode, VT)) {
20245       bool CanFold = false;
20246       switch (Opcode) {
20247       default : break;
20248       case ISD::ADD :
20249       case ISD::FADD :
20250       case ISD::SUB :
20251       case ISD::FSUB :
20252       case ISD::MUL :
20253       case ISD::FMUL :
20254         CanFold = true;
20255       }
20256
20257       unsigned SVTNumElts = SVT.getVectorNumElements();
20258       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
20259       for (unsigned i = 0, e = SVTNumElts; i != e && CanFold; ++i)
20260         CanFold = SVOp->getMaskElt(i) == (int)(i * 2);
20261       for (unsigned i = SVTNumElts, e = NumElts; i != e && CanFold; ++i)
20262         CanFold = SVOp->getMaskElt(i) < 0;
20263
20264       if (CanFold) {
20265         SDValue BC00 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(0));
20266         SDValue BC01 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(1));
20267         SDValue NewBinOp = DAG.getNode(BC0.getOpcode(), dl, VT, BC00, BC01);
20268         return DAG.getVectorShuffle(VT, dl, NewBinOp, N1, &SVOp->getMask()[0]);
20269       }
20270     }
20271   }
20272
20273   // Combine a vector_shuffle that is equal to build_vector load1, load2, load3,
20274   // load4, <0, 1, 2, 3> into a 128-bit load if the load addresses are
20275   // consecutive, non-overlapping, and in the right order.
20276   SmallVector<SDValue, 16> Elts;
20277   for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
20278     Elts.push_back(getShuffleScalarElt(N, i, DAG, 0));
20279
20280   SDValue LD = EltsFromConsecutiveLoads(VT, Elts, dl, DAG, true);
20281   if (LD.getNode())
20282     return LD;
20283
20284   if (isTargetShuffle(N->getOpcode())) {
20285     SDValue Shuffle =
20286         PerformTargetShuffleCombine(SDValue(N, 0), DAG, DCI, Subtarget);
20287     if (Shuffle.getNode())
20288       return Shuffle;
20289
20290     // Try recursively combining arbitrary sequences of x86 shuffle
20291     // instructions into higher-order shuffles. We do this after combining
20292     // specific PSHUF instruction sequences into their minimal form so that we
20293     // can evaluate how many specialized shuffle instructions are involved in
20294     // a particular chain.
20295     SmallVector<int, 1> NonceMask; // Just a placeholder.
20296     NonceMask.push_back(0);
20297     if (combineX86ShufflesRecursively(SDValue(N, 0), SDValue(N, 0), NonceMask,
20298                                       /*Depth*/ 1, /*HasPSHUFB*/ false, DAG,
20299                                       DCI, Subtarget))
20300       return SDValue(); // This routine will use CombineTo to replace N.
20301   }
20302
20303   return SDValue();
20304 }
20305
20306 /// PerformTruncateCombine - Converts truncate operation to
20307 /// a sequence of vector shuffle operations.
20308 /// It is possible when we truncate 256-bit vector to 128-bit vector
20309 static SDValue PerformTruncateCombine(SDNode *N, SelectionDAG &DAG,
20310                                       TargetLowering::DAGCombinerInfo &DCI,
20311                                       const X86Subtarget *Subtarget)  {
20312   return SDValue();
20313 }
20314
20315 /// XFormVExtractWithShuffleIntoLoad - Check if a vector extract from a target
20316 /// specific shuffle of a load can be folded into a single element load.
20317 /// Similar handling for VECTOR_SHUFFLE is performed by DAGCombiner, but
20318 /// shuffles have been custom lowered so we need to handle those here.
20319 static SDValue XFormVExtractWithShuffleIntoLoad(SDNode *N, SelectionDAG &DAG,
20320                                          TargetLowering::DAGCombinerInfo &DCI) {
20321   if (DCI.isBeforeLegalizeOps())
20322     return SDValue();
20323
20324   SDValue InVec = N->getOperand(0);
20325   SDValue EltNo = N->getOperand(1);
20326
20327   if (!isa<ConstantSDNode>(EltNo))
20328     return SDValue();
20329
20330   EVT OriginalVT = InVec.getValueType();
20331
20332   if (InVec.getOpcode() == ISD::BITCAST) {
20333     // Don't duplicate a load with other uses.
20334     if (!InVec.hasOneUse())
20335       return SDValue();
20336     EVT BCVT = InVec.getOperand(0).getValueType();
20337     if (BCVT.getVectorNumElements() != OriginalVT.getVectorNumElements())
20338       return SDValue();
20339     InVec = InVec.getOperand(0);
20340   }
20341
20342   EVT CurrentVT = InVec.getValueType();
20343
20344   if (!isTargetShuffle(InVec.getOpcode()))
20345     return SDValue();
20346
20347   // Don't duplicate a load with other uses.
20348   if (!InVec.hasOneUse())
20349     return SDValue();
20350
20351   SmallVector<int, 16> ShuffleMask;
20352   bool UnaryShuffle;
20353   if (!getTargetShuffleMask(InVec.getNode(), CurrentVT.getSimpleVT(),
20354                             ShuffleMask, UnaryShuffle))
20355     return SDValue();
20356
20357   // Select the input vector, guarding against out of range extract vector.
20358   unsigned NumElems = CurrentVT.getVectorNumElements();
20359   int Elt = cast<ConstantSDNode>(EltNo)->getZExtValue();
20360   int Idx = (Elt > (int)NumElems) ? -1 : ShuffleMask[Elt];
20361   SDValue LdNode = (Idx < (int)NumElems) ? InVec.getOperand(0)
20362                                          : InVec.getOperand(1);
20363
20364   // If inputs to shuffle are the same for both ops, then allow 2 uses
20365   unsigned AllowedUses = InVec.getNumOperands() > 1 &&
20366                          InVec.getOperand(0) == InVec.getOperand(1) ? 2 : 1;
20367
20368   if (LdNode.getOpcode() == ISD::BITCAST) {
20369     // Don't duplicate a load with other uses.
20370     if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
20371       return SDValue();
20372
20373     AllowedUses = 1; // only allow 1 load use if we have a bitcast
20374     LdNode = LdNode.getOperand(0);
20375   }
20376
20377   if (!ISD::isNormalLoad(LdNode.getNode()))
20378     return SDValue();
20379
20380   LoadSDNode *LN0 = cast<LoadSDNode>(LdNode);
20381
20382   if (!LN0 ||!LN0->hasNUsesOfValue(AllowedUses, 0) || LN0->isVolatile())
20383     return SDValue();
20384
20385   EVT EltVT = N->getValueType(0);
20386   // If there's a bitcast before the shuffle, check if the load type and
20387   // alignment is valid.
20388   unsigned Align = LN0->getAlignment();
20389   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20390   unsigned NewAlign = TLI.getDataLayout()->getABITypeAlignment(
20391       EltVT.getTypeForEVT(*DAG.getContext()));
20392
20393   if (NewAlign > Align || !TLI.isOperationLegalOrCustom(ISD::LOAD, EltVT))
20394     return SDValue();
20395
20396   // All checks match so transform back to vector_shuffle so that DAG combiner
20397   // can finish the job
20398   SDLoc dl(N);
20399
20400   // Create shuffle node taking into account the case that its a unary shuffle
20401   SDValue Shuffle = (UnaryShuffle) ? DAG.getUNDEF(CurrentVT)
20402                                    : InVec.getOperand(1);
20403   Shuffle = DAG.getVectorShuffle(CurrentVT, dl,
20404                                  InVec.getOperand(0), Shuffle,
20405                                  &ShuffleMask[0]);
20406   Shuffle = DAG.getNode(ISD::BITCAST, dl, OriginalVT, Shuffle);
20407   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
20408                      EltNo);
20409 }
20410
20411 /// \brief Detect bitcasts between i32 to x86mmx low word. Since MMX types are
20412 /// special and don't usually play with other vector types, it's better to
20413 /// handle them early to be sure we emit efficient code by avoiding
20414 /// store-load conversions.
20415 static SDValue PerformBITCASTCombine(SDNode *N, SelectionDAG &DAG) {
20416   if (N->getValueType(0) != MVT::x86mmx ||
20417       N->getOperand(0)->getOpcode() != ISD::BUILD_VECTOR ||
20418       N->getOperand(0)->getValueType(0) != MVT::v2i32)
20419     return SDValue();
20420
20421   SDValue V = N->getOperand(0);
20422   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V.getOperand(1));
20423   if (C && C->getZExtValue() == 0 && V.getOperand(0).getValueType() == MVT::i32)
20424     return DAG.getNode(X86ISD::MMX_MOVW2D, SDLoc(V.getOperand(0)),
20425                        N->getValueType(0), V.getOperand(0));
20426
20427   return SDValue();
20428 }
20429
20430 /// PerformEXTRACT_VECTOR_ELTCombine - Detect vector gather/scatter index
20431 /// generation and convert it from being a bunch of shuffles and extracts
20432 /// into a somewhat faster sequence. For i686, the best sequence is apparently
20433 /// storing the value and loading scalars back, while for x64 we should
20434 /// use 64-bit extracts and shifts.
20435 static SDValue PerformEXTRACT_VECTOR_ELTCombine(SDNode *N, SelectionDAG &DAG,
20436                                          TargetLowering::DAGCombinerInfo &DCI) {
20437   SDValue NewOp = XFormVExtractWithShuffleIntoLoad(N, DAG, DCI);
20438   if (NewOp.getNode())
20439     return NewOp;
20440
20441   SDValue InputVector = N->getOperand(0);
20442
20443   // Detect mmx to i32 conversion through a v2i32 elt extract.
20444   if (InputVector.getOpcode() == ISD::BITCAST && InputVector.hasOneUse() &&
20445       N->getValueType(0) == MVT::i32 &&
20446       InputVector.getValueType() == MVT::v2i32) {
20447
20448     // The bitcast source is a direct mmx result.
20449     SDValue MMXSrc = InputVector.getNode()->getOperand(0);
20450     if (MMXSrc.getValueType() == MVT::x86mmx)
20451       return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
20452                          N->getValueType(0),
20453                          InputVector.getNode()->getOperand(0));
20454
20455     // The mmx is indirect: (i64 extract_elt (v1i64 bitcast (x86mmx ...))).
20456     SDValue MMXSrcOp = MMXSrc.getOperand(0);
20457     if (MMXSrc.getOpcode() == ISD::EXTRACT_VECTOR_ELT && MMXSrc.hasOneUse() &&
20458         MMXSrc.getValueType() == MVT::i64 && MMXSrcOp.hasOneUse() &&
20459         MMXSrcOp.getOpcode() == ISD::BITCAST &&
20460         MMXSrcOp.getValueType() == MVT::v1i64 &&
20461         MMXSrcOp.getOperand(0).getValueType() == MVT::x86mmx)
20462       return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
20463                          N->getValueType(0),
20464                          MMXSrcOp.getOperand(0));
20465   }
20466
20467   // Only operate on vectors of 4 elements, where the alternative shuffling
20468   // gets to be more expensive.
20469   if (InputVector.getValueType() != MVT::v4i32)
20470     return SDValue();
20471
20472   // Check whether every use of InputVector is an EXTRACT_VECTOR_ELT with a
20473   // single use which is a sign-extend or zero-extend, and all elements are
20474   // used.
20475   SmallVector<SDNode *, 4> Uses;
20476   unsigned ExtractedElements = 0;
20477   for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
20478        UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
20479     if (UI.getUse().getResNo() != InputVector.getResNo())
20480       return SDValue();
20481
20482     SDNode *Extract = *UI;
20483     if (Extract->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
20484       return SDValue();
20485
20486     if (Extract->getValueType(0) != MVT::i32)
20487       return SDValue();
20488     if (!Extract->hasOneUse())
20489       return SDValue();
20490     if (Extract->use_begin()->getOpcode() != ISD::SIGN_EXTEND &&
20491         Extract->use_begin()->getOpcode() != ISD::ZERO_EXTEND)
20492       return SDValue();
20493     if (!isa<ConstantSDNode>(Extract->getOperand(1)))
20494       return SDValue();
20495
20496     // Record which element was extracted.
20497     ExtractedElements |=
20498       1 << cast<ConstantSDNode>(Extract->getOperand(1))->getZExtValue();
20499
20500     Uses.push_back(Extract);
20501   }
20502
20503   // If not all the elements were used, this may not be worthwhile.
20504   if (ExtractedElements != 15)
20505     return SDValue();
20506
20507   // Ok, we've now decided to do the transformation.
20508   // If 64-bit shifts are legal, use the extract-shift sequence,
20509   // otherwise bounce the vector off the cache.
20510   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20511   SDValue Vals[4];
20512   SDLoc dl(InputVector);
20513
20514   if (TLI.isOperationLegal(ISD::SRA, MVT::i64)) {
20515     SDValue Cst = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, InputVector);
20516     EVT VecIdxTy = DAG.getTargetLoweringInfo().getVectorIdxTy();
20517     SDValue BottomHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Cst,
20518       DAG.getConstant(0, VecIdxTy));
20519     SDValue TopHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Cst,
20520       DAG.getConstant(1, VecIdxTy));
20521
20522     SDValue ShAmt = DAG.getConstant(32,
20523       DAG.getTargetLoweringInfo().getShiftAmountTy(MVT::i64));
20524     Vals[0] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BottomHalf);
20525     Vals[1] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
20526       DAG.getNode(ISD::SRA, dl, MVT::i64, BottomHalf, ShAmt));
20527     Vals[2] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, TopHalf);
20528     Vals[3] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
20529       DAG.getNode(ISD::SRA, dl, MVT::i64, TopHalf, ShAmt));
20530   } else {
20531     // Store the value to a temporary stack slot.
20532     SDValue StackPtr = DAG.CreateStackTemporary(InputVector.getValueType());
20533     SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, InputVector, StackPtr,
20534       MachinePointerInfo(), false, false, 0);
20535
20536     EVT ElementType = InputVector.getValueType().getVectorElementType();
20537     unsigned EltSize = ElementType.getSizeInBits() / 8;
20538
20539     // Replace each use (extract) with a load of the appropriate element.
20540     for (unsigned i = 0; i < 4; ++i) {
20541       uint64_t Offset = EltSize * i;
20542       SDValue OffsetVal = DAG.getConstant(Offset, TLI.getPointerTy());
20543
20544       SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
20545                                        StackPtr, OffsetVal);
20546
20547       // Load the scalar.
20548       Vals[i] = DAG.getLoad(ElementType, dl, Ch,
20549                             ScalarAddr, MachinePointerInfo(),
20550                             false, false, false, 0);
20551
20552     }
20553   }
20554
20555   // Replace the extracts
20556   for (SmallVectorImpl<SDNode *>::iterator UI = Uses.begin(),
20557     UE = Uses.end(); UI != UE; ++UI) {
20558     SDNode *Extract = *UI;
20559
20560     SDValue Idx = Extract->getOperand(1);
20561     uint64_t IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
20562     DAG.ReplaceAllUsesOfValueWith(SDValue(Extract, 0), Vals[IdxVal]);
20563   }
20564
20565   // The replacement was made in place; don't return anything.
20566   return SDValue();
20567 }
20568
20569 /// \brief Matches a VSELECT onto min/max or return 0 if the node doesn't match.
20570 static std::pair<unsigned, bool>
20571 matchIntegerMINMAX(SDValue Cond, EVT VT, SDValue LHS, SDValue RHS,
20572                    SelectionDAG &DAG, const X86Subtarget *Subtarget) {
20573   if (!VT.isVector())
20574     return std::make_pair(0, false);
20575
20576   bool NeedSplit = false;
20577   switch (VT.getSimpleVT().SimpleTy) {
20578   default: return std::make_pair(0, false);
20579   case MVT::v4i64:
20580   case MVT::v2i64:
20581     if (!Subtarget->hasVLX())
20582       return std::make_pair(0, false);
20583     break;
20584   case MVT::v64i8:
20585   case MVT::v32i16:
20586     if (!Subtarget->hasBWI())
20587       return std::make_pair(0, false);
20588     break;
20589   case MVT::v16i32:
20590   case MVT::v8i64:
20591     if (!Subtarget->hasAVX512())
20592       return std::make_pair(0, false);
20593     break;
20594   case MVT::v32i8:
20595   case MVT::v16i16:
20596   case MVT::v8i32:
20597     if (!Subtarget->hasAVX2())
20598       NeedSplit = true;
20599     if (!Subtarget->hasAVX())
20600       return std::make_pair(0, false);
20601     break;
20602   case MVT::v16i8:
20603   case MVT::v8i16:
20604   case MVT::v4i32:
20605     if (!Subtarget->hasSSE2())
20606       return std::make_pair(0, false);
20607   }
20608
20609   // SSE2 has only a small subset of the operations.
20610   bool hasUnsigned = Subtarget->hasSSE41() ||
20611                      (Subtarget->hasSSE2() && VT == MVT::v16i8);
20612   bool hasSigned = Subtarget->hasSSE41() ||
20613                    (Subtarget->hasSSE2() && VT == MVT::v8i16);
20614
20615   ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
20616
20617   unsigned Opc = 0;
20618   // Check for x CC y ? x : y.
20619   if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
20620       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
20621     switch (CC) {
20622     default: break;
20623     case ISD::SETULT:
20624     case ISD::SETULE:
20625       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
20626     case ISD::SETUGT:
20627     case ISD::SETUGE:
20628       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
20629     case ISD::SETLT:
20630     case ISD::SETLE:
20631       Opc = hasSigned ? X86ISD::SMIN : 0; break;
20632     case ISD::SETGT:
20633     case ISD::SETGE:
20634       Opc = hasSigned ? X86ISD::SMAX : 0; break;
20635     }
20636   // Check for x CC y ? y : x -- a min/max with reversed arms.
20637   } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
20638              DAG.isEqualTo(RHS, Cond.getOperand(0))) {
20639     switch (CC) {
20640     default: break;
20641     case ISD::SETULT:
20642     case ISD::SETULE:
20643       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
20644     case ISD::SETUGT:
20645     case ISD::SETUGE:
20646       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
20647     case ISD::SETLT:
20648     case ISD::SETLE:
20649       Opc = hasSigned ? X86ISD::SMAX : 0; break;
20650     case ISD::SETGT:
20651     case ISD::SETGE:
20652       Opc = hasSigned ? X86ISD::SMIN : 0; break;
20653     }
20654   }
20655
20656   return std::make_pair(Opc, NeedSplit);
20657 }
20658
20659 static SDValue
20660 transformVSELECTtoBlendVECTOR_SHUFFLE(SDNode *N, SelectionDAG &DAG,
20661                                       const X86Subtarget *Subtarget) {
20662   SDLoc dl(N);
20663   SDValue Cond = N->getOperand(0);
20664   SDValue LHS = N->getOperand(1);
20665   SDValue RHS = N->getOperand(2);
20666
20667   if (Cond.getOpcode() == ISD::SIGN_EXTEND) {
20668     SDValue CondSrc = Cond->getOperand(0);
20669     if (CondSrc->getOpcode() == ISD::SIGN_EXTEND_INREG)
20670       Cond = CondSrc->getOperand(0);
20671   }
20672
20673   if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
20674     return SDValue();
20675
20676   // A vselect where all conditions and data are constants can be optimized into
20677   // a single vector load by SelectionDAGLegalize::ExpandBUILD_VECTOR().
20678   if (ISD::isBuildVectorOfConstantSDNodes(LHS.getNode()) &&
20679       ISD::isBuildVectorOfConstantSDNodes(RHS.getNode()))
20680     return SDValue();
20681
20682   unsigned MaskValue = 0;
20683   if (!BUILD_VECTORtoBlendMask(cast<BuildVectorSDNode>(Cond), MaskValue))
20684     return SDValue();
20685
20686   MVT VT = N->getSimpleValueType(0);
20687   unsigned NumElems = VT.getVectorNumElements();
20688   SmallVector<int, 8> ShuffleMask(NumElems, -1);
20689   for (unsigned i = 0; i < NumElems; ++i) {
20690     // Be sure we emit undef where we can.
20691     if (Cond.getOperand(i)->getOpcode() == ISD::UNDEF)
20692       ShuffleMask[i] = -1;
20693     else
20694       ShuffleMask[i] = i + NumElems * ((MaskValue >> i) & 1);
20695   }
20696
20697   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20698   if (!TLI.isShuffleMaskLegal(ShuffleMask, VT))
20699     return SDValue();
20700   return DAG.getVectorShuffle(VT, dl, LHS, RHS, &ShuffleMask[0]);
20701 }
20702
20703 /// PerformSELECTCombine - Do target-specific dag combines on SELECT and VSELECT
20704 /// nodes.
20705 static SDValue PerformSELECTCombine(SDNode *N, SelectionDAG &DAG,
20706                                     TargetLowering::DAGCombinerInfo &DCI,
20707                                     const X86Subtarget *Subtarget) {
20708   SDLoc DL(N);
20709   SDValue Cond = N->getOperand(0);
20710   // Get the LHS/RHS of the select.
20711   SDValue LHS = N->getOperand(1);
20712   SDValue RHS = N->getOperand(2);
20713   EVT VT = LHS.getValueType();
20714   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
20715
20716   // If we have SSE[12] support, try to form min/max nodes. SSE min/max
20717   // instructions match the semantics of the common C idiom x<y?x:y but not
20718   // x<=y?x:y, because of how they handle negative zero (which can be
20719   // ignored in unsafe-math mode).
20720   // We also try to create v2f32 min/max nodes, which we later widen to v4f32.
20721   if (Cond.getOpcode() == ISD::SETCC && VT.isFloatingPoint() &&
20722       VT != MVT::f80 && (TLI.isTypeLegal(VT) || VT == MVT::v2f32) &&
20723       (Subtarget->hasSSE2() ||
20724        (Subtarget->hasSSE1() && VT.getScalarType() == MVT::f32))) {
20725     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
20726
20727     unsigned Opcode = 0;
20728     // Check for x CC y ? x : y.
20729     if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
20730         DAG.isEqualTo(RHS, Cond.getOperand(1))) {
20731       switch (CC) {
20732       default: break;
20733       case ISD::SETULT:
20734         // Converting this to a min would handle NaNs incorrectly, and swapping
20735         // the operands would cause it to handle comparisons between positive
20736         // and negative zero incorrectly.
20737         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
20738           if (!DAG.getTarget().Options.UnsafeFPMath &&
20739               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
20740             break;
20741           std::swap(LHS, RHS);
20742         }
20743         Opcode = X86ISD::FMIN;
20744         break;
20745       case ISD::SETOLE:
20746         // Converting this to a min would handle comparisons between positive
20747         // and negative zero incorrectly.
20748         if (!DAG.getTarget().Options.UnsafeFPMath &&
20749             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
20750           break;
20751         Opcode = X86ISD::FMIN;
20752         break;
20753       case ISD::SETULE:
20754         // Converting this to a min would handle both negative zeros and NaNs
20755         // incorrectly, but we can swap the operands to fix both.
20756         std::swap(LHS, RHS);
20757       case ISD::SETOLT:
20758       case ISD::SETLT:
20759       case ISD::SETLE:
20760         Opcode = X86ISD::FMIN;
20761         break;
20762
20763       case ISD::SETOGE:
20764         // Converting this to a max would handle comparisons between positive
20765         // and negative zero incorrectly.
20766         if (!DAG.getTarget().Options.UnsafeFPMath &&
20767             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
20768           break;
20769         Opcode = X86ISD::FMAX;
20770         break;
20771       case ISD::SETUGT:
20772         // Converting this to a max would handle NaNs incorrectly, and swapping
20773         // the operands would cause it to handle comparisons between positive
20774         // and negative zero incorrectly.
20775         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
20776           if (!DAG.getTarget().Options.UnsafeFPMath &&
20777               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
20778             break;
20779           std::swap(LHS, RHS);
20780         }
20781         Opcode = X86ISD::FMAX;
20782         break;
20783       case ISD::SETUGE:
20784         // Converting this to a max would handle both negative zeros and NaNs
20785         // incorrectly, but we can swap the operands to fix both.
20786         std::swap(LHS, RHS);
20787       case ISD::SETOGT:
20788       case ISD::SETGT:
20789       case ISD::SETGE:
20790         Opcode = X86ISD::FMAX;
20791         break;
20792       }
20793     // Check for x CC y ? y : x -- a min/max with reversed arms.
20794     } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
20795                DAG.isEqualTo(RHS, Cond.getOperand(0))) {
20796       switch (CC) {
20797       default: break;
20798       case ISD::SETOGE:
20799         // Converting this to a min would handle comparisons between positive
20800         // and negative zero incorrectly, and swapping the operands would
20801         // cause it to handle NaNs incorrectly.
20802         if (!DAG.getTarget().Options.UnsafeFPMath &&
20803             !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS))) {
20804           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
20805             break;
20806           std::swap(LHS, RHS);
20807         }
20808         Opcode = X86ISD::FMIN;
20809         break;
20810       case ISD::SETUGT:
20811         // Converting this to a min would handle NaNs incorrectly.
20812         if (!DAG.getTarget().Options.UnsafeFPMath &&
20813             (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)))
20814           break;
20815         Opcode = X86ISD::FMIN;
20816         break;
20817       case ISD::SETUGE:
20818         // Converting this to a min would handle both negative zeros and NaNs
20819         // incorrectly, but we can swap the operands to fix both.
20820         std::swap(LHS, RHS);
20821       case ISD::SETOGT:
20822       case ISD::SETGT:
20823       case ISD::SETGE:
20824         Opcode = X86ISD::FMIN;
20825         break;
20826
20827       case ISD::SETULT:
20828         // Converting this to a max would handle NaNs incorrectly.
20829         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
20830           break;
20831         Opcode = X86ISD::FMAX;
20832         break;
20833       case ISD::SETOLE:
20834         // Converting this to a max would handle comparisons between positive
20835         // and negative zero incorrectly, and swapping the operands would
20836         // cause it to handle NaNs incorrectly.
20837         if (!DAG.getTarget().Options.UnsafeFPMath &&
20838             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS)) {
20839           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
20840             break;
20841           std::swap(LHS, RHS);
20842         }
20843         Opcode = X86ISD::FMAX;
20844         break;
20845       case ISD::SETULE:
20846         // Converting this to a max would handle both negative zeros and NaNs
20847         // incorrectly, but we can swap the operands to fix both.
20848         std::swap(LHS, RHS);
20849       case ISD::SETOLT:
20850       case ISD::SETLT:
20851       case ISD::SETLE:
20852         Opcode = X86ISD::FMAX;
20853         break;
20854       }
20855     }
20856
20857     if (Opcode)
20858       return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
20859   }
20860
20861   EVT CondVT = Cond.getValueType();
20862   if (Subtarget->hasAVX512() && VT.isVector() && CondVT.isVector() &&
20863       CondVT.getVectorElementType() == MVT::i1) {
20864     // v16i8 (select v16i1, v16i8, v16i8) does not have a proper
20865     // lowering on KNL. In this case we convert it to
20866     // v16i8 (select v16i8, v16i8, v16i8) and use AVX instruction.
20867     // The same situation for all 128 and 256-bit vectors of i8 and i16.
20868     // Since SKX these selects have a proper lowering.
20869     EVT OpVT = LHS.getValueType();
20870     if ((OpVT.is128BitVector() || OpVT.is256BitVector()) &&
20871         (OpVT.getVectorElementType() == MVT::i8 ||
20872          OpVT.getVectorElementType() == MVT::i16) &&
20873         !(Subtarget->hasBWI() && Subtarget->hasVLX())) {
20874       Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, OpVT, Cond);
20875       DCI.AddToWorklist(Cond.getNode());
20876       return DAG.getNode(N->getOpcode(), DL, OpVT, Cond, LHS, RHS);
20877     }
20878   }
20879   // If this is a select between two integer constants, try to do some
20880   // optimizations.
20881   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(LHS)) {
20882     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(RHS))
20883       // Don't do this for crazy integer types.
20884       if (DAG.getTargetLoweringInfo().isTypeLegal(LHS.getValueType())) {
20885         // If this is efficiently invertible, canonicalize the LHSC/RHSC values
20886         // so that TrueC (the true value) is larger than FalseC.
20887         bool NeedsCondInvert = false;
20888
20889         if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue()) &&
20890             // Efficiently invertible.
20891             (Cond.getOpcode() == ISD::SETCC ||  // setcc -> invertible.
20892              (Cond.getOpcode() == ISD::XOR &&   // xor(X, C) -> invertible.
20893               isa<ConstantSDNode>(Cond.getOperand(1))))) {
20894           NeedsCondInvert = true;
20895           std::swap(TrueC, FalseC);
20896         }
20897
20898         // Optimize C ? 8 : 0 -> zext(C) << 3.  Likewise for any pow2/0.
20899         if (FalseC->getAPIntValue() == 0 &&
20900             TrueC->getAPIntValue().isPowerOf2()) {
20901           if (NeedsCondInvert) // Invert the condition if needed.
20902             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
20903                                DAG.getConstant(1, Cond.getValueType()));
20904
20905           // Zero extend the condition if needed.
20906           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
20907
20908           unsigned ShAmt = TrueC->getAPIntValue().logBase2();
20909           return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
20910                              DAG.getConstant(ShAmt, MVT::i8));
20911         }
20912
20913         // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.
20914         if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
20915           if (NeedsCondInvert) // Invert the condition if needed.
20916             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
20917                                DAG.getConstant(1, Cond.getValueType()));
20918
20919           // Zero extend the condition if needed.
20920           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
20921                              FalseC->getValueType(0), Cond);
20922           return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
20923                              SDValue(FalseC, 0));
20924         }
20925
20926         // Optimize cases that will turn into an LEA instruction.  This requires
20927         // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
20928         if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
20929           uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
20930           if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
20931
20932           bool isFastMultiplier = false;
20933           if (Diff < 10) {
20934             switch ((unsigned char)Diff) {
20935               default: break;
20936               case 1:  // result = add base, cond
20937               case 2:  // result = lea base(    , cond*2)
20938               case 3:  // result = lea base(cond, cond*2)
20939               case 4:  // result = lea base(    , cond*4)
20940               case 5:  // result = lea base(cond, cond*4)
20941               case 8:  // result = lea base(    , cond*8)
20942               case 9:  // result = lea base(cond, cond*8)
20943                 isFastMultiplier = true;
20944                 break;
20945             }
20946           }
20947
20948           if (isFastMultiplier) {
20949             APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
20950             if (NeedsCondInvert) // Invert the condition if needed.
20951               Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
20952                                  DAG.getConstant(1, Cond.getValueType()));
20953
20954             // Zero extend the condition if needed.
20955             Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
20956                                Cond);
20957             // Scale the condition by the difference.
20958             if (Diff != 1)
20959               Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
20960                                  DAG.getConstant(Diff, Cond.getValueType()));
20961
20962             // Add the base if non-zero.
20963             if (FalseC->getAPIntValue() != 0)
20964               Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
20965                                  SDValue(FalseC, 0));
20966             return Cond;
20967           }
20968         }
20969       }
20970   }
20971
20972   // Canonicalize max and min:
20973   // (x > y) ? x : y -> (x >= y) ? x : y
20974   // (x < y) ? x : y -> (x <= y) ? x : y
20975   // This allows use of COND_S / COND_NS (see TranslateX86CC) which eliminates
20976   // the need for an extra compare
20977   // against zero. e.g.
20978   // (x - y) > 0 : (x - y) ? 0 -> (x - y) >= 0 : (x - y) ? 0
20979   // subl   %esi, %edi
20980   // testl  %edi, %edi
20981   // movl   $0, %eax
20982   // cmovgl %edi, %eax
20983   // =>
20984   // xorl   %eax, %eax
20985   // subl   %esi, $edi
20986   // cmovsl %eax, %edi
20987   if (N->getOpcode() == ISD::SELECT && Cond.getOpcode() == ISD::SETCC &&
20988       DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
20989       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
20990     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
20991     switch (CC) {
20992     default: break;
20993     case ISD::SETLT:
20994     case ISD::SETGT: {
20995       ISD::CondCode NewCC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGE;
20996       Cond = DAG.getSetCC(SDLoc(Cond), Cond.getValueType(),
20997                           Cond.getOperand(0), Cond.getOperand(1), NewCC);
20998       return DAG.getNode(ISD::SELECT, DL, VT, Cond, LHS, RHS);
20999     }
21000     }
21001   }
21002
21003   // Early exit check
21004   if (!TLI.isTypeLegal(VT))
21005     return SDValue();
21006
21007   // Match VSELECTs into subs with unsigned saturation.
21008   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC &&
21009       // psubus is available in SSE2 and AVX2 for i8 and i16 vectors.
21010       ((Subtarget->hasSSE2() && (VT == MVT::v16i8 || VT == MVT::v8i16)) ||
21011        (Subtarget->hasAVX2() && (VT == MVT::v32i8 || VT == MVT::v16i16)))) {
21012     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
21013
21014     // Check if one of the arms of the VSELECT is a zero vector. If it's on the
21015     // left side invert the predicate to simplify logic below.
21016     SDValue Other;
21017     if (ISD::isBuildVectorAllZeros(LHS.getNode())) {
21018       Other = RHS;
21019       CC = ISD::getSetCCInverse(CC, true);
21020     } else if (ISD::isBuildVectorAllZeros(RHS.getNode())) {
21021       Other = LHS;
21022     }
21023
21024     if (Other.getNode() && Other->getNumOperands() == 2 &&
21025         DAG.isEqualTo(Other->getOperand(0), Cond.getOperand(0))) {
21026       SDValue OpLHS = Other->getOperand(0), OpRHS = Other->getOperand(1);
21027       SDValue CondRHS = Cond->getOperand(1);
21028
21029       // Look for a general sub with unsigned saturation first.
21030       // x >= y ? x-y : 0 --> subus x, y
21031       // x >  y ? x-y : 0 --> subus x, y
21032       if ((CC == ISD::SETUGE || CC == ISD::SETUGT) &&
21033           Other->getOpcode() == ISD::SUB && DAG.isEqualTo(OpRHS, CondRHS))
21034         return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
21035
21036       if (auto *OpRHSBV = dyn_cast<BuildVectorSDNode>(OpRHS))
21037         if (auto *OpRHSConst = OpRHSBV->getConstantSplatNode()) {
21038           if (auto *CondRHSBV = dyn_cast<BuildVectorSDNode>(CondRHS))
21039             if (auto *CondRHSConst = CondRHSBV->getConstantSplatNode())
21040               // If the RHS is a constant we have to reverse the const
21041               // canonicalization.
21042               // x > C-1 ? x+-C : 0 --> subus x, C
21043               if (CC == ISD::SETUGT && Other->getOpcode() == ISD::ADD &&
21044                   CondRHSConst->getAPIntValue() ==
21045                       (-OpRHSConst->getAPIntValue() - 1))
21046                 return DAG.getNode(
21047                     X86ISD::SUBUS, DL, VT, OpLHS,
21048                     DAG.getConstant(-OpRHSConst->getAPIntValue(), VT));
21049
21050           // Another special case: If C was a sign bit, the sub has been
21051           // canonicalized into a xor.
21052           // FIXME: Would it be better to use computeKnownBits to determine
21053           //        whether it's safe to decanonicalize the xor?
21054           // x s< 0 ? x^C : 0 --> subus x, C
21055           if (CC == ISD::SETLT && Other->getOpcode() == ISD::XOR &&
21056               ISD::isBuildVectorAllZeros(CondRHS.getNode()) &&
21057               OpRHSConst->getAPIntValue().isSignBit())
21058             // Note that we have to rebuild the RHS constant here to ensure we
21059             // don't rely on particular values of undef lanes.
21060             return DAG.getNode(
21061                 X86ISD::SUBUS, DL, VT, OpLHS,
21062                 DAG.getConstant(OpRHSConst->getAPIntValue(), VT));
21063         }
21064     }
21065   }
21066
21067   // Try to match a min/max vector operation.
21068   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC) {
21069     std::pair<unsigned, bool> ret = matchIntegerMINMAX(Cond, VT, LHS, RHS, DAG, Subtarget);
21070     unsigned Opc = ret.first;
21071     bool NeedSplit = ret.second;
21072
21073     if (Opc && NeedSplit) {
21074       unsigned NumElems = VT.getVectorNumElements();
21075       // Extract the LHS vectors
21076       SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, DL);
21077       SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, DL);
21078
21079       // Extract the RHS vectors
21080       SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, DL);
21081       SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, DL);
21082
21083       // Create min/max for each subvector
21084       LHS = DAG.getNode(Opc, DL, LHS1.getValueType(), LHS1, RHS1);
21085       RHS = DAG.getNode(Opc, DL, LHS2.getValueType(), LHS2, RHS2);
21086
21087       // Merge the result
21088       return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LHS, RHS);
21089     } else if (Opc)
21090       return DAG.getNode(Opc, DL, VT, LHS, RHS);
21091   }
21092
21093   // Simplify vector selection if condition value type matches vselect
21094   // operand type
21095   if (N->getOpcode() == ISD::VSELECT && CondVT == VT) {
21096     assert(Cond.getValueType().isVector() &&
21097            "vector select expects a vector selector!");
21098
21099     bool TValIsAllOnes = ISD::isBuildVectorAllOnes(LHS.getNode());
21100     bool FValIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
21101
21102     // Try invert the condition if true value is not all 1s and false value
21103     // is not all 0s.
21104     if (!TValIsAllOnes && !FValIsAllZeros &&
21105         // Check if the selector will be produced by CMPP*/PCMP*
21106         Cond.getOpcode() == ISD::SETCC &&
21107         // Check if SETCC has already been promoted
21108         TLI.getSetCCResultType(*DAG.getContext(), VT) == CondVT) {
21109       bool TValIsAllZeros = ISD::isBuildVectorAllZeros(LHS.getNode());
21110       bool FValIsAllOnes = ISD::isBuildVectorAllOnes(RHS.getNode());
21111
21112       if (TValIsAllZeros || FValIsAllOnes) {
21113         SDValue CC = Cond.getOperand(2);
21114         ISD::CondCode NewCC =
21115           ISD::getSetCCInverse(cast<CondCodeSDNode>(CC)->get(),
21116                                Cond.getOperand(0).getValueType().isInteger());
21117         Cond = DAG.getSetCC(DL, CondVT, Cond.getOperand(0), Cond.getOperand(1), NewCC);
21118         std::swap(LHS, RHS);
21119         TValIsAllOnes = FValIsAllOnes;
21120         FValIsAllZeros = TValIsAllZeros;
21121       }
21122     }
21123
21124     if (TValIsAllOnes || FValIsAllZeros) {
21125       SDValue Ret;
21126
21127       if (TValIsAllOnes && FValIsAllZeros)
21128         Ret = Cond;
21129       else if (TValIsAllOnes)
21130         Ret = DAG.getNode(ISD::OR, DL, CondVT, Cond,
21131                           DAG.getNode(ISD::BITCAST, DL, CondVT, RHS));
21132       else if (FValIsAllZeros)
21133         Ret = DAG.getNode(ISD::AND, DL, CondVT, Cond,
21134                           DAG.getNode(ISD::BITCAST, DL, CondVT, LHS));
21135
21136       return DAG.getNode(ISD::BITCAST, DL, VT, Ret);
21137     }
21138   }
21139
21140   // We should generate an X86ISD::BLENDI from a vselect if its argument
21141   // is a sign_extend_inreg of an any_extend of a BUILD_VECTOR of
21142   // constants. This specific pattern gets generated when we split a
21143   // selector for a 512 bit vector in a machine without AVX512 (but with
21144   // 256-bit vectors), during legalization:
21145   //
21146   // (vselect (sign_extend (any_extend (BUILD_VECTOR)) i1) LHS RHS)
21147   //
21148   // Iff we find this pattern and the build_vectors are built from
21149   // constants, we translate the vselect into a shuffle_vector that we
21150   // know will be matched by LowerVECTOR_SHUFFLEtoBlend.
21151   if ((N->getOpcode() == ISD::VSELECT ||
21152        N->getOpcode() == X86ISD::SHRUNKBLEND) &&
21153       !DCI.isBeforeLegalize()) {
21154     SDValue Shuffle = transformVSELECTtoBlendVECTOR_SHUFFLE(N, DAG, Subtarget);
21155     if (Shuffle.getNode())
21156       return Shuffle;
21157   }
21158
21159   // If this is a *dynamic* select (non-constant condition) and we can match
21160   // this node with one of the variable blend instructions, restructure the
21161   // condition so that the blends can use the high bit of each element and use
21162   // SimplifyDemandedBits to simplify the condition operand.
21163   if (N->getOpcode() == ISD::VSELECT && DCI.isBeforeLegalizeOps() &&
21164       !DCI.isBeforeLegalize() &&
21165       !ISD::isBuildVectorOfConstantSDNodes(Cond.getNode())) {
21166     unsigned BitWidth = Cond.getValueType().getScalarType().getSizeInBits();
21167
21168     // Don't optimize vector selects that map to mask-registers.
21169     if (BitWidth == 1)
21170       return SDValue();
21171
21172     // We can only handle the cases where VSELECT is directly legal on the
21173     // subtarget. We custom lower VSELECT nodes with constant conditions and
21174     // this makes it hard to see whether a dynamic VSELECT will correctly
21175     // lower, so we both check the operation's status and explicitly handle the
21176     // cases where a *dynamic* blend will fail even though a constant-condition
21177     // blend could be custom lowered.
21178     // FIXME: We should find a better way to handle this class of problems.
21179     // Potentially, we should combine constant-condition vselect nodes
21180     // pre-legalization into shuffles and not mark as many types as custom
21181     // lowered.
21182     if (!TLI.isOperationLegalOrCustom(ISD::VSELECT, VT))
21183       return SDValue();
21184     // FIXME: We don't support i16-element blends currently. We could and
21185     // should support them by making *all* the bits in the condition be set
21186     // rather than just the high bit and using an i8-element blend.
21187     if (VT.getScalarType() == MVT::i16)
21188       return SDValue();
21189     // Dynamic blending was only available from SSE4.1 onward.
21190     if (VT.getSizeInBits() == 128 && !Subtarget->hasSSE41())
21191       return SDValue();
21192     // Byte blends are only available in AVX2
21193     if (VT.getSizeInBits() == 256 && VT.getScalarType() == MVT::i8 &&
21194         !Subtarget->hasAVX2())
21195       return SDValue();
21196
21197     assert(BitWidth >= 8 && BitWidth <= 64 && "Invalid mask size");
21198     APInt DemandedMask = APInt::getHighBitsSet(BitWidth, 1);
21199
21200     APInt KnownZero, KnownOne;
21201     TargetLowering::TargetLoweringOpt TLO(DAG, DCI.isBeforeLegalize(),
21202                                           DCI.isBeforeLegalizeOps());
21203     if (TLO.ShrinkDemandedConstant(Cond, DemandedMask) ||
21204         TLI.SimplifyDemandedBits(Cond, DemandedMask, KnownZero, KnownOne,
21205                                  TLO)) {
21206       // If we changed the computation somewhere in the DAG, this change
21207       // will affect all users of Cond.
21208       // Make sure it is fine and update all the nodes so that we do not
21209       // use the generic VSELECT anymore. Otherwise, we may perform
21210       // wrong optimizations as we messed up with the actual expectation
21211       // for the vector boolean values.
21212       if (Cond != TLO.Old) {
21213         // Check all uses of that condition operand to check whether it will be
21214         // consumed by non-BLEND instructions, which may depend on all bits are
21215         // set properly.
21216         for (SDNode::use_iterator I = Cond->use_begin(), E = Cond->use_end();
21217              I != E; ++I)
21218           if (I->getOpcode() != ISD::VSELECT)
21219             // TODO: Add other opcodes eventually lowered into BLEND.
21220             return SDValue();
21221
21222         // Update all the users of the condition, before committing the change,
21223         // so that the VSELECT optimizations that expect the correct vector
21224         // boolean value will not be triggered.
21225         for (SDNode::use_iterator I = Cond->use_begin(), E = Cond->use_end();
21226              I != E; ++I)
21227           DAG.ReplaceAllUsesOfValueWith(
21228               SDValue(*I, 0),
21229               DAG.getNode(X86ISD::SHRUNKBLEND, SDLoc(*I), I->getValueType(0),
21230                           Cond, I->getOperand(1), I->getOperand(2)));
21231         DCI.CommitTargetLoweringOpt(TLO);
21232         return SDValue();
21233       }
21234       // At this point, only Cond is changed. Change the condition
21235       // just for N to keep the opportunity to optimize all other
21236       // users their own way.
21237       DAG.ReplaceAllUsesOfValueWith(
21238           SDValue(N, 0),
21239           DAG.getNode(X86ISD::SHRUNKBLEND, SDLoc(N), N->getValueType(0),
21240                       TLO.New, N->getOperand(1), N->getOperand(2)));
21241       return SDValue();
21242     }
21243   }
21244
21245   return SDValue();
21246 }
21247
21248 // Check whether a boolean test is testing a boolean value generated by
21249 // X86ISD::SETCC. If so, return the operand of that SETCC and proper condition
21250 // code.
21251 //
21252 // Simplify the following patterns:
21253 // (Op (CMP (SETCC Cond EFLAGS) 1) EQ) or
21254 // (Op (CMP (SETCC Cond EFLAGS) 0) NEQ)
21255 // to (Op EFLAGS Cond)
21256 //
21257 // (Op (CMP (SETCC Cond EFLAGS) 0) EQ) or
21258 // (Op (CMP (SETCC Cond EFLAGS) 1) NEQ)
21259 // to (Op EFLAGS !Cond)
21260 //
21261 // where Op could be BRCOND or CMOV.
21262 //
21263 static SDValue checkBoolTestSetCCCombine(SDValue Cmp, X86::CondCode &CC) {
21264   // Quit if not CMP and SUB with its value result used.
21265   if (Cmp.getOpcode() != X86ISD::CMP &&
21266       (Cmp.getOpcode() != X86ISD::SUB || Cmp.getNode()->hasAnyUseOfValue(0)))
21267       return SDValue();
21268
21269   // Quit if not used as a boolean value.
21270   if (CC != X86::COND_E && CC != X86::COND_NE)
21271     return SDValue();
21272
21273   // Check CMP operands. One of them should be 0 or 1 and the other should be
21274   // an SetCC or extended from it.
21275   SDValue Op1 = Cmp.getOperand(0);
21276   SDValue Op2 = Cmp.getOperand(1);
21277
21278   SDValue SetCC;
21279   const ConstantSDNode* C = nullptr;
21280   bool needOppositeCond = (CC == X86::COND_E);
21281   bool checkAgainstTrue = false; // Is it a comparison against 1?
21282
21283   if ((C = dyn_cast<ConstantSDNode>(Op1)))
21284     SetCC = Op2;
21285   else if ((C = dyn_cast<ConstantSDNode>(Op2)))
21286     SetCC = Op1;
21287   else // Quit if all operands are not constants.
21288     return SDValue();
21289
21290   if (C->getZExtValue() == 1) {
21291     needOppositeCond = !needOppositeCond;
21292     checkAgainstTrue = true;
21293   } else if (C->getZExtValue() != 0)
21294     // Quit if the constant is neither 0 or 1.
21295     return SDValue();
21296
21297   bool truncatedToBoolWithAnd = false;
21298   // Skip (zext $x), (trunc $x), or (and $x, 1) node.
21299   while (SetCC.getOpcode() == ISD::ZERO_EXTEND ||
21300          SetCC.getOpcode() == ISD::TRUNCATE ||
21301          SetCC.getOpcode() == ISD::AND) {
21302     if (SetCC.getOpcode() == ISD::AND) {
21303       int OpIdx = -1;
21304       ConstantSDNode *CS;
21305       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(0))) &&
21306           CS->getZExtValue() == 1)
21307         OpIdx = 1;
21308       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(1))) &&
21309           CS->getZExtValue() == 1)
21310         OpIdx = 0;
21311       if (OpIdx == -1)
21312         break;
21313       SetCC = SetCC.getOperand(OpIdx);
21314       truncatedToBoolWithAnd = true;
21315     } else
21316       SetCC = SetCC.getOperand(0);
21317   }
21318
21319   switch (SetCC.getOpcode()) {
21320   case X86ISD::SETCC_CARRY:
21321     // Since SETCC_CARRY gives output based on R = CF ? ~0 : 0, it's unsafe to
21322     // simplify it if the result of SETCC_CARRY is not canonicalized to 0 or 1,
21323     // i.e. it's a comparison against true but the result of SETCC_CARRY is not
21324     // truncated to i1 using 'and'.
21325     if (checkAgainstTrue && !truncatedToBoolWithAnd)
21326       break;
21327     assert(X86::CondCode(SetCC.getConstantOperandVal(0)) == X86::COND_B &&
21328            "Invalid use of SETCC_CARRY!");
21329     // FALL THROUGH
21330   case X86ISD::SETCC:
21331     // Set the condition code or opposite one if necessary.
21332     CC = X86::CondCode(SetCC.getConstantOperandVal(0));
21333     if (needOppositeCond)
21334       CC = X86::GetOppositeBranchCondition(CC);
21335     return SetCC.getOperand(1);
21336   case X86ISD::CMOV: {
21337     // Check whether false/true value has canonical one, i.e. 0 or 1.
21338     ConstantSDNode *FVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(0));
21339     ConstantSDNode *TVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(1));
21340     // Quit if true value is not a constant.
21341     if (!TVal)
21342       return SDValue();
21343     // Quit if false value is not a constant.
21344     if (!FVal) {
21345       SDValue Op = SetCC.getOperand(0);
21346       // Skip 'zext' or 'trunc' node.
21347       if (Op.getOpcode() == ISD::ZERO_EXTEND ||
21348           Op.getOpcode() == ISD::TRUNCATE)
21349         Op = Op.getOperand(0);
21350       // A special case for rdrand/rdseed, where 0 is set if false cond is
21351       // found.
21352       if ((Op.getOpcode() != X86ISD::RDRAND &&
21353            Op.getOpcode() != X86ISD::RDSEED) || Op.getResNo() != 0)
21354         return SDValue();
21355     }
21356     // Quit if false value is not the constant 0 or 1.
21357     bool FValIsFalse = true;
21358     if (FVal && FVal->getZExtValue() != 0) {
21359       if (FVal->getZExtValue() != 1)
21360         return SDValue();
21361       // If FVal is 1, opposite cond is needed.
21362       needOppositeCond = !needOppositeCond;
21363       FValIsFalse = false;
21364     }
21365     // Quit if TVal is not the constant opposite of FVal.
21366     if (FValIsFalse && TVal->getZExtValue() != 1)
21367       return SDValue();
21368     if (!FValIsFalse && TVal->getZExtValue() != 0)
21369       return SDValue();
21370     CC = X86::CondCode(SetCC.getConstantOperandVal(2));
21371     if (needOppositeCond)
21372       CC = X86::GetOppositeBranchCondition(CC);
21373     return SetCC.getOperand(3);
21374   }
21375   }
21376
21377   return SDValue();
21378 }
21379
21380 /// Check whether Cond is an AND/OR of SETCCs off of the same EFLAGS.
21381 /// Match:
21382 ///   (X86or (X86setcc) (X86setcc))
21383 ///   (X86cmp (and (X86setcc) (X86setcc)), 0)
21384 static bool checkBoolTestAndOrSetCCCombine(SDValue Cond, X86::CondCode &CC0,
21385                                            X86::CondCode &CC1, SDValue &Flags,
21386                                            bool &isAnd) {
21387   if (Cond->getOpcode() == X86ISD::CMP) {
21388     ConstantSDNode *CondOp1C = dyn_cast<ConstantSDNode>(Cond->getOperand(1));
21389     if (!CondOp1C || !CondOp1C->isNullValue())
21390       return false;
21391
21392     Cond = Cond->getOperand(0);
21393   }
21394
21395   isAnd = false;
21396
21397   SDValue SetCC0, SetCC1;
21398   switch (Cond->getOpcode()) {
21399   default: return false;
21400   case ISD::AND:
21401   case X86ISD::AND:
21402     isAnd = true;
21403     // fallthru
21404   case ISD::OR:
21405   case X86ISD::OR:
21406     SetCC0 = Cond->getOperand(0);
21407     SetCC1 = Cond->getOperand(1);
21408     break;
21409   };
21410
21411   // Make sure we have SETCC nodes, using the same flags value.
21412   if (SetCC0.getOpcode() != X86ISD::SETCC ||
21413       SetCC1.getOpcode() != X86ISD::SETCC ||
21414       SetCC0->getOperand(1) != SetCC1->getOperand(1))
21415     return false;
21416
21417   CC0 = (X86::CondCode)SetCC0->getConstantOperandVal(0);
21418   CC1 = (X86::CondCode)SetCC1->getConstantOperandVal(0);
21419   Flags = SetCC0->getOperand(1);
21420   return true;
21421 }
21422
21423 /// Optimize X86ISD::CMOV [LHS, RHS, CONDCODE (e.g. X86::COND_NE), CONDVAL]
21424 static SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG,
21425                                   TargetLowering::DAGCombinerInfo &DCI,
21426                                   const X86Subtarget *Subtarget) {
21427   SDLoc DL(N);
21428
21429   // If the flag operand isn't dead, don't touch this CMOV.
21430   if (N->getNumValues() == 2 && !SDValue(N, 1).use_empty())
21431     return SDValue();
21432
21433   SDValue FalseOp = N->getOperand(0);
21434   SDValue TrueOp = N->getOperand(1);
21435   X86::CondCode CC = (X86::CondCode)N->getConstantOperandVal(2);
21436   SDValue Cond = N->getOperand(3);
21437
21438   if (CC == X86::COND_E || CC == X86::COND_NE) {
21439     switch (Cond.getOpcode()) {
21440     default: break;
21441     case X86ISD::BSR:
21442     case X86ISD::BSF:
21443       // If operand of BSR / BSF are proven never zero, then ZF cannot be set.
21444       if (DAG.isKnownNeverZero(Cond.getOperand(0)))
21445         return (CC == X86::COND_E) ? FalseOp : TrueOp;
21446     }
21447   }
21448
21449   SDValue Flags;
21450
21451   Flags = checkBoolTestSetCCCombine(Cond, CC);
21452   if (Flags.getNode() &&
21453       // Extra check as FCMOV only supports a subset of X86 cond.
21454       (FalseOp.getValueType() != MVT::f80 || hasFPCMov(CC))) {
21455     SDValue Ops[] = { FalseOp, TrueOp,
21456                       DAG.getConstant(CC, MVT::i8), Flags };
21457     return DAG.getNode(X86ISD::CMOV, DL, N->getVTList(), Ops);
21458   }
21459
21460   // If this is a select between two integer constants, try to do some
21461   // optimizations.  Note that the operands are ordered the opposite of SELECT
21462   // operands.
21463   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(TrueOp)) {
21464     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(FalseOp)) {
21465       // Canonicalize the TrueC/FalseC values so that TrueC (the true value) is
21466       // larger than FalseC (the false value).
21467       if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue())) {
21468         CC = X86::GetOppositeBranchCondition(CC);
21469         std::swap(TrueC, FalseC);
21470         std::swap(TrueOp, FalseOp);
21471       }
21472
21473       // Optimize C ? 8 : 0 -> zext(setcc(C)) << 3.  Likewise for any pow2/0.
21474       // This is efficient for any integer data type (including i8/i16) and
21475       // shift amount.
21476       if (FalseC->getAPIntValue() == 0 && TrueC->getAPIntValue().isPowerOf2()) {
21477         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
21478                            DAG.getConstant(CC, MVT::i8), Cond);
21479
21480         // Zero extend the condition if needed.
21481         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
21482
21483         unsigned ShAmt = TrueC->getAPIntValue().logBase2();
21484         Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
21485                            DAG.getConstant(ShAmt, MVT::i8));
21486         if (N->getNumValues() == 2)  // Dead flag value?
21487           return DCI.CombineTo(N, Cond, SDValue());
21488         return Cond;
21489       }
21490
21491       // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.  This is efficient
21492       // for any integer data type, including i8/i16.
21493       if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
21494         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
21495                            DAG.getConstant(CC, MVT::i8), Cond);
21496
21497         // Zero extend the condition if needed.
21498         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
21499                            FalseC->getValueType(0), Cond);
21500         Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
21501                            SDValue(FalseC, 0));
21502
21503         if (N->getNumValues() == 2)  // Dead flag value?
21504           return DCI.CombineTo(N, Cond, SDValue());
21505         return Cond;
21506       }
21507
21508       // Optimize cases that will turn into an LEA instruction.  This requires
21509       // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
21510       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
21511         uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
21512         if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
21513
21514         bool isFastMultiplier = false;
21515         if (Diff < 10) {
21516           switch ((unsigned char)Diff) {
21517           default: break;
21518           case 1:  // result = add base, cond
21519           case 2:  // result = lea base(    , cond*2)
21520           case 3:  // result = lea base(cond, cond*2)
21521           case 4:  // result = lea base(    , cond*4)
21522           case 5:  // result = lea base(cond, cond*4)
21523           case 8:  // result = lea base(    , cond*8)
21524           case 9:  // result = lea base(cond, cond*8)
21525             isFastMultiplier = true;
21526             break;
21527           }
21528         }
21529
21530         if (isFastMultiplier) {
21531           APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
21532           Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
21533                              DAG.getConstant(CC, MVT::i8), Cond);
21534           // Zero extend the condition if needed.
21535           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
21536                              Cond);
21537           // Scale the condition by the difference.
21538           if (Diff != 1)
21539             Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
21540                                DAG.getConstant(Diff, Cond.getValueType()));
21541
21542           // Add the base if non-zero.
21543           if (FalseC->getAPIntValue() != 0)
21544             Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
21545                                SDValue(FalseC, 0));
21546           if (N->getNumValues() == 2)  // Dead flag value?
21547             return DCI.CombineTo(N, Cond, SDValue());
21548           return Cond;
21549         }
21550       }
21551     }
21552   }
21553
21554   // Handle these cases:
21555   //   (select (x != c), e, c) -> select (x != c), e, x),
21556   //   (select (x == c), c, e) -> select (x == c), x, e)
21557   // where the c is an integer constant, and the "select" is the combination
21558   // of CMOV and CMP.
21559   //
21560   // The rationale for this change is that the conditional-move from a constant
21561   // needs two instructions, however, conditional-move from a register needs
21562   // only one instruction.
21563   //
21564   // CAVEAT: By replacing a constant with a symbolic value, it may obscure
21565   //  some instruction-combining opportunities. This opt needs to be
21566   //  postponed as late as possible.
21567   //
21568   if (!DCI.isBeforeLegalize() && !DCI.isBeforeLegalizeOps()) {
21569     // the DCI.xxxx conditions are provided to postpone the optimization as
21570     // late as possible.
21571
21572     ConstantSDNode *CmpAgainst = nullptr;
21573     if ((Cond.getOpcode() == X86ISD::CMP || Cond.getOpcode() == X86ISD::SUB) &&
21574         (CmpAgainst = dyn_cast<ConstantSDNode>(Cond.getOperand(1))) &&
21575         !isa<ConstantSDNode>(Cond.getOperand(0))) {
21576
21577       if (CC == X86::COND_NE &&
21578           CmpAgainst == dyn_cast<ConstantSDNode>(FalseOp)) {
21579         CC = X86::GetOppositeBranchCondition(CC);
21580         std::swap(TrueOp, FalseOp);
21581       }
21582
21583       if (CC == X86::COND_E &&
21584           CmpAgainst == dyn_cast<ConstantSDNode>(TrueOp)) {
21585         SDValue Ops[] = { FalseOp, Cond.getOperand(0),
21586                           DAG.getConstant(CC, MVT::i8), Cond };
21587         return DAG.getNode(X86ISD::CMOV, DL, N->getVTList (), Ops);
21588       }
21589     }
21590   }
21591
21592   // Fold and/or of setcc's to double CMOV:
21593   //   (CMOV F, T, ((cc1 | cc2) != 0)) -> (CMOV (CMOV F, T, cc1), T, cc2)
21594   //   (CMOV F, T, ((cc1 & cc2) != 0)) -> (CMOV (CMOV T, F, !cc1), F, !cc2)
21595   //
21596   // This combine lets us generate:
21597   //   cmovcc1 (jcc1 if we don't have CMOV)
21598   //   cmovcc2 (same)
21599   // instead of:
21600   //   setcc1
21601   //   setcc2
21602   //   and/or
21603   //   cmovne (jne if we don't have CMOV)
21604   // When we can't use the CMOV instruction, it might increase branch
21605   // mispredicts.
21606   // When we can use CMOV, or when there is no mispredict, this improves
21607   // throughput and reduces register pressure.
21608   //
21609   if (CC == X86::COND_NE) {
21610     SDValue Flags;
21611     X86::CondCode CC0, CC1;
21612     bool isAndSetCC;
21613     if (checkBoolTestAndOrSetCCCombine(Cond, CC0, CC1, Flags, isAndSetCC)) {
21614       if (isAndSetCC) {
21615         std::swap(FalseOp, TrueOp);
21616         CC0 = X86::GetOppositeBranchCondition(CC0);
21617         CC1 = X86::GetOppositeBranchCondition(CC1);
21618       }
21619
21620       SDValue LOps[] = {FalseOp, TrueOp, DAG.getConstant(CC0, MVT::i8),
21621         Flags};
21622       SDValue LCMOV = DAG.getNode(X86ISD::CMOV, DL, N->getVTList(), LOps);
21623       SDValue Ops[] = {LCMOV, TrueOp, DAG.getConstant(CC1, MVT::i8), Flags};
21624       SDValue CMOV = DAG.getNode(X86ISD::CMOV, DL, N->getVTList(), Ops);
21625       DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), SDValue(CMOV.getNode(), 1));
21626       return CMOV;
21627     }
21628   }
21629
21630   return SDValue();
21631 }
21632
21633 static SDValue PerformINTRINSIC_WO_CHAINCombine(SDNode *N, SelectionDAG &DAG,
21634                                                 const X86Subtarget *Subtarget) {
21635   unsigned IntNo = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
21636   switch (IntNo) {
21637   default: return SDValue();
21638   // SSE/AVX/AVX2 blend intrinsics.
21639   case Intrinsic::x86_avx2_pblendvb:
21640     // Don't try to simplify this intrinsic if we don't have AVX2.
21641     if (!Subtarget->hasAVX2())
21642       return SDValue();
21643     // FALL-THROUGH
21644   case Intrinsic::x86_avx_blendv_pd_256:
21645   case Intrinsic::x86_avx_blendv_ps_256:
21646     // Don't try to simplify this intrinsic if we don't have AVX.
21647     if (!Subtarget->hasAVX())
21648       return SDValue();
21649     // FALL-THROUGH
21650   case Intrinsic::x86_sse41_blendvps:
21651   case Intrinsic::x86_sse41_blendvpd:
21652   case Intrinsic::x86_sse41_pblendvb: {
21653     SDValue Op0 = N->getOperand(1);
21654     SDValue Op1 = N->getOperand(2);
21655     SDValue Mask = N->getOperand(3);
21656
21657     // Don't try to simplify this intrinsic if we don't have SSE4.1.
21658     if (!Subtarget->hasSSE41())
21659       return SDValue();
21660
21661     // fold (blend A, A, Mask) -> A
21662     if (Op0 == Op1)
21663       return Op0;
21664     // fold (blend A, B, allZeros) -> A
21665     if (ISD::isBuildVectorAllZeros(Mask.getNode()))
21666       return Op0;
21667     // fold (blend A, B, allOnes) -> B
21668     if (ISD::isBuildVectorAllOnes(Mask.getNode()))
21669       return Op1;
21670
21671     // Simplify the case where the mask is a constant i32 value.
21672     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Mask)) {
21673       if (C->isNullValue())
21674         return Op0;
21675       if (C->isAllOnesValue())
21676         return Op1;
21677     }
21678
21679     return SDValue();
21680   }
21681
21682   // Packed SSE2/AVX2 arithmetic shift immediate intrinsics.
21683   case Intrinsic::x86_sse2_psrai_w:
21684   case Intrinsic::x86_sse2_psrai_d:
21685   case Intrinsic::x86_avx2_psrai_w:
21686   case Intrinsic::x86_avx2_psrai_d:
21687   case Intrinsic::x86_sse2_psra_w:
21688   case Intrinsic::x86_sse2_psra_d:
21689   case Intrinsic::x86_avx2_psra_w:
21690   case Intrinsic::x86_avx2_psra_d: {
21691     SDValue Op0 = N->getOperand(1);
21692     SDValue Op1 = N->getOperand(2);
21693     EVT VT = Op0.getValueType();
21694     assert(VT.isVector() && "Expected a vector type!");
21695
21696     if (isa<BuildVectorSDNode>(Op1))
21697       Op1 = Op1.getOperand(0);
21698
21699     if (!isa<ConstantSDNode>(Op1))
21700       return SDValue();
21701
21702     EVT SVT = VT.getVectorElementType();
21703     unsigned SVTBits = SVT.getSizeInBits();
21704
21705     ConstantSDNode *CND = cast<ConstantSDNode>(Op1);
21706     const APInt &C = APInt(SVTBits, CND->getAPIntValue().getZExtValue());
21707     uint64_t ShAmt = C.getZExtValue();
21708
21709     // Don't try to convert this shift into a ISD::SRA if the shift
21710     // count is bigger than or equal to the element size.
21711     if (ShAmt >= SVTBits)
21712       return SDValue();
21713
21714     // Trivial case: if the shift count is zero, then fold this
21715     // into the first operand.
21716     if (ShAmt == 0)
21717       return Op0;
21718
21719     // Replace this packed shift intrinsic with a target independent
21720     // shift dag node.
21721     SDValue Splat = DAG.getConstant(C, VT);
21722     return DAG.getNode(ISD::SRA, SDLoc(N), VT, Op0, Splat);
21723   }
21724   }
21725 }
21726
21727 /// PerformMulCombine - Optimize a single multiply with constant into two
21728 /// in order to implement it with two cheaper instructions, e.g.
21729 /// LEA + SHL, LEA + LEA.
21730 static SDValue PerformMulCombine(SDNode *N, SelectionDAG &DAG,
21731                                  TargetLowering::DAGCombinerInfo &DCI) {
21732   if (DCI.isBeforeLegalize() || DCI.isCalledByLegalizer())
21733     return SDValue();
21734
21735   EVT VT = N->getValueType(0);
21736   if (VT != MVT::i64 && VT != MVT::i32)
21737     return SDValue();
21738
21739   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1));
21740   if (!C)
21741     return SDValue();
21742   uint64_t MulAmt = C->getZExtValue();
21743   if (isPowerOf2_64(MulAmt) || MulAmt == 3 || MulAmt == 5 || MulAmt == 9)
21744     return SDValue();
21745
21746   uint64_t MulAmt1 = 0;
21747   uint64_t MulAmt2 = 0;
21748   if ((MulAmt % 9) == 0) {
21749     MulAmt1 = 9;
21750     MulAmt2 = MulAmt / 9;
21751   } else if ((MulAmt % 5) == 0) {
21752     MulAmt1 = 5;
21753     MulAmt2 = MulAmt / 5;
21754   } else if ((MulAmt % 3) == 0) {
21755     MulAmt1 = 3;
21756     MulAmt2 = MulAmt / 3;
21757   }
21758   if (MulAmt2 &&
21759       (isPowerOf2_64(MulAmt2) || MulAmt2 == 3 || MulAmt2 == 5 || MulAmt2 == 9)){
21760     SDLoc DL(N);
21761
21762     if (isPowerOf2_64(MulAmt2) &&
21763         !(N->hasOneUse() && N->use_begin()->getOpcode() == ISD::ADD))
21764       // If second multiplifer is pow2, issue it first. We want the multiply by
21765       // 3, 5, or 9 to be folded into the addressing mode unless the lone use
21766       // is an add.
21767       std::swap(MulAmt1, MulAmt2);
21768
21769     SDValue NewMul;
21770     if (isPowerOf2_64(MulAmt1))
21771       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
21772                            DAG.getConstant(Log2_64(MulAmt1), MVT::i8));
21773     else
21774       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
21775                            DAG.getConstant(MulAmt1, VT));
21776
21777     if (isPowerOf2_64(MulAmt2))
21778       NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
21779                            DAG.getConstant(Log2_64(MulAmt2), MVT::i8));
21780     else
21781       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
21782                            DAG.getConstant(MulAmt2, VT));
21783
21784     // Do not add new nodes to DAG combiner worklist.
21785     DCI.CombineTo(N, NewMul, false);
21786   }
21787   return SDValue();
21788 }
21789
21790 static SDValue PerformSHLCombine(SDNode *N, SelectionDAG &DAG) {
21791   SDValue N0 = N->getOperand(0);
21792   SDValue N1 = N->getOperand(1);
21793   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
21794   EVT VT = N0.getValueType();
21795
21796   // fold (shl (and (setcc_c), c1), c2) -> (and setcc_c, (c1 << c2))
21797   // since the result of setcc_c is all zero's or all ones.
21798   if (VT.isInteger() && !VT.isVector() &&
21799       N1C && N0.getOpcode() == ISD::AND &&
21800       N0.getOperand(1).getOpcode() == ISD::Constant) {
21801     SDValue N00 = N0.getOperand(0);
21802     if (N00.getOpcode() == X86ISD::SETCC_CARRY ||
21803         ((N00.getOpcode() == ISD::ANY_EXTEND ||
21804           N00.getOpcode() == ISD::ZERO_EXTEND) &&
21805          N00.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY)) {
21806       APInt Mask = cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue();
21807       APInt ShAmt = N1C->getAPIntValue();
21808       Mask = Mask.shl(ShAmt);
21809       if (Mask != 0)
21810         return DAG.getNode(ISD::AND, SDLoc(N), VT,
21811                            N00, DAG.getConstant(Mask, VT));
21812     }
21813   }
21814
21815   // Hardware support for vector shifts is sparse which makes us scalarize the
21816   // vector operations in many cases. Also, on sandybridge ADD is faster than
21817   // shl.
21818   // (shl V, 1) -> add V,V
21819   if (auto *N1BV = dyn_cast<BuildVectorSDNode>(N1))
21820     if (auto *N1SplatC = N1BV->getConstantSplatNode()) {
21821       assert(N0.getValueType().isVector() && "Invalid vector shift type");
21822       // We shift all of the values by one. In many cases we do not have
21823       // hardware support for this operation. This is better expressed as an ADD
21824       // of two values.
21825       if (N1SplatC->getZExtValue() == 1)
21826         return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N0);
21827     }
21828
21829   return SDValue();
21830 }
21831
21832 /// \brief Returns a vector of 0s if the node in input is a vector logical
21833 /// shift by a constant amount which is known to be bigger than or equal
21834 /// to the vector element size in bits.
21835 static SDValue performShiftToAllZeros(SDNode *N, SelectionDAG &DAG,
21836                                       const X86Subtarget *Subtarget) {
21837   EVT VT = N->getValueType(0);
21838
21839   if (VT != MVT::v2i64 && VT != MVT::v4i32 && VT != MVT::v8i16 &&
21840       (!Subtarget->hasInt256() ||
21841        (VT != MVT::v4i64 && VT != MVT::v8i32 && VT != MVT::v16i16)))
21842     return SDValue();
21843
21844   SDValue Amt = N->getOperand(1);
21845   SDLoc DL(N);
21846   if (auto *AmtBV = dyn_cast<BuildVectorSDNode>(Amt))
21847     if (auto *AmtSplat = AmtBV->getConstantSplatNode()) {
21848       APInt ShiftAmt = AmtSplat->getAPIntValue();
21849       unsigned MaxAmount = VT.getVectorElementType().getSizeInBits();
21850
21851       // SSE2/AVX2 logical shifts always return a vector of 0s
21852       // if the shift amount is bigger than or equal to
21853       // the element size. The constant shift amount will be
21854       // encoded as a 8-bit immediate.
21855       if (ShiftAmt.trunc(8).uge(MaxAmount))
21856         return getZeroVector(VT, Subtarget, DAG, DL);
21857     }
21858
21859   return SDValue();
21860 }
21861
21862 /// PerformShiftCombine - Combine shifts.
21863 static SDValue PerformShiftCombine(SDNode* N, SelectionDAG &DAG,
21864                                    TargetLowering::DAGCombinerInfo &DCI,
21865                                    const X86Subtarget *Subtarget) {
21866   if (N->getOpcode() == ISD::SHL) {
21867     SDValue V = PerformSHLCombine(N, DAG);
21868     if (V.getNode()) return V;
21869   }
21870
21871   if (N->getOpcode() != ISD::SRA) {
21872     // Try to fold this logical shift into a zero vector.
21873     SDValue V = performShiftToAllZeros(N, DAG, Subtarget);
21874     if (V.getNode()) return V;
21875   }
21876
21877   return SDValue();
21878 }
21879
21880 // CMPEQCombine - Recognize the distinctive  (AND (setcc ...) (setcc ..))
21881 // where both setccs reference the same FP CMP, and rewrite for CMPEQSS
21882 // and friends.  Likewise for OR -> CMPNEQSS.
21883 static SDValue CMPEQCombine(SDNode *N, SelectionDAG &DAG,
21884                             TargetLowering::DAGCombinerInfo &DCI,
21885                             const X86Subtarget *Subtarget) {
21886   unsigned opcode;
21887
21888   // SSE1 supports CMP{eq|ne}SS, and SSE2 added CMP{eq|ne}SD, but
21889   // we're requiring SSE2 for both.
21890   if (Subtarget->hasSSE2() && isAndOrOfSetCCs(SDValue(N, 0U), opcode)) {
21891     SDValue N0 = N->getOperand(0);
21892     SDValue N1 = N->getOperand(1);
21893     SDValue CMP0 = N0->getOperand(1);
21894     SDValue CMP1 = N1->getOperand(1);
21895     SDLoc DL(N);
21896
21897     // The SETCCs should both refer to the same CMP.
21898     if (CMP0.getOpcode() != X86ISD::CMP || CMP0 != CMP1)
21899       return SDValue();
21900
21901     SDValue CMP00 = CMP0->getOperand(0);
21902     SDValue CMP01 = CMP0->getOperand(1);
21903     EVT     VT    = CMP00.getValueType();
21904
21905     if (VT == MVT::f32 || VT == MVT::f64) {
21906       bool ExpectingFlags = false;
21907       // Check for any users that want flags:
21908       for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end();
21909            !ExpectingFlags && UI != UE; ++UI)
21910         switch (UI->getOpcode()) {
21911         default:
21912         case ISD::BR_CC:
21913         case ISD::BRCOND:
21914         case ISD::SELECT:
21915           ExpectingFlags = true;
21916           break;
21917         case ISD::CopyToReg:
21918         case ISD::SIGN_EXTEND:
21919         case ISD::ZERO_EXTEND:
21920         case ISD::ANY_EXTEND:
21921           break;
21922         }
21923
21924       if (!ExpectingFlags) {
21925         enum X86::CondCode cc0 = (enum X86::CondCode)N0.getConstantOperandVal(0);
21926         enum X86::CondCode cc1 = (enum X86::CondCode)N1.getConstantOperandVal(0);
21927
21928         if (cc1 == X86::COND_E || cc1 == X86::COND_NE) {
21929           X86::CondCode tmp = cc0;
21930           cc0 = cc1;
21931           cc1 = tmp;
21932         }
21933
21934         if ((cc0 == X86::COND_E  && cc1 == X86::COND_NP) ||
21935             (cc0 == X86::COND_NE && cc1 == X86::COND_P)) {
21936           // FIXME: need symbolic constants for these magic numbers.
21937           // See X86ATTInstPrinter.cpp:printSSECC().
21938           unsigned x86cc = (cc0 == X86::COND_E) ? 0 : 4;
21939           if (Subtarget->hasAVX512()) {
21940             SDValue FSetCC = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CMP00,
21941                                          CMP01, DAG.getConstant(x86cc, MVT::i8));
21942             if (N->getValueType(0) != MVT::i1)
21943               return DAG.getNode(ISD::ZERO_EXTEND, DL, N->getValueType(0),
21944                                  FSetCC);
21945             return FSetCC;
21946           }
21947           SDValue OnesOrZeroesF = DAG.getNode(X86ISD::FSETCC, DL,
21948                                               CMP00.getValueType(), CMP00, CMP01,
21949                                               DAG.getConstant(x86cc, MVT::i8));
21950
21951           bool is64BitFP = (CMP00.getValueType() == MVT::f64);
21952           MVT IntVT = is64BitFP ? MVT::i64 : MVT::i32;
21953
21954           if (is64BitFP && !Subtarget->is64Bit()) {
21955             // On a 32-bit target, we cannot bitcast the 64-bit float to a
21956             // 64-bit integer, since that's not a legal type. Since
21957             // OnesOrZeroesF is all ones of all zeroes, we don't need all the
21958             // bits, but can do this little dance to extract the lowest 32 bits
21959             // and work with those going forward.
21960             SDValue Vector64 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64,
21961                                            OnesOrZeroesF);
21962             SDValue Vector32 = DAG.getNode(ISD::BITCAST, DL, MVT::v4f32,
21963                                            Vector64);
21964             OnesOrZeroesF = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32,
21965                                         Vector32, DAG.getIntPtrConstant(0));
21966             IntVT = MVT::i32;
21967           }
21968
21969           SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, IntVT, OnesOrZeroesF);
21970           SDValue ANDed = DAG.getNode(ISD::AND, DL, IntVT, OnesOrZeroesI,
21971                                       DAG.getConstant(1, IntVT));
21972           SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
21973           return OneBitOfTruth;
21974         }
21975       }
21976     }
21977   }
21978   return SDValue();
21979 }
21980
21981 /// CanFoldXORWithAllOnes - Test whether the XOR operand is a AllOnes vector
21982 /// so it can be folded inside ANDNP.
21983 static bool CanFoldXORWithAllOnes(const SDNode *N) {
21984   EVT VT = N->getValueType(0);
21985
21986   // Match direct AllOnes for 128 and 256-bit vectors
21987   if (ISD::isBuildVectorAllOnes(N))
21988     return true;
21989
21990   // Look through a bit convert.
21991   if (N->getOpcode() == ISD::BITCAST)
21992     N = N->getOperand(0).getNode();
21993
21994   // Sometimes the operand may come from a insert_subvector building a 256-bit
21995   // allones vector
21996   if (VT.is256BitVector() &&
21997       N->getOpcode() == ISD::INSERT_SUBVECTOR) {
21998     SDValue V1 = N->getOperand(0);
21999     SDValue V2 = N->getOperand(1);
22000
22001     if (V1.getOpcode() == ISD::INSERT_SUBVECTOR &&
22002         V1.getOperand(0).getOpcode() == ISD::UNDEF &&
22003         ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
22004         ISD::isBuildVectorAllOnes(V2.getNode()))
22005       return true;
22006   }
22007
22008   return false;
22009 }
22010
22011 // On AVX/AVX2 the type v8i1 is legalized to v8i16, which is an XMM sized
22012 // register. In most cases we actually compare or select YMM-sized registers
22013 // and mixing the two types creates horrible code. This method optimizes
22014 // some of the transition sequences.
22015 static SDValue WidenMaskArithmetic(SDNode *N, SelectionDAG &DAG,
22016                                  TargetLowering::DAGCombinerInfo &DCI,
22017                                  const X86Subtarget *Subtarget) {
22018   EVT VT = N->getValueType(0);
22019   if (!VT.is256BitVector())
22020     return SDValue();
22021
22022   assert((N->getOpcode() == ISD::ANY_EXTEND ||
22023           N->getOpcode() == ISD::ZERO_EXTEND ||
22024           N->getOpcode() == ISD::SIGN_EXTEND) && "Invalid Node");
22025
22026   SDValue Narrow = N->getOperand(0);
22027   EVT NarrowVT = Narrow->getValueType(0);
22028   if (!NarrowVT.is128BitVector())
22029     return SDValue();
22030
22031   if (Narrow->getOpcode() != ISD::XOR &&
22032       Narrow->getOpcode() != ISD::AND &&
22033       Narrow->getOpcode() != ISD::OR)
22034     return SDValue();
22035
22036   SDValue N0  = Narrow->getOperand(0);
22037   SDValue N1  = Narrow->getOperand(1);
22038   SDLoc DL(Narrow);
22039
22040   // The Left side has to be a trunc.
22041   if (N0.getOpcode() != ISD::TRUNCATE)
22042     return SDValue();
22043
22044   // The type of the truncated inputs.
22045   EVT WideVT = N0->getOperand(0)->getValueType(0);
22046   if (WideVT != VT)
22047     return SDValue();
22048
22049   // The right side has to be a 'trunc' or a constant vector.
22050   bool RHSTrunc = N1.getOpcode() == ISD::TRUNCATE;
22051   ConstantSDNode *RHSConstSplat = nullptr;
22052   if (auto *RHSBV = dyn_cast<BuildVectorSDNode>(N1))
22053     RHSConstSplat = RHSBV->getConstantSplatNode();
22054   if (!RHSTrunc && !RHSConstSplat)
22055     return SDValue();
22056
22057   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
22058
22059   if (!TLI.isOperationLegalOrPromote(Narrow->getOpcode(), WideVT))
22060     return SDValue();
22061
22062   // Set N0 and N1 to hold the inputs to the new wide operation.
22063   N0 = N0->getOperand(0);
22064   if (RHSConstSplat) {
22065     N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, WideVT.getScalarType(),
22066                      SDValue(RHSConstSplat, 0));
22067     SmallVector<SDValue, 8> C(WideVT.getVectorNumElements(), N1);
22068     N1 = DAG.getNode(ISD::BUILD_VECTOR, DL, WideVT, C);
22069   } else if (RHSTrunc) {
22070     N1 = N1->getOperand(0);
22071   }
22072
22073   // Generate the wide operation.
22074   SDValue Op = DAG.getNode(Narrow->getOpcode(), DL, WideVT, N0, N1);
22075   unsigned Opcode = N->getOpcode();
22076   switch (Opcode) {
22077   case ISD::ANY_EXTEND:
22078     return Op;
22079   case ISD::ZERO_EXTEND: {
22080     unsigned InBits = NarrowVT.getScalarType().getSizeInBits();
22081     APInt Mask = APInt::getAllOnesValue(InBits);
22082     Mask = Mask.zext(VT.getScalarType().getSizeInBits());
22083     return DAG.getNode(ISD::AND, DL, VT,
22084                        Op, DAG.getConstant(Mask, VT));
22085   }
22086   case ISD::SIGN_EXTEND:
22087     return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT,
22088                        Op, DAG.getValueType(NarrowVT));
22089   default:
22090     llvm_unreachable("Unexpected opcode");
22091   }
22092 }
22093
22094 static SDValue VectorZextCombine(SDNode *N, SelectionDAG &DAG,
22095                                  TargetLowering::DAGCombinerInfo &DCI,
22096                                  const X86Subtarget *Subtarget) {
22097   SDValue N0 = N->getOperand(0);
22098   SDValue N1 = N->getOperand(1);
22099   SDLoc DL(N);
22100
22101   // A vector zext_in_reg may be represented as a shuffle,
22102   // feeding into a bitcast (this represents anyext) feeding into
22103   // an and with a mask.
22104   // We'd like to try to combine that into a shuffle with zero
22105   // plus a bitcast, removing the and.
22106   if (N0.getOpcode() != ISD::BITCAST ||
22107       N0.getOperand(0).getOpcode() != ISD::VECTOR_SHUFFLE)
22108     return SDValue();
22109
22110   // The other side of the AND should be a splat of 2^C, where C
22111   // is the number of bits in the source type.
22112   if (N1.getOpcode() == ISD::BITCAST)
22113     N1 = N1.getOperand(0);
22114   if (N1.getOpcode() != ISD::BUILD_VECTOR)
22115     return SDValue();
22116   BuildVectorSDNode *Vector = cast<BuildVectorSDNode>(N1);
22117
22118   ShuffleVectorSDNode *Shuffle = cast<ShuffleVectorSDNode>(N0.getOperand(0));
22119   EVT SrcType = Shuffle->getValueType(0);
22120
22121   // We expect a single-source shuffle
22122   if (Shuffle->getOperand(1)->getOpcode() != ISD::UNDEF)
22123     return SDValue();
22124
22125   unsigned SrcSize = SrcType.getScalarSizeInBits();
22126
22127   APInt SplatValue, SplatUndef;
22128   unsigned SplatBitSize;
22129   bool HasAnyUndefs;
22130   if (!Vector->isConstantSplat(SplatValue, SplatUndef,
22131                                 SplatBitSize, HasAnyUndefs))
22132     return SDValue();
22133
22134   unsigned ResSize = N1.getValueType().getScalarSizeInBits();
22135   // Make sure the splat matches the mask we expect
22136   if (SplatBitSize > ResSize ||
22137       (SplatValue + 1).exactLogBase2() != (int)SrcSize)
22138     return SDValue();
22139
22140   // Make sure the input and output size make sense
22141   if (SrcSize >= ResSize || ResSize % SrcSize)
22142     return SDValue();
22143
22144   // We expect a shuffle of the form <0, u, u, u, 1, u, u, u...>
22145   // The number of u's between each two values depends on the ratio between
22146   // the source and dest type.
22147   unsigned ZextRatio = ResSize / SrcSize;
22148   bool IsZext = true;
22149   for (unsigned i = 0; i < SrcType.getVectorNumElements(); ++i) {
22150     if (i % ZextRatio) {
22151       if (Shuffle->getMaskElt(i) > 0) {
22152         // Expected undef
22153         IsZext = false;
22154         break;
22155       }
22156     } else {
22157       if (Shuffle->getMaskElt(i) != (int)(i / ZextRatio)) {
22158         // Expected element number
22159         IsZext = false;
22160         break;
22161       }
22162     }
22163   }
22164
22165   if (!IsZext)
22166     return SDValue();
22167
22168   // Ok, perform the transformation - replace the shuffle with
22169   // a shuffle of the form <0, k, k, k, 1, k, k, k> with zero
22170   // (instead of undef) where the k elements come from the zero vector.
22171   SmallVector<int, 8> Mask;
22172   unsigned NumElems = SrcType.getVectorNumElements();
22173   for (unsigned i = 0; i < NumElems; ++i)
22174     if (i % ZextRatio)
22175       Mask.push_back(NumElems);
22176     else
22177       Mask.push_back(i / ZextRatio);
22178
22179   SDValue NewShuffle = DAG.getVectorShuffle(Shuffle->getValueType(0), DL,
22180     Shuffle->getOperand(0), DAG.getConstant(0, SrcType), Mask);
22181   return DAG.getNode(ISD::BITCAST, DL,  N0.getValueType(), NewShuffle);
22182 }
22183
22184 static SDValue PerformAndCombine(SDNode *N, SelectionDAG &DAG,
22185                                  TargetLowering::DAGCombinerInfo &DCI,
22186                                  const X86Subtarget *Subtarget) {
22187   if (DCI.isBeforeLegalizeOps())
22188     return SDValue();
22189
22190   if (SDValue Zext = VectorZextCombine(N, DAG, DCI, Subtarget))
22191     return Zext;
22192
22193   if (SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget))
22194     return R;
22195
22196   EVT VT = N->getValueType(0);
22197   SDValue N0 = N->getOperand(0);
22198   SDValue N1 = N->getOperand(1);
22199   SDLoc DL(N);
22200
22201   // Create BEXTR instructions
22202   // BEXTR is ((X >> imm) & (2**size-1))
22203   if (VT == MVT::i32 || VT == MVT::i64) {
22204     // Check for BEXTR.
22205     if ((Subtarget->hasBMI() || Subtarget->hasTBM()) &&
22206         (N0.getOpcode() == ISD::SRA || N0.getOpcode() == ISD::SRL)) {
22207       ConstantSDNode *MaskNode = dyn_cast<ConstantSDNode>(N1);
22208       ConstantSDNode *ShiftNode = dyn_cast<ConstantSDNode>(N0.getOperand(1));
22209       if (MaskNode && ShiftNode) {
22210         uint64_t Mask = MaskNode->getZExtValue();
22211         uint64_t Shift = ShiftNode->getZExtValue();
22212         if (isMask_64(Mask)) {
22213           uint64_t MaskSize = countPopulation(Mask);
22214           if (Shift + MaskSize <= VT.getSizeInBits())
22215             return DAG.getNode(X86ISD::BEXTR, DL, VT, N0.getOperand(0),
22216                                DAG.getConstant(Shift | (MaskSize << 8), VT));
22217         }
22218       }
22219     } // BEXTR
22220
22221     return SDValue();
22222   }
22223
22224   // Want to form ANDNP nodes:
22225   // 1) In the hopes of then easily combining them with OR and AND nodes
22226   //    to form PBLEND/PSIGN.
22227   // 2) To match ANDN packed intrinsics
22228   if (VT != MVT::v2i64 && VT != MVT::v4i64)
22229     return SDValue();
22230
22231   // Check LHS for vnot
22232   if (N0.getOpcode() == ISD::XOR &&
22233       //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
22234       CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
22235     return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
22236
22237   // Check RHS for vnot
22238   if (N1.getOpcode() == ISD::XOR &&
22239       //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
22240       CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
22241     return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
22242
22243   return SDValue();
22244 }
22245
22246 static SDValue PerformOrCombine(SDNode *N, SelectionDAG &DAG,
22247                                 TargetLowering::DAGCombinerInfo &DCI,
22248                                 const X86Subtarget *Subtarget) {
22249   if (DCI.isBeforeLegalizeOps())
22250     return SDValue();
22251
22252   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
22253   if (R.getNode())
22254     return R;
22255
22256   SDValue N0 = N->getOperand(0);
22257   SDValue N1 = N->getOperand(1);
22258   EVT VT = N->getValueType(0);
22259
22260   // look for psign/blend
22261   if (VT == MVT::v2i64 || VT == MVT::v4i64) {
22262     if (!Subtarget->hasSSSE3() ||
22263         (VT == MVT::v4i64 && !Subtarget->hasInt256()))
22264       return SDValue();
22265
22266     // Canonicalize pandn to RHS
22267     if (N0.getOpcode() == X86ISD::ANDNP)
22268       std::swap(N0, N1);
22269     // or (and (m, y), (pandn m, x))
22270     if (N0.getOpcode() == ISD::AND && N1.getOpcode() == X86ISD::ANDNP) {
22271       SDValue Mask = N1.getOperand(0);
22272       SDValue X    = N1.getOperand(1);
22273       SDValue Y;
22274       if (N0.getOperand(0) == Mask)
22275         Y = N0.getOperand(1);
22276       if (N0.getOperand(1) == Mask)
22277         Y = N0.getOperand(0);
22278
22279       // Check to see if the mask appeared in both the AND and ANDNP and
22280       if (!Y.getNode())
22281         return SDValue();
22282
22283       // Validate that X, Y, and Mask are BIT_CONVERTS, and see through them.
22284       // Look through mask bitcast.
22285       if (Mask.getOpcode() == ISD::BITCAST)
22286         Mask = Mask.getOperand(0);
22287       if (X.getOpcode() == ISD::BITCAST)
22288         X = X.getOperand(0);
22289       if (Y.getOpcode() == ISD::BITCAST)
22290         Y = Y.getOperand(0);
22291
22292       EVT MaskVT = Mask.getValueType();
22293
22294       // Validate that the Mask operand is a vector sra node.
22295       // FIXME: what to do for bytes, since there is a psignb/pblendvb, but
22296       // there is no psrai.b
22297       unsigned EltBits = MaskVT.getVectorElementType().getSizeInBits();
22298       unsigned SraAmt = ~0;
22299       if (Mask.getOpcode() == ISD::SRA) {
22300         if (auto *AmtBV = dyn_cast<BuildVectorSDNode>(Mask.getOperand(1)))
22301           if (auto *AmtConst = AmtBV->getConstantSplatNode())
22302             SraAmt = AmtConst->getZExtValue();
22303       } else if (Mask.getOpcode() == X86ISD::VSRAI) {
22304         SDValue SraC = Mask.getOperand(1);
22305         SraAmt  = cast<ConstantSDNode>(SraC)->getZExtValue();
22306       }
22307       if ((SraAmt + 1) != EltBits)
22308         return SDValue();
22309
22310       SDLoc DL(N);
22311
22312       // Now we know we at least have a plendvb with the mask val.  See if
22313       // we can form a psignb/w/d.
22314       // psign = x.type == y.type == mask.type && y = sub(0, x);
22315       if (Y.getOpcode() == ISD::SUB && Y.getOperand(1) == X &&
22316           ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
22317           X.getValueType() == MaskVT && Y.getValueType() == MaskVT) {
22318         assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
22319                "Unsupported VT for PSIGN");
22320         Mask = DAG.getNode(X86ISD::PSIGN, DL, MaskVT, X, Mask.getOperand(0));
22321         return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
22322       }
22323       // PBLENDVB only available on SSE 4.1
22324       if (!Subtarget->hasSSE41())
22325         return SDValue();
22326
22327       EVT BlendVT = (VT == MVT::v4i64) ? MVT::v32i8 : MVT::v16i8;
22328
22329       X = DAG.getNode(ISD::BITCAST, DL, BlendVT, X);
22330       Y = DAG.getNode(ISD::BITCAST, DL, BlendVT, Y);
22331       Mask = DAG.getNode(ISD::BITCAST, DL, BlendVT, Mask);
22332       Mask = DAG.getNode(ISD::VSELECT, DL, BlendVT, Mask, Y, X);
22333       return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
22334     }
22335   }
22336
22337   if (VT != MVT::i16 && VT != MVT::i32 && VT != MVT::i64)
22338     return SDValue();
22339
22340   // fold (or (x << c) | (y >> (64 - c))) ==> (shld64 x, y, c)
22341   MachineFunction &MF = DAG.getMachineFunction();
22342   bool OptForSize =
22343       MF.getFunction()->hasFnAttribute(Attribute::OptimizeForSize);
22344
22345   // SHLD/SHRD instructions have lower register pressure, but on some
22346   // platforms they have higher latency than the equivalent
22347   // series of shifts/or that would otherwise be generated.
22348   // Don't fold (or (x << c) | (y >> (64 - c))) if SHLD/SHRD instructions
22349   // have higher latencies and we are not optimizing for size.
22350   if (!OptForSize && Subtarget->isSHLDSlow())
22351     return SDValue();
22352
22353   if (N0.getOpcode() == ISD::SRL && N1.getOpcode() == ISD::SHL)
22354     std::swap(N0, N1);
22355   if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
22356     return SDValue();
22357   if (!N0.hasOneUse() || !N1.hasOneUse())
22358     return SDValue();
22359
22360   SDValue ShAmt0 = N0.getOperand(1);
22361   if (ShAmt0.getValueType() != MVT::i8)
22362     return SDValue();
22363   SDValue ShAmt1 = N1.getOperand(1);
22364   if (ShAmt1.getValueType() != MVT::i8)
22365     return SDValue();
22366   if (ShAmt0.getOpcode() == ISD::TRUNCATE)
22367     ShAmt0 = ShAmt0.getOperand(0);
22368   if (ShAmt1.getOpcode() == ISD::TRUNCATE)
22369     ShAmt1 = ShAmt1.getOperand(0);
22370
22371   SDLoc DL(N);
22372   unsigned Opc = X86ISD::SHLD;
22373   SDValue Op0 = N0.getOperand(0);
22374   SDValue Op1 = N1.getOperand(0);
22375   if (ShAmt0.getOpcode() == ISD::SUB) {
22376     Opc = X86ISD::SHRD;
22377     std::swap(Op0, Op1);
22378     std::swap(ShAmt0, ShAmt1);
22379   }
22380
22381   unsigned Bits = VT.getSizeInBits();
22382   if (ShAmt1.getOpcode() == ISD::SUB) {
22383     SDValue Sum = ShAmt1.getOperand(0);
22384     if (ConstantSDNode *SumC = dyn_cast<ConstantSDNode>(Sum)) {
22385       SDValue ShAmt1Op1 = ShAmt1.getOperand(1);
22386       if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
22387         ShAmt1Op1 = ShAmt1Op1.getOperand(0);
22388       if (SumC->getSExtValue() == Bits && ShAmt1Op1 == ShAmt0)
22389         return DAG.getNode(Opc, DL, VT,
22390                            Op0, Op1,
22391                            DAG.getNode(ISD::TRUNCATE, DL,
22392                                        MVT::i8, ShAmt0));
22393     }
22394   } else if (ConstantSDNode *ShAmt1C = dyn_cast<ConstantSDNode>(ShAmt1)) {
22395     ConstantSDNode *ShAmt0C = dyn_cast<ConstantSDNode>(ShAmt0);
22396     if (ShAmt0C &&
22397         ShAmt0C->getSExtValue() + ShAmt1C->getSExtValue() == Bits)
22398       return DAG.getNode(Opc, DL, VT,
22399                          N0.getOperand(0), N1.getOperand(0),
22400                          DAG.getNode(ISD::TRUNCATE, DL,
22401                                        MVT::i8, ShAmt0));
22402   }
22403
22404   return SDValue();
22405 }
22406
22407 // Generate NEG and CMOV for integer abs.
22408 static SDValue performIntegerAbsCombine(SDNode *N, SelectionDAG &DAG) {
22409   EVT VT = N->getValueType(0);
22410
22411   // Since X86 does not have CMOV for 8-bit integer, we don't convert
22412   // 8-bit integer abs to NEG and CMOV.
22413   if (VT.isInteger() && VT.getSizeInBits() == 8)
22414     return SDValue();
22415
22416   SDValue N0 = N->getOperand(0);
22417   SDValue N1 = N->getOperand(1);
22418   SDLoc DL(N);
22419
22420   // Check pattern of XOR(ADD(X,Y), Y) where Y is SRA(X, size(X)-1)
22421   // and change it to SUB and CMOV.
22422   if (VT.isInteger() && N->getOpcode() == ISD::XOR &&
22423       N0.getOpcode() == ISD::ADD &&
22424       N0.getOperand(1) == N1 &&
22425       N1.getOpcode() == ISD::SRA &&
22426       N1.getOperand(0) == N0.getOperand(0))
22427     if (ConstantSDNode *Y1C = dyn_cast<ConstantSDNode>(N1.getOperand(1)))
22428       if (Y1C->getAPIntValue() == VT.getSizeInBits()-1) {
22429         // Generate SUB & CMOV.
22430         SDValue Neg = DAG.getNode(X86ISD::SUB, DL, DAG.getVTList(VT, MVT::i32),
22431                                   DAG.getConstant(0, VT), N0.getOperand(0));
22432
22433         SDValue Ops[] = { N0.getOperand(0), Neg,
22434                           DAG.getConstant(X86::COND_GE, MVT::i8),
22435                           SDValue(Neg.getNode(), 1) };
22436         return DAG.getNode(X86ISD::CMOV, DL, DAG.getVTList(VT, MVT::Glue), Ops);
22437       }
22438   return SDValue();
22439 }
22440
22441 // PerformXorCombine - Attempts to turn XOR nodes into BLSMSK nodes
22442 static SDValue PerformXorCombine(SDNode *N, SelectionDAG &DAG,
22443                                  TargetLowering::DAGCombinerInfo &DCI,
22444                                  const X86Subtarget *Subtarget) {
22445   if (DCI.isBeforeLegalizeOps())
22446     return SDValue();
22447
22448   if (Subtarget->hasCMov()) {
22449     SDValue RV = performIntegerAbsCombine(N, DAG);
22450     if (RV.getNode())
22451       return RV;
22452   }
22453
22454   return SDValue();
22455 }
22456
22457 /// PerformLOADCombine - Do target-specific dag combines on LOAD nodes.
22458 static SDValue PerformLOADCombine(SDNode *N, SelectionDAG &DAG,
22459                                   TargetLowering::DAGCombinerInfo &DCI,
22460                                   const X86Subtarget *Subtarget) {
22461   LoadSDNode *Ld = cast<LoadSDNode>(N);
22462   EVT RegVT = Ld->getValueType(0);
22463   EVT MemVT = Ld->getMemoryVT();
22464   SDLoc dl(Ld);
22465   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
22466
22467   // For chips with slow 32-byte unaligned loads, break the 32-byte operation
22468   // into two 16-byte operations.
22469   ISD::LoadExtType Ext = Ld->getExtensionType();
22470   unsigned Alignment = Ld->getAlignment();
22471   bool IsAligned = Alignment == 0 || Alignment >= MemVT.getSizeInBits()/8;
22472   if (RegVT.is256BitVector() && Subtarget->isUnalignedMem32Slow() &&
22473       !DCI.isBeforeLegalizeOps() && !IsAligned && Ext == ISD::NON_EXTLOAD) {
22474     unsigned NumElems = RegVT.getVectorNumElements();
22475     if (NumElems < 2)
22476       return SDValue();
22477
22478     SDValue Ptr = Ld->getBasePtr();
22479     SDValue Increment = DAG.getConstant(16, TLI.getPointerTy());
22480
22481     EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
22482                                   NumElems/2);
22483     SDValue Load1 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
22484                                 Ld->getPointerInfo(), Ld->isVolatile(),
22485                                 Ld->isNonTemporal(), Ld->isInvariant(),
22486                                 Alignment);
22487     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
22488     SDValue Load2 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
22489                                 Ld->getPointerInfo(), Ld->isVolatile(),
22490                                 Ld->isNonTemporal(), Ld->isInvariant(),
22491                                 std::min(16U, Alignment));
22492     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
22493                              Load1.getValue(1),
22494                              Load2.getValue(1));
22495
22496     SDValue NewVec = DAG.getUNDEF(RegVT);
22497     NewVec = Insert128BitVector(NewVec, Load1, 0, DAG, dl);
22498     NewVec = Insert128BitVector(NewVec, Load2, NumElems/2, DAG, dl);
22499     return DCI.CombineTo(N, NewVec, TF, true);
22500   }
22501
22502   return SDValue();
22503 }
22504
22505 /// PerformMLOADCombine - Resolve extending loads
22506 static SDValue PerformMLOADCombine(SDNode *N, SelectionDAG &DAG,
22507                                    TargetLowering::DAGCombinerInfo &DCI,
22508                                    const X86Subtarget *Subtarget) {
22509   MaskedLoadSDNode *Mld = cast<MaskedLoadSDNode>(N);
22510   if (Mld->getExtensionType() != ISD::SEXTLOAD)
22511     return SDValue();
22512
22513   EVT VT = Mld->getValueType(0);
22514   unsigned NumElems = VT.getVectorNumElements();
22515   EVT LdVT = Mld->getMemoryVT();
22516   SDLoc dl(Mld);
22517
22518   assert(LdVT != VT && "Cannot extend to the same type");
22519   unsigned ToSz = VT.getVectorElementType().getSizeInBits();
22520   unsigned FromSz = LdVT.getVectorElementType().getSizeInBits();
22521   // From, To sizes and ElemCount must be pow of two
22522   assert (isPowerOf2_32(NumElems * FromSz * ToSz) &&
22523     "Unexpected size for extending masked load");
22524
22525   unsigned SizeRatio  = ToSz / FromSz;
22526   assert(SizeRatio * NumElems * FromSz == VT.getSizeInBits());
22527
22528   // Create a type on which we perform the shuffle
22529   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
22530           LdVT.getScalarType(), NumElems*SizeRatio);
22531   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
22532
22533   // Convert Src0 value
22534   SDValue WideSrc0 = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mld->getSrc0());
22535   if (Mld->getSrc0().getOpcode() != ISD::UNDEF) {
22536     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
22537     for (unsigned i = 0; i != NumElems; ++i)
22538       ShuffleVec[i] = i * SizeRatio;
22539
22540     // Can't shuffle using an illegal type.
22541     assert (DAG.getTargetLoweringInfo().isTypeLegal(WideVecVT)
22542             && "WideVecVT should be legal");
22543     WideSrc0 = DAG.getVectorShuffle(WideVecVT, dl, WideSrc0,
22544                                     DAG.getUNDEF(WideVecVT), &ShuffleVec[0]);
22545   }
22546   // Prepare the new mask
22547   SDValue NewMask;
22548   SDValue Mask = Mld->getMask();
22549   if (Mask.getValueType() == VT) {
22550     // Mask and original value have the same type
22551     NewMask = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mask);
22552     SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
22553     for (unsigned i = 0; i != NumElems; ++i)
22554       ShuffleVec[i] = i * SizeRatio;
22555     for (unsigned i = NumElems; i != NumElems*SizeRatio; ++i)
22556       ShuffleVec[i] = NumElems*SizeRatio;
22557     NewMask = DAG.getVectorShuffle(WideVecVT, dl, NewMask,
22558                                    DAG.getConstant(0, WideVecVT),
22559                                    &ShuffleVec[0]);
22560   }
22561   else {
22562     assert(Mask.getValueType().getVectorElementType() == MVT::i1);
22563     unsigned WidenNumElts = NumElems*SizeRatio;
22564     unsigned MaskNumElts = VT.getVectorNumElements();
22565     EVT NewMaskVT = EVT::getVectorVT(*DAG.getContext(),  MVT::i1,
22566                                      WidenNumElts);
22567
22568     unsigned NumConcat = WidenNumElts / MaskNumElts;
22569     SmallVector<SDValue, 16> Ops(NumConcat);
22570     SDValue ZeroVal = DAG.getConstant(0, Mask.getValueType());
22571     Ops[0] = Mask;
22572     for (unsigned i = 1; i != NumConcat; ++i)
22573       Ops[i] = ZeroVal;
22574
22575     NewMask = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewMaskVT, Ops);
22576   }
22577
22578   SDValue WideLd = DAG.getMaskedLoad(WideVecVT, dl, Mld->getChain(),
22579                                      Mld->getBasePtr(), NewMask, WideSrc0,
22580                                      Mld->getMemoryVT(), Mld->getMemOperand(),
22581                                      ISD::NON_EXTLOAD);
22582   SDValue NewVec = DAG.getNode(X86ISD::VSEXT, dl, VT, WideLd);
22583   return DCI.CombineTo(N, NewVec, WideLd.getValue(1), true);
22584
22585 }
22586 /// PerformMSTORECombine - Resolve truncating stores
22587 static SDValue PerformMSTORECombine(SDNode *N, SelectionDAG &DAG,
22588                                     const X86Subtarget *Subtarget) {
22589   MaskedStoreSDNode *Mst = cast<MaskedStoreSDNode>(N);
22590   if (!Mst->isTruncatingStore())
22591     return SDValue();
22592
22593   EVT VT = Mst->getValue().getValueType();
22594   unsigned NumElems = VT.getVectorNumElements();
22595   EVT StVT = Mst->getMemoryVT();
22596   SDLoc dl(Mst);
22597
22598   assert(StVT != VT && "Cannot truncate to the same type");
22599   unsigned FromSz = VT.getVectorElementType().getSizeInBits();
22600   unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
22601
22602   // From, To sizes and ElemCount must be pow of two
22603   assert (isPowerOf2_32(NumElems * FromSz * ToSz) &&
22604     "Unexpected size for truncating masked store");
22605   // We are going to use the original vector elt for storing.
22606   // Accumulated smaller vector elements must be a multiple of the store size.
22607   assert (((NumElems * FromSz) % ToSz) == 0 &&
22608           "Unexpected ratio for truncating masked store");
22609
22610   unsigned SizeRatio  = FromSz / ToSz;
22611   assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
22612
22613   // Create a type on which we perform the shuffle
22614   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
22615           StVT.getScalarType(), NumElems*SizeRatio);
22616
22617   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
22618
22619   SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mst->getValue());
22620   SmallVector<int, 16> ShuffleVec(NumElems * SizeRatio, -1);
22621   for (unsigned i = 0; i != NumElems; ++i)
22622     ShuffleVec[i] = i * SizeRatio;
22623
22624   // Can't shuffle using an illegal type.
22625   assert (DAG.getTargetLoweringInfo().isTypeLegal(WideVecVT)
22626           && "WideVecVT should be legal");
22627
22628   SDValue TruncatedVal = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
22629                                         DAG.getUNDEF(WideVecVT),
22630                                         &ShuffleVec[0]);
22631
22632   SDValue NewMask;
22633   SDValue Mask = Mst->getMask();
22634   if (Mask.getValueType() == VT) {
22635     // Mask and original value have the same type
22636     NewMask = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Mask);
22637     for (unsigned i = 0; i != NumElems; ++i)
22638       ShuffleVec[i] = i * SizeRatio;
22639     for (unsigned i = NumElems; i != NumElems*SizeRatio; ++i)
22640       ShuffleVec[i] = NumElems*SizeRatio;
22641     NewMask = DAG.getVectorShuffle(WideVecVT, dl, NewMask,
22642                                    DAG.getConstant(0, WideVecVT),
22643                                    &ShuffleVec[0]);
22644   }
22645   else {
22646     assert(Mask.getValueType().getVectorElementType() == MVT::i1);
22647     unsigned WidenNumElts = NumElems*SizeRatio;
22648     unsigned MaskNumElts = VT.getVectorNumElements();
22649     EVT NewMaskVT = EVT::getVectorVT(*DAG.getContext(),  MVT::i1,
22650                                      WidenNumElts);
22651
22652     unsigned NumConcat = WidenNumElts / MaskNumElts;
22653     SmallVector<SDValue, 16> Ops(NumConcat);
22654     SDValue ZeroVal = DAG.getConstant(0, Mask.getValueType());
22655     Ops[0] = Mask;
22656     for (unsigned i = 1; i != NumConcat; ++i)
22657       Ops[i] = ZeroVal;
22658
22659     NewMask = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewMaskVT, Ops);
22660   }
22661
22662   return DAG.getMaskedStore(Mst->getChain(), dl, TruncatedVal, Mst->getBasePtr(),
22663                             NewMask, StVT, Mst->getMemOperand(), false);
22664 }
22665 /// PerformSTORECombine - Do target-specific dag combines on STORE nodes.
22666 static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
22667                                    const X86Subtarget *Subtarget) {
22668   StoreSDNode *St = cast<StoreSDNode>(N);
22669   EVT VT = St->getValue().getValueType();
22670   EVT StVT = St->getMemoryVT();
22671   SDLoc dl(St);
22672   SDValue StoredVal = St->getOperand(1);
22673   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
22674
22675   // If we are saving a concatenation of two XMM registers and 32-byte stores
22676   // are slow, such as on Sandy Bridge, perform two 16-byte stores.
22677   unsigned Alignment = St->getAlignment();
22678   bool IsAligned = Alignment == 0 || Alignment >= VT.getSizeInBits()/8;
22679   if (VT.is256BitVector() && Subtarget->isUnalignedMem32Slow() &&
22680       StVT == VT && !IsAligned) {
22681     unsigned NumElems = VT.getVectorNumElements();
22682     if (NumElems < 2)
22683       return SDValue();
22684
22685     SDValue Value0 = Extract128BitVector(StoredVal, 0, DAG, dl);
22686     SDValue Value1 = Extract128BitVector(StoredVal, NumElems/2, DAG, dl);
22687
22688     SDValue Stride = DAG.getConstant(16, TLI.getPointerTy());
22689     SDValue Ptr0 = St->getBasePtr();
22690     SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
22691
22692     SDValue Ch0 = DAG.getStore(St->getChain(), dl, Value0, Ptr0,
22693                                 St->getPointerInfo(), St->isVolatile(),
22694                                 St->isNonTemporal(), Alignment);
22695     SDValue Ch1 = DAG.getStore(St->getChain(), dl, Value1, Ptr1,
22696                                 St->getPointerInfo(), St->isVolatile(),
22697                                 St->isNonTemporal(),
22698                                 std::min(16U, Alignment));
22699     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
22700   }
22701
22702   // Optimize trunc store (of multiple scalars) to shuffle and store.
22703   // First, pack all of the elements in one place. Next, store to memory
22704   // in fewer chunks.
22705   if (St->isTruncatingStore() && VT.isVector()) {
22706     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
22707     unsigned NumElems = VT.getVectorNumElements();
22708     assert(StVT != VT && "Cannot truncate to the same type");
22709     unsigned FromSz = VT.getVectorElementType().getSizeInBits();
22710     unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
22711
22712     // From, To sizes and ElemCount must be pow of two
22713     if (!isPowerOf2_32(NumElems * FromSz * ToSz)) return SDValue();
22714     // We are going to use the original vector elt for storing.
22715     // Accumulated smaller vector elements must be a multiple of the store size.
22716     if (0 != (NumElems * FromSz) % ToSz) return SDValue();
22717
22718     unsigned SizeRatio  = FromSz / ToSz;
22719
22720     assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
22721
22722     // Create a type on which we perform the shuffle
22723     EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
22724             StVT.getScalarType(), NumElems*SizeRatio);
22725
22726     assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
22727
22728     SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
22729     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
22730     for (unsigned i = 0; i != NumElems; ++i)
22731       ShuffleVec[i] = i * SizeRatio;
22732
22733     // Can't shuffle using an illegal type.
22734     if (!TLI.isTypeLegal(WideVecVT))
22735       return SDValue();
22736
22737     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
22738                                          DAG.getUNDEF(WideVecVT),
22739                                          &ShuffleVec[0]);
22740     // At this point all of the data is stored at the bottom of the
22741     // register. We now need to save it to mem.
22742
22743     // Find the largest store unit
22744     MVT StoreType = MVT::i8;
22745     for (MVT Tp : MVT::integer_valuetypes()) {
22746       if (TLI.isTypeLegal(Tp) && Tp.getSizeInBits() <= NumElems * ToSz)
22747         StoreType = Tp;
22748     }
22749
22750     // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
22751     if (TLI.isTypeLegal(MVT::f64) && StoreType.getSizeInBits() < 64 &&
22752         (64 <= NumElems * ToSz))
22753       StoreType = MVT::f64;
22754
22755     // Bitcast the original vector into a vector of store-size units
22756     EVT StoreVecVT = EVT::getVectorVT(*DAG.getContext(),
22757             StoreType, VT.getSizeInBits()/StoreType.getSizeInBits());
22758     assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
22759     SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
22760     SmallVector<SDValue, 8> Chains;
22761     SDValue Increment = DAG.getConstant(StoreType.getSizeInBits()/8,
22762                                         TLI.getPointerTy());
22763     SDValue Ptr = St->getBasePtr();
22764
22765     // Perform one or more big stores into memory.
22766     for (unsigned i=0, e=(ToSz*NumElems)/StoreType.getSizeInBits(); i!=e; ++i) {
22767       SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
22768                                    StoreType, ShuffWide,
22769                                    DAG.getIntPtrConstant(i));
22770       SDValue Ch = DAG.getStore(St->getChain(), dl, SubVec, Ptr,
22771                                 St->getPointerInfo(), St->isVolatile(),
22772                                 St->isNonTemporal(), St->getAlignment());
22773       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
22774       Chains.push_back(Ch);
22775     }
22776
22777     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
22778   }
22779
22780   // Turn load->store of MMX types into GPR load/stores.  This avoids clobbering
22781   // the FP state in cases where an emms may be missing.
22782   // A preferable solution to the general problem is to figure out the right
22783   // places to insert EMMS.  This qualifies as a quick hack.
22784
22785   // Similarly, turn load->store of i64 into double load/stores in 32-bit mode.
22786   if (VT.getSizeInBits() != 64)
22787     return SDValue();
22788
22789   const Function *F = DAG.getMachineFunction().getFunction();
22790   bool NoImplicitFloatOps = F->hasFnAttribute(Attribute::NoImplicitFloat);
22791   bool F64IsLegal = !DAG.getTarget().Options.UseSoftFloat && !NoImplicitFloatOps
22792                      && Subtarget->hasSSE2();
22793   if ((VT.isVector() ||
22794        (VT == MVT::i64 && F64IsLegal && !Subtarget->is64Bit())) &&
22795       isa<LoadSDNode>(St->getValue()) &&
22796       !cast<LoadSDNode>(St->getValue())->isVolatile() &&
22797       St->getChain().hasOneUse() && !St->isVolatile()) {
22798     SDNode* LdVal = St->getValue().getNode();
22799     LoadSDNode *Ld = nullptr;
22800     int TokenFactorIndex = -1;
22801     SmallVector<SDValue, 8> Ops;
22802     SDNode* ChainVal = St->getChain().getNode();
22803     // Must be a store of a load.  We currently handle two cases:  the load
22804     // is a direct child, and it's under an intervening TokenFactor.  It is
22805     // possible to dig deeper under nested TokenFactors.
22806     if (ChainVal == LdVal)
22807       Ld = cast<LoadSDNode>(St->getChain());
22808     else if (St->getValue().hasOneUse() &&
22809              ChainVal->getOpcode() == ISD::TokenFactor) {
22810       for (unsigned i = 0, e = ChainVal->getNumOperands(); i != e; ++i) {
22811         if (ChainVal->getOperand(i).getNode() == LdVal) {
22812           TokenFactorIndex = i;
22813           Ld = cast<LoadSDNode>(St->getValue());
22814         } else
22815           Ops.push_back(ChainVal->getOperand(i));
22816       }
22817     }
22818
22819     if (!Ld || !ISD::isNormalLoad(Ld))
22820       return SDValue();
22821
22822     // If this is not the MMX case, i.e. we are just turning i64 load/store
22823     // into f64 load/store, avoid the transformation if there are multiple
22824     // uses of the loaded value.
22825     if (!VT.isVector() && !Ld->hasNUsesOfValue(1, 0))
22826       return SDValue();
22827
22828     SDLoc LdDL(Ld);
22829     SDLoc StDL(N);
22830     // If we are a 64-bit capable x86, lower to a single movq load/store pair.
22831     // Otherwise, if it's legal to use f64 SSE instructions, use f64 load/store
22832     // pair instead.
22833     if (Subtarget->is64Bit() || F64IsLegal) {
22834       EVT LdVT = Subtarget->is64Bit() ? MVT::i64 : MVT::f64;
22835       SDValue NewLd = DAG.getLoad(LdVT, LdDL, Ld->getChain(), Ld->getBasePtr(),
22836                                   Ld->getPointerInfo(), Ld->isVolatile(),
22837                                   Ld->isNonTemporal(), Ld->isInvariant(),
22838                                   Ld->getAlignment());
22839       SDValue NewChain = NewLd.getValue(1);
22840       if (TokenFactorIndex != -1) {
22841         Ops.push_back(NewChain);
22842         NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
22843       }
22844       return DAG.getStore(NewChain, StDL, NewLd, St->getBasePtr(),
22845                           St->getPointerInfo(),
22846                           St->isVolatile(), St->isNonTemporal(),
22847                           St->getAlignment());
22848     }
22849
22850     // Otherwise, lower to two pairs of 32-bit loads / stores.
22851     SDValue LoAddr = Ld->getBasePtr();
22852     SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
22853                                  DAG.getConstant(4, MVT::i32));
22854
22855     SDValue LoLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), LoAddr,
22856                                Ld->getPointerInfo(),
22857                                Ld->isVolatile(), Ld->isNonTemporal(),
22858                                Ld->isInvariant(), Ld->getAlignment());
22859     SDValue HiLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), HiAddr,
22860                                Ld->getPointerInfo().getWithOffset(4),
22861                                Ld->isVolatile(), Ld->isNonTemporal(),
22862                                Ld->isInvariant(),
22863                                MinAlign(Ld->getAlignment(), 4));
22864
22865     SDValue NewChain = LoLd.getValue(1);
22866     if (TokenFactorIndex != -1) {
22867       Ops.push_back(LoLd);
22868       Ops.push_back(HiLd);
22869       NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
22870     }
22871
22872     LoAddr = St->getBasePtr();
22873     HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
22874                          DAG.getConstant(4, MVT::i32));
22875
22876     SDValue LoSt = DAG.getStore(NewChain, StDL, LoLd, LoAddr,
22877                                 St->getPointerInfo(),
22878                                 St->isVolatile(), St->isNonTemporal(),
22879                                 St->getAlignment());
22880     SDValue HiSt = DAG.getStore(NewChain, StDL, HiLd, HiAddr,
22881                                 St->getPointerInfo().getWithOffset(4),
22882                                 St->isVolatile(),
22883                                 St->isNonTemporal(),
22884                                 MinAlign(St->getAlignment(), 4));
22885     return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
22886   }
22887   return SDValue();
22888 }
22889
22890 /// Return 'true' if this vector operation is "horizontal"
22891 /// and return the operands for the horizontal operation in LHS and RHS.  A
22892 /// horizontal operation performs the binary operation on successive elements
22893 /// of its first operand, then on successive elements of its second operand,
22894 /// returning the resulting values in a vector.  For example, if
22895 ///   A = < float a0, float a1, float a2, float a3 >
22896 /// and
22897 ///   B = < float b0, float b1, float b2, float b3 >
22898 /// then the result of doing a horizontal operation on A and B is
22899 ///   A horizontal-op B = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >.
22900 /// In short, LHS and RHS are inspected to see if LHS op RHS is of the form
22901 /// A horizontal-op B, for some already available A and B, and if so then LHS is
22902 /// set to A, RHS to B, and the routine returns 'true'.
22903 /// Note that the binary operation should have the property that if one of the
22904 /// operands is UNDEF then the result is UNDEF.
22905 static bool isHorizontalBinOp(SDValue &LHS, SDValue &RHS, bool IsCommutative) {
22906   // Look for the following pattern: if
22907   //   A = < float a0, float a1, float a2, float a3 >
22908   //   B = < float b0, float b1, float b2, float b3 >
22909   // and
22910   //   LHS = VECTOR_SHUFFLE A, B, <0, 2, 4, 6>
22911   //   RHS = VECTOR_SHUFFLE A, B, <1, 3, 5, 7>
22912   // then LHS op RHS = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >
22913   // which is A horizontal-op B.
22914
22915   // At least one of the operands should be a vector shuffle.
22916   if (LHS.getOpcode() != ISD::VECTOR_SHUFFLE &&
22917       RHS.getOpcode() != ISD::VECTOR_SHUFFLE)
22918     return false;
22919
22920   MVT VT = LHS.getSimpleValueType();
22921
22922   assert((VT.is128BitVector() || VT.is256BitVector()) &&
22923          "Unsupported vector type for horizontal add/sub");
22924
22925   // Handle 128 and 256-bit vector lengths. AVX defines horizontal add/sub to
22926   // operate independently on 128-bit lanes.
22927   unsigned NumElts = VT.getVectorNumElements();
22928   unsigned NumLanes = VT.getSizeInBits()/128;
22929   unsigned NumLaneElts = NumElts / NumLanes;
22930   assert((NumLaneElts % 2 == 0) &&
22931          "Vector type should have an even number of elements in each lane");
22932   unsigned HalfLaneElts = NumLaneElts/2;
22933
22934   // View LHS in the form
22935   //   LHS = VECTOR_SHUFFLE A, B, LMask
22936   // If LHS is not a shuffle then pretend it is the shuffle
22937   //   LHS = VECTOR_SHUFFLE LHS, undef, <0, 1, ..., N-1>
22938   // NOTE: in what follows a default initialized SDValue represents an UNDEF of
22939   // type VT.
22940   SDValue A, B;
22941   SmallVector<int, 16> LMask(NumElts);
22942   if (LHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
22943     if (LHS.getOperand(0).getOpcode() != ISD::UNDEF)
22944       A = LHS.getOperand(0);
22945     if (LHS.getOperand(1).getOpcode() != ISD::UNDEF)
22946       B = LHS.getOperand(1);
22947     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(LHS.getNode())->getMask();
22948     std::copy(Mask.begin(), Mask.end(), LMask.begin());
22949   } else {
22950     if (LHS.getOpcode() != ISD::UNDEF)
22951       A = LHS;
22952     for (unsigned i = 0; i != NumElts; ++i)
22953       LMask[i] = i;
22954   }
22955
22956   // Likewise, view RHS in the form
22957   //   RHS = VECTOR_SHUFFLE C, D, RMask
22958   SDValue C, D;
22959   SmallVector<int, 16> RMask(NumElts);
22960   if (RHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
22961     if (RHS.getOperand(0).getOpcode() != ISD::UNDEF)
22962       C = RHS.getOperand(0);
22963     if (RHS.getOperand(1).getOpcode() != ISD::UNDEF)
22964       D = RHS.getOperand(1);
22965     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(RHS.getNode())->getMask();
22966     std::copy(Mask.begin(), Mask.end(), RMask.begin());
22967   } else {
22968     if (RHS.getOpcode() != ISD::UNDEF)
22969       C = RHS;
22970     for (unsigned i = 0; i != NumElts; ++i)
22971       RMask[i] = i;
22972   }
22973
22974   // Check that the shuffles are both shuffling the same vectors.
22975   if (!(A == C && B == D) && !(A == D && B == C))
22976     return false;
22977
22978   // If everything is UNDEF then bail out: it would be better to fold to UNDEF.
22979   if (!A.getNode() && !B.getNode())
22980     return false;
22981
22982   // If A and B occur in reverse order in RHS, then "swap" them (which means
22983   // rewriting the mask).
22984   if (A != C)
22985     ShuffleVectorSDNode::commuteMask(RMask);
22986
22987   // At this point LHS and RHS are equivalent to
22988   //   LHS = VECTOR_SHUFFLE A, B, LMask
22989   //   RHS = VECTOR_SHUFFLE A, B, RMask
22990   // Check that the masks correspond to performing a horizontal operation.
22991   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
22992     for (unsigned i = 0; i != NumLaneElts; ++i) {
22993       int LIdx = LMask[i+l], RIdx = RMask[i+l];
22994
22995       // Ignore any UNDEF components.
22996       if (LIdx < 0 || RIdx < 0 ||
22997           (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
22998           (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
22999         continue;
23000
23001       // Check that successive elements are being operated on.  If not, this is
23002       // not a horizontal operation.
23003       unsigned Src = (i/HalfLaneElts); // each lane is split between srcs
23004       int Index = 2*(i%HalfLaneElts) + NumElts*Src + l;
23005       if (!(LIdx == Index && RIdx == Index + 1) &&
23006           !(IsCommutative && LIdx == Index + 1 && RIdx == Index))
23007         return false;
23008     }
23009   }
23010
23011   LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
23012   RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
23013   return true;
23014 }
23015
23016 /// Do target-specific dag combines on floating point adds.
23017 static SDValue PerformFADDCombine(SDNode *N, SelectionDAG &DAG,
23018                                   const X86Subtarget *Subtarget) {
23019   EVT VT = N->getValueType(0);
23020   SDValue LHS = N->getOperand(0);
23021   SDValue RHS = N->getOperand(1);
23022
23023   // Try to synthesize horizontal adds from adds of shuffles.
23024   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
23025        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
23026       isHorizontalBinOp(LHS, RHS, true))
23027     return DAG.getNode(X86ISD::FHADD, SDLoc(N), VT, LHS, RHS);
23028   return SDValue();
23029 }
23030
23031 /// Do target-specific dag combines on floating point subs.
23032 static SDValue PerformFSUBCombine(SDNode *N, SelectionDAG &DAG,
23033                                   const X86Subtarget *Subtarget) {
23034   EVT VT = N->getValueType(0);
23035   SDValue LHS = N->getOperand(0);
23036   SDValue RHS = N->getOperand(1);
23037
23038   // Try to synthesize horizontal subs from subs of shuffles.
23039   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
23040        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
23041       isHorizontalBinOp(LHS, RHS, false))
23042     return DAG.getNode(X86ISD::FHSUB, SDLoc(N), VT, LHS, RHS);
23043   return SDValue();
23044 }
23045
23046 /// Do target-specific dag combines on X86ISD::FOR and X86ISD::FXOR nodes.
23047 static SDValue PerformFORCombine(SDNode *N, SelectionDAG &DAG) {
23048   assert(N->getOpcode() == X86ISD::FOR || N->getOpcode() == X86ISD::FXOR);
23049
23050   // F[X]OR(0.0, x) -> x
23051   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
23052     if (C->getValueAPF().isPosZero())
23053       return N->getOperand(1);
23054
23055   // F[X]OR(x, 0.0) -> x
23056   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
23057     if (C->getValueAPF().isPosZero())
23058       return N->getOperand(0);
23059   return SDValue();
23060 }
23061
23062 /// Do target-specific dag combines on X86ISD::FMIN and X86ISD::FMAX nodes.
23063 static SDValue PerformFMinFMaxCombine(SDNode *N, SelectionDAG &DAG) {
23064   assert(N->getOpcode() == X86ISD::FMIN || N->getOpcode() == X86ISD::FMAX);
23065
23066   // Only perform optimizations if UnsafeMath is used.
23067   if (!DAG.getTarget().Options.UnsafeFPMath)
23068     return SDValue();
23069
23070   // If we run in unsafe-math mode, then convert the FMAX and FMIN nodes
23071   // into FMINC and FMAXC, which are Commutative operations.
23072   unsigned NewOp = 0;
23073   switch (N->getOpcode()) {
23074     default: llvm_unreachable("unknown opcode");
23075     case X86ISD::FMIN:  NewOp = X86ISD::FMINC; break;
23076     case X86ISD::FMAX:  NewOp = X86ISD::FMAXC; break;
23077   }
23078
23079   return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
23080                      N->getOperand(0), N->getOperand(1));
23081 }
23082
23083 /// Do target-specific dag combines on X86ISD::FAND nodes.
23084 static SDValue PerformFANDCombine(SDNode *N, SelectionDAG &DAG) {
23085   // FAND(0.0, x) -> 0.0
23086   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
23087     if (C->getValueAPF().isPosZero())
23088       return N->getOperand(0);
23089
23090   // FAND(x, 0.0) -> 0.0
23091   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
23092     if (C->getValueAPF().isPosZero())
23093       return N->getOperand(1);
23094
23095   return SDValue();
23096 }
23097
23098 /// Do target-specific dag combines on X86ISD::FANDN nodes
23099 static SDValue PerformFANDNCombine(SDNode *N, SelectionDAG &DAG) {
23100   // FANDN(0.0, x) -> x
23101   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
23102     if (C->getValueAPF().isPosZero())
23103       return N->getOperand(1);
23104
23105   // FANDN(x, 0.0) -> 0.0
23106   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
23107     if (C->getValueAPF().isPosZero())
23108       return N->getOperand(1);
23109
23110   return SDValue();
23111 }
23112
23113 static SDValue PerformBTCombine(SDNode *N,
23114                                 SelectionDAG &DAG,
23115                                 TargetLowering::DAGCombinerInfo &DCI) {
23116   // BT ignores high bits in the bit index operand.
23117   SDValue Op1 = N->getOperand(1);
23118   if (Op1.hasOneUse()) {
23119     unsigned BitWidth = Op1.getValueSizeInBits();
23120     APInt DemandedMask = APInt::getLowBitsSet(BitWidth, Log2_32(BitWidth));
23121     APInt KnownZero, KnownOne;
23122     TargetLowering::TargetLoweringOpt TLO(DAG, !DCI.isBeforeLegalize(),
23123                                           !DCI.isBeforeLegalizeOps());
23124     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
23125     if (TLO.ShrinkDemandedConstant(Op1, DemandedMask) ||
23126         TLI.SimplifyDemandedBits(Op1, DemandedMask, KnownZero, KnownOne, TLO))
23127       DCI.CommitTargetLoweringOpt(TLO);
23128   }
23129   return SDValue();
23130 }
23131
23132 static SDValue PerformVZEXT_MOVLCombine(SDNode *N, SelectionDAG &DAG) {
23133   SDValue Op = N->getOperand(0);
23134   if (Op.getOpcode() == ISD::BITCAST)
23135     Op = Op.getOperand(0);
23136   EVT VT = N->getValueType(0), OpVT = Op.getValueType();
23137   if (Op.getOpcode() == X86ISD::VZEXT_LOAD &&
23138       VT.getVectorElementType().getSizeInBits() ==
23139       OpVT.getVectorElementType().getSizeInBits()) {
23140     return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
23141   }
23142   return SDValue();
23143 }
23144
23145 static SDValue PerformSIGN_EXTEND_INREGCombine(SDNode *N, SelectionDAG &DAG,
23146                                                const X86Subtarget *Subtarget) {
23147   EVT VT = N->getValueType(0);
23148   if (!VT.isVector())
23149     return SDValue();
23150
23151   SDValue N0 = N->getOperand(0);
23152   SDValue N1 = N->getOperand(1);
23153   EVT ExtraVT = cast<VTSDNode>(N1)->getVT();
23154   SDLoc dl(N);
23155
23156   // The SIGN_EXTEND_INREG to v4i64 is expensive operation on the
23157   // both SSE and AVX2 since there is no sign-extended shift right
23158   // operation on a vector with 64-bit elements.
23159   //(sext_in_reg (v4i64 anyext (v4i32 x )), ExtraVT) ->
23160   // (v4i64 sext (v4i32 sext_in_reg (v4i32 x , ExtraVT)))
23161   if (VT == MVT::v4i64 && (N0.getOpcode() == ISD::ANY_EXTEND ||
23162       N0.getOpcode() == ISD::SIGN_EXTEND)) {
23163     SDValue N00 = N0.getOperand(0);
23164
23165     // EXTLOAD has a better solution on AVX2,
23166     // it may be replaced with X86ISD::VSEXT node.
23167     if (N00.getOpcode() == ISD::LOAD && Subtarget->hasInt256())
23168       if (!ISD::isNormalLoad(N00.getNode()))
23169         return SDValue();
23170
23171     if (N00.getValueType() == MVT::v4i32 && ExtraVT.getSizeInBits() < 128) {
23172         SDValue Tmp = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32,
23173                                   N00, N1);
23174       return DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i64, Tmp);
23175     }
23176   }
23177   return SDValue();
23178 }
23179
23180 static SDValue PerformSExtCombine(SDNode *N, SelectionDAG &DAG,
23181                                   TargetLowering::DAGCombinerInfo &DCI,
23182                                   const X86Subtarget *Subtarget) {
23183   SDValue N0 = N->getOperand(0);
23184   EVT VT = N->getValueType(0);
23185
23186   // (i8,i32 sext (sdivrem (i8 x, i8 y)) ->
23187   // (i8,i32 (sdivrem_sext_hreg (i8 x, i8 y)
23188   // This exposes the sext to the sdivrem lowering, so that it directly extends
23189   // from AH (which we otherwise need to do contortions to access).
23190   if (N0.getOpcode() == ISD::SDIVREM && N0.getResNo() == 1 &&
23191       N0.getValueType() == MVT::i8 && VT == MVT::i32) {
23192     SDLoc dl(N);
23193     SDVTList NodeTys = DAG.getVTList(MVT::i8, VT);
23194     SDValue R = DAG.getNode(X86ISD::SDIVREM8_SEXT_HREG, dl, NodeTys,
23195                             N0.getOperand(0), N0.getOperand(1));
23196     DAG.ReplaceAllUsesOfValueWith(N0.getValue(0), R.getValue(0));
23197     return R.getValue(1);
23198   }
23199
23200   if (!DCI.isBeforeLegalizeOps())
23201     return SDValue();
23202
23203   if (!Subtarget->hasFp256())
23204     return SDValue();
23205
23206   if (VT.isVector() && VT.getSizeInBits() == 256) {
23207     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
23208     if (R.getNode())
23209       return R;
23210   }
23211
23212   return SDValue();
23213 }
23214
23215 static SDValue PerformFMACombine(SDNode *N, SelectionDAG &DAG,
23216                                  const X86Subtarget* Subtarget) {
23217   SDLoc dl(N);
23218   EVT VT = N->getValueType(0);
23219
23220   // Let legalize expand this if it isn't a legal type yet.
23221   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
23222     return SDValue();
23223
23224   EVT ScalarVT = VT.getScalarType();
23225   if ((ScalarVT != MVT::f32 && ScalarVT != MVT::f64) ||
23226       (!Subtarget->hasFMA() && !Subtarget->hasFMA4()))
23227     return SDValue();
23228
23229   SDValue A = N->getOperand(0);
23230   SDValue B = N->getOperand(1);
23231   SDValue C = N->getOperand(2);
23232
23233   bool NegA = (A.getOpcode() == ISD::FNEG);
23234   bool NegB = (B.getOpcode() == ISD::FNEG);
23235   bool NegC = (C.getOpcode() == ISD::FNEG);
23236
23237   // Negative multiplication when NegA xor NegB
23238   bool NegMul = (NegA != NegB);
23239   if (NegA)
23240     A = A.getOperand(0);
23241   if (NegB)
23242     B = B.getOperand(0);
23243   if (NegC)
23244     C = C.getOperand(0);
23245
23246   unsigned Opcode;
23247   if (!NegMul)
23248     Opcode = (!NegC) ? X86ISD::FMADD : X86ISD::FMSUB;
23249   else
23250     Opcode = (!NegC) ? X86ISD::FNMADD : X86ISD::FNMSUB;
23251
23252   return DAG.getNode(Opcode, dl, VT, A, B, C);
23253 }
23254
23255 static SDValue PerformZExtCombine(SDNode *N, SelectionDAG &DAG,
23256                                   TargetLowering::DAGCombinerInfo &DCI,
23257                                   const X86Subtarget *Subtarget) {
23258   // (i32 zext (and (i8  x86isd::setcc_carry), 1)) ->
23259   //           (and (i32 x86isd::setcc_carry), 1)
23260   // This eliminates the zext. This transformation is necessary because
23261   // ISD::SETCC is always legalized to i8.
23262   SDLoc dl(N);
23263   SDValue N0 = N->getOperand(0);
23264   EVT VT = N->getValueType(0);
23265
23266   if (N0.getOpcode() == ISD::AND &&
23267       N0.hasOneUse() &&
23268       N0.getOperand(0).hasOneUse()) {
23269     SDValue N00 = N0.getOperand(0);
23270     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
23271       ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
23272       if (!C || C->getZExtValue() != 1)
23273         return SDValue();
23274       return DAG.getNode(ISD::AND, dl, VT,
23275                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
23276                                      N00.getOperand(0), N00.getOperand(1)),
23277                          DAG.getConstant(1, VT));
23278     }
23279   }
23280
23281   if (N0.getOpcode() == ISD::TRUNCATE &&
23282       N0.hasOneUse() &&
23283       N0.getOperand(0).hasOneUse()) {
23284     SDValue N00 = N0.getOperand(0);
23285     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
23286       return DAG.getNode(ISD::AND, dl, VT,
23287                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
23288                                      N00.getOperand(0), N00.getOperand(1)),
23289                          DAG.getConstant(1, VT));
23290     }
23291   }
23292   if (VT.is256BitVector()) {
23293     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
23294     if (R.getNode())
23295       return R;
23296   }
23297
23298   // (i8,i32 zext (udivrem (i8 x, i8 y)) ->
23299   // (i8,i32 (udivrem_zext_hreg (i8 x, i8 y)
23300   // This exposes the zext to the udivrem lowering, so that it directly extends
23301   // from AH (which we otherwise need to do contortions to access).
23302   if (N0.getOpcode() == ISD::UDIVREM &&
23303       N0.getResNo() == 1 && N0.getValueType() == MVT::i8 &&
23304       (VT == MVT::i32 || VT == MVT::i64)) {
23305     SDVTList NodeTys = DAG.getVTList(MVT::i8, VT);
23306     SDValue R = DAG.getNode(X86ISD::UDIVREM8_ZEXT_HREG, dl, NodeTys,
23307                             N0.getOperand(0), N0.getOperand(1));
23308     DAG.ReplaceAllUsesOfValueWith(N0.getValue(0), R.getValue(0));
23309     return R.getValue(1);
23310   }
23311
23312   return SDValue();
23313 }
23314
23315 // Optimize x == -y --> x+y == 0
23316 //          x != -y --> x+y != 0
23317 static SDValue PerformISDSETCCCombine(SDNode *N, SelectionDAG &DAG,
23318                                       const X86Subtarget* Subtarget) {
23319   ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
23320   SDValue LHS = N->getOperand(0);
23321   SDValue RHS = N->getOperand(1);
23322   EVT VT = N->getValueType(0);
23323   SDLoc DL(N);
23324
23325   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && LHS.getOpcode() == ISD::SUB)
23326     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHS.getOperand(0)))
23327       if (C->getAPIntValue() == 0 && LHS.hasOneUse()) {
23328         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N), LHS.getValueType(), RHS,
23329                                    LHS.getOperand(1));
23330         return DAG.getSetCC(SDLoc(N), N->getValueType(0), addV,
23331                             DAG.getConstant(0, addV.getValueType()), CC);
23332       }
23333   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && RHS.getOpcode() == ISD::SUB)
23334     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS.getOperand(0)))
23335       if (C->getAPIntValue() == 0 && RHS.hasOneUse()) {
23336         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N), RHS.getValueType(), LHS,
23337                                    RHS.getOperand(1));
23338         return DAG.getSetCC(SDLoc(N), N->getValueType(0), addV,
23339                             DAG.getConstant(0, addV.getValueType()), CC);
23340       }
23341
23342   if (VT.getScalarType() == MVT::i1 &&
23343       (CC == ISD::SETNE || CC == ISD::SETEQ || ISD::isSignedIntSetCC(CC))) {
23344     bool IsSEXT0 =
23345         (LHS.getOpcode() == ISD::SIGN_EXTEND) &&
23346         (LHS.getOperand(0).getValueType().getScalarType() == MVT::i1);
23347     bool IsVZero1 = ISD::isBuildVectorAllZeros(RHS.getNode());
23348
23349     if (!IsSEXT0 || !IsVZero1) {
23350       // Swap the operands and update the condition code.
23351       std::swap(LHS, RHS);
23352       CC = ISD::getSetCCSwappedOperands(CC);
23353
23354       IsSEXT0 = (LHS.getOpcode() == ISD::SIGN_EXTEND) &&
23355                 (LHS.getOperand(0).getValueType().getScalarType() == MVT::i1);
23356       IsVZero1 = ISD::isBuildVectorAllZeros(RHS.getNode());
23357     }
23358
23359     if (IsSEXT0 && IsVZero1) {
23360       assert(VT == LHS.getOperand(0).getValueType() &&
23361              "Uexpected operand type");
23362       if (CC == ISD::SETGT)
23363         return DAG.getConstant(0, VT);
23364       if (CC == ISD::SETLE)
23365         return DAG.getConstant(1, VT);
23366       if (CC == ISD::SETEQ || CC == ISD::SETGE)
23367         return DAG.getNOT(DL, LHS.getOperand(0), VT);
23368
23369       assert((CC == ISD::SETNE || CC == ISD::SETLT) &&
23370              "Unexpected condition code!");
23371       return LHS.getOperand(0);
23372     }
23373   }
23374
23375   return SDValue();
23376 }
23377
23378 static SDValue NarrowVectorLoadToElement(LoadSDNode *Load, unsigned Index,
23379                                          SelectionDAG &DAG) {
23380   SDLoc dl(Load);
23381   MVT VT = Load->getSimpleValueType(0);
23382   MVT EVT = VT.getVectorElementType();
23383   SDValue Addr = Load->getOperand(1);
23384   SDValue NewAddr = DAG.getNode(
23385       ISD::ADD, dl, Addr.getSimpleValueType(), Addr,
23386       DAG.getConstant(Index * EVT.getStoreSize(), Addr.getSimpleValueType()));
23387
23388   SDValue NewLoad =
23389       DAG.getLoad(EVT, dl, Load->getChain(), NewAddr,
23390                   DAG.getMachineFunction().getMachineMemOperand(
23391                       Load->getMemOperand(), 0, EVT.getStoreSize()));
23392   return NewLoad;
23393 }
23394
23395 static SDValue PerformINSERTPSCombine(SDNode *N, SelectionDAG &DAG,
23396                                       const X86Subtarget *Subtarget) {
23397   SDLoc dl(N);
23398   MVT VT = N->getOperand(1)->getSimpleValueType(0);
23399   assert((VT == MVT::v4f32 || VT == MVT::v4i32) &&
23400          "X86insertps is only defined for v4x32");
23401
23402   SDValue Ld = N->getOperand(1);
23403   if (MayFoldLoad(Ld)) {
23404     // Extract the countS bits from the immediate so we can get the proper
23405     // address when narrowing the vector load to a specific element.
23406     // When the second source op is a memory address, insertps doesn't use
23407     // countS and just gets an f32 from that address.
23408     unsigned DestIndex =
23409         cast<ConstantSDNode>(N->getOperand(2))->getZExtValue() >> 6;
23410
23411     Ld = NarrowVectorLoadToElement(cast<LoadSDNode>(Ld), DestIndex, DAG);
23412
23413     // Create this as a scalar to vector to match the instruction pattern.
23414     SDValue LoadScalarToVector = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Ld);
23415     // countS bits are ignored when loading from memory on insertps, which
23416     // means we don't need to explicitly set them to 0.
23417     return DAG.getNode(X86ISD::INSERTPS, dl, VT, N->getOperand(0),
23418                        LoadScalarToVector, N->getOperand(2));
23419   }
23420   return SDValue();
23421 }
23422
23423 static SDValue PerformBLENDICombine(SDNode *N, SelectionDAG &DAG) {
23424   SDValue V0 = N->getOperand(0);
23425   SDValue V1 = N->getOperand(1);
23426   SDLoc DL(N);
23427   EVT VT = N->getValueType(0);
23428
23429   // Canonicalize a v2f64 blend with a mask of 2 by swapping the vector
23430   // operands and changing the mask to 1. This saves us a bunch of
23431   // pattern-matching possibilities related to scalar math ops in SSE/AVX.
23432   // x86InstrInfo knows how to commute this back after instruction selection
23433   // if it would help register allocation.
23434
23435   // TODO: If optimizing for size or a processor that doesn't suffer from
23436   // partial register update stalls, this should be transformed into a MOVSD
23437   // instruction because a MOVSD is 1-2 bytes smaller than a BLENDPD.
23438
23439   if (VT == MVT::v2f64)
23440     if (auto *Mask = dyn_cast<ConstantSDNode>(N->getOperand(2)))
23441       if (Mask->getZExtValue() == 2 && !isShuffleFoldableLoad(V0)) {
23442         SDValue NewMask = DAG.getConstant(1, MVT::i8);
23443         return DAG.getNode(X86ISD::BLENDI, DL, VT, V1, V0, NewMask);
23444       }
23445
23446   return SDValue();
23447 }
23448
23449 // Helper function of PerformSETCCCombine. It is to materialize "setb reg"
23450 // as "sbb reg,reg", since it can be extended without zext and produces
23451 // an all-ones bit which is more useful than 0/1 in some cases.
23452 static SDValue MaterializeSETB(SDLoc DL, SDValue EFLAGS, SelectionDAG &DAG,
23453                                MVT VT) {
23454   if (VT == MVT::i8)
23455     return DAG.getNode(ISD::AND, DL, VT,
23456                        DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
23457                                    DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS),
23458                        DAG.getConstant(1, VT));
23459   assert (VT == MVT::i1 && "Unexpected type for SECCC node");
23460   return DAG.getNode(ISD::TRUNCATE, DL, MVT::i1,
23461                      DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
23462                                  DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS));
23463 }
23464
23465 // Optimize  RES = X86ISD::SETCC CONDCODE, EFLAG_INPUT
23466 static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG &DAG,
23467                                    TargetLowering::DAGCombinerInfo &DCI,
23468                                    const X86Subtarget *Subtarget) {
23469   SDLoc DL(N);
23470   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(0));
23471   SDValue EFLAGS = N->getOperand(1);
23472
23473   if (CC == X86::COND_A) {
23474     // Try to convert COND_A into COND_B in an attempt to facilitate
23475     // materializing "setb reg".
23476     //
23477     // Do not flip "e > c", where "c" is a constant, because Cmp instruction
23478     // cannot take an immediate as its first operand.
23479     //
23480     if (EFLAGS.getOpcode() == X86ISD::SUB && EFLAGS.hasOneUse() &&
23481         EFLAGS.getValueType().isInteger() &&
23482         !isa<ConstantSDNode>(EFLAGS.getOperand(1))) {
23483       SDValue NewSub = DAG.getNode(X86ISD::SUB, SDLoc(EFLAGS),
23484                                    EFLAGS.getNode()->getVTList(),
23485                                    EFLAGS.getOperand(1), EFLAGS.getOperand(0));
23486       SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
23487       return MaterializeSETB(DL, NewEFLAGS, DAG, N->getSimpleValueType(0));
23488     }
23489   }
23490
23491   // Materialize "setb reg" as "sbb reg,reg", since it can be extended without
23492   // a zext and produces an all-ones bit which is more useful than 0/1 in some
23493   // cases.
23494   if (CC == X86::COND_B)
23495     return MaterializeSETB(DL, EFLAGS, DAG, N->getSimpleValueType(0));
23496
23497   SDValue Flags;
23498
23499   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
23500   if (Flags.getNode()) {
23501     SDValue Cond = DAG.getConstant(CC, MVT::i8);
23502     return DAG.getNode(X86ISD::SETCC, DL, N->getVTList(), Cond, Flags);
23503   }
23504
23505   return SDValue();
23506 }
23507
23508 // Optimize branch condition evaluation.
23509 //
23510 static SDValue PerformBrCondCombine(SDNode *N, SelectionDAG &DAG,
23511                                     TargetLowering::DAGCombinerInfo &DCI,
23512                                     const X86Subtarget *Subtarget) {
23513   SDLoc DL(N);
23514   SDValue Chain = N->getOperand(0);
23515   SDValue Dest = N->getOperand(1);
23516   SDValue EFLAGS = N->getOperand(3);
23517   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(2));
23518
23519   SDValue Flags;
23520
23521   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
23522   if (Flags.getNode()) {
23523     SDValue Cond = DAG.getConstant(CC, MVT::i8);
23524     return DAG.getNode(X86ISD::BRCOND, DL, N->getVTList(), Chain, Dest, Cond,
23525                        Flags);
23526   }
23527
23528   return SDValue();
23529 }
23530
23531 static SDValue performVectorCompareAndMaskUnaryOpCombine(SDNode *N,
23532                                                          SelectionDAG &DAG) {
23533   // Take advantage of vector comparisons producing 0 or -1 in each lane to
23534   // optimize away operation when it's from a constant.
23535   //
23536   // The general transformation is:
23537   //    UNARYOP(AND(VECTOR_CMP(x,y), constant)) -->
23538   //       AND(VECTOR_CMP(x,y), constant2)
23539   //    constant2 = UNARYOP(constant)
23540
23541   // Early exit if this isn't a vector operation, the operand of the
23542   // unary operation isn't a bitwise AND, or if the sizes of the operations
23543   // aren't the same.
23544   EVT VT = N->getValueType(0);
23545   if (!VT.isVector() || N->getOperand(0)->getOpcode() != ISD::AND ||
23546       N->getOperand(0)->getOperand(0)->getOpcode() != ISD::SETCC ||
23547       VT.getSizeInBits() != N->getOperand(0)->getValueType(0).getSizeInBits())
23548     return SDValue();
23549
23550   // Now check that the other operand of the AND is a constant. We could
23551   // make the transformation for non-constant splats as well, but it's unclear
23552   // that would be a benefit as it would not eliminate any operations, just
23553   // perform one more step in scalar code before moving to the vector unit.
23554   if (BuildVectorSDNode *BV =
23555           dyn_cast<BuildVectorSDNode>(N->getOperand(0)->getOperand(1))) {
23556     // Bail out if the vector isn't a constant.
23557     if (!BV->isConstant())
23558       return SDValue();
23559
23560     // Everything checks out. Build up the new and improved node.
23561     SDLoc DL(N);
23562     EVT IntVT = BV->getValueType(0);
23563     // Create a new constant of the appropriate type for the transformed
23564     // DAG.
23565     SDValue SourceConst = DAG.getNode(N->getOpcode(), DL, VT, SDValue(BV, 0));
23566     // The AND node needs bitcasts to/from an integer vector type around it.
23567     SDValue MaskConst = DAG.getNode(ISD::BITCAST, DL, IntVT, SourceConst);
23568     SDValue NewAnd = DAG.getNode(ISD::AND, DL, IntVT,
23569                                  N->getOperand(0)->getOperand(0), MaskConst);
23570     SDValue Res = DAG.getNode(ISD::BITCAST, DL, VT, NewAnd);
23571     return Res;
23572   }
23573
23574   return SDValue();
23575 }
23576
23577 static SDValue PerformSINT_TO_FPCombine(SDNode *N, SelectionDAG &DAG,
23578                                         const X86Subtarget *Subtarget) {
23579   // First try to optimize away the conversion entirely when it's
23580   // conditionally from a constant. Vectors only.
23581   SDValue Res = performVectorCompareAndMaskUnaryOpCombine(N, DAG);
23582   if (Res != SDValue())
23583     return Res;
23584
23585   // Now move on to more general possibilities.
23586   SDValue Op0 = N->getOperand(0);
23587   EVT InVT = Op0->getValueType(0);
23588
23589   // SINT_TO_FP(v4i8) -> SINT_TO_FP(SEXT(v4i8 to v4i32))
23590   if (InVT == MVT::v8i8 || InVT == MVT::v4i8) {
23591     SDLoc dl(N);
23592     MVT DstVT = InVT == MVT::v4i8 ? MVT::v4i32 : MVT::v8i32;
23593     SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
23594     return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
23595   }
23596
23597   // Transform (SINT_TO_FP (i64 ...)) into an x87 operation if we have
23598   // a 32-bit target where SSE doesn't support i64->FP operations.
23599   if (Op0.getOpcode() == ISD::LOAD) {
23600     LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
23601     EVT VT = Ld->getValueType(0);
23602     if (!Ld->isVolatile() && !N->getValueType(0).isVector() &&
23603         ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
23604         !Subtarget->is64Bit() && VT == MVT::i64) {
23605       SDValue FILDChain = Subtarget->getTargetLowering()->BuildFILD(
23606           SDValue(N, 0), Ld->getValueType(0), Ld->getChain(), Op0, DAG);
23607       DAG.ReplaceAllUsesOfValueWith(Op0.getValue(1), FILDChain.getValue(1));
23608       return FILDChain;
23609     }
23610   }
23611   return SDValue();
23612 }
23613
23614 // Optimize RES, EFLAGS = X86ISD::ADC LHS, RHS, EFLAGS
23615 static SDValue PerformADCCombine(SDNode *N, SelectionDAG &DAG,
23616                                  X86TargetLowering::DAGCombinerInfo &DCI) {
23617   // If the LHS and RHS of the ADC node are zero, then it can't overflow and
23618   // the result is either zero or one (depending on the input carry bit).
23619   // Strength reduce this down to a "set on carry" aka SETCC_CARRY&1.
23620   if (X86::isZeroNode(N->getOperand(0)) &&
23621       X86::isZeroNode(N->getOperand(1)) &&
23622       // We don't have a good way to replace an EFLAGS use, so only do this when
23623       // dead right now.
23624       SDValue(N, 1).use_empty()) {
23625     SDLoc DL(N);
23626     EVT VT = N->getValueType(0);
23627     SDValue CarryOut = DAG.getConstant(0, N->getValueType(1));
23628     SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
23629                                DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
23630                                            DAG.getConstant(X86::COND_B,MVT::i8),
23631                                            N->getOperand(2)),
23632                                DAG.getConstant(1, VT));
23633     return DCI.CombineTo(N, Res1, CarryOut);
23634   }
23635
23636   return SDValue();
23637 }
23638
23639 // fold (add Y, (sete  X, 0)) -> adc  0, Y
23640 //      (add Y, (setne X, 0)) -> sbb -1, Y
23641 //      (sub (sete  X, 0), Y) -> sbb  0, Y
23642 //      (sub (setne X, 0), Y) -> adc -1, Y
23643 static SDValue OptimizeConditionalInDecrement(SDNode *N, SelectionDAG &DAG) {
23644   SDLoc DL(N);
23645
23646   // Look through ZExts.
23647   SDValue Ext = N->getOperand(N->getOpcode() == ISD::SUB ? 1 : 0);
23648   if (Ext.getOpcode() != ISD::ZERO_EXTEND || !Ext.hasOneUse())
23649     return SDValue();
23650
23651   SDValue SetCC = Ext.getOperand(0);
23652   if (SetCC.getOpcode() != X86ISD::SETCC || !SetCC.hasOneUse())
23653     return SDValue();
23654
23655   X86::CondCode CC = (X86::CondCode)SetCC.getConstantOperandVal(0);
23656   if (CC != X86::COND_E && CC != X86::COND_NE)
23657     return SDValue();
23658
23659   SDValue Cmp = SetCC.getOperand(1);
23660   if (Cmp.getOpcode() != X86ISD::CMP || !Cmp.hasOneUse() ||
23661       !X86::isZeroNode(Cmp.getOperand(1)) ||
23662       !Cmp.getOperand(0).getValueType().isInteger())
23663     return SDValue();
23664
23665   SDValue CmpOp0 = Cmp.getOperand(0);
23666   SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
23667                                DAG.getConstant(1, CmpOp0.getValueType()));
23668
23669   SDValue OtherVal = N->getOperand(N->getOpcode() == ISD::SUB ? 0 : 1);
23670   if (CC == X86::COND_NE)
23671     return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
23672                        DL, OtherVal.getValueType(), OtherVal,
23673                        DAG.getConstant(-1ULL, OtherVal.getValueType()), NewCmp);
23674   return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
23675                      DL, OtherVal.getValueType(), OtherVal,
23676                      DAG.getConstant(0, OtherVal.getValueType()), NewCmp);
23677 }
23678
23679 /// PerformADDCombine - Do target-specific dag combines on integer adds.
23680 static SDValue PerformAddCombine(SDNode *N, SelectionDAG &DAG,
23681                                  const X86Subtarget *Subtarget) {
23682   EVT VT = N->getValueType(0);
23683   SDValue Op0 = N->getOperand(0);
23684   SDValue Op1 = N->getOperand(1);
23685
23686   // Try to synthesize horizontal adds from adds of shuffles.
23687   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
23688        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
23689       isHorizontalBinOp(Op0, Op1, true))
23690     return DAG.getNode(X86ISD::HADD, SDLoc(N), VT, Op0, Op1);
23691
23692   return OptimizeConditionalInDecrement(N, DAG);
23693 }
23694
23695 static SDValue PerformSubCombine(SDNode *N, SelectionDAG &DAG,
23696                                  const X86Subtarget *Subtarget) {
23697   SDValue Op0 = N->getOperand(0);
23698   SDValue Op1 = N->getOperand(1);
23699
23700   // X86 can't encode an immediate LHS of a sub. See if we can push the
23701   // negation into a preceding instruction.
23702   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op0)) {
23703     // If the RHS of the sub is a XOR with one use and a constant, invert the
23704     // immediate. Then add one to the LHS of the sub so we can turn
23705     // X-Y -> X+~Y+1, saving one register.
23706     if (Op1->hasOneUse() && Op1.getOpcode() == ISD::XOR &&
23707         isa<ConstantSDNode>(Op1.getOperand(1))) {
23708       APInt XorC = cast<ConstantSDNode>(Op1.getOperand(1))->getAPIntValue();
23709       EVT VT = Op0.getValueType();
23710       SDValue NewXor = DAG.getNode(ISD::XOR, SDLoc(Op1), VT,
23711                                    Op1.getOperand(0),
23712                                    DAG.getConstant(~XorC, VT));
23713       return DAG.getNode(ISD::ADD, SDLoc(N), VT, NewXor,
23714                          DAG.getConstant(C->getAPIntValue()+1, VT));
23715     }
23716   }
23717
23718   // Try to synthesize horizontal adds from adds of shuffles.
23719   EVT VT = N->getValueType(0);
23720   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
23721        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
23722       isHorizontalBinOp(Op0, Op1, true))
23723     return DAG.getNode(X86ISD::HSUB, SDLoc(N), VT, Op0, Op1);
23724
23725   return OptimizeConditionalInDecrement(N, DAG);
23726 }
23727
23728 /// performVZEXTCombine - Performs build vector combines
23729 static SDValue performVZEXTCombine(SDNode *N, SelectionDAG &DAG,
23730                                    TargetLowering::DAGCombinerInfo &DCI,
23731                                    const X86Subtarget *Subtarget) {
23732   SDLoc DL(N);
23733   MVT VT = N->getSimpleValueType(0);
23734   SDValue Op = N->getOperand(0);
23735   MVT OpVT = Op.getSimpleValueType();
23736   MVT OpEltVT = OpVT.getVectorElementType();
23737   unsigned InputBits = OpEltVT.getSizeInBits() * VT.getVectorNumElements();
23738
23739   // (vzext (bitcast (vzext (x)) -> (vzext x)
23740   SDValue V = Op;
23741   while (V.getOpcode() == ISD::BITCAST)
23742     V = V.getOperand(0);
23743
23744   if (V != Op && V.getOpcode() == X86ISD::VZEXT) {
23745     MVT InnerVT = V.getSimpleValueType();
23746     MVT InnerEltVT = InnerVT.getVectorElementType();
23747
23748     // If the element sizes match exactly, we can just do one larger vzext. This
23749     // is always an exact type match as vzext operates on integer types.
23750     if (OpEltVT == InnerEltVT) {
23751       assert(OpVT == InnerVT && "Types must match for vzext!");
23752       return DAG.getNode(X86ISD::VZEXT, DL, VT, V.getOperand(0));
23753     }
23754
23755     // The only other way we can combine them is if only a single element of the
23756     // inner vzext is used in the input to the outer vzext.
23757     if (InnerEltVT.getSizeInBits() < InputBits)
23758       return SDValue();
23759
23760     // In this case, the inner vzext is completely dead because we're going to
23761     // only look at bits inside of the low element. Just do the outer vzext on
23762     // a bitcast of the input to the inner.
23763     return DAG.getNode(X86ISD::VZEXT, DL, VT,
23764                        DAG.getNode(ISD::BITCAST, DL, OpVT, V));
23765   }
23766
23767   // Check if we can bypass extracting and re-inserting an element of an input
23768   // vector. Essentialy:
23769   // (bitcast (sclr2vec (ext_vec_elt x))) -> (bitcast x)
23770   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR &&
23771       V.getOperand(0).getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
23772       V.getOperand(0).getSimpleValueType().getSizeInBits() == InputBits) {
23773     SDValue ExtractedV = V.getOperand(0);
23774     SDValue OrigV = ExtractedV.getOperand(0);
23775     if (auto *ExtractIdx = dyn_cast<ConstantSDNode>(ExtractedV.getOperand(1)))
23776       if (ExtractIdx->getZExtValue() == 0) {
23777         MVT OrigVT = OrigV.getSimpleValueType();
23778         // Extract a subvector if necessary...
23779         if (OrigVT.getSizeInBits() > OpVT.getSizeInBits()) {
23780           int Ratio = OrigVT.getSizeInBits() / OpVT.getSizeInBits();
23781           OrigVT = MVT::getVectorVT(OrigVT.getVectorElementType(),
23782                                     OrigVT.getVectorNumElements() / Ratio);
23783           OrigV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigVT, OrigV,
23784                               DAG.getIntPtrConstant(0));
23785         }
23786         Op = DAG.getNode(ISD::BITCAST, DL, OpVT, OrigV);
23787         return DAG.getNode(X86ISD::VZEXT, DL, VT, Op);
23788       }
23789   }
23790
23791   return SDValue();
23792 }
23793
23794 SDValue X86TargetLowering::PerformDAGCombine(SDNode *N,
23795                                              DAGCombinerInfo &DCI) const {
23796   SelectionDAG &DAG = DCI.DAG;
23797   switch (N->getOpcode()) {
23798   default: break;
23799   case ISD::EXTRACT_VECTOR_ELT:
23800     return PerformEXTRACT_VECTOR_ELTCombine(N, DAG, DCI);
23801   case ISD::VSELECT:
23802   case ISD::SELECT:
23803   case X86ISD::SHRUNKBLEND:
23804     return PerformSELECTCombine(N, DAG, DCI, Subtarget);
23805   case ISD::BITCAST:        return PerformBITCASTCombine(N, DAG);
23806   case X86ISD::CMOV:        return PerformCMOVCombine(N, DAG, DCI, Subtarget);
23807   case ISD::ADD:            return PerformAddCombine(N, DAG, Subtarget);
23808   case ISD::SUB:            return PerformSubCombine(N, DAG, Subtarget);
23809   case X86ISD::ADC:         return PerformADCCombine(N, DAG, DCI);
23810   case ISD::MUL:            return PerformMulCombine(N, DAG, DCI);
23811   case ISD::SHL:
23812   case ISD::SRA:
23813   case ISD::SRL:            return PerformShiftCombine(N, DAG, DCI, Subtarget);
23814   case ISD::AND:            return PerformAndCombine(N, DAG, DCI, Subtarget);
23815   case ISD::OR:             return PerformOrCombine(N, DAG, DCI, Subtarget);
23816   case ISD::XOR:            return PerformXorCombine(N, DAG, DCI, Subtarget);
23817   case ISD::LOAD:           return PerformLOADCombine(N, DAG, DCI, Subtarget);
23818   case ISD::MLOAD:          return PerformMLOADCombine(N, DAG, DCI, Subtarget);
23819   case ISD::STORE:          return PerformSTORECombine(N, DAG, Subtarget);
23820   case ISD::MSTORE:         return PerformMSTORECombine(N, DAG, Subtarget);
23821   case ISD::SINT_TO_FP:     return PerformSINT_TO_FPCombine(N, DAG, Subtarget);
23822   case ISD::FADD:           return PerformFADDCombine(N, DAG, Subtarget);
23823   case ISD::FSUB:           return PerformFSUBCombine(N, DAG, Subtarget);
23824   case X86ISD::FXOR:
23825   case X86ISD::FOR:         return PerformFORCombine(N, DAG);
23826   case X86ISD::FMIN:
23827   case X86ISD::FMAX:        return PerformFMinFMaxCombine(N, DAG);
23828   case X86ISD::FAND:        return PerformFANDCombine(N, DAG);
23829   case X86ISD::FANDN:       return PerformFANDNCombine(N, DAG);
23830   case X86ISD::BT:          return PerformBTCombine(N, DAG, DCI);
23831   case X86ISD::VZEXT_MOVL:  return PerformVZEXT_MOVLCombine(N, DAG);
23832   case ISD::ANY_EXTEND:
23833   case ISD::ZERO_EXTEND:    return PerformZExtCombine(N, DAG, DCI, Subtarget);
23834   case ISD::SIGN_EXTEND:    return PerformSExtCombine(N, DAG, DCI, Subtarget);
23835   case ISD::SIGN_EXTEND_INREG:
23836     return PerformSIGN_EXTEND_INREGCombine(N, DAG, Subtarget);
23837   case ISD::TRUNCATE:       return PerformTruncateCombine(N, DAG,DCI,Subtarget);
23838   case ISD::SETCC:          return PerformISDSETCCCombine(N, DAG, Subtarget);
23839   case X86ISD::SETCC:       return PerformSETCCCombine(N, DAG, DCI, Subtarget);
23840   case X86ISD::BRCOND:      return PerformBrCondCombine(N, DAG, DCI, Subtarget);
23841   case X86ISD::VZEXT:       return performVZEXTCombine(N, DAG, DCI, Subtarget);
23842   case X86ISD::SHUFP:       // Handle all target specific shuffles
23843   case X86ISD::PALIGNR:
23844   case X86ISD::UNPCKH:
23845   case X86ISD::UNPCKL:
23846   case X86ISD::MOVHLPS:
23847   case X86ISD::MOVLHPS:
23848   case X86ISD::PSHUFB:
23849   case X86ISD::PSHUFD:
23850   case X86ISD::PSHUFHW:
23851   case X86ISD::PSHUFLW:
23852   case X86ISD::MOVSS:
23853   case X86ISD::MOVSD:
23854   case X86ISD::VPERMILPI:
23855   case X86ISD::VPERM2X128:
23856   case ISD::VECTOR_SHUFFLE: return PerformShuffleCombine(N, DAG, DCI,Subtarget);
23857   case ISD::FMA:            return PerformFMACombine(N, DAG, Subtarget);
23858   case ISD::INTRINSIC_WO_CHAIN:
23859     return PerformINTRINSIC_WO_CHAINCombine(N, DAG, Subtarget);
23860   case X86ISD::INSERTPS: {
23861     if (getTargetMachine().getOptLevel() > CodeGenOpt::None)
23862       return PerformINSERTPSCombine(N, DAG, Subtarget);
23863     break;
23864   }
23865   case X86ISD::BLENDI:    return PerformBLENDICombine(N, DAG);
23866   case ISD::BUILD_VECTOR: return PerformBUILD_VECTORCombine(N, DAG, Subtarget);
23867   }
23868
23869   return SDValue();
23870 }
23871
23872 /// isTypeDesirableForOp - Return true if the target has native support for
23873 /// the specified value type and it is 'desirable' to use the type for the
23874 /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
23875 /// instruction encodings are longer and some i16 instructions are slow.
23876 bool X86TargetLowering::isTypeDesirableForOp(unsigned Opc, EVT VT) const {
23877   if (!isTypeLegal(VT))
23878     return false;
23879   if (VT != MVT::i16)
23880     return true;
23881
23882   switch (Opc) {
23883   default:
23884     return true;
23885   case ISD::LOAD:
23886   case ISD::SIGN_EXTEND:
23887   case ISD::ZERO_EXTEND:
23888   case ISD::ANY_EXTEND:
23889   case ISD::SHL:
23890   case ISD::SRL:
23891   case ISD::SUB:
23892   case ISD::ADD:
23893   case ISD::MUL:
23894   case ISD::AND:
23895   case ISD::OR:
23896   case ISD::XOR:
23897     return false;
23898   }
23899 }
23900
23901 /// IsDesirableToPromoteOp - This method query the target whether it is
23902 /// beneficial for dag combiner to promote the specified node. If true, it
23903 /// should return the desired promotion type by reference.
23904 bool X86TargetLowering::IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
23905   EVT VT = Op.getValueType();
23906   if (VT != MVT::i16)
23907     return false;
23908
23909   bool Promote = false;
23910   bool Commute = false;
23911   switch (Op.getOpcode()) {
23912   default: break;
23913   case ISD::LOAD: {
23914     LoadSDNode *LD = cast<LoadSDNode>(Op);
23915     // If the non-extending load has a single use and it's not live out, then it
23916     // might be folded.
23917     if (LD->getExtensionType() == ISD::NON_EXTLOAD /*&&
23918                                                      Op.hasOneUse()*/) {
23919       for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
23920              UE = Op.getNode()->use_end(); UI != UE; ++UI) {
23921         // The only case where we'd want to promote LOAD (rather then it being
23922         // promoted as an operand is when it's only use is liveout.
23923         if (UI->getOpcode() != ISD::CopyToReg)
23924           return false;
23925       }
23926     }
23927     Promote = true;
23928     break;
23929   }
23930   case ISD::SIGN_EXTEND:
23931   case ISD::ZERO_EXTEND:
23932   case ISD::ANY_EXTEND:
23933     Promote = true;
23934     break;
23935   case ISD::SHL:
23936   case ISD::SRL: {
23937     SDValue N0 = Op.getOperand(0);
23938     // Look out for (store (shl (load), x)).
23939     if (MayFoldLoad(N0) && MayFoldIntoStore(Op))
23940       return false;
23941     Promote = true;
23942     break;
23943   }
23944   case ISD::ADD:
23945   case ISD::MUL:
23946   case ISD::AND:
23947   case ISD::OR:
23948   case ISD::XOR:
23949     Commute = true;
23950     // fallthrough
23951   case ISD::SUB: {
23952     SDValue N0 = Op.getOperand(0);
23953     SDValue N1 = Op.getOperand(1);
23954     if (!Commute && MayFoldLoad(N1))
23955       return false;
23956     // Avoid disabling potential load folding opportunities.
23957     if (MayFoldLoad(N0) && (!isa<ConstantSDNode>(N1) || MayFoldIntoStore(Op)))
23958       return false;
23959     if (MayFoldLoad(N1) && (!isa<ConstantSDNode>(N0) || MayFoldIntoStore(Op)))
23960       return false;
23961     Promote = true;
23962   }
23963   }
23964
23965   PVT = MVT::i32;
23966   return Promote;
23967 }
23968
23969 //===----------------------------------------------------------------------===//
23970 //                           X86 Inline Assembly Support
23971 //===----------------------------------------------------------------------===//
23972
23973 // Helper to match a string separated by whitespace.
23974 static bool matchAsm(StringRef S, ArrayRef<const char *> Pieces) {
23975   S = S.substr(S.find_first_not_of(" \t")); // Skip leading whitespace.
23976
23977   for (StringRef Piece : Pieces) {
23978     if (!S.startswith(Piece)) // Check if the piece matches.
23979       return false;
23980
23981     S = S.substr(Piece.size());
23982     StringRef::size_type Pos = S.find_first_not_of(" \t");
23983     if (Pos == 0) // We matched a prefix.
23984       return false;
23985
23986     S = S.substr(Pos);
23987   }
23988
23989   return S.empty();
23990 }
23991
23992 static bool clobbersFlagRegisters(const SmallVector<StringRef, 4> &AsmPieces) {
23993
23994   if (AsmPieces.size() == 3 || AsmPieces.size() == 4) {
23995     if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{cc}") &&
23996         std::count(AsmPieces.begin(), AsmPieces.end(), "~{flags}") &&
23997         std::count(AsmPieces.begin(), AsmPieces.end(), "~{fpsr}")) {
23998
23999       if (AsmPieces.size() == 3)
24000         return true;
24001       else if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{dirflag}"))
24002         return true;
24003     }
24004   }
24005   return false;
24006 }
24007
24008 bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const {
24009   InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
24010
24011   std::string AsmStr = IA->getAsmString();
24012
24013   IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
24014   if (!Ty || Ty->getBitWidth() % 16 != 0)
24015     return false;
24016
24017   // TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
24018   SmallVector<StringRef, 4> AsmPieces;
24019   SplitString(AsmStr, AsmPieces, ";\n");
24020
24021   switch (AsmPieces.size()) {
24022   default: return false;
24023   case 1:
24024     // FIXME: this should verify that we are targeting a 486 or better.  If not,
24025     // we will turn this bswap into something that will be lowered to logical
24026     // ops instead of emitting the bswap asm.  For now, we don't support 486 or
24027     // lower so don't worry about this.
24028     // bswap $0
24029     if (matchAsm(AsmPieces[0], {"bswap", "$0"}) ||
24030         matchAsm(AsmPieces[0], {"bswapl", "$0"}) ||
24031         matchAsm(AsmPieces[0], {"bswapq", "$0"}) ||
24032         matchAsm(AsmPieces[0], {"bswap", "${0:q}"}) ||
24033         matchAsm(AsmPieces[0], {"bswapl", "${0:q}"}) ||
24034         matchAsm(AsmPieces[0], {"bswapq", "${0:q}"})) {
24035       // No need to check constraints, nothing other than the equivalent of
24036       // "=r,0" would be valid here.
24037       return IntrinsicLowering::LowerToByteSwap(CI);
24038     }
24039
24040     // rorw $$8, ${0:w}  -->  llvm.bswap.i16
24041     if (CI->getType()->isIntegerTy(16) &&
24042         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
24043         (matchAsm(AsmPieces[0], {"rorw", "$$8,", "${0:w}"}) ||
24044          matchAsm(AsmPieces[0], {"rolw", "$$8,", "${0:w}"}))) {
24045       AsmPieces.clear();
24046       const std::string &ConstraintsStr = IA->getConstraintString();
24047       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
24048       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
24049       if (clobbersFlagRegisters(AsmPieces))
24050         return IntrinsicLowering::LowerToByteSwap(CI);
24051     }
24052     break;
24053   case 3:
24054     if (CI->getType()->isIntegerTy(32) &&
24055         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
24056         matchAsm(AsmPieces[0], {"rorw", "$$8,", "${0:w}"}) &&
24057         matchAsm(AsmPieces[1], {"rorl", "$$16,", "$0"}) &&
24058         matchAsm(AsmPieces[2], {"rorw", "$$8,", "${0:w}"})) {
24059       AsmPieces.clear();
24060       const std::string &ConstraintsStr = IA->getConstraintString();
24061       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
24062       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
24063       if (clobbersFlagRegisters(AsmPieces))
24064         return IntrinsicLowering::LowerToByteSwap(CI);
24065     }
24066
24067     if (CI->getType()->isIntegerTy(64)) {
24068       InlineAsm::ConstraintInfoVector Constraints = IA->ParseConstraints();
24069       if (Constraints.size() >= 2 &&
24070           Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
24071           Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {
24072         // bswap %eax / bswap %edx / xchgl %eax, %edx  -> llvm.bswap.i64
24073         if (matchAsm(AsmPieces[0], {"bswap", "%eax"}) &&
24074             matchAsm(AsmPieces[1], {"bswap", "%edx"}) &&
24075             matchAsm(AsmPieces[2], {"xchgl", "%eax,", "%edx"}))
24076           return IntrinsicLowering::LowerToByteSwap(CI);
24077       }
24078     }
24079     break;
24080   }
24081   return false;
24082 }
24083
24084 /// getConstraintType - Given a constraint letter, return the type of
24085 /// constraint it is for this target.
24086 X86TargetLowering::ConstraintType
24087 X86TargetLowering::getConstraintType(const std::string &Constraint) const {
24088   if (Constraint.size() == 1) {
24089     switch (Constraint[0]) {
24090     case 'R':
24091     case 'q':
24092     case 'Q':
24093     case 'f':
24094     case 't':
24095     case 'u':
24096     case 'y':
24097     case 'x':
24098     case 'Y':
24099     case 'l':
24100       return C_RegisterClass;
24101     case 'a':
24102     case 'b':
24103     case 'c':
24104     case 'd':
24105     case 'S':
24106     case 'D':
24107     case 'A':
24108       return C_Register;
24109     case 'I':
24110     case 'J':
24111     case 'K':
24112     case 'L':
24113     case 'M':
24114     case 'N':
24115     case 'G':
24116     case 'C':
24117     case 'e':
24118     case 'Z':
24119       return C_Other;
24120     default:
24121       break;
24122     }
24123   }
24124   return TargetLowering::getConstraintType(Constraint);
24125 }
24126
24127 /// Examine constraint type and operand type and determine a weight value.
24128 /// This object must already have been set up with the operand type
24129 /// and the current alternative constraint selected.
24130 TargetLowering::ConstraintWeight
24131   X86TargetLowering::getSingleConstraintMatchWeight(
24132     AsmOperandInfo &info, const char *constraint) const {
24133   ConstraintWeight weight = CW_Invalid;
24134   Value *CallOperandVal = info.CallOperandVal;
24135     // If we don't have a value, we can't do a match,
24136     // but allow it at the lowest weight.
24137   if (!CallOperandVal)
24138     return CW_Default;
24139   Type *type = CallOperandVal->getType();
24140   // Look at the constraint type.
24141   switch (*constraint) {
24142   default:
24143     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
24144   case 'R':
24145   case 'q':
24146   case 'Q':
24147   case 'a':
24148   case 'b':
24149   case 'c':
24150   case 'd':
24151   case 'S':
24152   case 'D':
24153   case 'A':
24154     if (CallOperandVal->getType()->isIntegerTy())
24155       weight = CW_SpecificReg;
24156     break;
24157   case 'f':
24158   case 't':
24159   case 'u':
24160     if (type->isFloatingPointTy())
24161       weight = CW_SpecificReg;
24162     break;
24163   case 'y':
24164     if (type->isX86_MMXTy() && Subtarget->hasMMX())
24165       weight = CW_SpecificReg;
24166     break;
24167   case 'x':
24168   case 'Y':
24169     if (((type->getPrimitiveSizeInBits() == 128) && Subtarget->hasSSE1()) ||
24170         ((type->getPrimitiveSizeInBits() == 256) && Subtarget->hasFp256()))
24171       weight = CW_Register;
24172     break;
24173   case 'I':
24174     if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
24175       if (C->getZExtValue() <= 31)
24176         weight = CW_Constant;
24177     }
24178     break;
24179   case 'J':
24180     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
24181       if (C->getZExtValue() <= 63)
24182         weight = CW_Constant;
24183     }
24184     break;
24185   case 'K':
24186     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
24187       if ((C->getSExtValue() >= -0x80) && (C->getSExtValue() <= 0x7f))
24188         weight = CW_Constant;
24189     }
24190     break;
24191   case 'L':
24192     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
24193       if ((C->getZExtValue() == 0xff) || (C->getZExtValue() == 0xffff))
24194         weight = CW_Constant;
24195     }
24196     break;
24197   case 'M':
24198     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
24199       if (C->getZExtValue() <= 3)
24200         weight = CW_Constant;
24201     }
24202     break;
24203   case 'N':
24204     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
24205       if (C->getZExtValue() <= 0xff)
24206         weight = CW_Constant;
24207     }
24208     break;
24209   case 'G':
24210   case 'C':
24211     if (dyn_cast<ConstantFP>(CallOperandVal)) {
24212       weight = CW_Constant;
24213     }
24214     break;
24215   case 'e':
24216     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
24217       if ((C->getSExtValue() >= -0x80000000LL) &&
24218           (C->getSExtValue() <= 0x7fffffffLL))
24219         weight = CW_Constant;
24220     }
24221     break;
24222   case 'Z':
24223     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
24224       if (C->getZExtValue() <= 0xffffffff)
24225         weight = CW_Constant;
24226     }
24227     break;
24228   }
24229   return weight;
24230 }
24231
24232 /// LowerXConstraint - try to replace an X constraint, which matches anything,
24233 /// with another that has more specific requirements based on the type of the
24234 /// corresponding operand.
24235 const char *X86TargetLowering::
24236 LowerXConstraint(EVT ConstraintVT) const {
24237   // FP X constraints get lowered to SSE1/2 registers if available, otherwise
24238   // 'f' like normal targets.
24239   if (ConstraintVT.isFloatingPoint()) {
24240     if (Subtarget->hasSSE2())
24241       return "Y";
24242     if (Subtarget->hasSSE1())
24243       return "x";
24244   }
24245
24246   return TargetLowering::LowerXConstraint(ConstraintVT);
24247 }
24248
24249 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
24250 /// vector.  If it is invalid, don't add anything to Ops.
24251 void X86TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
24252                                                      std::string &Constraint,
24253                                                      std::vector<SDValue>&Ops,
24254                                                      SelectionDAG &DAG) const {
24255   SDValue Result;
24256
24257   // Only support length 1 constraints for now.
24258   if (Constraint.length() > 1) return;
24259
24260   char ConstraintLetter = Constraint[0];
24261   switch (ConstraintLetter) {
24262   default: break;
24263   case 'I':
24264     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24265       if (C->getZExtValue() <= 31) {
24266         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
24267         break;
24268       }
24269     }
24270     return;
24271   case 'J':
24272     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24273       if (C->getZExtValue() <= 63) {
24274         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
24275         break;
24276       }
24277     }
24278     return;
24279   case 'K':
24280     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24281       if (isInt<8>(C->getSExtValue())) {
24282         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
24283         break;
24284       }
24285     }
24286     return;
24287   case 'L':
24288     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24289       if (C->getZExtValue() == 0xff || C->getZExtValue() == 0xffff ||
24290           (Subtarget->is64Bit() && C->getZExtValue() == 0xffffffff)) {
24291         Result = DAG.getTargetConstant(C->getSExtValue(), Op.getValueType());
24292         break;
24293       }
24294     }
24295     return;
24296   case 'M':
24297     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24298       if (C->getZExtValue() <= 3) {
24299         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
24300         break;
24301       }
24302     }
24303     return;
24304   case 'N':
24305     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24306       if (C->getZExtValue() <= 255) {
24307         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
24308         break;
24309       }
24310     }
24311     return;
24312   case 'O':
24313     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24314       if (C->getZExtValue() <= 127) {
24315         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
24316         break;
24317       }
24318     }
24319     return;
24320   case 'e': {
24321     // 32-bit signed value
24322     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24323       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
24324                                            C->getSExtValue())) {
24325         // Widen to 64 bits here to get it sign extended.
24326         Result = DAG.getTargetConstant(C->getSExtValue(), MVT::i64);
24327         break;
24328       }
24329     // FIXME gcc accepts some relocatable values here too, but only in certain
24330     // memory models; it's complicated.
24331     }
24332     return;
24333   }
24334   case 'Z': {
24335     // 32-bit unsigned value
24336     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
24337       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
24338                                            C->getZExtValue())) {
24339         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
24340         break;
24341       }
24342     }
24343     // FIXME gcc accepts some relocatable values here too, but only in certain
24344     // memory models; it's complicated.
24345     return;
24346   }
24347   case 'i': {
24348     // Literal immediates are always ok.
24349     if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op)) {
24350       // Widen to 64 bits here to get it sign extended.
24351       Result = DAG.getTargetConstant(CST->getSExtValue(), MVT::i64);
24352       break;
24353     }
24354
24355     // In any sort of PIC mode addresses need to be computed at runtime by
24356     // adding in a register or some sort of table lookup.  These can't
24357     // be used as immediates.
24358     if (Subtarget->isPICStyleGOT() || Subtarget->isPICStyleStubPIC())
24359       return;
24360
24361     // If we are in non-pic codegen mode, we allow the address of a global (with
24362     // an optional displacement) to be used with 'i'.
24363     GlobalAddressSDNode *GA = nullptr;
24364     int64_t Offset = 0;
24365
24366     // Match either (GA), (GA+C), (GA+C1+C2), etc.
24367     while (1) {
24368       if ((GA = dyn_cast<GlobalAddressSDNode>(Op))) {
24369         Offset += GA->getOffset();
24370         break;
24371       } else if (Op.getOpcode() == ISD::ADD) {
24372         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
24373           Offset += C->getZExtValue();
24374           Op = Op.getOperand(0);
24375           continue;
24376         }
24377       } else if (Op.getOpcode() == ISD::SUB) {
24378         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
24379           Offset += -C->getZExtValue();
24380           Op = Op.getOperand(0);
24381           continue;
24382         }
24383       }
24384
24385       // Otherwise, this isn't something we can handle, reject it.
24386       return;
24387     }
24388
24389     const GlobalValue *GV = GA->getGlobal();
24390     // If we require an extra load to get this address, as in PIC mode, we
24391     // can't accept it.
24392     if (isGlobalStubReference(
24393             Subtarget->ClassifyGlobalReference(GV, DAG.getTarget())))
24394       return;
24395
24396     Result = DAG.getTargetGlobalAddress(GV, SDLoc(Op),
24397                                         GA->getValueType(0), Offset);
24398     break;
24399   }
24400   }
24401
24402   if (Result.getNode()) {
24403     Ops.push_back(Result);
24404     return;
24405   }
24406   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
24407 }
24408
24409 std::pair<unsigned, const TargetRegisterClass *>
24410 X86TargetLowering::getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
24411                                                 const std::string &Constraint,
24412                                                 MVT VT) const {
24413   // First, see if this is a constraint that directly corresponds to an LLVM
24414   // register class.
24415   if (Constraint.size() == 1) {
24416     // GCC Constraint Letters
24417     switch (Constraint[0]) {
24418     default: break;
24419       // TODO: Slight differences here in allocation order and leaving
24420       // RIP in the class. Do they matter any more here than they do
24421       // in the normal allocation?
24422     case 'q':   // GENERAL_REGS in 64-bit mode, Q_REGS in 32-bit mode.
24423       if (Subtarget->is64Bit()) {
24424         if (VT == MVT::i32 || VT == MVT::f32)
24425           return std::make_pair(0U, &X86::GR32RegClass);
24426         if (VT == MVT::i16)
24427           return std::make_pair(0U, &X86::GR16RegClass);
24428         if (VT == MVT::i8 || VT == MVT::i1)
24429           return std::make_pair(0U, &X86::GR8RegClass);
24430         if (VT == MVT::i64 || VT == MVT::f64)
24431           return std::make_pair(0U, &X86::GR64RegClass);
24432         break;
24433       }
24434       // 32-bit fallthrough
24435     case 'Q':   // Q_REGS
24436       if (VT == MVT::i32 || VT == MVT::f32)
24437         return std::make_pair(0U, &X86::GR32_ABCDRegClass);
24438       if (VT == MVT::i16)
24439         return std::make_pair(0U, &X86::GR16_ABCDRegClass);
24440       if (VT == MVT::i8 || VT == MVT::i1)
24441         return std::make_pair(0U, &X86::GR8_ABCD_LRegClass);
24442       if (VT == MVT::i64)
24443         return std::make_pair(0U, &X86::GR64_ABCDRegClass);
24444       break;
24445     case 'r':   // GENERAL_REGS
24446     case 'l':   // INDEX_REGS
24447       if (VT == MVT::i8 || VT == MVT::i1)
24448         return std::make_pair(0U, &X86::GR8RegClass);
24449       if (VT == MVT::i16)
24450         return std::make_pair(0U, &X86::GR16RegClass);
24451       if (VT == MVT::i32 || VT == MVT::f32 || !Subtarget->is64Bit())
24452         return std::make_pair(0U, &X86::GR32RegClass);
24453       return std::make_pair(0U, &X86::GR64RegClass);
24454     case 'R':   // LEGACY_REGS
24455       if (VT == MVT::i8 || VT == MVT::i1)
24456         return std::make_pair(0U, &X86::GR8_NOREXRegClass);
24457       if (VT == MVT::i16)
24458         return std::make_pair(0U, &X86::GR16_NOREXRegClass);
24459       if (VT == MVT::i32 || !Subtarget->is64Bit())
24460         return std::make_pair(0U, &X86::GR32_NOREXRegClass);
24461       return std::make_pair(0U, &X86::GR64_NOREXRegClass);
24462     case 'f':  // FP Stack registers.
24463       // If SSE is enabled for this VT, use f80 to ensure the isel moves the
24464       // value to the correct fpstack register class.
24465       if (VT == MVT::f32 && !isScalarFPTypeInSSEReg(VT))
24466         return std::make_pair(0U, &X86::RFP32RegClass);
24467       if (VT == MVT::f64 && !isScalarFPTypeInSSEReg(VT))
24468         return std::make_pair(0U, &X86::RFP64RegClass);
24469       return std::make_pair(0U, &X86::RFP80RegClass);
24470     case 'y':   // MMX_REGS if MMX allowed.
24471       if (!Subtarget->hasMMX()) break;
24472       return std::make_pair(0U, &X86::VR64RegClass);
24473     case 'Y':   // SSE_REGS if SSE2 allowed
24474       if (!Subtarget->hasSSE2()) break;
24475       // FALL THROUGH.
24476     case 'x':   // SSE_REGS if SSE1 allowed or AVX_REGS if AVX allowed
24477       if (!Subtarget->hasSSE1()) break;
24478
24479       switch (VT.SimpleTy) {
24480       default: break;
24481       // Scalar SSE types.
24482       case MVT::f32:
24483       case MVT::i32:
24484         return std::make_pair(0U, &X86::FR32RegClass);
24485       case MVT::f64:
24486       case MVT::i64:
24487         return std::make_pair(0U, &X86::FR64RegClass);
24488       // Vector types.
24489       case MVT::v16i8:
24490       case MVT::v8i16:
24491       case MVT::v4i32:
24492       case MVT::v2i64:
24493       case MVT::v4f32:
24494       case MVT::v2f64:
24495         return std::make_pair(0U, &X86::VR128RegClass);
24496       // AVX types.
24497       case MVT::v32i8:
24498       case MVT::v16i16:
24499       case MVT::v8i32:
24500       case MVT::v4i64:
24501       case MVT::v8f32:
24502       case MVT::v4f64:
24503         return std::make_pair(0U, &X86::VR256RegClass);
24504       case MVT::v8f64:
24505       case MVT::v16f32:
24506       case MVT::v16i32:
24507       case MVT::v8i64:
24508         return std::make_pair(0U, &X86::VR512RegClass);
24509       }
24510       break;
24511     }
24512   }
24513
24514   // Use the default implementation in TargetLowering to convert the register
24515   // constraint into a member of a register class.
24516   std::pair<unsigned, const TargetRegisterClass*> Res;
24517   Res = TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
24518
24519   // Not found as a standard register?
24520   if (!Res.second) {
24521     // Map st(0) -> st(7) -> ST0
24522     if (Constraint.size() == 7 && Constraint[0] == '{' &&
24523         tolower(Constraint[1]) == 's' &&
24524         tolower(Constraint[2]) == 't' &&
24525         Constraint[3] == '(' &&
24526         (Constraint[4] >= '0' && Constraint[4] <= '7') &&
24527         Constraint[5] == ')' &&
24528         Constraint[6] == '}') {
24529
24530       Res.first = X86::FP0+Constraint[4]-'0';
24531       Res.second = &X86::RFP80RegClass;
24532       return Res;
24533     }
24534
24535     // GCC allows "st(0)" to be called just plain "st".
24536     if (StringRef("{st}").equals_lower(Constraint)) {
24537       Res.first = X86::FP0;
24538       Res.second = &X86::RFP80RegClass;
24539       return Res;
24540     }
24541
24542     // flags -> EFLAGS
24543     if (StringRef("{flags}").equals_lower(Constraint)) {
24544       Res.first = X86::EFLAGS;
24545       Res.second = &X86::CCRRegClass;
24546       return Res;
24547     }
24548
24549     // 'A' means EAX + EDX.
24550     if (Constraint == "A") {
24551       Res.first = X86::EAX;
24552       Res.second = &X86::GR32_ADRegClass;
24553       return Res;
24554     }
24555     return Res;
24556   }
24557
24558   // Otherwise, check to see if this is a register class of the wrong value
24559   // type.  For example, we want to map "{ax},i32" -> {eax}, we don't want it to
24560   // turn into {ax},{dx}.
24561   if (Res.second->hasType(VT))
24562     return Res;   // Correct type already, nothing to do.
24563
24564   // All of the single-register GCC register classes map their values onto
24565   // 16-bit register pieces "ax","dx","cx","bx","si","di","bp","sp".  If we
24566   // really want an 8-bit or 32-bit register, map to the appropriate register
24567   // class and return the appropriate register.
24568   if (Res.second == &X86::GR16RegClass) {
24569     if (VT == MVT::i8 || VT == MVT::i1) {
24570       unsigned DestReg = 0;
24571       switch (Res.first) {
24572       default: break;
24573       case X86::AX: DestReg = X86::AL; break;
24574       case X86::DX: DestReg = X86::DL; break;
24575       case X86::CX: DestReg = X86::CL; break;
24576       case X86::BX: DestReg = X86::BL; break;
24577       }
24578       if (DestReg) {
24579         Res.first = DestReg;
24580         Res.second = &X86::GR8RegClass;
24581       }
24582     } else if (VT == MVT::i32 || VT == MVT::f32) {
24583       unsigned DestReg = 0;
24584       switch (Res.first) {
24585       default: break;
24586       case X86::AX: DestReg = X86::EAX; break;
24587       case X86::DX: DestReg = X86::EDX; break;
24588       case X86::CX: DestReg = X86::ECX; break;
24589       case X86::BX: DestReg = X86::EBX; break;
24590       case X86::SI: DestReg = X86::ESI; break;
24591       case X86::DI: DestReg = X86::EDI; break;
24592       case X86::BP: DestReg = X86::EBP; break;
24593       case X86::SP: DestReg = X86::ESP; break;
24594       }
24595       if (DestReg) {
24596         Res.first = DestReg;
24597         Res.second = &X86::GR32RegClass;
24598       }
24599     } else if (VT == MVT::i64 || VT == MVT::f64) {
24600       unsigned DestReg = 0;
24601       switch (Res.first) {
24602       default: break;
24603       case X86::AX: DestReg = X86::RAX; break;
24604       case X86::DX: DestReg = X86::RDX; break;
24605       case X86::CX: DestReg = X86::RCX; break;
24606       case X86::BX: DestReg = X86::RBX; break;
24607       case X86::SI: DestReg = X86::RSI; break;
24608       case X86::DI: DestReg = X86::RDI; break;
24609       case X86::BP: DestReg = X86::RBP; break;
24610       case X86::SP: DestReg = X86::RSP; break;
24611       }
24612       if (DestReg) {
24613         Res.first = DestReg;
24614         Res.second = &X86::GR64RegClass;
24615       }
24616     }
24617   } else if (Res.second == &X86::FR32RegClass ||
24618              Res.second == &X86::FR64RegClass ||
24619              Res.second == &X86::VR128RegClass ||
24620              Res.second == &X86::VR256RegClass ||
24621              Res.second == &X86::FR32XRegClass ||
24622              Res.second == &X86::FR64XRegClass ||
24623              Res.second == &X86::VR128XRegClass ||
24624              Res.second == &X86::VR256XRegClass ||
24625              Res.second == &X86::VR512RegClass) {
24626     // Handle references to XMM physical registers that got mapped into the
24627     // wrong class.  This can happen with constraints like {xmm0} where the
24628     // target independent register mapper will just pick the first match it can
24629     // find, ignoring the required type.
24630
24631     if (VT == MVT::f32 || VT == MVT::i32)
24632       Res.second = &X86::FR32RegClass;
24633     else if (VT == MVT::f64 || VT == MVT::i64)
24634       Res.second = &X86::FR64RegClass;
24635     else if (X86::VR128RegClass.hasType(VT))
24636       Res.second = &X86::VR128RegClass;
24637     else if (X86::VR256RegClass.hasType(VT))
24638       Res.second = &X86::VR256RegClass;
24639     else if (X86::VR512RegClass.hasType(VT))
24640       Res.second = &X86::VR512RegClass;
24641   }
24642
24643   return Res;
24644 }
24645
24646 int X86TargetLowering::getScalingFactorCost(const AddrMode &AM,
24647                                             Type *Ty) const {
24648   // Scaling factors are not free at all.
24649   // An indexed folded instruction, i.e., inst (reg1, reg2, scale),
24650   // will take 2 allocations in the out of order engine instead of 1
24651   // for plain addressing mode, i.e. inst (reg1).
24652   // E.g.,
24653   // vaddps (%rsi,%drx), %ymm0, %ymm1
24654   // Requires two allocations (one for the load, one for the computation)
24655   // whereas:
24656   // vaddps (%rsi), %ymm0, %ymm1
24657   // Requires just 1 allocation, i.e., freeing allocations for other operations
24658   // and having less micro operations to execute.
24659   //
24660   // For some X86 architectures, this is even worse because for instance for
24661   // stores, the complex addressing mode forces the instruction to use the
24662   // "load" ports instead of the dedicated "store" port.
24663   // E.g., on Haswell:
24664   // vmovaps %ymm1, (%r8, %rdi) can use port 2 or 3.
24665   // vmovaps %ymm1, (%r8) can use port 2, 3, or 7.
24666   if (isLegalAddressingMode(AM, Ty))
24667     // Scale represents reg2 * scale, thus account for 1
24668     // as soon as we use a second register.
24669     return AM.Scale != 0;
24670   return -1;
24671 }
24672
24673 bool X86TargetLowering::isTargetFTOL() const {
24674   return Subtarget->isTargetKnownWindowsMSVC() && !Subtarget->is64Bit();
24675 }