LLVM  15.0.0git
InstCombineCalls.cpp
Go to the documentation of this file.
1 //===- InstCombineCalls.cpp -----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the visitCall, visitInvoke, and visitCallBr functions.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "InstCombineInternal.h"
14 #include "llvm/ADT/APFloat.h"
15 #include "llvm/ADT/APInt.h"
16 #include "llvm/ADT/APSInt.h"
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/None.h"
19 #include "llvm/ADT/Optional.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/Statistic.h"
28 #include "llvm/Analysis/Loads.h"
32 #include "llvm/IR/Attributes.h"
33 #include "llvm/IR/BasicBlock.h"
34 #include "llvm/IR/Constant.h"
35 #include "llvm/IR/Constants.h"
36 #include "llvm/IR/DataLayout.h"
37 #include "llvm/IR/DerivedTypes.h"
38 #include "llvm/IR/Function.h"
39 #include "llvm/IR/GlobalVariable.h"
40 #include "llvm/IR/InlineAsm.h"
41 #include "llvm/IR/InstrTypes.h"
42 #include "llvm/IR/Instruction.h"
43 #include "llvm/IR/Instructions.h"
44 #include "llvm/IR/IntrinsicInst.h"
45 #include "llvm/IR/Intrinsics.h"
46 #include "llvm/IR/IntrinsicsAArch64.h"
47 #include "llvm/IR/IntrinsicsAMDGPU.h"
48 #include "llvm/IR/IntrinsicsARM.h"
49 #include "llvm/IR/IntrinsicsHexagon.h"
50 #include "llvm/IR/LLVMContext.h"
51 #include "llvm/IR/Metadata.h"
52 #include "llvm/IR/PatternMatch.h"
53 #include "llvm/IR/Statepoint.h"
54 #include "llvm/IR/Type.h"
55 #include "llvm/IR/User.h"
56 #include "llvm/IR/Value.h"
57 #include "llvm/IR/ValueHandle.h"
59 #include "llvm/Support/Casting.h"
61 #include "llvm/Support/Compiler.h"
62 #include "llvm/Support/Debug.h"
64 #include "llvm/Support/KnownBits.h"
71 #include <algorithm>
72 #include <cassert>
73 #include <cstdint>
74 #include <utility>
75 #include <vector>
76 
77 #define DEBUG_TYPE "instcombine"
79 
80 using namespace llvm;
81 using namespace PatternMatch;
82 
83 STATISTIC(NumSimplified, "Number of library calls simplified");
84 
86  "instcombine-guard-widening-window",
87  cl::init(3),
88  cl::desc("How wide an instruction window to bypass looking for "
89  "another guard"));
90 
91 namespace llvm {
92 /// enable preservation of attributes in assume like:
93 /// call void @llvm.assume(i1 true) [ "nonnull"(i32* %PTR) ]
95 } // namespace llvm
96 
97 /// Return the specified type promoted as it would be to pass though a va_arg
98 /// area.
99 static Type *getPromotedType(Type *Ty) {
100  if (IntegerType* ITy = dyn_cast<IntegerType>(Ty)) {
101  if (ITy->getBitWidth() < 32)
102  return Type::getInt32Ty(Ty->getContext());
103  }
104  return Ty;
105 }
106 
107 /// Recognize a memcpy/memmove from a trivially otherwise unused alloca.
108 /// TODO: This should probably be integrated with visitAllocSites, but that
109 /// requires a deeper change to allow either unread or unwritten objects.
111  auto *Src = MI->getRawSource();
112  while (isa<GetElementPtrInst>(Src) || isa<BitCastInst>(Src)) {
113  if (!Src->hasOneUse())
114  return false;
115  Src = cast<Instruction>(Src)->getOperand(0);
116  }
117  return isa<AllocaInst>(Src) && Src->hasOneUse();
118 }
119 
121  Align DstAlign = getKnownAlignment(MI->getRawDest(), DL, MI, &AC, &DT);
122  MaybeAlign CopyDstAlign = MI->getDestAlign();
123  if (!CopyDstAlign || *CopyDstAlign < DstAlign) {
124  MI->setDestAlignment(DstAlign);
125  return MI;
126  }
127 
128  Align SrcAlign = getKnownAlignment(MI->getRawSource(), DL, MI, &AC, &DT);
129  MaybeAlign CopySrcAlign = MI->getSourceAlign();
130  if (!CopySrcAlign || *CopySrcAlign < SrcAlign) {
131  MI->setSourceAlignment(SrcAlign);
132  return MI;
133  }
134 
135  // If we have a store to a location which is known constant, we can conclude
136  // that the store must be storing the constant value (else the memory
137  // wouldn't be constant), and this must be a noop.
138  if (AA->pointsToConstantMemory(MI->getDest())) {
139  // Set the size of the copy to 0, it will be deleted on the next iteration.
140  MI->setLength(Constant::getNullValue(MI->getLength()->getType()));
141  return MI;
142  }
143 
144  // If the source is provably undef, the memcpy/memmove doesn't do anything
145  // (unless the transfer is volatile).
146  if (hasUndefSource(MI) && !MI->isVolatile()) {
147  // Set the size of the copy to 0, it will be deleted on the next iteration.
148  MI->setLength(Constant::getNullValue(MI->getLength()->getType()));
149  return MI;
150  }
151 
152  // If MemCpyInst length is 1/2/4/8 bytes then replace memcpy with
153  // load/store.
154  ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getLength());
155  if (!MemOpLength) return nullptr;
156 
157  // Source and destination pointer types are always "i8*" for intrinsic. See
158  // if the size is something we can handle with a single primitive load/store.
159  // A single load+store correctly handles overlapping memory in the memmove
160  // case.
161  uint64_t Size = MemOpLength->getLimitedValue();
162  assert(Size && "0-sized memory transferring should be removed already.");
163 
164  if (Size > 8 || (Size&(Size-1)))
165  return nullptr; // If not 1/2/4/8 bytes, exit.
166 
167  // If it is an atomic and alignment is less than the size then we will
168  // introduce the unaligned memory access which will be later transformed
169  // into libcall in CodeGen. This is not evident performance gain so disable
170  // it now.
171  if (isa<AtomicMemTransferInst>(MI))
172  if (*CopyDstAlign < Size || *CopySrcAlign < Size)
173  return nullptr;
174 
175  // Use an integer load+store unless we can find something better.
176  unsigned SrcAddrSp =
177  cast<PointerType>(MI->getArgOperand(1)->getType())->getAddressSpace();
178  unsigned DstAddrSp =
179  cast<PointerType>(MI->getArgOperand(0)->getType())->getAddressSpace();
180 
181  IntegerType* IntType = IntegerType::get(MI->getContext(), Size<<3);
182  Type *NewSrcPtrTy = PointerType::get(IntType, SrcAddrSp);
183  Type *NewDstPtrTy = PointerType::get(IntType, DstAddrSp);
184 
185  // If the memcpy has metadata describing the members, see if we can get the
186  // TBAA tag describing our copy.
187  MDNode *CopyMD = nullptr;
188  if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa)) {
189  CopyMD = M;
190  } else if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa_struct)) {
191  if (M->getNumOperands() == 3 && M->getOperand(0) &&
192  mdconst::hasa<ConstantInt>(M->getOperand(0)) &&
193  mdconst::extract<ConstantInt>(M->getOperand(0))->isZero() &&
194  M->getOperand(1) &&
195  mdconst::hasa<ConstantInt>(M->getOperand(1)) &&
196  mdconst::extract<ConstantInt>(M->getOperand(1))->getValue() ==
197  Size &&
198  M->getOperand(2) && isa<MDNode>(M->getOperand(2)))
199  CopyMD = cast<MDNode>(M->getOperand(2));
200  }
201 
202  Value *Src = Builder.CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy);
203  Value *Dest = Builder.CreateBitCast(MI->getArgOperand(0), NewDstPtrTy);
204  LoadInst *L = Builder.CreateLoad(IntType, Src);
205  // Alignment from the mem intrinsic will be better, so use it.
206  L->setAlignment(*CopySrcAlign);
207  if (CopyMD)
208  L->setMetadata(LLVMContext::MD_tbaa, CopyMD);
209  MDNode *LoopMemParallelMD =
210  MI->getMetadata(LLVMContext::MD_mem_parallel_loop_access);
211  if (LoopMemParallelMD)
212  L->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
213  MDNode *AccessGroupMD = MI->getMetadata(LLVMContext::MD_access_group);
214  if (AccessGroupMD)
215  L->setMetadata(LLVMContext::MD_access_group, AccessGroupMD);
216 
217  StoreInst *S = Builder.CreateStore(L, Dest);
218  // Alignment from the mem intrinsic will be better, so use it.
219  S->setAlignment(*CopyDstAlign);
220  if (CopyMD)
221  S->setMetadata(LLVMContext::MD_tbaa, CopyMD);
222  if (LoopMemParallelMD)
223  S->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
224  if (AccessGroupMD)
225  S->setMetadata(LLVMContext::MD_access_group, AccessGroupMD);
226 
227  if (auto *MT = dyn_cast<MemTransferInst>(MI)) {
228  // non-atomics can be volatile
229  L->setVolatile(MT->isVolatile());
230  S->setVolatile(MT->isVolatile());
231  }
232  if (isa<AtomicMemTransferInst>(MI)) {
233  // atomics have to be unordered
235  S->setOrdering(AtomicOrdering::Unordered);
236  }
237 
238  // Set the size of the copy to 0, it will be deleted on the next iteration.
239  MI->setLength(Constant::getNullValue(MemOpLength->getType()));
240  return MI;
241 }
242 
244  const Align KnownAlignment =
245  getKnownAlignment(MI->getDest(), DL, MI, &AC, &DT);
246  MaybeAlign MemSetAlign = MI->getDestAlign();
247  if (!MemSetAlign || *MemSetAlign < KnownAlignment) {
248  MI->setDestAlignment(KnownAlignment);
249  return MI;
250  }
251 
252  // If we have a store to a location which is known constant, we can conclude
253  // that the store must be storing the constant value (else the memory
254  // wouldn't be constant), and this must be a noop.
255  if (AA->pointsToConstantMemory(MI->getDest())) {
256  // Set the size of the copy to 0, it will be deleted on the next iteration.
257  MI->setLength(Constant::getNullValue(MI->getLength()->getType()));
258  return MI;
259  }
260 
261  // Remove memset with an undef value.
262  // FIXME: This is technically incorrect because it might overwrite a poison
263  // value. Change to PoisonValue once #52930 is resolved.
264  if (isa<UndefValue>(MI->getValue())) {
265  // Set the size of the copy to 0, it will be deleted on the next iteration.
266  MI->setLength(Constant::getNullValue(MI->getLength()->getType()));
267  return MI;
268  }
269 
270  // Extract the length and alignment and fill if they are constant.
271  ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength());
272  ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue());
273  if (!LenC || !FillC || !FillC->getType()->isIntegerTy(8))
274  return nullptr;
275  const uint64_t Len = LenC->getLimitedValue();
276  assert(Len && "0-sized memory setting should be removed already.");
277  const Align Alignment = assumeAligned(MI->getDestAlignment());
278 
279  // If it is an atomic and alignment is less than the size then we will
280  // introduce the unaligned memory access which will be later transformed
281  // into libcall in CodeGen. This is not evident performance gain so disable
282  // it now.
283  if (isa<AtomicMemSetInst>(MI))
284  if (Alignment < Len)
285  return nullptr;
286 
287  // memset(s,c,n) -> store s, c (for n=1,2,4,8)
288  if (Len <= 8 && isPowerOf2_32((uint32_t)Len)) {
289  Type *ITy = IntegerType::get(MI->getContext(), Len*8); // n=1 -> i8.
290 
291  Value *Dest = MI->getDest();
292  unsigned DstAddrSp = cast<PointerType>(Dest->getType())->getAddressSpace();
293  Type *NewDstPtrTy = PointerType::get(ITy, DstAddrSp);
294  Dest = Builder.CreateBitCast(Dest, NewDstPtrTy);
295 
296  // Extract the fill value and store.
297  uint64_t Fill = FillC->getZExtValue()*0x0101010101010101ULL;
298  StoreInst *S = Builder.CreateStore(ConstantInt::get(ITy, Fill), Dest,
299  MI->isVolatile());
300  S->setAlignment(Alignment);
301  if (isa<AtomicMemSetInst>(MI))
302  S->setOrdering(AtomicOrdering::Unordered);
303 
304  // Set the size of the copy to 0, it will be deleted on the next iteration.
305  MI->setLength(Constant::getNullValue(LenC->getType()));
306  return MI;
307  }
308 
309  return nullptr;
310 }
311 
312 // TODO, Obvious Missing Transforms:
313 // * Narrow width by halfs excluding zero/undef lanes
314 Value *InstCombinerImpl::simplifyMaskedLoad(IntrinsicInst &II) {
315  Value *LoadPtr = II.getArgOperand(0);
316  const Align Alignment =
317  cast<ConstantInt>(II.getArgOperand(1))->getAlignValue();
318 
319  // If the mask is all ones or undefs, this is a plain vector load of the 1st
320  // argument.
321  if (maskIsAllOneOrUndef(II.getArgOperand(2))) {
322  LoadInst *L = Builder.CreateAlignedLoad(II.getType(), LoadPtr, Alignment,
323  "unmaskedload");
324  L->copyMetadata(II);
325  return L;
326  }
327 
328  // If we can unconditionally load from this address, replace with a
329  // load/select idiom. TODO: use DT for context sensitive query
330  if (isDereferenceablePointer(LoadPtr, II.getType(),
331  II.getModule()->getDataLayout(), &II, nullptr)) {
332  LoadInst *LI = Builder.CreateAlignedLoad(II.getType(), LoadPtr, Alignment,
333  "unmaskedload");
334  LI->copyMetadata(II);
335  return Builder.CreateSelect(II.getArgOperand(2), LI, II.getArgOperand(3));
336  }
337 
338  return nullptr;
339 }
340 
341 // TODO, Obvious Missing Transforms:
342 // * Single constant active lane -> store
343 // * Narrow width by halfs excluding zero/undef lanes
344 Instruction *InstCombinerImpl::simplifyMaskedStore(IntrinsicInst &II) {
345  auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(3));
346  if (!ConstMask)
347  return nullptr;
348 
349  // If the mask is all zeros, this instruction does nothing.
350  if (ConstMask->isNullValue())
351  return eraseInstFromFunction(II);
352 
353  // If the mask is all ones, this is a plain vector store of the 1st argument.
354  if (ConstMask->isAllOnesValue()) {
355  Value *StorePtr = II.getArgOperand(1);
356  Align Alignment = cast<ConstantInt>(II.getArgOperand(2))->getAlignValue();
357  StoreInst *S =
358  new StoreInst(II.getArgOperand(0), StorePtr, false, Alignment);
359  S->copyMetadata(II);
360  return S;
361  }
362 
363  if (isa<ScalableVectorType>(ConstMask->getType()))
364  return nullptr;
365 
366  // Use masked off lanes to simplify operands via SimplifyDemandedVectorElts
367  APInt DemandedElts = possiblyDemandedEltsInMask(ConstMask);
368  APInt UndefElts(DemandedElts.getBitWidth(), 0);
369  if (Value *V =
370  SimplifyDemandedVectorElts(II.getOperand(0), DemandedElts, UndefElts))
371  return replaceOperand(II, 0, V);
372 
373  return nullptr;
374 }
375 
376 // TODO, Obvious Missing Transforms:
377 // * Single constant active lane load -> load
378 // * Dereferenceable address & few lanes -> scalarize speculative load/selects
379 // * Adjacent vector addresses -> masked.load
380 // * Narrow width by halfs excluding zero/undef lanes
381 // * Vector incrementing address -> vector masked load
382 Instruction *InstCombinerImpl::simplifyMaskedGather(IntrinsicInst &II) {
383  auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(2));
384  if (!ConstMask)
385  return nullptr;
386 
387  // Vector splat address w/known mask -> scalar load
388  // Fold the gather to load the source vector first lane
389  // because it is reloading the same value each time
390  if (ConstMask->isAllOnesValue())
391  if (auto *SplatPtr = getSplatValue(II.getArgOperand(0))) {
392  auto *VecTy = cast<VectorType>(II.getType());
393  const Align Alignment =
394  cast<ConstantInt>(II.getArgOperand(1))->getAlignValue();
395  LoadInst *L = Builder.CreateAlignedLoad(VecTy->getElementType(), SplatPtr,
396  Alignment, "load.scalar");
397  Value *Shuf =
398  Builder.CreateVectorSplat(VecTy->getElementCount(), L, "broadcast");
399  return replaceInstUsesWith(II, cast<Instruction>(Shuf));
400  }
401 
402  return nullptr;
403 }
404 
405 // TODO, Obvious Missing Transforms:
406 // * Single constant active lane -> store
407 // * Adjacent vector addresses -> masked.store
408 // * Narrow store width by halfs excluding zero/undef lanes
409 // * Vector incrementing address -> vector masked store
410 Instruction *InstCombinerImpl::simplifyMaskedScatter(IntrinsicInst &II) {
411  auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(3));
412  if (!ConstMask)
413  return nullptr;
414 
415  // If the mask is all zeros, a scatter does nothing.
416  if (ConstMask->isNullValue())
417  return eraseInstFromFunction(II);
418 
419  // Vector splat address -> scalar store
420  if (auto *SplatPtr = getSplatValue(II.getArgOperand(1))) {
421  // scatter(splat(value), splat(ptr), non-zero-mask) -> store value, ptr
422  if (auto *SplatValue = getSplatValue(II.getArgOperand(0))) {
423  Align Alignment = cast<ConstantInt>(II.getArgOperand(2))->getAlignValue();
424  StoreInst *S =
425  new StoreInst(SplatValue, SplatPtr, /*IsVolatile=*/false, Alignment);
426  S->copyMetadata(II);
427  return S;
428  }
429  // scatter(vector, splat(ptr), splat(true)) -> store extract(vector,
430  // lastlane), ptr
431  if (ConstMask->isAllOnesValue()) {
432  Align Alignment = cast<ConstantInt>(II.getArgOperand(2))->getAlignValue();
433  VectorType *WideLoadTy = cast<VectorType>(II.getArgOperand(1)->getType());
434  ElementCount VF = WideLoadTy->getElementCount();
435  Constant *EC =
436  ConstantInt::get(Builder.getInt32Ty(), VF.getKnownMinValue());
437  Value *RunTimeVF = VF.isScalable() ? Builder.CreateVScale(EC) : EC;
438  Value *LastLane = Builder.CreateSub(RunTimeVF, Builder.getInt32(1));
439  Value *Extract =
440  Builder.CreateExtractElement(II.getArgOperand(0), LastLane);
441  StoreInst *S =
442  new StoreInst(Extract, SplatPtr, /*IsVolatile=*/false, Alignment);
443  S->copyMetadata(II);
444  return S;
445  }
446  }
447  if (isa<ScalableVectorType>(ConstMask->getType()))
448  return nullptr;
449 
450  // Use masked off lanes to simplify operands via SimplifyDemandedVectorElts
451  APInt DemandedElts = possiblyDemandedEltsInMask(ConstMask);
452  APInt UndefElts(DemandedElts.getBitWidth(), 0);
453  if (Value *V =
454  SimplifyDemandedVectorElts(II.getOperand(0), DemandedElts, UndefElts))
455  return replaceOperand(II, 0, V);
456  if (Value *V =
457  SimplifyDemandedVectorElts(II.getOperand(1), DemandedElts, UndefElts))
458  return replaceOperand(II, 1, V);
459 
460  return nullptr;
461 }
462 
463 /// This function transforms launder.invariant.group and strip.invariant.group
464 /// like:
465 /// launder(launder(%x)) -> launder(%x) (the result is not the argument)
466 /// launder(strip(%x)) -> launder(%x)
467 /// strip(strip(%x)) -> strip(%x) (the result is not the argument)
468 /// strip(launder(%x)) -> strip(%x)
469 /// This is legal because it preserves the most recent information about
470 /// the presence or absence of invariant.group.
472  InstCombinerImpl &IC) {
473  auto *Arg = II.getArgOperand(0);
474  auto *StrippedArg = Arg->stripPointerCasts();
475  auto *StrippedInvariantGroupsArg = StrippedArg;
476  while (auto *Intr = dyn_cast<IntrinsicInst>(StrippedInvariantGroupsArg)) {
477  if (Intr->getIntrinsicID() != Intrinsic::launder_invariant_group &&
478  Intr->getIntrinsicID() != Intrinsic::strip_invariant_group)
479  break;
480  StrippedInvariantGroupsArg = Intr->getArgOperand(0)->stripPointerCasts();
481  }
482  if (StrippedArg == StrippedInvariantGroupsArg)
483  return nullptr; // No launders/strips to remove.
484 
485  Value *Result = nullptr;
486 
487  if (II.getIntrinsicID() == Intrinsic::launder_invariant_group)
488  Result = IC.Builder.CreateLaunderInvariantGroup(StrippedInvariantGroupsArg);
489  else if (II.getIntrinsicID() == Intrinsic::strip_invariant_group)
490  Result = IC.Builder.CreateStripInvariantGroup(StrippedInvariantGroupsArg);
491  else
493  "simplifyInvariantGroupIntrinsic only handles launder and strip");
494  if (Result->getType()->getPointerAddressSpace() !=
496  Result = IC.Builder.CreateAddrSpaceCast(Result, II.getType());
497  if (Result->getType() != II.getType())
498  Result = IC.Builder.CreateBitCast(Result, II.getType());
499 
500  return cast<Instruction>(Result);
501 }
502 
504  assert((II.getIntrinsicID() == Intrinsic::cttz ||
505  II.getIntrinsicID() == Intrinsic::ctlz) &&
506  "Expected cttz or ctlz intrinsic");
507  bool IsTZ = II.getIntrinsicID() == Intrinsic::cttz;
508  Value *Op0 = II.getArgOperand(0);
509  Value *Op1 = II.getArgOperand(1);
510  Value *X;
511  // ctlz(bitreverse(x)) -> cttz(x)
512  // cttz(bitreverse(x)) -> ctlz(x)
513  if (match(Op0, m_BitReverse(m_Value(X)))) {
514  Intrinsic::ID ID = IsTZ ? Intrinsic::ctlz : Intrinsic::cttz;
516  return CallInst::Create(F, {X, II.getArgOperand(1)});
517  }
518 
519  if (II.getType()->isIntOrIntVectorTy(1)) {
520  // ctlz/cttz i1 Op0 --> not Op0
521  if (match(Op1, m_Zero()))
522  return BinaryOperator::CreateNot(Op0);
523  // If zero is poison, then the input can be assumed to be "true", so the
524  // instruction simplifies to "false".
525  assert(match(Op1, m_One()) && "Expected ctlz/cttz operand to be 0 or 1");
527  }
528 
529  // If the operand is a select with constant arm(s), try to hoist ctlz/cttz.
530  if (auto *Sel = dyn_cast<SelectInst>(Op0))
531  if (Instruction *R = IC.FoldOpIntoSelect(II, Sel))
532  return R;
533 
534  if (IsTZ) {
535  // cttz(-x) -> cttz(x)
536  if (match(Op0, m_Neg(m_Value(X))))
537  return IC.replaceOperand(II, 0, X);
538 
539  // cttz(sext(x)) -> cttz(zext(x))
540  if (match(Op0, m_OneUse(m_SExt(m_Value(X))))) {
541  auto *Zext = IC.Builder.CreateZExt(X, II.getType());
542  auto *CttzZext =
543  IC.Builder.CreateBinaryIntrinsic(Intrinsic::cttz, Zext, Op1);
544  return IC.replaceInstUsesWith(II, CttzZext);
545  }
546 
547  // Zext doesn't change the number of trailing zeros, so narrow:
548  // cttz(zext(x)) -> zext(cttz(x)) if the 'ZeroIsPoison' parameter is 'true'.
549  if (match(Op0, m_OneUse(m_ZExt(m_Value(X)))) && match(Op1, m_One())) {
550  auto *Cttz = IC.Builder.CreateBinaryIntrinsic(Intrinsic::cttz, X,
551  IC.Builder.getTrue());
552  auto *ZextCttz = IC.Builder.CreateZExt(Cttz, II.getType());
553  return IC.replaceInstUsesWith(II, ZextCttz);
554  }
555 
556  // cttz(abs(x)) -> cttz(x)
557  // cttz(nabs(x)) -> cttz(x)
558  Value *Y;
560  if (SPF == SPF_ABS || SPF == SPF_NABS)
561  return IC.replaceOperand(II, 0, X);
562 
563  if (match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(X))))
564  return IC.replaceOperand(II, 0, X);
565  }
566 
567  KnownBits Known = IC.computeKnownBits(Op0, 0, &II);
568 
569  // Create a mask for bits above (ctlz) or below (cttz) the first known one.
570  unsigned PossibleZeros = IsTZ ? Known.countMaxTrailingZeros()
571  : Known.countMaxLeadingZeros();
572  unsigned DefiniteZeros = IsTZ ? Known.countMinTrailingZeros()
573  : Known.countMinLeadingZeros();
574 
575  // If all bits above (ctlz) or below (cttz) the first known one are known
576  // zero, this value is constant.
577  // FIXME: This should be in InstSimplify because we're replacing an
578  // instruction with a constant.
579  if (PossibleZeros == DefiniteZeros) {
580  auto *C = ConstantInt::get(Op0->getType(), DefiniteZeros);
581  return IC.replaceInstUsesWith(II, C);
582  }
583 
584  // If the input to cttz/ctlz is known to be non-zero,
585  // then change the 'ZeroIsPoison' parameter to 'true'
586  // because we know the zero behavior can't affect the result.
587  if (!Known.One.isZero() ||
588  isKnownNonZero(Op0, IC.getDataLayout(), 0, &IC.getAssumptionCache(), &II,
589  &IC.getDominatorTree())) {
590  if (!match(II.getArgOperand(1), m_One()))
591  return IC.replaceOperand(II, 1, IC.Builder.getTrue());
592  }
593 
594  // Add range metadata since known bits can't completely reflect what we know.
595  // TODO: Handle splat vectors.
596  auto *IT = dyn_cast<IntegerType>(Op0->getType());
597  if (IT && IT->getBitWidth() != 1 && !II.getMetadata(LLVMContext::MD_range)) {
598  Metadata *LowAndHigh[] = {
600  ConstantAsMetadata::get(ConstantInt::get(IT, PossibleZeros + 1))};
601  II.setMetadata(LLVMContext::MD_range,
603  return &II;
604  }
605 
606  return nullptr;
607 }
608 
610  assert(II.getIntrinsicID() == Intrinsic::ctpop &&
611  "Expected ctpop intrinsic");
612  Type *Ty = II.getType();
613  unsigned BitWidth = Ty->getScalarSizeInBits();
614  Value *Op0 = II.getArgOperand(0);
615  Value *X, *Y;
616 
617  // ctpop(bitreverse(x)) -> ctpop(x)
618  // ctpop(bswap(x)) -> ctpop(x)
619  if (match(Op0, m_BitReverse(m_Value(X))) || match(Op0, m_BSwap(m_Value(X))))
620  return IC.replaceOperand(II, 0, X);
621 
622  // ctpop(rot(x)) -> ctpop(x)
623  if ((match(Op0, m_FShl(m_Value(X), m_Value(Y), m_Value())) ||
624  match(Op0, m_FShr(m_Value(X), m_Value(Y), m_Value()))) &&
625  X == Y)
626  return IC.replaceOperand(II, 0, X);
627 
628  // ctpop(x | -x) -> bitwidth - cttz(x, false)
629  if (Op0->hasOneUse() &&
630  match(Op0, m_c_Or(m_Value(X), m_Neg(m_Deferred(X))))) {
631  Function *F =
632  Intrinsic::getDeclaration(II.getModule(), Intrinsic::cttz, Ty);
633  auto *Cttz = IC.Builder.CreateCall(F, {X, IC.Builder.getFalse()});
634  auto *Bw = ConstantInt::get(Ty, APInt(BitWidth, BitWidth));
635  return IC.replaceInstUsesWith(II, IC.Builder.CreateSub(Bw, Cttz));
636  }
637 
638  // ctpop(~x & (x - 1)) -> cttz(x, false)
639  if (match(Op0,
641  Function *F =
642  Intrinsic::getDeclaration(II.getModule(), Intrinsic::cttz, Ty);
643  return CallInst::Create(F, {X, IC.Builder.getFalse()});
644  }
645 
646  // Zext doesn't change the number of set bits, so narrow:
647  // ctpop (zext X) --> zext (ctpop X)
648  if (match(Op0, m_OneUse(m_ZExt(m_Value(X))))) {
649  Value *NarrowPop = IC.Builder.CreateUnaryIntrinsic(Intrinsic::ctpop, X);
650  return CastInst::Create(Instruction::ZExt, NarrowPop, Ty);
651  }
652 
653  // If the operand is a select with constant arm(s), try to hoist ctpop.
654  if (auto *Sel = dyn_cast<SelectInst>(Op0))
655  if (Instruction *R = IC.FoldOpIntoSelect(II, Sel))
656  return R;
657 
658  KnownBits Known(BitWidth);
659  IC.computeKnownBits(Op0, Known, 0, &II);
660 
661  // If all bits are zero except for exactly one fixed bit, then the result
662  // must be 0 or 1, and we can get that answer by shifting to LSB:
663  // ctpop (X & 32) --> (X & 32) >> 5
664  if ((~Known.Zero).isPowerOf2())
665  return BinaryOperator::CreateLShr(
666  Op0, ConstantInt::get(Ty, (~Known.Zero).exactLogBase2()));
667 
668  // FIXME: Try to simplify vectors of integers.
669  auto *IT = dyn_cast<IntegerType>(Ty);
670  if (!IT)
671  return nullptr;
672 
673  // Add range metadata since known bits can't completely reflect what we know.
674  unsigned MinCount = Known.countMinPopulation();
675  unsigned MaxCount = Known.countMaxPopulation();
676  if (IT->getBitWidth() != 1 && !II.getMetadata(LLVMContext::MD_range)) {
677  Metadata *LowAndHigh[] = {
680  II.setMetadata(LLVMContext::MD_range,
682  return &II;
683  }
684 
685  return nullptr;
686 }
687 
688 /// Convert a table lookup to shufflevector if the mask is constant.
689 /// This could benefit tbl1 if the mask is { 7,6,5,4,3,2,1,0 }, in
690 /// which case we could lower the shufflevector with rev64 instructions
691 /// as it's actually a byte reverse.
694  // Bail out if the mask is not a constant.
695  auto *C = dyn_cast<Constant>(II.getArgOperand(1));
696  if (!C)
697  return nullptr;
698 
699  auto *VecTy = cast<FixedVectorType>(II.getType());
700  unsigned NumElts = VecTy->getNumElements();
701 
702  // Only perform this transformation for <8 x i8> vector types.
703  if (!VecTy->getElementType()->isIntegerTy(8) || NumElts != 8)
704  return nullptr;
705 
706  int Indexes[8];
707 
708  for (unsigned I = 0; I < NumElts; ++I) {
709  Constant *COp = C->getAggregateElement(I);
710 
711  if (!COp || !isa<ConstantInt>(COp))
712  return nullptr;
713 
714  Indexes[I] = cast<ConstantInt>(COp)->getLimitedValue();
715 
716  // Make sure the mask indices are in range.
717  if ((unsigned)Indexes[I] >= NumElts)
718  return nullptr;
719  }
720 
721  auto *V1 = II.getArgOperand(0);
722  auto *V2 = Constant::getNullValue(V1->getType());
723  return Builder.CreateShuffleVector(V1, V2, makeArrayRef(Indexes));
724 }
725 
726 // Returns true iff the 2 intrinsics have the same operands, limiting the
727 // comparison to the first NumOperands.
728 static bool haveSameOperands(const IntrinsicInst &I, const IntrinsicInst &E,
729  unsigned NumOperands) {
730  assert(I.arg_size() >= NumOperands && "Not enough operands");
731  assert(E.arg_size() >= NumOperands && "Not enough operands");
732  for (unsigned i = 0; i < NumOperands; i++)
733  if (I.getArgOperand(i) != E.getArgOperand(i))
734  return false;
735  return true;
736 }
737 
738 // Remove trivially empty start/end intrinsic ranges, i.e. a start
739 // immediately followed by an end (ignoring debuginfo or other
740 // start/end intrinsics in between). As this handles only the most trivial
741 // cases, tracking the nesting level is not needed:
742 //
743 // call @llvm.foo.start(i1 0)
744 // call @llvm.foo.start(i1 0) ; This one won't be skipped: it will be removed
745 // call @llvm.foo.end(i1 0)
746 // call @llvm.foo.end(i1 0) ; &I
747 static bool
749  std::function<bool(const IntrinsicInst &)> IsStart) {
750  // We start from the end intrinsic and scan backwards, so that InstCombine
751  // has already processed (and potentially removed) all the instructions
752  // before the end intrinsic.
753  BasicBlock::reverse_iterator BI(EndI), BE(EndI.getParent()->rend());
754  for (; BI != BE; ++BI) {
755  if (auto *I = dyn_cast<IntrinsicInst>(&*BI)) {
756  if (I->isDebugOrPseudoInst() ||
757  I->getIntrinsicID() == EndI.getIntrinsicID())
758  continue;
759  if (IsStart(*I)) {
760  if (haveSameOperands(EndI, *I, EndI.arg_size())) {
762  IC.eraseInstFromFunction(EndI);
763  return true;
764  }
765  // Skip start intrinsics that don't pair with this end intrinsic.
766  continue;
767  }
768  }
769  break;
770  }
771 
772  return false;
773 }
774 
776  removeTriviallyEmptyRange(I, *this, [](const IntrinsicInst &I) {
777  return I.getIntrinsicID() == Intrinsic::vastart ||
778  I.getIntrinsicID() == Intrinsic::vacopy;
779  });
780  return nullptr;
781 }
782 
784  assert(Call.arg_size() > 1 && "Need at least 2 args to swap");
785  Value *Arg0 = Call.getArgOperand(0), *Arg1 = Call.getArgOperand(1);
786  if (isa<Constant>(Arg0) && !isa<Constant>(Arg1)) {
787  Call.setArgOperand(0, Arg1);
788  Call.setArgOperand(1, Arg0);
789  return &Call;
790  }
791  return nullptr;
792 }
793 
794 /// Creates a result tuple for an overflow intrinsic \p II with a given
795 /// \p Result and a constant \p Overflow value.
797  Constant *Overflow) {
798  Constant *V[] = {UndefValue::get(Result->getType()), Overflow};
799  StructType *ST = cast<StructType>(II->getType());
800  Constant *Struct = ConstantStruct::get(ST, V);
801  return InsertValueInst::Create(Struct, Result, 0);
802 }
803 
804 Instruction *
805 InstCombinerImpl::foldIntrinsicWithOverflowCommon(IntrinsicInst *II) {
806  WithOverflowInst *WO = cast<WithOverflowInst>(II);
807  Value *OperationResult = nullptr;
808  Constant *OverflowResult = nullptr;
809  if (OptimizeOverflowCheck(WO->getBinaryOp(), WO->isSigned(), WO->getLHS(),
810  WO->getRHS(), *WO, OperationResult, OverflowResult))
811  return createOverflowTuple(WO, OperationResult, OverflowResult);
812  return nullptr;
813 }
814 
816  const DataLayout &DL, AssumptionCache *AC,
817  DominatorTree *DT) {
818  KnownBits Known = computeKnownBits(Op, DL, 0, AC, CxtI, DT);
819  if (Known.isNonNegative())
820  return false;
821  if (Known.isNegative())
822  return true;
823 
824  Value *X, *Y;
825  if (match(Op, m_NSWSub(m_Value(X), m_Value(Y))))
827 
829  ICmpInst::ICMP_SLT, Op, Constant::getNullValue(Op->getType()), CxtI, DL);
830 }
831 
832 /// Try to canonicalize min/max(X + C0, C1) as min/max(X, C1 - C0) + C0. This
833 /// can trigger other combines.
836  Intrinsic::ID MinMaxID = II->getIntrinsicID();
837  assert((MinMaxID == Intrinsic::smax || MinMaxID == Intrinsic::smin ||
838  MinMaxID == Intrinsic::umax || MinMaxID == Intrinsic::umin) &&
839  "Expected a min or max intrinsic");
840 
841  // TODO: Match vectors with undef elements, but undef may not propagate.
842  Value *Op0 = II->getArgOperand(0), *Op1 = II->getArgOperand(1);
843  Value *X;
844  const APInt *C0, *C1;
845  if (!match(Op0, m_OneUse(m_Add(m_Value(X), m_APInt(C0)))) ||
846  !match(Op1, m_APInt(C1)))
847  return nullptr;
848 
849  // Check for necessary no-wrap and overflow constraints.
850  bool IsSigned = MinMaxID == Intrinsic::smax || MinMaxID == Intrinsic::smin;
851  auto *Add = cast<BinaryOperator>(Op0);
852  if ((IsSigned && !Add->hasNoSignedWrap()) ||
853  (!IsSigned && !Add->hasNoUnsignedWrap()))
854  return nullptr;
855 
856  // If the constant difference overflows, then instsimplify should reduce the
857  // min/max to the add or C1.
858  bool Overflow;
859  APInt CDiff =
860  IsSigned ? C1->ssub_ov(*C0, Overflow) : C1->usub_ov(*C0, Overflow);
861  assert(!Overflow && "Expected simplify of min/max");
862 
863  // min/max (add X, C0), C1 --> add (min/max X, C1 - C0), C0
864  // Note: the "mismatched" no-overflow setting does not propagate.
865  Constant *NewMinMaxC = ConstantInt::get(II->getType(), CDiff);
866  Value *NewMinMax = Builder.CreateBinaryIntrinsic(MinMaxID, X, NewMinMaxC);
867  return IsSigned ? BinaryOperator::CreateNSWAdd(NewMinMax, Add->getOperand(1))
868  : BinaryOperator::CreateNUWAdd(NewMinMax, Add->getOperand(1));
869 }
870 /// Match a sadd_sat or ssub_sat which is using min/max to clamp the value.
871 Instruction *InstCombinerImpl::matchSAddSubSat(IntrinsicInst &MinMax1) {
872  Type *Ty = MinMax1.getType();
873 
874  // We are looking for a tree of:
875  // max(INT_MIN, min(INT_MAX, add(sext(A), sext(B))))
876  // Where the min and max could be reversed
877  Instruction *MinMax2;
879  const APInt *MinValue, *MaxValue;
880  if (match(&MinMax1, m_SMin(m_Instruction(MinMax2), m_APInt(MaxValue)))) {
881  if (!match(MinMax2, m_SMax(m_BinOp(AddSub), m_APInt(MinValue))))
882  return nullptr;
883  } else if (match(&MinMax1,
884  m_SMax(m_Instruction(MinMax2), m_APInt(MinValue)))) {
885  if (!match(MinMax2, m_SMin(m_BinOp(AddSub), m_APInt(MaxValue))))
886  return nullptr;
887  } else
888  return nullptr;
889 
890  // Check that the constants clamp a saturate, and that the new type would be
891  // sensible to convert to.
892  if (!(*MaxValue + 1).isPowerOf2() || -*MinValue != *MaxValue + 1)
893  return nullptr;
894  // In what bitwidth can this be treated as saturating arithmetics?
895  unsigned NewBitWidth = (*MaxValue + 1).logBase2() + 1;
896  // FIXME: This isn't quite right for vectors, but using the scalar type is a
897  // good first approximation for what should be done there.
898  if (!shouldChangeType(Ty->getScalarType()->getIntegerBitWidth(), NewBitWidth))
899  return nullptr;
900 
901  // Also make sure that the inner min/max and the add/sub have one use.
902  if (!MinMax2->hasOneUse() || !AddSub->hasOneUse())
903  return nullptr;
904 
905  // Create the new type (which can be a vector type)
906  Type *NewTy = Ty->getWithNewBitWidth(NewBitWidth);
907 
908  Intrinsic::ID IntrinsicID;
909  if (AddSub->getOpcode() == Instruction::Add)
910  IntrinsicID = Intrinsic::sadd_sat;
911  else if (AddSub->getOpcode() == Instruction::Sub)
912  IntrinsicID = Intrinsic::ssub_sat;
913  else
914  return nullptr;
915 
916  // The two operands of the add/sub must be nsw-truncatable to the NewTy. This
917  // is usually achieved via a sext from a smaller type.
918  if (ComputeMaxSignificantBits(AddSub->getOperand(0), 0, AddSub) >
919  NewBitWidth ||
920  ComputeMaxSignificantBits(AddSub->getOperand(1), 0, AddSub) > NewBitWidth)
921  return nullptr;
922 
923  // Finally create and return the sat intrinsic, truncated to the new type
924  Function *F = Intrinsic::getDeclaration(MinMax1.getModule(), IntrinsicID, NewTy);
925  Value *AT = Builder.CreateTrunc(AddSub->getOperand(0), NewTy);
926  Value *BT = Builder.CreateTrunc(AddSub->getOperand(1), NewTy);
927  Value *Sat = Builder.CreateCall(F, {AT, BT});
928  return CastInst::Create(Instruction::SExt, Sat, Ty);
929 }
930 
931 
932 /// If we have a clamp pattern like max (min X, 42), 41 -- where the output
933 /// can only be one of two possible constant values -- turn that into a select
934 /// of constants.
937  Value *I0 = II->getArgOperand(0), *I1 = II->getArgOperand(1);
938  Value *X;
939  const APInt *C0, *C1;
940  if (!match(I1, m_APInt(C1)) || !I0->hasOneUse())
941  return nullptr;
942 
944  switch (II->getIntrinsicID()) {
945  case Intrinsic::smax:
946  if (match(I0, m_SMin(m_Value(X), m_APInt(C0))) && *C0 == *C1 + 1)
947  Pred = ICmpInst::ICMP_SGT;
948  break;
949  case Intrinsic::smin:
950  if (match(I0, m_SMax(m_Value(X), m_APInt(C0))) && *C1 == *C0 + 1)
951  Pred = ICmpInst::ICMP_SLT;
952  break;
953  case Intrinsic::umax:
954  if (match(I0, m_UMin(m_Value(X), m_APInt(C0))) && *C0 == *C1 + 1)
955  Pred = ICmpInst::ICMP_UGT;
956  break;
957  case Intrinsic::umin:
958  if (match(I0, m_UMax(m_Value(X), m_APInt(C0))) && *C1 == *C0 + 1)
959  Pred = ICmpInst::ICMP_ULT;
960  break;
961  default:
962  llvm_unreachable("Expected min/max intrinsic");
963  }
964  if (Pred == CmpInst::BAD_ICMP_PREDICATE)
965  return nullptr;
966 
967  // max (min X, 42), 41 --> X > 41 ? 42 : 41
968  // min (max X, 42), 43 --> X < 43 ? 42 : 43
969  Value *Cmp = Builder.CreateICmp(Pred, X, I1);
970  return SelectInst::Create(Cmp, ConstantInt::get(II->getType(), *C0), I1);
971 }
972 
973 /// If this min/max has a constant operand and an operand that is a matching
974 /// min/max with a constant operand, constant-fold the 2 constant operands.
976  Intrinsic::ID MinMaxID = II->getIntrinsicID();
977  auto *LHS = dyn_cast<IntrinsicInst>(II->getArgOperand(0));
978  if (!LHS || LHS->getIntrinsicID() != MinMaxID)
979  return nullptr;
980 
981  Constant *C0, *C1;
982  if (!match(LHS->getArgOperand(1), m_ImmConstant(C0)) ||
983  !match(II->getArgOperand(1), m_ImmConstant(C1)))
984  return nullptr;
985 
986  // max (max X, C0), C1 --> max X, (max C0, C1) --> max X, NewC
988  Constant *CondC = ConstantExpr::getICmp(Pred, C0, C1);
989  Constant *NewC = ConstantExpr::getSelect(CondC, C0, C1);
990 
991  Module *Mod = II->getModule();
992  Function *MinMax = Intrinsic::getDeclaration(Mod, MinMaxID, II->getType());
993  return CallInst::Create(MinMax, {LHS->getArgOperand(0), NewC});
994 }
995 
996 /// If this min/max has a matching min/max operand with a constant, try to push
997 /// the constant operand into this instruction. This can enable more folds.
998 static Instruction *
1001  // Match and capture a min/max operand candidate.
1002  Value *X, *Y;
1003  Constant *C;
1004  Instruction *Inner;
1006  m_Instruction(Inner),
1008  m_Value(Y))))
1009  return nullptr;
1010 
1011  // The inner op must match. Check for constants to avoid infinite loops.
1012  Intrinsic::ID MinMaxID = II->getIntrinsicID();
1013  auto *InnerMM = dyn_cast<IntrinsicInst>(Inner);
1014  if (!InnerMM || InnerMM->getIntrinsicID() != MinMaxID ||
1016  return nullptr;
1017 
1018  // max (max X, C), Y --> max (max X, Y), C
1019  Function *MinMax =
1020  Intrinsic::getDeclaration(II->getModule(), MinMaxID, II->getType());
1021  Value *NewInner = Builder.CreateBinaryIntrinsic(MinMaxID, X, Y);
1022  NewInner->takeName(Inner);
1023  return CallInst::Create(MinMax, {NewInner, C});
1024 }
1025 
1026 /// Reduce a sequence of min/max intrinsics with a common operand.
1028  // Match 3 of the same min/max ops. Example: umin(umin(), umin()).
1029  auto *LHS = dyn_cast<IntrinsicInst>(II->getArgOperand(0));
1030  auto *RHS = dyn_cast<IntrinsicInst>(II->getArgOperand(1));
1031  Intrinsic::ID MinMaxID = II->getIntrinsicID();
1032  if (!LHS || !RHS || LHS->getIntrinsicID() != MinMaxID ||
1033  RHS->getIntrinsicID() != MinMaxID ||
1034  (!LHS->hasOneUse() && !RHS->hasOneUse()))
1035  return nullptr;
1036 
1037  Value *A = LHS->getArgOperand(0);
1038  Value *B = LHS->getArgOperand(1);
1039  Value *C = RHS->getArgOperand(0);
1040  Value *D = RHS->getArgOperand(1);
1041 
1042  // Look for a common operand.
1043  Value *MinMaxOp = nullptr;
1044  Value *ThirdOp = nullptr;
1045  if (LHS->hasOneUse()) {
1046  // If the LHS is only used in this chain and the RHS is used outside of it,
1047  // reuse the RHS min/max because that will eliminate the LHS.
1048  if (D == A || C == A) {
1049  // min(min(a, b), min(c, a)) --> min(min(c, a), b)
1050  // min(min(a, b), min(a, d)) --> min(min(a, d), b)
1051  MinMaxOp = RHS;
1052  ThirdOp = B;
1053  } else if (D == B || C == B) {
1054  // min(min(a, b), min(c, b)) --> min(min(c, b), a)
1055  // min(min(a, b), min(b, d)) --> min(min(b, d), a)
1056  MinMaxOp = RHS;
1057  ThirdOp = A;
1058  }
1059  } else {
1060  assert(RHS->hasOneUse() && "Expected one-use operand");
1061  // Reuse the LHS. This will eliminate the RHS.
1062  if (D == A || D == B) {
1063  // min(min(a, b), min(c, a)) --> min(min(a, b), c)
1064  // min(min(a, b), min(c, b)) --> min(min(a, b), c)
1065  MinMaxOp = LHS;
1066  ThirdOp = C;
1067  } else if (C == A || C == B) {
1068  // min(min(a, b), min(b, d)) --> min(min(a, b), d)
1069  // min(min(a, b), min(c, b)) --> min(min(a, b), d)
1070  MinMaxOp = LHS;
1071  ThirdOp = D;
1072  }
1073  }
1074 
1075  if (!MinMaxOp || !ThirdOp)
1076  return nullptr;
1077 
1078  Module *Mod = II->getModule();
1079  Function *MinMax = Intrinsic::getDeclaration(Mod, MinMaxID, II->getType());
1080  return CallInst::Create(MinMax, { MinMaxOp, ThirdOp });
1081 }
1082 
1083 /// If all arguments of the intrinsic are unary shuffles with the same mask,
1084 /// try to shuffle after the intrinsic.
1085 static Instruction *
1088  // TODO: This should be extended to handle other intrinsics like fshl, ctpop,
1089  // etc. Use llvm::isTriviallyVectorizable() and related to determine
1090  // which intrinsics are safe to shuffle?
1091  switch (II->getIntrinsicID()) {
1092  case Intrinsic::smax:
1093  case Intrinsic::smin:
1094  case Intrinsic::umax:
1095  case Intrinsic::umin:
1096  case Intrinsic::fma:
1097  case Intrinsic::fshl:
1098  case Intrinsic::fshr:
1099  break;
1100  default:
1101  return nullptr;
1102  }
1103 
1104  Value *X;
1106  if (!match(II->getArgOperand(0),
1108  return nullptr;
1109 
1110  // At least 1 operand must have 1 use because we are creating 2 instructions.
1111  if (none_of(II->args(), [](Value *V) { return V->hasOneUse(); }))
1112  return nullptr;
1113 
1114  // See if all arguments are shuffled with the same mask.
1115  SmallVector<Value *, 4> NewArgs(II->arg_size());
1116  NewArgs[0] = X;
1117  Type *SrcTy = X->getType();
1118  for (unsigned i = 1, e = II->arg_size(); i != e; ++i) {
1119  if (!match(II->getArgOperand(i),
1121  X->getType() != SrcTy)
1122  return nullptr;
1123  NewArgs[i] = X;
1124  }
1125 
1126  // intrinsic (shuf X, M), (shuf Y, M), ... --> shuf (intrinsic X, Y, ...), M
1127  Instruction *FPI = isa<FPMathOperator>(II) ? II : nullptr;
1128  Value *NewIntrinsic =
1129  Builder.CreateIntrinsic(II->getIntrinsicID(), SrcTy, NewArgs, FPI);
1130  return new ShuffleVectorInst(NewIntrinsic, Mask);
1131 }
1132 
1133 /// CallInst simplification. This mostly only handles folding of intrinsic
1134 /// instructions. For normal calls, it allows visitCallBase to do the heavy
1135 /// lifting.
1137  // Don't try to simplify calls without uses. It will not do anything useful,
1138  // but will result in the following folds being skipped.
1139  if (!CI.use_empty())
1140  if (Value *V = SimplifyCall(&CI, SQ.getWithInstruction(&CI)))
1141  return replaceInstUsesWith(CI, V);
1142 
1143  if (isFreeCall(&CI, &TLI))
1144  return visitFree(CI);
1145 
1146  // If the caller function (i.e. us, the function that contains this CallInst)
1147  // is nounwind, mark the call as nounwind, even if the callee isn't.
1148  if (CI.getFunction()->doesNotThrow() && !CI.doesNotThrow()) {
1149  CI.setDoesNotThrow();
1150  return &CI;
1151  }
1152 
1153  IntrinsicInst *II = dyn_cast<IntrinsicInst>(&CI);
1154  if (!II) return visitCallBase(CI);
1155 
1156  // For atomic unordered mem intrinsics if len is not a positive or
1157  // not a multiple of element size then behavior is undefined.
1158  if (auto *AMI = dyn_cast<AtomicMemIntrinsic>(II))
1159  if (ConstantInt *NumBytes = dyn_cast<ConstantInt>(AMI->getLength()))
1160  if (NumBytes->getSExtValue() < 0 ||
1161  (NumBytes->getZExtValue() % AMI->getElementSizeInBytes() != 0)) {
1162  CreateNonTerminatorUnreachable(AMI);
1163  assert(AMI->getType()->isVoidTy() &&
1164  "non void atomic unordered mem intrinsic");
1165  return eraseInstFromFunction(*AMI);
1166  }
1167 
1168  // Intrinsics cannot occur in an invoke or a callbr, so handle them here
1169  // instead of in visitCallBase.
1170  if (auto *MI = dyn_cast<AnyMemIntrinsic>(II)) {
1171  bool Changed = false;
1172 
1173  // memmove/cpy/set of zero bytes is a noop.
1174  if (Constant *NumBytes = dyn_cast<Constant>(MI->getLength())) {
1175  if (NumBytes->isNullValue())
1176  return eraseInstFromFunction(CI);
1177  }
1178 
1179  // No other transformations apply to volatile transfers.
1180  if (auto *M = dyn_cast<MemIntrinsic>(MI))
1181  if (M->isVolatile())
1182  return nullptr;
1183 
1184  // If we have a memmove and the source operation is a constant global,
1185  // then the source and dest pointers can't alias, so we can change this
1186  // into a call to memcpy.
1187  if (auto *MMI = dyn_cast<AnyMemMoveInst>(MI)) {
1188  if (GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource()))
1189  if (GVSrc->isConstant()) {
1190  Module *M = CI.getModule();
1191  Intrinsic::ID MemCpyID =
1192  isa<AtomicMemMoveInst>(MMI)
1193  ? Intrinsic::memcpy_element_unordered_atomic
1195  Type *Tys[3] = { CI.getArgOperand(0)->getType(),
1196  CI.getArgOperand(1)->getType(),
1197  CI.getArgOperand(2)->getType() };
1198  CI.setCalledFunction(Intrinsic::getDeclaration(M, MemCpyID, Tys));
1199  Changed = true;
1200  }
1201  }
1202 
1203  if (AnyMemTransferInst *MTI = dyn_cast<AnyMemTransferInst>(MI)) {
1204  // memmove(x,x,size) -> noop.
1205  if (MTI->getSource() == MTI->getDest())
1206  return eraseInstFromFunction(CI);
1207  }
1208 
1209  // If we can determine a pointer alignment that is bigger than currently
1210  // set, update the alignment.
1211  if (auto *MTI = dyn_cast<AnyMemTransferInst>(MI)) {
1212  if (Instruction *I = SimplifyAnyMemTransfer(MTI))
1213  return I;
1214  } else if (auto *MSI = dyn_cast<AnyMemSetInst>(MI)) {
1215  if (Instruction *I = SimplifyAnyMemSet(MSI))
1216  return I;
1217  }
1218 
1219  if (Changed) return II;
1220  }
1221 
1222  // For fixed width vector result intrinsics, use the generic demanded vector
1223  // support.
1224  if (auto *IIFVTy = dyn_cast<FixedVectorType>(II->getType())) {
1225  auto VWidth = IIFVTy->getNumElements();
1226  APInt UndefElts(VWidth, 0);
1227  APInt AllOnesEltMask(APInt::getAllOnes(VWidth));
1228  if (Value *V = SimplifyDemandedVectorElts(II, AllOnesEltMask, UndefElts)) {
1229  if (V != II)
1230  return replaceInstUsesWith(*II, V);
1231  return II;
1232  }
1233  }
1234 
1235  if (II->isCommutative()) {
1236  if (CallInst *NewCall = canonicalizeConstantArg0ToArg1(CI))
1237  return NewCall;
1238  }
1239 
1240  // Unused constrained FP intrinsic calls may have declared side effect, which
1241  // prevents it from being removed. In some cases however the side effect is
1242  // actually absent. To detect this case, call SimplifyConstrainedFPCall. If it
1243  // returns a replacement, the call may be removed.
1244  if (CI.use_empty() && isa<ConstrainedFPIntrinsic>(CI)) {
1245  if (SimplifyConstrainedFPCall(&CI, SQ.getWithInstruction(&CI)))
1246  return eraseInstFromFunction(CI);
1247  }
1248 
1249  Intrinsic::ID IID = II->getIntrinsicID();
1250  switch (IID) {
1251  case Intrinsic::objectsize:
1252  if (Value *V = lowerObjectSizeCall(II, DL, &TLI, AA, /*MustSucceed=*/false))
1253  return replaceInstUsesWith(CI, V);
1254  return nullptr;
1255  case Intrinsic::abs: {
1256  Value *IIOperand = II->getArgOperand(0);
1257  bool IntMinIsPoison = cast<Constant>(II->getArgOperand(1))->isOneValue();
1258 
1259  // abs(-x) -> abs(x)
1260  // TODO: Copy nsw if it was present on the neg?
1261  Value *X;
1262  if (match(IIOperand, m_Neg(m_Value(X))))
1263  return replaceOperand(*II, 0, X);
1264  if (match(IIOperand, m_Select(m_Value(), m_Value(X), m_Neg(m_Deferred(X)))))
1265  return replaceOperand(*II, 0, X);
1266  if (match(IIOperand, m_Select(m_Value(), m_Neg(m_Value(X)), m_Deferred(X))))
1267  return replaceOperand(*II, 0, X);
1268 
1269  if (Optional<bool> Sign = getKnownSign(IIOperand, II, DL, &AC, &DT)) {
1270  // abs(x) -> x if x >= 0
1271  if (!*Sign)
1272  return replaceInstUsesWith(*II, IIOperand);
1273 
1274  // abs(x) -> -x if x < 0
1275  if (IntMinIsPoison)
1276  return BinaryOperator::CreateNSWNeg(IIOperand);
1277  return BinaryOperator::CreateNeg(IIOperand);
1278  }
1279 
1280  // abs (sext X) --> zext (abs X*)
1281  // Clear the IsIntMin (nsw) bit on the abs to allow narrowing.
1282  if (match(IIOperand, m_OneUse(m_SExt(m_Value(X))))) {
1283  Value *NarrowAbs =
1284  Builder.CreateBinaryIntrinsic(Intrinsic::abs, X, Builder.getFalse());
1285  return CastInst::Create(Instruction::ZExt, NarrowAbs, II->getType());
1286  }
1287 
1288  // Match a complicated way to check if a number is odd/even:
1289  // abs (srem X, 2) --> and X, 1
1290  const APInt *C;
1291  if (match(IIOperand, m_SRem(m_Value(X), m_APInt(C))) && *C == 2)
1292  return BinaryOperator::CreateAnd(X, ConstantInt::get(II->getType(), 1));
1293 
1294  break;
1295  }
1296  case Intrinsic::umin: {
1297  Value *I0 = II->getArgOperand(0), *I1 = II->getArgOperand(1);
1298  // umin(x, 1) == zext(x != 0)
1299  if (match(I1, m_One())) {
1300  Value *Zero = Constant::getNullValue(I0->getType());
1301  Value *Cmp = Builder.CreateICmpNE(I0, Zero);
1302  return CastInst::Create(Instruction::ZExt, Cmp, II->getType());
1303  }
1305  }
1306  case Intrinsic::umax: {
1307  Value *I0 = II->getArgOperand(0), *I1 = II->getArgOperand(1);
1308  Value *X, *Y;
1309  if (match(I0, m_ZExt(m_Value(X))) && match(I1, m_ZExt(m_Value(Y))) &&
1310  (I0->hasOneUse() || I1->hasOneUse()) && X->getType() == Y->getType()) {
1311  Value *NarrowMaxMin = Builder.CreateBinaryIntrinsic(IID, X, Y);
1312  return CastInst::Create(Instruction::ZExt, NarrowMaxMin, II->getType());
1313  }
1314  Constant *C;
1315  if (match(I0, m_ZExt(m_Value(X))) && match(I1, m_Constant(C)) &&
1316  I0->hasOneUse()) {
1317  Constant *NarrowC = ConstantExpr::getTrunc(C, X->getType());
1318  if (ConstantExpr::getZExt(NarrowC, II->getType()) == C) {
1319  Value *NarrowMaxMin = Builder.CreateBinaryIntrinsic(IID, X, NarrowC);
1320  return CastInst::Create(Instruction::ZExt, NarrowMaxMin, II->getType());
1321  }
1322  }
1323  // If both operands of unsigned min/max are sign-extended, it is still ok
1324  // to narrow the operation.
1326  }
1327  case Intrinsic::smax:
1328  case Intrinsic::smin: {
1329  Value *I0 = II->getArgOperand(0), *I1 = II->getArgOperand(1);
1330  Value *X, *Y;
1331  if (match(I0, m_SExt(m_Value(X))) && match(I1, m_SExt(m_Value(Y))) &&
1332  (I0->hasOneUse() || I1->hasOneUse()) && X->getType() == Y->getType()) {
1333  Value *NarrowMaxMin = Builder.CreateBinaryIntrinsic(IID, X, Y);
1334  return CastInst::Create(Instruction::SExt, NarrowMaxMin, II->getType());
1335  }
1336 
1337  Constant *C;
1338  if (match(I0, m_SExt(m_Value(X))) && match(I1, m_Constant(C)) &&
1339  I0->hasOneUse()) {
1340  Constant *NarrowC = ConstantExpr::getTrunc(C, X->getType());
1341  if (ConstantExpr::getSExt(NarrowC, II->getType()) == C) {
1342  Value *NarrowMaxMin = Builder.CreateBinaryIntrinsic(IID, X, NarrowC);
1343  return CastInst::Create(Instruction::SExt, NarrowMaxMin, II->getType());
1344  }
1345  }
1346 
1347  if (IID == Intrinsic::smax || IID == Intrinsic::smin) {
1348  // smax (neg nsw X), (neg nsw Y) --> neg nsw (smin X, Y)
1349  // smin (neg nsw X), (neg nsw Y) --> neg nsw (smax X, Y)
1350  // TODO: Canonicalize neg after min/max if I1 is constant.
1351  if (match(I0, m_NSWNeg(m_Value(X))) && match(I1, m_NSWNeg(m_Value(Y))) &&
1352  (I0->hasOneUse() || I1->hasOneUse())) {
1354  Value *InvMaxMin = Builder.CreateBinaryIntrinsic(InvID, X, Y);
1355  return BinaryOperator::CreateNSWNeg(InvMaxMin);
1356  }
1357  }
1358 
1359  // If we can eliminate ~A and Y is free to invert:
1360  // max ~A, Y --> ~(min A, ~Y)
1361  //
1362  // Examples:
1363  // max ~A, ~Y --> ~(min A, Y)
1364  // max ~A, C --> ~(min A, ~C)
1365  // max ~A, (max ~Y, ~Z) --> ~min( A, (min Y, Z))
1366  auto moveNotAfterMinMax = [&](Value *X, Value *Y) -> Instruction * {
1367  Value *A;
1368  if (match(X, m_OneUse(m_Not(m_Value(A)))) &&
1369  !isFreeToInvert(A, A->hasOneUse()) &&
1370  isFreeToInvert(Y, Y->hasOneUse())) {
1371  Value *NotY = Builder.CreateNot(Y);
1373  Value *InvMaxMin = Builder.CreateBinaryIntrinsic(InvID, A, NotY);
1374  return BinaryOperator::CreateNot(InvMaxMin);
1375  }
1376  return nullptr;
1377  };
1378 
1379  if (Instruction *I = moveNotAfterMinMax(I0, I1))
1380  return I;
1381  if (Instruction *I = moveNotAfterMinMax(I1, I0))
1382  return I;
1383 
1385  return I;
1386 
1387  // smax(X, -X) --> abs(X)
1388  // smin(X, -X) --> -abs(X)
1389  // umax(X, -X) --> -abs(X)
1390  // umin(X, -X) --> abs(X)
1391  if (isKnownNegation(I0, I1)) {
1392  // We can choose either operand as the input to abs(), but if we can
1393  // eliminate the only use of a value, that's better for subsequent
1394  // transforms/analysis.
1395  if (I0->hasOneUse() && !I1->hasOneUse())
1396  std::swap(I0, I1);
1397 
1398  // This is some variant of abs(). See if we can propagate 'nsw' to the abs
1399  // operation and potentially its negation.
1400  bool IntMinIsPoison = isKnownNegation(I0, I1, /* NeedNSW */ true);
1401  Value *Abs = Builder.CreateBinaryIntrinsic(
1402  Intrinsic::abs, I0,
1403  ConstantInt::getBool(II->getContext(), IntMinIsPoison));
1404 
1405  // We don't have a "nabs" intrinsic, so negate if needed based on the
1406  // max/min operation.
1407  if (IID == Intrinsic::smin || IID == Intrinsic::umax)
1408  Abs = Builder.CreateNeg(Abs, "nabs", /* NUW */ false, IntMinIsPoison);
1409  return replaceInstUsesWith(CI, Abs);
1410  }
1411 
1412  if (Instruction *Sel = foldClampRangeOfTwo(II, Builder))
1413  return Sel;
1414 
1415  if (Instruction *SAdd = matchSAddSubSat(*II))
1416  return SAdd;
1417 
1418  if (match(I1, m_ImmConstant()))
1419  if (auto *Sel = dyn_cast<SelectInst>(I0))
1420  if (Instruction *R = FoldOpIntoSelect(*II, Sel))
1421  return R;
1422 
1423  if (Instruction *NewMinMax = reassociateMinMaxWithConstants(II))
1424  return NewMinMax;
1425 
1427  return R;
1428 
1429  if (Instruction *NewMinMax = factorizeMinMaxTree(II))
1430  return NewMinMax;
1431 
1432  break;
1433  }
1434  case Intrinsic::bswap: {
1435  Value *IIOperand = II->getArgOperand(0);
1436 
1437  // Try to canonicalize bswap-of-logical-shift-by-8-bit-multiple as
1438  // inverse-shift-of-bswap:
1439  // bswap (shl X, Y) --> lshr (bswap X), Y
1440  // bswap (lshr X, Y) --> shl (bswap X), Y
1441  Value *X, *Y;
1442  if (match(IIOperand, m_OneUse(m_LogicalShift(m_Value(X), m_Value(Y))))) {
1443  // The transform allows undef vector elements, so try a constant match
1444  // first. If knownbits can handle that case, that clause could be removed.
1445  unsigned BitWidth = IIOperand->getType()->getScalarSizeInBits();
1446  const APInt *C;
1447  if ((match(Y, m_APIntAllowUndef(C)) && (*C & 7) == 0) ||
1449  Value *NewSwap = Builder.CreateUnaryIntrinsic(Intrinsic::bswap, X);
1450  BinaryOperator::BinaryOps InverseShift =
1451  cast<BinaryOperator>(IIOperand)->getOpcode() == Instruction::Shl
1452  ? Instruction::LShr
1453  : Instruction::Shl;
1454  return BinaryOperator::Create(InverseShift, NewSwap, Y);
1455  }
1456  }
1457 
1458  KnownBits Known = computeKnownBits(IIOperand, 0, II);
1459  uint64_t LZ = alignDown(Known.countMinLeadingZeros(), 8);
1460  uint64_t TZ = alignDown(Known.countMinTrailingZeros(), 8);
1461  unsigned BW = Known.getBitWidth();
1462 
1463  // bswap(x) -> shift(x) if x has exactly one "active byte"
1464  if (BW - LZ - TZ == 8) {
1465  assert(LZ != TZ && "active byte cannot be in the middle");
1466  if (LZ > TZ) // -> shl(x) if the "active byte" is in the low part of x
1467  return BinaryOperator::CreateNUWShl(
1468  IIOperand, ConstantInt::get(IIOperand->getType(), LZ - TZ));
1469  // -> lshr(x) if the "active byte" is in the high part of x
1470  return BinaryOperator::CreateExactLShr(
1471  IIOperand, ConstantInt::get(IIOperand->getType(), TZ - LZ));
1472  }
1473 
1474  // bswap(trunc(bswap(x))) -> trunc(lshr(x, c))
1475  if (match(IIOperand, m_Trunc(m_BSwap(m_Value(X))))) {
1476  unsigned C = X->getType()->getScalarSizeInBits() - BW;
1477  Value *CV = ConstantInt::get(X->getType(), C);
1478  Value *V = Builder.CreateLShr(X, CV);
1479  return new TruncInst(V, IIOperand->getType());
1480  }
1481  break;
1482  }
1483  case Intrinsic::masked_load:
1484  if (Value *SimplifiedMaskedOp = simplifyMaskedLoad(*II))
1485  return replaceInstUsesWith(CI, SimplifiedMaskedOp);
1486  break;
1487  case Intrinsic::masked_store:
1488  return simplifyMaskedStore(*II);
1489  case Intrinsic::masked_gather:
1490  return simplifyMaskedGather(*II);
1491  case Intrinsic::masked_scatter:
1492  return simplifyMaskedScatter(*II);
1493  case Intrinsic::launder_invariant_group:
1494  case Intrinsic::strip_invariant_group:
1495  if (auto *SkippedBarrier = simplifyInvariantGroupIntrinsic(*II, *this))
1496  return replaceInstUsesWith(*II, SkippedBarrier);
1497  break;
1498  case Intrinsic::powi:
1499  if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
1500  // 0 and 1 are handled in instsimplify
1501  // powi(x, -1) -> 1/x
1502  if (Power->isMinusOne())
1504  II->getArgOperand(0), II);
1505  // powi(x, 2) -> x*x
1506  if (Power->equalsInt(2))
1508  II->getArgOperand(0), II);
1509 
1510  if (!Power->getValue()[0]) {
1511  Value *X;
1512  // If power is even:
1513  // powi(-x, p) -> powi(x, p)
1514  // powi(fabs(x), p) -> powi(x, p)
1515  // powi(copysign(x, y), p) -> powi(x, p)
1516  if (match(II->getArgOperand(0), m_FNeg(m_Value(X))) ||
1517  match(II->getArgOperand(0), m_FAbs(m_Value(X))) ||
1518  match(II->getArgOperand(0),
1519  m_Intrinsic<Intrinsic::copysign>(m_Value(X), m_Value())))
1520  return replaceOperand(*II, 0, X);
1521  }
1522  }
1523  break;
1524 
1525  case Intrinsic::cttz:
1526  case Intrinsic::ctlz:
1527  if (auto *I = foldCttzCtlz(*II, *this))
1528  return I;
1529  break;
1530 
1531  case Intrinsic::ctpop:
1532  if (auto *I = foldCtpop(*II, *this))
1533  return I;
1534  break;
1535 
1536  case Intrinsic::fshl:
1537  case Intrinsic::fshr: {
1538  Value *Op0 = II->getArgOperand(0), *Op1 = II->getArgOperand(1);
1539  Type *Ty = II->getType();
1540  unsigned BitWidth = Ty->getScalarSizeInBits();
1541  Constant *ShAmtC;
1542  if (match(II->getArgOperand(2), m_ImmConstant(ShAmtC)) &&
1543  !ShAmtC->containsConstantExpression()) {
1544  // Canonicalize a shift amount constant operand to modulo the bit-width.
1545  Constant *WidthC = ConstantInt::get(Ty, BitWidth);
1546  Constant *ModuloC = ConstantExpr::getURem(ShAmtC, WidthC);
1547  if (ModuloC != ShAmtC)
1548  return replaceOperand(*II, 2, ModuloC);
1549 
1550  assert(ConstantExpr::getICmp(ICmpInst::ICMP_UGT, WidthC, ShAmtC) ==
1552  "Shift amount expected to be modulo bitwidth");
1553 
1554  // Canonicalize funnel shift right by constant to funnel shift left. This
1555  // is not entirely arbitrary. For historical reasons, the backend may
1556  // recognize rotate left patterns but miss rotate right patterns.
1557  if (IID == Intrinsic::fshr) {
1558  // fshr X, Y, C --> fshl X, Y, (BitWidth - C)
1559  Constant *LeftShiftC = ConstantExpr::getSub(WidthC, ShAmtC);
1560  Module *Mod = II->getModule();
1561  Function *Fshl = Intrinsic::getDeclaration(Mod, Intrinsic::fshl, Ty);
1562  return CallInst::Create(Fshl, { Op0, Op1, LeftShiftC });
1563  }
1564  assert(IID == Intrinsic::fshl &&
1565  "All funnel shifts by simple constants should go left");
1566 
1567  // fshl(X, 0, C) --> shl X, C
1568  // fshl(X, undef, C) --> shl X, C
1569  if (match(Op1, m_ZeroInt()) || match(Op1, m_Undef()))
1570  return BinaryOperator::CreateShl(Op0, ShAmtC);
1571 
1572  // fshl(0, X, C) --> lshr X, (BW-C)
1573  // fshl(undef, X, C) --> lshr X, (BW-C)
1574  if (match(Op0, m_ZeroInt()) || match(Op0, m_Undef()))
1575  return BinaryOperator::CreateLShr(Op1,
1576  ConstantExpr::getSub(WidthC, ShAmtC));
1577 
1578  // fshl i16 X, X, 8 --> bswap i16 X (reduce to more-specific form)
1579  if (Op0 == Op1 && BitWidth == 16 && match(ShAmtC, m_SpecificInt(8))) {
1580  Module *Mod = II->getModule();
1581  Function *Bswap = Intrinsic::getDeclaration(Mod, Intrinsic::bswap, Ty);
1582  return CallInst::Create(Bswap, { Op0 });
1583  }
1584  }
1585 
1586  // Left or right might be masked.
1587  if (SimplifyDemandedInstructionBits(*II))
1588  return &CI;
1589 
1590  // The shift amount (operand 2) of a funnel shift is modulo the bitwidth,
1591  // so only the low bits of the shift amount are demanded if the bitwidth is
1592  // a power-of-2.
1593  if (!isPowerOf2_32(BitWidth))
1594  break;
1596  KnownBits Op2Known(BitWidth);
1597  if (SimplifyDemandedBits(II, 2, Op2Demanded, Op2Known))
1598  return &CI;
1599  break;
1600  }
1601  case Intrinsic::uadd_with_overflow:
1602  case Intrinsic::sadd_with_overflow: {
1603  if (Instruction *I = foldIntrinsicWithOverflowCommon(II))
1604  return I;
1605 
1606  // Given 2 constant operands whose sum does not overflow:
1607  // uaddo (X +nuw C0), C1 -> uaddo X, C0 + C1
1608  // saddo (X +nsw C0), C1 -> saddo X, C0 + C1
1609  Value *X;
1610  const APInt *C0, *C1;
1611  Value *Arg0 = II->getArgOperand(0);
1612  Value *Arg1 = II->getArgOperand(1);
1613  bool IsSigned = IID == Intrinsic::sadd_with_overflow;
1614  bool HasNWAdd = IsSigned ? match(Arg0, m_NSWAdd(m_Value(X), m_APInt(C0)))
1615  : match(Arg0, m_NUWAdd(m_Value(X), m_APInt(C0)));
1616  if (HasNWAdd && match(Arg1, m_APInt(C1))) {
1617  bool Overflow;
1618  APInt NewC =
1619  IsSigned ? C1->sadd_ov(*C0, Overflow) : C1->uadd_ov(*C0, Overflow);
1620  if (!Overflow)
1621  return replaceInstUsesWith(
1622  *II, Builder.CreateBinaryIntrinsic(
1623  IID, X, ConstantInt::get(Arg1->getType(), NewC)));
1624  }
1625  break;
1626  }
1627 
1628  case Intrinsic::umul_with_overflow:
1629  case Intrinsic::smul_with_overflow:
1630  case Intrinsic::usub_with_overflow:
1631  if (Instruction *I = foldIntrinsicWithOverflowCommon(II))
1632  return I;
1633  break;
1634 
1635  case Intrinsic::ssub_with_overflow: {
1636  if (Instruction *I = foldIntrinsicWithOverflowCommon(II))
1637  return I;
1638 
1639  Constant *C;
1640  Value *Arg0 = II->getArgOperand(0);
1641  Value *Arg1 = II->getArgOperand(1);
1642  // Given a constant C that is not the minimum signed value
1643  // for an integer of a given bit width:
1644  //
1645  // ssubo X, C -> saddo X, -C
1646  if (match(Arg1, m_Constant(C)) && C->isNotMinSignedValue()) {
1647  Value *NegVal = ConstantExpr::getNeg(C);
1648  // Build a saddo call that is equivalent to the discovered
1649  // ssubo call.
1650  return replaceInstUsesWith(
1651  *II, Builder.CreateBinaryIntrinsic(Intrinsic::sadd_with_overflow,
1652  Arg0, NegVal));
1653  }
1654 
1655  break;
1656  }
1657 
1658  case Intrinsic::uadd_sat:
1659  case Intrinsic::sadd_sat:
1660  case Intrinsic::usub_sat:
1661  case Intrinsic::ssub_sat: {
1662  SaturatingInst *SI = cast<SaturatingInst>(II);
1663  Type *Ty = SI->getType();
1664  Value *Arg0 = SI->getLHS();
1665  Value *Arg1 = SI->getRHS();
1666 
1667  // Make use of known overflow information.
1668  OverflowResult OR = computeOverflow(SI->getBinaryOp(), SI->isSigned(),
1669  Arg0, Arg1, SI);
1670  switch (OR) {
1672  break;
1674  if (SI->isSigned())
1675  return BinaryOperator::CreateNSW(SI->getBinaryOp(), Arg0, Arg1);
1676  else
1677  return BinaryOperator::CreateNUW(SI->getBinaryOp(), Arg0, Arg1);
1679  unsigned BitWidth = Ty->getScalarSizeInBits();
1680  APInt Min = APSInt::getMinValue(BitWidth, !SI->isSigned());
1681  return replaceInstUsesWith(*SI, ConstantInt::get(Ty, Min));
1682  }
1684  unsigned BitWidth = Ty->getScalarSizeInBits();
1685  APInt Max = APSInt::getMaxValue(BitWidth, !SI->isSigned());
1686  return replaceInstUsesWith(*SI, ConstantInt::get(Ty, Max));
1687  }
1688  }
1689 
1690  // ssub.sat(X, C) -> sadd.sat(X, -C) if C != MIN
1691  Constant *C;
1692  if (IID == Intrinsic::ssub_sat && match(Arg1, m_Constant(C)) &&
1693  C->isNotMinSignedValue()) {
1694  Value *NegVal = ConstantExpr::getNeg(C);
1695  return replaceInstUsesWith(
1696  *II, Builder.CreateBinaryIntrinsic(
1697  Intrinsic::sadd_sat, Arg0, NegVal));
1698  }
1699 
1700  // sat(sat(X + Val2) + Val) -> sat(X + (Val+Val2))
1701  // sat(sat(X - Val2) - Val) -> sat(X - (Val+Val2))
1702  // if Val and Val2 have the same sign
1703  if (auto *Other = dyn_cast<IntrinsicInst>(Arg0)) {
1704  Value *X;
1705  const APInt *Val, *Val2;
1706  APInt NewVal;
1707  bool IsUnsigned =
1708  IID == Intrinsic::uadd_sat || IID == Intrinsic::usub_sat;
1709  if (Other->getIntrinsicID() == IID &&
1710  match(Arg1, m_APInt(Val)) &&
1711  match(Other->getArgOperand(0), m_Value(X)) &&
1712  match(Other->getArgOperand(1), m_APInt(Val2))) {
1713  if (IsUnsigned)
1714  NewVal = Val->uadd_sat(*Val2);
1715  else if (Val->isNonNegative() == Val2->isNonNegative()) {
1716  bool Overflow;
1717  NewVal = Val->sadd_ov(*Val2, Overflow);
1718  if (Overflow) {
1719  // Both adds together may add more than SignedMaxValue
1720  // without saturating the final result.
1721  break;
1722  }
1723  } else {
1724  // Cannot fold saturated addition with different signs.
1725  break;
1726  }
1727 
1728  return replaceInstUsesWith(
1729  *II, Builder.CreateBinaryIntrinsic(
1730  IID, X, ConstantInt::get(II->getType(), NewVal)));
1731  }
1732  }
1733  break;
1734  }
1735 
1736  case Intrinsic::minnum:
1737  case Intrinsic::maxnum:
1738  case Intrinsic::minimum:
1739  case Intrinsic::maximum: {
1740  Value *Arg0 = II->getArgOperand(0);
1741  Value *Arg1 = II->getArgOperand(1);
1742  Value *X, *Y;
1743  if (match(Arg0, m_FNeg(m_Value(X))) && match(Arg1, m_FNeg(m_Value(Y))) &&
1744  (Arg0->hasOneUse() || Arg1->hasOneUse())) {
1745  // If both operands are negated, invert the call and negate the result:
1746  // min(-X, -Y) --> -(max(X, Y))
1747  // max(-X, -Y) --> -(min(X, Y))
1748  Intrinsic::ID NewIID;
1749  switch (IID) {
1750  case Intrinsic::maxnum:
1751  NewIID = Intrinsic::minnum;
1752  break;
1753  case Intrinsic::minnum:
1754  NewIID = Intrinsic::maxnum;
1755  break;
1756  case Intrinsic::maximum:
1757  NewIID = Intrinsic::minimum;
1758  break;
1759  case Intrinsic::minimum:
1760  NewIID = Intrinsic::maximum;
1761  break;
1762  default:
1763  llvm_unreachable("unexpected intrinsic ID");
1764  }
1765  Value *NewCall = Builder.CreateBinaryIntrinsic(NewIID, X, Y, II);
1766  Instruction *FNeg = UnaryOperator::CreateFNeg(NewCall);
1767  FNeg->copyIRFlags(II);
1768  return FNeg;
1769  }
1770 
1771  // m(m(X, C2), C1) -> m(X, C)
1772  const APFloat *C1, *C2;
1773  if (auto *M = dyn_cast<IntrinsicInst>(Arg0)) {
1774  if (M->getIntrinsicID() == IID && match(Arg1, m_APFloat(C1)) &&
1775  ((match(M->getArgOperand(0), m_Value(X)) &&
1776  match(M->getArgOperand(1), m_APFloat(C2))) ||
1777  (match(M->getArgOperand(1), m_Value(X)) &&
1778  match(M->getArgOperand(0), m_APFloat(C2))))) {
1779  APFloat Res(0.0);
1780  switch (IID) {
1781  case Intrinsic::maxnum:
1782  Res = maxnum(*C1, *C2);
1783  break;
1784  case Intrinsic::minnum:
1785  Res = minnum(*C1, *C2);
1786  break;
1787  case Intrinsic::maximum:
1788  Res = maximum(*C1, *C2);
1789  break;
1790  case Intrinsic::minimum:
1791  Res = minimum(*C1, *C2);
1792  break;
1793  default:
1794  llvm_unreachable("unexpected intrinsic ID");
1795  }
1796  Instruction *NewCall = Builder.CreateBinaryIntrinsic(
1797  IID, X, ConstantFP::get(Arg0->getType(), Res), II);
1798  // TODO: Conservatively intersecting FMF. If Res == C2, the transform
1799  // was a simplification (so Arg0 and its original flags could
1800  // propagate?)
1801  NewCall->andIRFlags(M);
1802  return replaceInstUsesWith(*II, NewCall);
1803  }
1804  }
1805 
1806  // m((fpext X), (fpext Y)) -> fpext (m(X, Y))
1807  if (match(Arg0, m_OneUse(m_FPExt(m_Value(X)))) &&
1808  match(Arg1, m_OneUse(m_FPExt(m_Value(Y)))) &&
1809  X->getType() == Y->getType()) {
1810  Value *NewCall =
1811  Builder.CreateBinaryIntrinsic(IID, X, Y, II, II->getName());
1812  return new FPExtInst(NewCall, II->getType());
1813  }
1814 
1815  // max X, -X --> fabs X
1816  // min X, -X --> -(fabs X)
1817  // TODO: Remove one-use limitation? That is obviously better for max.
1818  // It would be an extra instruction for min (fnabs), but that is
1819  // still likely better for analysis and codegen.
1820  if ((match(Arg0, m_OneUse(m_FNeg(m_Value(X)))) && Arg1 == X) ||
1821  (match(Arg1, m_OneUse(m_FNeg(m_Value(X)))) && Arg0 == X)) {
1822  Value *R = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, X, II);
1823  if (IID == Intrinsic::minimum || IID == Intrinsic::minnum)
1824  R = Builder.CreateFNegFMF(R, II);
1825  return replaceInstUsesWith(*II, R);
1826  }
1827 
1828  break;
1829  }
1830  case Intrinsic::fmuladd: {
1831  // Canonicalize fast fmuladd to the separate fmul + fadd.
1832  if (II->isFast()) {
1834  Builder.setFastMathFlags(II->getFastMathFlags());
1835  Value *Mul = Builder.CreateFMul(II->getArgOperand(0),
1836  II->getArgOperand(1));
1837  Value *Add = Builder.CreateFAdd(Mul, II->getArgOperand(2));
1838  Add->takeName(II);
1839  return replaceInstUsesWith(*II, Add);
1840  }
1841 
1842  // Try to simplify the underlying FMul.
1843  if (Value *V = SimplifyFMulInst(II->getArgOperand(0), II->getArgOperand(1),
1844  II->getFastMathFlags(),
1845  SQ.getWithInstruction(II))) {
1846  auto *FAdd = BinaryOperator::CreateFAdd(V, II->getArgOperand(2));
1847  FAdd->copyFastMathFlags(II);
1848  return FAdd;
1849  }
1850 
1852  }
1853  case Intrinsic::fma: {
1854  // fma fneg(x), fneg(y), z -> fma x, y, z
1855  Value *Src0 = II->getArgOperand(0);
1856  Value *Src1 = II->getArgOperand(1);
1857  Value *X, *Y;
1858  if (match(Src0, m_FNeg(m_Value(X))) && match(Src1, m_FNeg(m_Value(Y)))) {
1859  replaceOperand(*II, 0, X);
1860  replaceOperand(*II, 1, Y);
1861  return II;
1862  }
1863 
1864  // fma fabs(x), fabs(x), z -> fma x, x, z
1865  if (match(Src0, m_FAbs(m_Value(X))) &&
1866  match(Src1, m_FAbs(m_Specific(X)))) {
1867  replaceOperand(*II, 0, X);
1868  replaceOperand(*II, 1, X);
1869  return II;
1870  }
1871 
1872  // Try to simplify the underlying FMul. We can only apply simplifications
1873  // that do not require rounding.
1874  if (Value *V = SimplifyFMAFMul(II->getArgOperand(0), II->getArgOperand(1),
1875  II->getFastMathFlags(),
1876  SQ.getWithInstruction(II))) {
1877  auto *FAdd = BinaryOperator::CreateFAdd(V, II->getArgOperand(2));
1878  FAdd->copyFastMathFlags(II);
1879  return FAdd;
1880  }
1881 
1882  // fma x, y, 0 -> fmul x, y
1883  // This is always valid for -0.0, but requires nsz for +0.0 as
1884  // -0.0 + 0.0 = 0.0, which would not be the same as the fmul on its own.
1885  if (match(II->getArgOperand(2), m_NegZeroFP()) ||
1886  (match(II->getArgOperand(2), m_PosZeroFP()) &&
1888  return BinaryOperator::CreateFMulFMF(Src0, Src1, II);
1889 
1890  break;
1891  }
1892  case Intrinsic::copysign: {
1893  Value *Mag = II->getArgOperand(0), *Sign = II->getArgOperand(1);
1894  if (SignBitMustBeZero(Sign, &TLI)) {
1895  // If we know that the sign argument is positive, reduce to FABS:
1896  // copysign Mag, +Sign --> fabs Mag
1897  Value *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, Mag, II);
1898  return replaceInstUsesWith(*II, Fabs);
1899  }
1900  // TODO: There should be a ValueTracking sibling like SignBitMustBeOne.
1901  const APFloat *C;
1902  if (match(Sign, m_APFloat(C)) && C->isNegative()) {
1903  // If we know that the sign argument is negative, reduce to FNABS:
1904  // copysign Mag, -Sign --> fneg (fabs Mag)
1905  Value *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, Mag, II);
1906  return replaceInstUsesWith(*II, Builder.CreateFNegFMF(Fabs, II));
1907  }
1908 
1909  // Propagate sign argument through nested calls:
1910  // copysign Mag, (copysign ?, X) --> copysign Mag, X
1911  Value *X;
1912  if (match(Sign, m_Intrinsic<Intrinsic::copysign>(m_Value(), m_Value(X))))
1913  return replaceOperand(*II, 1, X);
1914 
1915  // Peek through changes of magnitude's sign-bit. This call rewrites those:
1916  // copysign (fabs X), Sign --> copysign X, Sign
1917  // copysign (fneg X), Sign --> copysign X, Sign
1918  if (match(Mag, m_FAbs(m_Value(X))) || match(Mag, m_FNeg(m_Value(X))))
1919  return replaceOperand(*II, 0, X);
1920 
1921  break;
1922  }
1923  case Intrinsic::fabs: {
1924  Value *Cond, *TVal, *FVal;
1925  if (match(II->getArgOperand(0),
1926  m_Select(m_Value(Cond), m_Value(TVal), m_Value(FVal)))) {
1927  // fabs (select Cond, TrueC, FalseC) --> select Cond, AbsT, AbsF
1928  if (isa<Constant>(TVal) && isa<Constant>(FVal)) {
1929  CallInst *AbsT = Builder.CreateCall(II->getCalledFunction(), {TVal});
1930  CallInst *AbsF = Builder.CreateCall(II->getCalledFunction(), {FVal});
1931  return SelectInst::Create(Cond, AbsT, AbsF);
1932  }
1933  // fabs (select Cond, -FVal, FVal) --> fabs FVal
1934  if (match(TVal, m_FNeg(m_Specific(FVal))))
1935  return replaceOperand(*II, 0, FVal);
1936  // fabs (select Cond, TVal, -TVal) --> fabs TVal
1937  if (match(FVal, m_FNeg(m_Specific(TVal))))
1938  return replaceOperand(*II, 0, TVal);
1939  }
1940 
1942  }
1943  case Intrinsic::ceil:
1944  case Intrinsic::floor:
1945  case Intrinsic::round:
1946  case Intrinsic::roundeven:
1947  case Intrinsic::nearbyint:
1948  case Intrinsic::rint:
1949  case Intrinsic::trunc: {
1950  Value *ExtSrc;
1951  if (match(II->getArgOperand(0), m_OneUse(m_FPExt(m_Value(ExtSrc))))) {
1952  // Narrow the call: intrinsic (fpext x) -> fpext (intrinsic x)
1953  Value *NarrowII = Builder.CreateUnaryIntrinsic(IID, ExtSrc, II);
1954  return new FPExtInst(NarrowII, II->getType());
1955  }
1956  break;
1957  }
1958  case Intrinsic::cos:
1959  case Intrinsic::amdgcn_cos: {
1960  Value *X;
1961  Value *Src = II->getArgOperand(0);
1962  if (match(Src, m_FNeg(m_Value(X))) || match(Src, m_FAbs(m_Value(X)))) {
1963  // cos(-x) -> cos(x)
1964  // cos(fabs(x)) -> cos(x)
1965  return replaceOperand(*II, 0, X);
1966  }
1967  break;
1968  }
1969  case Intrinsic::sin: {
1970  Value *X;
1971  if (match(II->getArgOperand(0), m_OneUse(m_FNeg(m_Value(X))))) {
1972  // sin(-x) --> -sin(x)
1973  Value *NewSin = Builder.CreateUnaryIntrinsic(Intrinsic::sin, X, II);
1974  Instruction *FNeg = UnaryOperator::CreateFNeg(NewSin);
1975  FNeg->copyFastMathFlags(II);
1976  return FNeg;
1977  }
1978  break;
1979  }
1980 
1981  case Intrinsic::arm_neon_vtbl1:
1982  case Intrinsic::aarch64_neon_tbl1:
1983  if (Value *V = simplifyNeonTbl1(*II, Builder))
1984  return replaceInstUsesWith(*II, V);
1985  break;
1986 
1987  case Intrinsic::arm_neon_vmulls:
1988  case Intrinsic::arm_neon_vmullu:
1989  case Intrinsic::aarch64_neon_smull:
1990  case Intrinsic::aarch64_neon_umull: {
1991  Value *Arg0 = II->getArgOperand(0);
1992  Value *Arg1 = II->getArgOperand(1);
1993 
1994  // Handle mul by zero first:
1995  if (isa<ConstantAggregateZero>(Arg0) || isa<ConstantAggregateZero>(Arg1)) {
1996  return replaceInstUsesWith(CI, ConstantAggregateZero::get(II->getType()));
1997  }
1998 
1999  // Check for constant LHS & RHS - in this case we just simplify.
2000  bool Zext = (IID == Intrinsic::arm_neon_vmullu ||
2001  IID == Intrinsic::aarch64_neon_umull);
2002  VectorType *NewVT = cast<VectorType>(II->getType());
2003  if (Constant *CV0 = dyn_cast<Constant>(Arg0)) {
2004  if (Constant *CV1 = dyn_cast<Constant>(Arg1)) {
2005  CV0 = ConstantExpr::getIntegerCast(CV0, NewVT, /*isSigned=*/!Zext);
2006  CV1 = ConstantExpr::getIntegerCast(CV1, NewVT, /*isSigned=*/!Zext);
2007 
2008  return replaceInstUsesWith(CI, ConstantExpr::getMul(CV0, CV1));
2009  }
2010 
2011  // Couldn't simplify - canonicalize constant to the RHS.
2012  std::swap(Arg0, Arg1);
2013  }
2014 
2015  // Handle mul by one:
2016  if (Constant *CV1 = dyn_cast<Constant>(Arg1))
2017  if (ConstantInt *Splat =
2018  dyn_cast_or_null<ConstantInt>(CV1->getSplatValue()))
2019  if (Splat->isOne())
2020  return CastInst::CreateIntegerCast(Arg0, II->getType(),
2021  /*isSigned=*/!Zext);
2022 
2023  break;
2024  }
2025  case Intrinsic::arm_neon_aesd:
2026  case Intrinsic::arm_neon_aese:
2027  case Intrinsic::aarch64_crypto_aesd:
2028  case Intrinsic::aarch64_crypto_aese: {
2029  Value *DataArg = II->getArgOperand(0);
2030  Value *KeyArg = II->getArgOperand(1);
2031 
2032  // Try to use the builtin XOR in AESE and AESD to eliminate a prior XOR
2033  Value *Data, *Key;
2034  if (match(KeyArg, m_ZeroInt()) &&
2035  match(DataArg, m_Xor(m_Value(Data), m_Value(Key)))) {
2036  replaceOperand(*II, 0, Data);
2037  replaceOperand(*II, 1, Key);
2038  return II;
2039  }
2040  break;
2041  }
2042  case Intrinsic::hexagon_V6_vandvrt:
2043  case Intrinsic::hexagon_V6_vandvrt_128B: {
2044  // Simplify Q -> V -> Q conversion.
2045  if (auto Op0 = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) {
2046  Intrinsic::ID ID0 = Op0->getIntrinsicID();
2047  if (ID0 != Intrinsic::hexagon_V6_vandqrt &&
2048  ID0 != Intrinsic::hexagon_V6_vandqrt_128B)
2049  break;
2050  Value *Bytes = Op0->getArgOperand(1), *Mask = II->getArgOperand(1);
2051  uint64_t Bytes1 = computeKnownBits(Bytes, 0, Op0).One.getZExtValue();
2052  uint64_t Mask1 = computeKnownBits(Mask, 0, II).One.getZExtValue();
2053  // Check if every byte has common bits in Bytes and Mask.
2054  uint64_t C = Bytes1 & Mask1;
2055  if ((C & 0xFF) && (C & 0xFF00) && (C & 0xFF0000) && (C & 0xFF000000))
2056  return replaceInstUsesWith(*II, Op0->getArgOperand(0));
2057  }
2058  break;
2059  }
2060  case Intrinsic::stackrestore: {
2061  enum class ClassifyResult {
2062  None,
2063  Alloca,
2064  StackRestore,
2065  CallWithSideEffects,
2066  };
2067  auto Classify = [](const Instruction *I) {
2068  if (isa<AllocaInst>(I))
2069  return ClassifyResult::Alloca;
2070 
2071  if (auto *CI = dyn_cast<CallInst>(I)) {
2072  if (auto *II = dyn_cast<IntrinsicInst>(CI)) {
2073  if (II->getIntrinsicID() == Intrinsic::stackrestore)
2074  return ClassifyResult::StackRestore;
2075 
2076  if (II->mayHaveSideEffects())
2077  return ClassifyResult::CallWithSideEffects;
2078  } else {
2079  // Consider all non-intrinsic calls to be side effects
2080  return ClassifyResult::CallWithSideEffects;
2081  }
2082  }
2083 
2084  return ClassifyResult::None;
2085  };
2086 
2087  // If the stacksave and the stackrestore are in the same BB, and there is
2088  // no intervening call, alloca, or stackrestore of a different stacksave,
2089  // remove the restore. This can happen when variable allocas are DCE'd.
2090  if (IntrinsicInst *SS = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) {
2091  if (SS->getIntrinsicID() == Intrinsic::stacksave &&
2092  SS->getParent() == II->getParent()) {
2094  bool CannotRemove = false;
2095  for (++BI; &*BI != II; ++BI) {
2096  switch (Classify(&*BI)) {
2097  case ClassifyResult::None:
2098  // So far so good, look at next instructions.
2099  break;
2100 
2101  case ClassifyResult::StackRestore:
2102  // If we found an intervening stackrestore for a different
2103  // stacksave, we can't remove the stackrestore. Otherwise, continue.
2104  if (cast<IntrinsicInst>(*BI).getArgOperand(0) != SS)
2105  CannotRemove = true;
2106  break;
2107 
2108  case ClassifyResult::Alloca:
2109  case ClassifyResult::CallWithSideEffects:
2110  // If we found an alloca, a non-intrinsic call, or an intrinsic
2111  // call with side effects, we can't remove the stackrestore.
2112  CannotRemove = true;
2113  break;
2114  }
2115  if (CannotRemove)
2116  break;
2117  }
2118 
2119  if (!CannotRemove)
2120  return eraseInstFromFunction(CI);
2121  }
2122  }
2123 
2124  // Scan down this block to see if there is another stack restore in the
2125  // same block without an intervening call/alloca.
2126  BasicBlock::iterator BI(II);
2127  Instruction *TI = II->getParent()->getTerminator();
2128  bool CannotRemove = false;
2129  for (++BI; &*BI != TI; ++BI) {
2130  switch (Classify(&*BI)) {
2131  case ClassifyResult::None:
2132  // So far so good, look at next instructions.
2133  break;
2134 
2135  case ClassifyResult::StackRestore:
2136  // If there is a stackrestore below this one, remove this one.
2137  return eraseInstFromFunction(CI);
2138 
2139  case ClassifyResult::Alloca:
2140  case ClassifyResult::CallWithSideEffects:
2141  // If we found an alloca, a non-intrinsic call, or an intrinsic call
2142  // with side effects (such as llvm.stacksave and llvm.read_register),
2143  // we can't remove the stack restore.
2144  CannotRemove = true;
2145  break;
2146  }
2147  if (CannotRemove)
2148  break;
2149  }
2150 
2151  // If the stack restore is in a return, resume, or unwind block and if there
2152  // are no allocas or calls between the restore and the return, nuke the
2153  // restore.
2154  if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))
2155  return eraseInstFromFunction(CI);
2156  break;
2157  }
2158  case Intrinsic::lifetime_end:
2159  // Asan needs to poison memory to detect invalid access which is possible
2160  // even for empty lifetime range.
2161  if (II->getFunction()->hasFnAttribute(Attribute::SanitizeAddress) ||
2162  II->getFunction()->hasFnAttribute(Attribute::SanitizeMemory) ||
2163  II->getFunction()->hasFnAttribute(Attribute::SanitizeHWAddress))
2164  break;
2165 
2166  if (removeTriviallyEmptyRange(*II, *this, [](const IntrinsicInst &I) {
2167  return I.getIntrinsicID() == Intrinsic::lifetime_start;
2168  }))
2169  return nullptr;
2170  break;
2171  case Intrinsic::assume: {
2172  Value *IIOperand = II->getArgOperand(0);
2174  II->getOperandBundlesAsDefs(OpBundles);
2175 
2176  /// This will remove the boolean Condition from the assume given as
2177  /// argument and remove the assume if it becomes useless.
2178  /// always returns nullptr for use as a return values.
2179  auto RemoveConditionFromAssume = [&](Instruction *Assume) -> Instruction * {
2180  assert(isa<AssumeInst>(Assume));
2181  if (isAssumeWithEmptyBundle(*cast<AssumeInst>(II)))
2182  return eraseInstFromFunction(CI);
2183  replaceUse(II->getOperandUse(0), ConstantInt::getTrue(II->getContext()));
2184  return nullptr;
2185  };
2186  // Remove an assume if it is followed by an identical assume.
2187  // TODO: Do we need this? Unless there are conflicting assumptions, the
2188  // computeKnownBits(IIOperand) below here eliminates redundant assumes.
2190  if (match(Next, m_Intrinsic<Intrinsic::assume>(m_Specific(IIOperand))))
2191  return RemoveConditionFromAssume(Next);
2192 
2193  // Canonicalize assume(a && b) -> assume(a); assume(b);
2194  // Note: New assumption intrinsics created here are registered by
2195  // the InstCombineIRInserter object.
2196  FunctionType *AssumeIntrinsicTy = II->getFunctionType();
2197  Value *AssumeIntrinsic = II->getCalledOperand();
2198  Value *A, *B;
2199  if (match(IIOperand, m_LogicalAnd(m_Value(A), m_Value(B)))) {
2200  Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic, A, OpBundles,
2201  II->getName());
2202  Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic, B, II->getName());
2203  return eraseInstFromFunction(*II);
2204  }
2205  // assume(!(a || b)) -> assume(!a); assume(!b);
2206  if (match(IIOperand, m_Not(m_LogicalOr(m_Value(A), m_Value(B))))) {
2207  Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic,
2208  Builder.CreateNot(A), OpBundles, II->getName());
2209  Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic,
2210  Builder.CreateNot(B), II->getName());
2211  return eraseInstFromFunction(*II);
2212  }
2213 
2214  // assume( (load addr) != null ) -> add 'nonnull' metadata to load
2215  // (if assume is valid at the load)
2216  CmpInst::Predicate Pred;
2217  Instruction *LHS;
2218  if (match(IIOperand, m_ICmp(Pred, m_Instruction(LHS), m_Zero())) &&
2219  Pred == ICmpInst::ICMP_NE && LHS->getOpcode() == Instruction::Load &&
2220  LHS->getType()->isPointerTy() &&
2221  isValidAssumeForContext(II, LHS, &DT)) {
2222  MDNode *MD = MDNode::get(II->getContext(), None);
2223  LHS->setMetadata(LLVMContext::MD_nonnull, MD);
2224  return RemoveConditionFromAssume(II);
2225 
2226  // TODO: apply nonnull return attributes to calls and invokes
2227  // TODO: apply range metadata for range check patterns?
2228  }
2229 
2230  // Convert nonnull assume like:
2231  // %A = icmp ne i32* %PTR, null
2232  // call void @llvm.assume(i1 %A)
2233  // into
2234  // call void @llvm.assume(i1 true) [ "nonnull"(i32* %PTR) ]
2236  match(IIOperand, m_Cmp(Pred, m_Value(A), m_Zero())) &&
2237  Pred == CmpInst::ICMP_NE && A->getType()->isPointerTy()) {
2238  if (auto *Replacement = buildAssumeFromKnowledge(
2239  {RetainedKnowledge{Attribute::NonNull, 0, A}}, Next, &AC, &DT)) {
2240 
2241  Replacement->insertBefore(Next);
2242  AC.registerAssumption(Replacement);
2243  return RemoveConditionFromAssume(II);
2244  }
2245  }
2246 
2247  // Convert alignment assume like:
2248  // %B = ptrtoint i32* %A to i64
2249  // %C = and i64 %B, Constant
2250  // %D = icmp eq i64 %C, 0
2251  // call void @llvm.assume(i1 %D)
2252  // into
2253  // call void @llvm.assume(i1 true) [ "align"(i32* [[A]], i64 Constant + 1)]
2254  uint64_t AlignMask;
2256  match(IIOperand,
2257  m_Cmp(Pred, m_And(m_Value(A), m_ConstantInt(AlignMask)),
2258  m_Zero())) &&
2259  Pred == CmpInst::ICMP_EQ) {
2260  if (isPowerOf2_64(AlignMask + 1)) {
2261  uint64_t Offset = 0;
2262  match(A, m_Add(m_Value(A), m_ConstantInt(Offset)));
2263  if (match(A, m_PtrToInt(m_Value(A)))) {
2264  /// Note: this doesn't preserve the offset information but merges
2265  /// offset and alignment.
2266  /// TODO: we can generate a GEP instead of merging the alignment with
2267  /// the offset.
2268  RetainedKnowledge RK{Attribute::Alignment,
2269  (unsigned)MinAlign(Offset, AlignMask + 1), A};
2270  if (auto *Replacement =
2271  buildAssumeFromKnowledge(RK, Next, &AC, &DT)) {
2272 
2273  Replacement->insertAfter(II);
2274  AC.registerAssumption(Replacement);
2275  }
2276  return RemoveConditionFromAssume(II);
2277  }
2278  }
2279  }
2280 
2281  /// Canonicalize Knowledge in operand bundles.
2283  for (unsigned Idx = 0; Idx < II->getNumOperandBundles(); Idx++) {
2284  auto &BOI = II->bundle_op_info_begin()[Idx];
2285  RetainedKnowledge RK =
2286  llvm::getKnowledgeFromBundle(cast<AssumeInst>(*II), BOI);
2287  if (BOI.End - BOI.Begin > 2)
2288  continue; // Prevent reducing knowledge in an align with offset since
2289  // extracting a RetainedKnowledge form them looses offset
2290  // information
2291  RetainedKnowledge CanonRK =
2292  llvm::simplifyRetainedKnowledge(cast<AssumeInst>(II), RK,
2293  &getAssumptionCache(),
2294  &getDominatorTree());
2295  if (CanonRK == RK)
2296  continue;
2297  if (!CanonRK) {
2298  if (BOI.End - BOI.Begin > 0) {
2299  Worklist.pushValue(II->op_begin()[BOI.Begin]);
2300  Value::dropDroppableUse(II->op_begin()[BOI.Begin]);
2301  }
2302  continue;
2303  }
2304  assert(RK.AttrKind == CanonRK.AttrKind);
2305  if (BOI.End - BOI.Begin > 0)
2306  II->op_begin()[BOI.Begin].set(CanonRK.WasOn);
2307  if (BOI.End - BOI.Begin > 1)
2308  II->op_begin()[BOI.Begin + 1].set(ConstantInt::get(
2309  Type::getInt64Ty(II->getContext()), CanonRK.ArgValue));
2310  if (RK.WasOn)
2311  Worklist.pushValue(RK.WasOn);
2312  return II;
2313  }
2314  }
2315 
2316  // If there is a dominating assume with the same condition as this one,
2317  // then this one is redundant, and should be removed.
2318  KnownBits Known(1);
2319  computeKnownBits(IIOperand, Known, 0, II);
2320  if (Known.isAllOnes() && isAssumeWithEmptyBundle(cast<AssumeInst>(*II)))
2321  return eraseInstFromFunction(*II);
2322 
2323  // Update the cache of affected values for this assumption (we might be
2324  // here because we just simplified the condition).
2325  AC.updateAffectedValues(cast<AssumeInst>(II));
2326  break;
2327  }
2328  case Intrinsic::experimental_guard: {
2329  // Is this guard followed by another guard? We scan forward over a small
2330  // fixed window of instructions to handle common cases with conditions
2331  // computed between guards.
2332  Instruction *NextInst = II->getNextNonDebugInstruction();
2333  for (unsigned i = 0; i < GuardWideningWindow; i++) {
2334  // Note: Using context-free form to avoid compile time blow up
2335  if (!isSafeToSpeculativelyExecute(NextInst))
2336  break;
2337  NextInst = NextInst->getNextNonDebugInstruction();
2338  }
2339  Value *NextCond = nullptr;
2340  if (match(NextInst,
2341  m_Intrinsic<Intrinsic::experimental_guard>(m_Value(NextCond)))) {
2342  Value *CurrCond = II->getArgOperand(0);
2343 
2344  // Remove a guard that it is immediately preceded by an identical guard.
2345  // Otherwise canonicalize guard(a); guard(b) -> guard(a & b).
2346  if (CurrCond != NextCond) {
2347  Instruction *MoveI = II->getNextNonDebugInstruction();
2348  while (MoveI != NextInst) {
2349  auto *Temp = MoveI;
2350  MoveI = MoveI->getNextNonDebugInstruction();
2351  Temp->moveBefore(II);
2352  }
2353  replaceOperand(*II, 0, Builder.CreateAnd(CurrCond, NextCond));
2354  }
2355  eraseInstFromFunction(*NextInst);
2356  return II;
2357  }
2358  break;
2359  }
2360  case Intrinsic::experimental_vector_insert: {
2361  Value *Vec = II->getArgOperand(0);
2362  Value *SubVec = II->getArgOperand(1);
2363  Value *Idx = II->getArgOperand(2);
2364  auto *DstTy = dyn_cast<FixedVectorType>(II->getType());
2365  auto *VecTy = dyn_cast<FixedVectorType>(Vec->getType());
2366  auto *SubVecTy = dyn_cast<FixedVectorType>(SubVec->getType());
2367 
2368  // Only canonicalize if the destination vector, Vec, and SubVec are all
2369  // fixed vectors.
2370  if (DstTy && VecTy && SubVecTy) {
2371  unsigned DstNumElts = DstTy->getNumElements();
2372  unsigned VecNumElts = VecTy->getNumElements();
2373  unsigned SubVecNumElts = SubVecTy->getNumElements();
2374  unsigned IdxN = cast<ConstantInt>(Idx)->getZExtValue();
2375 
2376  // An insert that entirely overwrites Vec with SubVec is a nop.
2377  if (VecNumElts == SubVecNumElts)
2378  return replaceInstUsesWith(CI, SubVec);
2379 
2380  // Widen SubVec into a vector of the same width as Vec, since
2381  // shufflevector requires the two input vectors to be the same width.
2382  // Elements beyond the bounds of SubVec within the widened vector are
2383  // undefined.
2384  SmallVector<int, 8> WidenMask;
2385  unsigned i;
2386  for (i = 0; i != SubVecNumElts; ++i)
2387  WidenMask.push_back(i);
2388  for (; i != VecNumElts; ++i)
2389  WidenMask.push_back(UndefMaskElem);
2390 
2391  Value *WidenShuffle = Builder.CreateShuffleVector(SubVec, WidenMask);
2392 
2394  for (unsigned i = 0; i != IdxN; ++i)
2395  Mask.push_back(i);
2396  for (unsigned i = DstNumElts; i != DstNumElts + SubVecNumElts; ++i)
2397  Mask.push_back(i);
2398  for (unsigned i = IdxN + SubVecNumElts; i != DstNumElts; ++i)
2399  Mask.push_back(i);
2400 
2401  Value *Shuffle = Builder.CreateShuffleVector(Vec, WidenShuffle, Mask);
2402  return replaceInstUsesWith(CI, Shuffle);
2403  }
2404  break;
2405  }
2406  case Intrinsic::experimental_vector_extract: {
2407  Value *Vec = II->getArgOperand(0);
2408  Value *Idx = II->getArgOperand(1);
2409 
2410  auto *DstTy = dyn_cast<FixedVectorType>(II->getType());
2411  auto *VecTy = dyn_cast<FixedVectorType>(Vec->getType());
2412 
2413  // Only canonicalize if the the destination vector and Vec are fixed
2414  // vectors.
2415  if (DstTy && VecTy) {
2416  unsigned DstNumElts = DstTy->getNumElements();
2417  unsigned VecNumElts = VecTy->getNumElements();
2418  unsigned IdxN = cast<ConstantInt>(Idx)->getZExtValue();
2419 
2420  // Extracting the entirety of Vec is a nop.
2421  if (VecNumElts == DstNumElts) {
2422  replaceInstUsesWith(CI, Vec);
2423  return eraseInstFromFunction(CI);
2424  }
2425 
2427  for (unsigned i = 0; i != DstNumElts; ++i)
2428  Mask.push_back(IdxN + i);
2429 
2430  Value *Shuffle = Builder.CreateShuffleVector(Vec, Mask);
2431  return replaceInstUsesWith(CI, Shuffle);
2432  }
2433  break;
2434  }
2435  case Intrinsic::experimental_vector_reverse: {
2436  Value *BO0, *BO1, *X, *Y;
2437  Value *Vec = II->getArgOperand(0);
2438  if (match(Vec, m_OneUse(m_BinOp(m_Value(BO0), m_Value(BO1))))) {
2439  auto *OldBinOp = cast<BinaryOperator>(Vec);
2440  if (match(BO0, m_Intrinsic<Intrinsic::experimental_vector_reverse>(
2441  m_Value(X)))) {
2442  // rev(binop rev(X), rev(Y)) --> binop X, Y
2443  if (match(BO1, m_Intrinsic<Intrinsic::experimental_vector_reverse>(
2444  m_Value(Y))))
2445  return replaceInstUsesWith(CI,
2447  OldBinOp->getOpcode(), X, Y, OldBinOp,
2448  OldBinOp->getName(), II));
2449  // rev(binop rev(X), BO1Splat) --> binop X, BO1Splat
2450  if (isSplatValue(BO1))
2451  return replaceInstUsesWith(CI,
2453  OldBinOp->getOpcode(), X, BO1,
2454  OldBinOp, OldBinOp->getName(), II));
2455  }
2456  // rev(binop BO0Splat, rev(Y)) --> binop BO0Splat, Y
2457  if (match(BO1, m_Intrinsic<Intrinsic::experimental_vector_reverse>(
2458  m_Value(Y))) &&
2459  isSplatValue(BO0))
2460  return replaceInstUsesWith(CI, BinaryOperator::CreateWithCopiedFlags(
2461  OldBinOp->getOpcode(), BO0, Y,
2462  OldBinOp, OldBinOp->getName(), II));
2463  }
2464  // rev(unop rev(X)) --> unop X
2465  if (match(Vec, m_OneUse(m_UnOp(
2466  m_Intrinsic<Intrinsic::experimental_vector_reverse>(
2467  m_Value(X)))))) {
2468  auto *OldUnOp = cast<UnaryOperator>(Vec);
2469  auto *NewUnOp = UnaryOperator::CreateWithCopiedFlags(
2470  OldUnOp->getOpcode(), X, OldUnOp, OldUnOp->getName(), II);
2471  return replaceInstUsesWith(CI, NewUnOp);
2472  }
2473  break;
2474  }
2475  case Intrinsic::vector_reduce_or:
2476  case Intrinsic::vector_reduce_and: {
2477  // Canonicalize logical or/and reductions:
2478  // Or reduction for i1 is represented as:
2479  // %val = bitcast <ReduxWidth x i1> to iReduxWidth
2480  // %res = cmp ne iReduxWidth %val, 0
2481  // And reduction for i1 is represented as:
2482  // %val = bitcast <ReduxWidth x i1> to iReduxWidth
2483  // %res = cmp eq iReduxWidth %val, 11111
2484  Value *Arg = II->getArgOperand(0);
2485  Value *Vect;
2486  if (match(Arg, m_ZExtOrSExtOrSelf(m_Value(Vect)))) {
2487  if (auto *FTy = dyn_cast<FixedVectorType>(Vect->getType()))
2488  if (FTy->getElementType() == Builder.getInt1Ty()) {
2489  Value *Res = Builder.CreateBitCast(
2490  Vect, Builder.getIntNTy(FTy->getNumElements()));
2491  if (IID == Intrinsic::vector_reduce_and) {
2492  Res = Builder.CreateICmpEQ(
2493  Res, ConstantInt::getAllOnesValue(Res->getType()));
2494  } else {
2495  assert(IID == Intrinsic::vector_reduce_or &&
2496  "Expected or reduction.");
2497  Res = Builder.CreateIsNotNull(Res);
2498  }
2499  if (Arg != Vect)
2500  Res = Builder.CreateCast(cast<CastInst>(Arg)->getOpcode(), Res,
2501  II->getType());
2502  return replaceInstUsesWith(CI, Res);
2503  }
2504  }
2506  }
2507  case Intrinsic::vector_reduce_add: {
2508  if (IID == Intrinsic::vector_reduce_add) {
2509  // Convert vector_reduce_add(ZExt(<n x i1>)) to
2510  // ZExtOrTrunc(ctpop(bitcast <n x i1> to in)).
2511  // Convert vector_reduce_add(SExt(<n x i1>)) to
2512  // -ZExtOrTrunc(ctpop(bitcast <n x i1> to in)).
2513  // Convert vector_reduce_add(<n x i1>) to
2514  // Trunc(ctpop(bitcast <n x i1> to in)).
2515  Value *Arg = II->getArgOperand(0);
2516  Value *Vect;
2517  if (match(Arg, m_ZExtOrSExtOrSelf(m_Value(Vect)))) {
2518  if (auto *FTy = dyn_cast<FixedVectorType>(Vect->getType()))
2519  if (FTy->getElementType() == Builder.getInt1Ty()) {
2520  Value *V = Builder.CreateBitCast(
2521  Vect, Builder.getIntNTy(FTy->getNumElements()));
2522  Value *Res = Builder.CreateUnaryIntrinsic(Intrinsic::ctpop, V);
2523  if (Res->getType() != II->getType())
2524  Res = Builder.CreateZExtOrTrunc(Res, II->getType());
2525  if (Arg != Vect &&
2526  cast<Instruction>(Arg)->getOpcode() == Instruction::SExt)
2527  Res = Builder.CreateNeg(Res);
2528  return replaceInstUsesWith(CI, Res);
2529  }
2530  }
2531  }
2533  }
2534  case Intrinsic::vector_reduce_xor: {
2535  if (IID == Intrinsic::vector_reduce_xor) {
2536  // Exclusive disjunction reduction over the vector with
2537  // (potentially-extended) i1 element type is actually a
2538  // (potentially-extended) arithmetic `add` reduction over the original
2539  // non-extended value:
2540  // vector_reduce_xor(?ext(<n x i1>))
2541  // -->
2542  // ?ext(vector_reduce_add(<n x i1>))
2543  Value *Arg = II->getArgOperand(0);
2544  Value *Vect;
2545  if (match(Arg, m_ZExtOrSExtOrSelf(m_Value(Vect)))) {
2546  if (auto *FTy = dyn_cast<FixedVectorType>(Vect->getType()))
2547  if (FTy->getElementType() == Builder.getInt1Ty()) {
2548  Value *Res = Builder.CreateAddReduce(Vect);
2549  if (Arg != Vect)
2550  Res = Builder.CreateCast(cast<CastInst>(Arg)->getOpcode(), Res,
2551  II->getType());
2552  return replaceInstUsesWith(CI, Res);
2553  }
2554  }
2555  }
2557  }
2558  case Intrinsic::vector_reduce_mul: {
2559  if (IID == Intrinsic::vector_reduce_mul) {
2560  // Multiplicative reduction over the vector with (potentially-extended)
2561  // i1 element type is actually a (potentially zero-extended)
2562  // logical `and` reduction over the original non-extended value:
2563  // vector_reduce_mul(?ext(<n x i1>))
2564  // -->
2565  // zext(vector_reduce_and(<n x i1>))
2566  Value *Arg = II->getArgOperand(0);
2567  Value *Vect;
2568  if (match(Arg, m_ZExtOrSExtOrSelf(m_Value(Vect)))) {
2569  if (auto *FTy = dyn_cast<FixedVectorType>(Vect->getType()))
2570  if (FTy->getElementType() == Builder.getInt1Ty()) {
2571  Value *Res = Builder.CreateAndReduce(Vect);
2572  if (Res->getType() != II->getType())
2573  Res = Builder.CreateZExt(Res, II->getType());
2574  return replaceInstUsesWith(CI, Res);
2575  }
2576  }
2577  }
2579  }
2580  case Intrinsic::vector_reduce_umin:
2581  case Intrinsic::vector_reduce_umax: {
2582  if (IID == Intrinsic::vector_reduce_umin ||
2583  IID == Intrinsic::vector_reduce_umax) {
2584  // UMin/UMax reduction over the vector with (potentially-extended)
2585  // i1 element type is actually a (potentially-extended)
2586  // logical `and`/`or` reduction over the original non-extended value:
2587  // vector_reduce_u{min,max}(?ext(<n x i1>))
2588  // -->
2589  // ?ext(vector_reduce_{and,or}(<n x i1>))
2590  Value *Arg = II->getArgOperand(0);
2591  Value *Vect;
2592  if (match(Arg, m_ZExtOrSExtOrSelf(m_Value(Vect)))) {
2593  if (auto *FTy = dyn_cast<FixedVectorType>(Vect->getType()))
2594  if (FTy->getElementType() == Builder.getInt1Ty()) {
2595  Value *Res = IID == Intrinsic::vector_reduce_umin
2596  ? Builder.CreateAndReduce(Vect)
2597  : Builder.CreateOrReduce(Vect);
2598  if (Arg != Vect)
2599  Res = Builder.CreateCast(cast<CastInst>(Arg)->getOpcode(), Res,
2600  II->getType());
2601  return replaceInstUsesWith(CI, Res);
2602  }
2603  }
2604  }
2606  }
2607  case Intrinsic::vector_reduce_smin:
2608  case Intrinsic::vector_reduce_smax: {
2609  if (IID == Intrinsic::vector_reduce_smin ||
2610  IID == Intrinsic::vector_reduce_smax) {
2611  // SMin/SMax reduction over the vector with (potentially-extended)
2612  // i1 element type is actually a (potentially-extended)
2613  // logical `and`/`or` reduction over the original non-extended value:
2614  // vector_reduce_s{min,max}(<n x i1>)
2615  // -->
2616  // vector_reduce_{or,and}(<n x i1>)
2617  // and
2618  // vector_reduce_s{min,max}(sext(<n x i1>))
2619  // -->
2620  // sext(vector_reduce_{or,and}(<n x i1>))
2621  // and
2622  // vector_reduce_s{min,max}(zext(<n x i1>))
2623  // -->
2624  // zext(vector_reduce_{and,or}(<n x i1>))
2625  Value *Arg = II->getArgOperand(0);
2626  Value *Vect;
2627  if (match(Arg, m_ZExtOrSExtOrSelf(m_Value(Vect)))) {
2628  if (auto *FTy = dyn_cast<FixedVectorType>(Vect->getType()))
2629  if (FTy->getElementType() == Builder.getInt1Ty()) {
2630  Instruction::CastOps ExtOpc = Instruction::CastOps::CastOpsEnd;
2631  if (Arg != Vect)
2632  ExtOpc = cast<CastInst>(Arg)->getOpcode();
2633  Value *Res = ((IID == Intrinsic::vector_reduce_smin) ==
2634  (ExtOpc == Instruction::CastOps::ZExt))
2635  ? Builder.CreateAndReduce(Vect)
2636  : Builder.CreateOrReduce(Vect);
2637  if (Arg != Vect)
2638  Res = Builder.CreateCast(ExtOpc, Res, II->getType());
2639  return replaceInstUsesWith(CI, Res);
2640  }
2641  }
2642  }
2644  }
2645  case Intrinsic::vector_reduce_fmax:
2646  case Intrinsic::vector_reduce_fmin:
2647  case Intrinsic::vector_reduce_fadd:
2648  case Intrinsic::vector_reduce_fmul: {
2649  bool CanBeReassociated = (IID != Intrinsic::vector_reduce_fadd &&
2650  IID != Intrinsic::vector_reduce_fmul) ||
2651  II->hasAllowReassoc();
2652  const unsigned ArgIdx = (IID == Intrinsic::vector_reduce_fadd ||
2653  IID == Intrinsic::vector_reduce_fmul)
2654  ? 1
2655  : 0;
2656  Value *Arg = II->getArgOperand(ArgIdx);
2657  Value *V;
2659  if (!isa<FixedVectorType>(Arg->getType()) || !CanBeReassociated ||
2660  !match(Arg, m_Shuffle(m_Value(V), m_Undef(), m_Mask(Mask))) ||
2661  !cast<ShuffleVectorInst>(Arg)->isSingleSource())
2662  break;
2663  int Sz = Mask.size();
2664  SmallBitVector UsedIndices(Sz);
2665  for (int Idx : Mask) {
2666  if (Idx == UndefMaskElem || UsedIndices.test(Idx))
2667  break;
2668  UsedIndices.set(Idx);
2669  }
2670  // Can remove shuffle iff just shuffled elements, no repeats, undefs, or
2671  // other changes.
2672  if (UsedIndices.all()) {
2673  replaceUse(II->getOperandUse(ArgIdx), V);
2674  return nullptr;
2675  }
2676  break;
2677  }
2678  default: {
2679  // Handle target specific intrinsics
2680  Optional<Instruction *> V = targetInstCombineIntrinsic(*II);
2681  if (V.hasValue())
2682  return V.getValue();
2683  break;
2684  }
2685  }
2686 
2688  return Shuf;
2689 
2690  // Some intrinsics (like experimental_gc_statepoint) can be used in invoke
2691  // context, so it is handled in visitCallBase and we should trigger it.
2692  return visitCallBase(*II);
2693 }
2694 
2695 // Fence instruction simplification
2697  auto *NFI = dyn_cast<FenceInst>(FI.getNextNonDebugInstruction());
2698  // This check is solely here to handle arbitrary target-dependent syncscopes.
2699  // TODO: Can remove if does not matter in practice.
2700  if (NFI && FI.isIdenticalTo(NFI))
2701  return eraseInstFromFunction(FI);
2702 
2703  // Returns true if FI1 is identical or stronger fence than FI2.
2704  auto isIdenticalOrStrongerFence = [](FenceInst *FI1, FenceInst *FI2) {
2705  auto FI1SyncScope = FI1->getSyncScopeID();
2706  // Consider same scope, where scope is global or single-thread.
2707  if (FI1SyncScope != FI2->getSyncScopeID() ||
2708  (FI1SyncScope != SyncScope::System &&
2709  FI1SyncScope != SyncScope::SingleThread))
2710  return false;
2711 
2712  return isAtLeastOrStrongerThan(FI1->getOrdering(), FI2->getOrdering());
2713  };
2714  if (NFI && isIdenticalOrStrongerFence(NFI, &FI))
2715  return eraseInstFromFunction(FI);
2716 
2717  if (auto *PFI = dyn_cast_or_null<FenceInst>(FI.getPrevNonDebugInstruction()))
2718  if (isIdenticalOrStrongerFence(PFI, &FI))
2719  return eraseInstFromFunction(FI);
2720  return nullptr;
2721 }
2722 
2723 // InvokeInst simplification
2725  return visitCallBase(II);
2726 }
2727 
2728 // CallBrInst simplification
2730  return visitCallBase(CBI);
2731 }
2732 
2733 /// If this cast does not affect the value passed through the varargs area, we
2734 /// can eliminate the use of the cast.
2735 static bool isSafeToEliminateVarargsCast(const CallBase &Call,
2736  const DataLayout &DL,
2737  const CastInst *const CI,
2738  const int ix) {
2739  if (!CI->isLosslessCast())
2740  return false;
2741 
2742  // If this is a GC intrinsic, avoid munging types. We need types for
2743  // statepoint reconstruction in SelectionDAG.
2744  // TODO: This is probably something which should be expanded to all
2745  // intrinsics since the entire point of intrinsics is that
2746  // they are understandable by the optimizer.
2747  if (isa<GCStatepointInst>(Call) || isa<GCRelocateInst>(Call) ||
2748  isa<GCResultInst>(Call))
2749  return false;
2750 
2751  // Opaque pointers are compatible with any byval types.
2752  PointerType *SrcTy = cast<PointerType>(CI->getOperand(0)->getType());
2753  if (SrcTy->isOpaque())
2754  return true;
2755 
2756  // The size of ByVal or InAlloca arguments is derived from the type, so we
2757  // can't change to a type with a different size. If the size were
2758  // passed explicitly we could avoid this check.
2759  if (!Call.isPassPointeeByValueArgument(ix))
2760  return true;
2761 
2762  // The transform currently only handles type replacement for byval, not other
2763  // type-carrying attributes.
2764  if (!Call.isByValArgument(ix))
2765  return false;
2766 
2767  Type *SrcElemTy = SrcTy->getNonOpaquePointerElementType();
2768  Type *DstElemTy = Call.getParamByValType(ix);
2769  if (!SrcElemTy->isSized() || !DstElemTy->isSized())
2770  return false;
2771  if (DL.getTypeAllocSize(SrcElemTy) != DL.getTypeAllocSize(DstElemTy))
2772  return false;
2773  return true;
2774 }
2775 
2776 Instruction *InstCombinerImpl::tryOptimizeCall(CallInst *CI) {
2777  if (!CI->getCalledFunction()) return nullptr;
2778 
2779  // Skip optimizing notail and musttail calls so
2780  // LibCallSimplifier::optimizeCall doesn't have to preserve those invariants.
2781  // LibCallSimplifier::optimizeCall should try to preseve tail calls though.
2782  if (CI->isMustTailCall() || CI->isNoTailCall())
2783  return nullptr;
2784 
2785  auto InstCombineRAUW = [this](Instruction *From, Value *With) {
2786  replaceInstUsesWith(*From, With);
2787  };
2788  auto InstCombineErase = [this](Instruction *I) {
2789  eraseInstFromFunction(*I);
2790  };
2791  LibCallSimplifier Simplifier(DL, &TLI, ORE, BFI, PSI, InstCombineRAUW,
2792  InstCombineErase);
2793  if (Value *With = Simplifier.optimizeCall(CI, Builder)) {
2794  ++NumSimplified;
2795  return CI->use_empty() ? CI : replaceInstUsesWith(*CI, With);
2796  }
2797 
2798  return nullptr;
2799 }
2800 
2802  // Strip off at most one level of pointer casts, looking for an alloca. This
2803  // is good enough in practice and simpler than handling any number of casts.
2804  Value *Underlying = TrampMem->stripPointerCasts();
2805  if (Underlying != TrampMem &&
2806  (!Underlying->hasOneUse() || Underlying->user_back() != TrampMem))
2807  return nullptr;
2808  if (!isa<AllocaInst>(Underlying))
2809  return nullptr;
2810 
2811  IntrinsicInst *InitTrampoline = nullptr;
2812  for (User *U : TrampMem->users()) {
2813  IntrinsicInst *II = dyn_cast<IntrinsicInst>(U);
2814  if (!II)
2815  return nullptr;
2816  if (II->getIntrinsicID() == Intrinsic::init_trampoline) {
2817  if (InitTrampoline)
2818  // More than one init_trampoline writes to this value. Give up.
2819  return nullptr;
2820  InitTrampoline = II;
2821  continue;
2822  }
2823  if (II->getIntrinsicID() == Intrinsic::adjust_trampoline)
2824  // Allow any number of calls to adjust.trampoline.
2825  continue;
2826  return nullptr;
2827  }
2828 
2829  // No call to init.trampoline found.
2830  if (!InitTrampoline)
2831  return nullptr;
2832 
2833  // Check that the alloca is being used in the expected way.
2834  if (InitTrampoline->getOperand(0) != TrampMem)
2835  return nullptr;
2836 
2837  return InitTrampoline;
2838 }
2839 
2841  Value *TrampMem) {
2842  // Visit all the previous instructions in the basic block, and try to find a
2843  // init.trampoline which has a direct path to the adjust.trampoline.
2844  for (BasicBlock::iterator I = AdjustTramp->getIterator(),
2845  E = AdjustTramp->getParent()->begin();
2846  I != E;) {
2847  Instruction *Inst = &*--I;
2848  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I))
2849  if (II->getIntrinsicID() == Intrinsic::init_trampoline &&
2850  II->getOperand(0) == TrampMem)
2851  return II;
2852  if (Inst->mayWriteToMemory())
2853  return nullptr;
2854  }
2855  return nullptr;
2856 }
2857 
2858 // Given a call to llvm.adjust.trampoline, find and return the corresponding
2859 // call to llvm.init.trampoline if the call to the trampoline can be optimized
2860 // to a direct call to a function. Otherwise return NULL.
2862  Callee = Callee->stripPointerCasts();
2863  IntrinsicInst *AdjustTramp = dyn_cast<IntrinsicInst>(Callee);
2864  if (!AdjustTramp ||
2865  AdjustTramp->getIntrinsicID() != Intrinsic::adjust_trampoline)
2866  return nullptr;
2867 
2868  Value *TrampMem = AdjustTramp->getOperand(0);
2869 
2871  return IT;
2872  if (IntrinsicInst *IT = findInitTrampolineFromBB(AdjustTramp, TrampMem))
2873  return IT;
2874  return nullptr;
2875 }
2876 
2877 bool InstCombinerImpl::annotateAnyAllocSite(CallBase &Call,
2878  const TargetLibraryInfo *TLI) {
2879  // Note: We only handle cases which can't be driven from generic attributes
2880  // here. So, for example, nonnull and noalias (which are common properties
2881  // of some allocation functions) are expected to be handled via annotation
2882  // of the respective allocator declaration with generic attributes.
2883  bool Changed = false;
2884 
2885  if (isAllocationFn(&Call, TLI)) {
2886  uint64_t Size;
2887  ObjectSizeOpts Opts;
2888  if (getObjectSize(&Call, Size, DL, TLI, Opts) && Size > 0) {
2889  // TODO: We really should just emit deref_or_null here and then
2890  // let the generic inference code combine that with nonnull.
2891  if (Call.hasRetAttr(Attribute::NonNull)) {
2892  Changed = !Call.hasRetAttr(Attribute::Dereferenceable);
2893  Call.addRetAttr(
2894  Attribute::getWithDereferenceableBytes(Call.getContext(), Size));
2895  } else {
2896  Changed = !Call.hasRetAttr(Attribute::DereferenceableOrNull);
2898  Call.getContext(), Size));
2899  }
2900  }
2901  }
2902 
2903  // Add alignment attribute if alignment is a power of two constant.
2904  Value *Alignment = getAllocAlignment(&Call, TLI);
2905  if (!Alignment)
2906  return Changed;
2907 
2908  ConstantInt *AlignOpC = dyn_cast<ConstantInt>(Alignment);
2909  if (AlignOpC && AlignOpC->getValue().ult(llvm::Value::MaximumAlignment)) {
2910  uint64_t AlignmentVal = AlignOpC->getZExtValue();
2911  if (llvm::isPowerOf2_64(AlignmentVal)) {
2912  Align ExistingAlign = Call.getRetAlign().valueOrOne();
2913  Align NewAlign = Align(AlignmentVal);
2914  if (NewAlign > ExistingAlign) {
2915  Call.addRetAttr(
2916  Attribute::getWithAlignment(Call.getContext(), NewAlign));
2917  Changed = true;
2918  }
2919  }
2920  }
2921  return Changed;
2922 }
2923 
2924 /// Improvements for call, callbr and invoke instructions.
2925 Instruction *InstCombinerImpl::visitCallBase(CallBase &Call) {
2926  bool Changed = annotateAnyAllocSite(Call, &TLI);
2927 
2928  // Mark any parameters that are known to be non-null with the nonnull
2929  // attribute. This is helpful for inlining calls to functions with null
2930  // checks on their arguments.
2931  SmallVector<unsigned, 4> ArgNos;
2932  unsigned ArgNo = 0;
2933 
2934  for (Value *V : Call.args()) {
2935  if (V->getType()->isPointerTy() &&
2936  !Call.paramHasAttr(ArgNo, Attribute::NonNull) &&
2937  isKnownNonZero(V, DL, 0, &AC, &Call, &DT))
2938  ArgNos.push_back(ArgNo);
2939  ArgNo++;
2940  }
2941 
2942  assert(ArgNo == Call.arg_size() && "Call arguments not processed correctly.");
2943 
2944  if (!ArgNos.empty()) {
2945  AttributeList AS = Call.getAttributes();
2946  LLVMContext &Ctx = Call.getContext();
2947  AS = AS.addParamAttribute(Ctx, ArgNos,
2948  Attribute::get(Ctx, Attribute::NonNull));
2949  Call.setAttributes(AS);
2950  Changed = true;
2951  }
2952 
2953  // If the callee is a pointer to a function, attempt to move any casts to the
2954  // arguments of the call/callbr/invoke.
2955  Value *Callee = Call.getCalledOperand();
2956  Function *CalleeF = dyn_cast<Function>(Callee);
2957  if ((!CalleeF || CalleeF->getFunctionType() != Call.getFunctionType()) &&
2958  transformConstExprCastCall(Call))
2959  return nullptr;
2960 
2961  if (CalleeF) {
2962  // Remove the convergent attr on calls when the callee is not convergent.
2963  if (Call.isConvergent() && !CalleeF->isConvergent() &&
2964  !CalleeF->isIntrinsic()) {
2965  LLVM_DEBUG(dbgs() << "Removing convergent attr from instr " << Call
2966  << "\n");
2967  Call.setNotConvergent();
2968  return &Call;
2969  }
2970 
2971  // If the call and callee calling conventions don't match, and neither one
2972  // of the calling conventions is compatible with C calling convention
2973  // this call must be unreachable, as the call is undefined.
2974  if ((CalleeF->getCallingConv() != Call.getCallingConv() &&
2975  !(CalleeF->getCallingConv() == llvm::CallingConv::C &&
2977  !(Call.getCallingConv() == llvm::CallingConv::C &&
2979  // Only do this for calls to a function with a body. A prototype may
2980  // not actually end up matching the implementation's calling conv for a
2981  // variety of reasons (e.g. it may be written in assembly).
2982  !CalleeF->isDeclaration()) {
2983  Instruction *OldCall = &Call;
2984  CreateNonTerminatorUnreachable(OldCall);
2985  // If OldCall does not return void then replaceInstUsesWith poison.
2986  // This allows ValueHandlers and custom metadata to adjust itself.
2987  if (!OldCall->getType()->isVoidTy())
2988  replaceInstUsesWith(*OldCall, PoisonValue::get(OldCall->getType()));
2989  if (isa<CallInst>(OldCall))
2990  return eraseInstFromFunction(*OldCall);
2991 
2992  // We cannot remove an invoke or a callbr, because it would change thexi
2993  // CFG, just change the callee to a null pointer.
2994  cast<CallBase>(OldCall)->setCalledFunction(
2995  CalleeF->getFunctionType(),
2996  Constant::getNullValue(CalleeF->getType()));
2997  return nullptr;
2998  }
2999  }
3000 
3001  // Calling a null function pointer is undefined if a null address isn't
3002  // dereferenceable.
3003  if ((isa<ConstantPointerNull>(Callee) &&
3004  !NullPointerIsDefined(Call.getFunction())) ||
3005  isa<UndefValue>(Callee)) {
3006  // If Call does not return void then replaceInstUsesWith poison.
3007  // This allows ValueHandlers and custom metadata to adjust itself.
3008  if (!Call.getType()->isVoidTy())
3009  replaceInstUsesWith(Call, PoisonValue::get(Call.getType()));
3010 
3011  if (Call.isTerminator()) {
3012  // Can't remove an invoke or callbr because we cannot change the CFG.
3013  return nullptr;
3014  }
3015 
3016  // This instruction is not reachable, just remove it.
3017  CreateNonTerminatorUnreachable(&Call);
3018  return eraseInstFromFunction(Call);
3019  }
3020 
3021  if (IntrinsicInst *II = findInitTrampoline(Callee))
3022  return transformCallThroughTrampoline(Call, *II);
3023 
3024  // TODO: Drop this transform once opaque pointer transition is done.
3025  FunctionType *FTy = Call.getFunctionType();
3026  if (FTy->isVarArg()) {
3027  int ix = FTy->getNumParams();
3028  // See if we can optimize any arguments passed through the varargs area of
3029  // the call.
3030  for (auto I = Call.arg_begin() + FTy->getNumParams(), E = Call.arg_end();
3031  I != E; ++I, ++ix) {
3032  CastInst *CI = dyn_cast<CastInst>(*I);
3033  if (CI && isSafeToEliminateVarargsCast(Call, DL, CI, ix)) {
3034  replaceUse(*I, CI->getOperand(0));
3035 
3036  // Update the byval type to match the pointer type.
3037  // Not necessary for opaque pointers.
3038  PointerType *NewTy = cast<PointerType>(CI->getOperand(0)->getType());
3039  if (!NewTy->isOpaque() && Call.isByValArgument(ix)) {
3040  Call.removeParamAttr(ix, Attribute::ByVal);
3041  Call.addParamAttr(ix, Attribute::getWithByValType(
3042  Call.getContext(),
3043  NewTy->getNonOpaquePointerElementType()));
3044  }
3045  Changed = true;
3046  }
3047  }
3048  }
3049 
3050  if (isa<InlineAsm>(Callee) && !Call.doesNotThrow()) {
3051  InlineAsm *IA = cast<InlineAsm>(Callee);
3052  if (!IA->canThrow()) {
3053  // Normal inline asm calls cannot throw - mark them
3054  // 'nounwind'.
3055  Call.setDoesNotThrow();
3056  Changed = true;
3057  }
3058  }
3059 
3060  // Try to optimize the call if possible, we require DataLayout for most of
3061  // this. None of these calls are seen as possibly dead so go ahead and
3062  // delete the instruction now.
3063  if (CallInst *CI = dyn_cast<CallInst>(&Call)) {
3064  Instruction *I = tryOptimizeCall(CI);
3065  // If we changed something return the result, etc. Otherwise let
3066  // the fallthrough check.
3067  if (I) return eraseInstFromFunction(*I);
3068  }
3069 
3070  if (!Call.use_empty() && !Call.isMustTailCall())
3071  if (Value *ReturnedArg = Call.getReturnedArgOperand()) {
3072  Type *CallTy = Call.getType();
3073  Type *RetArgTy = ReturnedArg->getType();
3074  if (RetArgTy->canLosslesslyBitCastTo(CallTy))
3075  return replaceInstUsesWith(
3076  Call, Builder.CreateBitOrPointerCast(ReturnedArg, CallTy));
3077  }
3078 
3079  if (isAllocationFn(&Call, &TLI) &&
3080  isAllocRemovable(&cast<CallBase>(Call), &TLI))
3081  return visitAllocSite(Call);
3082 
3083  // Handle intrinsics which can be used in both call and invoke context.
3084  switch (Call.getIntrinsicID()) {
3085  case Intrinsic::experimental_gc_statepoint: {
3086  GCStatepointInst &GCSP = *cast<GCStatepointInst>(&Call);
3087  SmallPtrSet<Value *, 32> LiveGcValues;
3088  for (const GCRelocateInst *Reloc : GCSP.getGCRelocates()) {
3089  GCRelocateInst &GCR = *const_cast<GCRelocateInst *>(Reloc);
3090 
3091  // Remove the relocation if unused.
3092  if (GCR.use_empty()) {
3093  eraseInstFromFunction(GCR);
3094  continue;
3095  }
3096 
3097  Value *DerivedPtr = GCR.getDerivedPtr();
3098  Value *BasePtr = GCR.getBasePtr();
3099 
3100  // Undef is undef, even after relocation.
3101  if (isa<UndefValue>(DerivedPtr) || isa<UndefValue>(BasePtr)) {
3102  replaceInstUsesWith(GCR, UndefValue::get(GCR.getType()));
3103  eraseInstFromFunction(GCR);
3104  continue;
3105  }
3106 
3107  if (auto *PT = dyn_cast<PointerType>(GCR.getType())) {
3108  // The relocation of null will be null for most any collector.
3109  // TODO: provide a hook for this in GCStrategy. There might be some
3110  // weird collector this property does not hold for.
3111  if (isa<ConstantPointerNull>(DerivedPtr)) {
3112  // Use null-pointer of gc_relocate's type to replace it.
3113  replaceInstUsesWith(GCR, ConstantPointerNull::get(PT));
3114  eraseInstFromFunction(GCR);
3115  continue;
3116  }
3117 
3118  // isKnownNonNull -> nonnull attribute
3119  if (!GCR.hasRetAttr(Attribute::NonNull) &&
3120  isKnownNonZero(DerivedPtr, DL, 0, &AC, &Call, &DT)) {
3121  GCR.addRetAttr(Attribute::NonNull);
3122  // We discovered new fact, re-check users.
3123  Worklist.pushUsersToWorkList(GCR);
3124  }
3125  }
3126 
3127  // If we have two copies of the same pointer in the statepoint argument
3128  // list, canonicalize to one. This may let us common gc.relocates.
3129  if (GCR.getBasePtr() == GCR.getDerivedPtr() &&
3130  GCR.getBasePtrIndex() != GCR.getDerivedPtrIndex()) {
3131  auto *OpIntTy = GCR.getOperand(2)->getType();
3132  GCR.setOperand(2, ConstantInt::get(OpIntTy, GCR.getBasePtrIndex()));
3133  }
3134 
3135  // TODO: bitcast(relocate(p)) -> relocate(bitcast(p))
3136  // Canonicalize on the type from the uses to the defs
3137 
3138  // TODO: relocate((gep p, C, C2, ...)) -> gep(relocate(p), C, C2, ...)
3139  LiveGcValues.insert(BasePtr);
3140  LiveGcValues.insert(DerivedPtr);
3141  }
3144  unsigned NumOfGCLives = LiveGcValues.size();
3145  if (!Bundle.hasValue() || NumOfGCLives == Bundle->Inputs.size())
3146  break;
3147  // We can reduce the size of gc live bundle.
3149  std::vector<Value *> NewLiveGc;
3150  for (unsigned I = 0, E = Bundle->Inputs.size(); I < E; ++I) {
3151  Value *V = Bundle->Inputs[I];
3152  if (Val2Idx.count(V))
3153  continue;
3154  if (LiveGcValues.count(V)) {
3155  Val2Idx[V] = NewLiveGc.size();
3156  NewLiveGc.push_back(V);
3157  } else
3158  Val2Idx[V] = NumOfGCLives;
3159  }
3160  // Update all gc.relocates
3161  for (const GCRelocateInst *Reloc : GCSP.getGCRelocates()) {
3162  GCRelocateInst &GCR = *const_cast<GCRelocateInst *>(Reloc);
3163  Value *BasePtr = GCR.getBasePtr();
3164  assert(Val2Idx.count(BasePtr) && Val2Idx[BasePtr] != NumOfGCLives &&
3165  "Missed live gc for base pointer");
3166  auto *OpIntTy1 = GCR.getOperand(1)->getType();
3167  GCR.setOperand(1, ConstantInt::get(OpIntTy1, Val2Idx[BasePtr]));
3168  Value *DerivedPtr = GCR.getDerivedPtr();
3169  assert(Val2Idx.count(DerivedPtr) && Val2Idx[DerivedPtr] != NumOfGCLives &&
3170  "Missed live gc for derived pointer");
3171  auto *OpIntTy2 = GCR.getOperand(2)->getType();
3172  GCR.setOperand(2, ConstantInt::get(OpIntTy2, Val2Idx[DerivedPtr]));
3173  }
3174  // Create new statepoint instruction.
3175  OperandBundleDef NewBundle("gc-live", NewLiveGc);
3176  return CallBase::Create(&Call, NewBundle);
3177  }
3178  default: { break; }
3179  }
3180 
3181  return Changed ? &Call : nullptr;
3182 }
3183 
3184 /// If the callee is a constexpr cast of a function, attempt to move the cast to
3185 /// the arguments of the call/callbr/invoke.
3186 bool InstCombinerImpl::transformConstExprCastCall(CallBase &Call) {
3187  auto *Callee =
3188  dyn_cast<Function>(Call.getCalledOperand()->stripPointerCasts());
3189  if (!Callee)
3190  return false;
3191 
3192  // If this is a call to a thunk function, don't remove the cast. Thunks are
3193  // used to transparently forward all incoming parameters and outgoing return
3194  // values, so it's important to leave the cast in place.
3195  if (Callee->hasFnAttribute("thunk"))
3196  return false;
3197 
3198  // If this is a musttail call, the callee's prototype must match the caller's
3199  // prototype with the exception of pointee types. The code below doesn't
3200  // implement that, so we can't do this transform.
3201  // TODO: Do the transform if it only requires adding pointer casts.
3202  if (Call.isMustTailCall())
3203  return false;
3204 
3205  Instruction *Caller = &Call;
3206  const AttributeList &CallerPAL = Call.getAttributes();
3207 
3208  // Okay, this is a cast from a function to a different type. Unless doing so
3209  // would cause a type conversion of one of our arguments, change this call to
3210  // be a direct call with arguments casted to the appropriate types.
3212  Type *OldRetTy = Caller->getType();
3213  Type *NewRetTy = FT->getReturnType();
3214 
3215  // Check to see if we are changing the return type...
3216  if (OldRetTy != NewRetTy) {
3217 
3218  if (NewRetTy->isStructTy())
3219  return false; // TODO: Handle multiple return values.
3220 
3221  if (!CastInst::isBitOrNoopPointerCastable(NewRetTy, OldRetTy, DL)) {
3222  if (Callee->isDeclaration())
3223  return false; // Cannot transform this return value.
3224 
3225  if (!Caller->use_empty() &&
3226  // void -> non-void is handled specially
3227  !NewRetTy->isVoidTy())
3228  return false; // Cannot transform this return value.
3229  }
3230 
3231  if (!CallerPAL.isEmpty() && !Caller->use_empty()) {
3232  AttrBuilder RAttrs(FT->getContext(), CallerPAL.getRetAttrs());
3233  if (RAttrs.overlaps(AttributeFuncs::typeIncompatible(NewRetTy)))
3234  return false; // Attribute not compatible with transformed value.
3235  }
3236 
3237  // If the callbase is an invoke/callbr instruction, and the return value is
3238  // used by a PHI node in a successor, we cannot change the return type of
3239  // the call because there is no place to put the cast instruction (without
3240  // breaking the critical edge). Bail out in this case.
3241  if (!Caller->use_empty()) {
3242  if (InvokeInst *II = dyn_cast<InvokeInst>(Caller))
3243  for (User *U : II->users())
3244  if (PHINode *PN = dyn_cast<PHINode>(U))
3245  if (PN->getParent() == II->getNormalDest() ||
3246  PN->getParent() == II->getUnwindDest())
3247  return false;
3248  // FIXME: Be conservative for callbr to avoid a quadratic search.
3249  if (isa<CallBrInst>(Caller))
3250  return false;
3251  }
3252  }
3253 
3254  unsigned NumActualArgs = Call.arg_size();
3255  unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs);
3256 
3257  // Prevent us turning:
3258  // declare void @takes_i32_inalloca(i32* inalloca)
3259  // call void bitcast (void (i32*)* @takes_i32_inalloca to void (i32)*)(i32 0)
3260  //
3261  // into:
3262  // call void @takes_i32_inalloca(i32* null)
3263  //
3264  // Similarly, avoid folding away bitcasts of byval calls.
3265  if (Callee->getAttributes().hasAttrSomewhere(Attribute::InAlloca) ||
3266  Callee->getAttributes().hasAttrSomewhere(Attribute::Preallocated))
3267  return false;
3268 
3269  auto AI = Call.arg_begin();
3270  for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) {
3271  Type *ParamTy = FT->getParamType(i);
3272  Type *ActTy = (*AI)->getType();
3273 
3274  if (!CastInst::isBitOrNoopPointerCastable(ActTy, ParamTy, DL))
3275  return false; // Cannot transform this parameter value.
3276 
3277  // Check if there are any incompatible attributes we cannot drop safely.
3278  if (AttrBuilder(FT->getContext(), CallerPAL.getParamAttrs(i))
3281  return false; // Attribute not compatible with transformed value.
3282 
3283  if (Call.isInAllocaArgument(i) ||
3284  CallerPAL.hasParamAttr(i, Attribute::Preallocated))
3285  return false; // Cannot transform to and from inalloca/preallocated.
3286 
3287  if (CallerPAL.hasParamAttr(i, Attribute::SwiftError))
3288  return false;
3289 
3290  // If the parameter is passed as a byval argument, then we have to have a
3291  // sized type and the sized type has to have the same size as the old type.
3292  if (ParamTy != ActTy && CallerPAL.hasParamAttr(i, Attribute::ByVal)) {
3293  PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
3294  if (!ParamPTy)
3295  return false;
3296 
3297  if (!ParamPTy->isOpaque()) {
3298  Type *ParamElTy = ParamPTy->getNonOpaquePointerElementType();
3299  if (!ParamElTy->isSized())
3300  return false;
3301 
3302  Type *CurElTy = Call.getParamByValType(i);
3303  if (DL.getTypeAllocSize(CurElTy) != DL.getTypeAllocSize(ParamElTy))
3304  return false;
3305  }
3306  }
3307  }
3308 
3309  if (Callee->isDeclaration()) {
3310  // Do not delete arguments unless we have a function body.
3311  if (FT->getNumParams() < NumActualArgs && !FT->isVarArg())
3312  return false;
3313 
3314  // If the callee is just a declaration, don't change the varargsness of the
3315  // call. We don't want to introduce a varargs call where one doesn't
3316  // already exist.
3317  if (FT->isVarArg() != Call.getFunctionType()->isVarArg())
3318  return false;
3319 
3320  // If both the callee and the cast type are varargs, we still have to make
3321  // sure the number of fixed parameters are the same or we have the same
3322  // ABI issues as if we introduce a varargs call.
3323  if (FT->isVarArg() && Call.getFunctionType()->isVarArg() &&
3324  FT->getNumParams() != Call.getFunctionType()->getNumParams())
3325  return false;
3326  }
3327 
3328  if (FT->getNumParams() < NumActualArgs && FT->isVarArg() &&
3329  !CallerPAL.isEmpty()) {
3330  // In this case we have more arguments than the new function type, but we
3331  // won't be dropping them. Check that these extra arguments have attributes
3332  // that are compatible with being a vararg call argument.
3333  unsigned SRetIdx;
3334  if (CallerPAL.hasAttrSomewhere(Attribute::StructRet, &SRetIdx) &&
3335  SRetIdx - AttributeList::FirstArgIndex >= FT->getNumParams())
3336  return false;
3337  }
3338 
3339  // Okay, we decided that this is a safe thing to do: go ahead and start
3340  // inserting cast instructions as necessary.
3343  Args.reserve(NumActualArgs);
3344  ArgAttrs.reserve(NumActualArgs);
3345 
3346  // Get any return attributes.
3347  AttrBuilder RAttrs(FT->getContext(), CallerPAL.getRetAttrs());
3348 
3349  // If the return value is not being used, the type may not be compatible
3350  // with the existing attributes. Wipe out any problematic attributes.
3351  RAttrs.remove(AttributeFuncs::typeIncompatible(NewRetTy));
3352 
3353  LLVMContext &Ctx = Call.getContext();
3354  AI = Call.arg_begin();
3355  for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) {
3356  Type *ParamTy = FT->getParamType(i);
3357 
3358  Value *NewArg = *AI;
3359  if ((*AI)->getType() != ParamTy)
3360  NewArg = Builder.CreateBitOrPointerCast(*AI, ParamTy);
3361  Args.push_back(NewArg);
3362 
3363  // Add any parameter attributes except the ones incompatible with the new
3364  // type. Note that we made sure all incompatible ones are safe to drop.
3365  AttributeMask IncompatibleAttrs = AttributeFuncs::typeIncompatible(
3367  if (CallerPAL.hasParamAttr(i, Attribute::ByVal) &&
3368  !ParamTy->isOpaquePointerTy()) {
3369  AttrBuilder AB(Ctx, CallerPAL.getParamAttrs(i).removeAttributes(
3370  Ctx, IncompatibleAttrs));
3371  AB.addByValAttr(ParamTy->getNonOpaquePointerElementType());
3372  ArgAttrs.push_back(AttributeSet::get(Ctx, AB));
3373  } else {
3374  ArgAttrs.push_back(
3375  CallerPAL.getParamAttrs(i).removeAttributes(Ctx, IncompatibleAttrs));
3376  }
3377  }
3378 
3379  // If the function takes more arguments than the call was taking, add them
3380  // now.
3381  for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i) {
3382  Args.push_back(Constant::getNullValue(FT->getParamType(i)));
3383  ArgAttrs.push_back(AttributeSet());
3384  }
3385 
3386  // If we are removing arguments to the function, emit an obnoxious warning.
3387  if (FT->getNumParams() < NumActualArgs) {
3388  // TODO: if (!FT->isVarArg()) this call may be unreachable. PR14722
3389  if (FT->isVarArg()) {
3390  // Add all of the arguments in their promoted form to the arg list.
3391  for (unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) {
3392  Type *PTy = getPromotedType((*AI)->getType());
3393  Value *NewArg = *AI;
3394  if (PTy != (*AI)->getType()) {
3395  // Must promote to pass through va_arg area!
3396  Instruction::CastOps opcode =
3397  CastInst::getCastOpcode(*AI, false, PTy, false);
3398  NewArg = Builder.CreateCast(opcode, *AI, PTy);
3399  }
3400  Args.push_back(NewArg);
3401 
3402  // Add any parameter attributes.
3403  ArgAttrs.push_back(CallerPAL.getParamAttrs(i));
3404  }
3405  }
3406  }
3407 
3408  AttributeSet FnAttrs = CallerPAL.getFnAttrs();
3409 
3410  if (NewRetTy->isVoidTy())
3411  Caller->setName(""); // Void type should not have a name.
3412 
3413  assert((ArgAttrs.size() == FT->getNumParams() || FT->isVarArg()) &&
3414  "missing argument attributes");
3415  AttributeList NewCallerPAL = AttributeList::get(
3416  Ctx, FnAttrs, AttributeSet::get(Ctx, RAttrs), ArgAttrs);
3417 
3419  Call.getOperandBundlesAsDefs(OpBundles);
3420 
3421  CallBase *NewCall;
3422  if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
3423  NewCall = Builder.CreateInvoke(Callee, II->getNormalDest(),
3424  II->getUnwindDest(), Args, OpBundles);
3425  } else if (CallBrInst *CBI = dyn_cast<CallBrInst>(Caller)) {
3426  NewCall = Builder.CreateCallBr(Callee, CBI->getDefaultDest(),
3427  CBI->getIndirectDests(), Args, OpBundles);
3428  } else {
3429  NewCall = Builder.CreateCall(Callee, Args, OpBundles);
3430  cast<CallInst>(NewCall)->setTailCallKind(
3431  cast<CallInst>(Caller)->getTailCallKind());
3432  }
3433  NewCall->takeName(Caller);
3434  NewCall->setCallingConv(Call.getCallingConv());
3435  NewCall->setAttributes(NewCallerPAL);
3436 
3437  // Preserve prof metadata if any.
3438  NewCall->copyMetadata(*Caller, {LLVMContext::MD_prof});
3439 
3440  // Insert a cast of the return type as necessary.
3441  Instruction *NC = NewCall;
3442  Value *NV = NC;
3443  if (OldRetTy != NV->getType() && !Caller->use_empty()) {
3444  if (!NV->getType()->isVoidTy()) {
3445  NV = NC = CastInst::CreateBitOrPointerCast(NC, OldRetTy);
3446  NC->setDebugLoc(Caller->getDebugLoc());
3447 
3448  // If this is an invoke/callbr instruction, we should insert it after the
3449  // first non-phi instruction in the normal successor block.
3450  if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
3451  BasicBlock::iterator I = II->getNormalDest()->getFirstInsertionPt();
3452  InsertNewInstBefore(NC, *I);
3453  } else if (CallBrInst *CBI = dyn_cast<CallBrInst>(Caller)) {
3454  BasicBlock::iterator I = CBI->getDefaultDest()->getFirstInsertionPt();
3455  InsertNewInstBefore(NC, *I);
3456  } else {
3457  // Otherwise, it's a call, just insert cast right after the call.
3458  InsertNewInstBefore(NC, *Caller);
3459  }
3460  Worklist.pushUsersToWorkList(*Caller);
3461  } else {
3462  NV = UndefValue::get(Caller->getType());
3463  }
3464  }
3465 
3466  if (!Caller->use_empty())
3467  replaceInstUsesWith(*Caller, NV);
3468  else if (Caller->hasValueHandle()) {
3469  if (OldRetTy == NV->getType())
3471  else
3472  // We cannot call ValueIsRAUWd with a different type, and the
3473  // actual tracked value will disappear.
3475  }
3476 
3477  eraseInstFromFunction(*Caller);
3478  return true;
3479 }
3480 
3481 /// Turn a call to a function created by init_trampoline / adjust_trampoline
3482 /// intrinsic pair into a direct call to the underlying function.
3483 Instruction *
3484 InstCombinerImpl::transformCallThroughTrampoline(CallBase &Call,
3485  IntrinsicInst &Tramp) {
3486  Value *Callee = Call.getCalledOperand();
3487  Type *CalleeTy = Callee->getType();
3488  FunctionType *FTy = Call.getFunctionType();
3489  AttributeList Attrs = Call.getAttributes();
3490 
3491  // If the call already has the 'nest' attribute somewhere then give up -
3492  // otherwise 'nest' would occur twice after splicing in the chain.
3493  if (Attrs.hasAttrSomewhere(Attribute::Nest))
3494  return nullptr;
3495 
3496  Function *NestF = cast<Function>(Tramp.getArgOperand(1)->stripPointerCasts());
3497  FunctionType *NestFTy = NestF->getFunctionType();
3498 
3499  AttributeList NestAttrs = NestF->getAttributes();
3500  if (!NestAttrs.isEmpty()) {
3501  unsigned NestArgNo = 0;
3502  Type *NestTy = nullptr;
3503  AttributeSet NestAttr;
3504 
3505  // Look for a parameter marked with the 'nest' attribute.
3506  for (FunctionType::param_iterator I = NestFTy->param_begin(),
3507  E = NestFTy->param_end();
3508  I != E; ++NestArgNo, ++I) {
3509  AttributeSet AS = NestAttrs.getParamAttrs(NestArgNo);
3510  if (AS.hasAttribute(Attribute::Nest)) {
3511  // Record the parameter type and any other attributes.
3512  NestTy = *I;
3513  NestAttr = AS;
3514  break;
3515  }
3516  }
3517 
3518  if (NestTy) {
3519  std::vector<Value*> NewArgs;
3520  std::vector<AttributeSet> NewArgAttrs;
3521  NewArgs.reserve(Call.arg_size() + 1);
3522  NewArgAttrs.reserve(Call.arg_size());
3523 
3524  // Insert the nest argument into the call argument list, which may
3525  // mean appending it. Likewise for attributes.
3526 
3527  {
3528  unsigned ArgNo = 0;
3529  auto I = Call.arg_begin(), E = Call.arg_end();
3530  do {
3531  if (ArgNo == NestArgNo) {
3532  // Add the chain argument and attributes.
3533  Value *NestVal = Tramp.getArgOperand(2);
3534  if (NestVal->getType() != NestTy)
3535  NestVal = Builder.CreateBitCast(NestVal, NestTy, "nest");
3536  NewArgs.push_back(NestVal);
3537  NewArgAttrs.push_back(NestAttr);
3538  }
3539 
3540  if (I == E)
3541  break;
3542 
3543  // Add the original argument and attributes.
3544  NewArgs.push_back(*I);
3545  NewArgAttrs.push_back(Attrs.getParamAttrs(ArgNo));
3546 
3547  ++ArgNo;
3548  ++I;
3549  } while (true);
3550  }
3551 
3552  // The trampoline may have been bitcast to a bogus type (FTy).
3553  // Handle this by synthesizing a new function type, equal to FTy
3554  // with the chain parameter inserted.
3555 
3556  std::vector<Type*> NewTypes;
3557  NewTypes.reserve(FTy->getNumParams()+1);
3558 
3559  // Insert the chain's type into the list of parameter types, which may
3560  // mean appending it.
3561  {
3562  unsigned ArgNo = 0;
3564  E = FTy->param_end();
3565 
3566  do {
3567  if (ArgNo == NestArgNo)
3568  // Add the chain's type.
3569  NewTypes.push_back(NestTy);
3570 
3571  if (I == E)
3572  break;
3573 
3574  // Add the original type.
3575  NewTypes.push_back(*I);
3576 
3577  ++ArgNo;
3578  ++I;
3579  } while (true);
3580  }
3581 
3582  // Replace the trampoline call with a direct call. Let the generic
3583  // code sort out any function type mismatches.
3584  FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes,
3585  FTy->isVarArg());
3586  Constant *NewCallee =
3587  NestF->getType() == PointerType::getUnqual(NewFTy) ?
3588  NestF : ConstantExpr::getBitCast(NestF,
3589  PointerType::getUnqual(NewFTy));
3590  AttributeList NewPAL =
3591  AttributeList::get(FTy->getContext(), Attrs.getFnAttrs(),
3592  Attrs.getRetAttrs(), NewArgAttrs);
3593 
3595  Call.getOperandBundlesAsDefs(OpBundles);
3596 
3597  Instruction *NewCaller;
3598  if (InvokeInst *II = dyn_cast<InvokeInst>(&Call)) {
3599  NewCaller = InvokeInst::Create(NewFTy, NewCallee,
3600  II->getNormalDest(), II->getUnwindDest(),
3601  NewArgs, OpBundles);
3602  cast<InvokeInst>(NewCaller)->setCallingConv(II->getCallingConv());
3603  cast<InvokeInst>(NewCaller)->setAttributes(NewPAL);
3604  } else if (CallBrInst *CBI = dyn_cast<CallBrInst>(&Call)) {
3605  NewCaller =
3606  CallBrInst::Create(NewFTy, NewCallee, CBI->getDefaultDest(),
3607  CBI->getIndirectDests(), NewArgs, OpBundles);
3608  cast<CallBrInst>(NewCaller)->setCallingConv(CBI->getCallingConv());
3609  cast<CallBrInst>(NewCaller)->setAttributes(NewPAL);
3610  } else {
3611  NewCaller = CallInst::Create(NewFTy, NewCallee, NewArgs, OpBundles);
3612  cast<CallInst>(NewCaller)->setTailCallKind(
3613  cast<CallInst>(Call).getTailCallKind());
3614  cast<CallInst>(NewCaller)->setCallingConv(
3615  cast<CallInst>(Call).getCallingConv());
3616  cast<CallInst>(NewCaller)->setAttributes(NewPAL);
3617  }
3618  NewCaller->setDebugLoc(Call.getDebugLoc());
3619 
3620  return NewCaller;
3621  }
3622  }
3623 
3624  // Replace the trampoline call with a direct call. Since there is no 'nest'
3625  // parameter, there is no need to adjust the argument list. Let the generic
3626  // code sort out any function type mismatches.
3627  Constant *NewCallee = ConstantExpr::getBitCast(NestF, CalleeTy);
3628  Call.setCalledFunction(FTy, NewCallee);
3629  return &Call;
3630 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:76
llvm::Instruction::getPrevNonDebugInstruction
const Instruction * getPrevNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the previous non-debug instruction in the same basic block as 'this',...
Definition: Instruction.cpp:748
llvm::RetainedKnowledge::WasOn
Value * WasOn
Definition: AssumeBundleQueries.h:103
i
i
Definition: README.txt:29
llvm::CallBase::getNumOperandBundles
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
Definition: InstrTypes.h:1940
llvm::LLVMContext::OB_gc_live
@ OB_gc_live
Definition: LLVMContext.h:95
llvm::SmallBitVector::set
SmallBitVector & set()
Definition: SmallBitVector.h:366
AssumptionCache.h
llvm::BinaryOpIntrinsic::getBinaryOp
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
Definition: IntrinsicInst.cpp:657
llvm::PatternMatch::m_FShr
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
Definition: PatternMatch.h:2211
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::Type::isSized
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:264
llvm::Function::isIntrinsic
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition: Function.h:210
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:104
MathExtras.h
llvm::APInt::sadd_ov
APInt sadd_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:1944
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::maskIsAllOneOrUndef
bool maskIsAllOneOrUndef(Value *Mask)
Given a mask vector of i1, Return true if all of the elements of this predicate mask are known to be ...
Definition: VectorUtils.cpp:1044
llvm::CallBase::getOperandBundlesAsDefs
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Definition: Instructions.cpp:396
llvm::InvokeInst::Create
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:3820
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::Instruction::getModule
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:65
llvm::Value::dropDroppableUse
static void dropDroppableUse(Use &U)
Remove the droppable use U.
Definition: Value.cpp:213
llvm::CmpInst::ICMP_EQ
@ ICMP_EQ
equal
Definition: InstrTypes.h:740
llvm::none_of
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1619
llvm::OverflowResult::NeverOverflows
@ NeverOverflows
Never overflows.
llvm::CallBase::getOperandBundle
Optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Definition: InstrTypes.h:2027
Optional.h
llvm::MaskedValueIsZero
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if 'V & Mask' is known to be zero.
Definition: ValueTracking.cpp:391
llvm::PatternMatch::m_Mask
Definition: PatternMatch.h:1524
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::ISD::OR
@ OR
Definition: ISDOpcodes.h:667
llvm::Value::hasOneUse
bool hasOneUse() const
Return true if there is exactly one use of this value.
Definition: Value.h:434
InstCombiner.h
llvm::Intrinsic::getDeclaration
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:1410
Metadata.h
llvm::AttributeList::hasAttrSomewhere
bool hasAttrSomewhere(Attribute::AttrKind Kind, unsigned *Index=nullptr) const
Return true if the specified attribute is set for at least one parameter or for the return value.
Definition: Attributes.cpp:1386
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:719
llvm::Value::MaximumAlignment
static constexpr uint64_t MaximumAlignment
Definition: Value.h:793
llvm::BasicBlock::iterator
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:87
llvm::isSafeToSpeculativelyExecute
bool isSafeToSpeculativelyExecute(const Value *V, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
Definition: ValueTracking.cpp:4576
llvm::ConstantInt::getType
IntegerType * getType() const
getType - Specialize the getType() method to always return an IntegerType, which reduces the amount o...
Definition: Constants.h:173
llvm::InstCombiner::getDominatorTree
DominatorTree & getDominatorTree() const
Definition: InstCombiner.h:370
IntrinsicInst.h
llvm::Type::isPointerTy
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:218
ceil
We have fiadd patterns now but the followings have the same cost and complexity We need a way to specify the later is more profitable def def The FP stackifier should handle simple permutates to reduce number of shuffle e g ceil
Definition: README-FPStack.txt:54
AtomicOrdering.h
llvm::ElementCount
Definition: TypeSize.h:390
llvm::ConstantExpr::getZExt
static Constant * getZExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2148
llvm::Instruction::getNextNonDebugInstruction
const Instruction * getNextNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the next non-debug instruction in the same basic block as 'this',...
Definition: Instruction.cpp:740
Loads.h
GuardWideningWindow
static cl::opt< unsigned > GuardWideningWindow("instcombine-guard-widening-window", cl::init(3), cl::desc("How wide an instruction window to bypass looking for " "another guard"))
llvm::Function
Definition: Function.h:60
llvm::ConstantStruct::get
static Constant * get(StructType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:1347
llvm::AttributeFuncs::ASK_UNSAFE_TO_DROP
@ ASK_UNSAFE_TO_DROP
Definition: Attributes.h:1216
llvm::BinaryOperator::CreateWithCopiedFlags
static BinaryOperator * CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, Instruction *CopyO, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: InstrTypes.h:249
llvm::BinaryOperator::CreateNot
static BinaryOperator * CreateNot(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: Instructions.cpp:2834
llvm::IntrinsicInst::getIntrinsicID
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:53
llvm::SelectPatternResult::Flavor
SelectPatternFlavor Flavor
Definition: ValueTracking.h:700
llvm::CallBase::setCalledFunction
void setCalledFunction(Function *Fn)
Sets the function called, including updating the function type.
Definition: InstrTypes.h:1435
llvm::possiblyDemandedEltsInMask
APInt possiblyDemandedEltsInMask(Value *Mask)
Given a mask vector of the form <Y x i1>, return an APInt (of bitwidth Y) for each lane which may be ...
Definition: VectorUtils.cpp:1072
llvm::X86AS::SS
@ SS
Definition: X86.h:189
llvm::PointerType::get
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
Definition: Type.cpp:727
minimum
Should compile r2 movcc movcs str strb mov lr r1 movcs movcc mov lr r1 str mov mov cmp r1 movlo r2 str bx lr r0 mov mov cmp r0 movhs r2 mov r1 bx lr Some of the NEON intrinsics may be appropriate for more general either as target independent intrinsics or perhaps elsewhere in the ARM backend Some of them may also be lowered to target independent and perhaps some new SDNodes could be added For minimum
Definition: README.txt:489
llvm::KnownBits::Zero
APInt Zero
Definition: KnownBits.h:24
C1
instcombine should handle this C2 when C1
Definition: README.txt:263
llvm::Attribute::get
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Definition: Attributes.cpp:91
llvm::Type::getScalarType
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.h:309
llvm::ConstantInt::getValue
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:133
llvm::BinaryOpIntrinsic::getRHS
Value * getRHS() const
Definition: IntrinsicInst.h:664
llvm::ConstantExpr::getSExt
static Constant * getSExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2134
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::InstCombiner::Builder
BuilderTy & Builder
Definition: InstCombiner.h:58
Statistic.h
llvm::PatternMatch::m_SpecificMask
Definition: PatternMatch.h:1539
InlineAsm.h
llvm::AttributeList::addParamAttribute
LLVM_NODISCARD AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
Definition: Attributes.h:544
llvm::ConstantExpr::getICmp
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:2527
llvm::BinaryOperator::CreateFDivFMF
static BinaryOperator * CreateFDivFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
Definition: InstrTypes.h:272
llvm::PatternMatch::m_Add
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:988
llvm::BinaryOpIntrinsic::getLHS
Value * getLHS() const
Definition: IntrinsicInst.h:663
llvm::getSplatValue
Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
Definition: VectorUtils.cpp:371
ErrorHandling.h
llvm::CmpInst::makeCmpResultType
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Definition: InstrTypes.h:1044
llvm::Type::getPointerAddressSpace
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:729
llvm::IRBuilder< TargetFolder, IRBuilderCallbackInserter >
llvm::InsertValueInst::Create
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:2561
llvm::X86::SecondMacroFusionInstKind::AB
@ AB
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::CastInst::Create
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 ...
Definition: Instructions.cpp:3180
llvm::CmpInst::ICMP_NE
@ ICMP_NE
not equal
Definition: InstrTypes.h:741
llvm::SimplifyConstrainedFPCall
Value * SimplifyConstrainedFPCall(CallBase *Call, const SimplifyQuery &Q)
Given a constrained FP intrinsic call, tries to compute its simplified version.
Definition: InstructionSimplify.cpp:6253
llvm::ConstantExpr::getBitCast
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2258
llvm::FunctionType::get
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:361
llvm::SignBitMustBeZero
bool SignBitMustBeZero(const Value *V, const TargetLibraryInfo *TLI)
Return true if we can prove that the specified FP value's sign bit is 0.
Definition: ValueTracking.cpp:3636
ValueTracking.h
llvm::isAssumeWithEmptyBundle
bool isAssumeWithEmptyBundle(AssumeInst &Assume)
Return true iff the operand bundles of the provided llvm.assume doesn't contain any valuable informat...
Definition: AssumeBundleQueries.cpp:125
Local.h
llvm::AttributeList::get
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:1015
llvm::ComputeMaxSignificantBits
unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Get the upper bound on bit size for this Value Op as a signed integer.
Definition: ValueTracking.cpp:423
llvm::ConstantExpr::getSelect
static Constant * getSelect(Constant *C, Constant *V1, Constant *V2, Type *OnlyIfReducedTy=nullptr)
Select constant expr.
Definition: Constants.cpp:2445
llvm::PatternMatch::m_APFloat
apfloat_match m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
Definition: PatternMatch.h:287
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
llvm::minimum
LLVM_READONLY APFloat minimum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2018 minimum semantics.
Definition: APFloat.h:1317
llvm::IRBuilderBase::CreateUnaryIntrinsic
CallInst * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
Definition: IRBuilder.cpp:840
reassociateMinMaxWithConstants
static Instruction * reassociateMinMaxWithConstants(IntrinsicInst *II)
If this min/max has a constant operand and an operand that is a matching min/max with a constant oper...
Definition: InstCombineCalls.cpp:975
llvm::PatternMatch::m_BitReverse
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
Definition: PatternMatch.h:2172
llvm::isKnownNonZero
bool isKnownNonZero(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given value is known to be non-zero when defined.
Definition: ValueTracking.cpp:340
llvm::ConstantInt::getLimitedValue
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:244
APInt.h
llvm::IRBuilderBase::CreateStripInvariantGroup
Value * CreateStripInvariantGroup(Value *Ptr)
Create a strip.invariant.group intrinsic call.
Definition: IRBuilder.cpp:1045
llvm::PatternMatch::m_NegZeroFP
cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()
Match a floating-point negative zero.
Definition: PatternMatch.h:692
llvm::InstCombinerImpl::visitInvokeInst
Instruction * visitInvokeInst(InvokeInst &II)
Definition: InstCombineCalls.cpp:2724
llvm::CmpInst::ICMP_SGT
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:746
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::OverflowResult::AlwaysOverflowsLow
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
llvm::APInt::getBitWidth
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1423
llvm::InstCombinerImpl::visitCallInst
Instruction * visitCallInst(CallInst &CI)
CallInst simplification.
Definition: InstCombineCalls.cpp:1136
MemoryBuiltins.h
llvm::AttributeList
Definition: Attributes.h:408
llvm::AttributeMask
Definition: Attributes.h:944
foldShuffledIntrinsicOperands
static Instruction * foldShuffledIntrinsicOperands(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
If all arguments of the intrinsic are unary shuffles with the same mask, try to shuffle after the int...
Definition: InstCombineCalls.cpp:1086
llvm::OperandBundleDefT
A container for an operand bundle being viewed as a set of values rather than a set of uses.
Definition: InstrTypes.h:1127
llvm::CallBase::getFunctionType
FunctionType * getFunctionType() const
Definition: InstrTypes.h:1254
llvm::simplifyRetainedKnowledge
RetainedKnowledge simplifyRetainedKnowledge(AssumeInst *Assume, RetainedKnowledge RK, AssumptionCache *AC, DominatorTree *DT)
canonicalize the RetainedKnowledge RK.
Definition: AssumeBundleBuilder.cpp:316
llvm::FastMathFlags::noSignedZeros
bool noSignedZeros() const
Definition: FMF.h:69
llvm::AttributeList::getFnAttrs
AttributeSet getFnAttrs() const
The function attributes are returned.
Definition: Attributes.cpp:1361
llvm::GCRelocateInst::getBasePtrIndex
unsigned getBasePtrIndex() const
The index into the associate statepoint's argument list which contains the base pointer of the pointe...
Definition: IntrinsicInst.h:1382
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
llvm::PatternMatch::m_ZExtOrSExtOrSelf
match_combine_or< match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > >, OpTy > m_ZExtOrSExtOrSelf(const OpTy &Op)
Definition: PatternMatch.h:1667
llvm::EnableKnowledgeRetention
cl::opt< bool > EnableKnowledgeRetention
enable preservation of attributes in assume like: call void @llvm.assume(i1 true) [ "nonnull"(i32* PT...
Definition: InstCombineCalls.cpp:94
llvm::InstCombinerImpl::replaceInstUsesWith
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
Definition: InstCombineInternal.h:404
llvm::IRBuilderBase::CreateBinaryIntrinsic
CallInst * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
Definition: IRBuilder.cpp:848
llvm::Optional< bool >
foldCttzCtlz
static Instruction * foldCttzCtlz(IntrinsicInst &II, InstCombinerImpl &IC)
Definition: InstCombineCalls.cpp:503
llvm::DenseMapBase::count
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:147
llvm::CastInst::getCastOpcode
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.
Definition: Instructions.cpp:3462
llvm::FenceInst
An instruction for ordering other memory operations.
Definition: Instructions.h:445
llvm::PatternMatch::m_BinOp
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
Definition: PatternMatch.h:84
llvm::ConstantAsMetadata::get
static ConstantAsMetadata * get(Constant *C)
Definition: Metadata.h:420
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
llvm::ore::NV
DiagnosticInfoOptimizationBase::Argument NV
Definition: OptimizationRemarkEmitter.h:136
llvm::Instruction::copyMetadata
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
Definition: Instruction.cpp:841
llvm::FunctionType::getNumParams
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
llvm::CastInst::CreateIntegerCast
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.
Definition: Instructions.cpp:3346
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::SmallBitVector::test
bool test(unsigned Idx) const
Definition: SmallBitVector.h:472
llvm::isPowerOf2_32
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
Definition: MathExtras.h:491
llvm::matchSelectPattern
SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
Definition: ValueTracking.cpp:6192
llvm::PatternMatch::m_c_And
BinaryOp_match< LHS, RHS, Instruction::And, true > m_c_And(const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
Definition: PatternMatch.h:2257
llvm::BinaryOperator::CreateNeg
NUW NUW NUW NUW Exact static Exact BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
Definition: Instructions.cpp:2794
llvm::CallBase::setDoesNotThrow
void setDoesNotThrow()
Definition: InstrTypes.h:1900
findInitTrampolineFromBB
static IntrinsicInst * findInitTrampolineFromBB(IntrinsicInst *AdjustTramp, Value *TrampMem)
Definition: InstCombineCalls.cpp:2840
llvm::PatternMatch::m_Not
BinaryOp_match< ValTy, cst_pred_ty< is_all_ones >, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
Definition: PatternMatch.h:2295
llvm::SelectPatternFlavor
SelectPatternFlavor
Specific patterns of select instructions we can match.
Definition: ValueTracking.h:676
llvm::CallBrInst::Create
static CallBrInst * Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, const Twine &NameStr, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:4028
llvm::Type::getNonOpaquePointerElementType
Type * getNonOpaquePointerElementType() const
Only use this method in code that is not reachable with opaque pointers, or part of deprecated method...
Definition: Type.h:382
llvm::InstCombinerImpl::SimplifyAnyMemTransfer
Instruction * SimplifyAnyMemTransfer(AnyMemTransferInst *MI)
Definition: InstCombineCalls.cpp:120
llvm::BasicBlock::rend
reverse_iterator rend()
Definition: BasicBlock.h:304
llvm::LinearPolySize::isScalable
bool isScalable() const
Returns whether the size is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:298
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
llvm::PatternMatch::m_Deferred
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
Definition: PatternMatch.h:798
llvm::APIntOps::umin
const APInt & umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be unsigned.
Definition: APInt.h:2149
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1289
llvm::Instruction::mayHaveSideEffects
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
Definition: Instruction.cpp:695
llvm::PatternMatch::m_c_MaxOrMin
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > > m_c_MaxOrMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:2355
I1
@ I1
Definition: DXILOpLowering.cpp:37
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::FunctionType::isVarArg
bool isVarArg() const
Definition: DerivedTypes.h:123
llvm::Instruction::setMetadata
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1368
KnownBits.h
llvm::KnownBits::countMinTrailingZeros
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
Definition: KnownBits.h:226
floor
We have fiadd patterns now but the followings have the same cost and complexity We need a way to specify the later is more profitable def def The FP stackifier should handle simple permutates to reduce number of shuffle e g floor
Definition: README-FPStack.txt:54
llvm::GCRelocateInst::getDerivedPtrIndex
unsigned getDerivedPtrIndex() const
The index into the associate statepoint's argument list which contains the pointer whose relocation t...
Definition: IntrinsicInst.h:1388
llvm::UndefMaskElem
constexpr int UndefMaskElem
Definition: Instructions.h:1996
AliasAnalysis.h
llvm::PatternMatch::m_OneUse
OneUse_match< T > m_OneUse(const T &SubPattern)
Definition: PatternMatch.h:67
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:283
factorizeMinMaxTree
static Instruction * factorizeMinMaxTree(IntrinsicInst *II)
Reduce a sequence of min/max intrinsics with a common operand.
Definition: InstCombineCalls.cpp:1027
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::ConstantExpr::getSub
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2726
llvm::InstCombinerImpl::eraseInstFromFunction
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Definition: InstCombineInternal.h:452
llvm::GCStatepointInst
Represents a gc.statepoint intrinsic call.
Definition: Statepoint.h:62
llvm::isAllocationFn
bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI)
Tests if a value is a call or invoke to a library function that allocates or reallocates memory (eith...
Definition: MemoryBuiltins.cpp:272
llvm::isAtLeastOrStrongerThan
bool isAtLeastOrStrongerThan(AtomicOrdering AO, AtomicOrdering Other)
Definition: AtomicOrdering.h:105
llvm::SmallBitVector
This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is ...
Definition: SmallBitVector.h:35
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:186
llvm::User::getOperandUse
const Use & getOperandUse(unsigned i) const
Definition: User.h:182
llvm::BitmaskEnumDetail::Mask
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
Instruction.h
llvm::PatternMatch::m_APInt
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
Definition: PatternMatch.h:270
llvm::SPF_NABS
@ SPF_NABS
Absolute value.
Definition: ValueTracking.h:685
CommandLine.h
llvm::PatternMatch::m_UMax
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1875
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::KnownBits::isNonNegative
bool isNonNegative() const
Returns true if this value is known to be non-negative.
Definition: KnownBits.h:99
llvm::MinAlign
constexpr uint64_t MinAlign(uint64_t A, uint64_t B)
A and B are either alignments or offsets.
Definition: MathExtras.h:699
llvm::FenceInst::getSyncScopeID
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this fence instruction.
Definition: Instructions.h:481
llvm::APInt::isNonNegative
bool isNonNegative() const
Determine if this APInt Value is non-negative (>= 0)
Definition: APInt.h:317
llvm::isValidAssumeForContext
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,...
Definition: ValueTracking.cpp:566
llvm::isSplatValue
bool isSplatValue(const Value *V, int Index=-1, unsigned Depth=0)
Return true if each element of the vector value V is poisoned or equal to every other non-poisoned el...
Definition: VectorUtils.cpp:386
llvm::SelectInst::Create
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr, Instruction *MDFrom=nullptr)
Definition: Instructions.h:1768
InstCombineInternal.h
llvm::GlobalValue::isDeclaration
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:241
llvm::PatternMatch::m_Select
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
Definition: PatternMatch.h:1472
llvm::SimplifyCall
Value * SimplifyCall(CallBase *Call, const SimplifyQuery &Q)
Given a callsite, fold the result or return null.
Definition: InstructionSimplify.cpp:6230
llvm::Constant::containsConstantExpression
bool containsConstantExpression() const
Return true if this is a fixed width vector constant that includes any constant expressions.
Definition: Constants.cpp:340
Constants.h
llvm::maximum
LLVM_READONLY APFloat maximum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2018 maximum semantics.
Definition: APFloat.h:1330
llvm::PatternMatch::match
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
llvm::SyncScope::SingleThread
@ SingleThread
Synchronized with respect to signal handlers executing in the same thread.
Definition: LLVMContext.h:55
llvm::PatternMatch::m_FShl
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
Definition: PatternMatch.h:2205
llvm::APInt::isZero
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
Definition: APInt.h:359
llvm::OverflowResult::MayOverflow
@ MayOverflow
May or may not overflow.
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::User
Definition: User.h:44
Intr
unsigned Intr
Definition: AMDGPUBaseInfo.cpp:2276
llvm::PatternMatch::m_UnOp
class_match< UnaryOperator > m_UnOp()
Match an arbitrary unary operation and ignore it.
Definition: PatternMatch.h:79
llvm::getKnownAlignment
Align getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to infer an alignment for the specified pointer.
Definition: Local.h:222
Intrinsics.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::FunctionType::param_end
param_iterator param_end() const
Definition: DerivedTypes.h:129
llvm::AttributeSet::hasAttribute
bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists in this set.
Definition: Attributes.cpp:665
round
static uint64_t round(uint64_t Acc, uint64_t Input)
Definition: xxhash.cpp:56
InstrTypes.h
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
Definition: InstrTypes.h:1396
llvm::CallBase::setAttributes
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1478
llvm::BinaryOperator::CreateNSW
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:283
llvm::BasicBlock::begin
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:297
llvm::KnownBits::One
APInt One
Definition: KnownBits.h:25
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
llvm::PatternMatch::m_PosZeroFP
cstfp_pred_ty< is_pos_zero_fp > m_PosZeroFP()
Match a floating-point positive zero.
Definition: PatternMatch.h:683
llvm::X86::FirstMacroFusionInstKind::AddSub
@ AddSub
InstructionWorklist.h
llvm::LoadInst::setVolatile
void setVolatile(bool V)
Specify whether this is a volatile load or not.
Definition: Instructions.h:216
llvm::CallInst::Create
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1517
AssumeBundleQueries.h
getOpcode
static Optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
Definition: VPlanSLP.cpp:190
llvm::APInt::getAllOnes
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
Definition: APInt.h:214
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:486
llvm::BitTracker
Definition: BitTracker.h:35
llvm::PatternMatch::m_Instruction
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
Definition: PatternMatch.h:726
AssumeBundleBuilder.h
llvm::VectorType::getElementCount
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
Definition: DerivedTypes.h:627
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
llvm::alignDown
uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the largest uint64_t less than or equal to Value and is Skew mod Align.
Definition: MathExtras.h:780
llvm::PatternMatch::m_ZExt
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
Definition: PatternMatch.h:1639
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::SmallBitVector::all
bool all() const
Returns true if all bits are set.
Definition: SmallBitVector.h:216
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
llvm::Instruction::CastOps
CastOps
Definition: Instruction.h:800
llvm::PatternMatch::m_MaxOrMin
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > > > m_MaxOrMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1892
llvm::PatternMatch::m_FNeg
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
Definition: PatternMatch.h:1043
llvm::SaturatingInst
Represents a saturating add/sub intrinsic.
Definition: IntrinsicInst.h:698
llvm::Constant::getAllOnesValue
static Constant * getAllOnesValue(Type *Ty)
Definition: Constants.cpp:395
llvm::pdb::PDB_SymType::Caller
@ Caller
llvm::PatternMatch::m_ConstantInt
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:145
llvm::FunctionType::param_begin
param_iterator param_begin() const
Definition: DerivedTypes.h:128
llvm::Instruction
Definition: Instruction.h:42
llvm::Type::getScalarSizeInBits
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
Definition: Type.cpp:189
llvm::isDereferenceablePointer
bool isDereferenceablePointer(const Value *V, Type *Ty, const DataLayout &DL, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if this is always a dereferenceable pointer.
Definition: Loads.cpp:227
llvm::PatternMatch::m_UMin
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1881
llvm::PatternMatch::m_c_Or
BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
Definition: PatternMatch.h:2264
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
APFloat.h
llvm::UnaryOperator::CreateWithCopiedFlags
static UnaryOperator * CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: InstrTypes.h:156
llvm::codeview::EncodedFramePtrReg::BasePtr
@ BasePtr
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1769
llvm::CallBase::bundle_op_info_begin
bundle_op_iterator bundle_op_info_begin()
Return the start of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:2238
llvm::ConstantExpr::getURem
static Constant * getURem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2762
llvm::InstCombinerImpl
Definition: InstCombineInternal.h:61
llvm::ConstantInt::get
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:919
llvm::PatternMatch::m_NSWSub
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1174
llvm::FunctionCallee::getFunctionType
FunctionType * getFunctionType()
Definition: DerivedTypes.h:182
STLFunctionalExtras.h
llvm::APSInt::getMinValue
static APSInt getMinValue(uint32_t numBits, bool Unsigned)
Return the APSInt representing the minimum integer value with the given bit width and signedness.
Definition: APSInt.h:290
llvm::getKnowledgeFromBundle
RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI)
This extracts the Knowledge from an element of an operand bundle.
Definition: AssumeBundleQueries.cpp:99
llvm::KnownBits::isNegative
bool isNegative() const
Returns true if this value is known to be negative.
Definition: KnownBits.h:96
canonicalizeConstantArg0ToArg1
static CallInst * canonicalizeConstantArg0ToArg1(CallInst &Call)
Definition: InstCombineCalls.cpp:783
Align
uint64_t Align
Definition: ELFObjHandler.cpp:81
PatternMatch.h
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:155
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::Instruction::mayWriteToMemory
bool mayWriteToMemory() const
Return true if this instruction may modify memory.
Definition: Instruction.cpp:596
llvm::PatternMatch::m_APIntAllowUndef
apint_match m_APIntAllowUndef(const APInt *&Res)
Match APInt while allowing undefs in splat vector constants.
Definition: PatternMatch.h:276
llvm::PointerType::isOpaque
bool isOpaque() const
Definition: DerivedTypes.h:673
llvm::CallBase::getCallingConv
CallingConv::ID getCallingConv() const
Definition: InstrTypes.h:1455
llvm::getObjectSize
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, const TargetLibraryInfo *TLI, ObjectSizeOpts Opts={})
Compute the size of the object pointed by Ptr.
Definition: MemoryBuiltins.cpp:558
llvm::None
const NoneType None
Definition: None.h:24
Statepoint.h
llvm::Type::getIntegerBitWidth
unsigned getIntegerBitWidth() const
Definition: DerivedTypes.h:97
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:344
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
Type.h
llvm::IRBuilderBase::CreateAddrSpaceCast
Value * CreateAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1957
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::AnyMemTransferInst
Definition: IntrinsicInst.h:1117
llvm::Log2_32_Ceil
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
Definition: MathExtras.h:636
llvm::CastInst::isLosslessCast
bool isLosslessCast() const
A lossless cast is one that does not alter the basic value.
Definition: Instructions.cpp:2890
llvm::PatternMatch::m_One
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:513
llvm::Instruction::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:279
llvm::SimplifyFMulInst
Value * SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FMul, fold the result or return null.
Definition: InstructionSimplify.cpp:5330
llvm::OverflowResult
OverflowResult
Definition: ValueTracking.h:486
llvm::maxnum
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE maxNum semantics.
Definition: APFloat.h:1306
findInitTrampolineFromAlloca
static IntrinsicInst * findInitTrampolineFromAlloca(Value *TrampMem)
Definition: InstCombineCalls.cpp:2801
reassociateMinMaxWithConstantInOperand
static Instruction * reassociateMinMaxWithConstantInOperand(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
If this min/max has a matching min/max operand with a constant, try to push the constant operand into...
Definition: InstCombineCalls.cpp:999
llvm::ValueHandleBase::ValueIsRAUWd
static void ValueIsRAUWd(Value *Old, Value *New)
Definition: Value.cpp:1187
llvm::PatternMatch::m_NSWAdd
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1166
llvm::IRBuilderBase::CreateLaunderInvariantGroup
Value * CreateLaunderInvariantGroup(Value *Ptr)
Create a launder.invariant.group intrinsic call.
Definition: IRBuilder.cpp:1021
llvm::Function::getAttributes
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:314
llvm::SyncScope::System
@ System
Synchronized with respect to all concurrently executing threads.
Definition: LLVMContext.h:58
llvm::InvokeInst
Invoke instruction.
Definition: Instructions.h:3776
llvm::IRBuilderBase::CreateZExt
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1860
llvm::PatternMatch::m_Xor
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1115
llvm::Type::isIntegerTy
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:191
removeTriviallyEmptyRange
static bool removeTriviallyEmptyRange(IntrinsicInst &EndI, InstCombinerImpl &IC, std::function< bool(const IntrinsicInst &)> IsStart)
Definition: InstCombineCalls.cpp:748
llvm::InlineAsm
Definition: InlineAsm.h:31
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:389
llvm::Instruction::andIRFlags
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction.
Definition: Instruction.cpp:322
llvm::IRBuilderBase::FastMathFlagGuard
Definition: IRBuilder.h:372
VectorUtils.h
llvm::KnownBits::isAllOnes
bool isAllOnes() const
Returns true if value is all one bits.
Definition: KnownBits.h:78
llvm::Use::set
void set(Value *Val)
Definition: Value.h:868
llvm::ConstantExpr::getTrunc
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2120
llvm::Function::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:625
llvm::GCStatepointInst::getGCRelocates
std::vector< const GCRelocateInst * > getGCRelocates() const
Get list of all gc reloactes linked to this statepoint May contain several relocations for the same b...
Definition: Statepoint.h:207
llvm::SPIRV::Decoration::Alignment
@ Alignment
BasicBlock.h
llvm::cl::opt
Definition: CommandLine.h:1392
llvm::APFloat
Definition: APFloat.h:700
llvm::IRBuilderBase::CreateBitCast
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1952
llvm::RetainedKnowledge::AttrKind
Attribute::AttrKind AttrKind
Definition: AssumeBundleQueries.h:101
llvm::PatternMatch::m_Zero
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:535
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:305
llvm::PatternMatch::m_NUWAdd
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1199
llvm::AttributeList::getRetAttrs
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:1357
llvm::FunctionType::param_iterator
Type::subtype_iterator param_iterator
Definition: DerivedTypes.h:126
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::GCRelocateInst
Represents calls to the gc.relocate intrinsic.
Definition: IntrinsicInst.h:1369
findInitTrampoline
static IntrinsicInst * findInitTrampoline(Value *Callee)
Definition: InstCombineCalls.cpp:2861
llvm::PointerType::getUnqual
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:651
llvm::PatternMatch::m_ImmConstant
match_combine_and< class_match< Constant >, match_unless< class_match< ConstantExpr > > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
Definition: PatternMatch.h:759
llvm::InlineAsm::canThrow
bool canThrow() const
Definition: InlineAsm.h:71
llvm::LibCallSimplifier
LibCallSimplifier - This class implements a collection of optimizations that replace well formed call...
Definition: SimplifyLibCalls.h:100
llvm::InstCombiner::getAssumptionCache
AssumptionCache & getAssumptionCache() const
Definition: InstCombiner.h:368
llvm::BinaryOperator::CreateFMulFMF
static BinaryOperator * CreateFMulFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
Definition: InstrTypes.h:267
llvm::BinaryOpIntrinsic::isSigned
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Definition: IntrinsicInst.cpp:677
uint64_t
llvm::Type::getWithNewBitWidth
Type * getWithNewBitWidth(unsigned NewBitWidth) const
Given an integer or vector type, change the lane bitwidth to NewBitwidth, whilst keeping the old numb...
Definition: DerivedTypes.h:722
llvm::InstCombiner::getDataLayout
const DataLayout & getDataLayout() const
Definition: InstCombiner.h:371
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::Function::getCallingConv
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:238
llvm::PatternMatch::m_LogicalOr
LogicalOp_match< LHS, RHS, Instruction::Or > m_LogicalOr(const LHS &L, const RHS &R)
Matches L || R either in the form of L | R or L ? true : R.
Definition: PatternMatch.h:2562
llvm::BitmaskEnumDetail::Underlying
constexpr std::underlying_type_t< E > Underlying(E Val)
Check that Val is in range for E, and return Val cast to E's underlying type.
Definition: BitmaskEnum.h:90
llvm::RetainedKnowledge::ArgValue
uint64_t ArgValue
Definition: AssumeBundleQueries.h:102
llvm::LoadInst::setOrdering
void setOrdering(AtomicOrdering Ordering)
Sets the ordering constraint of this load instruction.
Definition: Instructions.h:238
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
llvm::TruncInst
This class represents a truncation of integer types.
Definition: Instructions.h:4780
llvm::GCRelocateInst::getDerivedPtr
Value * getDerivedPtr() const
Definition: IntrinsicInst.cpp:722
llvm::AttributeSet::get
static AttributeSet get(LLVMContext &C, const AttrBuilder &B)
Definition: Attributes.cpp:598
llvm::ConstantPointerNull::get
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1755
llvm::AttributeFuncs::ASK_SAFE_TO_DROP
@ ASK_SAFE_TO_DROP
Definition: Attributes.h:1215
llvm::CallBrInst
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
Definition: Instructions.h:3985
llvm::PatternMatch::m_AllOnes
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
Definition: PatternMatch.h:445
simplifyNeonTbl1
static Value * simplifyNeonTbl1(const IntrinsicInst &II, InstCombiner::BuilderTy &Builder)
Convert a table lookup to shufflevector if the mask is constant.
Definition: InstCombineCalls.cpp:692
llvm::Instruction::isIdenticalTo
bool isIdenticalTo(const Instruction *I) const
Return true if the specified instruction is exactly identical to the current one.
Definition: Instruction.cpp:502
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::assumeAligned
Align assumeAligned(uint64_t Value)
Treats the value 0 as a 1, so Align is always at least 1.
Definition: Alignment.h:103
llvm::DenseMap< Value *, unsigned >
llvm::InstCombinerImpl::visitFenceInst
Instruction * visitFenceInst(FenceInst &FI)
Definition: InstCombineCalls.cpp:2696
llvm::AtomicOrdering::Unordered
@ Unordered
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::AttrBuilder
Definition: Attributes.h:1005
llvm::FunctionType::getParamType
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:135
llvm::LoadInst::setAlignment
void setAlignment(Align Align)
Definition: Instructions.h:228
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
llvm::lowerObjectSizeCall
Value * lowerObjectSizeCall(IntrinsicInst *ObjectSize, const DataLayout &DL, const TargetLibraryInfo *TLI, bool MustSucceed)
Try to turn a call to @llvm.objectsize into an integer value of the given Type.
Definition: MemoryBuiltins.cpp:569
llvm::PatternMatch::m_FAbs
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
Definition: PatternMatch.h:2182
llvm::Attribute::getWithDereferenceableBytes
static Attribute getWithDereferenceableBytes(LLVMContext &Context, uint64_t Bytes)
Definition: Attributes.cpp:175
llvm::PatternMatch::m_And
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1103
llvm::PointerType
Class to represent pointers.
Definition: DerivedTypes.h:632
ArrayRef.h
llvm::CallBase::addRetAttr
void addRetAttr(Attribute::AttrKind Kind)
Adds the attribute to the return value.
Definition: InstrTypes.h:1516
llvm::SimplifyFMAFMul
Value * SimplifyFMAFMul(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for the multiplication of a FMA, fold the result or return null.
Definition: InstructionSimplify.cpp:5338
llvm::Instruction::setDebugLoc
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:364
llvm::PatternMatch::m_SRem
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1091
llvm::AttributeSet::removeAttributes
LLVM_NODISCARD AttributeSet removeAttributes(LLVMContext &C, const AttributeMask &AttrsToRemove) const
Remove the specified attributes from this set.
Definition: Attributes.cpp:650
llvm::computeKnownBits
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, OptimizationRemarkEmitter *ORE=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
Definition: ValueTracking.cpp:222
maximum
Should compile r2 movcc movcs str strb mov lr r1 movcs movcc mov lr r1 str mov mov cmp r1 movlo r2 str bx lr r0 mov mov cmp r0 movhs r2 mov r1 bx lr Some of the NEON intrinsics may be appropriate for more general either as target independent intrinsics or perhaps elsewhere in the ARM backend Some of them may also be lowered to target independent and perhaps some new SDNodes could be added For maximum
Definition: README.txt:489
IT
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 any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
llvm::KnownBits::countMaxLeadingZeros
unsigned countMaxLeadingZeros() const
Returns the maximum number of leading zero bits possible.
Definition: KnownBits.h:276
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
foldClampRangeOfTwo
static Instruction * foldClampRangeOfTwo(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
If we have a clamp pattern like max (min X, 42), 41 – where the output can only be one of two possibl...
Definition: InstCombineCalls.cpp:935
llvm::KnownBits::countMaxTrailingZeros
unsigned countMaxTrailingZeros() const
Returns the maximum number of trailing zero bits possible.
Definition: KnownBits.h:266
llvm::Optional::getValue
constexpr const T & getValue() const &
Definition: Optional.h:279
llvm::SPF_ABS
@ SPF_ABS
Floating point maxnum.
Definition: ValueTracking.h:684
llvm::CallBase::hasOperandBundles
bool hasOperandBundles() const
Return true if this User has any operand bundles.
Definition: InstrTypes.h:1945
std::swap
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:853
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::isKnownNegation
bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false)
Return true if the two given values are negation.
Definition: ValueTracking.cpp:5881
llvm::FenceInst::getOrdering
AtomicOrdering getOrdering() const
Returns the ordering constraint of this fence instruction.
Definition: Instructions.h:470
llvm::Instruction::isFast
bool isFast() const
Determine whether all fast-math-flags are set.
Definition: Instruction.cpp:249
llvm::codeview::CompileSym2Flags::EC
@ EC
llvm::KnownBits::countMinLeadingZeros
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
Definition: KnownBits.h:236
llvm::KnownBits::countMaxPopulation
unsigned countMaxPopulation() const
Returns the maximum number of bits that could be one.
Definition: KnownBits.h:291
llvm::CmpInst::BAD_ICMP_PREDICATE
@ BAD_ICMP_PREDICATE
Definition: InstrTypes.h:752
APSInt.h
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::Type::isVoidTy
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139
llvm::PatternMatch::m_SMin
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1869
llvm::MinMaxIntrinsic::getPredicate
ICmpInst::Predicate getPredicate() const
Returns the comparison predicate underlying the intrinsic.
Definition: IntrinsicInst.h:585
simplifyInvariantGroupIntrinsic
static Instruction * simplifyInvariantGroupIntrinsic(IntrinsicInst &II, InstCombinerImpl &IC)
This function transforms launder.invariant.group and strip.invariant.group like: launder(launder(x)) ...
Definition: InstCombineCalls.cpp:471
foldCtpop
static Instruction * foldCtpop(IntrinsicInst &II, InstCombinerImpl &IC)
Definition: InstCombineCalls.cpp:609
llvm::IRBuilderBase::getTrue
ConstantInt * getTrue()
Get the constant value for i1 true.
Definition: IRBuilder.h:441
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:926
llvm::CallBase::Create
static CallBase * Create(CallBase *CB, ArrayRef< OperandBundleDef > Bundles, Instruction *InsertPt=nullptr)
Create a clone of CB with a different set of operand bundles and insert it before InsertPt.
Definition: Instructions.cpp:255
llvm::PatternMatch::m_Constant
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
Definition: PatternMatch.h:142
llvm::LinearPolySize::getKnownMinValue
ScalarTy getKnownMinValue() const
Returns the minimum value this size can represent.
Definition: TypeSize.h:296
haveSameOperands
static bool haveSameOperands(const IntrinsicInst &I, const IntrinsicInst &E, unsigned NumOperands)
Definition: InstCombineCalls.cpp:728
llvm::SmallPtrSetImpl::count
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:383
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::PatternMatch::m_Value
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:76
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::User::setOperand
void setOperand(unsigned i, Value *Val)
Definition: User.h:174
llvm::CmpInst::ICMP_SLT
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:748
llvm::APSInt::getMaxValue
static APSInt getMaxValue(uint32_t numBits, bool Unsigned)
Return the APSInt representing the maximum integer value with the given bit width and signedness.
Definition: APSInt.h:283
llvm::APIntOps::smin
const APInt & smin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be signed.
Definition: APInt.h:2139
llvm::PatternMatch::m_SExt
CastClass_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
Definition: PatternMatch.h:1633
llvm::PatternMatch::m_SpecificInt
specific_intval< false > m_SpecificInt(APInt V)
Match a specific integer value or vector with all elements equal to the value.
Definition: PatternMatch.h:863
llvm::Function::isConvergent
bool isConvergent() const
Determine if the call is convergent.
Definition: Function.h:570
llvm::PatternMatch::m_CombineAnd
match_combine_and< LTy, RTy > m_CombineAnd(const LTy &L, const RTy &R)
Combine two pattern matchers matching L && R.
Definition: PatternMatch.h:216
llvm::ValueHandleBase::ValueIsDeleted
static void ValueIsDeleted(Value *V)
Definition: Value.cpp:1134
llvm::ArrayRef< int >
llvm::VAEndInst
This represents the llvm.va_end intrinsic.
Definition: IntrinsicInst.h:1189
llvm::Instruction::getFastMathFlags
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
Definition: Instruction.cpp:289
llvm::BinaryOperator
Definition: InstrTypes.h:188
None.h
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
Mul
BinaryOperator * Mul
Definition: X86PartialReduction.cpp:70
DataLayout.h
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:213
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:178
llvm::PatternMatch::m_Undef
auto m_Undef()
Match an arbitrary undef constant.
Definition: PatternMatch.h:136
llvm::AssumptionCache
A cache of @llvm.assume calls within a function.
Definition: AssumptionCache.h:42
SimplifyLibCalls.h
llvm::CmpInst::ICMP_ULT
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:744
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::Constant::getAggregateElement
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:410
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
isSafeToEliminateVarargsCast
static bool isSafeToEliminateVarargsCast(const CallBase &Call, const DataLayout &DL, const CastInst *const CI, const int ix)
If this cast does not affect the value passed through the varargs area, we can eliminate the use of t...
Definition: InstCombineCalls.cpp:2735
llvm::Instruction::getFunction
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:69
llvm::PatternMatch::m_Shuffle
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
Definition: PatternMatch.h:1561
llvm::CallingConv::C
@ C
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
moveAddAfterMinMax
static Instruction * moveAddAfterMinMax(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
Try to canonicalize min/max(X + C0, C1) as min/max(X, C1 - C0) + C0.
Definition: InstCombineCalls.cpp:834
uint32_t
Compiler.h
llvm::CallInst::isNoTailCall
bool isNoTailCall() const
Definition: Instructions.h:1675
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:991
llvm::InstCombinerImpl::visitVAEndInst
Instruction * visitVAEndInst(VAEndInst &I)
Definition: InstCombineCalls.cpp:775
llvm::MinMax
Definition: AssumeBundleQueries.h:71
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:82
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::CastInst::isBitOrNoopPointerCastable
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.
Definition: Instructions.cpp:3440
llvm::ConstantExpr::getIntegerCast
static Constant * getIntegerCast(Constant *C, Type *Ty, bool IsSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:2096
llvm::FPExtInst
This class represents an extension of floating point types.
Definition: Instructions.h:4936
trunc
We have fiadd patterns now but the followings have the same cost and complexity We need a way to specify the later is more profitable def def The FP stackifier should handle simple permutates to reduce number of shuffle e g trunc
Definition: README-FPStack.txt:63
llvm::RetainedKnowledge
Represent one information held inside an operand bundle of an llvm.assume.
Definition: AssumeBundleQueries.h:100
llvm::ObjectSizeOpts
Various options to control the behavior of getObjectSize.
Definition: MemoryBuiltins.h:135
llvm::Instruction::copyFastMathFlags
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction,...
Definition: Instruction.cpp:244
llvm::CastInst
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:429
llvm::WithOverflowInst
Represents an op.with.overflow intrinsic.
Definition: IntrinsicInst.h:677
llvm::CallInst::isMustTailCall
bool isMustTailCall() const
Definition: Instructions.h:1673
llvm::AMDGPUISD::BFI
@ BFI
Definition: AMDGPUISelLowering.h:429
hasUndefSource
static bool hasUndefSource(AnyMemTransferInst *MI)
Recognize a memcpy/memmove from a trivially otherwise unused alloca.
Definition: InstCombineCalls.cpp:110
llvm::APInt::ult
bool ult(const APInt &RHS) const
Unsigned less than comparison.
Definition: APInt.h:1061
llvm::Attribute::getWithDereferenceableOrNullBytes
static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context, uint64_t Bytes)
Definition: Attributes.cpp:181
llvm::CallBase::hasRetAttr
bool hasRetAttr(Attribute::AttrKind Kind) const
Determine whether the return value has the given attribute.
Definition: InstrTypes.h:1595
llvm::Value::setMetadata
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1266
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:280
llvm::PatternMatch::m_SMax
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1863
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:305
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:176
ValueHandle.h
llvm::Value::stripPointerCasts
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:682
llvm::SmallPtrSetImplBase::size
size_type size() const
Definition: SmallPtrSet.h:93
llvm::CallBase::doesNotThrow
bool doesNotThrow() const
Determine if the call cannot unwind.
Definition: InstrTypes.h:1899
llvm::OperandBundleUse::Inputs
ArrayRef< Use > Inputs
Definition: InstrTypes.h:1070
llvm::ConstantInt::getZExtValue
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:142
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:186
getPromotedType
static Type * getPromotedType(Type *Ty)
Return the specified type promoted as it would be to pass though a va_arg area.
Definition: InstCombineCalls.cpp:99
llvm::Attribute::getWithAlignment
static Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
Definition: Attributes.cpp:165
llvm::Function::doesNotThrow
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:554
Attributes.h
llvm::PatternMatch::m_FPExt
CastClass_match< OpTy, Instruction::FPExt > m_FPExt(const OpTy &Op)
Definition: PatternMatch.h:1697
llvm::APIntOps::umax
const APInt & umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
Definition: APInt.h:2154
Constant.h
llvm::NVPTX::PTXLdStInstCode::V2
@ V2
Definition: NVPTX.h:123
llvm::GCRelocateInst::getBasePtr
Value * getBasePtr() const
Definition: IntrinsicInst.cpp:716
llvm::minnum
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE minNum semantics.
Definition: APFloat.h:1295
llvm::IRBuilderBase::getFalse
ConstantInt * getFalse()
Get the constant value for i1 false.
Definition: IRBuilder.h:446
llvm::APInt::uadd_sat
APInt uadd_sat(const APInt &RHS) const
Definition: APInt.cpp:2037
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:240
llvm::ConstantInt::getTrue
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:867
llvm::Constant::getNullValue
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:350
llvm::KnownBits
Definition: KnownBits.h:23
llvm::ConstantExpr::getNeg
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2696
llvm::AnyMemSetInst
This class represents any memset intrinsic.
Definition: IntrinsicInst.h:1098
llvm::CastInst::CreateBitOrPointerCast
static CastInst * CreateBitOrPointerCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
Definition: Instructions.cpp:3335
llvm::KnownBits::countMinPopulation
unsigned countMinPopulation() const
Returns the number of bits known to be one.
Definition: KnownBits.h:286
NC
#define NC
Definition: regutils.h:42
llvm::BinaryOperator::CreateNUW
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:302
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:338
llvm::ConstantInt::getBool
static ConstantInt * getBool(LLVMContext &Context, bool V)
Definition: Constants.cpp:881
llvm::CallBase::arg_size
unsigned arg_size() const
Definition: InstrTypes.h:1339
llvm::Type::isIntOrIntVectorTy
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:197
GlobalVariable.h
llvm::ConstantFP::get
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition: Constants.cpp:966
llvm::getAllocAlignment
Value * getAllocAlignment(const CallBase *V, const TargetLibraryInfo *TLI)
Gets the alignment argument for an aligned_alloc-like function, using either built-in knowledge based...
Definition: MemoryBuiltins.cpp:335
Casting.h
llvm::InstCombinerImpl::visitCallBrInst
Instruction * visitCallBrInst(CallBrInst &CBI)
Definition: InstCombineCalls.cpp:2729
LowAndHigh
Metadata * LowAndHigh[]
Definition: NVVMIntrRange.cpp:68
Function.h
llvm::InstCombinerImpl::FoldOpIntoSelect
Instruction * FoldOpIntoSelect(Instruction &Op, SelectInst *SI, bool FoldWithMultiUse=false)
Given an instruction with a select as one operand and a constant as the other operand,...
Definition: InstructionCombining.cpp:1040
llvm::BitWidth
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:147
llvm::BinaryOperator::CreateNSWNeg
static BinaryOperator * CreateNSWNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: Instructions.cpp:2810
llvm::DenseMapBase::size
unsigned size() const
Definition: DenseMap.h:101
llvm::PatternMatch::m_BSwap
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
Definition: PatternMatch.h:2177
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:222
powi
This is blocked on not handling X *X *X powi(X, 3)(see note above). The issue is that we end up getting t
llvm::AttributeFuncs::typeIncompatible
AttributeMask typeIncompatible(Type *Ty, AttributeSafetyKind ASK=ASK_ALL)
Which attributes cannot be applied to a type.
Definition: Attributes.cpp:1776
llvm::OverflowResult::AlwaysOverflowsHigh
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
llvm::Function::getFunctionType
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:175
llvm::PatternMatch::m_ZeroInt
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
Definition: PatternMatch.h:522
llvm::getInverseMinMaxIntrinsic
Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
Definition: ValueTracking.cpp:6270
llvm::PatternMatch::m_PtrToInt
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
Definition: PatternMatch.h:1609
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:185
llvm::Instruction::hasAllowReassoc
bool hasAllowReassoc() const
Determine whether the allow-reassociation flag is set.
Definition: Instruction.cpp:254
llvm::CallBase::getCalledOperand
Value * getCalledOperand() const
Definition: InstrTypes.h:1389
createOverflowTuple
static Instruction * createOverflowTuple(IntrinsicInst *II, Value *Result, Constant *Overflow)
Creates a result tuple for an overflow intrinsic II with a given Result and a constant Overflow value...
Definition: InstCombineCalls.cpp:796
llvm::IntrinsicInst
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:46
llvm::PatternMatch::m_LogicalShift
BinOpPred_match< LHS, RHS, is_logical_shift_op > m_LogicalShift(const LHS &L, const RHS &R)
Matches logical shift operations.
Definition: PatternMatch.h:1321
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:475
AA
llvm::InstCombinerImpl::replaceOperand
Instruction * replaceOperand(Instruction &I, unsigned OpNum, Value *V)
Replace operand of instruction and add old operand to the worklist.
Definition: InstCombineInternal.h:425
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:786
llvm::BasicBlock::reverse_iterator
InstListType::reverse_iterator reverse_iterator
Definition: BasicBlock.h:89
llvm::ShuffleVectorInst
This instruction constructs a fixed permutation of two input vectors.
Definition: Instructions.h:2008
llvm::Type::isOpaquePointerTy
bool isOpaquePointerTy() const
True if this is an instance of an opaque PointerType.
Definition: Type.cpp:61
llvm::RecurKind::FAdd
@ FAdd
Sum of floats.
Instructions.h
llvm::isImpliedByDomCondition
Optional< bool > isImpliedByDomCondition(const Value *Cond, const Instruction *ContextI, const DataLayout &DL)
Return the boolean condition value in the context of the given instruction if it is known based on do...
Definition: ValueTracking.cpp:6722
llvm::Type::isStructTy
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:212
llvm::AttributeSet
Definition: Attributes.h:274
SmallVector.h
getKnownSign
static Optional< bool > getKnownSign(Value *Op, Instruction *CxtI, const DataLayout &DL, AssumptionCache *AC, DominatorTree *DT)
Definition: InstCombineCalls.cpp:815
llvm::PatternMatch::m_Specific
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:780
User.h
llvm::PatternMatch::m_ICmp
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Definition: PatternMatch.h:1404
llvm::CmpInst::ICMP_UGT
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:742
llvm::User::op_begin
op_iterator op_begin()
Definition: User.h:234
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1341
SmallBitVector.h
llvm::IntrinsicInst::isCommutative
bool isCommutative() const
Return true if swapping the first two arguments to the intrinsic produces the same result.
Definition: IntrinsicInst.h:59
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:91
InstructionSimplify.h
llvm::ConstantExpr::getMul
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2737
llvm::PatternMatch::m_NSWNeg
OverflowingBinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWNeg(const ValTy &V)
Matches a 'Neg' as 'sub nsw 0, V'.
Definition: PatternMatch.h:2288
llvm::PHINode
Definition: Instructions.h:2664
llvm::BasicBlock::getTerminator
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.h:119
llvm::Instruction::copyIRFlags
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
Definition: Instruction.cpp:298
llvm::buildAssumeFromKnowledge
AssumeInst * buildAssumeFromKnowledge(ArrayRef< RetainedKnowledge > Knowledge, Instruction *CtxI, AssumptionCache *AC=nullptr, DominatorTree *DT=nullptr)
Build and return a new assume created from the provided knowledge if the knowledge in the assume is f...
Definition: AssumeBundleBuilder.cpp:307
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::GlobalValue::getType
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:270
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:398
DerivedTypes.h
llvm::PatternMatch::m_Neg
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
Definition: PatternMatch.h:2279
llvm::APInt::getLowBitsSet
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Constructs an APInt value that has the bottom loBitsSet bits set.
Definition: APInt.h:289
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:311
llvm::TargetLibraryInfoImpl::isCallingConvCCompatible
static bool isCallingConvCCompatible(CallBase *CI)
Returns true if call site / callee has cdecl-compatible calling conventions.
Definition: TargetLibraryInfo.cpp:101
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1474
llvm::KnownBits::getBitWidth
unsigned getBitWidth() const
Get the bit width of this value.
Definition: KnownBits.h:40
LLVMContext.h
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::IRBuilderBase::CreateSub
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1217
llvm::Value::takeName
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:378
llvm::isAllocRemovable
bool isAllocRemovable(const CallBase *V, const TargetLibraryInfo *TLI)
Return false if the allocation can have side effects on the program state we are required to preserve...
Definition: MemoryBuiltins.cpp:323
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:394
llvm::InstCombinerImpl::SimplifyAnyMemSet
Instruction * SimplifyAnyMemSet(AnyMemSetInst *MI)
Definition: InstCombineCalls.cpp:243
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::cl::desc
Definition: CommandLine.h:405
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
raw_ostream.h
llvm::PatternMatch::m_Trunc
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
Definition: PatternMatch.h:1621
llvm::NullPointerIsDefined
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
Definition: Function.cpp:2039
llvm::AttributeList::hasParamAttr
bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Return true if the attribute exists for the given argument.
Definition: Attributes.h:734
llvm::Attribute::getWithByValType
static Attribute getWithByValType(LLVMContext &Context, Type *Ty)
Definition: Attributes.cpp:187
llvm::AttributeList::getParamAttrs
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
Definition: Attributes.cpp:1353
llvm::ConstantAggregateZero::get
static ConstantAggregateZero * get(Type *Ty)
Definition: Constants.cpp:1648
llvm::Type::canLosslesslyBitCastTo
bool canLosslesslyBitCastTo(Type *Ty) const
Return true if this type could be converted with a lossless BitCast to type 'Ty'.
Definition: Type.cpp:105
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:644
llvm::BinaryOperator::Create
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
Definition: Instructions.cpp:2778
llvm::isPowerOf2_64
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a po