46#define DEBUG_TYPE "instcombine"
50using namespace PatternMatch;
67 IsEq = Pred == ICmpInst::ICMP_EQ;
68 else if (Pred == FCmpInst::FCMP_OEQ)
70 else if (Pred == FCmpInst::FCMP_UNE)
100 if (isa<FPMathOperator>(BO))
124 const APInt *SelTC, *SelFC;
131 if (SelType->
isVectorTy() != Cmp->getType()->isVectorTy())
136 bool CreateAnd =
false;
142 V = Cmp->getOperand(0);
149 Cmp->getOperand(1), Pred)) {
151 if (!Res->Mask.isPowerOf2())
161 if (Pred == ICmpInst::ICMP_NE)
168 const APInt &TC = *SelTC;
169 const APInt &FC = *SelFC;
170 if (!TC.
isZero() && !FC.isZero()) {
175 if (CreateAnd && !Cmp->hasOneUse())
182 Constant *TCC = ConstantInt::get(SelType, TC);
183 Constant *FCC = ConstantInt::get(SelType, FC);
184 Constant *MaskC = ConstantInt::get(SelType, AndMask);
185 for (
auto Opc : {Instruction::Or, Instruction::Xor, Instruction::Add,
205 unsigned ValZeros = ValC.
logBase2();
206 unsigned AndZeros = AndMask.
logBase2();
207 bool ShouldNotVal = !TC.
isZero();
212 if (CreateAnd && ShouldNotVal && ValZeros != AndZeros)
217 V = Builder.
CreateAnd(V, ConstantInt::get(V->getType(), AndMask));
221 if (ValZeros > AndZeros) {
223 V = Builder.
CreateShl(V, ValZeros - AndZeros);
224 }
else if (ValZeros < AndZeros) {
225 V = Builder.
CreateLShr(V, AndZeros - ValZeros);
250 switch (
I->getOpcode()) {
251 case Instruction::Add:
252 case Instruction::FAdd:
253 case Instruction::Mul:
254 case Instruction::FMul:
255 case Instruction::And:
256 case Instruction::Or:
257 case Instruction::Xor:
259 case Instruction::Sub:
260 case Instruction::FSub:
261 case Instruction::FDiv:
262 case Instruction::Shl:
263 case Instruction::LShr:
264 case Instruction::AShr:
294 if (
auto *CondVTy = dyn_cast<VectorType>(CondTy)) {
296 CondVTy->getElementCount() !=
297 cast<VectorType>(FIOpndTy)->getElementCount())
308 if (TI->
getOpcode() != Instruction::BitCast &&
321 SI.getName() +
".v", &SI);
326 Value *OtherOpT, *OtherOpF;
329 bool Swapped =
false) ->
Value * {
330 assert(!(Commute && Swapped) &&
331 "Commute and Swapped can't set at the same time");
336 MatchIsOpZero =
true;
341 MatchIsOpZero =
false;
346 if (!Commute && !Swapped)
355 MatchIsOpZero =
true;
360 MatchIsOpZero =
false;
374 FMF |= SI.getFastMathFlags();
377 if (
auto *NewSelI = dyn_cast<Instruction>(NewSel))
378 NewSelI->setFastMathFlags(FMF);
379 Instruction *NewFNeg = UnaryOperator::CreateFNeg(NewSel);
388 auto *
TII = dyn_cast<IntrinsicInst>(TI);
389 auto *FII = dyn_cast<IntrinsicInst>(FI);
390 if (
TII && FII &&
TII->getIntrinsicID() == FII->getIntrinsicID()) {
392 if (
Value *MatchOp = getCommonOp(TI, FI,
true)) {
404 if (
TII->getIntrinsicID() == Intrinsic::ldexp) {
405 Value *LdexpVal0 =
TII->getArgOperand(0);
406 Value *LdexpExp0 =
TII->getArgOperand(1);
407 Value *LdexpVal1 = FII->getArgOperand(0);
408 Value *LdexpExp1 = FII->getArgOperand(1);
412 FMF &= cast<FPMathOperator>(FII)->getFastMathFlags();
419 TII->
getType(), Intrinsic::ldexp, {SelectVal, SelectExp});
426 auto CreateCmpSel = [&](std::optional<CmpPredicate>
P,
435 SI.getName() +
".v", &SI);
463 (!isa<BinaryOperator>(TI) && !isa<GetElementPtrInst>(TI)) ||
485 auto *BO = dyn_cast<BinaryOperator>(TI);
489 if (BO->getOpcode() == Instruction::SDiv ||
490 BO->getOpcode() == Instruction::SRem || MatchIsOpZero)
496 SI.getName() +
".v", &SI);
497 Value *Op0 = MatchIsOpZero ? MatchOp : NewSI;
498 Value *Op1 = MatchIsOpZero ? NewSI : MatchOp;
499 if (
auto *BO = dyn_cast<BinaryOperator>(TI)) {
505 if (
auto *TGEP = dyn_cast<GetElementPtrInst>(TI)) {
506 auto *FGEP = cast<GetElementPtrInst>(FI);
507 Type *ElementType = TGEP->getSourceElementType();
509 ElementType, Op0, Op1, TGEP->getNoWrapFlags() & FGEP->getNoWrapFlags());
530 auto *TVI = dyn_cast<BinaryOperator>(TrueVal);
531 if (!TVI || !TVI->hasOneUse() || isa<Constant>(FalseVal))
535 unsigned OpToFold = 0;
536 if ((SFO & 1) && FalseVal == TVI->getOperand(0))
538 else if ((SFO & 2) && FalseVal == TVI->getOperand(1))
545 if (isa<FPMathOperator>(&SI))
546 FMF = SI.getFastMathFlags();
548 TVI->getOpcode(), TVI->getType(),
true, FMF.
noSignedZeros());
549 Value *OOp = TVI->getOperand(2 - OpToFold);
554 if (isa<Constant>(OOp) &&
555 (!OOpIsAPInt || !
isSelect01(
C->getUniqueInteger(), *OOpC)))
564 if (isa<FPMathOperator>(&SI) &&
569 Swapped ? OOp :
C,
"", &SI);
570 if (isa<FPMathOperator>(&SI))
571 cast<Instruction>(NewSel)->setFastMathFlags(FMF);
576 if (isa<FPMathOperator>(&SI)) {
587 if (
Instruction *R = TryFoldSelectIntoOp(SI, TrueVal, FalseVal,
false))
590 if (
Instruction *R = TryFoldSelectIntoOp(SI, FalseVal, TrueVal,
true))
607 if (!(Cmp->hasOneUse() && Cmp->getOperand(0)->hasOneUse() &&
639 Constant *One = ConstantInt::get(SelType, 1);
644 return new ZExtInst(ICmpNeZero, SelType);
666 const APInt *C2, *C1;
676 auto *FI = dyn_cast<Instruction>(FVal);
680 FI->setHasNoSignedWrap(
false);
681 FI->setHasNoUnsignedWrap(
false);
716 const auto *Ashr = cast<Instruction>(FalseVal);
718 bool IsExact = Ashr->isExact() && cast<Instruction>(TrueVal)->isExact();
750 if (!TrueVal->getType()->isIntOrIntVectorTy() ||
771 if (!Res || !Res->Mask.isPowerOf2())
776 C1Log = Res->Mask.logBase2();
786 BinOp = cast<BinaryOperator>(FalseVal);
790 BinOp = cast<BinaryOperator>(TrueVal);
800 if (IdentityC ==
nullptr || !IdentityC->isNullValue())
805 bool NeedShift = C1Log != C2Log;
806 bool NeedZExtTrunc =
Y->getType()->getScalarSizeInBits() !=
807 V->getType()->getScalarSizeInBits();
810 if ((NeedShift + NeedXor + NeedZExtTrunc +
NeedAnd) >
817 V = Builder.
CreateAnd(V, ConstantInt::get(V->getType(), C1));
823 }
else if (C1Log > C2Log) {
850 Constant *OrC = ConstantInt::get(Ty, *
C);
852 return BinaryOperator::CreateOr(
T, NewSel);
859 Constant *OrC = ConstantInt::get(Ty, *
C);
861 return BinaryOperator::CreateOr(
F, NewSel);
878 auto *CondVal = SI.getCondition();
879 auto *TrueVal = SI.getTrueValue();
880 auto *FalseVal = SI.getFalseValue();
898 auto *TrueValC = dyn_cast<Constant>(TrueVal);
899 if (TrueValC ==
nullptr ||
901 !isa<Instruction>(FalseVal))
904 auto *ZeroC = cast<Constant>(cast<Instruction>(CondVal)->getOperand(1));
912 auto *FalseValI = cast<Instruction>(FalseVal);
915 IC.
replaceOperand(*FalseValI, FalseValI->getOperand(0) ==
Y ? 0 : 1, FrY);
922 const Value *TrueVal,
923 const Value *FalseVal,
944 ConstantInt::get(
A->getType(), 1));
958 "Unexpected isUnsigned predicate!");
964 bool IsNegative =
false;
977 if (IsNegative && !TrueVal->hasOneUse() && !ICI->
hasOneUse())
990 if (!Cmp->hasOneUse())
994 Value *Cmp0 = Cmp->getOperand(0);
995 Value *Cmp1 = Cmp->getOperand(1);
1016 Intrinsic::uadd_sat, Cmp0, ConstantInt::get(Cmp0->
getType(), 1));
1027 ConstantInt::get(Cmp0->
getType(), *
C));
1037 ConstantInt::get(Cmp0->
getType(), *
C));
1047 ConstantInt::get(Cmp0->
getType(), *
C));
1094 auto *TI = dyn_cast<Instruction>(TVal);
1095 auto *FI = dyn_cast<Instruction>(FVal);
1101 Value *
A = Cmp->getOperand(0);
1102 Value *
B = Cmp->getOperand(1);
1115 (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap()) &&
1116 (FI->hasNoSignedWrap() || FI->hasNoUnsignedWrap())) {
1123 TI->setHasNoUnsignedWrap(
false);
1124 if (!TI->hasNoSignedWrap())
1125 TI->setHasNoSignedWrap(TI->hasOneUse());
1153 if (!
match(FalseVal,
1157 if (!
match(Ctlz, m_Intrinsic<Intrinsic::ctlz>()))
1164 auto *
II = cast<IntrinsicInst>(Ctlz);
1169 II->getModule(), Intrinsic::cttz,
II->getType());
1201 Value *Count =
nullptr;
1209 if (!
match(Count, m_Intrinsic<Intrinsic::cttz>(
m_Value(
X))) &&
1229 II->dropPoisonGeneratingAnnotations();
1241 II->dropUBImplyingAttrsAndMetadata();
1252 if (!
TrueVal->getType()->isIntOrIntVectorTy())
1289 assert(!isa<Constant>(Old) &&
"Only replace non-constant values");
1291 auto *
I = dyn_cast<Instruction>(V);
1292 if (!
I || !
I->hasOneUse() ||
1300 bool Changed =
false;
1301 for (
Use &U :
I->operands()) {
1334 bool Swapped =
false;
1335 if (
Cmp.isEquivalence(
true)) {
1338 }
else if (!
Cmp.isEquivalence()) {
1342 Value *CmpLHS =
Cmp.getOperand(0), *CmpRHS =
Cmp.getOperand(1);
1343 auto ReplaceOldOpWithNewOp = [&](
Value *OldOp,
1351 if (TrueVal == OldOp && (isa<Constant>(OldOp) || !isa<Constant>(NewOp)))
1386 if (
Instruction *R = ReplaceOldOpWithNewOp(CmpLHS, CmpRHS))
1388 if (
Instruction *R = ReplaceOldOpWithNewOp(CmpRHS, CmpLHS))
1391 auto *FalseInst = dyn_cast<Instruction>(FalseVal);
1406 &DropFlags) == TrueVal ||
1409 &DropFlags) == TrueVal) {
1411 I->dropPoisonGeneratingAnnotations();
1456 cast<ICmpInst>(XeqY)->setSameSign(
false);
1491 if (!isa<SelectInst>(Sel1)) {
1532 if (Cmp00->
getType() !=
X->getType() &&
X->hasOneUse())
1540 else if (!
match(Cmp00,
1548 Value *ReplacementLow, *ReplacementHigh;
1585 std::swap(ReplacementLow, ReplacementHigh);
1591 "Unexpected predicate type.");
1599 "Unexpected predicate type.");
1601 std::swap(ThresholdLowIncl, ThresholdHighExcl);
1617 if (
X->getType() != Sel0.
getType()) {
1627 assert(ReplacementLow && ReplacementHigh &&
1628 "Constant folding of ImmConstant cannot fail");
1634 Value *MaybeReplacedLow =
1640 ShouldReplaceHigh, ReplacementHigh, MaybeReplacedLow);
1684 Value *SelVal0, *SelVal1;
1693 auto MatchesSelectValue = [SelVal0, SelVal1](
Constant *
C) {
1694 return C->isElementWiseEqual(SelVal0) ||
C->isElementWiseEqual(SelVal1);
1698 if (MatchesSelectValue(C0))
1703 if (!FlippedStrictness)
1707 if (!MatchesSelectValue(FlippedStrictness->second))
1716 Cmp.getName() +
".inv");
1727 if (!
Cmp->hasOneUse())
1757 Value *TVal =
SI.getTrueValue();
1758 Value *FVal =
SI.getFalseValue();
1784 const APInt *BinOpC;
1852 foldSelectWithExtremeEqCond(CmpLHS, CmpRHS, TrueVal, FalseVal))
1902 Opcode, Flipped->second, C2,
DL)) {
1904 RHS = Flipped->second;
1918 canonicalizeSPF(*ICI,
SI.getTrueValue(),
SI.getFalseValue(), *
this))
1921 if (
Value *V = foldSelectInstWithICmpConst(SI, ICI,
Builder))
1924 if (
Value *V = canonicalizeClampLike(SI, *ICI,
Builder, *
this))
1928 tryToReuseConstantFromSelectInComparison(SI, *ICI, *
this))
1935 bool Changed =
false;
1942 if (
Instruction *NewSel = foldSelectICmpEq(SI, ICI, *
this))
1957 SI.swapProfMetadata();
1980 if (
Value *V = foldSelectCttzCtlz(ICI, TrueVal, FalseVal, *
this))
1992 if (
Value *V = foldSelectWithConstOpToBinOp(ICI, TrueVal, FalseVal,
Builder))
1995 return Changed ? &
SI :
nullptr;
2008 if (
C ==
A ||
C ==
B) {
2023 Value *CondVal =
SI.getCondition();
2026 auto *TI = dyn_cast<Instruction>(TrueVal);
2027 auto *FI = dyn_cast<Instruction>(FalseVal);
2028 if (!TI || !FI || !TI->hasOneUse() || !FI->hasOneUse())
2032 if ((TI->getOpcode() == Instruction::Sub &&
2033 FI->getOpcode() == Instruction::Add) ||
2034 (TI->getOpcode() == Instruction::FSub &&
2035 FI->getOpcode() == Instruction::FAdd)) {
2038 }
else if ((FI->getOpcode() == Instruction::Sub &&
2039 TI->getOpcode() == Instruction::Add) ||
2040 (FI->getOpcode() == Instruction::FSub &&
2041 TI->getOpcode() == Instruction::FAdd)) {
2047 Value *OtherAddOp =
nullptr;
2048 if (SubOp->getOperand(0) == AddOp->
getOperand(0)) {
2050 }
else if (SubOp->getOperand(0) == AddOp->
getOperand(1)) {
2058 if (
SI.getType()->isFPOrFPVectorTy()) {
2059 NegVal = Builder.
CreateFNeg(SubOp->getOperand(1));
2060 if (
Instruction *NegInst = dyn_cast<Instruction>(NegVal)) {
2062 Flags &= SubOp->getFastMathFlags();
2063 NegInst->setFastMathFlags(Flags);
2066 NegVal = Builder.
CreateNeg(SubOp->getOperand(1));
2069 Value *NewTrueOp = OtherAddOp;
2070 Value *NewFalseOp = NegVal;
2074 SI.getName() +
".p", &SI);
2076 if (
SI.getType()->isFPOrFPVectorTy()) {
2078 BinaryOperator::CreateFAdd(SubOp->getOperand(0), NewSel);
2081 Flags &= SubOp->getFastMathFlags();
2085 return BinaryOperator::CreateAdd(SubOp->getOperand(0), NewSel);
2098 Value *CondVal =
SI.getCondition();
2110 auto IsSignedSaturateLimit = [&](
Value *Limit,
bool IsAdd) {
2120 auto IsZeroOrOne = [](
const APInt &
C) {
return C.isZero() ||
C.isOne(); };
2137 IsMinMax(TrueVal, FalseVal))
2144 IsMinMax(FalseVal, TrueVal))
2150 IsMinMax(TrueVal, FalseVal))
2155 IsMinMax(FalseVal, TrueVal))
2160 IsMinMax(FalseVal, TrueVal))
2165 IsMinMax(TrueVal, FalseVal))
2173 if (
II->getIntrinsicID() == Intrinsic::uadd_with_overflow &&
2176 NewIntrinsicID = Intrinsic::uadd_sat;
2177 else if (
II->getIntrinsicID() == Intrinsic::usub_with_overflow &&
2180 NewIntrinsicID = Intrinsic::usub_sat;
2181 else if (
II->getIntrinsicID() == Intrinsic::sadd_with_overflow &&
2182 IsSignedSaturateLimit(TrueVal,
true))
2191 NewIntrinsicID = Intrinsic::sadd_sat;
2192 else if (
II->getIntrinsicID() == Intrinsic::ssub_with_overflow &&
2193 IsSignedSaturateLimit(TrueVal,
false))
2202 NewIntrinsicID = Intrinsic::ssub_sat;
2207 NewIntrinsicID,
SI.getType());
2223 if (ExtOpcode != Instruction::ZExt && ExtOpcode != Instruction::SExt)
2229 Type *SmallType =
X->getType();
2231 auto *
Cmp = dyn_cast<CmpInst>(
Cond);
2233 (!Cmp ||
Cmp->getOperand(0)->getType() != SmallType))
2241 Value *TruncCVal = cast<Value>(TruncC);
2257 Value *CondVal =
SI.getCondition();
2259 auto *CondValTy = dyn_cast<FixedVectorType>(CondVal->
getType());
2263 unsigned NumElts = CondValTy->getNumElements();
2265 Mask.reserve(NumElts);
2266 for (
unsigned i = 0; i != NumElts; ++i) {
2276 Mask.push_back(i + NumElts);
2277 }
else if (isa<UndefValue>(Elt)) {
2297 auto *Ty = dyn_cast<VectorType>(Sel.
getType());
2329 if (TVal ==
A || TVal ==
B || FVal ==
A || FVal ==
B)
2346 if (TSrc ==
C && FSrc ==
D) {
2350 }
else if (TSrc ==
D && FSrc ==
C) {
2389 auto *Extract = dyn_cast<ExtractValueInst>(V);
2392 if (Extract->getIndices()[0] !=
I)
2394 return dyn_cast<AtomicCmpXchgInst>(Extract->getAggregateOperand());
2400 if (
auto *
Select = dyn_cast<SelectInst>(
SI.user_back()))
2401 if (
Select->getCondition() ==
SI.getCondition())
2402 if (
Select->getFalseValue() ==
SI.getTrueValue() ||
2403 Select->getTrueValue() ==
SI.getFalseValue())
2407 auto *CmpXchg = isExtractFromCmpXchg(
SI.getCondition(), 1);
2414 if (
auto *
X = isExtractFromCmpXchg(
SI.getTrueValue(), 0))
2415 if (
X == CmpXchg &&
X->getCompareOperand() ==
SI.getFalseValue())
2416 return SI.getFalseValue();
2421 if (
auto *
X = isExtractFromCmpXchg(
SI.getFalseValue(), 0))
2422 if (
X == CmpXchg &&
X->getCompareOperand() ==
SI.getTrueValue())
2423 return SI.getFalseValue();
2447 Value *SV0, *SV1, *SA0, *SA1;
2456 if (Or0->
getOpcode() == BinaryOperator::LShr) {
2462 Or1->
getOpcode() == BinaryOperator::LShr &&
2463 "Illegal or(shift,shift) pair");
2478 bool IsFshl = (ShAmt == SA0);
2480 if ((IsFshl && TVal != SV0) || (!IsFshl && TVal != SV1))
2500 Intrinsic::ID IID = IsFshl ? Intrinsic::fshl : Intrinsic::fshr;
2522 assert(TC != FC &&
"Expected equal select arms to simplify");
2526 bool IsTrueIfSignSet;
2544 Value *MagArg = ConstantFP::get(SelType,
abs(*TC));
2551 if (!isa<VectorType>(Sel.
getType()))
2562 if (
auto *
I = dyn_cast<Instruction>(V))
2563 I->copyIRFlags(&Sel);
2566 M, Intrinsic::vector_reverse,
V->getType());
2574 return createSelReverse(
C,
X,
Y);
2578 return createSelReverse(
C,
X, FVal);
2583 return createSelReverse(
C, TVal,
Y);
2586 auto *VecTy = dyn_cast<FixedVectorType>(Sel.
getType());
2590 unsigned NumElts = VecTy->getNumElements();
2591 APInt PoisonElts(NumElts, 0);
2605 cast<ShuffleVectorInst>(TVal)->isSelect()) {
2619 cast<ShuffleVectorInst>(FVal)->isSelect()) {
2640 auto *IDomNode = DT[BB]->getIDom();
2646 Value *IfTrue, *IfFalse;
2662 if (TrueSucc == FalseSucc)
2683 if (
auto *
Insn = dyn_cast<Instruction>(Inputs[Pred]))
2702 if (
auto *
I = dyn_cast<Instruction>(V))
2703 CandidateBlocks.
insert(
I->getParent());
2706 if (
auto *PN = foldSelectToPhiImpl(Sel, BB, DT, Builder))
2719 Value *CondVal =
SI.getCondition();
2724 Value *
Op, *RemRes, *Remainder;
2726 bool TrueIfSigned =
false;
2740 return BinaryOperator::CreateAnd(
Op,
Add);
2752 return FoldToBitwiseAnd(Remainder);
2761 return FoldToBitwiseAnd(ConstantInt::get(RemRes->
getType(), 2));
2797 Value *InnerCondVal =
SI.getCondition();
2798 Value *InnerTrueVal =
SI.getTrueValue();
2799 Value *InnerFalseVal =
SI.getFalseValue();
2801 "The type of inner condition must match with the outer.");
2803 return *Implied ? InnerTrueVal : InnerFalseVal;
2810 assert(
Op->getType()->isIntOrIntVectorTy(1) &&
2811 "Op must be either i1 or vector of i1.");
2812 if (
SI.getCondition()->getType() !=
Op->getType())
2814 if (
Value *V = simplifyNestedSelectsUsingImpliedCond(SI,
Op, IsAnd,
DL))
2825 Value *CondVal =
SI.getCondition();
2827 bool ChangedFMF =
false;
2828 for (
bool Swap : {
false,
true}) {
2858 FastMathFlags FMF = cast<FPMathOperator>(TrueVal)->getFastMathFlags();
2859 if (FMF.
noNaNs() && !
SI.hasNoNaNs()) {
2860 SI.setHasNoNaNs(
true);
2863 if (FMF.
noInfs() && !
SI.hasNoInfs()) {
2864 SI.setHasNoInfs(
true);
2878 if (!
SI.hasNoSignedZeros() || !
SI.hasNoNaNs())
2895 Instruction *NewFNeg = UnaryOperator::CreateFNeg(Fabs);
2904 for (
bool Swap : {
false,
true}) {
2920 if (Swap == TrueIfSigned && !CondVal->
hasOneUse() && !
TrueVal->hasOneUse())
2926 if (Swap != TrueIfSigned)
2931 return ChangedFMF ? &
SI :
nullptr;
2949foldRoundUpIntegerWithPow2Alignment(
SelectInst &SI,
2953 Value *XBiasedHighBits =
SI.getFalseValue();
2966 const APInt *LowBitMaskCst;
2971 const APInt *BiasCst, *HighBitMaskCst;
2972 if (!
match(XBiasedHighBits,
2975 !
match(XBiasedHighBits,
2980 if (!LowBitMaskCst->
isMask())
2983 APInt InvertedLowBitMaskCst = ~*LowBitMaskCst;
2984 if (InvertedLowBitMaskCst != *HighBitMaskCst)
2987 APInt AlignmentCst = *LowBitMaskCst + 1;
2989 if (*BiasCst != AlignmentCst && *BiasCst != *LowBitMaskCst)
2994 if (*BiasCst == *LowBitMaskCst &&
impliesPoison(XBiasedHighBits,
X))
2995 return XBiasedHighBits;
3000 Type *Ty =
X->getType();
3001 Value *XOffset = Builder.
CreateAdd(
X, ConstantInt::get(Ty, *LowBitMaskCst),
3002 X->getName() +
".biased");
3003 Value *
R = Builder.
CreateAnd(XOffset, ConstantInt::get(Ty, *HighBitMaskCst));
3009struct DecomposedSelect {
3021foldSelectOfSymmetricSelect(
SelectInst &OuterSelVal,
3024 Value *OuterCond, *InnerCond, *InnerTrueVal, *InnerFalseVal;
3052 DecomposedSelect OuterSel;
3059 std::swap(OuterSel.TrueVal, OuterSel.FalseVal);
3067 Value *InnerSelVal = IsAndVariant ? OuterSel.FalseVal : OuterSel.TrueVal;
3071 [](
Value *V) {
return V->hasOneUse(); }))
3075 DecomposedSelect InnerSel;
3076 if (!
match(InnerSelVal,
3083 std::swap(InnerSel.TrueVal, InnerSel.FalseVal);
3085 Value *AltCond =
nullptr;
3086 auto matchOuterCond = [OuterSel, IsAndVariant, &AltCond](
auto m_InnerCond) {
3091 return IsAndVariant ?
match(OuterSel.Cond,
3101 if (matchOuterCond(
m_Specific(InnerSel.Cond))) {
3106 std::swap(InnerSel.TrueVal, InnerSel.FalseVal);
3107 InnerSel.Cond = NotInnerCond;
3112 AltCond, IsAndVariant ? OuterSel.TrueVal : InnerSel.FalseVal,
3113 IsAndVariant ? InnerSel.TrueVal : OuterSel.FalseVal);
3116 IsAndVariant ? SelInner : InnerSel.TrueVal,
3117 !IsAndVariant ? SelInner : InnerSel.FalseVal);
3123static bool impliesPoisonOrCond(
const Value *ValAssumedPoison,
const Value *V,
3130 if (
auto *ICmp = dyn_cast<ICmpInst>(ValAssumedPoison)) {
3135 if (ICmp->hasSameSign() &&
3154 Value *CondVal =
SI.getCondition();
3157 Type *SelType =
SI.getType();
3174 if (impliesPoisonOrCond(FalseVal, CondVal,
false)) {
3176 return BinaryOperator::CreateOr(CondVal, FalseVal);
3180 impliesPoisonOrCond(FalseVal,
B,
false)) {
3190 bool CondLogicAnd = isa<SelectInst>(CondVal);
3191 bool FalseLogicAnd = isa<SelectInst>(FalseVal);
3192 auto AndFactorization = [&](
Value *Common,
Value *InnerCond,
3198 if (FalseLogicAnd || (CondLogicAnd && Common ==
A))
3201 return BinaryOperator::CreateAnd(Common, InnerSel);
3205 return AndFactorization(
A,
B,
D);
3207 return AndFactorization(
A,
B,
C);
3209 return AndFactorization(
B,
A,
D);
3211 return AndFactorization(
B,
A,
C, CondLogicAnd && FalseLogicAnd);
3216 if (impliesPoisonOrCond(TrueVal, CondVal,
true)) {
3218 return BinaryOperator::CreateAnd(CondVal, TrueVal);
3222 impliesPoisonOrCond(TrueVal,
B,
true)) {
3232 bool CondLogicOr = isa<SelectInst>(CondVal);
3233 bool TrueLogicOr = isa<SelectInst>(TrueVal);
3234 auto OrFactorization = [&](
Value *Common,
Value *InnerCond,
3240 if (TrueLogicOr || (CondLogicOr && Common ==
A))
3243 return BinaryOperator::CreateOr(Common, InnerSel);
3247 return OrFactorization(
A,
B,
D);
3249 return OrFactorization(
A,
B,
C);
3251 return OrFactorization(
B,
A,
D);
3253 return OrFactorization(
B,
A,
C, CondLogicOr && TrueLogicOr);
3296 return BinaryOperator::CreateXor(
A,
B);
3330 auto *FI =
new FreezeInst(*
Y, (*Y)->getName() +
".fr");
3336 if (
auto *V = foldBooleanAndOr(CondVal, Op1, SI, IsAnd,
3347 if (Res && *Res ==
false)
3353 if (Res && *Res ==
false)
3362 if (Res && *Res ==
true)
3368 if (Res && *Res ==
true)
3381 auto *SelCond = dyn_cast<SelectInst>(CondVal);
3382 auto *SelFVal = dyn_cast<SelectInst>(FalseVal);
3383 bool MayNeedFreeze = SelCond && SelFVal &&
3384 match(SelFVal->getTrueValue(),
3397 auto *SelCond = dyn_cast<SelectInst>(CondVal);
3398 auto *SelFVal = dyn_cast<SelectInst>(FalseVal);
3399 bool MayNeedFreeze = SelCond && SelFVal &&
3400 match(SelCond->getTrueValue(),
3416 bool &ShouldDropNUW) {
3439 ShouldDropNUW =
false;
3445 auto MatchForward = [&](
Value *CommonAncestor) {
3446 const APInt *
C =
nullptr;
3447 if (CtlzOp == CommonAncestor)
3454 ShouldDropNUW =
true;
3465 const APInt *
C =
nullptr;
3466 Value *CommonAncestor;
3467 if (MatchForward(Cond0)) {
3471 if (!MatchForward(CommonAncestor))
3509 Type *SelType =
SI.getType();
3516 Value *Cond0, *Ctlz, *CtlzOp;
3532 !isSafeToRemoveBitCeilSelect(Pred, Cond0, Cond1, CtlzOp,
BitWidth,
3537 cast<Instruction>(CtlzOp)->setHasNoUnsignedWrap(
false);
3545 cast<Instruction>(Ctlz)->dropPoisonGeneratingAnnotations();
3562 Value *TV =
SI.getTrueValue();
3563 Value *FV =
SI.getFalseValue();
3584 bool Replace =
false;
3606 const APInt *InnerTV, *InnerFV;
3612 FalseBranchSelectPredicate =
3617 if (!InnerTV->
isOne()) {
3629 Intrinsic::ID IID = IsSigned ? Intrinsic::scmp : Intrinsic::ucmp;
3651 FastMathFlags FMF = cast<FPMathOperator>(TrueVal)->getFastMathFlags();
3673 if (
auto *
I = dyn_cast<Instruction>(V)) {
3674 if (isa<PHINode>(
I)) {
3680 return Op->getType()->isIntOrIntVectorTy() &&
3681 hasAffectedValue(Op, Affected, Depth + 1);
3694 auto *SIFOp = dyn_cast<FPMathOperator>(&SI);
3695 if (!SIFOp || !SIFOp->hasNoSignedZeros() || !SIFOp->hasNoNaNs())
3698 auto TryFoldIntoAddConstant =
3710 Swapped ?
X :
Z,
"", &
SI);
3721 cast<Instruction>(NewFAdd)->setFastMathFlags(NewFMF);
3722 cast<Instruction>(NewSelect)->setFastMathFlags(NewFMF);
3741 return TryFoldIntoAddConstant(Pred,
X, Z,
FAdd,
C,
false);
3745 return TryFoldIntoAddConstant(Pred,
X, Z,
FAdd,
C,
true);
3751 Value *CondVal =
SI.getCondition();
3754 Type *SelType =
SI.getType();
3763 if (
Instruction *
I = canonicalizeScalarSelectOfVecs(SI, *
this))
3805 return new ZExtInst(CondVal, SelType);
3809 return new SExtInst(CondVal, SelType);
3814 return new ZExtInst(NotCond, SelType);
3820 return new SExtInst(NotCond, SelType);
3824 auto *SIFPOp = dyn_cast<FPMathOperator>(&SI);
3826 if (
auto *FCmp = dyn_cast<FCmpInst>(CondVal)) {
3828 Value *Cmp0 = FCmp->getOperand(0), *Cmp1 = FCmp->getOperand(1);
3830 if ((Cmp0 == TrueVal && Cmp1 == FalseVal) ||
3831 (Cmp0 == FalseVal && Cmp1 == TrueVal)) {
3841 FCmp->getName() +
".inv");
3862 Value *MatchCmp0 =
nullptr;
3863 Value *MatchCmp1 =
nullptr;
3875 if (Cmp0 == MatchCmp0 &&
3876 matchFMulByZeroIfResultEqZero(*
this, Cmp0, Cmp1, MatchCmp1, MatchCmp0,
3877 SI, SIFPOp->hasNoSignedZeros()))
3885 auto *FCmp = dyn_cast<FCmpInst>(CondVal);
3889 if (SIFPOp->hasNoNaNs() && SIFPOp->hasNoSignedZeros()) {
3894 if (
auto *BinIntrInst = dyn_cast<Instruction>(BinIntr))
3895 BinIntrInst->setHasNoNaNs(FCmp->hasNoNaNs());
3902 if (
auto *BinIntrInst = dyn_cast<Instruction>(BinIntr))
3903 BinIntrInst->setHasNoNaNs(FCmp->hasNoNaNs());
3910 if (
Instruction *Fabs = foldSelectWithFCmpToFabs(SI, *
this))
3914 if (
CmpInst *CI = dyn_cast<CmpInst>(CondVal))
3918 if (
ICmpInst *ICI = dyn_cast<ICmpInst>(CondVal))
3932 auto *TI = dyn_cast<Instruction>(TrueVal);
3933 auto *FI = dyn_cast<Instruction>(FalseVal);
3934 if (TI && FI && TI->getOpcode() == FI->
getOpcode())
3953 if (isa<VectorType>(CondVal->
getType()) && !isa<VectorType>(
Idx->getType()))
3965 if (
auto *TrueGep = dyn_cast<GetElementPtrInst>(TrueVal))
3966 if (
auto *NewGep = SelectGepWithBase(TrueGep, FalseVal,
false))
3968 if (
auto *FalseGep = dyn_cast<GetElementPtrInst>(FalseVal))
3969 if (
auto *NewGep = SelectGepWithBase(FalseGep, TrueVal,
true))
3985 RHS2, SI, SPF, RHS))
3989 RHS2, SI, SPF, LHS))
3998 bool IsCastNeeded =
LHS->
getType() != SelType;
3999 Value *CmpLHS = cast<CmpInst>(CondVal)->getOperand(0);
4000 Value *CmpRHS = cast<CmpInst>(CondVal)->getOperand(1);
4003 ((CmpLHS != LHS && CmpLHS != RHS) ||
4004 (CmpRHS != LHS && CmpRHS != RHS)))) {
4012 cast<Instruction>(
SI.getCondition()));
4025 if (
auto *PN = dyn_cast<PHINode>(
SI.getCondition()))
4029 if (
SelectInst *TrueSI = dyn_cast<SelectInst>(TrueVal)) {
4030 if (TrueSI->getCondition()->getType() == CondVal->
getType()) {
4033 if (
Value *V = simplifyNestedSelectsUsingImpliedCond(
4034 *TrueSI, CondVal,
true,
DL))
4041 if (TrueSI->getFalseValue() == FalseVal && TrueSI->hasOneUse()) {
4049 if (
SelectInst *FalseSI = dyn_cast<SelectInst>(FalseVal)) {
4050 if (FalseSI->getCondition()->getType() == CondVal->
getType()) {
4053 if (
Value *V = simplifyNestedSelectsUsingImpliedCond(
4054 *FalseSI, CondVal,
false,
DL))
4058 if (FalseSI->getTrueValue() == TrueVal && FalseSI->hasOneUse()) {
4075 if (
auto *TrueBOSI = dyn_cast<SelectInst>(TrueBO->
getOperand(0))) {
4076 if (TrueBOSI->getCondition() == CondVal) {
4082 if (
auto *TrueBOSI = dyn_cast<SelectInst>(TrueBO->
getOperand(1))) {
4083 if (TrueBOSI->getCondition() == CondVal) {
4094 if (
auto *FalseBOSI = dyn_cast<SelectInst>(FalseBO->
getOperand(0))) {
4095 if (FalseBOSI->getCondition() == CondVal) {
4101 if (
auto *FalseBOSI = dyn_cast<SelectInst>(FalseBO->
getOperand(1))) {
4102 if (FalseBOSI->getCondition() == CondVal) {
4115 SI.swapProfMetadata();
4130 if (Known.One.isOne())
4132 if (Known.Zero.isOne())
4140 if (
Value *V = foldSelectCmpXchg(SI))
4158 if (
Value *V = foldRoundUpIntegerWithPow2Alignment(SI,
Builder))
4171 auto *MaskedInst = cast<IntrinsicInst>(TrueVal);
4172 if (isa<UndefValue>(MaskedInst->getArgOperand(3)))
4173 MaskedInst->setArgOperand(3, FalseVal );
4188 bool CanMergeSelectIntoLoad =
false;
4192 if (CanMergeSelectIntoLoad) {
4193 auto *MaskedInst = cast<IntrinsicInst>(FalseVal);
4194 if (isa<UndefValue>(MaskedInst->getArgOperand(3)))
4195 MaskedInst->setArgOperand(3, TrueVal );
4227 auto FoldSelectWithAndOrCond = [&](
bool IsAnd,
Value *
A,
4235 if (
ICmpInst *Cmp = dyn_cast<ICmpInst>(
B))
4236 if (
Value *V = canonicalizeSPF(*Cmp, TrueVal, FalseVal, *
this))
4238 IsAnd ? FalseVal : V);
4246 if (
Instruction *
I = FoldSelectWithAndOrCond(
true, LHS, RHS))
4248 if (
Instruction *
I = FoldSelectWithAndOrCond(
true, RHS, LHS))
4251 if (
Instruction *
I = FoldSelectWithAndOrCond(
false, LHS, RHS))
4253 if (
Instruction *
I = FoldSelectWithAndOrCond(
false, RHS, LHS))
4259 if (
Instruction *
I = FoldSelectWithAndOrCond(
true, LHS, RHS))
4262 if (
Instruction *
I = FoldSelectWithAndOrCond(
false, LHS, RHS))
4269 return BinaryOperator::CreateXor(CondVal, FalseVal);
4274 (!isa<Constant>(TrueVal) || !isa<Constant>(FalseVal))) {
4278 CC.AffectedValues.insert(V);
4281 if (!
CC.AffectedValues.empty()) {
4282 if (!isa<Constant>(TrueVal) &&
4283 hasAffectedValue(TrueVal,
CC.AffectedValues, 0)) {
4291 if (!isa<Constant>(FalseVal) &&
4292 hasAffectedValue(FalseVal,
CC.AffectedValues, 0)) {
4307 if (TrueVal == Trunc)
4309 if (FalseVal == Trunc)
4313 if (TrueVal == Trunc)
4316 if (FalseVal == Trunc)
SmallVector< AArch64_IMM::ImmInsnModel, 4 > Insn
AMDGPU Register Bank Select
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
const HexagonInstrInfo * TII
This file provides internal interfaces used to implement the InstCombine.
static Value * canonicalizeSaturatedAdd(ICmpInst *Cmp, Value *TVal, Value *FVal, InstCombiner::BuilderTy &Builder)
static Instruction * foldSetClearBits(SelectInst &Sel, InstCombiner::BuilderTy &Builder)
Canonicalize a set or clear of a masked set of constant bits to select-of-constants form.
static Instruction * foldSelectICmpAndAnd(Type *SelType, const ICmpInst *Cmp, Value *TVal, Value *FVal, InstCombiner::BuilderTy &Builder)
We want to turn: (select (icmp eq (and X, Y), 0), (and (lshr X, Z), 1), 1) into: zext (icmp ne i32 (a...
static unsigned getSelectFoldableOperands(BinaryOperator *I)
We want to turn code that looks like this: C = or A, B D = select cond, C, A into: C = select cond,...
static Instruction * foldSelectZeroOrMul(SelectInst &SI, InstCombinerImpl &IC)
static Value * canonicalizeSaturatedSubtract(const ICmpInst *ICI, const Value *TrueVal, const Value *FalseVal, InstCombiner::BuilderTy &Builder)
Transform patterns such as (a > b) ? a - b : 0 into usub.sat(a, b).
static Value * foldAbsDiff(ICmpInst *Cmp, Value *TVal, Value *FVal, InstCombiner::BuilderTy &Builder)
Try to match patterns with select and subtract as absolute difference.
static Instruction * foldSelectBinOpIdentity(SelectInst &Sel, const TargetLibraryInfo &TLI, InstCombinerImpl &IC)
Replace a select operand based on an equality comparison with the identity constant of a binop.
static Value * foldSelectICmpAndZeroShl(const ICmpInst *Cmp, Value *TVal, Value *FVal, InstCombiner::BuilderTy &Builder)
We want to turn: (select (icmp eq (and X, C1), 0), 0, (shl [nsw/nuw] X, C2)); iff C1 is a mask and th...
static Value * foldSelectICmpAndBinOp(const ICmpInst *IC, Value *TrueVal, Value *FalseVal, InstCombiner::BuilderTy &Builder)
We want to turn: (select (icmp eq (and X, C1), 0), Y, (BinOp Y, C2)) into: IF C2 u>= C1 (BinOp Y,...
static Value * foldSelectICmpLshrAshr(const ICmpInst *IC, Value *TrueVal, Value *FalseVal, InstCombiner::BuilderTy &Builder)
We want to turn: (select (icmp sgt x, C), lshr (X, Y), ashr (X, Y)); iff C s>= -1 (select (icmp slt x...
static bool isSelect01(const APInt &C1I, const APInt &C2I)
static Value * foldSelectICmpAnd(SelectInst &Sel, ICmpInst *Cmp, InstCombiner::BuilderTy &Builder)
This folds: select (icmp eq (and X, C1)), TC, FC iff C1 is a power 2 and the difference between TC an...
This file provides the interface for the instcombine pass implementation.
uint64_t IntrinsicInst * II
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static const uint32_t IV[8]
bool bitwiseIsEqual(const APFloat &RHS) const
Class for arbitrary precision integers.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
static APInt getSignMask(unsigned BitWidth)
Get the SignMask for a specific bit width.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
unsigned getBitWidth() const
Return the number of bits in the APInt.
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
bool isMinValue() const
Determine if this is the smallest unsigned value.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
unsigned countLeadingZeros() const
unsigned logBase2() const
bool isMask(unsigned numBits) const
bool isMaxSignedValue() const
Determine if this is the largest signed value.
bool isNonNegative() const
Determine if this APInt Value is non-negative (>= 0)
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
bool isOne() const
Determine if this is a value of 1.
static APInt getOneBitSet(unsigned numBits, unsigned BitNo)
Return an APInt with exactly one bit set in the result.
bool isMaxValue() const
Determine if this is the largest unsigned value.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
MutableArrayRef< ResultElem > assumptions()
Access the list of assumption handles currently tracked for this function.
An instruction that atomically checks whether a specified value is in a memory location,...
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
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...
BinaryOps getOpcode() const
static BinaryOperator * CreateNot(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
This class represents a no-op cast from one type to another.
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
This class is the base class for the comparison instructions.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ FCMP_OLT
0 1 0 0 True if ordered and less than
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ FCMP_ULT
1 1 0 0 True if unordered or less than
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ ICMP_ULT
unsigned less than
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
@ ICMP_SGE
signed greater or equal
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
@ ICMP_ULE
unsigned less or equal
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
bool isFPPredicate() const
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
Predicate getPredicate() const
Return the predicate for this instruction.
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
Predicate getFlippedStrictnessPredicate() const
For predicate of kind "is X or equal to 0" returns the predicate "is X".
bool isIntPredicate() const
bool isRelational() const
Return true if the predicate is relational (not EQ or NE).
An abstraction over a floating-point predicate, and a pack of an integer predicate with samesign info...
static std::optional< CmpPredicate > getMatching(CmpPredicate A, CmpPredicate B)
Compares two CmpPredicates taking samesign into account and returns the canonicalized CmpPredicate if...
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false, bool NSZ=false)
Return the identity constant for a binary opcode.
static Constant * getNeg(Constant *C, bool HasNSW=false)
static ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getFalse(LLVMContext &Context)
This class represents a range of values.
ConstantRange add(const ConstantRange &Other) const
Return a new range representing the possible values resulting from an addition of a value in this ran...
bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const
Does the predicate Pred hold between ranges this and Other? NOTE: false does not mean that inverse pr...
static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred, const APInt &Other)
Produce the exact range such that all values in the returned range satisfy the given predicate with a...
ConstantRange binaryNot() const
Return a new range representing the possible values resulting from a binary-xor of a value in this ra...
ConstantRange binaryOp(Instruction::BinaryOps BinOp, const ConstantRange &Other) const
Return a new range representing the possible values resulting from an application of the specified bi...
ConstantRange sub(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a subtraction of a value in this r...
This is an important base class in LLVM.
static Constant * mergeUndefsWith(Constant *C, Constant *Other)
Merges undefs of a Constant with another Constant, along with the undefs already present.
static Constant * getAllOnesValue(Type *Ty)
bool isOneValue() const
Returns true if the value is one.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
Tagged union holding either a T or a Error.
Utility class for floating point operations which can have information about relaxed accuracy require...
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags.
Convenience struct for specifying and reasoning about fast-math flags.
static FastMathFlags intersectRewrite(FastMathFlags LHS, FastMathFlags RHS)
Intersect rewrite-based flags.
bool noSignedZeros() const
static FastMathFlags unionValue(FastMathFlags LHS, FastMathFlags RHS)
Union value flags.
void setNoSignedZeros(bool B=true)
This class represents a freeze function that returns random concrete value if an operand is either a ...
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Value * getPointerOperand()
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Type * getSourceElementType() const
GEPNoWrapFlags getNoWrapFlags() const
Get the nowrap flags for the GEP instruction.
uint64_t getType(const MachineInstr &MI) const
This instruction compares its operands according to the predicate given to the constructor.
CmpPredicate getSwappedCmpPredicate() const
static bool isLT(Predicate P)
Return true if the predicate is SLT or ULT.
CmpPredicate getInverseCmpPredicate() const
static bool isGT(Predicate P)
Return true if the predicate is SGT or UGT.
bool isEquality() const
Return true if this predicate is either EQ or NE.
static bool isEquality(Predicate P)
Return true if this predicate is either EQ or NE.
bool isRelational() const
Return true if the predicate is relational (not EQ or NE).
Common base class shared among various IRBuilders.
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Value * CreateFAdd(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Value * CreateSelectFMF(Value *C, Value *True, Value *False, FMFSource FMFSource, const Twine &Name="", Instruction *MDFrom=nullptr)
Value * CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name="")
Return a vector value that contains.
ConstantInt * getTrue()
Get the constant value for i1 true.
Value * CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
Value * CreateFreeze(Value *V, const Twine &Name="")
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy, const Twine &Name="", MDNode *FPMathTag=nullptr, FMFSource FMFSource={})
Value * CreateFCmpFMF(CmpInst::Predicate P, Value *LHS, Value *RHS, FMFSource FMFSource, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNSW=false)
Value * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Value * CreateNot(Value *V, const Twine &Name="")
Value * CreateIsNeg(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg < 0.
CallInst * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateIsNotNull(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg != 0.
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="", bool IsNUW=false, bool IsNSW=false)
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name="")
Value * CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name="")
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Value * CreateAShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateXor(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name="")
Value * CreateFNeg(Value *V, const Twine &Name="", MDNode *FPMathTag=nullptr)
Instruction * foldSelectToCmp(SelectInst &SI)
bool fmulByZeroIsZero(Value *MulVal, FastMathFlags FMF, const Instruction *CtxI) const
Check if fmul MulVal, +0.0 will yield +0.0 (or signed zero is ignorable).
KnownFPClass computeKnownFPClass(Value *Val, FastMathFlags FMF, FPClassTest Interested=fcAllFlags, const Instruction *CtxI=nullptr, unsigned Depth=0) const
Instruction * foldSelectEqualityTest(SelectInst &SI)
Instruction * foldSelectValueEquivalence(SelectInst &SI, CmpInst &CI)
Instruction * foldOpIntoPhi(Instruction &I, PHINode *PN, bool AllowMultipleUses=false)
Given a binary operator, cast instruction, or select which has a PHI node as operand #0,...
Instruction * foldVectorSelect(SelectInst &Sel)
Value * SimplifyDemandedVectorElts(Value *V, APInt DemandedElts, APInt &PoisonElts, unsigned Depth=0, bool AllowMultipleUsers=false) override
The specified value produces a vector with any number of elements.
Instruction * foldSPFofSPF(Instruction *Inner, SelectPatternFlavor SPF1, Value *A, Value *B, Instruction &Outer, SelectPatternFlavor SPF2, Value *C)
Instruction * foldSelectOpOp(SelectInst &SI, Instruction *TI, Instruction *FI)
We have (select c, TI, FI), and we know that TI and FI have the same opcode.
bool replaceInInstruction(Value *V, Value *Old, Value *New, unsigned Depth=0)
Instruction * foldSelectInstWithICmp(SelectInst &SI, ICmpInst *ICI)
bool sinkNotIntoOtherHandOfLogicalOp(Instruction &I)
Constant * getLosslessTrunc(Constant *C, Type *TruncTy, unsigned ExtOp)
Instruction * foldSelectIntoOp(SelectInst &SI, Value *, Value *)
Try to fold the select into one of the operands to allow further optimization.
Instruction * visitSelectInst(SelectInst &SI)
Instruction * foldSelectOfBools(SelectInst &SI)
Instruction * foldSelectExtConst(SelectInst &Sel)
The core instruction combiner logic.
const DataLayout & getDataLayout() const
bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero=false, unsigned Depth=0, const Instruction *CxtI=nullptr)
Instruction * InsertNewInstBefore(Instruction *New, BasicBlock::iterator Old)
Inserts an instruction New before instruction Old.
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
static bool shouldAvoidAbsorbingNotIntoSelect(const SelectInst &SI)
void replaceUse(Use &U, Value *NewValue)
Replace use and add the previously used value to the worklist.
static bool isCanonicalPredicate(CmpPredicate Pred)
Predicate canonicalization reduces the number of patterns that need to be matched by other transforms...
InstructionWorklist & Worklist
A worklist of the instructions that need to be simplified.
void addToWorklist(Instruction *I)
Instruction * replaceOperand(Instruction &I, unsigned OpNum, Value *V)
Replace operand of instruction and add old operand to the worklist.
void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth, const Instruction *CxtI) const
Value * getFreelyInverted(Value *V, bool WillInvertAllUses, BuilderTy *Builder, bool &DoesConsume)
const SimplifyQuery & getSimplifyQuery() const
static Constant * AddOne(Constant *C)
Add one to a Constant.
void add(Instruction *I)
Add instruction to the worklist.
void push(Instruction *I)
Push the instruction onto the worklist stack.
bool hasNoNaNs() const LLVM_READONLY
Determine whether the no-NaNs flag is set.
bool hasNoInfs() const LLVM_READONLY
Determine whether the no-infs flag is set.
bool isSameOperationAs(const Instruction *I, unsigned flags=0) const LLVM_READONLY
This function determines if the specified instruction executes the same operation as the current one.
void setHasNoSignedZeros(bool B)
Set or clear the no-signed-zeros flag on this instruction, which must be an operator which supports t...
bool hasNoSignedZeros() const LLVM_READONLY
Determine whether the no-signed-zeros flag is set.
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction.
void setHasNoNaNs(bool B)
Set or clear the no-nans flag on this instruction, which must be an operator which supports this flag...
bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
void swapProfMetadata()
If the instruction has "branch_weights" MD_prof metadata and the MDNode has three operands (including...
void setHasNoInfs(bool B)
Set or clear the no-infs flag on this instruction, which must be an operator which supports this flag...
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
void dropPoisonGeneratingFlags()
Drops flags that may cause this instruction to evaluate to poison despite having non-poison inputs.
const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
A wrapper class for inspecting calls to intrinsic functions.
A Module instance is used to store all the information related to an LLVM module.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
This class represents a sign extension of integer types.
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, Instruction *MDFrom=nullptr)
const Value * getFalseValue() const
void swapValues()
Swap the true and false values of the select instruction.
const Value * getCondition() const
const Value * getTrueValue() const
bool insert(const value_type &X)
Insert a new element into the SetVector.
This instruction constructs a fixed permutation of two input vectors.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
bool contains(ConstPtrType Ptr) const
A SetVector that performs no allocations if smaller than a certain size.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Provides information about what library functions are available for the current target.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
static IntegerType * getInt1Ty(LLVMContext &C)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
static UnaryOperator * CreateFNegFMF(Value *Op, Instruction *FMFSource, const Twine &Name="", InsertPosition InsertBefore=nullptr)
A Use represents the edge between a Value definition and its users.
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) const
Translate PHI node to its predecessor from the given basic block.
bool hasOneUse() const
Return true if there is exactly one use of this value.
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
Represents an op.with.overflow intrinsic.
This class represents zero extension of integer types.
const ParentTy * getParent() const
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
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.
@ C
The default llvm calling convention, compatible with C.
int getMinValue(MCInstrInfo const &MCII, MCInst const &MCI)
Return the minimum value of an extendable operand.
int getMaxValue(MCInstrInfo const &MCII, MCInst const &MCI)
Return the maximum value of an extendable operand.
Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > Tys={})
Look up the Function declaration of the intrinsic id in the Module M.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
BinaryOp_match< cst_pred_ty< is_all_ones, false >, ValTy, Instruction::Xor, true > m_NotForbidPoison(const ValTy &V)
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
CmpClass_match< LHS, RHS, FCmpInst > m_FCmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FMul, true > m_c_FMul(const LHS &L, const RHS &R)
Matches FMul with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
match_combine_or< CastInst_match< OpTy, TruncInst >, OpTy > m_TruncOrSelf(const OpTy &Op)
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
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.
CastInst_match< OpTy, TruncInst > m_Trunc(const OpTy &Op)
Matches Trunc.
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
specific_intval< false > m_SpecificInt(const APInt &V)
Match a specific integer value or vector with all elements equal to the value.
match_combine_or< CastInst_match< OpTy, ZExtInst >, OpTy > m_ZExtOrSelf(const OpTy &Op)
bool match(Val *V, const Pattern &P)
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
constantexpr_match m_ConstantExpr()
Match a constant expression or a constant that contains a constant expression.
specific_intval< true > m_SpecificIntAllowPoison(const APInt &V)
CmpClass_match< LHS, RHS, ICmpInst, true > m_c_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
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'.
TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement > m_ExtractElt(const Val_t &Val, const Idx_t &Idx)
Matches ExtractElementInst.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > > m_OrdOrUnordFMin(const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point minimum function.
BinOpPred_match< LHS, RHS, is_logical_shift_op > m_LogicalShift(const LHS &L, const RHS &R)
Matches logical shift operations.
match_combine_and< LTy, RTy > m_CombineAnd(const LTy &L, const RTy &R)
Combine two pattern matchers matching L && R.
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
cst_pred_ty< is_any_apint > m_AnyIntegralConstant()
Match an integer or vector with any integral constant.
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
BinaryOp_match< LHS, RHS, Instruction::FAdd > m_FAdd(const LHS &L, const RHS &R)
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()...
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
apint_match m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
NoWrapTrunc_match< OpTy, TruncInst::NoSignedWrap > m_NSWTrunc(const OpTy &Op)
Matches trunc nsw.
OneUse_match< T > m_OneUse(const T &SubPattern)
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3)
Matches MaskedLoad Intrinsic.
SpecificCmpClass_match< LHS, RHS, ICmpInst > m_SpecificICmp(CmpPredicate MatchPred, const LHS &L, const RHS &R)
apint_match m_APIntForbidPoison(const APInt *&Res)
Match APInt while forbidding poison in splat vector constants.
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
class_match< CmpInst > m_Cmp()
Matches any compare instruction and ignore it.
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
auto m_c_LogicalOp(const LHS &L, const RHS &R)
Matches either L && R or L || R with LHS and RHS in either order.
NoWrapTrunc_match< OpTy, TruncInst::NoUnsignedWrap > m_NUWTrunc(const OpTy &Op)
Matches trunc nuw.
BinaryOp_match< LHS, RHS, Instruction::Add, true > m_c_Add(const LHS &L, const RHS &R)
Matches a Add with LHS and RHS in either order.
apfloat_match m_APFloatAllowPoison(const APFloat *&Res)
Match APFloat while allowing poison in splat vector constants.
match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > > m_OrdOrUnordFMax(const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point maximum function.
CastOperator_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, ICmpInst > m_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
cstfp_pred_ty< is_pos_zero_fp > m_PosZeroFP()
Match a floating-point positive zero.
LogicalOp_match< LHS, RHS, Instruction::And, true > m_c_LogicalAnd(const LHS &L, const RHS &R)
Matches L && R with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0 >::Ty m_VecReverse(const Opnd0 &Op0)
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
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)
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
auto m_Undef()
Match an arbitrary undef constant.
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
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.
LogicalOp_match< LHS, RHS, Instruction::Or, true > m_c_LogicalOr(const LHS &L, const RHS &R)
Matches L || R with LHS and RHS in either order.
SpecificCmpClass_match< LHS, RHS, ICmpInst, true > m_c_SpecificICmp(CmpPredicate MatchPred, const LHS &L, const RHS &R)
ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3)
Matches MaskedGather Intrinsic.
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
cst_pred_ty< icmp_pred_with_threshold > m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold)
Match an integer or vector with every element comparing 'pred' (eg/ne/...) to Threshold.
ElementType
The element type of an SRV or UAV resource.
DiagnosticInfoOptimizationBase::Argument NV
This is an optimization pass for GlobalISel generic memory operations.
bool isSafeToSpeculativelyExecuteWithVariableReplaced(const Instruction *I)
Don't use information from its non-constant operands.
bool isSignBitCheck(ICmpInst::Predicate Pred, const APInt &RHS, bool &TrueIfSigned)
Given an exploded icmp instruction, return true if the comparison only checks the sign bit.
APFloat abs(APFloat X)
Returns the absolute value of the argument.
Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const Instruction *I=nullptr)
Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands.
CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
bool isGuaranteedNotToBeUndef(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be undef, but may be poison.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
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...
constexpr unsigned MaxAnalysisRecursionDepth
SelectPatternFlavor
Specific patterns of select instructions we can match.
@ SPF_ABS
Floating point maxnum.
@ SPF_NABS
Absolute value.
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
SelectPatternResult getSelectPattern(CmpInst::Predicate Pred, SelectPatternNaNBehavior NaNBehavior=SPNB_NA, bool Ordered=false)
Determine the pattern for predicate X Pred Y ? X : Y.
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...
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
Value * simplifyAndInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an And, fold the result or return null.
bool isKnownInversion(const Value *X, const Value *Y)
Return true iff:
bool isNotCrossLaneOperation(const Instruction *I)
Return true if the instruction doesn't potentially cross vector lanes.
Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
constexpr int PoisonMaskElem
Intrinsic::ID getMinMaxIntrinsic(SelectPatternFlavor SPF)
Convert given SPF to equivalent min/max intrinsic.
@ Or
Bitwise or logical OR of integers.
@ Mul
Product of integers.
@ Xor
Bitwise or logical XOR of integers.
@ And
Bitwise or logical AND of integers.
std::optional< DecomposedBitTest > decomposeBitTestICmp(Value *LHS, Value *RHS, CmpInst::Predicate Pred, bool LookThroughTrunc=true, bool AllowNonZeroC=false)
Decompose an icmp into the form ((X & Mask) pred C) if possible.
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
DWARFExpression::Operation Op
constexpr unsigned BitWidth
SelectPatternResult matchDecomposedSelectPattern(CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Determine the pattern that a select with the given compare as its predicate and given values as its t...
Value * simplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp, const SimplifyQuery &Q, bool AllowRefinement, SmallVectorImpl< Instruction * > *DropFlags=nullptr)
See if V simplifies when its operand Op is replaced with RepOp.
auto predecessors(const MachineBasicBlock *BB)
std::optional< std::pair< CmpPredicate, Constant * > > getFlippedStrictnessPredicateAndConstant(CmpPredicate Pred, Constant *C)
Convert an integer comparison with a constant RHS into an equivalent form with the strictness flipped...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
bool cannotBeNegativeZero(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if we can prove that the specified FP value is never equal to -0.0.
bool isKnownNeverNaN(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has...
bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be poison, but may be undef.
bool isCheckForZeroAndMulWithOverflow(Value *Op0, Value *Op1, bool IsAnd, Use *&Y)
Match one of the patterns up to the select/logic op: Op0 = icmp ne i4 X, 0 Agg = call { i4,...
Value * simplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, const SimplifyQuery &Q)
Given operands for a SelectInst, fold the result or return null.
std::optional< bool > isImpliedCondition(const Value *LHS, const Value *RHS, const DataLayout &DL, bool LHSIsTrue=true, unsigned Depth=0)
Return true if RHS is known to be implied true by LHS.
void findValuesAffectedByCondition(Value *Cond, bool IsAssume, function_ref< void(Value *)> InsertAffected)
Call InsertAffected on all Values whose known bits / value may be affected by the condition Cond.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Evaluate query assuming this condition holds.
Incoming for lane maks phi as machine instruction, incoming register Reg and incoming block Block are...
bool isConstant() const
Returns true if we know the value of all bits.
const APInt & getConstant() const
Returns the value when all bits have a known value.
bool isKnownNeverInfinity() const
Return true if it's known this can never be an infinity.
bool isKnownNeverNaN() const
Return true if it's known this can never be a nan.
bool signBitIsZeroOrNaN() const
Return true if the sign bit must be 0, ignoring the sign of nans.
SelectPatternFlavor Flavor
bool Ordered
Only applicable if Flavor is SPF_FMINNUM or SPF_FMAXNUM.
static bool isMinOrMax(SelectPatternFlavor SPF)
When implementing this min/max pattern as fcmp; select, does the fcmp have to be ordered?
SimplifyQuery getWithCondContext(const CondContext &CC) const
SimplifyQuery getWithInstruction(const Instruction *I) const