Lines Matching defs:II
293 Value *InstCombinerImpl::simplifyMaskedLoad(IntrinsicInst &II) {
294 Value *LoadPtr = II.getArgOperand(0);
296 cast<ConstantInt>(II.getArgOperand(1))->getAlignValue();
300 if (maskIsAllOneOrUndef(II.getArgOperand(2))) {
301 LoadInst *L = Builder.CreateAlignedLoad(II.getType(), LoadPtr, Alignment,
303 L->copyMetadata(II);
309 if (isDereferenceablePointer(LoadPtr, II.getType(),
310 II.getDataLayout(), &II, &AC)) {
311 LoadInst *LI = Builder.CreateAlignedLoad(II.getType(), LoadPtr, Alignment,
313 LI->copyMetadata(II);
314 return Builder.CreateSelect(II.getArgOperand(2), LI, II.getArgOperand(3));
323 Instruction *InstCombinerImpl::simplifyMaskedStore(IntrinsicInst &II) {
324 auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(3));
330 return eraseInstFromFunction(II);
334 Value *StorePtr = II.getArgOperand(1);
335 Align Alignment = cast<ConstantInt>(II.getArgOperand(2))->getAlignValue();
337 new StoreInst(II.getArgOperand(0), StorePtr, false, Alignment);
338 S->copyMetadata(II);
348 if (Value *V = SimplifyDemandedVectorElts(II.getOperand(0), DemandedElts,
350 return replaceOperand(II, 0, V);
361 Instruction *InstCombinerImpl::simplifyMaskedGather(IntrinsicInst &II) {
362 auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(2));
370 if (auto *SplatPtr = getSplatValue(II.getArgOperand(0))) {
371 auto *VecTy = cast<VectorType>(II.getType());
373 cast<ConstantInt>(II.getArgOperand(1))->getAlignValue();
378 return replaceInstUsesWith(II, cast<Instruction>(Shuf));
389 Instruction *InstCombinerImpl::simplifyMaskedScatter(IntrinsicInst &II) {
390 auto *ConstMask = dyn_cast<Constant>(II.getArgOperand(3));
396 return eraseInstFromFunction(II);
399 if (auto *SplatPtr = getSplatValue(II.getArgOperand(1))) {
401 if (auto *SplatValue = getSplatValue(II.getArgOperand(0))) {
404 cast<ConstantInt>(II.getArgOperand(2))->getAlignValue();
407 S->copyMetadata(II);
414 Align Alignment = cast<ConstantInt>(II.getArgOperand(2))->getAlignValue();
415 VectorType *WideLoadTy = cast<VectorType>(II.getArgOperand(1)->getType());
420 Builder.CreateExtractElement(II.getArgOperand(0), LastLane);
423 S->copyMetadata(II);
433 if (Value *V = SimplifyDemandedVectorElts(II.getOperand(0), DemandedElts,
435 return replaceOperand(II, 0, V);
436 if (Value *V = SimplifyDemandedVectorElts(II.getOperand(1), DemandedElts,
438 return replaceOperand(II, 1, V);
451 static Instruction *simplifyInvariantGroupIntrinsic(IntrinsicInst &II,
453 auto *Arg = II.getArgOperand(0);
467 if (II.getIntrinsicID() == Intrinsic::launder_invariant_group)
469 else if (II.getIntrinsicID() == Intrinsic::strip_invariant_group)
475 II.getType()->getPointerAddressSpace())
476 Result = IC.Builder.CreateAddrSpaceCast(Result, II.getType());
481 static Instruction *foldCttzCtlz(IntrinsicInst &II, InstCombinerImpl &IC) {
482 assert((II.getIntrinsicID() == Intrinsic::cttz ||
483 II.getIntrinsicID() == Intrinsic::ctlz) &&
485 bool IsTZ = II.getIntrinsicID() == Intrinsic::cttz;
486 Value *Op0 = II.getArgOperand(0);
487 Value *Op1 = II.getArgOperand(1);
493 Function *F = Intrinsic::getDeclaration(II.getModule(), ID, II.getType());
494 return CallInst::Create(F, {X, II.getArgOperand(1)});
497 if (II.getType()->isIntOrIntVectorTy(1)) {
504 return IC.replaceInstUsesWith(II, ConstantInt::getNullValue(II.getType()));
508 if (II.hasOneUse() && match(Op1, m_Zero()) &&
509 match(II.user_back(), m_Shift(m_Value(), m_Specific(&II)))) {
510 II.dropUBImplyingAttrsAndMetadata();
511 return IC.replaceOperand(II, 1, IC.Builder.getTrue());
519 return IC.replaceOperand(II, 0, X);
523 return IC.replaceOperand(II, 0, X);
527 auto *Zext = IC.Builder.CreateZExt(X, II.getType());
530 return IC.replaceInstUsesWith(II, CttzZext);
538 auto *ZextCttz = IC.Builder.CreateZExt(Cttz, II.getType());
539 return IC.replaceInstUsesWith(II, ZextCttz);
547 return IC.replaceOperand(II, 0, X);
550 return IC.replaceOperand(II, 0, X);
571 ConstantInt::get(II.getType(), II.getType()->getScalarSizeInBits());
592 KnownBits Known = IC.computeKnownBits(Op0, 0, &II);
606 return IC.replaceInstUsesWith(II, C);
613 isKnownNonZero(Op0, IC.getSimplifyQuery().getWithInstruction(&II))) {
614 if (!match(II.getArgOperand(1), m_One()))
615 return IC.replaceOperand(II, 1, IC.Builder.getTrue());
620 if (BitWidth != 1 && !II.hasRetAttr(Attribute::Range) &&
621 !II.getMetadata(LLVMContext::MD_range)) {
624 II.addRangeRetAttr(Range);
625 return &II;
631 static Instruction *foldCtpop(IntrinsicInst &II, InstCombinerImpl &IC) {
632 assert(II.getIntrinsicID() == Intrinsic::ctpop &&
634 Type *Ty = II.getType();
636 Value *Op0 = II.getArgOperand(0);
642 return IC.replaceOperand(II, 0, X);
648 return IC.replaceOperand(II, 0, X);
654 Intrinsic::getDeclaration(II.getModule(), Intrinsic::cttz, Ty);
657 return IC.replaceInstUsesWith(II, IC.Builder.CreateSub(Bw, Cttz));
664 Intrinsic::getDeclaration(II.getModule(), Intrinsic::cttz, Ty);
676 IC.computeKnownBits(Op0, Known, 0, &II);
697 if (BitWidth != 1 && !II.hasRetAttr(Attribute::Range) &&
698 !II.getMetadata(LLVMContext::MD_range)) {
701 II.addRangeRetAttr(Range);
702 return &II;
712 static Value *simplifyNeonTbl1(const IntrinsicInst &II,
715 auto *C = dyn_cast<Constant>(II.getArgOperand(1));
719 auto *VecTy = cast<FixedVectorType>(II.getType());
741 auto *V1 = II.getArgOperand(0);
814 /// Creates a result tuple for an overflow intrinsic \p II with a given
816 static Instruction *createOverflowTuple(IntrinsicInst *II, Value *Result,
819 StructType *ST = cast<StructType>(II->getType());
825 InstCombinerImpl::foldIntrinsicWithOverflowCommon(IntrinsicInst *II) {
826 WithOverflowInst *WO = cast<WithOverflowInst>(II);
906 Instruction *InstCombinerImpl::foldIntrinsicIsFPClass(IntrinsicInst &II) {
907 Value *Src0 = II.getArgOperand(0);
908 Value *Src1 = II.getArgOperand(1);
917 II.getFunction()->getAttributes().hasFnAttr(Attribute::StrictFP);
923 II.setArgOperand(1, ConstantInt::get(Src1->getType(), fneg(Mask)));
924 return replaceOperand(II, 0, FNegSrc);
929 II.setArgOperand(1, ConstantInt::get(Src1->getType(), inverse_fabs(Mask)));
930 return replaceOperand(II, 0, FAbsSrc);
947 CmpInf->takeName(&II);
948 return replaceInstUsesWith(II, CmpInf);
962 EqInf->takeName(&II);
963 return replaceInstUsesWith(II, EqInf);
976 NeInf->takeName(&II);
977 return replaceInstUsesWith(II, NeInf);
985 IsNan->takeName(&II);
986 return replaceInstUsesWith(II, IsNan);
993 FCmp->takeName(&II);
994 return replaceInstUsesWith(II, FCmp);
1013 (PredType = fpclassTestIsFCmp0(OrderedMask, *II.getFunction(),
1022 FCmp->takeName(&II);
1023 return replaceInstUsesWith(II, FCmp);
1026 KnownFPClass Known = computeKnownFPClass(Src0, Mask, &II);
1032 II.setArgOperand(
1034 return &II;
1041 return replaceInstUsesWith(II, ConstantInt::get(II.getType(), true));
1086 static Instruction *moveAddAfterMinMax(IntrinsicInst *II,
1088 Intrinsic::ID MinMaxID = II->getIntrinsicID();
1094 Value *Op0 = II->getArgOperand(0), *Op1 = II->getArgOperand(1);
1117 Constant *NewMinMaxC = ConstantInt::get(II->getType(), CDiff);
1187 static Instruction *foldClampRangeOfTwo(IntrinsicInst *II,
1189 Value *I0 = II->getArgOperand(0), *I1 = II->getArgOperand(1);
1196 switch (II->getIntrinsicID()) {
1222 return SelectInst::Create(Cmp, ConstantInt::get(II->getType(), *C0), I1);
1227 static Value *reassociateMinMaxWithConstants(IntrinsicInst *II,
1230 Intrinsic::ID MinMaxID = II->getIntrinsicID();
1231 auto *LHS = dyn_cast<MinMaxIntrinsic>(II->getArgOperand(0));
1237 !match(II->getArgOperand(1), m_ImmConstant(C1)))
1254 return Builder.CreateIntrinsic(InnerMinMaxID, II->getType(),
1261 reassociateMinMaxWithConstantInOperand(IntrinsicInst *II,
1267 if (!match(II, m_c_MaxOrMin(m_OneUse(m_CombineAnd(
1274 Intrinsic::ID MinMaxID = II->getIntrinsicID();
1282 Intrinsic::getDeclaration(II->getModule(), MinMaxID, II->getType());
1289 static Instruction *factorizeMinMaxTree(IntrinsicInst *II) {
1291 auto *LHS = dyn_cast<IntrinsicInst>(II->getArgOperand(0));
1292 auto *RHS = dyn_cast<IntrinsicInst>(II->getArgOperand(1));
1293 Intrinsic::ID MinMaxID = II->getIntrinsicID();
1340 Module *Mod = II->getModule();
1341 Function *MinMax = Intrinsic::getDeclaration(Mod, MinMaxID, II->getType());
1348 foldShuffledIntrinsicOperands(IntrinsicInst *II,
1353 switch (II->getIntrinsicID()) {
1368 if (!match(II->getArgOperand(0),
1373 if (none_of(II->args(), [](Value *V) { return V->hasOneUse(); }))
1377 SmallVector<Value *, 4> NewArgs(II->arg_size());
1380 for (unsigned i = 1, e = II->arg_size(); i != e; ++i) {
1381 if (!match(II->getArgOperand(i),
1389 Instruction *FPI = isa<FPMathOperator>(II) ? II : nullptr;
1391 Builder.CreateIntrinsic(II->getIntrinsicID(), SrcTy, NewArgs, FPI);
1524 IntrinsicInst *II = dyn_cast<IntrinsicInst>(&CI);
1525 if (!II) return visitCallBase(CI);
1529 if (auto *AMI = dyn_cast<AtomicMemIntrinsic>(II))
1541 if (auto *MI = dyn_cast<AnyMemIntrinsic>(II)) {
1590 if (Changed) return II;
1595 if (auto *IIFVTy = dyn_cast<FixedVectorType>(II->getType())) {
1599 if (Value *V = SimplifyDemandedVectorElts(II, AllOnesEltMask, PoisonElts)) {
1600 if (V != II)
1601 return replaceInstUsesWith(*II, V);
1602 return II;
1606 if (II->isCommutative()) {
1607 if (auto Pair = matchSymmetricPair(II->getOperand(0), II->getOperand(1))) {
1608 replaceOperand(*II, 0, Pair->first);
1609 replaceOperand(*II, 1, Pair->second);
1610 return II;
1626 Intrinsic::ID IID = II->getIntrinsicID();
1630 if (Value *V = lowerObjectSizeCall(II, DL, &TLI, AA, /*MustSucceed=*/false,
1639 Value *IIOperand = II->getArgOperand(0);
1640 bool IntMinIsPoison = cast<Constant>(II->getArgOperand(1))->isOneValue();
1646 return replaceOperand(*II, 0, X);
1648 return replaceOperand(*II, 0, X);
1650 return replaceOperand(*II, 0, X);
1660 return replaceOperand(*II, 0, XY);
1664 getKnownSignOrZero(IIOperand, SQ.getWithInstruction(II))) {
1668 return replaceInstUsesWith(*II, IIOperand);
1682 return CastInst::Create(Instruction::ZExt, NarrowAbs, II->getType());
1689 return BinaryOperator::CreateAnd(X, ConstantInt::get(II->getType(), 1));
1694 Value *I0 = II->getArgOperand(0), *I1 = II->getArgOperand(1);
1697 assert(II->getType()->getScalarSizeInBits() != 1 &&
1701 return CastInst::Create(Instruction::ZExt, Cmp, II->getType());
1707 return replaceInstUsesWith(*II, FoldedCttz);
1712 return replaceInstUsesWith(*II, FoldedCtlz);
1716 Value *I0 = II->getArgOperand(0), *I1 = II->getArgOperand(1);
1721 return CastInst::Create(Instruction::ZExt, NarrowMaxMin, II->getType());
1728 return CastInst::Create(Instruction::ZExt, NarrowMaxMin, II->getType());
1737 Value *I0 = II->getArgOperand(0), *I1 = II->getArgOperand(1);
1742 return CastInst::Create(Instruction::SExt, NarrowMaxMin, II->getType());
1750 return CastInst::Create(Instruction::SExt, NarrowMaxMin, II->getType());
1757 II->getType()->isIntOrIntVectorTy(1)) {
1764 II->getType()->isIntOrIntVectorTy(1)) {
1799 auto KnownSign = getKnownSign(X, SQ.getWithInstruction(II));
1845 if (Instruction *I = moveAddAfterMinMax(II, Builder))
1853 ConstantInt::get(II->getType(), *RHSC));
1871 ConstantInt::getBool(II->getContext(), IntMinIsPoison));
1880 if (Instruction *Sel = foldClampRangeOfTwo(II, Builder))
1883 if (Instruction *SAdd = matchSAddSubSat(*II))
1886 if (Value *NewMinMax = reassociateMinMaxWithConstants(II, Builder, SQ))
1887 return replaceInstUsesWith(*II, NewMinMax);
1889 if (Instruction *R = reassociateMinMaxWithConstantInOperand(II, Builder))
1892 if (Instruction *NewMinMax = factorizeMinMaxTree(II))
1901 I0, IsSigned, SQ.getWithInstruction(II));
1904 return replaceInstUsesWith(*II, I0);
1906 return replaceInstUsesWith(*II,
1907 ConstantInt::get(II->getType(), *RHSC));
1914 Value *IIOperand = II->getArgOperand(0);
1919 Type *Ty = II->getType();
1932 Value *IIOperand = II->getArgOperand(0);
1951 KnownBits Known = computeKnownBits(IIOperand, 0, II);
1981 if (Instruction *BitOp = matchBSwapOrBitReverse(*II, /*MatchBSwaps*/ false,
1987 if (Value *SimplifiedMaskedOp = simplifyMaskedLoad(*II))
1991 return simplifyMaskedStore(*II);
1993 return simplifyMaskedGather(*II);
1995 return simplifyMaskedScatter(*II);
1998 if (auto *SkippedBarrier = simplifyInvariantGroupIntrinsic(*II, *this))
1999 return replaceInstUsesWith(*II, SkippedBarrier);
2002 if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
2007 II->getArgOperand(0), II);
2010 return BinaryOperator::CreateFMulFMF(II->getArgOperand(0),
2011 II->getArgOperand(0), II);
2019 if (match(II->getArgOperand(0), m_FNeg(m_Value(X))) ||
2020 match(II->getArgOperand(0), m_FAbs(m_Value(X))) ||
2021 match(II->getArgOperand(0),
2023 return replaceOperand(*II, 0, X);
2030 if (auto *I = foldCttzCtlz(*II, *this))
2035 if (auto *I = foldCtpop(*II, *this))
2041 Value *Op0 = II->getArgOperand(0), *Op1 = II->getArgOperand(1);
2042 Type *Ty = II->getType();
2045 if (match(II->getArgOperand(2), m_ImmConstant(ShAmtC))) {
2053 return replaceOperand(*II, 2, ModuloC);
2065 if (!isKnownNonZero(ShAmtC, SQ.getWithInstruction(II)))
2069 Module *Mod = II->getModule();
2089 Module *Mod = II->getModule();
2094 matchBSwapOrBitReverse(*II, /*MatchBSwaps*/ true,
2100 if (SimplifyDemandedInstructionBits(*II))
2110 if (SimplifyDemandedBits(II, 2, Op2Demanded, Op2Known))
2115 unsigned BitWidth = DL.getPointerTypeSizeInBits(II->getType());
2117 if (SimplifyDemandedInstructionBits(*II, Known))
2118 return II;
2125 if (match(II->getArgOperand(0),
2128 assert(II->getArgOperand(1)->getType() == InnerMask->getType() &&
2132 Value *NewMask = Builder.CreateAnd(II->getArgOperand(1), InnerMask);
2141 isKnownNonZero(II, getSimplifyQuery().getWithInstruction(II)))) {
2162 if (Instruction *I = foldIntrinsicWithOverflowCommon(II))
2170 Value *Arg0 = II->getArgOperand(0);
2171 Value *Arg1 = II->getArgOperand(1);
2182 *II, Builder.CreateBinaryIntrinsic(
2191 if (Instruction *I = foldIntrinsicWithOverflowCommon(II))
2196 if (Instruction *I = foldIntrinsicWithOverflowCommon(II))
2200 Value *Arg0 = II->getArgOperand(0);
2201 Value *Arg1 = II->getArgOperand(1);
2211 *II, Builder.CreateBinaryIntrinsic(Intrinsic::sadd_with_overflow,
2222 SaturatingInst *SI = cast<SaturatingInst>(II);
2270 *II, Builder.CreateBinaryIntrinsic(
2303 *II, Builder.CreateBinaryIntrinsic(
2304 IID, X, ConstantInt::get(II->getType(), NewVal)));
2314 Value *Arg0 = II->getArgOperand(0);
2315 Value *Arg1 = II->getArgOperand(1);
2339 Value *NewCall = Builder.CreateBinaryIntrinsic(NewIID, X, Y, II);
2341 FNeg->copyIRFlags(II);
2371 IID, X, ConstantFP::get(Arg0->getType(), Res), II);
2377 return replaceInstUsesWith(*II, V);
2386 Builder.CreateBinaryIntrinsic(IID, X, Y, II, II->getName());
2387 return new FPExtInst(NewCall, II->getType());
2404 Value *R = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, X, II);
2406 R = Builder.CreateFNegFMF(R, II);
2407 return replaceInstUsesWith(*II, R);
2417 if (match(II->getArgOperand(0), m_FNeg(m_Value(A))) &&
2418 match(II->getArgOperand(1), m_FNeg(m_Value(B)))) {
2419 replaceOperand(*II, 0, A);
2420 replaceOperand(*II, 1, B);
2421 return II;
2424 Value *Op0 = II->getOperand(0);
2425 Value *Op1 = II->getOperand(1);
2444 Value *OtherOp = II->getOperand(OtherOpArg);
2445 VectorType *RetTy = cast<VectorType>(II->getType());
2455 replaceOperand(*II, NegatedOpArg, OpNotNeg);
2456 replaceOperand(*II, OtherOpArg, InverseOtherOp);
2457 return II;
2461 SmallVector<Value *, 5> NewArgs(II->args());
2464 Builder.CreateIntrinsic(II->getType(), IID, NewArgs, II);
2465 return replaceInstUsesWith(*II, Builder.CreateFNegFMF(NewMul, II));
2471 if (Value *V = simplifyFMulInst(II->getArgOperand(0), II->getArgOperand(1),
2472 II->getFastMathFlags(),
2473 SQ.getWithInstruction(II))) {
2474 auto *FAdd = BinaryOperator::CreateFAdd(V, II->getArgOperand(2));
2475 FAdd->copyFastMathFlags(II);
2483 Value *Src0 = II->getArgOperand(0);
2484 Value *Src1 = II->getArgOperand(1);
2487 replaceOperand(*II, 0, X);
2488 replaceOperand(*II, 1, Y);
2489 return II;
2495 replaceOperand(*II, 0, X);
2496 replaceOperand(*II, 1, X);
2497 return II;
2502 if (Value *V = simplifyFMAFMul(II->getArgOperand(0), II->getArgOperand(1),
2503 II->getFastMathFlags(),
2504 SQ.getWithInstruction(II))) {
2505 auto *FAdd = BinaryOperator::CreateFAdd(V, II->getArgOperand(2));
2506 FAdd->copyFastMathFlags(II);
2513 if (match(II->getArgOperand(2), m_NegZeroFP()) ||
2514 (match(II->getArgOperand(2), m_PosZeroFP()) &&
2515 II->getFastMathFlags().noSignedZeros()))
2516 return BinaryOperator::CreateFMulFMF(Src0, Src1, II);
2521 Value *Mag = II->getArgOperand(0), *Sign = II->getArgOperand(1);
2523 Sign, /*Depth=*/0, getSimplifyQuery().getWithInstruction(II))) {
2527 Value *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, Mag, II);
2528 return replaceInstUsesWith(*II, Builder.CreateFNegFMF(Fabs, II));
2533 Value *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, Mag, II);
2534 return replaceInstUsesWith(*II, Fabs);
2541 return replaceOperand(*II, 1, X);
2550 return replaceOperand(*II, 0, ConstantFP::get(Mag->getType(), PosMagC));
2557 return replaceOperand(*II, 0, X);
2563 Value *Arg = II->getArgOperand(0);
2567 CallInst *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, X, II);
2574 CallInst *AbsT = Builder.CreateCall(II->getCalledFunction(), {TVal});
2575 CallInst *AbsF = Builder.CreateCall(II->getCalledFunction(), {FVal});
2577 FastMathFlags FMF1 = II->getFastMathFlags();
2585 return replaceOperand(*II, 0, FVal);
2588 return replaceOperand(*II, 0, TVal);
2592 if (match(II->getArgOperand(0),
2596 Builder.CreateCall(II->getCalledFunction(), {Magnitude});
2597 AbsSign->copyFastMathFlags(II);
2598 return replaceInstUsesWith(*II, AbsSign);
2611 if (match(II->getArgOperand(0), m_OneUse(m_FPExt(m_Value(ExtSrc))))) {
2613 Value *NarrowII = Builder.CreateUnaryIntrinsic(IID, ExtSrc, II);
2614 return new FPExtInst(NarrowII, II->getType());
2621 Value *Src = II->getArgOperand(0);
2627 return replaceOperand(*II, 0, X);
2634 if (match(II->getArgOperand(0), m_OneUse(m_FNeg(m_Value(X))))) {
2636 Value *NewSin = Builder.CreateUnaryIntrinsic(IID, X, II);
2637 return UnaryOperator::CreateFNegFMF(NewSin, II);
2654 Value *Src = II->getArgOperand(0);
2655 Value *Exp = II->getArgOperand(1);
2661 FastMathFlags FMF = II->getFastMathFlags();
2665 signBitMustBeTheSame(Exp, InnerExp, SQ.getWithInstruction(II))) {
2669 II->setArgOperand(1, NewExp);
2670 II->setFastMathFlags(InnerFlags); // Or the inner flags.
2671 return replaceOperand(*II, 0, InnerSrc);
2681 Builder.CreateSelect(ExtSrc, ConstantFP::get(II->getType(), 2.0),
2682 ConstantFP::get(II->getType(), 1.0));
2683 return BinaryOperator::CreateFMulFMF(Src, Select, II);
2688 Builder.CreateSelect(ExtSrc, ConstantFP::get(II->getType(), 0.5),
2689 ConstantFP::get(II->getType(), 1.0));
2690 return BinaryOperator::CreateFMulFMF(Src, Select, II);
2698 if (match(II->getArgOperand(1),
2712 Select->takeName(II);
2713 cast<Instruction>(NewLdexp)->copyFastMathFlags(II);
2714 return replaceInstUsesWith(*II, Select);
2724 bool NeedSign = II->getIntrinsicID() == Intrinsic::ptrauth_resign;
2725 Value *Ptr = II->getArgOperand(0);
2726 Value *Key = II->getArgOperand(1);
2727 Value *Disc = II->getArgOperand(2);
2752 if (NeedSign && isa<ConstantInt>(II->getArgOperand(4))) {
2753 auto *SignKey = cast<ConstantInt>(II->getArgOperand(3));
2754 auto *SignDisc = cast<ConstantInt>(II->getArgOperand(4));
2759 *II, ConstantExpr::getPointerCast(NewCPA, II->getType()));
2760 return eraseInstFromFunction(*II);
2764 BasePtr = Builder.CreatePtrToInt(CPA->getPointer(), II->getType());
2780 replaceInstUsesWith(*II, BasePtr);
2781 return eraseInstFromFunction(*II);
2792 CallArgs.push_back(II->getArgOperand(3));
2793 CallArgs.push_back(II->getArgOperand(4));
2796 Function *NewFn = Intrinsic::getDeclaration(II->getModule(), NewIntrin);
2801 if (Value *V = simplifyNeonTbl1(*II, Builder))
2802 return replaceInstUsesWith(*II, V);
2809 Value *Arg0 = II->getArgOperand(0);
2810 Value *Arg1 = II->getArgOperand(1);
2814 return replaceInstUsesWith(CI, ConstantAggregateZero::get(II->getType()));
2820 VectorType *NewVT = cast<VectorType>(II->getType());
2837 return CastInst::CreateIntegerCast(Arg0, II->getType(),
2846 Value *DataArg = II->getArgOperand(0);
2847 Value *KeyArg = II->getArgOperand(1);
2853 replaceOperand(*II, 0, Data);
2854 replaceOperand(*II, 1, Key);
2855 return II;
2862 if (auto Op0 = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) {
2867 Value *Bytes = Op0->getArgOperand(1), *Mask = II->getArgOperand(1);
2869 uint64_t Mask1 = computeKnownBits(Mask, 0, II).One.getZExtValue();
2873 return replaceInstUsesWith(*II, Op0->getArgOperand(0));
2889 if (auto *II = dyn_cast<IntrinsicInst>(CI)) {
2890 if (II->getIntrinsicID() == Intrinsic::stackrestore)
2893 if (II->mayHaveSideEffects())
2907 if (IntrinsicInst *SS = dyn_cast<IntrinsicInst>(II->getArgOperand(0))) {
2909 SS->getParent() == II->getParent()) {
2912 for (++BI; &*BI != II; ++BI) {
2943 BasicBlock::iterator BI(II);
2944 Instruction *TI = II->getParent()->getTerminator();
2978 if (II->getFunction()->hasFnAttribute(Attribute::SanitizeAddress) ||
2979 II->getFunction()->hasFnAttribute(Attribute::SanitizeMemory) ||
2980 II->getFunction()->hasFnAttribute(Attribute::SanitizeHWAddress))
2983 if (removeTriviallyEmptyRange(*II, *this, [](const IntrinsicInst &I) {
2989 Value *IIOperand = II->getArgOperand(0);
2991 II->getOperandBundlesAsDefs(OpBundles);
2998 if (isAssumeWithEmptyBundle(*cast<AssumeInst>(II)))
3000 replaceUse(II->getOperandUse(0), ConstantInt::getTrue(II->getContext()));
3006 Instruction *Next = II->getNextNonDebugInstruction();
3013 FunctionType *AssumeIntrinsicTy = II->getFunctionType();
3014 Value *AssumeIntrinsic = II->getCalledOperand();
3018 II->getName());
3019 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic, B, II->getName());
3020 return eraseInstFromFunction(*II);
3025 Builder.CreateNot(A), OpBundles, II->getName());
3027 Builder.CreateNot(B), II->getName());
3028 return eraseInstFromFunction(*II);
3038 isValidAssumeForContext(II, LHS, &DT)) {
3039 MDNode *MD = MDNode::get(II->getContext(), std::nullopt);
3042 return RemoveConditionFromAssume(II);
3052 for (unsigned Idx = 0; Idx < II->getNumOperandBundles(); Idx++) {
3053 OperandBundleUse OBU = II->getOperandBundleAt(Idx);
3082 return RemoveConditionFromAssume(II);
3112 Replacement->insertAfter(II);
3115 return RemoveConditionFromAssume(II);
3121 if (EnableKnowledgeRetention && II->hasOperandBundles()) {
3122 for (unsigned Idx = 0; Idx < II->getNumOperandBundles(); Idx++) {
3123 auto &BOI = II->bundle_op_info_begin()[Idx];
3125 llvm::getKnowledgeFromBundle(cast<AssumeInst>(*II), BOI);
3131 llvm::simplifyRetainedKnowledge(cast<AssumeInst>(II), RK,
3138 Worklist.pushValue(II->op_begin()[BOI.Begin]);
3139 Value::dropDroppableUse(II->op_begin()[BOI.Begin]);
3145 II->op_begin()[BOI.Begin].set(CanonRK.WasOn);
3147 II->op_begin()[BOI.Begin + 1].set(ConstantInt::get(
3148 Type::getInt64Ty(II->getContext()), CanonRK.ArgValue));
3151 return II;
3158 computeKnownBits(IIOperand, Known, 0, II);
3159 if (Known.isAllOnes() && isAssumeWithEmptyBundle(cast<AssumeInst>(*II)))
3160 return eraseInstFromFunction(*II);
3164 CreateNonTerminatorUnreachable(II);
3165 return eraseInstFromFunction(*II);
3170 AC.updateAffectedValues(cast<AssumeInst>(II));
3177 Instruction *NextInst = II->getNextNonDebugInstruction();
3187 Value *CurrCond = II->getArgOperand(0);
3192 Instruction *MoveI = II->getNextNonDebugInstruction();
3196 Temp->moveBefore(II);
3198 replaceOperand(*II, 0, Builder.CreateAnd(CurrCond, NextCond));
3201 return II;
3206 Value *Vec = II->getArgOperand(0);
3207 Value *SubVec = II->getArgOperand(1);
3208 Value *Idx = II->getArgOperand(2);
3209 auto *DstTy = dyn_cast<FixedVectorType>(II->getType());
3252 Value *Vec = II->getArgOperand(0);
3253 Value *Idx = II->getArgOperand(1);
3255 Type *ReturnType = II->getType();
3309 Value *Vec = II->getArgOperand(0);
3318 II->getIterator()));
3324 II->getIterator()));
3331 OldBinOp->getName(), II->getIterator()));
3338 II->getIterator());
3352 Value *Arg = II->getArgOperand(0);
3357 replaceUse(II->getOperandUse(0), NewOp);
3358 return II;
3376 II->getType());
3390 Value *Arg = II->getArgOperand(0);
3395 replaceUse(II->getOperandUse(0), NewOp);
3396 return II;
3405 if (Res->getType() != II->getType())
3406 Res = Builder.CreateZExtOrTrunc(Res, II->getType());
3425 Value *Arg = II->getArgOperand(0);
3430 replaceUse(II->getOperandUse(0), NewOp);
3431 return II;
3440 II->getType());
3455 Value *Arg = II->getArgOperand(0);
3460 replaceUse(II->getOperandUse(0), NewOp);
3461 return II;
3468 if (Res->getType() != II->getType())
3469 Res = Builder.CreateZExt(Res, II->getType());
3486 Value *Arg = II->getArgOperand(0);
3491 replaceUse(II->getOperandUse(0), NewOp);
3492 return II;
3503 II->getType());
3528 Value *Arg = II->getArgOperand(0);
3533 replaceUse(II->getOperandUse(0), NewOp);
3534 return II;
3548 Res = Builder.CreateCast(ExtOpc, Res, II->getType());
3561 II->hasAllowReassoc();
3566 Value *Arg = II->getArgOperand(ArgIdx);
3568 replaceUse(II->getOperandUse(ArgIdx), NewOp);
3574 if (Instruction *I = foldIntrinsicIsFPClass(*II))
3579 Align MinAlign = getKnownAlignment(II->getArgOperand(0), DL, II, &AC, &DT);
3580 MaybeAlign Align = II->getRetAlign();
3582 II->addRetAttr(Attribute::getWithAlignment(II->getContext(), MinAlign));
3583 return II;
3589 std::optional<Instruction *> V = targetInstCombineIntrinsic(*II);
3612 for (Value *Op : II->args())
3614 if (Instruction *R = FoldOpIntoSelect(*II, Sel))
3621 if (Instruction *Shuf = foldShuffledIntrinsicOperands(II, Builder))
3626 return visitCallBase(*II);
3658 Instruction *InstCombinerImpl::visitInvokeInst(InvokeInst &II) {
3659 return visitCallBase(II);
3704 IntrinsicInst *II = dyn_cast<IntrinsicInst>(U);
3705 if (!II)
3707 if (II->getIntrinsicID() == Intrinsic::init_trampoline) {
3711 InitTrampoline = II;
3714 if (II->getIntrinsicID() == Intrinsic::adjust_trampoline)
3739 if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I))
3740 if (II->getIntrinsicID() == Intrinsic::init_trampoline &&
3741 II->getOperand(0) == TrampMem)
3742 return II;
3912 if (IntrinsicInst *II = findInitTrampoline(Callee))
3913 return transformCallThroughTrampoline(Call, *II);
4141 if (auto *II = dyn_cast<InvokeInst>(Caller))
4142 PhisNotSupportedBlock = II->getNormalDest();
4297 if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
4298 NewCall = Builder.CreateInvoke(Callee, II->getNormalDest(),
4299 II->getUnwindDest(), Args, OpBundles);
4455 if (InvokeInst *II = dyn_cast<InvokeInst>(&Call)) {
4456 NewCaller = InvokeInst::Create(NewFTy, NestF, II->getNormalDest(),
4457 II->getUnwindDest(), NewArgs, OpBundles);
4458 cast<InvokeInst>(NewCaller)->setCallingConv(II->getCallingConv());