contrib/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

   1 //===- InstCombineCalls.cpp -----------------------------------------------===//
   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 implements the visitCall and visitInvoke functions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "InstCombineInternal.h"
  15 #include "llvm/ADT/APFloat.h"
  16 #include "llvm/ADT/APInt.h"
  17 #include "llvm/ADT/ArrayRef.h"
  18 #include "llvm/ADT/None.h"
  19 #include "llvm/ADT/Statistic.h"
  20 #include "llvm/ADT/STLExtras.h"
  21 #include "llvm/ADT/SmallVector.h"
  22 #include "llvm/ADT/Twine.h"
  23 #include "llvm/Analysis/InstructionSimplify.h"
  24 #include "llvm/Analysis/MemoryBuiltins.h"
  25 #include "llvm/Analysis/ValueTracking.h"
  26 #include "llvm/IR/BasicBlock.h"
  27 #include "llvm/IR/CallSite.h"
  28 #include "llvm/IR/Constant.h"
  29 #include "llvm/IR/DataLayout.h"
  30 #include "llvm/IR/DerivedTypes.h"
  31 #include "llvm/IR/Function.h"
  32 #include "llvm/IR/GlobalVariable.h"
  33 #include "llvm/IR/InstrTypes.h"
  34 #include "llvm/IR/Instruction.h"
  35 #include "llvm/IR/Instructions.h"
  36 #include "llvm/IR/IntrinsicInst.h"
  37 #include "llvm/IR/Intrinsics.h"
  38 #include "llvm/IR/LLVMContext.h"
  39 #include "llvm/IR/Metadata.h"
  40 #include "llvm/IR/PatternMatch.h"
  41 #include "llvm/IR/Statepoint.h"
  42 #include "llvm/IR/Type.h"
  43 #include "llvm/IR/Value.h"
  44 #include "llvm/IR/ValueHandle.h"
  45 #include "llvm/Support/Casting.h"
  46 #include "llvm/Support/Debug.h"
  47 #include "llvm/Support/MathExtras.h"
  48 #include "llvm/Transforms/Utils/Local.h"
  49 #include "llvm/Transforms/Utils/SimplifyLibCalls.h"
  50 #include <algorithm>
  51 #include <cassert>
  52 #include <cstdint>
  53 #include <cstring>
  54 #include <vector>
  55
  56 using namespace llvm;
  57 using namespace PatternMatch;
  58
  59 #define DEBUG_TYPE "instcombine"
  60
  61 STATISTIC(NumSimplified, "Number of library calls simplified");
  62
  63 /// Return the specified type promoted as it would be to pass though a va_arg
  64 /// area.
  65 static Type *getPromotedType(Type *Ty) {
  66   if (IntegerType* ITy = dyn_cast<IntegerType>(Ty)) {
  67     if (ITy->getBitWidth() < 32)
  68       return Type::getInt32Ty(Ty->getContext());
  69   }
  70   return Ty;
  71 }
  72
  73 /// Given an aggregate type which ultimately holds a single scalar element,
  74 /// like {{{type}}} or [1 x type], return type.
  75 static Type *reduceToSingleValueType(Type *T) {
  76   while (!T->isSingleValueType()) {
  77     if (StructType *STy = dyn_cast<StructType>(T)) {
  78       if (STy->getNumElements() == 1)
  79         T = STy->getElementType(0);
  80       else
  81         break;
  82     } else if (ArrayType *ATy = dyn_cast<ArrayType>(T)) {
  83       if (ATy->getNumElements() == 1)
  84         T = ATy->getElementType();
  85       else
  86         break;
  87     } else
  88       break;
  89   }
  90
  91   return T;
  92 }
  93
  94 /// Return a constant boolean vector that has true elements in all positions
  95 /// where the input constant data vector has an element with the sign bit set.
  96 static Constant *getNegativeIsTrueBoolVec(ConstantDataVector *V) {
  97   SmallVector<Constant *, 32> BoolVec;
  98   IntegerType *BoolTy = Type::getInt1Ty(V->getContext());
  99   for (unsigned I = 0, E = V->getNumElements(); I != E; ++I) {
 100     Constant *Elt = V->getElementAsConstant(I);
 101     assert((isa<ConstantInt>(Elt) || isa<ConstantFP>(Elt)) &&
 102            "Unexpected constant data vector element type");
 103     bool Sign = V->getElementType()->isIntegerTy()
 104                     ? cast<ConstantInt>(Elt)->isNegative()
 105                     : cast<ConstantFP>(Elt)->isNegative();
 106     BoolVec.push_back(ConstantInt::get(BoolTy, Sign));
 107   }
 108   return ConstantVector::get(BoolVec);
 109 }
 110
 111 Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) {
 112   unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), DL, MI, &AC, &DT);
 113   unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), DL, MI, &AC, &DT);
 114   unsigned MinAlign = std::min(DstAlign, SrcAlign);
 115   unsigned CopyAlign = MI->getAlignment();
 116
 117   if (CopyAlign < MinAlign) {
 118     MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), MinAlign, false));
 119     return MI;
 120   }
 121
 122   // If MemCpyInst length is 1/2/4/8 bytes then replace memcpy with
 123   // load/store.
 124   ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getArgOperand(2));
 125   if (!MemOpLength) return nullptr;
 126
 127   // Source and destination pointer types are always "i8*" for intrinsic.  See
 128   // if the size is something we can handle with a single primitive load/store.
 129   // A single load+store correctly handles overlapping memory in the memmove
 130   // case.
 131   uint64_t Size = MemOpLength->getLimitedValue();
 132   assert(Size && "0-sized memory transferring should be removed already.");
 133
 134   if (Size > 8 || (Size&(Size-1)))
 135     return nullptr;  // If not 1/2/4/8 bytes, exit.
 136
 137   // Use an integer load+store unless we can find something better.
 138   unsigned SrcAddrSp =
 139     cast<PointerType>(MI->getArgOperand(1)->getType())->getAddressSpace();
 140   unsigned DstAddrSp =
 141     cast<PointerType>(MI->getArgOperand(0)->getType())->getAddressSpace();
 142
 143   IntegerType* IntType = IntegerType::get(MI->getContext(), Size<<3);
 144   Type *NewSrcPtrTy = PointerType::get(IntType, SrcAddrSp);
 145   Type *NewDstPtrTy = PointerType::get(IntType, DstAddrSp);
 146
 147   // Memcpy forces the use of i8* for the source and destination.  That means
 148   // that if you're using memcpy to move one double around, you'll get a cast
 149   // from double* to i8*.  We'd much rather use a double load+store rather than
 150   // an i64 load+store, here because this improves the odds that the source or
 151   // dest address will be promotable.  See if we can find a better type than the
 152   // integer datatype.
 153   Value *StrippedDest = MI->getArgOperand(0)->stripPointerCasts();
 154   MDNode *CopyMD = nullptr;
 155   if (StrippedDest != MI->getArgOperand(0)) {
 156     Type *SrcETy = cast<PointerType>(StrippedDest->getType())
 157                                     ->getElementType();
 158     if (SrcETy->isSized() && DL.getTypeStoreSize(SrcETy) == Size) {
 159       // The SrcETy might be something like {{{double}}} or [1 x double].  Rip
 160       // down through these levels if so.
 161       SrcETy = reduceToSingleValueType(SrcETy);
 162
 163       if (SrcETy->isSingleValueType()) {
 164         NewSrcPtrTy = PointerType::get(SrcETy, SrcAddrSp);
 165         NewDstPtrTy = PointerType::get(SrcETy, DstAddrSp);
 166
 167         // If the memcpy has metadata describing the members, see if we can
 168         // get the TBAA tag describing our copy.
 169         if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa_struct)) {
 170           if (M->getNumOperands() == 3 && M->getOperand(0) &&
 171               mdconst::hasa<ConstantInt>(M->getOperand(0)) &&
 172               mdconst::extract<ConstantInt>(M->getOperand(0))->isNullValue() &&
 173               M->getOperand(1) &&
 174               mdconst::hasa<ConstantInt>(M->getOperand(1)) &&
 175               mdconst::extract<ConstantInt>(M->getOperand(1))->getValue() ==
 176                   Size &&
 177               M->getOperand(2) && isa<MDNode>(M->getOperand(2)))
 178             CopyMD = cast<MDNode>(M->getOperand(2));
 179         }
 180       }
 181     }
 182   }
 183
 184   // If the memcpy/memmove provides better alignment info than we can
 185   // infer, use it.
 186   SrcAlign = std::max(SrcAlign, CopyAlign);
 187   DstAlign = std::max(DstAlign, CopyAlign);
 188
 189   Value *Src = Builder->CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy);
 190   Value *Dest = Builder->CreateBitCast(MI->getArgOperand(0), NewDstPtrTy);
 191   LoadInst *L = Builder->CreateLoad(Src, MI->isVolatile());
 192   L->setAlignment(SrcAlign);
 193   if (CopyMD)
 194     L->setMetadata(LLVMContext::MD_tbaa, CopyMD);
 195   MDNode *LoopMemParallelMD =
 196     MI->getMetadata(LLVMContext::MD_mem_parallel_loop_access);
 197   if (LoopMemParallelMD)
 198     L->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
 199
 200   StoreInst *S = Builder->CreateStore(L, Dest, MI->isVolatile());
 201   S->setAlignment(DstAlign);
 202   if (CopyMD)
 203     S->setMetadata(LLVMContext::MD_tbaa, CopyMD);
 204   if (LoopMemParallelMD)
 205     S->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
 206
 207   // Set the size of the copy to 0, it will be deleted on the next iteration.
 208   MI->setArgOperand(2, Constant::getNullValue(MemOpLength->getType()));
 209   return MI;
 210 }
 211
 212 Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) {
 213   unsigned Alignment = getKnownAlignment(MI->getDest(), DL, MI, &AC, &DT);
 214   if (MI->getAlignment() < Alignment) {
 215     MI->setAlignment(ConstantInt::get(MI->getAlignmentType(),
 216                                              Alignment, false));
 217     return MI;
 218   }
 219
 220   // Extract the length and alignment and fill if they are constant.
 221   ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength());
 222   ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue());
 223   if (!LenC || !FillC || !FillC->getType()->isIntegerTy(8))
 224     return nullptr;
 225   uint64_t Len = LenC->getLimitedValue();
 226   Alignment = MI->getAlignment();
 227   assert(Len && "0-sized memory setting should be removed already.");
 228
 229   // memset(s,c,n) -> store s, c (for n=1,2,4,8)
 230   if (Len <= 8 && isPowerOf2_32((uint32_t)Len)) {
 231     Type *ITy = IntegerType::get(MI->getContext(), Len*8);  // n=1 -> i8.
 232
 233     Value *Dest = MI->getDest();
 234     unsigned DstAddrSp = cast<PointerType>(Dest->getType())->getAddressSpace();
 235     Type *NewDstPtrTy = PointerType::get(ITy, DstAddrSp);
 236     Dest = Builder->CreateBitCast(Dest, NewDstPtrTy);
 237
 238     // Alignment 0 is identity for alignment 1 for memset, but not store.
 239     if (Alignment == 0) Alignment = 1;
 240
 241     // Extract the fill value and store.
 242     uint64_t Fill = FillC->getZExtValue()*0x0101010101010101ULL;
 243     StoreInst *S = Builder->CreateStore(ConstantInt::get(ITy, Fill), Dest,
 244                                         MI->isVolatile());
 245     S->setAlignment(Alignment);
 246
 247     // Set the size of the copy to 0, it will be deleted on the next iteration.
 248     MI->setLength(Constant::getNullValue(LenC->getType()));
 249     return MI;
 250   }
 251
 252   return nullptr;
 253 }
 254
 255 static Value *simplifyX86immShift(const IntrinsicInst &II,
 256                                   InstCombiner::BuilderTy &Builder) {
 257   bool LogicalShift = false;
 258   bool ShiftLeft = false;
 259
 260   switch (II.getIntrinsicID()) {
 261   default: llvm_unreachable("Unexpected intrinsic!");
 262   case Intrinsic::x86_sse2_psra_d:
 263   case Intrinsic::x86_sse2_psra_w:
 264   case Intrinsic::x86_sse2_psrai_d:
 265   case Intrinsic::x86_sse2_psrai_w:
 266   case Intrinsic::x86_avx2_psra_d:
 267   case Intrinsic::x86_avx2_psra_w:
 268   case Intrinsic::x86_avx2_psrai_d:
 269   case Intrinsic::x86_avx2_psrai_w:
 270   case Intrinsic::x86_avx512_psra_q_128:
 271   case Intrinsic::x86_avx512_psrai_q_128:
 272   case Intrinsic::x86_avx512_psra_q_256:
 273   case Intrinsic::x86_avx512_psrai_q_256:
 274   case Intrinsic::x86_avx512_psra_d_512:
 275   case Intrinsic::x86_avx512_psra_q_512:
 276   case Intrinsic::x86_avx512_psra_w_512:
 277   case Intrinsic::x86_avx512_psrai_d_512:
 278   case Intrinsic::x86_avx512_psrai_q_512:
 279   case Intrinsic::x86_avx512_psrai_w_512:
 280     LogicalShift = false; ShiftLeft = false;
 281     break;
 282   case Intrinsic::x86_sse2_psrl_d:
 283   case Intrinsic::x86_sse2_psrl_q:
 284   case Intrinsic::x86_sse2_psrl_w:
 285   case Intrinsic::x86_sse2_psrli_d:
 286   case Intrinsic::x86_sse2_psrli_q:
 287   case Intrinsic::x86_sse2_psrli_w:
 288   case Intrinsic::x86_avx2_psrl_d:
 289   case Intrinsic::x86_avx2_psrl_q:
 290   case Intrinsic::x86_avx2_psrl_w:
 291   case Intrinsic::x86_avx2_psrli_d:
 292   case Intrinsic::x86_avx2_psrli_q:
 293   case Intrinsic::x86_avx2_psrli_w:
 294   case Intrinsic::x86_avx512_psrl_d_512:
 295   case Intrinsic::x86_avx512_psrl_q_512:
 296   case Intrinsic::x86_avx512_psrl_w_512:
 297   case Intrinsic::x86_avx512_psrli_d_512:
 298   case Intrinsic::x86_avx512_psrli_q_512:
 299   case Intrinsic::x86_avx512_psrli_w_512:
 300     LogicalShift = true; ShiftLeft = false;
 301     break;
 302   case Intrinsic::x86_sse2_psll_d:
 303   case Intrinsic::x86_sse2_psll_q:
 304   case Intrinsic::x86_sse2_psll_w:
 305   case Intrinsic::x86_sse2_pslli_d:
 306   case Intrinsic::x86_sse2_pslli_q:
 307   case Intrinsic::x86_sse2_pslli_w:
 308   case Intrinsic::x86_avx2_psll_d:
 309   case Intrinsic::x86_avx2_psll_q:
 310   case Intrinsic::x86_avx2_psll_w:
 311   case Intrinsic::x86_avx2_pslli_d:
 312   case Intrinsic::x86_avx2_pslli_q:
 313   case Intrinsic::x86_avx2_pslli_w:
 314   case Intrinsic::x86_avx512_psll_d_512:
 315   case Intrinsic::x86_avx512_psll_q_512:
 316   case Intrinsic::x86_avx512_psll_w_512:
 317   case Intrinsic::x86_avx512_pslli_d_512:
 318   case Intrinsic::x86_avx512_pslli_q_512:
 319   case Intrinsic::x86_avx512_pslli_w_512:
 320     LogicalShift = true; ShiftLeft = true;
 321     break;
 322   }
 323   assert((LogicalShift || !ShiftLeft) && "Only logical shifts can shift left");
 324
 325   // Simplify if count is constant.
 326   auto Arg1 = II.getArgOperand(1);
 327   auto CAZ = dyn_cast<ConstantAggregateZero>(Arg1);
 328   auto CDV = dyn_cast<ConstantDataVector>(Arg1);
 329   auto CInt = dyn_cast<ConstantInt>(Arg1);
 330   if (!CAZ && !CDV && !CInt)
 331     return nullptr;
 332
 333   APInt Count(64, 0);
 334   if (CDV) {
 335     // SSE2/AVX2 uses all the first 64-bits of the 128-bit vector
 336     // operand to compute the shift amount.
 337     auto VT = cast<VectorType>(CDV->getType());
 338     unsigned BitWidth = VT->getElementType()->getPrimitiveSizeInBits();
 339     assert((64 % BitWidth) == 0 && "Unexpected packed shift size");
 340     unsigned NumSubElts = 64 / BitWidth;
 341
 342     // Concatenate the sub-elements to create the 64-bit value.
 343     for (unsigned i = 0; i != NumSubElts; ++i) {
 344       unsigned SubEltIdx = (NumSubElts - 1) - i;
 345       auto SubElt = cast<ConstantInt>(CDV->getElementAsConstant(SubEltIdx));
 346       Count = Count.shl(BitWidth);
 347       Count |= SubElt->getValue().zextOrTrunc(64);
 348     }
 349   }
 350   else if (CInt)
 351     Count = CInt->getValue();
 352
 353   auto Vec = II.getArgOperand(0);
 354   auto VT = cast<VectorType>(Vec->getType());
 355   auto SVT = VT->getElementType();
 356   unsigned VWidth = VT->getNumElements();
 357   unsigned BitWidth = SVT->getPrimitiveSizeInBits();
 358
 359   // If shift-by-zero then just return the original value.
 360   if (Count == 0)
 361     return Vec;
 362
 363   // Handle cases when Shift >= BitWidth.
 364   if (Count.uge(BitWidth)) {
 365     // If LogicalShift - just return zero.
 366     if (LogicalShift)
 367       return ConstantAggregateZero::get(VT);
 368
 369     // If ArithmeticShift - clamp Shift to (BitWidth - 1).
 370     Count = APInt(64, BitWidth - 1);
 371   }
 372
 373   // Get a constant vector of the same type as the first operand.
 374   auto ShiftAmt = ConstantInt::get(SVT, Count.zextOrTrunc(BitWidth));
 375   auto ShiftVec = Builder.CreateVectorSplat(VWidth, ShiftAmt);
 376
 377   if (ShiftLeft)
 378     return Builder.CreateShl(Vec, ShiftVec);
 379
 380   if (LogicalShift)
 381     return Builder.CreateLShr(Vec, ShiftVec);
 382
 383   return Builder.CreateAShr(Vec, ShiftVec);
 384 }
 385
 386 // Attempt to simplify AVX2 per-element shift intrinsics to a generic IR shift.
 387 // Unlike the generic IR shifts, the intrinsics have defined behaviour for out
 388 // of range shift amounts (logical - set to zero, arithmetic - splat sign bit).
 389 static Value *simplifyX86varShift(const IntrinsicInst &II,
 390                                   InstCombiner::BuilderTy &Builder) {
 391   bool LogicalShift = false;
 392   bool ShiftLeft = false;
 393
 394   switch (II.getIntrinsicID()) {
 395   default: llvm_unreachable("Unexpected intrinsic!");
 396   case Intrinsic::x86_avx2_psrav_d:
 397   case Intrinsic::x86_avx2_psrav_d_256:
 398   case Intrinsic::x86_avx512_psrav_q_128:
 399   case Intrinsic::x86_avx512_psrav_q_256:
 400   case Intrinsic::x86_avx512_psrav_d_512:
 401   case Intrinsic::x86_avx512_psrav_q_512:
 402   case Intrinsic::x86_avx512_psrav_w_128:
 403   case Intrinsic::x86_avx512_psrav_w_256:
 404   case Intrinsic::x86_avx512_psrav_w_512:
 405     LogicalShift = false;
 406     ShiftLeft = false;
 407     break;
 408   case Intrinsic::x86_avx2_psrlv_d:
 409   case Intrinsic::x86_avx2_psrlv_d_256:
 410   case Intrinsic::x86_avx2_psrlv_q:
 411   case Intrinsic::x86_avx2_psrlv_q_256:
 412   case Intrinsic::x86_avx512_psrlv_d_512:
 413   case Intrinsic::x86_avx512_psrlv_q_512:
 414   case Intrinsic::x86_avx512_psrlv_w_128:
 415   case Intrinsic::x86_avx512_psrlv_w_256:
 416   case Intrinsic::x86_avx512_psrlv_w_512:
 417     LogicalShift = true;
 418     ShiftLeft = false;
 419     break;
 420   case Intrinsic::x86_avx2_psllv_d:
 421   case Intrinsic::x86_avx2_psllv_d_256:
 422   case Intrinsic::x86_avx2_psllv_q:
 423   case Intrinsic::x86_avx2_psllv_q_256:
 424   case Intrinsic::x86_avx512_psllv_d_512:
 425   case Intrinsic::x86_avx512_psllv_q_512:
 426   case Intrinsic::x86_avx512_psllv_w_128:
 427   case Intrinsic::x86_avx512_psllv_w_256:
 428   case Intrinsic::x86_avx512_psllv_w_512:
 429     LogicalShift = true;
 430     ShiftLeft = true;
 431     break;
 432   }
 433   assert((LogicalShift || !ShiftLeft) && "Only logical shifts can shift left");
 434
 435   // Simplify if all shift amounts are constant/undef.
 436   auto *CShift = dyn_cast<Constant>(II.getArgOperand(1));
 437   if (!CShift)
 438     return nullptr;
 439
 440   auto Vec = II.getArgOperand(0);
 441   auto VT = cast<VectorType>(II.getType());
 442   auto SVT = VT->getVectorElementType();
 443   int NumElts = VT->getNumElements();
 444   int BitWidth = SVT->getIntegerBitWidth();
 445
 446   // Collect each element's shift amount.
 447   // We also collect special cases: UNDEF = -1, OUT-OF-RANGE = BitWidth.
 448   bool AnyOutOfRange = false;
 449   SmallVector<int, 8> ShiftAmts;
 450   for (int I = 0; I < NumElts; ++I) {
 451     auto *CElt = CShift->getAggregateElement(I);
 452     if (CElt && isa<UndefValue>(CElt)) {
 453       ShiftAmts.push_back(-1);
 454       continue;
 455     }
 456
 457     auto *COp = dyn_cast_or_null<ConstantInt>(CElt);
 458     if (!COp)
 459       return nullptr;
 460
 461     // Handle out of range shifts.
 462     // If LogicalShift - set to BitWidth (special case).
 463     // If ArithmeticShift - set to (BitWidth - 1) (sign splat).
 464     APInt ShiftVal = COp->getValue();
 465     if (ShiftVal.uge(BitWidth)) {
 466       AnyOutOfRange = LogicalShift;
 467       ShiftAmts.push_back(LogicalShift ? BitWidth : BitWidth - 1);
 468       continue;
 469     }
 470
 471     ShiftAmts.push_back((int)ShiftVal.getZExtValue());
 472   }
 473
 474   // If all elements out of range or UNDEF, return vector of zeros/undefs.
 475   // ArithmeticShift should only hit this if they are all UNDEF.
 476   auto OutOfRange = [&](int Idx) { return (Idx < 0) || (BitWidth <= Idx); };
 477   if (all_of(ShiftAmts, OutOfRange)) {
 478     SmallVector<Constant *, 8> ConstantVec;
 479     for (int Idx : ShiftAmts) {
 480       if (Idx < 0) {
 481         ConstantVec.push_back(UndefValue::get(SVT));
 482       } else {
 483         assert(LogicalShift && "Logical shift expected");
 484         ConstantVec.push_back(ConstantInt::getNullValue(SVT));
 485       }
 486     }
 487     return ConstantVector::get(ConstantVec);
 488   }
 489
 490   // We can't handle only some out of range values with generic logical shifts.
 491   if (AnyOutOfRange)
 492     return nullptr;
 493
 494   // Build the shift amount constant vector.
 495   SmallVector<Constant *, 8> ShiftVecAmts;
 496   for (int Idx : ShiftAmts) {
 497     if (Idx < 0)
 498       ShiftVecAmts.push_back(UndefValue::get(SVT));
 499     else
 500       ShiftVecAmts.push_back(ConstantInt::get(SVT, Idx));
 501   }
 502   auto ShiftVec = ConstantVector::get(ShiftVecAmts);
 503
 504   if (ShiftLeft)
 505     return Builder.CreateShl(Vec, ShiftVec);
 506
 507   if (LogicalShift)
 508     return Builder.CreateLShr(Vec, ShiftVec);
 509
 510   return Builder.CreateAShr(Vec, ShiftVec);
 511 }
 512
 513 static Value *simplifyX86movmsk(const IntrinsicInst &II,
 514                                 InstCombiner::BuilderTy &Builder) {
 515   Value *Arg = II.getArgOperand(0);
 516   Type *ResTy = II.getType();
 517   Type *ArgTy = Arg->getType();
 518
 519   // movmsk(undef) -> zero as we must ensure the upper bits are zero.
 520   if (isa<UndefValue>(Arg))
 521     return Constant::getNullValue(ResTy);
 522
 523   // We can't easily peek through x86_mmx types.
 524   if (!ArgTy->isVectorTy())
 525     return nullptr;
 526
 527   auto *C = dyn_cast<Constant>(Arg);
 528   if (!C)
 529     return nullptr;
 530
 531   // Extract signbits of the vector input and pack into integer result.
 532   APInt Result(ResTy->getPrimitiveSizeInBits(), 0);
 533   for (unsigned I = 0, E = ArgTy->getVectorNumElements(); I != E; ++I) {
 534     auto *COp = C->getAggregateElement(I);
 535     if (!COp)
 536       return nullptr;
 537     if (isa<UndefValue>(COp))
 538       continue;
 539
 540     auto *CInt = dyn_cast<ConstantInt>(COp);
 541     auto *CFp = dyn_cast<ConstantFP>(COp);
 542     if (!CInt && !CFp)
 543       return nullptr;
 544
 545     if ((CInt && CInt->isNegative()) || (CFp && CFp->isNegative()))
 546       Result.setBit(I);
 547   }
 548
 549   return Constant::getIntegerValue(ResTy, Result);
 550 }
 551
 552 static Value *simplifyX86insertps(const IntrinsicInst &II,
 553                                   InstCombiner::BuilderTy &Builder) {
 554   auto *CInt = dyn_cast<ConstantInt>(II.getArgOperand(2));
 555   if (!CInt)
 556     return nullptr;
 557
 558   VectorType *VecTy = cast<VectorType>(II.getType());
 559   assert(VecTy->getNumElements() == 4 && "insertps with wrong vector type");
 560
 561   // The immediate permute control byte looks like this:
 562   //    [3:0] - zero mask for each 32-bit lane
 563   //    [5:4] - select one 32-bit destination lane
 564   //    [7:6] - select one 32-bit source lane
 565
 566   uint8_t Imm = CInt->getZExtValue();
 567   uint8_t ZMask = Imm & 0xf;
 568   uint8_t DestLane = (Imm >> 4) & 0x3;
 569   uint8_t SourceLane = (Imm >> 6) & 0x3;
 570
 571   ConstantAggregateZero *ZeroVector = ConstantAggregateZero::get(VecTy);
 572
 573   // If all zero mask bits are set, this was just a weird way to
 574   // generate a zero vector.
 575   if (ZMask == 0xf)
 576     return ZeroVector;
 577
 578   // Initialize by passing all of the first source bits through.
 579   uint32_t ShuffleMask[4] = { 0, 1, 2, 3 };
 580
 581   // We may replace the second operand with the zero vector.
 582   Value *V1 = II.getArgOperand(1);
 583
 584   if (ZMask) {
 585     // If the zero mask is being used with a single input or the zero mask
 586     // overrides the destination lane, this is a shuffle with the zero vector.
 587     if ((II.getArgOperand(0) == II.getArgOperand(1)) ||
 588         (ZMask & (1 << DestLane))) {
 589       V1 = ZeroVector;
 590       // We may still move 32-bits of the first source vector from one lane
 591       // to another.
 592       ShuffleMask[DestLane] = SourceLane;
 593       // The zero mask may override the previous insert operation.
 594       for (unsigned i = 0; i < 4; ++i)
 595         if ((ZMask >> i) & 0x1)
 596           ShuffleMask[i] = i + 4;
 597     } else {
 598       // TODO: Model this case as 2 shuffles or a 'logical and' plus shuffle?
 599       return nullptr;
 600     }
 601   } else {
 602     // Replace the selected destination lane with the selected source lane.
 603     ShuffleMask[DestLane] = SourceLane + 4;
 604   }
 605
 606   return Builder.CreateShuffleVector(II.getArgOperand(0), V1, ShuffleMask);
 607 }
 608
 609 /// Attempt to simplify SSE4A EXTRQ/EXTRQI instructions using constant folding
 610 /// or conversion to a shuffle vector.
 611 static Value *simplifyX86extrq(IntrinsicInst &II, Value *Op0,
 612                                ConstantInt *CILength, ConstantInt *CIIndex,
 613                                InstCombiner::BuilderTy &Builder) {
 614   auto LowConstantHighUndef = [&](uint64_t Val) {
 615     Type *IntTy64 = Type::getInt64Ty(II.getContext());
 616     Constant *Args[] = {ConstantInt::get(IntTy64, Val),
 617                         UndefValue::get(IntTy64)};
 618     return ConstantVector::get(Args);
 619   };
 620
 621   // See if we're dealing with constant values.
 622   Constant *C0 = dyn_cast<Constant>(Op0);
 623   ConstantInt *CI0 =
 624       C0 ? dyn_cast_or_null<ConstantInt>(C0->getAggregateElement((unsigned)0))
 625          : nullptr;
 626
 627   // Attempt to constant fold.
 628   if (CILength && CIIndex) {
 629     // From AMD documentation: "The bit index and field length are each six
 630     // bits in length other bits of the field are ignored."
 631     APInt APIndex = CIIndex->getValue().zextOrTrunc(6);
 632     APInt APLength = CILength->getValue().zextOrTrunc(6);
 633
 634     unsigned Index = APIndex.getZExtValue();
 635
 636     // From AMD documentation: "a value of zero in the field length is
 637     // defined as length of 64".
 638     unsigned Length = APLength == 0 ? 64 : APLength.getZExtValue();
 639
 640     // From AMD documentation: "If the sum of the bit index + length field
 641     // is greater than 64, the results are undefined".
 642     unsigned End = Index + Length;
 643
 644     // Note that both field index and field length are 8-bit quantities.
 645     // Since variables 'Index' and 'Length' are unsigned values
 646     // obtained from zero-extending field index and field length
 647     // respectively, their sum should never wrap around.
 648     if (End > 64)
 649       return UndefValue::get(II.getType());
 650
 651     // If we are inserting whole bytes, we can convert this to a shuffle.
 652     // Lowering can recognize EXTRQI shuffle masks.
 653     if ((Length % 8) == 0 && (Index % 8) == 0) {
 654       // Convert bit indices to byte indices.
 655       Length /= 8;
 656       Index /= 8;
 657
 658       Type *IntTy8 = Type::getInt8Ty(II.getContext());
 659       Type *IntTy32 = Type::getInt32Ty(II.getContext());
 660       VectorType *ShufTy = VectorType::get(IntTy8, 16);
 661
 662       SmallVector<Constant *, 16> ShuffleMask;
 663       for (int i = 0; i != (int)Length; ++i)
 664         ShuffleMask.push_back(
 665             Constant::getIntegerValue(IntTy32, APInt(32, i + Index)));
 666       for (int i = Length; i != 8; ++i)
 667         ShuffleMask.push_back(
 668             Constant::getIntegerValue(IntTy32, APInt(32, i + 16)));
 669       for (int i = 8; i != 16; ++i)
 670         ShuffleMask.push_back(UndefValue::get(IntTy32));
 671
 672       Value *SV = Builder.CreateShuffleVector(
 673           Builder.CreateBitCast(Op0, ShufTy),
 674           ConstantAggregateZero::get(ShufTy), ConstantVector::get(ShuffleMask));
 675       return Builder.CreateBitCast(SV, II.getType());
 676     }
 677
 678     // Constant Fold - shift Index'th bit to lowest position and mask off
 679     // Length bits.
 680     if (CI0) {
 681       APInt Elt = CI0->getValue();
 682       Elt = Elt.lshr(Index).zextOrTrunc(Length);
 683       return LowConstantHighUndef(Elt.getZExtValue());
 684     }
 685
 686     // If we were an EXTRQ call, we'll save registers if we convert to EXTRQI.
 687     if (II.getIntrinsicID() == Intrinsic::x86_sse4a_extrq) {
 688       Value *Args[] = {Op0, CILength, CIIndex};
 689       Module *M = II.getModule();
 690       Value *F = Intrinsic::getDeclaration(M, Intrinsic::x86_sse4a_extrqi);
 691       return Builder.CreateCall(F, Args);
 692     }
 693   }
 694
 695   // Constant Fold - extraction from zero is always {zero, undef}.
 696   if (CI0 && CI0->equalsInt(0))
 697     return LowConstantHighUndef(0);
 698
 699   return nullptr;
 700 }
 701
 702 /// Attempt to simplify SSE4A INSERTQ/INSERTQI instructions using constant
 703 /// folding or conversion to a shuffle vector.
 704 static Value *simplifyX86insertq(IntrinsicInst &II, Value *Op0, Value *Op1,
 705                                  APInt APLength, APInt APIndex,
 706                                  InstCombiner::BuilderTy &Builder) {
 707   // From AMD documentation: "The bit index and field length are each six bits
 708   // in length other bits of the field are ignored."
 709   APIndex = APIndex.zextOrTrunc(6);
 710   APLength = APLength.zextOrTrunc(6);
 711
 712   // Attempt to constant fold.
 713   unsigned Index = APIndex.getZExtValue();
 714
 715   // From AMD documentation: "a value of zero in the field length is
 716   // defined as length of 64".
 717   unsigned Length = APLength == 0 ? 64 : APLength.getZExtValue();
 718
 719   // From AMD documentation: "If the sum of the bit index + length field
 720   // is greater than 64, the results are undefined".
 721   unsigned End = Index + Length;
 722
 723   // Note that both field index and field length are 8-bit quantities.
 724   // Since variables 'Index' and 'Length' are unsigned values
 725   // obtained from zero-extending field index and field length
 726   // respectively, their sum should never wrap around.
 727   if (End > 64)
 728     return UndefValue::get(II.getType());
 729
 730   // If we are inserting whole bytes, we can convert this to a shuffle.
 731   // Lowering can recognize INSERTQI shuffle masks.
 732   if ((Length % 8) == 0 && (Index % 8) == 0) {
 733     // Convert bit indices to byte indices.
 734     Length /= 8;
 735     Index /= 8;
 736
 737     Type *IntTy8 = Type::getInt8Ty(II.getContext());
 738     Type *IntTy32 = Type::getInt32Ty(II.getContext());
 739     VectorType *ShufTy = VectorType::get(IntTy8, 16);
 740
 741     SmallVector<Constant *, 16> ShuffleMask;
 742     for (int i = 0; i != (int)Index; ++i)
 743       ShuffleMask.push_back(Constant::getIntegerValue(IntTy32, APInt(32, i)));
 744     for (int i = 0; i != (int)Length; ++i)
 745       ShuffleMask.push_back(
 746           Constant::getIntegerValue(IntTy32, APInt(32, i + 16)));
 747     for (int i = Index + Length; i != 8; ++i)
 748       ShuffleMask.push_back(Constant::getIntegerValue(IntTy32, APInt(32, i)));
 749     for (int i = 8; i != 16; ++i)
 750       ShuffleMask.push_back(UndefValue::get(IntTy32));
 751
 752     Value *SV = Builder.CreateShuffleVector(Builder.CreateBitCast(Op0, ShufTy),
 753                                             Builder.CreateBitCast(Op1, ShufTy),
 754                                             ConstantVector::get(ShuffleMask));
 755     return Builder.CreateBitCast(SV, II.getType());
 756   }
 757
 758   // See if we're dealing with constant values.
 759   Constant *C0 = dyn_cast<Constant>(Op0);
 760   Constant *C1 = dyn_cast<Constant>(Op1);
 761   ConstantInt *CI00 =
 762       C0 ? dyn_cast_or_null<ConstantInt>(C0->getAggregateElement((unsigned)0))
 763          : nullptr;
 764   ConstantInt *CI10 =
 765       C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)0))
 766          : nullptr;
 767
 768   // Constant Fold - insert bottom Length bits starting at the Index'th bit.
 769   if (CI00 && CI10) {
 770     APInt V00 = CI00->getValue();
 771     APInt V10 = CI10->getValue();
 772     APInt Mask = APInt::getLowBitsSet(64, Length).shl(Index);
 773     V00 = V00 & ~Mask;
 774     V10 = V10.zextOrTrunc(Length).zextOrTrunc(64).shl(Index);
 775     APInt Val = V00 | V10;
 776     Type *IntTy64 = Type::getInt64Ty(II.getContext());
 777     Constant *Args[] = {ConstantInt::get(IntTy64, Val.getZExtValue()),
 778                         UndefValue::get(IntTy64)};
 779     return ConstantVector::get(Args);
 780   }
 781
 782   // If we were an INSERTQ call, we'll save demanded elements if we convert to
 783   // INSERTQI.
 784   if (II.getIntrinsicID() == Intrinsic::x86_sse4a_insertq) {
 785     Type *IntTy8 = Type::getInt8Ty(II.getContext());
 786     Constant *CILength = ConstantInt::get(IntTy8, Length, false);
 787     Constant *CIIndex = ConstantInt::get(IntTy8, Index, false);
 788
 789     Value *Args[] = {Op0, Op1, CILength, CIIndex};
 790     Module *M = II.getModule();
 791     Value *F = Intrinsic::getDeclaration(M, Intrinsic::x86_sse4a_insertqi);
 792     return Builder.CreateCall(F, Args);
 793   }
 794
 795   return nullptr;
 796 }
 797
 798 /// Attempt to convert pshufb* to shufflevector if the mask is constant.
 799 static Value *simplifyX86pshufb(const IntrinsicInst &II,
 800                                 InstCombiner::BuilderTy &Builder) {
 801   Constant *V = dyn_cast<Constant>(II.getArgOperand(1));
 802   if (!V)
 803     return nullptr;
 804
 805   auto *VecTy = cast<VectorType>(II.getType());
 806   auto *MaskEltTy = Type::getInt32Ty(II.getContext());
 807   unsigned NumElts = VecTy->getNumElements();
 808   assert((NumElts == 16 || NumElts == 32 || NumElts == 64) &&
 809          "Unexpected number of elements in shuffle mask!");
 810
 811   // Construct a shuffle mask from constant integers or UNDEFs.
 812   Constant *Indexes[64] = {nullptr};
 813
 814   // Each byte in the shuffle control mask forms an index to permute the
 815   // corresponding byte in the destination operand.
 816   for (unsigned I = 0; I < NumElts; ++I) {
 817     Constant *COp = V->getAggregateElement(I);
 818     if (!COp || (!isa<UndefValue>(COp) && !isa<ConstantInt>(COp)))
 819       return nullptr;
 820
 821     if (isa<UndefValue>(COp)) {
 822       Indexes[I] = UndefValue::get(MaskEltTy);
 823       continue;
 824     }
 825
 826     int8_t Index = cast<ConstantInt>(COp)->getValue().getZExtValue();
 827
 828     // If the most significant bit (bit[7]) of each byte of the shuffle
 829     // control mask is set, then zero is written in the result byte.
 830     // The zero vector is in the right-hand side of the resulting
 831     // shufflevector.
 832
 833     // The value of each index for the high 128-bit lane is the least
 834     // significant 4 bits of the respective shuffle control byte.
 835     Index = ((Index < 0) ? NumElts : Index & 0x0F) + (I & 0xF0);
 836     Indexes[I] = ConstantInt::get(MaskEltTy, Index);
 837   }
 838
 839   auto ShuffleMask = ConstantVector::get(makeArrayRef(Indexes, NumElts));
 840   auto V1 = II.getArgOperand(0);
 841   auto V2 = Constant::getNullValue(VecTy);
 842   return Builder.CreateShuffleVector(V1, V2, ShuffleMask);
 843 }
 844
 845 /// Attempt to convert vpermilvar* to shufflevector if the mask is constant.
 846 static Value *simplifyX86vpermilvar(const IntrinsicInst &II,
 847                                     InstCombiner::BuilderTy &Builder) {
 848   Constant *V = dyn_cast<Constant>(II.getArgOperand(1));
 849   if (!V)
 850     return nullptr;
 851
 852   auto *VecTy = cast<VectorType>(II.getType());
 853   auto *MaskEltTy = Type::getInt32Ty(II.getContext());
 854   unsigned NumElts = VecTy->getVectorNumElements();
 855   bool IsPD = VecTy->getScalarType()->isDoubleTy();
 856   unsigned NumLaneElts = IsPD ? 2 : 4;
 857   assert(NumElts == 16 || NumElts == 8 || NumElts == 4 || NumElts == 2);
 858
 859   // Construct a shuffle mask from constant integers or UNDEFs.
 860   Constant *Indexes[16] = {nullptr};
 861
 862   // The intrinsics only read one or two bits, clear the rest.
 863   for (unsigned I = 0; I < NumElts; ++I) {
 864     Constant *COp = V->getAggregateElement(I);
 865     if (!COp || (!isa<UndefValue>(COp) && !isa<ConstantInt>(COp)))
 866       return nullptr;
 867
 868     if (isa<UndefValue>(COp)) {
 869       Indexes[I] = UndefValue::get(MaskEltTy);
 870       continue;
 871     }
 872
 873     APInt Index = cast<ConstantInt>(COp)->getValue();
 874     Index = Index.zextOrTrunc(32).getLoBits(2);
 875
 876     // The PD variants uses bit 1 to select per-lane element index, so
 877     // shift down to convert to generic shuffle mask index.
 878     if (IsPD)
 879       Index = Index.lshr(1);
 880
 881     // The _256 variants are a bit trickier since the mask bits always index
 882     // into the corresponding 128 half. In order to convert to a generic
 883     // shuffle, we have to make that explicit.
 884     Index += APInt(32, (I / NumLaneElts) * NumLaneElts);
 885
 886     Indexes[I] = ConstantInt::get(MaskEltTy, Index);
 887   }
 888
 889   auto ShuffleMask = ConstantVector::get(makeArrayRef(Indexes, NumElts));
 890   auto V1 = II.getArgOperand(0);
 891   auto V2 = UndefValue::get(V1->getType());
 892   return Builder.CreateShuffleVector(V1, V2, ShuffleMask);
 893 }
 894
 895 /// Attempt to convert vpermd/vpermps to shufflevector if the mask is constant.
 896 static Value *simplifyX86vpermv(const IntrinsicInst &II,
 897                                 InstCombiner::BuilderTy &Builder) {
 898   auto *V = dyn_cast<Constant>(II.getArgOperand(1));
 899   if (!V)
 900     return nullptr;
 901
 902   auto *VecTy = cast<VectorType>(II.getType());
 903   auto *MaskEltTy = Type::getInt32Ty(II.getContext());
 904   unsigned Size = VecTy->getNumElements();
 905   assert((Size == 4 || Size == 8 || Size == 16 || Size == 32 || Size == 64) &&
 906          "Unexpected shuffle mask size");
 907
 908   // Construct a shuffle mask from constant integers or UNDEFs.
 909   Constant *Indexes[64] = {nullptr};
 910
 911   for (unsigned I = 0; I < Size; ++I) {
 912     Constant *COp = V->getAggregateElement(I);
 913     if (!COp || (!isa<UndefValue>(COp) && !isa<ConstantInt>(COp)))
 914       return nullptr;
 915
 916     if (isa<UndefValue>(COp)) {
 917       Indexes[I] = UndefValue::get(MaskEltTy);
 918       continue;
 919     }
 920
 921     uint32_t Index = cast<ConstantInt>(COp)->getZExtValue();
 922     Index &= Size - 1;
 923     Indexes[I] = ConstantInt::get(MaskEltTy, Index);
 924   }
 925
 926   auto ShuffleMask = ConstantVector::get(makeArrayRef(Indexes, Size));
 927   auto V1 = II.getArgOperand(0);
 928   auto V2 = UndefValue::get(VecTy);
 929   return Builder.CreateShuffleVector(V1, V2, ShuffleMask);
 930 }
 931
 932 /// The shuffle mask for a perm2*128 selects any two halves of two 256-bit
 933 /// source vectors, unless a zero bit is set. If a zero bit is set,
 934 /// then ignore that half of the mask and clear that half of the vector.
 935 static Value *simplifyX86vperm2(const IntrinsicInst &II,
 936                                 InstCombiner::BuilderTy &Builder) {
 937   auto *CInt = dyn_cast<ConstantInt>(II.getArgOperand(2));
 938   if (!CInt)
 939     return nullptr;
 940
 941   VectorType *VecTy = cast<VectorType>(II.getType());
 942   ConstantAggregateZero *ZeroVector = ConstantAggregateZero::get(VecTy);
 943
 944   // The immediate permute control byte looks like this:
 945   //    [1:0] - select 128 bits from sources for low half of destination
 946   //    [2]   - ignore
 947   //    [3]   - zero low half of destination
 948   //    [5:4] - select 128 bits from sources for high half of destination
 949   //    [6]   - ignore
 950   //    [7]   - zero high half of destination
 951
 952   uint8_t Imm = CInt->getZExtValue();
 953
 954   bool LowHalfZero = Imm & 0x08;
 955   bool HighHalfZero = Imm & 0x80;
 956
 957   // If both zero mask bits are set, this was just a weird way to
 958   // generate a zero vector.
 959   if (LowHalfZero && HighHalfZero)
 960     return ZeroVector;
 961
 962   // If 0 or 1 zero mask bits are set, this is a simple shuffle.
 963   unsigned NumElts = VecTy->getNumElements();
 964   unsigned HalfSize = NumElts / 2;
 965   SmallVector<uint32_t, 8> ShuffleMask(NumElts);
 966
 967   // The high bit of the selection field chooses the 1st or 2nd operand.
 968   bool LowInputSelect = Imm & 0x02;
 969   bool HighInputSelect = Imm & 0x20;
 970
 971   // The low bit of the selection field chooses the low or high half
 972   // of the selected operand.
 973   bool LowHalfSelect = Imm & 0x01;
 974   bool HighHalfSelect = Imm & 0x10;
 975
 976   // Determine which operand(s) are actually in use for this instruction.
 977   Value *V0 = LowInputSelect ? II.getArgOperand(1) : II.getArgOperand(0);
 978   Value *V1 = HighInputSelect ? II.getArgOperand(1) : II.getArgOperand(0);
 979
 980   // If needed, replace operands based on zero mask.
 981   V0 = LowHalfZero ? ZeroVector : V0;
 982   V1 = HighHalfZero ? ZeroVector : V1;
 983
 984   // Permute low half of result.
 985   unsigned StartIndex = LowHalfSelect ? HalfSize : 0;
 986   for (unsigned i = 0; i < HalfSize; ++i)
 987     ShuffleMask[i] = StartIndex + i;
 988
 989   // Permute high half of result.
 990   StartIndex = HighHalfSelect ? HalfSize : 0;
 991   StartIndex += NumElts;
 992   for (unsigned i = 0; i < HalfSize; ++i)
 993     ShuffleMask[i + HalfSize] = StartIndex + i;
 994
 995   return Builder.CreateShuffleVector(V0, V1, ShuffleMask);
 996 }
 997
 998 /// Decode XOP integer vector comparison intrinsics.
 999 static Value *simplifyX86vpcom(const IntrinsicInst &II,
1000                                InstCombiner::BuilderTy &Builder,
1001                                bool IsSigned) {
1002   if (auto *CInt = dyn_cast<ConstantInt>(II.getArgOperand(2))) {
1003     uint64_t Imm = CInt->getZExtValue() & 0x7;
1004     VectorType *VecTy = cast<VectorType>(II.getType());
1005     CmpInst::Predicate Pred = ICmpInst::BAD_ICMP_PREDICATE;
1006
1007     switch (Imm) {
1008     case 0x0:
1009       Pred = IsSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
1010       break;
1011     case 0x1:
1012       Pred = IsSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE;
1013       break;
1014     case 0x2:
1015       Pred = IsSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1016       break;
1017     case 0x3:
1018       Pred = IsSigned ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE;
1019       break;
1020     case 0x4:
1021       Pred = ICmpInst::ICMP_EQ; break;
1022     case 0x5:
1023       Pred = ICmpInst::ICMP_NE; break;
1024     case 0x6:
1025       return ConstantInt::getSigned(VecTy, 0); // FALSE
1026     case 0x7:
1027       return ConstantInt::getSigned(VecTy, -1); // TRUE
1028     }
1029
1030     if (Value *Cmp = Builder.CreateICmp(Pred, II.getArgOperand(0),
1031                                         II.getArgOperand(1)))
1032       return Builder.CreateSExtOrTrunc(Cmp, VecTy);
1033   }
1034   return nullptr;
1035 }
1036
1037 // Emit a select instruction and appropriate bitcasts to help simplify
1038 // masked intrinsics.
1039 static Value *emitX86MaskSelect(Value *Mask, Value *Op0, Value *Op1,
1040                                 InstCombiner::BuilderTy &Builder) {
1041   unsigned VWidth = Op0->getType()->getVectorNumElements();
1042
1043   // If the mask is all ones we don't need the select. But we need to check
1044   // only the bit thats will be used in case VWidth is less than 8.
1045   if (auto *C = dyn_cast<ConstantInt>(Mask))
1046     if (C->getValue().zextOrTrunc(VWidth).isAllOnesValue())
1047       return Op0;
1048
1049   auto *MaskTy = VectorType::get(Builder.getInt1Ty(),
1050                          cast<IntegerType>(Mask->getType())->getBitWidth());
1051   Mask = Builder.CreateBitCast(Mask, MaskTy);
1052
1053   // If we have less than 8 elements, then the starting mask was an i8 and
1054   // we need to extract down to the right number of elements.
1055   if (VWidth < 8) {
1056     uint32_t Indices[4];
1057     for (unsigned i = 0; i != VWidth; ++i)
1058       Indices[i] = i;
1059     Mask = Builder.CreateShuffleVector(Mask, Mask,
1060                                        makeArrayRef(Indices, VWidth),
1061                                        "extract");
1062   }
1063
1064   return Builder.CreateSelect(Mask, Op0, Op1);
1065 }
1066
1067 static Value *simplifyMinnumMaxnum(const IntrinsicInst &II) {
1068   Value *Arg0 = II.getArgOperand(0);
1069   Value *Arg1 = II.getArgOperand(1);
1070
1071   // fmin(x, x) -> x
1072   if (Arg0 == Arg1)
1073     return Arg0;
1074
1075   const auto *C1 = dyn_cast<ConstantFP>(Arg1);
1076
1077   // fmin(x, nan) -> x
1078   if (C1 && C1->isNaN())
1079     return Arg0;
1080
1081   // This is the value because if undef were NaN, we would return the other
1082   // value and cannot return a NaN unless both operands are.
1083   //
1084   // fmin(undef, x) -> x
1085   if (isa<UndefValue>(Arg0))
1086     return Arg1;
1087
1088   // fmin(x, undef) -> x
1089   if (isa<UndefValue>(Arg1))
1090     return Arg0;
1091
1092   Value *X = nullptr;
1093   Value *Y = nullptr;
1094   if (II.getIntrinsicID() == Intrinsic::minnum) {
1095     // fmin(x, fmin(x, y)) -> fmin(x, y)
1096     // fmin(y, fmin(x, y)) -> fmin(x, y)
1097     if (match(Arg1, m_FMin(m_Value(X), m_Value(Y)))) {
1098       if (Arg0 == X || Arg0 == Y)
1099         return Arg1;
1100     }
1101
1102     // fmin(fmin(x, y), x) -> fmin(x, y)
1103     // fmin(fmin(x, y), y) -> fmin(x, y)
1104     if (match(Arg0, m_FMin(m_Value(X), m_Value(Y)))) {
1105       if (Arg1 == X || Arg1 == Y)
1106         return Arg0;
1107     }
1108
1109     // TODO: fmin(nnan x, inf) -> x
1110     // TODO: fmin(nnan ninf x, flt_max) -> x
1111     if (C1 && C1->isInfinity()) {
1112       // fmin(x, -inf) -> -inf
1113       if (C1->isNegative())
1114         return Arg1;
1115     }
1116   } else {
1117     assert(II.getIntrinsicID() == Intrinsic::maxnum);
1118     // fmax(x, fmax(x, y)) -> fmax(x, y)
1119     // fmax(y, fmax(x, y)) -> fmax(x, y)
1120     if (match(Arg1, m_FMax(m_Value(X), m_Value(Y)))) {
1121       if (Arg0 == X || Arg0 == Y)
1122         return Arg1;
1123     }
1124
1125     // fmax(fmax(x, y), x) -> fmax(x, y)
1126     // fmax(fmax(x, y), y) -> fmax(x, y)
1127     if (match(Arg0, m_FMax(m_Value(X), m_Value(Y)))) {
1128       if (Arg1 == X || Arg1 == Y)
1129         return Arg0;
1130     }
1131
1132     // TODO: fmax(nnan x, -inf) -> x
1133     // TODO: fmax(nnan ninf x, -flt_max) -> x
1134     if (C1 && C1->isInfinity()) {
1135       // fmax(x, inf) -> inf
1136       if (!C1->isNegative())
1137         return Arg1;
1138     }
1139   }
1140   return nullptr;
1141 }
1142
1143 static bool maskIsAllOneOrUndef(Value *Mask) {
1144   auto *ConstMask = dyn_cast<Constant>(Mask);
1145   if (!ConstMask)
1146     return false;
1147   if (ConstMask->isAllOnesValue() || isa<UndefValue>(ConstMask))
1148     return true;
1149   for (unsigned I = 0, E = ConstMask->getType()->getVectorNumElements(); I != E;
1150        ++I) {
1151     if (auto *MaskElt = ConstMask->getAggregateElement(I))
1152       if (MaskElt->isAllOnesValue() || isa<UndefValue>(MaskElt))
1153         continue;
1154     return false;
1155   }
1156   return true;
1157 }
1158
1159 static Value *simplifyMaskedLoad(const IntrinsicInst &II,
1160                                  InstCombiner::BuilderTy &Builder) {
1161   // If the mask is all ones or undefs, this is a plain vector load of the 1st
1162   // argument.
1163   if (maskIsAllOneOrUndef(II.getArgOperand(2))) {
1164     Value *LoadPtr = II.getArgOperand(0);
1165     unsigned Alignment = cast<ConstantInt>(II.getArgOperand(1))->getZExtValue();
1166     return Builder.CreateAlignedLoad(LoadPtr, Alignment, "unmaskedload");
1167   }
1168
1169   return nullptr;
1170 }
1171
1172 static Instruction *simplifyMaskedStore(IntrinsicInst &II, InstCombiner &IC) {
1173   auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(3));
1174   if (!ConstMask)
1175     return nullptr;
1176
1177   // If the mask is all zeros, this instruction does nothing.
1178   if (ConstMask->isNullValue())
1179     return IC.eraseInstFromFunction(II);
1180
1181   // If the mask is all ones, this is a plain vector store of the 1st argument.
1182   if (ConstMask->isAllOnesValue()) {
1183     Value *StorePtr = II.getArgOperand(1);
1184     unsigned Alignment = cast<ConstantInt>(II.getArgOperand(2))->getZExtValue();
1185     return new StoreInst(II.getArgOperand(0), StorePtr, false, Alignment);
1186   }
1187
1188   return nullptr;
1189 }
1190
1191 static Instruction *simplifyMaskedGather(IntrinsicInst &II, InstCombiner &IC) {
1192   // If the mask is all zeros, return the "passthru" argument of the gather.
1193   auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(2));
1194   if (ConstMask && ConstMask->isNullValue())
1195     return IC.replaceInstUsesWith(II, II.getArgOperand(3));
1196
1197   return nullptr;
1198 }
1199
1200 static Instruction *simplifyMaskedScatter(IntrinsicInst &II, InstCombiner &IC) {
1201   // If the mask is all zeros, a scatter does nothing.
1202   auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(3));
1203   if (ConstMask && ConstMask->isNullValue())
1204     return IC.eraseInstFromFunction(II);
1205
1206   return nullptr;
1207 }
1208
1209 static Instruction *foldCttzCtlz(IntrinsicInst &II, InstCombiner &IC) {
1210   assert((II.getIntrinsicID() == Intrinsic::cttz ||
1211           II.getIntrinsicID() == Intrinsic::ctlz) &&
1212          "Expected cttz or ctlz intrinsic");
1213   Value *Op0 = II.getArgOperand(0);
1214   // FIXME: Try to simplify vectors of integers.
1215   auto *IT = dyn_cast<IntegerType>(Op0->getType());
1216   if (!IT)
1217     return nullptr;
1218
1219   unsigned BitWidth = IT->getBitWidth();
1220   APInt KnownZero(BitWidth, 0);
1221   APInt KnownOne(BitWidth, 0);
1222   IC.computeKnownBits(Op0, KnownZero, KnownOne, 0, &II);
1223
1224   // Create a mask for bits above (ctlz) or below (cttz) the first known one.
1225   bool IsTZ = II.getIntrinsicID() == Intrinsic::cttz;
1226   unsigned NumMaskBits = IsTZ ? KnownOne.countTrailingZeros()
1227                               : KnownOne.countLeadingZeros();
1228   APInt Mask = IsTZ ? APInt::getLowBitsSet(BitWidth, NumMaskBits)
1229                     : APInt::getHighBitsSet(BitWidth, NumMaskBits);
1230
1231   // If all bits above (ctlz) or below (cttz) the first known one are known
1232   // zero, this value is constant.
1233   // FIXME: This should be in InstSimplify because we're replacing an
1234   // instruction with a constant.
1235   if ((Mask & KnownZero) == Mask) {
1236     auto *C = ConstantInt::get(IT, APInt(BitWidth, NumMaskBits));
1237     return IC.replaceInstUsesWith(II, C);
1238   }
1239
1240   // If the input to cttz/ctlz is known to be non-zero,
1241   // then change the 'ZeroIsUndef' parameter to 'true'
1242   // because we know the zero behavior can't affect the result.
1243   if (KnownOne != 0 || isKnownNonZero(Op0, IC.getDataLayout())) {
1244     if (!match(II.getArgOperand(1), m_One())) {
1245       II.setOperand(1, IC.Builder->getTrue());
1246       return &II;
1247     }
1248   }
1249
1250   return nullptr;
1251 }
1252
1253 // TODO: If the x86 backend knew how to convert a bool vector mask back to an
1254 // XMM register mask efficiently, we could transform all x86 masked intrinsics
1255 // to LLVM masked intrinsics and remove the x86 masked intrinsic defs.
1256 static Instruction *simplifyX86MaskedLoad(IntrinsicInst &II, InstCombiner &IC) {
1257   Value *Ptr = II.getOperand(0);
1258   Value *Mask = II.getOperand(1);
1259   Constant *ZeroVec = Constant::getNullValue(II.getType());
1260
1261   // Special case a zero mask since that's not a ConstantDataVector.
1262   // This masked load instruction creates a zero vector.
1263   if (isa<ConstantAggregateZero>(Mask))
1264     return IC.replaceInstUsesWith(II, ZeroVec);
1265
1266   auto *ConstMask = dyn_cast<ConstantDataVector>(Mask);
1267   if (!ConstMask)
1268     return nullptr;
1269
1270   // The mask is constant. Convert this x86 intrinsic to the LLVM instrinsic
1271   // to allow target-independent optimizations.
1272
1273   // First, cast the x86 intrinsic scalar pointer to a vector pointer to match
1274   // the LLVM intrinsic definition for the pointer argument.
1275   unsigned AddrSpace = cast<PointerType>(Ptr->getType())->getAddressSpace();
1276   PointerType *VecPtrTy = PointerType::get(II.getType(), AddrSpace);
1277   Value *PtrCast = IC.Builder->CreateBitCast(Ptr, VecPtrTy, "castvec");
1278
1279   // Second, convert the x86 XMM integer vector mask to a vector of bools based
1280   // on each element's most significant bit (the sign bit).
1281   Constant *BoolMask = getNegativeIsTrueBoolVec(ConstMask);
1282
1283   // The pass-through vector for an x86 masked load is a zero vector.
1284   CallInst *NewMaskedLoad =
1285       IC.Builder->CreateMaskedLoad(PtrCast, 1, BoolMask, ZeroVec);
1286   return IC.replaceInstUsesWith(II, NewMaskedLoad);
1287 }
1288
1289 // TODO: If the x86 backend knew how to convert a bool vector mask back to an
1290 // XMM register mask efficiently, we could transform all x86 masked intrinsics
1291 // to LLVM masked intrinsics and remove the x86 masked intrinsic defs.
1292 static bool simplifyX86MaskedStore(IntrinsicInst &II, InstCombiner &IC) {
1293   Value *Ptr = II.getOperand(0);
1294   Value *Mask = II.getOperand(1);
1295   Value *Vec = II.getOperand(2);
1296
1297   // Special case a zero mask since that's not a ConstantDataVector:
1298   // this masked store instruction does nothing.
1299   if (isa<ConstantAggregateZero>(Mask)) {
1300     IC.eraseInstFromFunction(II);
1301     return true;
1302   }
1303
1304   // The SSE2 version is too weird (eg, unaligned but non-temporal) to do
1305   // anything else at this level.
1306   if (II.getIntrinsicID() == Intrinsic::x86_sse2_maskmov_dqu)
1307     return false;
1308
1309   auto *ConstMask = dyn_cast<ConstantDataVector>(Mask);
1310   if (!ConstMask)
1311     return false;
1312
1313   // The mask is constant. Convert this x86 intrinsic to the LLVM instrinsic
1314   // to allow target-independent optimizations.
1315
1316   // First, cast the x86 intrinsic scalar pointer to a vector pointer to match
1317   // the LLVM intrinsic definition for the pointer argument.
1318   unsigned AddrSpace = cast<PointerType>(Ptr->getType())->getAddressSpace();
1319   PointerType *VecPtrTy = PointerType::get(Vec->getType(), AddrSpace);
1320   Value *PtrCast = IC.Builder->CreateBitCast(Ptr, VecPtrTy, "castvec");
1321
1322   // Second, convert the x86 XMM integer vector mask to a vector of bools based
1323   // on each element's most significant bit (the sign bit).
1324   Constant *BoolMask = getNegativeIsTrueBoolVec(ConstMask);
1325
1326   IC.Builder->CreateMaskedStore(Vec, PtrCast, 1, BoolMask);
1327
1328   // 'Replace uses' doesn't work for stores. Erase the original masked store.
1329   IC.eraseInstFromFunction(II);
1330   return true;
1331 }
1332
1333 // Returns true iff the 2 intrinsics have the same operands, limiting the
1334 // comparison to the first NumOperands.
1335 static bool haveSameOperands(const IntrinsicInst &I, const IntrinsicInst &E,
1336                              unsigned NumOperands) {
1337   assert(I.getNumArgOperands() >= NumOperands && "Not enough operands");
1338   assert(E.getNumArgOperands() >= NumOperands && "Not enough operands");
1339   for (unsigned i = 0; i < NumOperands; i++)
1340     if (I.getArgOperand(i) != E.getArgOperand(i))
1341       return false;
1342   return true;
1343 }
1344
1345 // Remove trivially empty start/end intrinsic ranges, i.e. a start
1346 // immediately followed by an end (ignoring debuginfo or other
1347 // start/end intrinsics in between). As this handles only the most trivial
1348 // cases, tracking the nesting level is not needed:
1349 //
1350 //   call @llvm.foo.start(i1 0) ; &I
1351 //   call @llvm.foo.start(i1 0)
1352 //   call @llvm.foo.end(i1 0) ; This one will not be skipped: it will be removed
1353 //   call @llvm.foo.end(i1 0)
1354 static bool removeTriviallyEmptyRange(IntrinsicInst &I, unsigned StartID,
1355                                       unsigned EndID, InstCombiner &IC) {
1356   assert(I.getIntrinsicID() == StartID &&
1357          "Start intrinsic does not have expected ID");
1358   BasicBlock::iterator BI(I), BE(I.getParent()->end());
1359   for (++BI; BI != BE; ++BI) {
1360     if (auto *E = dyn_cast<IntrinsicInst>(BI)) {
1361       if (isa<DbgInfoIntrinsic>(E) || E->getIntrinsicID() == StartID)
1362         continue;
1363       if (E->getIntrinsicID() == EndID &&
1364           haveSameOperands(I, *E, E->getNumArgOperands())) {
1365         IC.eraseInstFromFunction(*E);
1366         IC.eraseInstFromFunction(I);
1367         return true;
1368       }
1369     }
1370     break;
1371   }
1372
1373   return false;
1374 }
1375
1376 Instruction *InstCombiner::visitVAStartInst(VAStartInst &I) {
1377   removeTriviallyEmptyRange(I, Intrinsic::vastart, Intrinsic::vaend, *this);
1378   return nullptr;
1379 }
1380
1381 Instruction *InstCombiner::visitVACopyInst(VACopyInst &I) {
1382   removeTriviallyEmptyRange(I, Intrinsic::vacopy, Intrinsic::vaend, *this);
1383   return nullptr;
1384 }
1385
1386 /// CallInst simplification. This mostly only handles folding of intrinsic
1387 /// instructions. For normal calls, it allows visitCallSite to do the heavy
1388 /// lifting.
1389 Instruction *InstCombiner::visitCallInst(CallInst &CI) {
1390   auto Args = CI.arg_operands();
1391   if (Value *V = SimplifyCall(CI.getCalledValue(), Args.begin(), Args.end(), DL,
1392                               &TLI, &DT, &AC))
1393     return replaceInstUsesWith(CI, V);
1394
1395   if (isFreeCall(&CI, &TLI))
1396     return visitFree(CI);
1397
1398   // If the caller function is nounwind, mark the call as nounwind, even if the
1399   // callee isn't.
1400   if (CI.getFunction()->doesNotThrow() && !CI.doesNotThrow()) {
1401     CI.setDoesNotThrow();
1402     return &CI;
1403   }
1404
1405   IntrinsicInst *II = dyn_cast<IntrinsicInst>(&CI);
1406   if (!II) return visitCallSite(&CI);
1407
1408   // Intrinsics cannot occur in an invoke, so handle them here instead of in
1409   // visitCallSite.
1410   if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(II)) {
1411     bool Changed = false;
1412
1413     // memmove/cpy/set of zero bytes is a noop.
1414     if (Constant *NumBytes = dyn_cast<Constant>(MI->getLength())) {
1415       if (NumBytes->isNullValue())
1416         return eraseInstFromFunction(CI);
1417
1418       if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes))
1419         if (CI->getZExtValue() == 1) {
1420           // Replace the instruction with just byte operations.  We would
1421           // transform other cases to loads/stores, but we don't know if
1422           // alignment is sufficient.
1423         }
1424     }
1425
1426     // No other transformations apply to volatile transfers.
1427     if (MI->isVolatile())
1428       return nullptr;
1429
1430     // If we have a memmove and the source operation is a constant global,
1431     // then the source and dest pointers can't alias, so we can change this
1432     // into a call to memcpy.
1433     if (MemMoveInst *MMI = dyn_cast<MemMoveInst>(MI)) {
1434       if (GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource()))
1435         if (GVSrc->isConstant()) {
1436           Module *M = CI.getModule();
1437           Intrinsic::ID MemCpyID = Intrinsic::memcpy;
1438           Type *Tys[3] = { CI.getArgOperand(0)->getType(),
1439                            CI.getArgOperand(1)->getType(),
1440                            CI.getArgOperand(2)->getType() };
1441           CI.setCalledFunction(Intrinsic::getDeclaration(M, MemCpyID, Tys));
1442           Changed = true;
1443         }
1444     }
1445
1446     if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) {
1447       // memmove(x,x,size) -> noop.
1448       if (MTI->getSource() == MTI->getDest())
1449         return eraseInstFromFunction(CI);
1450     }
1451
1452     // If we can determine a pointer alignment that is bigger than currently
1453     // set, update the alignment.
1454     if (isa<MemTransferInst>(MI)) {
1455       if (Instruction *I = SimplifyMemTransfer(MI))
1456         return I;
1457     } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(MI)) {
1458       if (Instruction *I = SimplifyMemSet(MSI))
1459         return I;
1460     }
1461
1462     if (Changed) return II;
1463   }
1464
1465   auto SimplifyDemandedVectorEltsLow = [this](Value *Op, unsigned Width,
1466                                               unsigned DemandedWidth) {
1467     APInt UndefElts(Width, 0);
1468     APInt DemandedElts = APInt::getLowBitsSet(Width, DemandedWidth);
1469     return SimplifyDemandedVectorElts(Op, DemandedElts, UndefElts);
1470   };
1471
1472   switch (II->getIntrinsicID()) {
1473   default: break;
1474   case Intrinsic::objectsize:
1475     if (ConstantInt *N =
1476             lowerObjectSizeCall(II, DL, &TLI, /*MustSucceed=*/false))
1477       return replaceInstUsesWith(CI, N);
1478     return nullptr;
1479
1480   case Intrinsic::bswap: {
1481     Value *IIOperand = II->getArgOperand(0);
1482     Value *X = nullptr;
1483
1484     // bswap(bswap(x)) -> x
1485     if (match(IIOperand, m_BSwap(m_Value(X))))
1486         return replaceInstUsesWith(CI, X);
1487
1488     // bswap(trunc(bswap(x))) -> trunc(lshr(x, c))
1489     if (match(IIOperand, m_Trunc(m_BSwap(m_Value(X))))) {
1490       unsigned C = X->getType()->getPrimitiveSizeInBits() -
1491         IIOperand->getType()->getPrimitiveSizeInBits();
1492       Value *CV = ConstantInt::get(X->getType(), C);
1493       Value *V = Builder->CreateLShr(X, CV);
1494       return new TruncInst(V, IIOperand->getType());
1495     }
1496     break;
1497   }
1498
1499   case Intrinsic::bitreverse: {
1500     Value *IIOperand = II->getArgOperand(0);
1501     Value *X = nullptr;
1502
1503     // bitreverse(bitreverse(x)) -> x
1504     if (match(IIOperand, m_Intrinsic<Intrinsic::bitreverse>(m_Value(X))))
1505       return replaceInstUsesWith(CI, X);
1506     break;
1507   }
1508
1509   case Intrinsic::masked_load:
1510     if (Value *SimplifiedMaskedOp = simplifyMaskedLoad(*II, *Builder))
1511       return replaceInstUsesWith(CI, SimplifiedMaskedOp);
1512     break;
1513   case Intrinsic::masked_store:
1514     return simplifyMaskedStore(*II, *this);
1515   case Intrinsic::masked_gather:
1516     return simplifyMaskedGather(*II, *this);
1517   case Intrinsic::masked_scatter:
1518     return simplifyMaskedScatter(*II, *this);
1519
1520   case Intrinsic::powi:
1521     if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
1522       // powi(x, 0) -> 1.0
1523       if (Power->isZero())
1524         return replaceInstUsesWith(CI, ConstantFP::get(CI.getType(), 1.0));
1525       // powi(x, 1) -> x
1526       if (Power->isOne())
1527         return replaceInstUsesWith(CI, II->getArgOperand(0));
1528       // powi(x, -1) -> 1/x
1529       if (Power->isAllOnesValue())
1530         return BinaryOperator::CreateFDiv(ConstantFP::get(CI.getType(), 1.0),
1531                                           II->getArgOperand(0));
1532     }
1533     break;
1534
1535   case Intrinsic::cttz:
1536   case Intrinsic::ctlz:
1537     if (auto *I = foldCttzCtlz(*II, *this))
1538       return I;
1539     break;
1540
1541   case Intrinsic::uadd_with_overflow:
1542   case Intrinsic::sadd_with_overflow:
1543   case Intrinsic::umul_with_overflow:
1544   case Intrinsic::smul_with_overflow:
1545     if (isa<Constant>(II->getArgOperand(0)) &&
1546         !isa<Constant>(II->getArgOperand(1))) {
1547       // Canonicalize constants into the RHS.
1548       Value *LHS = II->getArgOperand(0);
1549       II->setArgOperand(0, II->getArgOperand(1));
1550       II->setArgOperand(1, LHS);
1551       return II;
1552     }
1553     LLVM_FALLTHROUGH;
1554
1555   case Intrinsic::usub_with_overflow:
1556   case Intrinsic::ssub_with_overflow: {
1557     OverflowCheckFlavor OCF =
1558         IntrinsicIDToOverflowCheckFlavor(II->getIntrinsicID());
1559     assert(OCF != OCF_INVALID && "unexpected!");
1560
1561     Value *OperationResult = nullptr;
1562     Constant *OverflowResult = nullptr;
1563     if (OptimizeOverflowCheck(OCF, II->getArgOperand(0), II->getArgOperand(1),
1564                               *II, OperationResult, OverflowResult))
1565       return CreateOverflowTuple(II, OperationResult, OverflowResult);
1566
1567     break;
1568   }
1569
1570   case Intrinsic::minnum:
1571   case Intrinsic::maxnum: {
1572     Value *Arg0 = II->getArgOperand(0);
1573     Value *Arg1 = II->getArgOperand(1);
1574     // Canonicalize constants to the RHS.
1575     if (isa<ConstantFP>(Arg0) && !isa<ConstantFP>(Arg1)) {
1576       II->setArgOperand(0, Arg1);
1577       II->setArgOperand(1, Arg0);
1578       return II;
1579     }
1580     if (Value *V = simplifyMinnumMaxnum(*II))
1581       return replaceInstUsesWith(*II, V);
1582     break;
1583   }
1584   case Intrinsic::ppc_altivec_lvx:
1585   case Intrinsic::ppc_altivec_lvxl:
1586     // Turn PPC lvx -> load if the pointer is known aligned.
1587     if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, II, &AC,
1588                                    &DT) >= 16) {
1589       Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
1590                                          PointerType::getUnqual(II->getType()));
1591       return new LoadInst(Ptr);
1592     }
1593     break;
1594   case Intrinsic::ppc_vsx_lxvw4x:
1595   case Intrinsic::ppc_vsx_lxvd2x: {
1596     // Turn PPC VSX loads into normal loads.
1597     Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
1598                                         PointerType::getUnqual(II->getType()));
1599     return new LoadInst(Ptr, Twine(""), false, 1);
1600   }
1601   case Intrinsic::ppc_altivec_stvx:
1602   case Intrinsic::ppc_altivec_stvxl:
1603     // Turn stvx -> store if the pointer is known aligned.
1604     if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, DL, II, &AC,
1605                                    &DT) >= 16) {
1606       Type *OpPtrTy =
1607         PointerType::getUnqual(II->getArgOperand(0)->getType());
1608       Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
1609       return new StoreInst(II->getArgOperand(0), Ptr);
1610     }
1611     break;
1612   case Intrinsic::ppc_vsx_stxvw4x:
1613   case Intrinsic::ppc_vsx_stxvd2x: {
1614     // Turn PPC VSX stores into normal stores.
1615     Type *OpPtrTy = PointerType::getUnqual(II->getArgOperand(0)->getType());
1616     Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
1617     return new StoreInst(II->getArgOperand(0), Ptr, false, 1);
1618   }
1619   case Intrinsic::ppc_qpx_qvlfs:
1620     // Turn PPC QPX qvlfs -> load if the pointer is known aligned.
1621     if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, II, &AC,
1622                                    &DT) >= 16) {
1623       Type *VTy = VectorType::get(Builder->getFloatTy(),
1624                                   II->getType()->getVectorNumElements());
1625       Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
1626                                          PointerType::getUnqual(VTy));
1627       Value *Load = Builder->CreateLoad(Ptr);
1628       return new FPExtInst(Load, II->getType());
1629     }
1630     break;
1631   case Intrinsic::ppc_qpx_qvlfd:
1632     // Turn PPC QPX qvlfd -> load if the pointer is known aligned.
1633     if (getOrEnforceKnownAlignment(II->getArgOperand(0), 32, DL, II, &AC,
1634                                    &DT) >= 32) {
1635       Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
1636                                          PointerType::getUnqual(II->getType()));
1637       return new LoadInst(Ptr);
1638     }
1639     break;
1640   case Intrinsic::ppc_qpx_qvstfs:
1641     // Turn PPC QPX qvstfs -> store if the pointer is known aligned.
1642     if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, DL, II, &AC,
1643                                    &DT) >= 16) {
1644       Type *VTy = VectorType::get(Builder->getFloatTy(),
1645           II->getArgOperand(0)->getType()->getVectorNumElements());
1646       Value *TOp = Builder->CreateFPTrunc(II->getArgOperand(0), VTy);
1647       Type *OpPtrTy = PointerType::getUnqual(VTy);
1648       Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
1649       return new StoreInst(TOp, Ptr);
1650     }
1651     break;
1652   case Intrinsic::ppc_qpx_qvstfd:
1653     // Turn PPC QPX qvstfd -> store if the pointer is known aligned.
1654     if (getOrEnforceKnownAlignment(II->getArgOperand(1), 32, DL, II, &AC,
1655                                    &DT) >= 32) {
1656       Type *OpPtrTy =
1657         PointerType::getUnqual(II->getArgOperand(0)->getType());
1658       Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
1659       return new StoreInst(II->getArgOperand(0), Ptr);
1660     }
1661     break;
1662
1663   case Intrinsic::x86_vcvtph2ps_128:
1664   case Intrinsic::x86_vcvtph2ps_256: {
1665     auto Arg = II->getArgOperand(0);
1666     auto ArgType = cast<VectorType>(Arg->getType());
1667     auto RetType = cast<VectorType>(II->getType());
1668     unsigned ArgWidth = ArgType->getNumElements();
1669     unsigned RetWidth = RetType->getNumElements();
1670     assert(RetWidth <= ArgWidth && "Unexpected input/return vector widths");
1671     assert(ArgType->isIntOrIntVectorTy() &&
1672            ArgType->getScalarSizeInBits() == 16 &&
1673            "CVTPH2PS input type should be 16-bit integer vector");
1674     assert(RetType->getScalarType()->isFloatTy() &&
1675            "CVTPH2PS output type should be 32-bit float vector");
1676
1677     // Constant folding: Convert to generic half to single conversion.
1678     if (isa<ConstantAggregateZero>(Arg))
1679       return replaceInstUsesWith(*II, ConstantAggregateZero::get(RetType));
1680
1681     if (isa<ConstantDataVector>(Arg)) {
1682       auto VectorHalfAsShorts = Arg;
1683       if (RetWidth < ArgWidth) {
1684         SmallVector<uint32_t, 8> SubVecMask;
1685         for (unsigned i = 0; i != RetWidth; ++i)
1686           SubVecMask.push_back((int)i);
1687         VectorHalfAsShorts = Builder->CreateShuffleVector(
1688             Arg, UndefValue::get(ArgType), SubVecMask);
1689       }
1690
1691       auto VectorHalfType =
1692           VectorType::get(Type::getHalfTy(II->getContext()), RetWidth);
1693       auto VectorHalfs =
1694           Builder->CreateBitCast(VectorHalfAsShorts, VectorHalfType);
1695       auto VectorFloats = Builder->CreateFPExt(VectorHalfs, RetType);
1696       return replaceInstUsesWith(*II, VectorFloats);
1697     }
1698
1699     // We only use the lowest lanes of the argument.
1700     if (Value *V = SimplifyDemandedVectorEltsLow(Arg, ArgWidth, RetWidth)) {
1701       II->setArgOperand(0, V);
1702       return II;
1703     }
1704     break;
1705   }
1706
1707   case Intrinsic::x86_sse_cvtss2si:
1708   case Intrinsic::x86_sse_cvtss2si64:
1709   case Intrinsic::x86_sse_cvttss2si:
1710   case Intrinsic::x86_sse_cvttss2si64:
1711   case Intrinsic::x86_sse2_cvtsd2si:
1712   case Intrinsic::x86_sse2_cvtsd2si64:
1713   case Intrinsic::x86_sse2_cvttsd2si:
1714   case Intrinsic::x86_sse2_cvttsd2si64:
1715   case Intrinsic::x86_avx512_vcvtss2si32:
1716   case Intrinsic::x86_avx512_vcvtss2si64:
1717   case Intrinsic::x86_avx512_vcvtss2usi32:
1718   case Intrinsic::x86_avx512_vcvtss2usi64:
1719   case Intrinsic::x86_avx512_vcvtsd2si32:
1720   case Intrinsic::x86_avx512_vcvtsd2si64:
1721   case Intrinsic::x86_avx512_vcvtsd2usi32:
1722   case Intrinsic::x86_avx512_vcvtsd2usi64:
1723   case Intrinsic::x86_avx512_cvttss2si:
1724   case Intrinsic::x86_avx512_cvttss2si64:
1725   case Intrinsic::x86_avx512_cvttss2usi:
1726   case Intrinsic::x86_avx512_cvttss2usi64:
1727   case Intrinsic::x86_avx512_cvttsd2si:
1728   case Intrinsic::x86_avx512_cvttsd2si64:
1729   case Intrinsic::x86_avx512_cvttsd2usi:
1730   case Intrinsic::x86_avx512_cvttsd2usi64: {
1731     // These intrinsics only demand the 0th element of their input vectors. If
1732     // we can simplify the input based on that, do so now.
1733     Value *Arg = II->getArgOperand(0);
1734     unsigned VWidth = Arg->getType()->getVectorNumElements();
1735     if (Value *V = SimplifyDemandedVectorEltsLow(Arg, VWidth, 1)) {
1736       II->setArgOperand(0, V);
1737       return II;
1738     }
1739     break;
1740   }
1741
1742   case Intrinsic::x86_mmx_pmovmskb:
1743   case Intrinsic::x86_sse_movmsk_ps:
1744   case Intrinsic::x86_sse2_movmsk_pd:
1745   case Intrinsic::x86_sse2_pmovmskb_128:
1746   case Intrinsic::x86_avx_movmsk_pd_256:
1747   case Intrinsic::x86_avx_movmsk_ps_256:
1748   case Intrinsic::x86_avx2_pmovmskb: {
1749     if (Value *V = simplifyX86movmsk(*II, *Builder))
1750       return replaceInstUsesWith(*II, V);
1751     break;
1752   }
1753
1754   case Intrinsic::x86_sse_comieq_ss:
1755   case Intrinsic::x86_sse_comige_ss:
1756   case Intrinsic::x86_sse_comigt_ss:
1757   case Intrinsic::x86_sse_comile_ss:
1758   case Intrinsic::x86_sse_comilt_ss:
1759   case Intrinsic::x86_sse_comineq_ss:
1760   case Intrinsic::x86_sse_ucomieq_ss:
1761   case Intrinsic::x86_sse_ucomige_ss:
1762   case Intrinsic::x86_sse_ucomigt_ss:
1763   case Intrinsic::x86_sse_ucomile_ss:
1764   case Intrinsic::x86_sse_ucomilt_ss:
1765   case Intrinsic::x86_sse_ucomineq_ss:
1766   case Intrinsic::x86_sse2_comieq_sd:
1767   case Intrinsic::x86_sse2_comige_sd:
1768   case Intrinsic::x86_sse2_comigt_sd:
1769   case Intrinsic::x86_sse2_comile_sd:
1770   case Intrinsic::x86_sse2_comilt_sd:
1771   case Intrinsic::x86_sse2_comineq_sd:
1772   case Intrinsic::x86_sse2_ucomieq_sd:
1773   case Intrinsic::x86_sse2_ucomige_sd:
1774   case Intrinsic::x86_sse2_ucomigt_sd:
1775   case Intrinsic::x86_sse2_ucomile_sd:
1776   case Intrinsic::x86_sse2_ucomilt_sd:
1777   case Intrinsic::x86_sse2_ucomineq_sd:
1778   case Intrinsic::x86_avx512_vcomi_ss:
1779   case Intrinsic::x86_avx512_vcomi_sd:
1780   case Intrinsic::x86_avx512_mask_cmp_ss:
1781   case Intrinsic::x86_avx512_mask_cmp_sd: {
1782     // These intrinsics only demand the 0th element of their input vectors. If
1783     // we can simplify the input based on that, do so now.
1784     bool MadeChange = false;
1785     Value *Arg0 = II->getArgOperand(0);
1786     Value *Arg1 = II->getArgOperand(1);
1787     unsigned VWidth = Arg0->getType()->getVectorNumElements();
1788     if (Value *V = SimplifyDemandedVectorEltsLow(Arg0, VWidth, 1)) {
1789       II->setArgOperand(0, V);
1790       MadeChange = true;
1791     }
1792     if (Value *V = SimplifyDemandedVectorEltsLow(Arg1, VWidth, 1)) {
1793       II->setArgOperand(1, V);
1794       MadeChange = true;
1795     }
1796     if (MadeChange)
1797       return II;
1798     break;
1799   }
1800
1801   case Intrinsic::x86_avx512_mask_add_ps_512:
1802   case Intrinsic::x86_avx512_mask_div_ps_512:
1803   case Intrinsic::x86_avx512_mask_mul_ps_512:
1804   case Intrinsic::x86_avx512_mask_sub_ps_512:
1805   case Intrinsic::x86_avx512_mask_add_pd_512:
1806   case Intrinsic::x86_avx512_mask_div_pd_512:
1807   case Intrinsic::x86_avx512_mask_mul_pd_512:
1808   case Intrinsic::x86_avx512_mask_sub_pd_512:
1809     // If the rounding mode is CUR_DIRECTION(4) we can turn these into regular
1810     // IR operations.
1811     if (auto *R = dyn_cast<ConstantInt>(II->getArgOperand(4))) {
1812       if (R->getValue() == 4) {
1813         Value *Arg0 = II->getArgOperand(0);
1814         Value *Arg1 = II->getArgOperand(1);
1815
1816         Value *V;
1817         switch (II->getIntrinsicID()) {
1818         default: llvm_unreachable("Case stmts out of sync!");
1819         case Intrinsic::x86_avx512_mask_add_ps_512:
1820         case Intrinsic::x86_avx512_mask_add_pd_512:
1821           V = Builder->CreateFAdd(Arg0, Arg1);
1822           break;
1823         case Intrinsic::x86_avx512_mask_sub_ps_512:
1824         case Intrinsic::x86_avx512_mask_sub_pd_512:
1825           V = Builder->CreateFSub(Arg0, Arg1);
1826           break;
1827         case Intrinsic::x86_avx512_mask_mul_ps_512:
1828         case Intrinsic::x86_avx512_mask_mul_pd_512:
1829           V = Builder->CreateFMul(Arg0, Arg1);
1830           break;
1831         case Intrinsic::x86_avx512_mask_div_ps_512:
1832         case Intrinsic::x86_avx512_mask_div_pd_512:
1833           V = Builder->CreateFDiv(Arg0, Arg1);
1834           break;
1835         }
1836
1837         // Create a select for the masking.
1838         V = emitX86MaskSelect(II->getArgOperand(3), V, II->getArgOperand(2),
1839                               *Builder);
1840         return replaceInstUsesWith(*II, V);
1841       }
1842     }
1843     break;
1844
1845   case Intrinsic::x86_avx512_mask_add_ss_round:
1846   case Intrinsic::x86_avx512_mask_div_ss_round:
1847   case Intrinsic::x86_avx512_mask_mul_ss_round:
1848   case Intrinsic::x86_avx512_mask_sub_ss_round:
1849   case Intrinsic::x86_avx512_mask_add_sd_round:
1850   case Intrinsic::x86_avx512_mask_div_sd_round:
1851   case Intrinsic::x86_avx512_mask_mul_sd_round:
1852   case Intrinsic::x86_avx512_mask_sub_sd_round:
1853     // If the rounding mode is CUR_DIRECTION(4) we can turn these into regular
1854     // IR operations.
1855     if (auto *R = dyn_cast<ConstantInt>(II->getArgOperand(4))) {
1856       if (R->getValue() == 4) {
1857         // Extract the element as scalars.
1858         Value *Arg0 = II->getArgOperand(0);
1859         Value *Arg1 = II->getArgOperand(1);
1860         Value *LHS = Builder->CreateExtractElement(Arg0, (uint64_t)0);
1861         Value *RHS = Builder->CreateExtractElement(Arg1, (uint64_t)0);
1862
1863         Value *V;
1864         switch (II->getIntrinsicID()) {
1865         default: llvm_unreachable("Case stmts out of sync!");
1866         case Intrinsic::x86_avx512_mask_add_ss_round:
1867         case Intrinsic::x86_avx512_mask_add_sd_round:
1868           V = Builder->CreateFAdd(LHS, RHS);
1869           break;
1870         case Intrinsic::x86_avx512_mask_sub_ss_round:
1871         case Intrinsic::x86_avx512_mask_sub_sd_round:
1872           V = Builder->CreateFSub(LHS, RHS);
1873           break;
1874         case Intrinsic::x86_avx512_mask_mul_ss_round:
1875         case Intrinsic::x86_avx512_mask_mul_sd_round:
1876           V = Builder->CreateFMul(LHS, RHS);
1877           break;
1878         case Intrinsic::x86_avx512_mask_div_ss_round:
1879         case Intrinsic::x86_avx512_mask_div_sd_round:
1880           V = Builder->CreateFDiv(LHS, RHS);
1881           break;
1882         }
1883
1884         // Handle the masking aspect of the intrinsic.
1885         Value *Mask = II->getArgOperand(3);
1886         auto *C = dyn_cast<ConstantInt>(Mask);
1887         // We don't need a select if we know the mask bit is a 1.
1888         if (!C || !C->getValue()[0]) {
1889           // Cast the mask to an i1 vector and then extract the lowest element.
1890           auto *MaskTy = VectorType::get(Builder->getInt1Ty(),
1891                              cast<IntegerType>(Mask->getType())->getBitWidth());
1892           Mask = Builder->CreateBitCast(Mask, MaskTy);
1893           Mask = Builder->CreateExtractElement(Mask, (uint64_t)0);
1894           // Extract the lowest element from the passthru operand.
1895           Value *Passthru = Builder->CreateExtractElement(II->getArgOperand(2),
1896                                                           (uint64_t)0);
1897           V = Builder->CreateSelect(Mask, V, Passthru);
1898         }
1899
1900         // Insert the result back into the original argument 0.
1901         V = Builder->CreateInsertElement(Arg0, V, (uint64_t)0);
1902
1903         return replaceInstUsesWith(*II, V);
1904       }
1905     }
1906     LLVM_FALLTHROUGH;
1907
1908   // X86 scalar intrinsics simplified with SimplifyDemandedVectorElts.
1909   case Intrinsic::x86_avx512_mask_max_ss_round:
1910   case Intrinsic::x86_avx512_mask_min_ss_round:
1911   case Intrinsic::x86_avx512_mask_max_sd_round:
1912   case Intrinsic::x86_avx512_mask_min_sd_round:
1913   case Intrinsic::x86_avx512_mask_vfmadd_ss:
1914   case Intrinsic::x86_avx512_mask_vfmadd_sd:
1915   case Intrinsic::x86_avx512_maskz_vfmadd_ss:
1916   case Intrinsic::x86_avx512_maskz_vfmadd_sd:
1917   case Intrinsic::x86_avx512_mask3_vfmadd_ss:
1918   case Intrinsic::x86_avx512_mask3_vfmadd_sd:
1919   case Intrinsic::x86_avx512_mask3_vfmsub_ss:
1920   case Intrinsic::x86_avx512_mask3_vfmsub_sd:
1921   case Intrinsic::x86_avx512_mask3_vfnmsub_ss:
1922   case Intrinsic::x86_avx512_mask3_vfnmsub_sd:
1923   case Intrinsic::x86_fma_vfmadd_ss:
1924   case Intrinsic::x86_fma_vfmsub_ss:
1925   case Intrinsic::x86_fma_vfnmadd_ss:
1926   case Intrinsic::x86_fma_vfnmsub_ss:
1927   case Intrinsic::x86_fma_vfmadd_sd:
1928   case Intrinsic::x86_fma_vfmsub_sd:
1929   case Intrinsic::x86_fma_vfnmadd_sd:
1930   case Intrinsic::x86_fma_vfnmsub_sd:
1931   case Intrinsic::x86_sse_cmp_ss:
1932   case Intrinsic::x86_sse_min_ss:
1933   case Intrinsic::x86_sse_max_ss:
1934   case Intrinsic::x86_sse2_cmp_sd:
1935   case Intrinsic::x86_sse2_min_sd:
1936   case Intrinsic::x86_sse2_max_sd:
1937   case Intrinsic::x86_sse41_round_ss:
1938   case Intrinsic::x86_sse41_round_sd:
1939   case Intrinsic::x86_xop_vfrcz_ss:
1940   case Intrinsic::x86_xop_vfrcz_sd: {
1941    unsigned VWidth = II->getType()->getVectorNumElements();
1942    APInt UndefElts(VWidth, 0);
1943    APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth));
1944    if (Value *V = SimplifyDemandedVectorElts(II, AllOnesEltMask, UndefElts)) {
1945      if (V != II)
1946        return replaceInstUsesWith(*II, V);
1947      return II;
1948    }
1949    break;
1950   }
1951
1952   // Constant fold ashr( <A x Bi>, Ci ).
1953   // Constant fold lshr( <A x Bi>, Ci ).
1954   // Constant fold shl( <A x Bi>, Ci ).
1955   case Intrinsic::x86_sse2_psrai_d:
1956   case Intrinsic::x86_sse2_psrai_w:
1957   case Intrinsic::x86_avx2_psrai_d:
1958   case Intrinsic::x86_avx2_psrai_w:
1959   case Intrinsic::x86_avx512_psrai_q_128:
1960   case Intrinsic::x86_avx512_psrai_q_256:
1961   case Intrinsic::x86_avx512_psrai_d_512:
1962   case Intrinsic::x86_avx512_psrai_q_512:
1963   case Intrinsic::x86_avx512_psrai_w_512:
1964   case Intrinsic::x86_sse2_psrli_d:
1965   case Intrinsic::x86_sse2_psrli_q:
1966   case Intrinsic::x86_sse2_psrli_w:
1967   case Intrinsic::x86_avx2_psrli_d:
1968   case Intrinsic::x86_avx2_psrli_q:
1969   case Intrinsic::x86_avx2_psrli_w:
1970   case Intrinsic::x86_avx512_psrli_d_512:
1971   case Intrinsic::x86_avx512_psrli_q_512:
1972   case Intrinsic::x86_avx512_psrli_w_512:
1973   case Intrinsic::x86_sse2_pslli_d:
1974   case Intrinsic::x86_sse2_pslli_q:
1975   case Intrinsic::x86_sse2_pslli_w:
1976   case Intrinsic::x86_avx2_pslli_d:
1977   case Intrinsic::x86_avx2_pslli_q:
1978   case Intrinsic::x86_avx2_pslli_w:
1979   case Intrinsic::x86_avx512_pslli_d_512:
1980   case Intrinsic::x86_avx512_pslli_q_512:
1981   case Intrinsic::x86_avx512_pslli_w_512:
1982     if (Value *V = simplifyX86immShift(*II, *Builder))
1983       return replaceInstUsesWith(*II, V);
1984     break;
1985
1986   case Intrinsic::x86_sse2_psra_d:
1987   case Intrinsic::x86_sse2_psra_w:
1988   case Intrinsic::x86_avx2_psra_d:
1989   case Intrinsic::x86_avx2_psra_w:
1990   case Intrinsic::x86_avx512_psra_q_128:
1991   case Intrinsic::x86_avx512_psra_q_256:
1992   case Intrinsic::x86_avx512_psra_d_512:
1993   case Intrinsic::x86_avx512_psra_q_512:
1994   case Intrinsic::x86_avx512_psra_w_512:
1995   case Intrinsic::x86_sse2_psrl_d:
1996   case Intrinsic::x86_sse2_psrl_q:
1997   case Intrinsic::x86_sse2_psrl_w:
1998   case Intrinsic::x86_avx2_psrl_d:
1999   case Intrinsic::x86_avx2_psrl_q:
2000   case Intrinsic::x86_avx2_psrl_w:
2001   case Intrinsic::x86_avx512_psrl_d_512:
2002   case Intrinsic::x86_avx512_psrl_q_512:
2003   case Intrinsic::x86_avx512_psrl_w_512:
2004   case Intrinsic::x86_sse2_psll_d:
2005   case Intrinsic::x86_sse2_psll_q:
2006   case Intrinsic::x86_sse2_psll_w:
2007   case Intrinsic::x86_avx2_psll_d:
2008   case Intrinsic::x86_avx2_psll_q:
2009   case Intrinsic::x86_avx2_psll_w:
2010   case Intrinsic::x86_avx512_psll_d_512:
2011   case Intrinsic::x86_avx512_psll_q_512:
2012   case Intrinsic::x86_avx512_psll_w_512: {
2013     if (Value *V = simplifyX86immShift(*II, *Builder))
2014       return replaceInstUsesWith(*II, V);
2015
2016     // SSE2/AVX2 uses only the first 64-bits of the 128-bit vector
2017     // operand to compute the shift amount.
2018     Value *Arg1 = II->getArgOperand(1);
2019     assert(Arg1->getType()->getPrimitiveSizeInBits() == 128 &&
2020            "Unexpected packed shift size");
2021     unsigned VWidth = Arg1->getType()->getVectorNumElements();
2022
2023     if (Value *V = SimplifyDemandedVectorEltsLow(Arg1, VWidth, VWidth / 2)) {
2024       II->setArgOperand(1, V);
2025       return II;
2026     }
2027     break;
2028   }
2029
2030   case Intrinsic::x86_avx2_psllv_d:
2031   case Intrinsic::x86_avx2_psllv_d_256:
2032   case Intrinsic::x86_avx2_psllv_q:
2033   case Intrinsic::x86_avx2_psllv_q_256:
2034   case Intrinsic::x86_avx512_psllv_d_512:
2035   case Intrinsic::x86_avx512_psllv_q_512:
2036   case Intrinsic::x86_avx512_psllv_w_128:
2037   case Intrinsic::x86_avx512_psllv_w_256:
2038   case Intrinsic::x86_avx512_psllv_w_512:
2039   case Intrinsic::x86_avx2_psrav_d:
2040   case Intrinsic::x86_avx2_psrav_d_256:
2041   case Intrinsic::x86_avx512_psrav_q_128:
2042   case Intrinsic::x86_avx512_psrav_q_256:
2043   case Intrinsic::x86_avx512_psrav_d_512:
2044   case Intrinsic::x86_avx512_psrav_q_512:
2045   case Intrinsic::x86_avx512_psrav_w_128:
2046   case Intrinsic::x86_avx512_psrav_w_256:
2047   case Intrinsic::x86_avx512_psrav_w_512:
2048   case Intrinsic::x86_avx2_psrlv_d:
2049   case Intrinsic::x86_avx2_psrlv_d_256:
2050   case Intrinsic::x86_avx2_psrlv_q:
2051   case Intrinsic::x86_avx2_psrlv_q_256:
2052   case Intrinsic::x86_avx512_psrlv_d_512:
2053   case Intrinsic::x86_avx512_psrlv_q_512:
2054   case Intrinsic::x86_avx512_psrlv_w_128:
2055   case Intrinsic::x86_avx512_psrlv_w_256:
2056   case Intrinsic::x86_avx512_psrlv_w_512:
2057     if (Value *V = simplifyX86varShift(*II, *Builder))
2058       return replaceInstUsesWith(*II, V);
2059     break;
2060
2061   case Intrinsic::x86_sse2_pmulu_dq:
2062   case Intrinsic::x86_sse41_pmuldq:
2063   case Intrinsic::x86_avx2_pmul_dq:
2064   case Intrinsic::x86_avx2_pmulu_dq:
2065   case Intrinsic::x86_avx512_pmul_dq_512:
2066   case Intrinsic::x86_avx512_pmulu_dq_512: {
2067     unsigned VWidth = II->getType()->getVectorNumElements();
2068     APInt UndefElts(VWidth, 0);
2069     APInt DemandedElts = APInt::getAllOnesValue(VWidth);
2070     if (Value *V = SimplifyDemandedVectorElts(II, DemandedElts, UndefElts)) {
2071       if (V != II)
2072         return replaceInstUsesWith(*II, V);
2073       return II;
2074     }
2075     break;
2076   }
2077
2078   case Intrinsic::x86_sse41_insertps:
2079     if (Value *V = simplifyX86insertps(*II, *Builder))
2080       return replaceInstUsesWith(*II, V);
2081     break;
2082
2083   case Intrinsic::x86_sse4a_extrq: {
2084     Value *Op0 = II->getArgOperand(0);
2085     Value *Op1 = II->getArgOperand(1);
2086     unsigned VWidth0 = Op0->getType()->getVectorNumElements();
2087     unsigned VWidth1 = Op1->getType()->getVectorNumElements();
2088     assert(Op0->getType()->getPrimitiveSizeInBits() == 128 &&
2089            Op1->getType()->getPrimitiveSizeInBits() == 128 && VWidth0 == 2 &&
2090            VWidth1 == 16 && "Unexpected operand sizes");
2091
2092     // See if we're dealing with constant values.
2093     Constant *C1 = dyn_cast<Constant>(Op1);
2094     ConstantInt *CILength =
2095         C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)0))
2096            : nullptr;
2097     ConstantInt *CIIndex =
2098         C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)1))
2099            : nullptr;
2100
2101     // Attempt to simplify to a constant, shuffle vector or EXTRQI call.
2102     if (Value *V = simplifyX86extrq(*II, Op0, CILength, CIIndex, *Builder))
2103       return replaceInstUsesWith(*II, V);
2104
2105     // EXTRQ only uses the lowest 64-bits of the first 128-bit vector
2106     // operands and the lowest 16-bits of the second.
2107     bool MadeChange = false;
2108     if (Value *V = SimplifyDemandedVectorEltsLow(Op0, VWidth0, 1)) {
2109       II->setArgOperand(0, V);
2110       MadeChange = true;
2111     }
2112     if (Value *V = SimplifyDemandedVectorEltsLow(Op1, VWidth1, 2)) {
2113       II->setArgOperand(1, V);
2114       MadeChange = true;
2115     }
2116     if (MadeChange)
2117       return II;
2118     break;
2119   }
2120
2121   case Intrinsic::x86_sse4a_extrqi: {
2122     // EXTRQI: Extract Length bits starting from Index. Zero pad the remaining
2123     // bits of the lower 64-bits. The upper 64-bits are undefined.
2124     Value *Op0 = II->getArgOperand(0);
2125     unsigned VWidth = Op0->getType()->getVectorNumElements();
2126     assert(Op0->getType()->getPrimitiveSizeInBits() == 128 && VWidth == 2 &&
2127            "Unexpected operand size");
2128
2129     // See if we're dealing with constant values.
2130     ConstantInt *CILength = dyn_cast<ConstantInt>(II->getArgOperand(1));
2131     ConstantInt *CIIndex = dyn_cast<ConstantInt>(II->getArgOperand(2));
2132
2133     // Attempt to simplify to a constant or shuffle vector.
2134     if (Value *V = simplifyX86extrq(*II, Op0, CILength, CIIndex, *Builder))
2135       return replaceInstUsesWith(*II, V);
2136
2137     // EXTRQI only uses the lowest 64-bits of the first 128-bit vector
2138     // operand.
2139     if (Value *V = SimplifyDemandedVectorEltsLow(Op0, VWidth, 1)) {
2140       II->setArgOperand(0, V);
2141       return II;
2142     }
2143     break;
2144   }
2145
2146   case Intrinsic::x86_sse4a_insertq: {
2147     Value *Op0 = II->getArgOperand(0);
2148     Value *Op1 = II->getArgOperand(1);
2149     unsigned VWidth = Op0->getType()->getVectorNumElements();
2150     assert(Op0->getType()->getPrimitiveSizeInBits() == 128 &&
2151            Op1->getType()->getPrimitiveSizeInBits() == 128 && VWidth == 2 &&
2152            Op1->getType()->getVectorNumElements() == 2 &&
2153            "Unexpected operand size");
2154
2155     // See if we're dealing with constant values.
2156     Constant *C1 = dyn_cast<Constant>(Op1);
2157     ConstantInt *CI11 =
2158         C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)1))
2159            : nullptr;
2160
2161     // Attempt to simplify to a constant, shuffle vector or INSERTQI call.
2162     if (CI11) {
2163       const APInt &V11 = CI11->getValue();
2164       APInt Len = V11.zextOrTrunc(6);
2165       APInt Idx = V11.lshr(8).zextOrTrunc(6);
2166       if (Value *V = simplifyX86insertq(*II, Op0, Op1, Len, Idx, *Builder))
2167         return replaceInstUsesWith(*II, V);
2168     }
2169
2170     // INSERTQ only uses the lowest 64-bits of the first 128-bit vector
2171     // operand.
2172     if (Value *V = SimplifyDemandedVectorEltsLow(Op0, VWidth, 1)) {
2173       II->setArgOperand(0, V);
2174       return II;
2175     }
2176     break;
2177   }
2178
2179   case Intrinsic::x86_sse4a_insertqi: {
2180     // INSERTQI: Extract lowest Length bits from lower half of second source and
2181     // insert over first source starting at Index bit. The upper 64-bits are
2182     // undefined.
2183     Value *Op0 = II->getArgOperand(0);
2184     Value *Op1 = II->getArgOperand(1);
2185     unsigned VWidth0 = Op0->getType()->getVectorNumElements();
2186     unsigned VWidth1 = Op1->getType()->getVectorNumElements();
2187     assert(Op0->getType()->getPrimitiveSizeInBits() == 128 &&
2188            Op1->getType()->getPrimitiveSizeInBits() == 128 && VWidth0 == 2 &&
2189            VWidth1 == 2 && "Unexpected operand sizes");
2190
2191     // See if we're dealing with constant values.
2192     ConstantInt *CILength = dyn_cast<ConstantInt>(II->getArgOperand(2));
2193     ConstantInt *CIIndex = dyn_cast<ConstantInt>(II->getArgOperand(3));
2194
2195     // Attempt to simplify to a constant or shuffle vector.
2196     if (CILength && CIIndex) {
2197       APInt Len = CILength->getValue().zextOrTrunc(6);
2198       APInt Idx = CIIndex->getValue().zextOrTrunc(6);
2199       if (Value *V = simplifyX86insertq(*II, Op0, Op1, Len, Idx, *Builder))
2200         return replaceInstUsesWith(*II, V);
2201     }
2202
2203     // INSERTQI only uses the lowest 64-bits of the first two 128-bit vector
2204     // operands.
2205     bool MadeChange = false;
2206     if (Value *V = SimplifyDemandedVectorEltsLow(Op0, VWidth0, 1)) {
2207       II->setArgOperand(0, V);
2208       MadeChange = true;
2209     }
2210     if (Value *V = SimplifyDemandedVectorEltsLow(Op1, VWidth1, 1)) {
2211       II->setArgOperand(1, V);
2212       MadeChange = true;
2213     }
2214     if (MadeChange)
2215       return II;
2216     break;
2217   }
2218
2219   case Intrinsic::x86_sse41_pblendvb:
2220   case Intrinsic::x86_sse41_blendvps:
2221   case Intrinsic::x86_sse41_blendvpd:
2222   case Intrinsic::x86_avx_blendv_ps_256:
2223   case Intrinsic::x86_avx_blendv_pd_256:
2224   case Intrinsic::x86_avx2_pblendvb: {
2225     // Convert blendv* to vector selects if the mask is constant.
2226     // This optimization is convoluted because the intrinsic is defined as
2227     // getting a vector of floats or doubles for the ps and pd versions.
2228     // FIXME: That should be changed.
2229
2230     Value *Op0 = II->getArgOperand(0);
2231     Value *Op1 = II->getArgOperand(1);
2232     Value *Mask = II->getArgOperand(2);
2233
2234     // fold (blend A, A, Mask) -> A
2235     if (Op0 == Op1)
2236       return replaceInstUsesWith(CI, Op0);
2237
2238     // Zero Mask - select 1st argument.
2239     if (isa<ConstantAggregateZero>(Mask))
2240       return replaceInstUsesWith(CI, Op0);
2241
2242     // Constant Mask - select 1st/2nd argument lane based on top bit of mask.
2243     if (auto *ConstantMask = dyn_cast<ConstantDataVector>(Mask)) {
2244       Constant *NewSelector = getNegativeIsTrueBoolVec(ConstantMask);
2245       return SelectInst::Create(NewSelector, Op1, Op0, "blendv");
2246     }
2247     break;
2248   }
2249
2250   case Intrinsic::x86_ssse3_pshuf_b_128:
2251   case Intrinsic::x86_avx2_pshuf_b:
2252   case Intrinsic::x86_avx512_pshuf_b_512:
2253     if (Value *V = simplifyX86pshufb(*II, *Builder))
2254       return replaceInstUsesWith(*II, V);
2255     break;
2256
2257   case Intrinsic::x86_avx_vpermilvar_ps:
2258   case Intrinsic::x86_avx_vpermilvar_ps_256:
2259   case Intrinsic::x86_avx512_vpermilvar_ps_512:
2260   case Intrinsic::x86_avx_vpermilvar_pd:
2261   case Intrinsic::x86_avx_vpermilvar_pd_256:
2262   case Intrinsic::x86_avx512_vpermilvar_pd_512:
2263     if (Value *V = simplifyX86vpermilvar(*II, *Builder))
2264       return replaceInstUsesWith(*II, V);
2265     break;
2266
2267   case Intrinsic::x86_avx2_permd:
2268   case Intrinsic::x86_avx2_permps:
2269     if (Value *V = simplifyX86vpermv(*II, *Builder))
2270       return replaceInstUsesWith(*II, V);
2271     break;
2272
2273   case Intrinsic::x86_avx512_mask_permvar_df_256:
2274   case Intrinsic::x86_avx512_mask_permvar_df_512:
2275   case Intrinsic::x86_avx512_mask_permvar_di_256:
2276   case Intrinsic::x86_avx512_mask_permvar_di_512:
2277   case Intrinsic::x86_avx512_mask_permvar_hi_128:
2278   case Intrinsic::x86_avx512_mask_permvar_hi_256:
2279   case Intrinsic::x86_avx512_mask_permvar_hi_512:
2280   case Intrinsic::x86_avx512_mask_permvar_qi_128:
2281   case Intrinsic::x86_avx512_mask_permvar_qi_256:
2282   case Intrinsic::x86_avx512_mask_permvar_qi_512:
2283   case Intrinsic::x86_avx512_mask_permvar_sf_256:
2284   case Intrinsic::x86_avx512_mask_permvar_sf_512:
2285   case Intrinsic::x86_avx512_mask_permvar_si_256:
2286   case Intrinsic::x86_avx512_mask_permvar_si_512:
2287     if (Value *V = simplifyX86vpermv(*II, *Builder)) {
2288       // We simplified the permuting, now create a select for the masking.
2289       V = emitX86MaskSelect(II->getArgOperand(3), V, II->getArgOperand(2),
2290                             *Builder);
2291       return replaceInstUsesWith(*II, V);
2292     }
2293     break;
2294
2295   case Intrinsic::x86_avx_vperm2f128_pd_256:
2296   case Intrinsic::x86_avx_vperm2f128_ps_256:
2297   case Intrinsic::x86_avx_vperm2f128_si_256:
2298   case Intrinsic::x86_avx2_vperm2i128:
2299     if (Value *V = simplifyX86vperm2(*II, *Builder))
2300       return replaceInstUsesWith(*II, V);
2301     break;
2302
2303   case Intrinsic::x86_avx_maskload_ps:
2304   case Intrinsic::x86_avx_maskload_pd:
2305   case Intrinsic::x86_avx_maskload_ps_256:
2306   case Intrinsic::x86_avx_maskload_pd_256:
2307   case Intrinsic::x86_avx2_maskload_d:
2308   case Intrinsic::x86_avx2_maskload_q:
2309   case Intrinsic::x86_avx2_maskload_d_256:
2310   case Intrinsic::x86_avx2_maskload_q_256:
2311     if (Instruction *I = simplifyX86MaskedLoad(*II, *this))
2312       return I;
2313     break;
2314
2315   case Intrinsic::x86_sse2_maskmov_dqu:
2316   case Intrinsic::x86_avx_maskstore_ps:
2317   case Intrinsic::x86_avx_maskstore_pd:
2318   case Intrinsic::x86_avx_maskstore_ps_256:
2319   case Intrinsic::x86_avx_maskstore_pd_256:
2320   case Intrinsic::x86_avx2_maskstore_d:
2321   case Intrinsic::x86_avx2_maskstore_q:
2322   case Intrinsic::x86_avx2_maskstore_d_256:
2323   case Intrinsic::x86_avx2_maskstore_q_256:
2324     if (simplifyX86MaskedStore(*II, *this))
2325       return nullptr;
2326     break;
2327
2328   case Intrinsic::x86_xop_vpcomb:
2329   case Intrinsic::x86_xop_vpcomd:
2330   case Intrinsic::x86_xop_vpcomq:
2331   case Intrinsic::x86_xop_vpcomw:
2332     if (Value *V = simplifyX86vpcom(*II, *Builder, true))
2333       return replaceInstUsesWith(*II, V);
2334     break;
2335
2336   case Intrinsic::x86_xop_vpcomub:
2337   case Intrinsic::x86_xop_vpcomud:
2338   case Intrinsic::x86_xop_vpcomuq:
2339   case Intrinsic::x86_xop_vpcomuw:
2340     if (Value *V = simplifyX86vpcom(*II, *Builder, false))
2341       return replaceInstUsesWith(*II, V);
2342     break;
2343
2344   case Intrinsic::ppc_altivec_vperm:
2345     // Turn vperm(V1,V2,mask) -> shuffle(V1,V2,mask) if mask is a constant.
2346     // Note that ppc_altivec_vperm has a big-endian bias, so when creating
2347     // a vectorshuffle for little endian, we must undo the transformation
2348     // performed on vec_perm in altivec.h.  That is, we must complement
2349     // the permutation mask with respect to 31 and reverse the order of
2350     // V1 and V2.
2351     if (Constant *Mask = dyn_cast<Constant>(II->getArgOperand(2))) {
2352       assert(Mask->getType()->getVectorNumElements() == 16 &&
2353              "Bad type for intrinsic!");
2354
2355       // Check that all of the elements are integer constants or undefs.
2356       bool AllEltsOk = true;
2357       for (unsigned i = 0; i != 16; ++i) {
2358         Constant *Elt = Mask->getAggregateElement(i);
2359         if (!Elt || !(isa<ConstantInt>(Elt) || isa<UndefValue>(Elt))) {
2360           AllEltsOk = false;
2361           break;
2362         }
2363       }
2364
2365       if (AllEltsOk) {
2366         // Cast the input vectors to byte vectors.
2367         Value *Op0 = Builder->CreateBitCast(II->getArgOperand(0),
2368                                             Mask->getType());
2369         Value *Op1 = Builder->CreateBitCast(II->getArgOperand(1),
2370                                             Mask->getType());
2371         Value *Result = UndefValue::get(Op0->getType());
2372
2373         // Only extract each element once.
2374         Value *ExtractedElts[32];
2375         memset(ExtractedElts, 0, sizeof(ExtractedElts));
2376
2377         for (unsigned i = 0; i != 16; ++i) {
2378           if (isa<UndefValue>(Mask->getAggregateElement(i)))
2379             continue;
2380           unsigned Idx =
2381             cast<ConstantInt>(Mask->getAggregateElement(i))->getZExtValue();
2382           Idx &= 31;  // Match the hardware behavior.
2383           if (DL.isLittleEndian())
2384             Idx = 31 - Idx;
2385
2386           if (!ExtractedElts[Idx]) {
2387             Value *Op0ToUse = (DL.isLittleEndian()) ? Op1 : Op0;
2388             Value *Op1ToUse = (DL.isLittleEndian()) ? Op0 : Op1;
2389             ExtractedElts[Idx] =
2390               Builder->CreateExtractElement(Idx < 16 ? Op0ToUse : Op1ToUse,
2391                                             Builder->getInt32(Idx&15));
2392           }
2393
2394           // Insert this value into the result vector.
2395           Result = Builder->CreateInsertElement(Result, ExtractedElts[Idx],
2396                                                 Builder->getInt32(i));
2397         }
2398         return CastInst::Create(Instruction::BitCast, Result, CI.getType());
2399       }
2400     }
2401     break;
2402
2403   case Intrinsic::arm_neon_vld1:
2404   case Intrinsic::arm_neon_vld2:
2405   case Intrinsic::arm_neon_vld3:
2406   case Intrinsic::arm_neon_vld4:
2407   case Intrinsic::arm_neon_vld2lane:
2408   case Intrinsic::arm_neon_vld3lane:
2409   case Intrinsic::arm_neon_vld4lane:
2410   case Intrinsic::arm_neon_vst1:
2411   case Intrinsic::arm_neon_vst2:
2412   case Intrinsic::arm_neon_vst3:
2413   case Intrinsic::arm_neon_vst4:
2414   case Intrinsic::arm_neon_vst2lane:
2415   case Intrinsic::arm_neon_vst3lane:
2416   case Intrinsic::arm_neon_vst4lane: {
2417     unsigned MemAlign =
2418         getKnownAlignment(II->getArgOperand(0), DL, II, &AC, &DT);
2419     unsigned AlignArg = II->getNumArgOperands() - 1;
2420     ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg));
2421     if (IntrAlign && IntrAlign->getZExtValue() < MemAlign) {
2422       II->setArgOperand(AlignArg,
2423                         ConstantInt::get(Type::getInt32Ty(II->getContext()),
2424                                          MemAlign, false));
2425       return II;
2426     }
2427     break;
2428   }
2429
2430   case Intrinsic::arm_neon_vmulls:
2431   case Intrinsic::arm_neon_vmullu:
2432   case Intrinsic::aarch64_neon_smull:
2433   case Intrinsic::aarch64_neon_umull: {
2434     Value *Arg0 = II->getArgOperand(0);
2435     Value *Arg1 = II->getArgOperand(1);
2436
2437     // Handle mul by zero first:
2438     if (isa<ConstantAggregateZero>(Arg0) || isa<ConstantAggregateZero>(Arg1)) {
2439       return replaceInstUsesWith(CI, ConstantAggregateZero::get(II->getType()));
2440     }
2441
2442     // Check for constant LHS & RHS - in this case we just simplify.
2443     bool Zext = (II->getIntrinsicID() == Intrinsic::arm_neon_vmullu ||
2444                  II->getIntrinsicID() == Intrinsic::aarch64_neon_umull);
2445     VectorType *NewVT = cast<VectorType>(II->getType());
2446     if (Constant *CV0 = dyn_cast<Constant>(Arg0)) {
2447       if (Constant *CV1 = dyn_cast<Constant>(Arg1)) {
2448         CV0 = ConstantExpr::getIntegerCast(CV0, NewVT, /*isSigned=*/!Zext);
2449         CV1 = ConstantExpr::getIntegerCast(CV1, NewVT, /*isSigned=*/!Zext);
2450
2451         return replaceInstUsesWith(CI, ConstantExpr::getMul(CV0, CV1));
2452       }
2453
2454       // Couldn't simplify - canonicalize constant to the RHS.
2455       std::swap(Arg0, Arg1);
2456     }
2457
2458     // Handle mul by one:
2459     if (Constant *CV1 = dyn_cast<Constant>(Arg1))
2460       if (ConstantInt *Splat =
2461               dyn_cast_or_null<ConstantInt>(CV1->getSplatValue()))
2462         if (Splat->isOne())
2463           return CastInst::CreateIntegerCast(Arg0, II->getType(),
2464                                              /*isSigned=*/!Zext);
2465
2466     break;
2467   }
2468
2469   case Intrinsic::amdgcn_rcp: {
2470     if (const ConstantFP *C = dyn_cast<ConstantFP>(II->getArgOperand(0))) {
2471       const APFloat &ArgVal = C->getValueAPF();
2472       APFloat Val(ArgVal.getSemantics(), 1.0);
2473       APFloat::opStatus Status = Val.divide(ArgVal,
2474                                             APFloat::rmNearestTiesToEven);
2475       // Only do this if it was exact and therefore not dependent on the
2476       // rounding mode.
2477       if (Status == APFloat::opOK)
2478         return replaceInstUsesWith(CI, ConstantFP::get(II->getContext(), Val));
2479     }
2480
2481     break;
2482   }
2483   case Intrinsic::amdgcn_frexp_mant:
2484   case Intrinsic::amdgcn_frexp_exp: {
2485     Value *Src = II->getArgOperand(0);
2486     if (const ConstantFP *C = dyn_cast<ConstantFP>(Src)) {
2487       int Exp;
2488       APFloat Significand = frexp(C->getValueAPF(), Exp,
2489                                   APFloat::rmNearestTiesToEven);
2490
2491       if (II->getIntrinsicID() == Intrinsic::amdgcn_frexp_mant) {
2492         return replaceInstUsesWith(CI, ConstantFP::get(II->getContext(),
2493                                                        Significand));
2494       }
2495
2496       // Match instruction special case behavior.
2497       if (Exp == APFloat::IEK_NaN || Exp == APFloat::IEK_Inf)
2498         Exp = 0;
2499
2500       return replaceInstUsesWith(CI, ConstantInt::get(II->getType(), Exp));
2501     }
2502
2503     if (isa<UndefValue>(Src))
2504       return replaceInstUsesWith(CI, UndefValue::get(II->getType()));
2505
2506     break;
2507   }
2508   case Intrinsic::amdgcn_class: {
2509     enum  {
2510       S_NAN = 1 << 0,        // Signaling NaN
2511       Q_NAN = 1 << 1,        // Quiet NaN
2512       N_INFINITY = 1 << 2,   // Negative infinity
2513       N_NORMAL = 1 << 3,     // Negative normal
2514       N_SUBNORMAL = 1 << 4,  // Negative subnormal
2515       N_ZERO = 1 << 5,       // Negative zero
2516       P_ZERO = 1 << 6,       // Positive zero
2517       P_SUBNORMAL = 1 << 7,  // Positive subnormal
2518       P_NORMAL = 1 << 8,     // Positive normal
2519       P_INFINITY = 1 << 9    // Positive infinity
2520     };
2521
2522     const uint32_t FullMask = S_NAN | Q_NAN | N_INFINITY | N_NORMAL |
2523       N_SUBNORMAL | N_ZERO | P_ZERO | P_SUBNORMAL | P_NORMAL | P_INFINITY;
2524
2525     Value *Src0 = II->getArgOperand(0);
2526     Value *Src1 = II->getArgOperand(1);
2527     const ConstantInt *CMask = dyn_cast<ConstantInt>(Src1);
2528     if (!CMask) {
2529       if (isa<UndefValue>(Src0))
2530         return replaceInstUsesWith(*II, UndefValue::get(II->getType()));
2531
2532       if (isa<UndefValue>(Src1))
2533         return replaceInstUsesWith(*II, ConstantInt::get(II->getType(), false));
2534       break;
2535     }
2536
2537     uint32_t Mask = CMask->getZExtValue();
2538
2539     // If all tests are made, it doesn't matter what the value is.
2540     if ((Mask & FullMask) == FullMask)
2541       return replaceInstUsesWith(*II, ConstantInt::get(II->getType(), true));
2542
2543     if ((Mask & FullMask) == 0)
2544       return replaceInstUsesWith(*II, ConstantInt::get(II->getType(), false));
2545
2546     if (Mask == (S_NAN | Q_NAN)) {
2547       // Equivalent of isnan. Replace with standard fcmp.
2548       Value *FCmp = Builder->CreateFCmpUNO(Src0, Src0);
2549       FCmp->takeName(II);
2550       return replaceInstUsesWith(*II, FCmp);
2551     }
2552
2553     const ConstantFP *CVal = dyn_cast<ConstantFP>(Src0);
2554     if (!CVal) {
2555       if (isa<UndefValue>(Src0))
2556         return replaceInstUsesWith(*II, UndefValue::get(II->getType()));
2557
2558       // Clamp mask to used bits
2559       if ((Mask & FullMask) != Mask) {
2560         CallInst *NewCall = Builder->CreateCall(II->getCalledFunction(),
2561           { Src0, ConstantInt::get(Src1->getType(), Mask & FullMask) }
2562         );
2563
2564         NewCall->takeName(II);
2565         return replaceInstUsesWith(*II, NewCall);
2566       }
2567
2568       break;
2569     }
2570
2571     const APFloat &Val = CVal->getValueAPF();
2572
2573     bool Result =
2574       ((Mask & S_NAN) && Val.isNaN() && Val.isSignaling()) ||
2575       ((Mask & Q_NAN) && Val.isNaN() && !Val.isSignaling()) ||
2576       ((Mask & N_INFINITY) && Val.isInfinity() && Val.isNegative()) ||
2577       ((Mask & N_NORMAL) && Val.isNormal() && Val.isNegative()) ||
2578       ((Mask & N_SUBNORMAL) && Val.isDenormal() && Val.isNegative()) ||
2579       ((Mask & N_ZERO) && Val.isZero() && Val.isNegative()) ||
2580       ((Mask & P_ZERO) && Val.isZero() && !Val.isNegative()) ||
2581       ((Mask & P_SUBNORMAL) && Val.isDenormal() && !Val.isNegative()) ||
2582       ((Mask & P_NORMAL) && Val.isNormal() && !Val.isNegative()) ||
2583       ((Mask & P_INFINITY) && Val.isInfinity() && !Val.isNegative());
2584
2585     return replaceInstUsesWith(*II, ConstantInt::get(II->getType(), Result));
2586   }
2587   case Intrinsic::stackrestore: {
2588     // If the save is right next to the restore, remove the restore.  This can
2589     // happen when variable allocas are DCE'd.
2590     if (IntrinsicInst *SS = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) {
2591       if (SS->getIntrinsicID() == Intrinsic::stacksave) {
2592         if (&*++SS->getIterator() == II)
2593           return eraseInstFromFunction(CI);
2594       }
2595     }
2596
2597     // Scan down this block to see if there is another stack restore in the
2598     // same block without an intervening call/alloca.
2599     BasicBlock::iterator BI(II);
2600     TerminatorInst *TI = II->getParent()->getTerminator();
2601     bool CannotRemove = false;
2602     for (++BI; &*BI != TI; ++BI) {
2603       if (isa<AllocaInst>(BI)) {
2604         CannotRemove = true;
2605         break;
2606       }
2607       if (CallInst *BCI = dyn_cast<CallInst>(BI)) {
2608         if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(BCI)) {
2609           // If there is a stackrestore below this one, remove this one.
2610           if (II->getIntrinsicID() == Intrinsic::stackrestore)
2611             return eraseInstFromFunction(CI);
2612
2613           // Bail if we cross over an intrinsic with side effects, such as
2614           // llvm.stacksave, llvm.read_register, or llvm.setjmp.
2615           if (II->mayHaveSideEffects()) {
2616             CannotRemove = true;
2617             break;
2618           }
2619         } else {
2620           // If we found a non-intrinsic call, we can't remove the stack
2621           // restore.
2622           CannotRemove = true;
2623           break;
2624         }
2625       }
2626     }
2627
2628     // If the stack restore is in a return, resume, or unwind block and if there
2629     // are no allocas or calls between the restore and the return, nuke the
2630     // restore.
2631     if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))
2632       return eraseInstFromFunction(CI);
2633     break;
2634   }
2635   case Intrinsic::lifetime_start:
2636     // Asan needs to poison memory to detect invalid access which is possible
2637     // even for empty lifetime range.
2638     if (II->getFunction()->hasFnAttribute(Attribute::SanitizeAddress))
2639       break;
2640
2641     if (removeTriviallyEmptyRange(*II, Intrinsic::lifetime_start,
2642                                   Intrinsic::lifetime_end, *this))
2643       return nullptr;
2644     break;
2645   case Intrinsic::assume: {
2646     Value *IIOperand = II->getArgOperand(0);
2647     // Remove an assume if it is immediately followed by an identical assume.
2648     if (match(II->getNextNode(),
2649               m_Intrinsic<Intrinsic::assume>(m_Specific(IIOperand))))
2650       return eraseInstFromFunction(CI);
2651
2652     // Canonicalize assume(a && b) -> assume(a); assume(b);
2653     // Note: New assumption intrinsics created here are registered by
2654     // the InstCombineIRInserter object.
2655     Value *AssumeIntrinsic = II->getCalledValue(), *A, *B;
2656     if (match(IIOperand, m_And(m_Value(A), m_Value(B)))) {
2657       Builder->CreateCall(AssumeIntrinsic, A, II->getName());
2658       Builder->CreateCall(AssumeIntrinsic, B, II->getName());
2659       return eraseInstFromFunction(*II);
2660     }
2661     // assume(!(a || b)) -> assume(!a); assume(!b);
2662     if (match(IIOperand, m_Not(m_Or(m_Value(A), m_Value(B))))) {
2663       Builder->CreateCall(AssumeIntrinsic, Builder->CreateNot(A),
2664                           II->getName());
2665       Builder->CreateCall(AssumeIntrinsic, Builder->CreateNot(B),
2666                           II->getName());
2667       return eraseInstFromFunction(*II);
2668     }
2669
2670     // assume( (load addr) != null ) -> add 'nonnull' metadata to load
2671     // (if assume is valid at the load)
2672     if (ICmpInst* ICmp = dyn_cast<ICmpInst>(IIOperand)) {
2673       Value *LHS = ICmp->getOperand(0);
2674       Value *RHS = ICmp->getOperand(1);
2675       if (ICmpInst::ICMP_NE == ICmp->getPredicate() &&
2676           isa<LoadInst>(LHS) &&
2677           isa<Constant>(RHS) &&
2678           RHS->getType()->isPointerTy() &&
2679           cast<Constant>(RHS)->isNullValue()) {
2680         LoadInst* LI = cast<LoadInst>(LHS);
2681         if (isValidAssumeForContext(II, LI, &DT)) {
2682           MDNode *MD = MDNode::get(II->getContext(), None);
2683           LI->setMetadata(LLVMContext::MD_nonnull, MD);
2684           return eraseInstFromFunction(*II);
2685         }
2686       }
2687       // TODO: apply nonnull return attributes to calls and invokes
2688       // TODO: apply range metadata for range check patterns?
2689     }
2690     // If there is a dominating assume with the same condition as this one,
2691     // then this one is redundant, and should be removed.
2692     APInt KnownZero(1, 0), KnownOne(1, 0);
2693     computeKnownBits(IIOperand, KnownZero, KnownOne, 0, II);
2694     if (KnownOne.isAllOnesValue())
2695       return eraseInstFromFunction(*II);
2696
2697     break;
2698   }
2699   case Intrinsic::experimental_gc_relocate: {
2700     // Translate facts known about a pointer before relocating into
2701     // facts about the relocate value, while being careful to
2702     // preserve relocation semantics.
2703     Value *DerivedPtr = cast<GCRelocateInst>(II)->getDerivedPtr();
2704
2705     // Remove the relocation if unused, note that this check is required
2706     // to prevent the cases below from looping forever.
2707     if (II->use_empty())
2708       return eraseInstFromFunction(*II);
2709
2710     // Undef is undef, even after relocation.
2711     // TODO: provide a hook for this in GCStrategy.  This is clearly legal for
2712     // most practical collectors, but there was discussion in the review thread
2713     // about whether it was legal for all possible collectors.
2714     if (isa<UndefValue>(DerivedPtr))
2715       // Use undef of gc_relocate's type to replace it.
2716       return replaceInstUsesWith(*II, UndefValue::get(II->getType()));
2717
2718     if (auto *PT = dyn_cast<PointerType>(II->getType())) {
2719       // The relocation of null will be null for most any collector.
2720       // TODO: provide a hook for this in GCStrategy.  There might be some
2721       // weird collector this property does not hold for.
2722       if (isa<ConstantPointerNull>(DerivedPtr))
2723         // Use null-pointer of gc_relocate's type to replace it.
2724         return replaceInstUsesWith(*II, ConstantPointerNull::get(PT));
2725
2726       // isKnownNonNull -> nonnull attribute
2727       if (isKnownNonNullAt(DerivedPtr, II, &DT))
2728         II->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull);
2729     }
2730
2731     // TODO: bitcast(relocate(p)) -> relocate(bitcast(p))
2732     // Canonicalize on the type from the uses to the defs
2733
2734     // TODO: relocate((gep p, C, C2, ...)) -> gep(relocate(p), C, C2, ...)
2735     break;
2736   }
2737   }
2738
2739   return visitCallSite(II);
2740 }
2741
2742 // InvokeInst simplification
2743 //
2744 Instruction *InstCombiner::visitInvokeInst(InvokeInst &II) {
2745   return visitCallSite(&II);
2746 }
2747
2748 /// If this cast does not affect the value passed through the varargs area, we
2749 /// can eliminate the use of the cast.
2750 static bool isSafeToEliminateVarargsCast(const CallSite CS,
2751                                          const DataLayout &DL,
2752                                          const CastInst *const CI,
2753                                          const int ix) {
2754   if (!CI->isLosslessCast())
2755     return false;
2756
2757   // If this is a GC intrinsic, avoid munging types.  We need types for
2758   // statepoint reconstruction in SelectionDAG.
2759   // TODO: This is probably something which should be expanded to all
2760   // intrinsics since the entire point of intrinsics is that
2761   // they are understandable by the optimizer.
2762   if (isStatepoint(CS) || isGCRelocate(CS) || isGCResult(CS))
2763     return false;
2764
2765   // The size of ByVal or InAlloca arguments is derived from the type, so we
2766   // can't change to a type with a different size.  If the size were
2767   // passed explicitly we could avoid this check.
2768   if (!CS.isByValOrInAllocaArgument(ix))
2769     return true;
2770
2771   Type* SrcTy =
2772             cast<PointerType>(CI->getOperand(0)->getType())->getElementType();
2773   Type* DstTy = cast<PointerType>(CI->getType())->getElementType();
2774   if (!SrcTy->isSized() || !DstTy->isSized())
2775     return false;
2776   if (DL.getTypeAllocSize(SrcTy) != DL.getTypeAllocSize(DstTy))
2777     return false;
2778   return true;
2779 }
2780
2781 Instruction *InstCombiner::tryOptimizeCall(CallInst *CI) {
2782   if (!CI->getCalledFunction()) return nullptr;
2783
2784   auto InstCombineRAUW = [this](Instruction *From, Value *With) {
2785     replaceInstUsesWith(*From, With);
2786   };
2787   LibCallSimplifier Simplifier(DL, &TLI, InstCombineRAUW);
2788   if (Value *With = Simplifier.optimizeCall(CI)) {
2789     ++NumSimplified;
2790     return CI->use_empty() ? CI : replaceInstUsesWith(*CI, With);
2791   }
2792
2793   return nullptr;
2794 }
2795
2796 static IntrinsicInst *findInitTrampolineFromAlloca(Value *TrampMem) {
2797   // Strip off at most one level of pointer casts, looking for an alloca.  This
2798   // is good enough in practice and simpler than handling any number of casts.
2799   Value *Underlying = TrampMem->stripPointerCasts();
2800   if (Underlying != TrampMem &&
2801       (!Underlying->hasOneUse() || Underlying->user_back() != TrampMem))
2802     return nullptr;
2803   if (!isa<AllocaInst>(Underlying))
2804     return nullptr;
2805
2806   IntrinsicInst *InitTrampoline = nullptr;
2807   for (User *U : TrampMem->users()) {
2808     IntrinsicInst *II = dyn_cast<IntrinsicInst>(U);
2809     if (!II)
2810       return nullptr;
2811     if (II->getIntrinsicID() == Intrinsic::init_trampoline) {
2812       if (InitTrampoline)
2813         // More than one init_trampoline writes to this value.  Give up.
2814         return nullptr;
2815       InitTrampoline = II;
2816       continue;
2817     }
2818     if (II->getIntrinsicID() == Intrinsic::adjust_trampoline)
2819       // Allow any number of calls to adjust.trampoline.
2820       continue;
2821     return nullptr;
2822   }
2823
2824   // No call to init.trampoline found.
2825   if (!InitTrampoline)
2826     return nullptr;
2827
2828   // Check that the alloca is being used in the expected way.
2829   if (InitTrampoline->getOperand(0) != TrampMem)
2830     return nullptr;
2831
2832   return InitTrampoline;
2833 }
2834
2835 static IntrinsicInst *findInitTrampolineFromBB(IntrinsicInst *AdjustTramp,
2836                                                Value *TrampMem) {
2837   // Visit all the previous instructions in the basic block, and try to find a
2838   // init.trampoline which has a direct path to the adjust.trampoline.
2839   for (BasicBlock::iterator I = AdjustTramp->getIterator(),
2840                             E = AdjustTramp->getParent()->begin();
2841        I != E;) {
2842     Instruction *Inst = &*--I;
2843     if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I))
2844       if (II->getIntrinsicID() == Intrinsic::init_trampoline &&
2845           II->getOperand(0) == TrampMem)
2846         return II;
2847     if (Inst->mayWriteToMemory())
2848       return nullptr;
2849   }
2850   return nullptr;
2851 }
2852
2853 // Given a call to llvm.adjust.trampoline, find and return the corresponding
2854 // call to llvm.init.trampoline if the call to the trampoline can be optimized
2855 // to a direct call to a function.  Otherwise return NULL.
2856 //
2857 static IntrinsicInst *findInitTrampoline(Value *Callee) {
2858   Callee = Callee->stripPointerCasts();
2859   IntrinsicInst *AdjustTramp = dyn_cast<IntrinsicInst>(Callee);
2860   if (!AdjustTramp ||
2861       AdjustTramp->getIntrinsicID() != Intrinsic::adjust_trampoline)
2862     return nullptr;
2863
2864   Value *TrampMem = AdjustTramp->getOperand(0);
2865
2866   if (IntrinsicInst *IT = findInitTrampolineFromAlloca(TrampMem))
2867     return IT;
2868   if (IntrinsicInst *IT = findInitTrampolineFromBB(AdjustTramp, TrampMem))
2869     return IT;
2870   return nullptr;
2871 }
2872
2873 /// Improvements for call and invoke instructions.
2874 Instruction *InstCombiner::visitCallSite(CallSite CS) {
2875   if (isAllocLikeFn(CS.getInstruction(), &TLI))
2876     return visitAllocSite(*CS.getInstruction());
2877
2878   bool Changed = false;
2879
2880   // Mark any parameters that are known to be non-null with the nonnull
2881   // attribute.  This is helpful for inlining calls to functions with null
2882   // checks on their arguments.
2883   SmallVector<unsigned, 4> Indices;
2884   unsigned ArgNo = 0;
2885
2886   for (Value *V : CS.args()) {
2887     if (V->getType()->isPointerTy() &&
2888         !CS.paramHasAttr(ArgNo + 1, Attribute::NonNull) &&
2889         isKnownNonNullAt(V, CS.getInstruction(), &DT))
2890       Indices.push_back(ArgNo + 1);
2891     ArgNo++;
2892   }
2893
2894   assert(ArgNo == CS.arg_size() && "sanity check");
2895
2896   if (!Indices.empty()) {
2897     AttributeSet AS = CS.getAttributes();
2898     LLVMContext &Ctx = CS.getInstruction()->getContext();
2899     AS = AS.addAttribute(Ctx, Indices,
2900                          Attribute::get(Ctx, Attribute::NonNull));
2901     CS.setAttributes(AS);
2902     Changed = true;
2903   }
2904
2905   // If the callee is a pointer to a function, attempt to move any casts to the
2906   // arguments of the call/invoke.
2907   Value *Callee = CS.getCalledValue();
2908   if (!isa<Function>(Callee) && transformConstExprCastCall(CS))
2909     return nullptr;
2910
2911   if (Function *CalleeF = dyn_cast<Function>(Callee)) {
2912     // Remove the convergent attr on calls when the callee is not convergent.
2913     if (CS.isConvergent() && !CalleeF->isConvergent() &&
2914         !CalleeF->isIntrinsic()) {
2915       DEBUG(dbgs() << "Removing convergent attr from instr "
2916                    << CS.getInstruction() << "\n");
2917       CS.setNotConvergent();
2918       return CS.getInstruction();
2919     }
2920
2921     // If the call and callee calling conventions don't match, this call must
2922     // be unreachable, as the call is undefined.
2923     if (CalleeF->getCallingConv() != CS.getCallingConv() &&
2924         // Only do this for calls to a function with a body.  A prototype may
2925         // not actually end up matching the implementation's calling conv for a
2926         // variety of reasons (e.g. it may be written in assembly).
2927         !CalleeF->isDeclaration()) {
2928       Instruction *OldCall = CS.getInstruction();
2929       new StoreInst(ConstantInt::getTrue(Callee->getContext()),
2930                 UndefValue::get(Type::getInt1PtrTy(Callee->getContext())),
2931                                   OldCall);
2932       // If OldCall does not return void then replaceAllUsesWith undef.
2933       // This allows ValueHandlers and custom metadata to adjust itself.
2934       if (!OldCall->getType()->isVoidTy())
2935         replaceInstUsesWith(*OldCall, UndefValue::get(OldCall->getType()));
2936       if (isa<CallInst>(OldCall))
2937         return eraseInstFromFunction(*OldCall);
2938
2939       // We cannot remove an invoke, because it would change the CFG, just
2940       // change the callee to a null pointer.
2941       cast<InvokeInst>(OldCall)->setCalledFunction(
2942                                     Constant::getNullValue(CalleeF->getType()));
2943       return nullptr;
2944     }
2945   }
2946
2947   if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
2948     // If CS does not return void then replaceAllUsesWith undef.
2949     // This allows ValueHandlers and custom metadata to adjust itself.
2950     if (!CS.getInstruction()->getType()->isVoidTy())
2951       replaceInstUsesWith(*CS.getInstruction(),
2952                           UndefValue::get(CS.getInstruction()->getType()));
2953
2954     if (isa<InvokeInst>(CS.getInstruction())) {
2955       // Can't remove an invoke because we cannot change the CFG.
2956       return nullptr;
2957     }
2958
2959     // This instruction is not reachable, just remove it.  We insert a store to
2960     // undef so that we know that this code is not reachable, despite the fact
2961     // that we can't modify the CFG here.
2962     new StoreInst(ConstantInt::getTrue(Callee->getContext()),
2963                   UndefValue::get(Type::getInt1PtrTy(Callee->getContext())),
2964                   CS.getInstruction());
2965
2966     return eraseInstFromFunction(*CS.getInstruction());
2967   }
2968
2969   if (IntrinsicInst *II = findInitTrampoline(Callee))
2970     return transformCallThroughTrampoline(CS, II);
2971
2972   PointerType *PTy = cast<PointerType>(Callee->getType());
2973   FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
2974   if (FTy->isVarArg()) {
2975     int ix = FTy->getNumParams();
2976     // See if we can optimize any arguments passed through the varargs area of
2977     // the call.
2978     for (CallSite::arg_iterator I = CS.arg_begin() + FTy->getNumParams(),
2979            E = CS.arg_end(); I != E; ++I, ++ix) {
2980       CastInst *CI = dyn_cast<CastInst>(*I);
2981       if (CI && isSafeToEliminateVarargsCast(CS, DL, CI, ix)) {
2982         *I = CI->getOperand(0);
2983         Changed = true;
2984       }
2985     }
2986   }
2987
2988   if (isa<InlineAsm>(Callee) && !CS.doesNotThrow()) {
2989     // Inline asm calls cannot throw - mark them 'nounwind'.
2990     CS.setDoesNotThrow();
2991     Changed = true;
2992   }
2993
2994   // Try to optimize the call if possible, we require DataLayout for most of
2995   // this.  None of these calls are seen as possibly dead so go ahead and
2996   // delete the instruction now.
2997   if (CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) {
2998     Instruction *I = tryOptimizeCall(CI);
2999     // If we changed something return the result, etc. Otherwise let
3000     // the fallthrough check.
3001     if (I) return eraseInstFromFunction(*I);
3002   }
3003
3004   return Changed ? CS.getInstruction() : nullptr;
3005 }
3006
3007 /// If the callee is a constexpr cast of a function, attempt to move the cast to
3008 /// the arguments of the call/invoke.
3009 bool InstCombiner::transformConstExprCastCall(CallSite CS) {
3010   auto *Callee = dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts());
3011   if (!Callee)
3012     return false;
3013
3014   // The prototype of a thunk is a lie. Don't directly call such a function.
3015   if (Callee->hasFnAttribute("thunk"))
3016     return false;
3017
3018   Instruction *Caller = CS.getInstruction();
3019   const AttributeSet &CallerPAL = CS.getAttributes();
3020
3021   // Okay, this is a cast from a function to a different type.  Unless doing so
3022   // would cause a type conversion of one of our arguments, change this call to
3023   // be a direct call with arguments casted to the appropriate types.
3024   //
3025   FunctionType *FT = Callee->getFunctionType();
3026   Type *OldRetTy = Caller->getType();
3027   Type *NewRetTy = FT->getReturnType();
3028
3029   // Check to see if we are changing the return type...
3030   if (OldRetTy != NewRetTy) {
3031
3032     if (NewRetTy->isStructTy())
3033       return false; // TODO: Handle multiple return values.
3034
3035     if (!CastInst::isBitOrNoopPointerCastable(NewRetTy, OldRetTy, DL)) {
3036       if (Callee->isDeclaration())
3037         return false;   // Cannot transform this return value.
3038
3039       if (!Caller->use_empty() &&
3040           // void -> non-void is handled specially
3041           !NewRetTy->isVoidTy())
3042         return false;   // Cannot transform this return value.
3043     }
3044
3045     if (!CallerPAL.isEmpty() && !Caller->use_empty()) {
3046       AttrBuilder RAttrs(CallerPAL, AttributeSet::ReturnIndex);
3047       if (RAttrs.overlaps(AttributeFuncs::typeIncompatible(NewRetTy)))
3048         return false;   // Attribute not compatible with transformed value.
3049     }
3050
3051     // If the callsite is an invoke instruction, and the return value is used by
3052     // a PHI node in a successor, we cannot change the return type of the call
3053     // because there is no place to put the cast instruction (without breaking
3054     // the critical edge).  Bail out in this case.
3055     if (!Caller->use_empty())
3056       if (InvokeInst *II = dyn_cast<InvokeInst>(Caller))
3057         for (User *U : II->users())
3058           if (PHINode *PN = dyn_cast<PHINode>(U))
3059             if (PN->getParent() == II->getNormalDest() ||
3060                 PN->getParent() == II->getUnwindDest())
3061               return false;
3062   }
3063
3064   unsigned NumActualArgs = CS.arg_size();
3065   unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs);
3066
3067   // Prevent us turning:
3068   // declare void @takes_i32_inalloca(i32* inalloca)
3069   //  call void bitcast (void (i32*)* @takes_i32_inalloca to void (i32)*)(i32 0)
3070   //
3071   // into:
3072   //  call void @takes_i32_inalloca(i32* null)
3073   //
3074   //  Similarly, avoid folding away bitcasts of byval calls.
3075   if (Callee->getAttributes().hasAttrSomewhere(Attribute::InAlloca) ||
3076       Callee->getAttributes().hasAttrSomewhere(Attribute::ByVal))
3077     return false;
3078
3079   CallSite::arg_iterator AI = CS.arg_begin();
3080   for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) {
3081     Type *ParamTy = FT->getParamType(i);
3082     Type *ActTy = (*AI)->getType();
3083
3084     if (!CastInst::isBitOrNoopPointerCastable(ActTy, ParamTy, DL))
3085       return false;   // Cannot transform this parameter value.
3086
3087     if (AttrBuilder(CallerPAL.getParamAttributes(i + 1), i + 1).
3088           overlaps(AttributeFuncs::typeIncompatible(ParamTy)))
3089       return false;   // Attribute not compatible with transformed value.
3090
3091     if (CS.isInAllocaArgument(i))
3092       return false;   // Cannot transform to and from inalloca.
3093
3094     // If the parameter is passed as a byval argument, then we have to have a
3095     // sized type and the sized type has to have the same size as the old type.
3096     if (ParamTy != ActTy &&
3097         CallerPAL.getParamAttributes(i + 1).hasAttribute(i + 1,
3098                                                          Attribute::ByVal)) {
3099       PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
3100       if (!ParamPTy || !ParamPTy->getElementType()->isSized())
3101         return false;
3102
3103       Type *CurElTy = ActTy->getPointerElementType();
3104       if (DL.getTypeAllocSize(CurElTy) !=
3105           DL.getTypeAllocSize(ParamPTy->getElementType()))
3106         return false;
3107     }
3108   }
3109
3110   if (Callee->isDeclaration()) {
3111     // Do not delete arguments unless we have a function body.
3112     if (FT->getNumParams() < NumActualArgs && !FT->isVarArg())
3113       return false;
3114
3115     // If the callee is just a declaration, don't change the varargsness of the
3116     // call.  We don't want to introduce a varargs call where one doesn't
3117     // already exist.
3118     PointerType *APTy = cast<PointerType>(CS.getCalledValue()->getType());
3119     if (FT->isVarArg()!=cast<FunctionType>(APTy->getElementType())->isVarArg())
3120       return false;
3121
3122     // If both the callee and the cast type are varargs, we still have to make
3123     // sure the number of fixed parameters are the same or we have the same
3124     // ABI issues as if we introduce a varargs call.
3125     if (FT->isVarArg() &&
3126         cast<FunctionType>(APTy->getElementType())->isVarArg() &&
3127         FT->getNumParams() !=
3128         cast<FunctionType>(APTy->getElementType())->getNumParams())
3129       return false;
3130   }
3131
3132   if (FT->getNumParams() < NumActualArgs && FT->isVarArg() &&
3133       !CallerPAL.isEmpty())
3134     // In this case we have more arguments than the new function type, but we
3135     // won't be dropping them.  Check that these extra arguments have attributes
3136     // that are compatible with being a vararg call argument.
3137     for (unsigned i = CallerPAL.getNumSlots(); i; --i) {
3138       unsigned Index = CallerPAL.getSlotIndex(i - 1);
3139       if (Index <= FT->getNumParams())
3140         break;
3141
3142       // Check if it has an attribute that's incompatible with varargs.
3143       AttributeSet PAttrs = CallerPAL.getSlotAttributes(i - 1);
3144       if (PAttrs.hasAttribute(Index, Attribute::StructRet))
3145         return false;
3146     }
3147
3148
3149   // Okay, we decided that this is a safe thing to do: go ahead and start
3150   // inserting cast instructions as necessary.
3151   std::vector<Value*> Args;
3152   Args.reserve(NumActualArgs);
3153   SmallVector<AttributeSet, 8> attrVec;
3154   attrVec.reserve(NumCommonArgs);
3155
3156   // Get any return attributes.
3157   AttrBuilder RAttrs(CallerPAL, AttributeSet::ReturnIndex);
3158
3159   // If the return value is not being used, the type may not be compatible
3160   // with the existing attributes.  Wipe out any problematic attributes.
3161   RAttrs.remove(AttributeFuncs::typeIncompatible(NewRetTy));
3162
3163   // Add the new return attributes.
3164   if (RAttrs.hasAttributes())
3165     attrVec.push_back(AttributeSet::get(Caller->getContext(),
3166                                         AttributeSet::ReturnIndex, RAttrs));
3167
3168   AI = CS.arg_begin();
3169   for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) {
3170     Type *ParamTy = FT->getParamType(i);
3171
3172     if ((*AI)->getType() == ParamTy) {
3173       Args.push_back(*AI);
3174     } else {
3175       Args.push_back(Builder->CreateBitOrPointerCast(*AI, ParamTy));
3176     }
3177
3178     // Add any parameter attributes.
3179     AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1);
3180     if (PAttrs.hasAttributes())
3181       attrVec.push_back(AttributeSet::get(Caller->getContext(), i + 1,
3182                                           PAttrs));
3183   }
3184
3185   // If the function takes more arguments than the call was taking, add them
3186   // now.
3187   for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i)
3188     Args.push_back(Constant::getNullValue(FT->getParamType(i)));
3189
3190   // If we are removing arguments to the function, emit an obnoxious warning.
3191   if (FT->getNumParams() < NumActualArgs) {
3192     // TODO: if (!FT->isVarArg()) this call may be unreachable. PR14722
3193     if (FT->isVarArg()) {
3194       // Add all of the arguments in their promoted form to the arg list.
3195       for (unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) {
3196         Type *PTy = getPromotedType((*AI)->getType());
3197         if (PTy != (*AI)->getType()) {
3198           // Must promote to pass through va_arg area!
3199           Instruction::CastOps opcode =
3200             CastInst::getCastOpcode(*AI, false, PTy, false);
3201           Args.push_back(Builder->CreateCast(opcode, *AI, PTy));
3202         } else {
3203           Args.push_back(*AI);
3204         }
3205
3206         // Add any parameter attributes.
3207         AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1);
3208         if (PAttrs.hasAttributes())
3209           attrVec.push_back(AttributeSet::get(FT->getContext(), i + 1,
3210                                               PAttrs));
3211       }
3212     }
3213   }
3214
3215   AttributeSet FnAttrs = CallerPAL.getFnAttributes();
3216   if (CallerPAL.hasAttributes(AttributeSet::FunctionIndex))
3217     attrVec.push_back(AttributeSet::get(Callee->getContext(), FnAttrs));
3218
3219   if (NewRetTy->isVoidTy())
3220     Caller->setName("");   // Void type should not have a name.
3221
3222   const AttributeSet &NewCallerPAL = AttributeSet::get(Callee->getContext(),
3223                                                        attrVec);
3224
3225   SmallVector<OperandBundleDef, 1> OpBundles;
3226   CS.getOperandBundlesAsDefs(OpBundles);
3227
3228   Instruction *NC;
3229   if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
3230     NC = Builder->CreateInvoke(Callee, II->getNormalDest(), II->getUnwindDest(),
3231                                Args, OpBundles);
3232     NC->takeName(II);
3233     cast<InvokeInst>(NC)->setCallingConv(II->getCallingConv());
3234     cast<InvokeInst>(NC)->setAttributes(NewCallerPAL);
3235   } else {
3236     CallInst *CI = cast<CallInst>(Caller);
3237     NC = Builder->CreateCall(Callee, Args, OpBundles);
3238     NC->takeName(CI);
3239     cast<CallInst>(NC)->setTailCallKind(CI->getTailCallKind());
3240     cast<CallInst>(NC)->setCallingConv(CI->getCallingConv());
3241     cast<CallInst>(NC)->setAttributes(NewCallerPAL);
3242   }
3243
3244   // Insert a cast of the return type as necessary.
3245   Value *NV = NC;
3246   if (OldRetTy != NV->getType() && !Caller->use_empty()) {
3247     if (!NV->getType()->isVoidTy()) {
3248       NV = NC = CastInst::CreateBitOrPointerCast(NC, OldRetTy);
3249       NC->setDebugLoc(Caller->getDebugLoc());
3250
3251       // If this is an invoke instruction, we should insert it after the first
3252       // non-phi, instruction in the normal successor block.
3253       if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
3254         BasicBlock::iterator I = II->getNormalDest()->getFirstInsertionPt();
3255         InsertNewInstBefore(NC, *I);
3256       } else {
3257         // Otherwise, it's a call, just insert cast right after the call.
3258         InsertNewInstBefore(NC, *Caller);
3259       }
3260       Worklist.AddUsersToWorkList(*Caller);
3261     } else {
3262       NV = UndefValue::get(Caller->getType());
3263     }
3264   }
3265
3266   if (!Caller->use_empty())
3267     replaceInstUsesWith(*Caller, NV);
3268   else if (Caller->hasValueHandle()) {
3269     if (OldRetTy == NV->getType())
3270       ValueHandleBase::ValueIsRAUWd(Caller, NV);
3271     else
3272       // We cannot call ValueIsRAUWd with a different type, and the
3273       // actual tracked value will disappear.
3274       ValueHandleBase::ValueIsDeleted(Caller);
3275   }
3276
3277   eraseInstFromFunction(*Caller);
3278   return true;
3279 }
3280
3281 /// Turn a call to a function created by init_trampoline / adjust_trampoline
3282 /// intrinsic pair into a direct call to the underlying function.
3283 Instruction *
3284 InstCombiner::transformCallThroughTrampoline(CallSite CS,
3285                                              IntrinsicInst *Tramp) {
3286   Value *Callee = CS.getCalledValue();
3287   PointerType *PTy = cast<PointerType>(Callee->getType());
3288   FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
3289   const AttributeSet &Attrs = CS.getAttributes();
3290
3291   // If the call already has the 'nest' attribute somewhere then give up -
3292   // otherwise 'nest' would occur twice after splicing in the chain.
3293   if (Attrs.hasAttrSomewhere(Attribute::Nest))
3294     return nullptr;
3295
3296   assert(Tramp &&
3297          "transformCallThroughTrampoline called with incorrect CallSite.");
3298
3299   Function *NestF =cast<Function>(Tramp->getArgOperand(1)->stripPointerCasts());
3300   FunctionType *NestFTy = cast<FunctionType>(NestF->getValueType());
3301
3302   const AttributeSet &NestAttrs = NestF->getAttributes();
3303   if (!NestAttrs.isEmpty()) {
3304     unsigned NestIdx = 1;
3305     Type *NestTy = nullptr;
3306     AttributeSet NestAttr;
3307
3308     // Look for a parameter marked with the 'nest' attribute.
3309     for (FunctionType::param_iterator I = NestFTy->param_begin(),
3310          E = NestFTy->param_end(); I != E; ++NestIdx, ++I)
3311       if (NestAttrs.hasAttribute(NestIdx, Attribute::Nest)) {
3312         // Record the parameter type and any other attributes.
3313         NestTy = *I;
3314         NestAttr = NestAttrs.getParamAttributes(NestIdx);
3315         break;
3316       }
3317
3318     if (NestTy) {
3319       Instruction *Caller = CS.getInstruction();
3320       std::vector<Value*> NewArgs;
3321       NewArgs.reserve(CS.arg_size() + 1);
3322
3323       SmallVector<AttributeSet, 8> NewAttrs;
3324       NewAttrs.reserve(Attrs.getNumSlots() + 1);
3325
3326       // Insert the nest argument into the call argument list, which may
3327       // mean appending it.  Likewise for attributes.
3328
3329       // Add any result attributes.
3330       if (Attrs.hasAttributes(AttributeSet::ReturnIndex))
3331         NewAttrs.push_back(AttributeSet::get(Caller->getContext(),
3332                                              Attrs.getRetAttributes()));
3333
3334       {
3335         unsigned Idx = 1;
3336         CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
3337         do {
3338           if (Idx == NestIdx) {
3339             // Add the chain argument and attributes.
3340             Value *NestVal = Tramp->getArgOperand(2);
3341             if (NestVal->getType() != NestTy)
3342               NestVal = Builder->CreateBitCast(NestVal, NestTy, "nest");
3343             NewArgs.push_back(NestVal);
3344             NewAttrs.push_back(AttributeSet::get(Caller->getContext(),
3345                                                  NestAttr));
3346           }
3347
3348           if (I == E)
3349             break;
3350
3351           // Add the original argument and attributes.
3352           NewArgs.push_back(*I);
3353           AttributeSet Attr = Attrs.getParamAttributes(Idx);
3354           if (Attr.hasAttributes(Idx)) {
3355             AttrBuilder B(Attr, Idx);
3356             NewAttrs.push_back(AttributeSet::get(Caller->getContext(),
3357                                                  Idx + (Idx >= NestIdx), B));
3358           }
3359
3360           ++Idx;
3361           ++I;
3362         } while (true);
3363       }
3364
3365       // Add any function attributes.
3366       if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
3367         NewAttrs.push_back(AttributeSet::get(FTy->getContext(),
3368                                              Attrs.getFnAttributes()));
3369
3370       // The trampoline may have been bitcast to a bogus type (FTy).
3371       // Handle this by synthesizing a new function type, equal to FTy
3372       // with the chain parameter inserted.
3373
3374       std::vector<Type*> NewTypes;
3375       NewTypes.reserve(FTy->getNumParams()+1);
3376
3377       // Insert the chain's type into the list of parameter types, which may
3378       // mean appending it.
3379       {
3380         unsigned Idx = 1;
3381         FunctionType::param_iterator I = FTy->param_begin(),
3382           E = FTy->param_end();
3383
3384         do {
3385           if (Idx == NestIdx)
3386             // Add the chain's type.
3387             NewTypes.push_back(NestTy);
3388
3389           if (I == E)
3390             break;
3391
3392           // Add the original type.
3393           NewTypes.push_back(*I);
3394
3395           ++Idx;
3396           ++I;
3397         } while (true);
3398       }
3399
3400       // Replace the trampoline call with a direct call.  Let the generic
3401       // code sort out any function type mismatches.
3402       FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes,
3403                                                 FTy->isVarArg());
3404       Constant *NewCallee =
3405         NestF->getType() == PointerType::getUnqual(NewFTy) ?
3406         NestF : ConstantExpr::getBitCast(NestF,
3407                                          PointerType::getUnqual(NewFTy));
3408       const AttributeSet &NewPAL =
3409           AttributeSet::get(FTy->getContext(), NewAttrs);
3410
3411       SmallVector<OperandBundleDef, 1> OpBundles;
3412       CS.getOperandBundlesAsDefs(OpBundles);
3413
3414       Instruction *NewCaller;
3415       if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
3416         NewCaller = InvokeInst::Create(NewCallee,
3417                                        II->getNormalDest(), II->getUnwindDest(),
3418                                        NewArgs, OpBundles);
3419         cast<InvokeInst>(NewCaller)->setCallingConv(II->getCallingConv());
3420         cast<InvokeInst>(NewCaller)->setAttributes(NewPAL);
3421       } else {
3422         NewCaller = CallInst::Create(NewCallee, NewArgs, OpBundles);
3423         cast<CallInst>(NewCaller)->setTailCallKind(
3424             cast<CallInst>(Caller)->getTailCallKind());
3425         cast<CallInst>(NewCaller)->setCallingConv(
3426             cast<CallInst>(Caller)->getCallingConv());
3427         cast<CallInst>(NewCaller)->setAttributes(NewPAL);
3428       }
3429
3430       return NewCaller;
3431     }
3432   }
3433
3434   // Replace the trampoline call with a direct call.  Since there is no 'nest'
3435   // parameter, there is no need to adjust the argument list.  Let the generic
3436   // code sort out any function type mismatches.
3437   Constant *NewCallee =
3438     NestF->getType() == PTy ? NestF :
3439                               ConstantExpr::getBitCast(NestF, PTy);
3440   CS.setCalledFunction(NewCallee);
3441   return CS.getInstruction();
3442 }