LLVM  3.7.0
InstCombineCalls.cpp
Go to the documentation of this file.
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/Statistic.h"
18 #include "llvm/IR/CallSite.h"
19 #include "llvm/IR/Dominators.h"
20 #include "llvm/IR/PatternMatch.h"
21 #include "llvm/IR/Statepoint.h"
25 using namespace llvm;
26 using namespace PatternMatch;
27 
28 #define DEBUG_TYPE "instcombine"
29 
30 STATISTIC(NumSimplified, "Number of library calls simplified");
31 
32 /// getPromotedType - Return the specified type promoted as it would be to pass
33 /// though a va_arg area.
34 static Type *getPromotedType(Type *Ty) {
35  if (IntegerType* ITy = dyn_cast<IntegerType>(Ty)) {
36  if (ITy->getBitWidth() < 32)
37  return Type::getInt32Ty(Ty->getContext());
38  }
39  return Ty;
40 }
41 
42 /// reduceToSingleValueType - Given an aggregate type which ultimately holds a
43 /// single scalar element, like {{{type}}} or [1 x type], return type.
45  while (!T->isSingleValueType()) {
46  if (StructType *STy = dyn_cast<StructType>(T)) {
47  if (STy->getNumElements() == 1)
48  T = STy->getElementType(0);
49  else
50  break;
51  } else if (ArrayType *ATy = dyn_cast<ArrayType>(T)) {
52  if (ATy->getNumElements() == 1)
53  T = ATy->getElementType();
54  else
55  break;
56  } else
57  break;
58  }
59 
60  return T;
61 }
62 
63 Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) {
64  unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), DL, MI, AC, DT);
65  unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), DL, MI, AC, DT);
66  unsigned MinAlign = std::min(DstAlign, SrcAlign);
67  unsigned CopyAlign = MI->getAlignment();
68 
69  if (CopyAlign < MinAlign) {
70  MI->setAlignment(ConstantInt::get(MI->getAlignmentType(),
71  MinAlign, false));
72  return MI;
73  }
74 
75  // If MemCpyInst length is 1/2/4/8 bytes then replace memcpy with
76  // load/store.
77  ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getArgOperand(2));
78  if (!MemOpLength) return nullptr;
79 
80  // Source and destination pointer types are always "i8*" for intrinsic. See
81  // if the size is something we can handle with a single primitive load/store.
82  // A single load+store correctly handles overlapping memory in the memmove
83  // case.
84  uint64_t Size = MemOpLength->getLimitedValue();
85  assert(Size && "0-sized memory transferring should be removed already.");
86 
87  if (Size > 8 || (Size&(Size-1)))
88  return nullptr; // If not 1/2/4/8 bytes, exit.
89 
90  // Use an integer load+store unless we can find something better.
91  unsigned SrcAddrSp =
92  cast<PointerType>(MI->getArgOperand(1)->getType())->getAddressSpace();
93  unsigned DstAddrSp =
94  cast<PointerType>(MI->getArgOperand(0)->getType())->getAddressSpace();
95 
96  IntegerType* IntType = IntegerType::get(MI->getContext(), Size<<3);
97  Type *NewSrcPtrTy = PointerType::get(IntType, SrcAddrSp);
98  Type *NewDstPtrTy = PointerType::get(IntType, DstAddrSp);
99 
100  // Memcpy forces the use of i8* for the source and destination. That means
101  // that if you're using memcpy to move one double around, you'll get a cast
102  // from double* to i8*. We'd much rather use a double load+store rather than
103  // an i64 load+store, here because this improves the odds that the source or
104  // dest address will be promotable. See if we can find a better type than the
105  // integer datatype.
106  Value *StrippedDest = MI->getArgOperand(0)->stripPointerCasts();
107  MDNode *CopyMD = nullptr;
108  if (StrippedDest != MI->getArgOperand(0)) {
109  Type *SrcETy = cast<PointerType>(StrippedDest->getType())
110  ->getElementType();
111  if (SrcETy->isSized() && DL.getTypeStoreSize(SrcETy) == Size) {
112  // The SrcETy might be something like {{{double}}} or [1 x double]. Rip
113  // down through these levels if so.
114  SrcETy = reduceToSingleValueType(SrcETy);
115 
116  if (SrcETy->isSingleValueType()) {
117  NewSrcPtrTy = PointerType::get(SrcETy, SrcAddrSp);
118  NewDstPtrTy = PointerType::get(SrcETy, DstAddrSp);
119 
120  // If the memcpy has metadata describing the members, see if we can
121  // get the TBAA tag describing our copy.
122  if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa_struct)) {
123  if (M->getNumOperands() == 3 && M->getOperand(0) &&
124  mdconst::hasa<ConstantInt>(M->getOperand(0)) &&
125  mdconst::extract<ConstantInt>(M->getOperand(0))->isNullValue() &&
126  M->getOperand(1) &&
127  mdconst::hasa<ConstantInt>(M->getOperand(1)) &&
128  mdconst::extract<ConstantInt>(M->getOperand(1))->getValue() ==
129  Size &&
130  M->getOperand(2) && isa<MDNode>(M->getOperand(2)))
131  CopyMD = cast<MDNode>(M->getOperand(2));
132  }
133  }
134  }
135  }
136 
137  // If the memcpy/memmove provides better alignment info than we can
138  // infer, use it.
139  SrcAlign = std::max(SrcAlign, CopyAlign);
140  DstAlign = std::max(DstAlign, CopyAlign);
141 
142  Value *Src = Builder->CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy);
143  Value *Dest = Builder->CreateBitCast(MI->getArgOperand(0), NewDstPtrTy);
144  LoadInst *L = Builder->CreateLoad(Src, MI->isVolatile());
145  L->setAlignment(SrcAlign);
146  if (CopyMD)
147  L->setMetadata(LLVMContext::MD_tbaa, CopyMD);
148  StoreInst *S = Builder->CreateStore(L, Dest, MI->isVolatile());
149  S->setAlignment(DstAlign);
150  if (CopyMD)
151  S->setMetadata(LLVMContext::MD_tbaa, CopyMD);
152 
153  // Set the size of the copy to 0, it will be deleted on the next iteration.
154  MI->setArgOperand(2, Constant::getNullValue(MemOpLength->getType()));
155  return MI;
156 }
157 
158 Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) {
159  unsigned Alignment = getKnownAlignment(MI->getDest(), DL, MI, AC, DT);
160  if (MI->getAlignment() < Alignment) {
161  MI->setAlignment(ConstantInt::get(MI->getAlignmentType(),
162  Alignment, false));
163  return MI;
164  }
165 
166  // Extract the length and alignment and fill if they are constant.
167  ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength());
168  ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue());
169  if (!LenC || !FillC || !FillC->getType()->isIntegerTy(8))
170  return nullptr;
171  uint64_t Len = LenC->getLimitedValue();
172  Alignment = MI->getAlignment();
173  assert(Len && "0-sized memory setting should be removed already.");
174 
175  // memset(s,c,n) -> store s, c (for n=1,2,4,8)
176  if (Len <= 8 && isPowerOf2_32((uint32_t)Len)) {
177  Type *ITy = IntegerType::get(MI->getContext(), Len*8); // n=1 -> i8.
178 
179  Value *Dest = MI->getDest();
180  unsigned DstAddrSp = cast<PointerType>(Dest->getType())->getAddressSpace();
181  Type *NewDstPtrTy = PointerType::get(ITy, DstAddrSp);
182  Dest = Builder->CreateBitCast(Dest, NewDstPtrTy);
183 
184  // Alignment 0 is identity for alignment 1 for memset, but not store.
185  if (Alignment == 0) Alignment = 1;
186 
187  // Extract the fill value and store.
188  uint64_t Fill = FillC->getZExtValue()*0x0101010101010101ULL;
189  StoreInst *S = Builder->CreateStore(ConstantInt::get(ITy, Fill), Dest,
190  MI->isVolatile());
191  S->setAlignment(Alignment);
192 
193  // Set the size of the copy to 0, it will be deleted on the next iteration.
194  MI->setLength(Constant::getNullValue(LenC->getType()));
195  return MI;
196  }
197 
198  return nullptr;
199 }
200 
202  InstCombiner::BuilderTy &Builder) {
203  if (auto *CInt = dyn_cast<ConstantInt>(II.getArgOperand(2))) {
204  VectorType *VecTy = cast<VectorType>(II.getType());
205  assert(VecTy->getNumElements() == 4 && "insertps with wrong vector type");
206 
207  // The immediate permute control byte looks like this:
208  // [3:0] - zero mask for each 32-bit lane
209  // [5:4] - select one 32-bit destination lane
210  // [7:6] - select one 32-bit source lane
211 
212  uint8_t Imm = CInt->getZExtValue();
213  uint8_t ZMask = Imm & 0xf;
214  uint8_t DestLane = (Imm >> 4) & 0x3;
215  uint8_t SourceLane = (Imm >> 6) & 0x3;
216 
218 
219  // If all zero mask bits are set, this was just a weird way to
220  // generate a zero vector.
221  if (ZMask == 0xf)
222  return ZeroVector;
223 
224  // Initialize by passing all of the first source bits through.
225  int ShuffleMask[4] = { 0, 1, 2, 3 };
226 
227  // We may replace the second operand with the zero vector.
228  Value *V1 = II.getArgOperand(1);
229 
230  if (ZMask) {
231  // If the zero mask is being used with a single input or the zero mask
232  // overrides the destination lane, this is a shuffle with the zero vector.
233  if ((II.getArgOperand(0) == II.getArgOperand(1)) ||
234  (ZMask & (1 << DestLane))) {
235  V1 = ZeroVector;
236  // We may still move 32-bits of the first source vector from one lane
237  // to another.
238  ShuffleMask[DestLane] = SourceLane;
239  // The zero mask may override the previous insert operation.
240  for (unsigned i = 0; i < 4; ++i)
241  if ((ZMask >> i) & 0x1)
242  ShuffleMask[i] = i + 4;
243  } else {
244  // TODO: Model this case as 2 shuffles or a 'logical and' plus shuffle?
245  return nullptr;
246  }
247  } else {
248  // Replace the selected destination lane with the selected source lane.
249  ShuffleMask[DestLane] = SourceLane + 4;
250  }
251 
252  return Builder.CreateShuffleVector(II.getArgOperand(0), V1, ShuffleMask);
253  }
254  return nullptr;
255 }
256 
257 /// The shuffle mask for a perm2*128 selects any two halves of two 256-bit
258 /// source vectors, unless a zero bit is set. If a zero bit is set,
259 /// then ignore that half of the mask and clear that half of the vector.
261  InstCombiner::BuilderTy &Builder) {
262  if (auto *CInt = dyn_cast<ConstantInt>(II.getArgOperand(2))) {
263  VectorType *VecTy = cast<VectorType>(II.getType());
265 
266  // The immediate permute control byte looks like this:
267  // [1:0] - select 128 bits from sources for low half of destination
268  // [2] - ignore
269  // [3] - zero low half of destination
270  // [5:4] - select 128 bits from sources for high half of destination
271  // [6] - ignore
272  // [7] - zero high half of destination
273 
274  uint8_t Imm = CInt->getZExtValue();
275 
276  bool LowHalfZero = Imm & 0x08;
277  bool HighHalfZero = Imm & 0x80;
278 
279  // If both zero mask bits are set, this was just a weird way to
280  // generate a zero vector.
281  if (LowHalfZero && HighHalfZero)
282  return ZeroVector;
283 
284  // If 0 or 1 zero mask bits are set, this is a simple shuffle.
285  unsigned NumElts = VecTy->getNumElements();
286  unsigned HalfSize = NumElts / 2;
287  SmallVector<int, 8> ShuffleMask(NumElts);
288 
289  // The high bit of the selection field chooses the 1st or 2nd operand.
290  bool LowInputSelect = Imm & 0x02;
291  bool HighInputSelect = Imm & 0x20;
292 
293  // The low bit of the selection field chooses the low or high half
294  // of the selected operand.
295  bool LowHalfSelect = Imm & 0x01;
296  bool HighHalfSelect = Imm & 0x10;
297 
298  // Determine which operand(s) are actually in use for this instruction.
299  Value *V0 = LowInputSelect ? II.getArgOperand(1) : II.getArgOperand(0);
300  Value *V1 = HighInputSelect ? II.getArgOperand(1) : II.getArgOperand(0);
301 
302  // If needed, replace operands based on zero mask.
303  V0 = LowHalfZero ? ZeroVector : V0;
304  V1 = HighHalfZero ? ZeroVector : V1;
305 
306  // Permute low half of result.
307  unsigned StartIndex = LowHalfSelect ? HalfSize : 0;
308  for (unsigned i = 0; i < HalfSize; ++i)
309  ShuffleMask[i] = StartIndex + i;
310 
311  // Permute high half of result.
312  StartIndex = HighHalfSelect ? HalfSize : 0;
313  StartIndex += NumElts;
314  for (unsigned i = 0; i < HalfSize; ++i)
315  ShuffleMask[i + HalfSize] = StartIndex + i;
316 
317  return Builder.CreateShuffleVector(V0, V1, ShuffleMask);
318  }
319  return nullptr;
320 }
321 
322 /// visitCallInst - CallInst simplification. This mostly only handles folding
323 /// of intrinsic instructions. For normal calls, it allows visitCallSite to do
324 /// the heavy lifting.
325 ///
327  auto Args = CI.arg_operands();
328  if (Value *V = SimplifyCall(CI.getCalledValue(), Args.begin(), Args.end(), DL,
329  TLI, DT, AC))
330  return ReplaceInstUsesWith(CI, V);
331 
332  if (isFreeCall(&CI, TLI))
333  return visitFree(CI);
334 
335  // If the caller function is nounwind, mark the call as nounwind, even if the
336  // callee isn't.
337  if (CI.getParent()->getParent()->doesNotThrow() &&
338  !CI.doesNotThrow()) {
339  CI.setDoesNotThrow();
340  return &CI;
341  }
342 
344  if (!II) return visitCallSite(&CI);
345 
346  // Intrinsics cannot occur in an invoke, so handle them here instead of in
347  // visitCallSite.
348  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(II)) {
349  bool Changed = false;
350 
351  // memmove/cpy/set of zero bytes is a noop.
352  if (Constant *NumBytes = dyn_cast<Constant>(MI->getLength())) {
353  if (NumBytes->isNullValue())
354  return EraseInstFromFunction(CI);
355 
356  if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes))
357  if (CI->getZExtValue() == 1) {
358  // Replace the instruction with just byte operations. We would
359  // transform other cases to loads/stores, but we don't know if
360  // alignment is sufficient.
361  }
362  }
363 
364  // No other transformations apply to volatile transfers.
365  if (MI->isVolatile())
366  return nullptr;
367 
368  // If we have a memmove and the source operation is a constant global,
369  // then the source and dest pointers can't alias, so we can change this
370  // into a call to memcpy.
371  if (MemMoveInst *MMI = dyn_cast<MemMoveInst>(MI)) {
372  if (GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource()))
373  if (GVSrc->isConstant()) {
374  Module *M = CI.getParent()->getParent()->getParent();
375  Intrinsic::ID MemCpyID = Intrinsic::memcpy;
376  Type *Tys[3] = { CI.getArgOperand(0)->getType(),
377  CI.getArgOperand(1)->getType(),
378  CI.getArgOperand(2)->getType() };
379  CI.setCalledFunction(Intrinsic::getDeclaration(M, MemCpyID, Tys));
380  Changed = true;
381  }
382  }
383 
384  if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) {
385  // memmove(x,x,size) -> noop.
386  if (MTI->getSource() == MTI->getDest())
387  return EraseInstFromFunction(CI);
388  }
389 
390  // If we can determine a pointer alignment that is bigger than currently
391  // set, update the alignment.
392  if (isa<MemTransferInst>(MI)) {
393  if (Instruction *I = SimplifyMemTransfer(MI))
394  return I;
395  } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(MI)) {
396  if (Instruction *I = SimplifyMemSet(MSI))
397  return I;
398  }
399 
400  if (Changed) return II;
401  }
402 
403  switch (II->getIntrinsicID()) {
404  default: break;
405  case Intrinsic::objectsize: {
406  uint64_t Size;
407  if (getObjectSize(II->getArgOperand(0), Size, DL, TLI))
408  return ReplaceInstUsesWith(CI, ConstantInt::get(CI.getType(), Size));
409  return nullptr;
410  }
411  case Intrinsic::bswap: {
412  Value *IIOperand = II->getArgOperand(0);
413  Value *X = nullptr;
414 
415  // bswap(bswap(x)) -> x
416  if (match(IIOperand, m_BSwap(m_Value(X))))
417  return ReplaceInstUsesWith(CI, X);
418 
419  // bswap(trunc(bswap(x))) -> trunc(lshr(x, c))
420  if (match(IIOperand, m_Trunc(m_BSwap(m_Value(X))))) {
421  unsigned C = X->getType()->getPrimitiveSizeInBits() -
422  IIOperand->getType()->getPrimitiveSizeInBits();
423  Value *CV = ConstantInt::get(X->getType(), C);
424  Value *V = Builder->CreateLShr(X, CV);
425  return new TruncInst(V, IIOperand->getType());
426  }
427  break;
428  }
429 
430  case Intrinsic::powi:
431  if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
432  // powi(x, 0) -> 1.0
433  if (Power->isZero())
434  return ReplaceInstUsesWith(CI, ConstantFP::get(CI.getType(), 1.0));
435  // powi(x, 1) -> x
436  if (Power->isOne())
437  return ReplaceInstUsesWith(CI, II->getArgOperand(0));
438  // powi(x, -1) -> 1/x
439  if (Power->isAllOnesValue())
440  return BinaryOperator::CreateFDiv(ConstantFP::get(CI.getType(), 1.0),
441  II->getArgOperand(0));
442  }
443  break;
444  case Intrinsic::cttz: {
445  // If all bits below the first known one are known zero,
446  // this value is constant.
448  // FIXME: Try to simplify vectors of integers.
449  if (!IT) break;
450  uint32_t BitWidth = IT->getBitWidth();
451  APInt KnownZero(BitWidth, 0);
452  APInt KnownOne(BitWidth, 0);
453  computeKnownBits(II->getArgOperand(0), KnownZero, KnownOne, 0, II);
454  unsigned TrailingZeros = KnownOne.countTrailingZeros();
455  APInt Mask(APInt::getLowBitsSet(BitWidth, TrailingZeros));
456  if ((Mask & KnownZero) == Mask)
457  return ReplaceInstUsesWith(CI, ConstantInt::get(IT,
458  APInt(BitWidth, TrailingZeros)));
459 
460  }
461  break;
462  case Intrinsic::ctlz: {
463  // If all bits above the first known one are known zero,
464  // this value is constant.
466  // FIXME: Try to simplify vectors of integers.
467  if (!IT) break;
468  uint32_t BitWidth = IT->getBitWidth();
469  APInt KnownZero(BitWidth, 0);
470  APInt KnownOne(BitWidth, 0);
471  computeKnownBits(II->getArgOperand(0), KnownZero, KnownOne, 0, II);
472  unsigned LeadingZeros = KnownOne.countLeadingZeros();
473  APInt Mask(APInt::getHighBitsSet(BitWidth, LeadingZeros));
474  if ((Mask & KnownZero) == Mask)
475  return ReplaceInstUsesWith(CI, ConstantInt::get(IT,
476  APInt(BitWidth, LeadingZeros)));
477 
478  }
479  break;
480 
481  case Intrinsic::uadd_with_overflow:
482  case Intrinsic::sadd_with_overflow:
483  case Intrinsic::umul_with_overflow:
484  case Intrinsic::smul_with_overflow:
485  if (isa<Constant>(II->getArgOperand(0)) &&
486  !isa<Constant>(II->getArgOperand(1))) {
487  // Canonicalize constants into the RHS.
488  Value *LHS = II->getArgOperand(0);
489  II->setArgOperand(0, II->getArgOperand(1));
490  II->setArgOperand(1, LHS);
491  return II;
492  }
493  // fall through
494 
495  case Intrinsic::usub_with_overflow:
496  case Intrinsic::ssub_with_overflow: {
497  OverflowCheckFlavor OCF =
499  assert(OCF != OCF_INVALID && "unexpected!");
500 
501  Value *OperationResult = nullptr;
502  Constant *OverflowResult = nullptr;
503  if (OptimizeOverflowCheck(OCF, II->getArgOperand(0), II->getArgOperand(1),
504  *II, OperationResult, OverflowResult))
505  return CreateOverflowTuple(II, OperationResult, OverflowResult);
506 
507  break;
508  }
509 
510  case Intrinsic::minnum:
511  case Intrinsic::maxnum: {
512  Value *Arg0 = II->getArgOperand(0);
513  Value *Arg1 = II->getArgOperand(1);
514 
515  // fmin(x, x) -> x
516  if (Arg0 == Arg1)
517  return ReplaceInstUsesWith(CI, Arg0);
518 
519  const ConstantFP *C0 = dyn_cast<ConstantFP>(Arg0);
520  const ConstantFP *C1 = dyn_cast<ConstantFP>(Arg1);
521 
522  // Canonicalize constants into the RHS.
523  if (C0 && !C1) {
524  II->setArgOperand(0, Arg1);
525  II->setArgOperand(1, Arg0);
526  return II;
527  }
528 
529  // fmin(x, nan) -> x
530  if (C1 && C1->isNaN())
531  return ReplaceInstUsesWith(CI, Arg0);
532 
533  // This is the value because if undef were NaN, we would return the other
534  // value and cannot return a NaN unless both operands are.
535  //
536  // fmin(undef, x) -> x
537  if (isa<UndefValue>(Arg0))
538  return ReplaceInstUsesWith(CI, Arg1);
539 
540  // fmin(x, undef) -> x
541  if (isa<UndefValue>(Arg1))
542  return ReplaceInstUsesWith(CI, Arg0);
543 
544  Value *X = nullptr;
545  Value *Y = nullptr;
546  if (II->getIntrinsicID() == Intrinsic::minnum) {
547  // fmin(x, fmin(x, y)) -> fmin(x, y)
548  // fmin(y, fmin(x, y)) -> fmin(x, y)
549  if (match(Arg1, m_FMin(m_Value(X), m_Value(Y)))) {
550  if (Arg0 == X || Arg0 == Y)
551  return ReplaceInstUsesWith(CI, Arg1);
552  }
553 
554  // fmin(fmin(x, y), x) -> fmin(x, y)
555  // fmin(fmin(x, y), y) -> fmin(x, y)
556  if (match(Arg0, m_FMin(m_Value(X), m_Value(Y)))) {
557  if (Arg1 == X || Arg1 == Y)
558  return ReplaceInstUsesWith(CI, Arg0);
559  }
560 
561  // TODO: fmin(nnan x, inf) -> x
562  // TODO: fmin(nnan ninf x, flt_max) -> x
563  if (C1 && C1->isInfinity()) {
564  // fmin(x, -inf) -> -inf
565  if (C1->isNegative())
566  return ReplaceInstUsesWith(CI, Arg1);
567  }
568  } else {
569  assert(II->getIntrinsicID() == Intrinsic::maxnum);
570  // fmax(x, fmax(x, y)) -> fmax(x, y)
571  // fmax(y, fmax(x, y)) -> fmax(x, y)
572  if (match(Arg1, m_FMax(m_Value(X), m_Value(Y)))) {
573  if (Arg0 == X || Arg0 == Y)
574  return ReplaceInstUsesWith(CI, Arg1);
575  }
576 
577  // fmax(fmax(x, y), x) -> fmax(x, y)
578  // fmax(fmax(x, y), y) -> fmax(x, y)
579  if (match(Arg0, m_FMax(m_Value(X), m_Value(Y)))) {
580  if (Arg1 == X || Arg1 == Y)
581  return ReplaceInstUsesWith(CI, Arg0);
582  }
583 
584  // TODO: fmax(nnan x, -inf) -> x
585  // TODO: fmax(nnan ninf x, -flt_max) -> x
586  if (C1 && C1->isInfinity()) {
587  // fmax(x, inf) -> inf
588  if (!C1->isNegative())
589  return ReplaceInstUsesWith(CI, Arg1);
590  }
591  }
592  break;
593  }
594  case Intrinsic::ppc_altivec_lvx:
595  case Intrinsic::ppc_altivec_lvxl:
596  // Turn PPC lvx -> load if the pointer is known aligned.
597  if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, II, AC, DT) >=
598  16) {
599  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
600  PointerType::getUnqual(II->getType()));
601  return new LoadInst(Ptr);
602  }
603  break;
604  case Intrinsic::ppc_vsx_lxvw4x:
605  case Intrinsic::ppc_vsx_lxvd2x: {
606  // Turn PPC VSX loads into normal loads.
607  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
608  PointerType::getUnqual(II->getType()));
609  return new LoadInst(Ptr, Twine(""), false, 1);
610  }
611  case Intrinsic::ppc_altivec_stvx:
612  case Intrinsic::ppc_altivec_stvxl:
613  // Turn stvx -> store if the pointer is known aligned.
614  if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, DL, II, AC, DT) >=
615  16) {
616  Type *OpPtrTy =
617  PointerType::getUnqual(II->getArgOperand(0)->getType());
618  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
619  return new StoreInst(II->getArgOperand(0), Ptr);
620  }
621  break;
622  case Intrinsic::ppc_vsx_stxvw4x:
623  case Intrinsic::ppc_vsx_stxvd2x: {
624  // Turn PPC VSX stores into normal stores.
625  Type *OpPtrTy = PointerType::getUnqual(II->getArgOperand(0)->getType());
626  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
627  return new StoreInst(II->getArgOperand(0), Ptr, false, 1);
628  }
629  case Intrinsic::ppc_qpx_qvlfs:
630  // Turn PPC QPX qvlfs -> load if the pointer is known aligned.
631  if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, II, AC, DT) >=
632  16) {
633  Type *VTy = VectorType::get(Builder->getFloatTy(),
634  II->getType()->getVectorNumElements());
635  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
637  Value *Load = Builder->CreateLoad(Ptr);
638  return new FPExtInst(Load, II->getType());
639  }
640  break;
641  case Intrinsic::ppc_qpx_qvlfd:
642  // Turn PPC QPX qvlfd -> load if the pointer is known aligned.
643  if (getOrEnforceKnownAlignment(II->getArgOperand(0), 32, DL, II, AC, DT) >=
644  32) {
645  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
646  PointerType::getUnqual(II->getType()));
647  return new LoadInst(Ptr);
648  }
649  break;
650  case Intrinsic::ppc_qpx_qvstfs:
651  // Turn PPC QPX qvstfs -> store if the pointer is known aligned.
652  if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, DL, II, AC, DT) >=
653  16) {
654  Type *VTy = VectorType::get(Builder->getFloatTy(),
655  II->getArgOperand(0)->getType()->getVectorNumElements());
656  Value *TOp = Builder->CreateFPTrunc(II->getArgOperand(0), VTy);
657  Type *OpPtrTy = PointerType::getUnqual(VTy);
658  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
659  return new StoreInst(TOp, Ptr);
660  }
661  break;
662  case Intrinsic::ppc_qpx_qvstfd:
663  // Turn PPC QPX qvstfd -> store if the pointer is known aligned.
664  if (getOrEnforceKnownAlignment(II->getArgOperand(1), 32, DL, II, AC, DT) >=
665  32) {
666  Type *OpPtrTy =
667  PointerType::getUnqual(II->getArgOperand(0)->getType());
668  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
669  return new StoreInst(II->getArgOperand(0), Ptr);
670  }
671  break;
672  case Intrinsic::x86_sse_storeu_ps:
673  case Intrinsic::x86_sse2_storeu_pd:
674  case Intrinsic::x86_sse2_storeu_dq:
675  // Turn X86 storeu -> store if the pointer is known aligned.
676  if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, II, AC, DT) >=
677  16) {
678  Type *OpPtrTy =
679  PointerType::getUnqual(II->getArgOperand(1)->getType());
680  Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), OpPtrTy);
681  return new StoreInst(II->getArgOperand(1), Ptr);
682  }
683  break;
684 
685  case Intrinsic::x86_sse_cvtss2si:
686  case Intrinsic::x86_sse_cvtss2si64:
687  case Intrinsic::x86_sse_cvttss2si:
688  case Intrinsic::x86_sse_cvttss2si64:
689  case Intrinsic::x86_sse2_cvtsd2si:
690  case Intrinsic::x86_sse2_cvtsd2si64:
691  case Intrinsic::x86_sse2_cvttsd2si:
692  case Intrinsic::x86_sse2_cvttsd2si64: {
693  // These intrinsics only demand the 0th element of their input vectors. If
694  // we can simplify the input based on that, do so now.
695  unsigned VWidth =
696  cast<VectorType>(II->getArgOperand(0)->getType())->getNumElements();
697  APInt DemandedElts(VWidth, 1);
698  APInt UndefElts(VWidth, 0);
699  if (Value *V = SimplifyDemandedVectorElts(II->getArgOperand(0),
700  DemandedElts, UndefElts)) {
701  II->setArgOperand(0, V);
702  return II;
703  }
704  break;
705  }
706 
707  // Constant fold <A x Bi> << Ci.
708  // FIXME: We don't handle _dq because it's a shift of an i128, but is
709  // represented in the IR as <2 x i64>. A per element shift is wrong.
710  case Intrinsic::x86_sse2_psll_d:
711  case Intrinsic::x86_sse2_psll_q:
712  case Intrinsic::x86_sse2_psll_w:
713  case Intrinsic::x86_sse2_pslli_d:
714  case Intrinsic::x86_sse2_pslli_q:
715  case Intrinsic::x86_sse2_pslli_w:
716  case Intrinsic::x86_avx2_psll_d:
717  case Intrinsic::x86_avx2_psll_q:
718  case Intrinsic::x86_avx2_psll_w:
719  case Intrinsic::x86_avx2_pslli_d:
720  case Intrinsic::x86_avx2_pslli_q:
721  case Intrinsic::x86_avx2_pslli_w:
722  case Intrinsic::x86_sse2_psrl_d:
723  case Intrinsic::x86_sse2_psrl_q:
724  case Intrinsic::x86_sse2_psrl_w:
725  case Intrinsic::x86_sse2_psrli_d:
726  case Intrinsic::x86_sse2_psrli_q:
727  case Intrinsic::x86_sse2_psrli_w:
728  case Intrinsic::x86_avx2_psrl_d:
729  case Intrinsic::x86_avx2_psrl_q:
730  case Intrinsic::x86_avx2_psrl_w:
731  case Intrinsic::x86_avx2_psrli_d:
732  case Intrinsic::x86_avx2_psrli_q:
733  case Intrinsic::x86_avx2_psrli_w: {
734  // Simplify if count is constant. To 0 if >= BitWidth,
735  // otherwise to shl/lshr.
736  auto CDV = dyn_cast<ConstantDataVector>(II->getArgOperand(1));
737  auto CInt = dyn_cast<ConstantInt>(II->getArgOperand(1));
738  if (!CDV && !CInt)
739  break;
740  ConstantInt *Count;
741  if (CDV)
742  Count = cast<ConstantInt>(CDV->getElementAsConstant(0));
743  else
744  Count = CInt;
745 
746  auto Vec = II->getArgOperand(0);
747  auto VT = cast<VectorType>(Vec->getType());
748  if (Count->getZExtValue() >
749  VT->getElementType()->getPrimitiveSizeInBits() - 1)
750  return ReplaceInstUsesWith(
751  CI, ConstantAggregateZero::get(Vec->getType()));
752 
753  bool isPackedShiftLeft = true;
754  switch (II->getIntrinsicID()) {
755  default : break;
756  case Intrinsic::x86_sse2_psrl_d:
757  case Intrinsic::x86_sse2_psrl_q:
758  case Intrinsic::x86_sse2_psrl_w:
759  case Intrinsic::x86_sse2_psrli_d:
760  case Intrinsic::x86_sse2_psrli_q:
761  case Intrinsic::x86_sse2_psrli_w:
762  case Intrinsic::x86_avx2_psrl_d:
763  case Intrinsic::x86_avx2_psrl_q:
764  case Intrinsic::x86_avx2_psrl_w:
765  case Intrinsic::x86_avx2_psrli_d:
766  case Intrinsic::x86_avx2_psrli_q:
767  case Intrinsic::x86_avx2_psrli_w: isPackedShiftLeft = false; break;
768  }
769 
770  unsigned VWidth = VT->getNumElements();
771  // Get a constant vector of the same type as the first operand.
772  auto VTCI = ConstantInt::get(VT->getElementType(), Count->getZExtValue());
773  if (isPackedShiftLeft)
774  return BinaryOperator::CreateShl(Vec,
775  Builder->CreateVectorSplat(VWidth, VTCI));
776 
777  return BinaryOperator::CreateLShr(Vec,
778  Builder->CreateVectorSplat(VWidth, VTCI));
779  }
780 
781  case Intrinsic::x86_sse41_pmovsxbw:
782  case Intrinsic::x86_sse41_pmovsxwd:
783  case Intrinsic::x86_sse41_pmovsxdq:
784  case Intrinsic::x86_sse41_pmovzxbw:
785  case Intrinsic::x86_sse41_pmovzxwd:
786  case Intrinsic::x86_sse41_pmovzxdq: {
787  // pmov{s|z}x ignores the upper half of their input vectors.
788  unsigned VWidth =
789  cast<VectorType>(II->getArgOperand(0)->getType())->getNumElements();
790  unsigned LowHalfElts = VWidth / 2;
791  APInt InputDemandedElts(APInt::getBitsSet(VWidth, 0, LowHalfElts));
792  APInt UndefElts(VWidth, 0);
793  if (Value *TmpV = SimplifyDemandedVectorElts(
794  II->getArgOperand(0), InputDemandedElts, UndefElts)) {
795  II->setArgOperand(0, TmpV);
796  return II;
797  }
798  break;
799  }
800  case Intrinsic::x86_sse41_insertps:
801  if (Value *V = SimplifyX86insertps(*II, *Builder))
802  return ReplaceInstUsesWith(*II, V);
803  break;
804 
805  case Intrinsic::x86_sse4a_insertqi: {
806  // insertqi x, y, 64, 0 can just copy y's lower bits and leave the top
807  // ones undef
808  // TODO: eventually we should lower this intrinsic to IR
809  if (auto CIWidth = dyn_cast<ConstantInt>(II->getArgOperand(2))) {
810  if (auto CIStart = dyn_cast<ConstantInt>(II->getArgOperand(3))) {
811  unsigned Index = CIStart->getZExtValue();
812  // From AMD documentation: "a value of zero in the field length is
813  // defined as length of 64".
814  unsigned Length = CIWidth->equalsInt(0) ? 64 : CIWidth->getZExtValue();
815 
816  // From AMD documentation: "If the sum of the bit index + length field
817  // is greater than 64, the results are undefined".
818 
819  // Note that both field index and field length are 8-bit quantities.
820  // Since variables 'Index' and 'Length' are unsigned values
821  // obtained from zero-extending field index and field length
822  // respectively, their sum should never wrap around.
823  if ((Index + Length) > 64)
824  return ReplaceInstUsesWith(CI, UndefValue::get(II->getType()));
825 
826  if (Length == 64 && Index == 0) {
827  Value *Vec = II->getArgOperand(1);
828  Value *Undef = UndefValue::get(Vec->getType());
829  const uint32_t Mask[] = { 0, 2 };
830  return ReplaceInstUsesWith(
831  CI,
832  Builder->CreateShuffleVector(
833  Vec, Undef, ConstantDataVector::get(
834  II->getContext(), makeArrayRef(Mask))));
835 
836  } else if (auto Source =
837  dyn_cast<IntrinsicInst>(II->getArgOperand(0))) {
838  if (Source->hasOneUse() &&
839  Source->getArgOperand(1) == II->getArgOperand(1)) {
840  // If the source of the insert has only one use and it's another
841  // insert (and they're both inserting from the same vector), try to
842  // bundle both together.
843  auto CISourceWidth =
844  dyn_cast<ConstantInt>(Source->getArgOperand(2));
845  auto CISourceStart =
846  dyn_cast<ConstantInt>(Source->getArgOperand(3));
847  if (CISourceStart && CISourceWidth) {
848  unsigned Start = CIStart->getZExtValue();
849  unsigned Width = CIWidth->getZExtValue();
850  unsigned End = Start + Width;
851  unsigned SourceStart = CISourceStart->getZExtValue();
852  unsigned SourceWidth = CISourceWidth->getZExtValue();
853  unsigned SourceEnd = SourceStart + SourceWidth;
854  unsigned NewStart, NewWidth;
855  bool ShouldReplace = false;
856  if (Start <= SourceStart && SourceStart <= End) {
857  NewStart = Start;
858  NewWidth = std::max(End, SourceEnd) - NewStart;
859  ShouldReplace = true;
860  } else if (SourceStart <= Start && Start <= SourceEnd) {
861  NewStart = SourceStart;
862  NewWidth = std::max(SourceEnd, End) - NewStart;
863  ShouldReplace = true;
864  }
865 
866  if (ShouldReplace) {
867  Constant *ConstantWidth = ConstantInt::get(
868  II->getArgOperand(2)->getType(), NewWidth, false);
869  Constant *ConstantStart = ConstantInt::get(
870  II->getArgOperand(3)->getType(), NewStart, false);
871  Value *Args[4] = { Source->getArgOperand(0),
872  II->getArgOperand(1), ConstantWidth,
873  ConstantStart };
874  Module *M = CI.getParent()->getParent()->getParent();
875  Value *F =
876  Intrinsic::getDeclaration(M, Intrinsic::x86_sse4a_insertqi);
877  return ReplaceInstUsesWith(CI, Builder->CreateCall(F, Args));
878  }
879  }
880  }
881  }
882  }
883  }
884  break;
885  }
886 
887  case Intrinsic::x86_sse41_pblendvb:
888  case Intrinsic::x86_sse41_blendvps:
889  case Intrinsic::x86_sse41_blendvpd:
890  case Intrinsic::x86_avx_blendv_ps_256:
891  case Intrinsic::x86_avx_blendv_pd_256:
892  case Intrinsic::x86_avx2_pblendvb: {
893  // Convert blendv* to vector selects if the mask is constant.
894  // This optimization is convoluted because the intrinsic is defined as
895  // getting a vector of floats or doubles for the ps and pd versions.
896  // FIXME: That should be changed.
897  Value *Mask = II->getArgOperand(2);
898  if (auto C = dyn_cast<ConstantDataVector>(Mask)) {
899  auto Tyi1 = Builder->getInt1Ty();
900  auto SelectorType = cast<VectorType>(Mask->getType());
901  auto EltTy = SelectorType->getElementType();
902  unsigned Size = SelectorType->getNumElements();
903  unsigned BitWidth =
904  EltTy->isFloatTy()
905  ? 32
906  : (EltTy->isDoubleTy() ? 64 : EltTy->getIntegerBitWidth());
907  assert((BitWidth == 64 || BitWidth == 32 || BitWidth == 8) &&
908  "Wrong arguments for variable blend intrinsic");
909  SmallVector<Constant *, 32> Selectors;
910  for (unsigned I = 0; I < Size; ++I) {
911  // The intrinsics only read the top bit
912  uint64_t Selector;
913  if (BitWidth == 8)
914  Selector = C->getElementAsInteger(I);
915  else
916  Selector = C->getElementAsAPFloat(I).bitcastToAPInt().getZExtValue();
917  Selectors.push_back(ConstantInt::get(Tyi1, Selector >> (BitWidth - 1)));
918  }
919  auto NewSelector = ConstantVector::get(Selectors);
920  return SelectInst::Create(NewSelector, II->getArgOperand(1),
921  II->getArgOperand(0), "blendv");
922  } else {
923  break;
924  }
925  }
926 
927  case Intrinsic::x86_avx_vpermilvar_ps:
928  case Intrinsic::x86_avx_vpermilvar_ps_256:
929  case Intrinsic::x86_avx_vpermilvar_pd:
930  case Intrinsic::x86_avx_vpermilvar_pd_256: {
931  // Convert vpermil* to shufflevector if the mask is constant.
932  Value *V = II->getArgOperand(1);
933  unsigned Size = cast<VectorType>(V->getType())->getNumElements();
934  assert(Size == 8 || Size == 4 || Size == 2);
935  uint32_t Indexes[8];
936  if (auto C = dyn_cast<ConstantDataVector>(V)) {
937  // The intrinsics only read one or two bits, clear the rest.
938  for (unsigned I = 0; I < Size; ++I) {
939  uint32_t Index = C->getElementAsInteger(I) & 0x3;
940  if (II->getIntrinsicID() == Intrinsic::x86_avx_vpermilvar_pd ||
941  II->getIntrinsicID() == Intrinsic::x86_avx_vpermilvar_pd_256)
942  Index >>= 1;
943  Indexes[I] = Index;
944  }
945  } else if (isa<ConstantAggregateZero>(V)) {
946  for (unsigned I = 0; I < Size; ++I)
947  Indexes[I] = 0;
948  } else {
949  break;
950  }
951  // The _256 variants are a bit trickier since the mask bits always index
952  // into the corresponding 128 half. In order to convert to a generic
953  // shuffle, we have to make that explicit.
954  if (II->getIntrinsicID() == Intrinsic::x86_avx_vpermilvar_ps_256 ||
955  II->getIntrinsicID() == Intrinsic::x86_avx_vpermilvar_pd_256) {
956  for (unsigned I = Size / 2; I < Size; ++I)
957  Indexes[I] += Size / 2;
958  }
959  auto NewC =
960  ConstantDataVector::get(V->getContext(), makeArrayRef(Indexes, Size));
961  auto V1 = II->getArgOperand(0);
962  auto V2 = UndefValue::get(V1->getType());
963  auto Shuffle = Builder->CreateShuffleVector(V1, V2, NewC);
964  return ReplaceInstUsesWith(CI, Shuffle);
965  }
966 
967  case Intrinsic::x86_avx_vperm2f128_pd_256:
968  case Intrinsic::x86_avx_vperm2f128_ps_256:
969  case Intrinsic::x86_avx_vperm2f128_si_256:
970  case Intrinsic::x86_avx2_vperm2i128:
971  if (Value *V = SimplifyX86vperm2(*II, *Builder))
972  return ReplaceInstUsesWith(*II, V);
973  break;
974 
975  case Intrinsic::ppc_altivec_vperm:
976  // Turn vperm(V1,V2,mask) -> shuffle(V1,V2,mask) if mask is a constant.
977  // Note that ppc_altivec_vperm has a big-endian bias, so when creating
978  // a vectorshuffle for little endian, we must undo the transformation
979  // performed on vec_perm in altivec.h. That is, we must complement
980  // the permutation mask with respect to 31 and reverse the order of
981  // V1 and V2.
982  if (Constant *Mask = dyn_cast<Constant>(II->getArgOperand(2))) {
983  assert(Mask->getType()->getVectorNumElements() == 16 &&
984  "Bad type for intrinsic!");
985 
986  // Check that all of the elements are integer constants or undefs.
987  bool AllEltsOk = true;
988  for (unsigned i = 0; i != 16; ++i) {
989  Constant *Elt = Mask->getAggregateElement(i);
990  if (!Elt || !(isa<ConstantInt>(Elt) || isa<UndefValue>(Elt))) {
991  AllEltsOk = false;
992  break;
993  }
994  }
995 
996  if (AllEltsOk) {
997  // Cast the input vectors to byte vectors.
998  Value *Op0 = Builder->CreateBitCast(II->getArgOperand(0),
999  Mask->getType());
1000  Value *Op1 = Builder->CreateBitCast(II->getArgOperand(1),
1001  Mask->getType());
1002  Value *Result = UndefValue::get(Op0->getType());
1003 
1004  // Only extract each element once.
1005  Value *ExtractedElts[32];
1006  memset(ExtractedElts, 0, sizeof(ExtractedElts));
1007 
1008  for (unsigned i = 0; i != 16; ++i) {
1009  if (isa<UndefValue>(Mask->getAggregateElement(i)))
1010  continue;
1011  unsigned Idx =
1012  cast<ConstantInt>(Mask->getAggregateElement(i))->getZExtValue();
1013  Idx &= 31; // Match the hardware behavior.
1014  if (DL.isLittleEndian())
1015  Idx = 31 - Idx;
1016 
1017  if (!ExtractedElts[Idx]) {
1018  Value *Op0ToUse = (DL.isLittleEndian()) ? Op1 : Op0;
1019  Value *Op1ToUse = (DL.isLittleEndian()) ? Op0 : Op1;
1020  ExtractedElts[Idx] =
1021  Builder->CreateExtractElement(Idx < 16 ? Op0ToUse : Op1ToUse,
1022  Builder->getInt32(Idx&15));
1023  }
1024 
1025  // Insert this value into the result vector.
1026  Result = Builder->CreateInsertElement(Result, ExtractedElts[Idx],
1027  Builder->getInt32(i));
1028  }
1029  return CastInst::Create(Instruction::BitCast, Result, CI.getType());
1030  }
1031  }
1032  break;
1033 
1034  case Intrinsic::arm_neon_vld1:
1035  case Intrinsic::arm_neon_vld2:
1036  case Intrinsic::arm_neon_vld3:
1037  case Intrinsic::arm_neon_vld4:
1038  case Intrinsic::arm_neon_vld2lane:
1039  case Intrinsic::arm_neon_vld3lane:
1040  case Intrinsic::arm_neon_vld4lane:
1041  case Intrinsic::arm_neon_vst1:
1042  case Intrinsic::arm_neon_vst2:
1043  case Intrinsic::arm_neon_vst3:
1044  case Intrinsic::arm_neon_vst4:
1045  case Intrinsic::arm_neon_vst2lane:
1046  case Intrinsic::arm_neon_vst3lane:
1047  case Intrinsic::arm_neon_vst4lane: {
1048  unsigned MemAlign = getKnownAlignment(II->getArgOperand(0), DL, II, AC, DT);
1049  unsigned AlignArg = II->getNumArgOperands() - 1;
1050  ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg));
1051  if (IntrAlign && IntrAlign->getZExtValue() < MemAlign) {
1052  II->setArgOperand(AlignArg,
1053  ConstantInt::get(Type::getInt32Ty(II->getContext()),
1054  MemAlign, false));
1055  return II;
1056  }
1057  break;
1058  }
1059 
1060  case Intrinsic::arm_neon_vmulls:
1061  case Intrinsic::arm_neon_vmullu:
1062  case Intrinsic::aarch64_neon_smull:
1063  case Intrinsic::aarch64_neon_umull: {
1064  Value *Arg0 = II->getArgOperand(0);
1065  Value *Arg1 = II->getArgOperand(1);
1066 
1067  // Handle mul by zero first:
1068  if (isa<ConstantAggregateZero>(Arg0) || isa<ConstantAggregateZero>(Arg1)) {
1069  return ReplaceInstUsesWith(CI, ConstantAggregateZero::get(II->getType()));
1070  }
1071 
1072  // Check for constant LHS & RHS - in this case we just simplify.
1073  bool Zext = (II->getIntrinsicID() == Intrinsic::arm_neon_vmullu ||
1074  II->getIntrinsicID() == Intrinsic::aarch64_neon_umull);
1075  VectorType *NewVT = cast<VectorType>(II->getType());
1076  if (Constant *CV0 = dyn_cast<Constant>(Arg0)) {
1077  if (Constant *CV1 = dyn_cast<Constant>(Arg1)) {
1078  CV0 = ConstantExpr::getIntegerCast(CV0, NewVT, /*isSigned=*/!Zext);
1079  CV1 = ConstantExpr::getIntegerCast(CV1, NewVT, /*isSigned=*/!Zext);
1080 
1081  return ReplaceInstUsesWith(CI, ConstantExpr::getMul(CV0, CV1));
1082  }
1083 
1084  // Couldn't simplify - canonicalize constant to the RHS.
1085  std::swap(Arg0, Arg1);
1086  }
1087 
1088  // Handle mul by one:
1089  if (Constant *CV1 = dyn_cast<Constant>(Arg1))
1090  if (ConstantInt *Splat =
1091  dyn_cast_or_null<ConstantInt>(CV1->getSplatValue()))
1092  if (Splat->isOne())
1093  return CastInst::CreateIntegerCast(Arg0, II->getType(),
1094  /*isSigned=*/!Zext);
1095 
1096  break;
1097  }
1098 
1099  case Intrinsic::AMDGPU_rcp: {
1100  if (const ConstantFP *C = dyn_cast<ConstantFP>(II->getArgOperand(0))) {
1101  const APFloat &ArgVal = C->getValueAPF();
1102  APFloat Val(ArgVal.getSemantics(), 1.0);
1103  APFloat::opStatus Status = Val.divide(ArgVal,
1105  // Only do this if it was exact and therefore not dependent on the
1106  // rounding mode.
1107  if (Status == APFloat::opOK)
1108  return ReplaceInstUsesWith(CI, ConstantFP::get(II->getContext(), Val));
1109  }
1110 
1111  break;
1112  }
1113  case Intrinsic::stackrestore: {
1114  // If the save is right next to the restore, remove the restore. This can
1115  // happen when variable allocas are DCE'd.
1116  if (IntrinsicInst *SS = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) {
1117  if (SS->getIntrinsicID() == Intrinsic::stacksave) {
1118  BasicBlock::iterator BI = SS;
1119  if (&*++BI == II)
1120  return EraseInstFromFunction(CI);
1121  }
1122  }
1123 
1124  // Scan down this block to see if there is another stack restore in the
1125  // same block without an intervening call/alloca.
1126  BasicBlock::iterator BI = II;
1127  TerminatorInst *TI = II->getParent()->getTerminator();
1128  bool CannotRemove = false;
1129  for (++BI; &*BI != TI; ++BI) {
1130  if (isa<AllocaInst>(BI)) {
1131  CannotRemove = true;
1132  break;
1133  }
1134  if (CallInst *BCI = dyn_cast<CallInst>(BI)) {
1135  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(BCI)) {
1136  // If there is a stackrestore below this one, remove this one.
1137  if (II->getIntrinsicID() == Intrinsic::stackrestore)
1138  return EraseInstFromFunction(CI);
1139  // Otherwise, ignore the intrinsic.
1140  } else {
1141  // If we found a non-intrinsic call, we can't remove the stack
1142  // restore.
1143  CannotRemove = true;
1144  break;
1145  }
1146  }
1147  }
1148 
1149  // If the stack restore is in a return, resume, or unwind block and if there
1150  // are no allocas or calls between the restore and the return, nuke the
1151  // restore.
1152  if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))
1153  return EraseInstFromFunction(CI);
1154  break;
1155  }
1156  case Intrinsic::assume: {
1157  // Canonicalize assume(a && b) -> assume(a); assume(b);
1158  // Note: New assumption intrinsics created here are registered by
1159  // the InstCombineIRInserter object.
1160  Value *IIOperand = II->getArgOperand(0), *A, *B,
1161  *AssumeIntrinsic = II->getCalledValue();
1162  if (match(IIOperand, m_And(m_Value(A), m_Value(B)))) {
1163  Builder->CreateCall(AssumeIntrinsic, A, II->getName());
1164  Builder->CreateCall(AssumeIntrinsic, B, II->getName());
1165  return EraseInstFromFunction(*II);
1166  }
1167  // assume(!(a || b)) -> assume(!a); assume(!b);
1168  if (match(IIOperand, m_Not(m_Or(m_Value(A), m_Value(B))))) {
1169  Builder->CreateCall(AssumeIntrinsic, Builder->CreateNot(A),
1170  II->getName());
1171  Builder->CreateCall(AssumeIntrinsic, Builder->CreateNot(B),
1172  II->getName());
1173  return EraseInstFromFunction(*II);
1174  }
1175 
1176  // assume( (load addr) != null ) -> add 'nonnull' metadata to load
1177  // (if assume is valid at the load)
1178  if (ICmpInst* ICmp = dyn_cast<ICmpInst>(IIOperand)) {
1179  Value *LHS = ICmp->getOperand(0);
1180  Value *RHS = ICmp->getOperand(1);
1181  if (ICmpInst::ICMP_NE == ICmp->getPredicate() &&
1182  isa<LoadInst>(LHS) &&
1183  isa<Constant>(RHS) &&
1184  RHS->getType()->isPointerTy() &&
1185  cast<Constant>(RHS)->isNullValue()) {
1186  LoadInst* LI = cast<LoadInst>(LHS);
1187  if (isValidAssumeForContext(II, LI, DT)) {
1188  MDNode *MD = MDNode::get(II->getContext(), None);
1190  return EraseInstFromFunction(*II);
1191  }
1192  }
1193  // TODO: apply nonnull return attributes to calls and invokes
1194  // TODO: apply range metadata for range check patterns?
1195  }
1196  // If there is a dominating assume with the same condition as this one,
1197  // then this one is redundant, and should be removed.
1198  APInt KnownZero(1, 0), KnownOne(1, 0);
1199  computeKnownBits(IIOperand, KnownZero, KnownOne, 0, II);
1200  if (KnownOne.isAllOnesValue())
1201  return EraseInstFromFunction(*II);
1202 
1203  break;
1204  }
1205  case Intrinsic::experimental_gc_relocate: {
1206  // Translate facts known about a pointer before relocating into
1207  // facts about the relocate value, while being careful to
1208  // preserve relocation semantics.
1210  Value *DerivedPtr = Operands.getDerivedPtr();
1211  auto *GCRelocateType = cast<PointerType>(II->getType());
1212 
1213  // Remove the relocation if unused, note that this check is required
1214  // to prevent the cases below from looping forever.
1215  if (II->use_empty())
1216  return EraseInstFromFunction(*II);
1217 
1218  // Undef is undef, even after relocation.
1219  // TODO: provide a hook for this in GCStrategy. This is clearly legal for
1220  // most practical collectors, but there was discussion in the review thread
1221  // about whether it was legal for all possible collectors.
1222  if (isa<UndefValue>(DerivedPtr)) {
1223  // gc_relocate is uncasted. Use undef of gc_relocate's type to replace it.
1224  return ReplaceInstUsesWith(*II, UndefValue::get(GCRelocateType));
1225  }
1226 
1227  // The relocation of null will be null for most any collector.
1228  // TODO: provide a hook for this in GCStrategy. There might be some weird
1229  // collector this property does not hold for.
1230  if (isa<ConstantPointerNull>(DerivedPtr)) {
1231  // gc_relocate is uncasted. Use null-pointer of gc_relocate's type to replace it.
1232  return ReplaceInstUsesWith(*II, ConstantPointerNull::get(GCRelocateType));
1233  }
1234 
1235  // isKnownNonNull -> nonnull attribute
1236  if (isKnownNonNull(DerivedPtr))
1237  II->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull);
1238 
1239  // isDereferenceablePointer -> deref attribute
1240  if (isDereferenceablePointer(DerivedPtr, DL)) {
1241  if (Argument *A = dyn_cast<Argument>(DerivedPtr)) {
1242  uint64_t Bytes = A->getDereferenceableBytes();
1243  II->addDereferenceableAttr(AttributeSet::ReturnIndex, Bytes);
1244  }
1245  }
1246 
1247  // TODO: bitcast(relocate(p)) -> relocate(bitcast(p))
1248  // Canonicalize on the type from the uses to the defs
1249 
1250  // TODO: relocate((gep p, C, C2, ...)) -> gep(relocate(p), C, C2, ...)
1251  }
1252  }
1253 
1254  return visitCallSite(II);
1255 }
1256 
1257 // InvokeInst simplification
1258 //
1260  return visitCallSite(&II);
1261 }
1262 
1263 /// isSafeToEliminateVarargsCast - If this cast does not affect the value
1264 /// passed through the varargs area, we can eliminate the use of the cast.
1266  const DataLayout &DL,
1267  const CastInst *const CI,
1268  const int ix) {
1269  if (!CI->isLosslessCast())
1270  return false;
1271 
1272  // If this is a GC intrinsic, avoid munging types. We need types for
1273  // statepoint reconstruction in SelectionDAG.
1274  // TODO: This is probably something which should be expanded to all
1275  // intrinsics since the entire point of intrinsics is that
1276  // they are understandable by the optimizer.
1277  if (isStatepoint(CS) || isGCRelocate(CS) || isGCResult(CS))
1278  return false;
1279 
1280  // The size of ByVal or InAlloca arguments is derived from the type, so we
1281  // can't change to a type with a different size. If the size were
1282  // passed explicitly we could avoid this check.
1283  if (!CS.isByValOrInAllocaArgument(ix))
1284  return true;
1285 
1286  Type* SrcTy =
1287  cast<PointerType>(CI->getOperand(0)->getType())->getElementType();
1288  Type* DstTy = cast<PointerType>(CI->getType())->getElementType();
1289  if (!SrcTy->isSized() || !DstTy->isSized())
1290  return false;
1291  if (DL.getTypeAllocSize(SrcTy) != DL.getTypeAllocSize(DstTy))
1292  return false;
1293  return true;
1294 }
1295 
1296 // Try to fold some different type of calls here.
1297 // Currently we're only working with the checking functions, memcpy_chk,
1298 // mempcpy_chk, memmove_chk, memset_chk, strcpy_chk, stpcpy_chk, strncpy_chk,
1299 // strcat_chk and strncat_chk.
1300 Instruction *InstCombiner::tryOptimizeCall(CallInst *CI) {
1301  if (!CI->getCalledFunction()) return nullptr;
1302 
1303  auto InstCombineRAUW = [this](Instruction *From, Value *With) {
1304  ReplaceInstUsesWith(*From, With);
1305  };
1306  LibCallSimplifier Simplifier(DL, TLI, InstCombineRAUW);
1307  if (Value *With = Simplifier.optimizeCall(CI)) {
1308  ++NumSimplified;
1309  return CI->use_empty() ? CI : ReplaceInstUsesWith(*CI, With);
1310  }
1311 
1312  return nullptr;
1313 }
1314 
1316  // Strip off at most one level of pointer casts, looking for an alloca. This
1317  // is good enough in practice and simpler than handling any number of casts.
1318  Value *Underlying = TrampMem->stripPointerCasts();
1319  if (Underlying != TrampMem &&
1320  (!Underlying->hasOneUse() || Underlying->user_back() != TrampMem))
1321  return nullptr;
1322  if (!isa<AllocaInst>(Underlying))
1323  return nullptr;
1324 
1325  IntrinsicInst *InitTrampoline = nullptr;
1326  for (User *U : TrampMem->users()) {
1328  if (!II)
1329  return nullptr;
1330  if (II->getIntrinsicID() == Intrinsic::init_trampoline) {
1331  if (InitTrampoline)
1332  // More than one init_trampoline writes to this value. Give up.
1333  return nullptr;
1334  InitTrampoline = II;
1335  continue;
1336  }
1337  if (II->getIntrinsicID() == Intrinsic::adjust_trampoline)
1338  // Allow any number of calls to adjust.trampoline.
1339  continue;
1340  return nullptr;
1341  }
1342 
1343  // No call to init.trampoline found.
1344  if (!InitTrampoline)
1345  return nullptr;
1346 
1347  // Check that the alloca is being used in the expected way.
1348  if (InitTrampoline->getOperand(0) != TrampMem)
1349  return nullptr;
1350 
1351  return InitTrampoline;
1352 }
1353 
1355  Value *TrampMem) {
1356  // Visit all the previous instructions in the basic block, and try to find a
1357  // init.trampoline which has a direct path to the adjust.trampoline.
1358  for (BasicBlock::iterator I = AdjustTramp,
1359  E = AdjustTramp->getParent()->begin(); I != E; ) {
1360  Instruction *Inst = --I;
1361  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I))
1362  if (II->getIntrinsicID() == Intrinsic::init_trampoline &&
1363  II->getOperand(0) == TrampMem)
1364  return II;
1365  if (Inst->mayWriteToMemory())
1366  return nullptr;
1367  }
1368  return nullptr;
1369 }
1370 
1371 // Given a call to llvm.adjust.trampoline, find and return the corresponding
1372 // call to llvm.init.trampoline if the call to the trampoline can be optimized
1373 // to a direct call to a function. Otherwise return NULL.
1374 //
1376  Callee = Callee->stripPointerCasts();
1377  IntrinsicInst *AdjustTramp = dyn_cast<IntrinsicInst>(Callee);
1378  if (!AdjustTramp ||
1379  AdjustTramp->getIntrinsicID() != Intrinsic::adjust_trampoline)
1380  return nullptr;
1381 
1382  Value *TrampMem = AdjustTramp->getOperand(0);
1383 
1385  return IT;
1386  if (IntrinsicInst *IT = FindInitTrampolineFromBB(AdjustTramp, TrampMem))
1387  return IT;
1388  return nullptr;
1389 }
1390 
1391 // visitCallSite - Improvements for call and invoke instructions.
1392 //
1393 Instruction *InstCombiner::visitCallSite(CallSite CS) {
1394 
1395  if (isAllocLikeFn(CS.getInstruction(), TLI))
1396  return visitAllocSite(*CS.getInstruction());
1397 
1398  bool Changed = false;
1399 
1400  // Mark any parameters that are known to be non-null with the nonnull
1401  // attribute. This is helpful for inlining calls to functions with null
1402  // checks on their arguments.
1403  unsigned ArgNo = 0;
1404  for (Value *V : CS.args()) {
1405  if (!CS.paramHasAttr(ArgNo+1, Attribute::NonNull) &&
1406  isKnownNonNull(V)) {
1407  AttributeSet AS = CS.getAttributes();
1408  AS = AS.addAttribute(CS.getInstruction()->getContext(), ArgNo+1,
1410  CS.setAttributes(AS);
1411  Changed = true;
1412  }
1413  ArgNo++;
1414  }
1415  assert(ArgNo == CS.arg_size() && "sanity check");
1416 
1417  // If the callee is a pointer to a function, attempt to move any casts to the
1418  // arguments of the call/invoke.
1419  Value *Callee = CS.getCalledValue();
1420  if (!isa<Function>(Callee) && transformConstExprCastCall(CS))
1421  return nullptr;
1422 
1423  if (Function *CalleeF = dyn_cast<Function>(Callee))
1424  // If the call and callee calling conventions don't match, this call must
1425  // be unreachable, as the call is undefined.
1426  if (CalleeF->getCallingConv() != CS.getCallingConv() &&
1427  // Only do this for calls to a function with a body. A prototype may
1428  // not actually end up matching the implementation's calling conv for a
1429  // variety of reasons (e.g. it may be written in assembly).
1430  !CalleeF->isDeclaration()) {
1431  Instruction *OldCall = CS.getInstruction();
1432  new StoreInst(ConstantInt::getTrue(Callee->getContext()),
1433  UndefValue::get(Type::getInt1PtrTy(Callee->getContext())),
1434  OldCall);
1435  // If OldCall does not return void then replaceAllUsesWith undef.
1436  // This allows ValueHandlers and custom metadata to adjust itself.
1437  if (!OldCall->getType()->isVoidTy())
1438  ReplaceInstUsesWith(*OldCall, UndefValue::get(OldCall->getType()));
1439  if (isa<CallInst>(OldCall))
1440  return EraseInstFromFunction(*OldCall);
1441 
1442  // We cannot remove an invoke, because it would change the CFG, just
1443  // change the callee to a null pointer.
1444  cast<InvokeInst>(OldCall)->setCalledFunction(
1445  Constant::getNullValue(CalleeF->getType()));
1446  return nullptr;
1447  }
1448 
1449  if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
1450  // If CS does not return void then replaceAllUsesWith undef.
1451  // This allows ValueHandlers and custom metadata to adjust itself.
1452  if (!CS.getInstruction()->getType()->isVoidTy())
1453  ReplaceInstUsesWith(*CS.getInstruction(),
1455 
1456  if (isa<InvokeInst>(CS.getInstruction())) {
1457  // Can't remove an invoke because we cannot change the CFG.
1458  return nullptr;
1459  }
1460 
1461  // This instruction is not reachable, just remove it. We insert a store to
1462  // undef so that we know that this code is not reachable, despite the fact
1463  // that we can't modify the CFG here.
1464  new StoreInst(ConstantInt::getTrue(Callee->getContext()),
1465  UndefValue::get(Type::getInt1PtrTy(Callee->getContext())),
1466  CS.getInstruction());
1467 
1468  return EraseInstFromFunction(*CS.getInstruction());
1469  }
1470 
1471  if (IntrinsicInst *II = FindInitTrampoline(Callee))
1472  return transformCallThroughTrampoline(CS, II);
1473 
1474  PointerType *PTy = cast<PointerType>(Callee->getType());
1475  FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
1476  if (FTy->isVarArg()) {
1477  int ix = FTy->getNumParams();
1478  // See if we can optimize any arguments passed through the varargs area of
1479  // the call.
1480  for (CallSite::arg_iterator I = CS.arg_begin() + FTy->getNumParams(),
1481  E = CS.arg_end(); I != E; ++I, ++ix) {
1482  CastInst *CI = dyn_cast<CastInst>(*I);
1483  if (CI && isSafeToEliminateVarargsCast(CS, DL, CI, ix)) {
1484  *I = CI->getOperand(0);
1485  Changed = true;
1486  }
1487  }
1488  }
1489 
1490  if (isa<InlineAsm>(Callee) && !CS.doesNotThrow()) {
1491  // Inline asm calls cannot throw - mark them 'nounwind'.
1492  CS.setDoesNotThrow();
1493  Changed = true;
1494  }
1495 
1496  // Try to optimize the call if possible, we require DataLayout for most of
1497  // this. None of these calls are seen as possibly dead so go ahead and
1498  // delete the instruction now.
1499  if (CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) {
1500  Instruction *I = tryOptimizeCall(CI);
1501  // If we changed something return the result, etc. Otherwise let
1502  // the fallthrough check.
1503  if (I) return EraseInstFromFunction(*I);
1504  }
1505 
1506  return Changed ? CS.getInstruction() : nullptr;
1507 }
1508 
1509 // transformConstExprCastCall - If the callee is a constexpr cast of a function,
1510 // attempt to move the cast to the arguments of the call/invoke.
1511 //
1512 bool InstCombiner::transformConstExprCastCall(CallSite CS) {
1513  Function *Callee =
1515  if (!Callee)
1516  return false;
1517  // The prototype of thunks are a lie, don't try to directly call such
1518  // functions.
1519  if (Callee->hasFnAttribute("thunk"))
1520  return false;
1521  Instruction *Caller = CS.getInstruction();
1522  const AttributeSet &CallerPAL = CS.getAttributes();
1523 
1524  // Okay, this is a cast from a function to a different type. Unless doing so
1525  // would cause a type conversion of one of our arguments, change this call to
1526  // be a direct call with arguments casted to the appropriate types.
1527  //
1528  FunctionType *FT = Callee->getFunctionType();
1529  Type *OldRetTy = Caller->getType();
1530  Type *NewRetTy = FT->getReturnType();
1531 
1532  // Check to see if we are changing the return type...
1533  if (OldRetTy != NewRetTy) {
1534 
1535  if (NewRetTy->isStructTy())
1536  return false; // TODO: Handle multiple return values.
1537 
1538  if (!CastInst::isBitOrNoopPointerCastable(NewRetTy, OldRetTy, DL)) {
1539  if (Callee->isDeclaration())
1540  return false; // Cannot transform this return value.
1541 
1542  if (!Caller->use_empty() &&
1543  // void -> non-void is handled specially
1544  !NewRetTy->isVoidTy())
1545  return false; // Cannot transform this return value.
1546  }
1547 
1548  if (!CallerPAL.isEmpty() && !Caller->use_empty()) {
1549  AttrBuilder RAttrs(CallerPAL, AttributeSet::ReturnIndex);
1550  if (RAttrs.overlaps(AttributeFuncs::typeIncompatible(NewRetTy)))
1551  return false; // Attribute not compatible with transformed value.
1552  }
1553 
1554  // If the callsite is an invoke instruction, and the return value is used by
1555  // a PHI node in a successor, we cannot change the return type of the call
1556  // because there is no place to put the cast instruction (without breaking
1557  // the critical edge). Bail out in this case.
1558  if (!Caller->use_empty())
1559  if (InvokeInst *II = dyn_cast<InvokeInst>(Caller))
1560  for (User *U : II->users())
1561  if (PHINode *PN = dyn_cast<PHINode>(U))
1562  if (PN->getParent() == II->getNormalDest() ||
1563  PN->getParent() == II->getUnwindDest())
1564  return false;
1565  }
1566 
1567  unsigned NumActualArgs = CS.arg_size();
1568  unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs);
1569 
1570  // Prevent us turning:
1571  // declare void @takes_i32_inalloca(i32* inalloca)
1572  // call void bitcast (void (i32*)* @takes_i32_inalloca to void (i32)*)(i32 0)
1573  //
1574  // into:
1575  // call void @takes_i32_inalloca(i32* null)
1576  //
1577  // Similarly, avoid folding away bitcasts of byval calls.
1580  return false;
1581 
1583  for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) {
1584  Type *ParamTy = FT->getParamType(i);
1585  Type *ActTy = (*AI)->getType();
1586 
1587  if (!CastInst::isBitOrNoopPointerCastable(ActTy, ParamTy, DL))
1588  return false; // Cannot transform this parameter value.
1589 
1590  if (AttrBuilder(CallerPAL.getParamAttributes(i + 1), i + 1).
1591  overlaps(AttributeFuncs::typeIncompatible(ParamTy)))
1592  return false; // Attribute not compatible with transformed value.
1593 
1594  if (CS.isInAllocaArgument(i))
1595  return false; // Cannot transform to and from inalloca.
1596 
1597  // If the parameter is passed as a byval argument, then we have to have a
1598  // sized type and the sized type has to have the same size as the old type.
1599  if (ParamTy != ActTy &&
1600  CallerPAL.getParamAttributes(i + 1).hasAttribute(i + 1,
1601  Attribute::ByVal)) {
1602  PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
1603  if (!ParamPTy || !ParamPTy->getElementType()->isSized())
1604  return false;
1605 
1606  Type *CurElTy = ActTy->getPointerElementType();
1607  if (DL.getTypeAllocSize(CurElTy) !=
1608  DL.getTypeAllocSize(ParamPTy->getElementType()))
1609  return false;
1610  }
1611  }
1612 
1613  if (Callee->isDeclaration()) {
1614  // Do not delete arguments unless we have a function body.
1615  if (FT->getNumParams() < NumActualArgs && !FT->isVarArg())
1616  return false;
1617 
1618  // If the callee is just a declaration, don't change the varargsness of the
1619  // call. We don't want to introduce a varargs call where one doesn't
1620  // already exist.
1621  PointerType *APTy = cast<PointerType>(CS.getCalledValue()->getType());
1622  if (FT->isVarArg()!=cast<FunctionType>(APTy->getElementType())->isVarArg())
1623  return false;
1624 
1625  // If both the callee and the cast type are varargs, we still have to make
1626  // sure the number of fixed parameters are the same or we have the same
1627  // ABI issues as if we introduce a varargs call.
1628  if (FT->isVarArg() &&
1629  cast<FunctionType>(APTy->getElementType())->isVarArg() &&
1630  FT->getNumParams() !=
1631  cast<FunctionType>(APTy->getElementType())->getNumParams())
1632  return false;
1633  }
1634 
1635  if (FT->getNumParams() < NumActualArgs && FT->isVarArg() &&
1636  !CallerPAL.isEmpty())
1637  // In this case we have more arguments than the new function type, but we
1638  // won't be dropping them. Check that these extra arguments have attributes
1639  // that are compatible with being a vararg call argument.
1640  for (unsigned i = CallerPAL.getNumSlots(); i; --i) {
1641  unsigned Index = CallerPAL.getSlotIndex(i - 1);
1642  if (Index <= FT->getNumParams())
1643  break;
1644 
1645  // Check if it has an attribute that's incompatible with varargs.
1646  AttributeSet PAttrs = CallerPAL.getSlotAttributes(i - 1);
1647  if (PAttrs.hasAttribute(Index, Attribute::StructRet))
1648  return false;
1649  }
1650 
1651 
1652  // Okay, we decided that this is a safe thing to do: go ahead and start
1653  // inserting cast instructions as necessary.
1654  std::vector<Value*> Args;
1655  Args.reserve(NumActualArgs);
1657  attrVec.reserve(NumCommonArgs);
1658 
1659  // Get any return attributes.
1660  AttrBuilder RAttrs(CallerPAL, AttributeSet::ReturnIndex);
1661 
1662  // If the return value is not being used, the type may not be compatible
1663  // with the existing attributes. Wipe out any problematic attributes.
1664  RAttrs.remove(AttributeFuncs::typeIncompatible(NewRetTy));
1665 
1666  // Add the new return attributes.
1667  if (RAttrs.hasAttributes())
1668  attrVec.push_back(AttributeSet::get(Caller->getContext(),
1669  AttributeSet::ReturnIndex, RAttrs));
1670 
1671  AI = CS.arg_begin();
1672  for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) {
1673  Type *ParamTy = FT->getParamType(i);
1674 
1675  if ((*AI)->getType() == ParamTy) {
1676  Args.push_back(*AI);
1677  } else {
1678  Args.push_back(Builder->CreateBitOrPointerCast(*AI, ParamTy));
1679  }
1680 
1681  // Add any parameter attributes.
1682  AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1);
1683  if (PAttrs.hasAttributes())
1684  attrVec.push_back(AttributeSet::get(Caller->getContext(), i + 1,
1685  PAttrs));
1686  }
1687 
1688  // If the function takes more arguments than the call was taking, add them
1689  // now.
1690  for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i)
1691  Args.push_back(Constant::getNullValue(FT->getParamType(i)));
1692 
1693  // If we are removing arguments to the function, emit an obnoxious warning.
1694  if (FT->getNumParams() < NumActualArgs) {
1695  // TODO: if (!FT->isVarArg()) this call may be unreachable. PR14722
1696  if (FT->isVarArg()) {
1697  // Add all of the arguments in their promoted form to the arg list.
1698  for (unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) {
1699  Type *PTy = getPromotedType((*AI)->getType());
1700  if (PTy != (*AI)->getType()) {
1701  // Must promote to pass through va_arg area!
1702  Instruction::CastOps opcode =
1703  CastInst::getCastOpcode(*AI, false, PTy, false);
1704  Args.push_back(Builder->CreateCast(opcode, *AI, PTy));
1705  } else {
1706  Args.push_back(*AI);
1707  }
1708 
1709  // Add any parameter attributes.
1710  AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1);
1711  if (PAttrs.hasAttributes())
1712  attrVec.push_back(AttributeSet::get(FT->getContext(), i + 1,
1713  PAttrs));
1714  }
1715  }
1716  }
1717 
1718  AttributeSet FnAttrs = CallerPAL.getFnAttributes();
1720  attrVec.push_back(AttributeSet::get(Callee->getContext(), FnAttrs));
1721 
1722  if (NewRetTy->isVoidTy())
1723  Caller->setName(""); // Void type should not have a name.
1724 
1725  const AttributeSet &NewCallerPAL = AttributeSet::get(Callee->getContext(),
1726  attrVec);
1727 
1728  Instruction *NC;
1729  if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
1730  NC = Builder->CreateInvoke(Callee, II->getNormalDest(),
1731  II->getUnwindDest(), Args);
1732  NC->takeName(II);
1733  cast<InvokeInst>(NC)->setCallingConv(II->getCallingConv());
1734  cast<InvokeInst>(NC)->setAttributes(NewCallerPAL);
1735  } else {
1736  CallInst *CI = cast<CallInst>(Caller);
1737  NC = Builder->CreateCall(Callee, Args);
1738  NC->takeName(CI);
1739  if (CI->isTailCall())
1740  cast<CallInst>(NC)->setTailCall();
1741  cast<CallInst>(NC)->setCallingConv(CI->getCallingConv());
1742  cast<CallInst>(NC)->setAttributes(NewCallerPAL);
1743  }
1744 
1745  // Insert a cast of the return type as necessary.
1746  Value *NV = NC;
1747  if (OldRetTy != NV->getType() && !Caller->use_empty()) {
1748  if (!NV->getType()->isVoidTy()) {
1749  NV = NC = CastInst::CreateBitOrPointerCast(NC, OldRetTy);
1750  NC->setDebugLoc(Caller->getDebugLoc());
1751 
1752  // If this is an invoke instruction, we should insert it after the first
1753  // non-phi, instruction in the normal successor block.
1754  if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
1755  BasicBlock::iterator I = II->getNormalDest()->getFirstInsertionPt();
1756  InsertNewInstBefore(NC, *I);
1757  } else {
1758  // Otherwise, it's a call, just insert cast right after the call.
1759  InsertNewInstBefore(NC, *Caller);
1760  }
1761  Worklist.AddUsersToWorkList(*Caller);
1762  } else {
1763  NV = UndefValue::get(Caller->getType());
1764  }
1765  }
1766 
1767  if (!Caller->use_empty())
1768  ReplaceInstUsesWith(*Caller, NV);
1769  else if (Caller->hasValueHandle()) {
1770  if (OldRetTy == NV->getType())
1771  ValueHandleBase::ValueIsRAUWd(Caller, NV);
1772  else
1773  // We cannot call ValueIsRAUWd with a different type, and the
1774  // actual tracked value will disappear.
1776  }
1777 
1778  EraseInstFromFunction(*Caller);
1779  return true;
1780 }
1781 
1782 // transformCallThroughTrampoline - Turn a call to a function created by
1783 // init_trampoline / adjust_trampoline intrinsic pair into a direct call to the
1784 // underlying function.
1785 //
1786 Instruction *
1787 InstCombiner::transformCallThroughTrampoline(CallSite CS,
1788  IntrinsicInst *Tramp) {
1789  Value *Callee = CS.getCalledValue();
1790  PointerType *PTy = cast<PointerType>(Callee->getType());
1791  FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
1792  const AttributeSet &Attrs = CS.getAttributes();
1793 
1794  // If the call already has the 'nest' attribute somewhere then give up -
1795  // otherwise 'nest' would occur twice after splicing in the chain.
1796  if (Attrs.hasAttrSomewhere(Attribute::Nest))
1797  return nullptr;
1798 
1799  assert(Tramp &&
1800  "transformCallThroughTrampoline called with incorrect CallSite.");
1801 
1802  Function *NestF =cast<Function>(Tramp->getArgOperand(1)->stripPointerCasts());
1803  PointerType *NestFPTy = cast<PointerType>(NestF->getType());
1804  FunctionType *NestFTy = cast<FunctionType>(NestFPTy->getElementType());
1805 
1806  const AttributeSet &NestAttrs = NestF->getAttributes();
1807  if (!NestAttrs.isEmpty()) {
1808  unsigned NestIdx = 1;
1809  Type *NestTy = nullptr;
1810  AttributeSet NestAttr;
1811 
1812  // Look for a parameter marked with the 'nest' attribute.
1813  for (FunctionType::param_iterator I = NestFTy->param_begin(),
1814  E = NestFTy->param_end(); I != E; ++NestIdx, ++I)
1815  if (NestAttrs.hasAttribute(NestIdx, Attribute::Nest)) {
1816  // Record the parameter type and any other attributes.
1817  NestTy = *I;
1818  NestAttr = NestAttrs.getParamAttributes(NestIdx);
1819  break;
1820  }
1821 
1822  if (NestTy) {
1823  Instruction *Caller = CS.getInstruction();
1824  std::vector<Value*> NewArgs;
1825  NewArgs.reserve(CS.arg_size() + 1);
1826 
1828  NewAttrs.reserve(Attrs.getNumSlots() + 1);
1829 
1830  // Insert the nest argument into the call argument list, which may
1831  // mean appending it. Likewise for attributes.
1832 
1833  // Add any result attributes.
1834  if (Attrs.hasAttributes(AttributeSet::ReturnIndex))
1835  NewAttrs.push_back(AttributeSet::get(Caller->getContext(),
1836  Attrs.getRetAttributes()));
1837 
1838  {
1839  unsigned Idx = 1;
1840  CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
1841  do {
1842  if (Idx == NestIdx) {
1843  // Add the chain argument and attributes.
1844  Value *NestVal = Tramp->getArgOperand(2);
1845  if (NestVal->getType() != NestTy)
1846  NestVal = Builder->CreateBitCast(NestVal, NestTy, "nest");
1847  NewArgs.push_back(NestVal);
1848  NewAttrs.push_back(AttributeSet::get(Caller->getContext(),
1849  NestAttr));
1850  }
1851 
1852  if (I == E)
1853  break;
1854 
1855  // Add the original argument and attributes.
1856  NewArgs.push_back(*I);
1857  AttributeSet Attr = Attrs.getParamAttributes(Idx);
1858  if (Attr.hasAttributes(Idx)) {
1859  AttrBuilder B(Attr, Idx);
1860  NewAttrs.push_back(AttributeSet::get(Caller->getContext(),
1861  Idx + (Idx >= NestIdx), B));
1862  }
1863 
1864  ++Idx, ++I;
1865  } while (1);
1866  }
1867 
1868  // Add any function attributes.
1869  if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
1870  NewAttrs.push_back(AttributeSet::get(FTy->getContext(),
1871  Attrs.getFnAttributes()));
1872 
1873  // The trampoline may have been bitcast to a bogus type (FTy).
1874  // Handle this by synthesizing a new function type, equal to FTy
1875  // with the chain parameter inserted.
1876 
1877  std::vector<Type*> NewTypes;
1878  NewTypes.reserve(FTy->getNumParams()+1);
1879 
1880  // Insert the chain's type into the list of parameter types, which may
1881  // mean appending it.
1882  {
1883  unsigned Idx = 1;
1884  FunctionType::param_iterator I = FTy->param_begin(),
1885  E = FTy->param_end();
1886 
1887  do {
1888  if (Idx == NestIdx)
1889  // Add the chain's type.
1890  NewTypes.push_back(NestTy);
1891 
1892  if (I == E)
1893  break;
1894 
1895  // Add the original type.
1896  NewTypes.push_back(*I);
1897 
1898  ++Idx, ++I;
1899  } while (1);
1900  }
1901 
1902  // Replace the trampoline call with a direct call. Let the generic
1903  // code sort out any function type mismatches.
1904  FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes,
1905  FTy->isVarArg());
1906  Constant *NewCallee =
1907  NestF->getType() == PointerType::getUnqual(NewFTy) ?
1908  NestF : ConstantExpr::getBitCast(NestF,
1909  PointerType::getUnqual(NewFTy));
1910  const AttributeSet &NewPAL =
1911  AttributeSet::get(FTy->getContext(), NewAttrs);
1912 
1913  Instruction *NewCaller;
1914  if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
1915  NewCaller = InvokeInst::Create(NewCallee,
1916  II->getNormalDest(), II->getUnwindDest(),
1917  NewArgs);
1918  cast<InvokeInst>(NewCaller)->setCallingConv(II->getCallingConv());
1919  cast<InvokeInst>(NewCaller)->setAttributes(NewPAL);
1920  } else {
1921  NewCaller = CallInst::Create(NewCallee, NewArgs);
1922  if (cast<CallInst>(Caller)->isTailCall())
1923  cast<CallInst>(NewCaller)->setTailCall();
1924  cast<CallInst>(NewCaller)->
1925  setCallingConv(cast<CallInst>(Caller)->getCallingConv());
1926  cast<CallInst>(NewCaller)->setAttributes(NewPAL);
1927  }
1928 
1929  return NewCaller;
1930  }
1931  }
1932 
1933  // Replace the trampoline call with a direct call. Since there is no 'nest'
1934  // parameter, there is no need to adjust the argument list. Let the generic
1935  // code sort out any function type mismatches.
1936  Constant *NewCallee =
1937  NestF->getType() == PTy ? NestF :
1938  ConstantExpr::getBitCast(NestF, PTy);
1939  CS.setCalledFunction(NewCallee);
1940  return CS.getInstruction();
1941 }
const NoneType None
Definition: None.h:23
ConstantDataVector - A vector constant whose element type is a simple 1/2/4/8-byte integer or float/d...
Definition: Constants.h:742
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
Definition: PatternMatch.h:506
LibCallSimplifier - This class implements a collection of optimizations that replace well formed call...
opStatus divide(const APFloat &, roundingMode)
Definition: APFloat.cpp:1709
const Value * getCalledValue() const
getCalledValue - Get a pointer to the function that is invoked by this instruction.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMin(const Opnd0 &Op0, const Opnd1 &Op1)
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
void setDoesNotThrow()
IntegerType * getType() const
getType - Specialize the getType() method to always return an IntegerType, which reduces the amount o...
Definition: Constants.h:140
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:64
static void ValueIsDeleted(Value *V)
Definition: Value.cpp:637
Value * SimplifyCall(Value *V, User::op_iterator ArgBegin, User::op_iterator ArgEnd, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given a function and iterators over arguments, see if we can fold the result.
unsigned getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
getOrEnforceKnownAlignment - If the specified pointer has an alignment that we can determine...
Definition: Local.cpp:927
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:223
LLVM Argument representation.
Definition: Argument.h:35
STATISTIC(NumFunctions,"Total number of functions")
AttributeSet getParamAttributes(unsigned Index) const
The attributes for the specified index are returned.
Definition: Attributes.cpp:930
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
unsigned getNumParams() const
getNumParams - Return the number of fixed parameters this function type requires. ...
Definition: DerivedTypes.h:136
Instruction * visitCallInst(CallInst &CI)
visitCallInst - CallInst simplification.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMax(const Opnd0 &Op0, const Opnd1 &Op1)
static CastInst * CreateBitOrPointerCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=0)
Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
InstrTy * getInstruction() const
Definition: CallSite.h:82
Intrinsic::ID getIntrinsicID() const
getIntrinsicID - Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:44
Nested function static chain.
Definition: Attributes.h:82
static ConstantAggregateZero * get(Type *Ty)
Definition: Constants.cpp:1377
Type::subtype_iterator param_iterator
Definition: DerivedTypes.h:123
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, const TargetLibraryInfo *TLI, bool RoundToAlign=false)
Compute the size of the object pointed by Ptr.
CallInst - This class represents a function call, abstracting a target machine's calling convention...
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Get a value with low bits set.
Definition: APInt.h:531
void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
static PointerType * get(Type *ElementType, unsigned AddressSpace)
PointerType::get - This constructs a pointer to an object of the specified type in a numbered address...
Definition: Type.cpp:738
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
opStatus
IEEE-754R 7: Default exception handling.
Definition: APFloat.h:166
MemSetInst - This class wraps the llvm.memset intrinsic.
void setAttributes(const AttributeSet &PAL)
Definition: CallSite.h:232
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr)
Return true if it is valid to use the assumptions provided by an assume intrinsic, I, at the point in the control-flow identified by the context instruction, CxtI.
Metadata node.
Definition: Metadata.h:740
F(f)
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:61
User::op_iterator arg_iterator
arg_iterator - The type of iterator to use when looping over actual arguments at this call site...
Definition: CallSite.h:147
static OverflowCheckFlavor IntrinsicIDToOverflowCheckFlavor(unsigned ID)
Returns the OverflowCheckFlavor corresponding to a overflow_with_op intrinsic.
void reserve(size_type N)
Definition: SmallVector.h:401
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Definition: Attributes.cpp:956
Value * CreateShuffleVector(Value *V1, Value *V2, Value *Mask, const Twine &Name="")
Definition: IRBuilder.h:1522
bool isByValOrInAllocaArgument(unsigned ArgNo) const
Determine whether this argument is passed by value or in an alloca.
Definition: CallSite.h:337
Type * getPointerElementType() const
Definition: Type.h:366
const CallInst * isFreeCall(const Value *I, const TargetLibraryInfo *TLI)
isFreeCall - Returns non-null if the value is a call to the builtin free()
static Constant * getNullValue(Type *Ty)
Definition: Constants.cpp:178
static bool isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy, const DataLayout &DL)
Check whether a bitcast, inttoptr, or ptrtoint cast between these types is valid and a no-op...
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
bool isSingleValueType() const
isSingleValueType - Return true if the type is a valid type for a register in codegen.
Definition: Type.h:250
IterTy arg_end() const
Definition: CallSite.h:157
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
Instruction * visitInvokeInst(InvokeInst &II)
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1674
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:316
OverflowCheckFlavor
Specific patterns of overflow check idioms that we match.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
static CallInst * Create(Value *Func, ArrayRef< Value * > Args, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::ZeroOrMore, cl::values(clEnumValN(DefaultIT,"arm-default-it","Generate IT block based on arch"), clEnumValN(RestrictedIT,"arm-restrict-it","Disallow deprecated IT based on ARMv8"), clEnumValN(NoRestrictedIT,"arm-no-restrict-it","Allow IT blocks based on ARMv7"), clEnumValEnd))
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:389
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:308
MemMoveInst - This class wraps the llvm.memmove intrinsic.
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
bool isDereferenceablePointer(const Value *V, const DataLayout &DL, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
isDereferenceablePointer - Return true if this is always a dereferenceable pointer.
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
Definition: PatternMatch.h:801
static Constant * get(ArrayRef< Constant * > V)
Definition: Constants.cpp:1057
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:517
static bool isSafeToEliminateVarargsCast(const CallSite CS, const DataLayout &DL, const CastInst *const CI, const int ix)
isSafeToEliminateVarargsCast - If this cast does not affect the value passed through the varargs area...
bool doesNotThrow() const
Determine if the call cannot unwind.
Definition: CallSite.h:311
bool isSized(SmallPtrSetImpl< const Type * > *Visited=nullptr) const
isSized - Return true if it makes sense to take the size of this type.
Definition: Type.h:268
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:250
Hidden pointer to structure to return.
Definition: Attributes.h:114
not_match< LHS > m_Not(const LHS &L)
Definition: PatternMatch.h:854
static IntrinsicInst * FindInitTrampolineFromBB(IntrinsicInst *AdjustTramp, Value *TrampMem)
bool doesNotThrow() const
Determine if the call cannot unwind.
ConstantAggregateZero - All zero aggregate value.
Definition: Constants.h:307
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:117
bool isStatepoint(const ImmutableCallSite &CS)
Definition: Statepoint.cpp:22
iterator_range< IterTy > args() const
Definition: CallSite.h:158
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
static IntrinsicInst * FindInitTrampoline(Value *Callee)
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
LLVMContext & getContext() const
getContext - Return the LLVMContext in which this type was uniqued.
Definition: Type.h:125
ValTy * getCalledValue() const
getCalledValue - Return the pointer to function that is being called.
Definition: CallSite.h:91
#define T
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
Definition: Constants.h:219
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
FunctionType::get - This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:361
Pass structure by value.
Definition: Attributes.h:73
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:866
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
static void ValueIsRAUWd(Value *Old, Value *New)
Definition: Value.cpp:694
unsigned getNumElements() const
Return the number of elements in the Vector type.
Definition: DerivedTypes.h:432
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:256
Type * getElementType() const
Definition: DerivedTypes.h:323
This class represents a truncation of integer types.
static unsigned getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
getKnownAlignment - Try to infer an alignment for the specified pointer.
Definition: Local.h:180
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Get a value with high bits set.
Definition: APInt.h:513
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1835
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
Definition: APFloat.h:122
unsigned getNumSlots() const
Return the number of slots used in this attribute list.
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:131
bool isLosslessCast() const
A lossless cast is one that does not alter the basic value.
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:35
static ConstantPointerNull * get(PointerType *T)
get() - Static factory methods - Return objects of the specified value
Definition: Constants.cpp:1455
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
Definition: PatternMatch.h:512
AttributeSet getSlotAttributes(unsigned Slot) const
Return the attributes at the given slot.
static Type * reduceToSingleValueType(Type *T)
reduceToSingleValueType - Given an aggregate type which ultimately holds a single scalar element...
This is an important base class in LLVM.
Definition: Constant.h:41
bool isGCRelocate(const Value *V)
Definition: Statepoint.cpp:50
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:233
const DebugLoc & getDebugLoc() const
getDebugLoc - Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:230
Pass structure in an alloca.
Definition: Attributes.h:74
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
This instruction compares its operands according to the predicate given to the constructor.
Value * getOperand(unsigned i) const
Definition: User.h:118
SI Fold Operands
Class to represent integer types.
Definition: DerivedTypes.h:37
bool hasValueHandle() const
Return true if there is a value handle associated with this value.
Definition: Value.h:389
Wraps a call to a gc.relocate and provides access to it's operands.
Definition: Statepoint.h:308
Constant * getAggregateElement(unsigned Elt) const
getAggregateElement - For aggregates (struct/array/vector) return the constant that corresponds to th...
Definition: Constants.cpp:250
void setAlignment(unsigned Align)
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
static UndefValue * get(Type *T)
get() - Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1473
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
void setMetadata(unsigned KindID, MDNode *Node)
setMetadata - Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1083
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE maxNum semantics.
Definition: APFloat.h:670
bool mayWriteToMemory() const
mayWriteToMemory - Return true if this instruction may modify memory.
Pointer is known to be not null.
Definition: Attributes.h:91
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:304
static InvokeInst * Create(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
static CastInst * CreateIntegerCast(Value *S, Type *Ty, bool isSigned, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a ZExt, BitCast, or Trunc for int -> int casts.
MemIntrinsic - This is the common base class for memset/memcpy/memmove.
static PointerType * getInt1PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:279
static PointerType * getUnqual(Type *ElementType)
PointerType::getUnqual - This constructs a pointer to an object of the specified type in the generic ...
Definition: DerivedTypes.h:460
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:388
bool paramHasAttr(unsigned i, Attribute::AttrKind A) const
Return true if the call or the callee has the given attribute.
Definition: CallSite.h:242
Value * getDest() const
getDest - This is just like getRawDest, but it strips off any cast instructions that feed it...
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
static IntrinsicInst * FindInitTrampolineFromAlloca(Value *TrampMem)
unsigned arg_size() const
Definition: CallSite.h:162
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:458
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:582
Function * getCalledFunction() const
getCalledFunction - Return the function called, or null if this is an indirect function invocation...
static Constant * get(Type *Ty, double V)
get() - This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in the specified type.
Definition: Constants.cpp:652
#define NC
Definition: regutils.h:42
bool isInAllocaArgument(unsigned ArgNo) const
Determine whether this argument is passed in an alloca.
Definition: CallSite.h:332
static Value * SimplifyX86vperm2(const IntrinsicInst &II, InstCombiner::BuilderTy &Builder)
The shuffle mask for a perm2*128 selects any two halves of two 256-bit source vectors, unless a zero bit is set.
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:530
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
AttributeSet getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:181
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
Class for arbitrary precision integers.
Definition: APInt.h:73
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
iterator_range< user_iterator > users()
Definition: Value.h:300
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
bool isKnownNonNull(const Value *V, const TargetLibraryInfo *TLI=nullptr)
isKnownNonNull - Return true if this pointer couldn't possibly be null by its definition.
static APInt getBitsSet(unsigned numBits, unsigned loBit, unsigned hiBit)
Get a value with a block of bits set.
Definition: APInt.h:498
static Value * SimplifyX86insertps(const IntrinsicInst &II, InstCombiner::BuilderTy &Builder)
bool isStructTy() const
isStructTy - True if this is an instance of StructType.
Definition: Type.h:209
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1030
bool isAllOnesValue() const
Determine if all bits are set.
Definition: APInt.h:337
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
uint64_t MinAlign(uint64_t A, uint64_t B)
MinAlign - A and B are either alignments or offsets.
Definition: MathExtras.h:552
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:185
void setCalledFunction(Value *Fn)
setCalledFunction - Set the function called.
MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics.
AttributeSet addAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Attr) const
Add an attribute to the attribute set at the given index.
Definition: Attributes.cpp:753
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:217
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:128
unsigned getSlotIndex(unsigned Slot) const
Return the index for the given slot.
bool hasAttrSomewhere(Attribute::AttrKind Attr) const
Return true if the specified attribute is set for at least one parameter or for the return value...
Definition: Attributes.cpp:973
OverflowResult
void setCalledFunction(Value *V)
setCalledFunction - Set the callee to the specified value.
Definition: CallSite.h:105
bool hasAttributes(unsigned Index) const
Return true if attribute exists at the given index.
Definition: Attributes.cpp:966
AttrBuilder typeIncompatible(const Type *Ty)
Which attributes cannot be applied to a type.
static Instruction::CastOps getCastOpcode(const Value *Val, bool SrcIsSigned, Type *Ty, bool DstIsSigned)
Returns the opcode necessary to cast Val into Ty using usual casting rules.
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - get or set the calling convention of the call.
Definition: CallSite.h:212
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
FunctionType * getFunctionType() const
Definition: Function.cpp:227
bool hasOneUse() const
Return true if there is exactly one user of this value.
Definition: Value.h:311
void setArgOperand(unsigned i, Value *v)
bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a library function that allocates memory (either malloc...
bool isTailCall() const
const AttributeSet & getAttributes() const
getAttributes/setAttributes - get or set the parameter attributes of the call.
Definition: CallSite.h:229
bool isVarArg() const
Definition: DerivedTypes.h:120
iterator_range< op_iterator > arg_operands()
arg_operands - iteration adapter for range-for loops.
bool use_empty() const
Definition: Value.h:275
Type * getReturnType() const
Definition: DerivedTypes.h:121
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
getPrimitiveSizeInBits - Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:121
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
void setAlignment(unsigned Align)
This file provides internal interfaces used to implement the InstCombine.
static VectorType * get(Type *ElementType, unsigned NumElements)
VectorType::get - This static method is the primary way to construct an VectorType.
Definition: Type.cpp:713
InvokeInst - Invoke instruction.
IterTy arg_begin() const
arg_begin/arg_end - Return iterators corresponding to the actual argument list for a call site...
Definition: CallSite.h:151
bool isPowerOf2_32(uint32_t Value)
isPowerOf2_32 - This function returns true if the argument is a power of two > 0. ...
Definition: MathExtras.h:354
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml","ocaml 3.10-compatible collector")
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2280
bool isGCResult(const Value *V)
Definition: Statepoint.cpp:67
static Constant * get(LLVMContext &Context, ArrayRef< uint8_t > Elts)
get() constructors - Return a constant with vector type with an element count and element type matchi...
Definition: Constants.cpp:2629
void setDoesNotThrow()
Definition: CallSite.h:314
This class represents an extension of floating point types.
bool isEmpty() const
Return true if there are no attributes.
Definition: Attributes.h:390
const fltSemantics & getSemantics() const
Definition: APFloat.h:435
static Type * getPromotedType(Type *Ty)
getPromotedType - Return the specified type promoted as it would be to pass though a va_arg area...
const BasicBlock * getParent() const
Definition: Instruction.h:72
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE minNum semantics.
Definition: APFloat.h:659
User * user_back()
Definition: Value.h:298
IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:37
bool isVoidTy() const
isVoidTy - Return true if this is 'void'.
Definition: Type.h:137
AttributeSet getFnAttributes() const
The function attributes are returned.
Definition: Attributes.cpp:947