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);
165 if (!TC.
isZero() && !FC.isZero()) {
174 if (!Cmp->hasOneUse())
176 V = Builder.
CreateAnd(V, ConstantInt::get(SelType, AndMask));
178 bool ExtraBitInTC = TC.
ugt(FC);
179 if (Pred == ICmpInst::ICMP_EQ) {
183 Constant *
C = ConstantInt::get(SelType, TC);
186 if (Pred == ICmpInst::ICMP_NE) {
190 Constant *
C = ConstantInt::get(SelType, FC);
203 unsigned ValZeros = ValC.
logBase2();
204 unsigned AndZeros = AndMask.
logBase2();
205 bool ShouldNotVal = !TC.
isZero();
206 ShouldNotVal ^= Pred == ICmpInst::ICMP_NE;
211 if (CreateAnd && ShouldNotVal && ValZeros != AndZeros)
216 V = Builder.
CreateAnd(V, ConstantInt::get(V->getType(), AndMask));
220 if (ValZeros > AndZeros) {
222 V = Builder.
CreateShl(V, ValZeros - AndZeros);
223 }
else if (ValZeros < AndZeros) {
224 V = Builder.
CreateLShr(V, AndZeros - ValZeros);
249 switch (
I->getOpcode()) {
250 case Instruction::Add:
251 case Instruction::FAdd:
252 case Instruction::Mul:
253 case Instruction::FMul:
254 case Instruction::And:
255 case Instruction::Or:
256 case Instruction::Xor:
258 case Instruction::Sub:
259 case Instruction::FSub:
260 case Instruction::FDiv:
261 case Instruction::Shl:
262 case Instruction::LShr:
263 case Instruction::AShr:
293 if (
auto *CondVTy = dyn_cast<VectorType>(CondTy)) {
295 CondVTy->getElementCount() !=
296 cast<VectorType>(FIOpndTy)->getElementCount())
307 if (TI->
getOpcode() != Instruction::BitCast &&
320 SI.getName() +
".v", &SI);
325 Value *OtherOpT, *OtherOpF;
328 bool Swapped =
false) ->
Value * {
329 assert(!(Commute && Swapped) &&
330 "Commute and Swapped can't set at the same time");
335 MatchIsOpZero =
true;
340 MatchIsOpZero =
false;
345 if (!Commute && !Swapped)
354 MatchIsOpZero =
true;
359 MatchIsOpZero =
false;
373 FMF |= SI.getFastMathFlags();
376 if (
auto *NewSelI = dyn_cast<Instruction>(NewSel))
377 NewSelI->setFastMathFlags(FMF);
378 Instruction *NewFNeg = UnaryOperator::CreateFNeg(NewSel);
387 auto *
TII = dyn_cast<IntrinsicInst>(TI);
388 auto *FII = dyn_cast<IntrinsicInst>(FI);
389 if (
TII && FII &&
TII->getIntrinsicID() == FII->getIntrinsicID()) {
391 if (
Value *MatchOp = getCommonOp(TI, FI,
true)) {
403 if (
TII->getIntrinsicID() == Intrinsic::ldexp) {
404 Value *LdexpVal0 =
TII->getArgOperand(0);
405 Value *LdexpExp0 =
TII->getArgOperand(1);
406 Value *LdexpVal1 = FII->getArgOperand(0);
407 Value *LdexpExp1 = FII->getArgOperand(1);
411 FMF &= cast<FPMathOperator>(FII)->getFastMathFlags();
418 TII->
getType(), Intrinsic::ldexp, {SelectVal, SelectExp});
431 bool Swapped = TPred != FPred;
435 SI.getName() +
".v", &SI);
450 (!isa<BinaryOperator>(TI) && !isa<GetElementPtrInst>(TI)) ||
472 auto *BO = dyn_cast<BinaryOperator>(TI);
476 if (BO->getOpcode() == Instruction::SDiv ||
477 BO->getOpcode() == Instruction::SRem || MatchIsOpZero)
483 SI.getName() +
".v", &SI);
484 Value *Op0 = MatchIsOpZero ? MatchOp : NewSI;
485 Value *Op1 = MatchIsOpZero ? NewSI : MatchOp;
486 if (
auto *BO = dyn_cast<BinaryOperator>(TI)) {
492 if (
auto *TGEP = dyn_cast<GetElementPtrInst>(TI)) {
493 auto *FGEP = cast<GetElementPtrInst>(FI);
494 Type *ElementType = TGEP->getSourceElementType();
496 ElementType, Op0, Op1, TGEP->getNoWrapFlags() & FGEP->getNoWrapFlags());
517 auto *TVI = dyn_cast<BinaryOperator>(TrueVal);
518 if (!TVI || !TVI->hasOneUse() || isa<Constant>(FalseVal))
522 unsigned OpToFold = 0;
523 if ((SFO & 1) && FalseVal == TVI->getOperand(0))
525 else if ((SFO & 2) && FalseVal == TVI->getOperand(1))
535 if (isa<FPMathOperator>(&SI))
536 FMF = SI.getFastMathFlags();
538 TVI->getOpcode(), TVI->getType(),
true, FMF.
noSignedZeros());
539 Value *OOp = TVI->getOperand(2 - OpToFold);
544 if (isa<Constant>(OOp) &&
545 (!OOpIsAPInt || !
isSelect01(
C->getUniqueInteger(), *OOpC)))
554 if (isa<FPMathOperator>(&SI) &&
559 Swapped ? OOp :
C,
"", &SI);
560 if (isa<FPMathOperator>(&SI))
561 cast<Instruction>(NewSel)->setFastMathFlags(FMF);
569 if (
Instruction *R = TryFoldSelectIntoOp(SI, TrueVal, FalseVal,
false))
572 if (
Instruction *R = TryFoldSelectIntoOp(SI, FalseVal, TrueVal,
true))
589 if (!(Cmp->hasOneUse() && Cmp->getOperand(0)->hasOneUse() &&
621 Constant *One = ConstantInt::get(SelType, 1);
626 return new ZExtInst(ICmpNeZero, SelType);
648 const APInt *C2, *C1;
658 auto *FI = dyn_cast<Instruction>(FVal);
662 FI->setHasNoSignedWrap(
false);
663 FI->setHasNoUnsignedWrap(
false);
698 const auto *Ashr = cast<Instruction>(FalseVal);
700 bool IsExact = Ashr->isExact() && cast<Instruction>(TrueVal)->isExact();
732 if (!TrueVal->getType()->isIntOrIntVectorTy() ||
767 BinOp = cast<BinaryOperator>(FalseVal);
771 BinOp = cast<BinaryOperator>(TrueVal);
781 if (IdentityC ==
nullptr || !IdentityC->isNullValue())
786 bool NeedShift = C1Log != C2Log;
787 bool NeedZExtTrunc =
Y->getType()->getScalarSizeInBits() !=
788 V->getType()->getScalarSizeInBits();
791 if ((NeedShift + NeedXor + NeedZExtTrunc +
NeedAnd) >
798 V = Builder.
CreateAnd(V, ConstantInt::get(V->getType(), C1));
804 }
else if (C1Log > C2Log) {
831 Constant *OrC = ConstantInt::get(Ty, *
C);
833 return BinaryOperator::CreateOr(
T, NewSel);
840 Constant *OrC = ConstantInt::get(Ty, *
C);
842 return BinaryOperator::CreateOr(
F, NewSel);
859 auto *CondVal = SI.getCondition();
860 auto *TrueVal = SI.getTrueValue();
861 auto *FalseVal = SI.getFalseValue();
879 auto *TrueValC = dyn_cast<Constant>(TrueVal);
880 if (TrueValC ==
nullptr ||
882 !isa<Instruction>(FalseVal))
885 auto *ZeroC = cast<Constant>(cast<Instruction>(CondVal)->getOperand(1));
893 auto *FalseValI = cast<Instruction>(FalseVal);
896 IC.
replaceOperand(*FalseValI, FalseValI->getOperand(0) ==
Y ? 0 : 1, FrY);
904 const Value *TrueVal,
905 const Value *FalseVal,
926 ConstantInt::get(
A->getType(), 1));
940 "Unexpected isUnsigned predicate!");
946 bool IsNegative =
false;
959 if (IsNegative && !TrueVal->hasOneUse() && !ICI->
hasOneUse())
972 if (!Cmp->hasOneUse())
976 Value *Cmp0 = Cmp->getOperand(0);
977 Value *Cmp1 = Cmp->getOperand(1);
986 Intrinsic::uadd_sat,
X, ConstantInt::get(
X->getType(), *
C));
1043 auto *TI = dyn_cast<Instruction>(TVal);
1044 auto *FI = dyn_cast<Instruction>(FVal);
1050 Value *
A = Cmp->getOperand(0);
1051 Value *
B = Cmp->getOperand(1);
1064 (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap()) &&
1065 (FI->hasNoSignedWrap() || FI->hasNoUnsignedWrap())) {
1072 TI->setHasNoUnsignedWrap(
false);
1073 if (!TI->hasNoSignedWrap())
1074 TI->setHasNoSignedWrap(TI->hasOneUse());
1102 if (!
match(FalseVal,
1106 if (!
match(Ctlz, m_Intrinsic<Intrinsic::ctlz>()))
1113 auto *
II = cast<IntrinsicInst>(Ctlz);
1150 Value *Count =
nullptr;
1158 if (!
match(Count, m_Intrinsic<Intrinsic::cttz>(
m_Value(
X))) &&
1178 II->dropPoisonGeneratingAnnotations();
1197 if (!
TrueVal->getType()->isIntOrIntVectorTy())
1224 IntrinsicID = Intrinsic::umin;
1227 IntrinsicID = Intrinsic::umax;
1230 IntrinsicID = Intrinsic::smin;
1233 IntrinsicID = Intrinsic::smax;
1250 auto *
I = dyn_cast<Instruction>(V);
1254 bool Changed =
false;
1255 for (
Use &U :
I->operands()) {
1285 if (!
Cmp.isEquality())
1290 bool Swapped =
false;
1296 Value *CmpLHS =
Cmp.getOperand(0), *CmpRHS =
Cmp.getOperand(1);
1297 auto ReplaceOldOpWithNewOp = [&](
Value *OldOp,
1305 if (TrueVal == OldOp)
1341 if (
Instruction *R = ReplaceOldOpWithNewOp(CmpLHS, CmpRHS))
1343 if (
Instruction *R = ReplaceOldOpWithNewOp(CmpRHS, CmpLHS))
1346 auto *FalseInst = dyn_cast<Instruction>(FalseVal);
1361 &DropFlags) == TrueVal ||
1364 &DropFlags) == TrueVal) {
1366 I->dropPoisonGeneratingAnnotations();
1407 if (!isa<SelectInst>(Sel1)) {
1448 if (Cmp00->
getType() !=
X->getType() &&
X->hasOneUse())
1456 else if (!
match(Cmp00,
1464 Value *ReplacementLow, *ReplacementHigh;
1501 std::swap(ReplacementLow, ReplacementHigh);
1507 "Unexpected predicate type.");
1515 "Unexpected predicate type.");
1517 std::swap(ThresholdLowIncl, ThresholdHighExcl);
1533 if (
X->getType() != Sel0.
getType()) {
1543 assert(ReplacementLow && ReplacementHigh &&
1544 "Constant folding of ImmConstant cannot fail");
1550 Value *MaybeReplacedLow =
1556 ShouldReplaceHigh, ReplacementHigh, MaybeReplacedLow);
1600 Value *SelVal0, *SelVal1;
1609 auto MatchesSelectValue = [SelVal0, SelVal1](
Constant *
C) {
1610 return C->isElementWiseEqual(SelVal0) ||
C->isElementWiseEqual(SelVal1);
1614 if (MatchesSelectValue(C0))
1618 auto FlippedStrictness =
1620 if (!FlippedStrictness)
1624 if (!MatchesSelectValue(FlippedStrictness->second))
1633 Cmp.getName() +
".inv");
1644 if (!
Cmp->hasOneUse())
1674 Value *TVal =
SI.getTrueValue();
1675 Value *FVal =
SI.getFalseValue();
1701 const APInt *BinOpC;
1738 const unsigned AndOps = Instruction::And, OrOps = Instruction::Or,
1739 XorOps = Instruction::Xor, NoOps = 0;
1740 enum NotMask {
None = 0, NotInner, NotRHS };
1742 auto matchFalseVal = [&](
unsigned OuterOpc,
unsigned InnerOpc,
1745 if (OuterOpc == NoOps)
1748 if (NotMask == NotInner) {
1751 }
else if (NotMask == NotRHS) {
1755 return match(FalseVal,
1766 if (matchFalseVal(OrOps, XorOps,
None) ||
1767 matchFalseVal(XorOps, XorOps,
None))
1772 if (matchFalseVal(XorOps, OrOps,
None) ||
1773 matchFalseVal(AndOps, OrOps, NotRHS))
1784 if (matchFalseVal(XorOps, XorOps,
None) ||
1785 matchFalseVal(AndOps, XorOps, NotInner))
1790 if (matchFalseVal(XorOps, AndOps,
None) ||
1791 matchFalseVal(AndOps, AndOps, NotInner))
1802 if (matchFalseVal(XorOps, OrOps,
None) ||
1803 matchFalseVal(AndOps, OrOps, NotRHS))
1808 if (matchFalseVal(OrOps, AndOps,
None) ||
1809 matchFalseVal(XorOps, AndOps,
None))
1824 canonicalizeSPF(*ICI,
SI.getTrueValue(),
SI.getFalseValue(), *
this))
1827 if (
Value *V = foldSelectInstWithICmpConst(SI, ICI,
Builder))
1830 if (
Value *V = canonicalizeClampLike(SI, *ICI,
Builder, *
this))
1834 tryToReuseConstantFromSelectInComparison(SI, *ICI, *
this))
1841 bool Changed =
false;
1847 if (CmpRHS != CmpLHS && isa<Constant>(CmpRHS) && !isa<Constant>(CmpLHS)) {
1859 if (
Instruction *NewSel = foldSelectICmpEq(SI, ICI, *
this))
1874 SI.swapProfMetadata();
1880 if (
TrueVal->getType()->isIntOrIntVectorTy()) {
1887 bool IsBitTest =
false;
1895 Y = &MinSignedValue;
1897 TrueWhenUnset =
false;
1900 Y = &MinSignedValue;
1902 TrueWhenUnset =
true;
1907 if (TrueWhenUnset && TrueVal ==
X &&
1911 else if (!TrueWhenUnset && FalseVal ==
X &&
1915 else if (TrueWhenUnset && FalseVal ==
X &&
1919 else if (!TrueWhenUnset && TrueVal ==
X &&
1947 if (
Value *V = foldSelectCttzCtlz(ICI, TrueVal, FalseVal, *
this))
1959 return Changed ? &
SI :
nullptr;
1971static bool canSelectOperandBeMappingIntoPredBlock(
const Value *V,
1976 if (!
I)
return true;
1980 const PHINode *CondPHI = cast<PHINode>(
SI.getCondition());
1982 if (
const PHINode *VP = dyn_cast<PHINode>(
I))
1983 if (VP->getParent() == CondPHI->
getParent())
2007 if (
C ==
A ||
C ==
B) {
2022 Value *CondVal =
SI.getCondition();
2025 auto *TI = dyn_cast<Instruction>(TrueVal);
2026 auto *FI = dyn_cast<Instruction>(FalseVal);
2027 if (!TI || !FI || !TI->hasOneUse() || !FI->hasOneUse())
2031 if ((TI->getOpcode() == Instruction::Sub &&
2032 FI->getOpcode() == Instruction::Add) ||
2033 (TI->getOpcode() == Instruction::FSub &&
2034 FI->getOpcode() == Instruction::FAdd)) {
2037 }
else if ((FI->getOpcode() == Instruction::Sub &&
2038 TI->getOpcode() == Instruction::Add) ||
2039 (FI->getOpcode() == Instruction::FSub &&
2040 TI->getOpcode() == Instruction::FAdd)) {
2046 Value *OtherAddOp =
nullptr;
2047 if (SubOp->getOperand(0) == AddOp->
getOperand(0)) {
2049 }
else if (SubOp->getOperand(0) == AddOp->
getOperand(1)) {
2057 if (
SI.getType()->isFPOrFPVectorTy()) {
2058 NegVal = Builder.
CreateFNeg(SubOp->getOperand(1));
2059 if (
Instruction *NegInst = dyn_cast<Instruction>(NegVal)) {
2061 Flags &= SubOp->getFastMathFlags();
2062 NegInst->setFastMathFlags(Flags);
2065 NegVal = Builder.
CreateNeg(SubOp->getOperand(1));
2068 Value *NewTrueOp = OtherAddOp;
2069 Value *NewFalseOp = NegVal;
2073 SI.getName() +
".p", &SI);
2075 if (
SI.getType()->isFPOrFPVectorTy()) {
2077 BinaryOperator::CreateFAdd(SubOp->getOperand(0), NewSel);
2080 Flags &= SubOp->getFastMathFlags();
2084 return BinaryOperator::CreateAdd(SubOp->getOperand(0), NewSel);
2097 Value *CondVal =
SI.getCondition();
2109 auto IsSignedSaturateLimit = [&](
Value *Limit,
bool IsAdd) {
2119 auto IsZeroOrOne = [](
const APInt &
C) {
return C.isZero() ||
C.isOne(); };
2136 IsMinMax(TrueVal, FalseVal))
2143 IsMinMax(FalseVal, TrueVal))
2149 IsMinMax(TrueVal, FalseVal))
2154 IsMinMax(FalseVal, TrueVal))
2159 IsMinMax(FalseVal, TrueVal))
2164 IsMinMax(TrueVal, FalseVal))
2172 if (
II->getIntrinsicID() == Intrinsic::uadd_with_overflow &&
2175 NewIntrinsicID = Intrinsic::uadd_sat;
2176 else if (
II->getIntrinsicID() == Intrinsic::usub_with_overflow &&
2179 NewIntrinsicID = Intrinsic::usub_sat;
2180 else if (
II->getIntrinsicID() == Intrinsic::sadd_with_overflow &&
2181 IsSignedSaturateLimit(TrueVal,
true))
2190 NewIntrinsicID = Intrinsic::sadd_sat;
2191 else if (
II->getIntrinsicID() == Intrinsic::ssub_with_overflow &&
2192 IsSignedSaturateLimit(TrueVal,
false))
2201 NewIntrinsicID = Intrinsic::ssub_sat;
2222 if (ExtOpcode != Instruction::ZExt && ExtOpcode != Instruction::SExt)
2228 Type *SmallType =
X->getType();
2230 auto *
Cmp = dyn_cast<CmpInst>(
Cond);
2232 (!Cmp ||
Cmp->getOperand(0)->getType() != SmallType))
2240 Value *TruncCVal = cast<Value>(TruncC);
2256 Value *CondVal =
SI.getCondition();
2258 auto *CondValTy = dyn_cast<FixedVectorType>(CondVal->
getType());
2262 unsigned NumElts = CondValTy->getNumElements();
2264 Mask.reserve(NumElts);
2265 for (
unsigned i = 0; i != NumElts; ++i) {
2275 Mask.push_back(i + NumElts);
2276 }
else if (isa<UndefValue>(Elt)) {
2296 auto *Ty = dyn_cast<VectorType>(Sel.
getType());
2328 if (TVal ==
A || TVal ==
B || FVal ==
A || FVal ==
B)
2345 if (TSrc ==
C && FSrc ==
D) {
2349 }
else if (TSrc ==
D && FSrc ==
C) {
2388 auto *Extract = dyn_cast<ExtractValueInst>(V);
2391 if (Extract->getIndices()[0] !=
I)
2393 return dyn_cast<AtomicCmpXchgInst>(Extract->getAggregateOperand());
2399 if (
auto *
Select = dyn_cast<SelectInst>(
SI.user_back()))
2400 if (
Select->getCondition() ==
SI.getCondition())
2401 if (
Select->getFalseValue() ==
SI.getTrueValue() ||
2402 Select->getTrueValue() ==
SI.getFalseValue())
2406 auto *CmpXchg = isExtractFromCmpXchg(
SI.getCondition(), 1);
2413 if (
auto *
X = isExtractFromCmpXchg(
SI.getTrueValue(), 0))
2414 if (
X == CmpXchg &&
X->getCompareOperand() ==
SI.getFalseValue())
2415 return SI.getFalseValue();
2420 if (
auto *
X = isExtractFromCmpXchg(
SI.getFalseValue(), 0))
2421 if (
X == CmpXchg &&
X->getCompareOperand() ==
SI.getTrueValue())
2422 return SI.getFalseValue();
2446 Value *SV0, *SV1, *SA0, *SA1;
2455 if (Or0->
getOpcode() == BinaryOperator::LShr) {
2461 Or1->
getOpcode() == BinaryOperator::LShr &&
2462 "Illegal or(shift,shift) pair");
2477 bool IsFshl = (ShAmt == SA0);
2479 if ((IsFshl && TVal != SV0) || (!IsFshl && TVal != SV1))
2500 Intrinsic::ID IID = IsFshl ? Intrinsic::fshl : Intrinsic::fshr;
2521 assert(TC != FC &&
"Expected equal select arms to simplify");
2525 bool IsTrueIfSignSet;
2543 Value *MagArg = ConstantFP::get(SelType,
abs(*TC));
2550 if (!isa<VectorType>(Sel.
getType()))
2561 if (
auto *
I = dyn_cast<Instruction>(V))
2562 I->copyIRFlags(&Sel);
2573 return createSelReverse(
C,
X,
Y);
2577 return createSelReverse(
C,
X, FVal);
2582 return createSelReverse(
C, TVal,
Y);
2585 auto *VecTy = dyn_cast<FixedVectorType>(Sel.
getType());
2589 unsigned NumElts = VecTy->getNumElements();
2590 APInt PoisonElts(NumElts, 0);
2604 cast<ShuffleVectorInst>(TVal)->isSelect()) {
2618 cast<ShuffleVectorInst>(FVal)->isSelect()) {
2639 auto *IDomNode = DT[BB]->getIDom();
2645 Value *IfTrue, *IfFalse;
2661 if (TrueSucc == FalseSucc)
2682 if (
auto *
Insn = dyn_cast<Instruction>(Inputs[Pred]))
2701 if (
auto *
I = dyn_cast<Instruction>(V))
2702 CandidateBlocks.
insert(
I->getParent());
2705 if (
auto *PN = foldSelectToPhiImpl(Sel, BB, DT, Builder))
2718 Value *CondVal =
SI.getCondition();
2723 Value *
Op, *RemRes, *Remainder;
2725 bool TrueIfSigned =
false;
2739 return BinaryOperator::CreateAnd(
Op,
Add);
2751 return FoldToBitwiseAnd(Remainder);
2760 return FoldToBitwiseAnd(ConstantInt::get(RemRes->
getType(), 2));
2796 Value *InnerCondVal =
SI.getCondition();
2797 Value *InnerTrueVal =
SI.getTrueValue();
2798 Value *InnerFalseVal =
SI.getFalseValue();
2800 "The type of inner condition must match with the outer.");
2802 return *Implied ? InnerTrueVal : InnerFalseVal;
2809 assert(
Op->getType()->isIntOrIntVectorTy(1) &&
2810 "Op must be either i1 or vector of i1.");
2811 if (
SI.getCondition()->getType() !=
Op->getType())
2813 if (
Value *V = simplifyNestedSelectsUsingImpliedCond(SI,
Op, IsAnd,
DL))
2824 Value *CondVal =
SI.getCondition();
2826 bool ChangedFMF =
false;
2827 for (
bool Swap : {
false,
true}) {
2857 FastMathFlags FMF = cast<FPMathOperator>(TrueVal)->getFastMathFlags();
2858 if (FMF.
noNaNs() && !
SI.hasNoNaNs()) {
2859 SI.setHasNoNaNs(
true);
2862 if (FMF.
noInfs() && !
SI.hasNoInfs()) {
2863 SI.setHasNoInfs(
true);
2877 if (!
SI.hasNoSignedZeros() || !
SI.hasNoNaNs())
2894 Instruction *NewFNeg = UnaryOperator::CreateFNeg(Fabs);
2903 for (
bool Swap : {
false,
true}) {
2919 if (Swap == TrueIfSigned && !CondVal->
hasOneUse() && !
TrueVal->hasOneUse())
2925 if (Swap != TrueIfSigned)
2930 return ChangedFMF ? &
SI :
nullptr;
2948foldRoundUpIntegerWithPow2Alignment(
SelectInst &SI,
2952 Value *XBiasedHighBits =
SI.getFalseValue();
2965 const APInt *LowBitMaskCst;
2970 const APInt *BiasCst, *HighBitMaskCst;
2971 if (!
match(XBiasedHighBits,
2974 !
match(XBiasedHighBits,
2979 if (!LowBitMaskCst->
isMask())
2982 APInt InvertedLowBitMaskCst = ~*LowBitMaskCst;
2983 if (InvertedLowBitMaskCst != *HighBitMaskCst)
2986 APInt AlignmentCst = *LowBitMaskCst + 1;
2988 if (*BiasCst != AlignmentCst && *BiasCst != *LowBitMaskCst)
2993 if (*BiasCst == *LowBitMaskCst &&
impliesPoison(XBiasedHighBits,
X))
2994 return XBiasedHighBits;
2999 Type *Ty =
X->getType();
3000 Value *XOffset = Builder.
CreateAdd(
X, ConstantInt::get(Ty, *LowBitMaskCst),
3001 X->getName() +
".biased");
3002 Value *
R = Builder.
CreateAnd(XOffset, ConstantInt::get(Ty, *HighBitMaskCst));
3008struct DecomposedSelect {
3020foldSelectOfSymmetricSelect(
SelectInst &OuterSelVal,
3023 Value *OuterCond, *InnerCond, *InnerTrueVal, *InnerFalseVal;
3051 DecomposedSelect OuterSel;
3058 std::swap(OuterSel.TrueVal, OuterSel.FalseVal);
3066 Value *InnerSelVal = IsAndVariant ? OuterSel.FalseVal : OuterSel.TrueVal;
3070 [](
Value *V) {
return V->hasOneUse(); }))
3074 DecomposedSelect InnerSel;
3075 if (!
match(InnerSelVal,
3082 std::swap(InnerSel.TrueVal, InnerSel.FalseVal);
3084 Value *AltCond =
nullptr;
3085 auto matchOuterCond = [OuterSel, IsAndVariant, &AltCond](
auto m_InnerCond) {
3090 return IsAndVariant ?
match(OuterSel.Cond,
3100 if (matchOuterCond(
m_Specific(InnerSel.Cond))) {
3105 std::swap(InnerSel.TrueVal, InnerSel.FalseVal);
3106 InnerSel.Cond = NotInnerCond;
3111 AltCond, IsAndVariant ? OuterSel.TrueVal : InnerSel.FalseVal,
3112 IsAndVariant ? InnerSel.TrueVal : OuterSel.FalseVal);
3115 IsAndVariant ? SelInner : InnerSel.TrueVal,
3116 !IsAndVariant ? SelInner : InnerSel.FalseVal);
3120 Value *CondVal =
SI.getCondition();
3123 Type *SelType =
SI.getType();
3142 return BinaryOperator::CreateOr(CondVal, FalseVal);
3152 if (
auto *LHS = dyn_cast<FCmpInst>(CondVal))
3153 if (
auto *RHS = dyn_cast<FCmpInst>(FalseVal))
3154 if (
Value *V = foldLogicOfFCmps(LHS, RHS,
false,
3162 bool CondLogicAnd = isa<SelectInst>(CondVal);
3163 bool FalseLogicAnd = isa<SelectInst>(FalseVal);
3164 auto AndFactorization = [&](
Value *Common,
Value *InnerCond,
3170 if (FalseLogicAnd || (CondLogicAnd && Common ==
A))
3173 return BinaryOperator::CreateAnd(Common, InnerSel);
3177 return AndFactorization(
A,
B,
D);
3179 return AndFactorization(
A,
B,
C);
3181 return AndFactorization(
B,
A,
D);
3183 return AndFactorization(
B,
A,
C, CondLogicAnd && FalseLogicAnd);
3190 return BinaryOperator::CreateAnd(CondVal, TrueVal);
3200 if (
auto *LHS = dyn_cast<FCmpInst>(CondVal))
3201 if (
auto *RHS = dyn_cast<FCmpInst>(TrueVal))
3202 if (
Value *V = foldLogicOfFCmps(LHS, RHS,
true,
3210 bool CondLogicOr = isa<SelectInst>(CondVal);
3211 bool TrueLogicOr = isa<SelectInst>(TrueVal);
3212 auto OrFactorization = [&](
Value *Common,
Value *InnerCond,
3218 if (TrueLogicOr || (CondLogicOr && Common ==
A))
3221 return BinaryOperator::CreateOr(Common, InnerSel);
3225 return OrFactorization(
A,
B,
D);
3227 return OrFactorization(
A,
B,
C);
3229 return OrFactorization(
B,
A,
D);
3231 return OrFactorization(
B,
A,
C, CondLogicOr && TrueLogicOr);
3274 return BinaryOperator::CreateXor(
A,
B);
3308 auto *FI =
new FreezeInst(*
Y, (*Y)->getName() +
".fr");
3314 if (
auto *ICmp0 = dyn_cast<ICmpInst>(CondVal))
3315 if (
auto *ICmp1 = dyn_cast<ICmpInst>(Op1))
3316 if (
auto *V = foldAndOrOfICmps(ICmp0, ICmp1, SI, IsAnd,
3327 if (Res && *Res ==
false)
3333 if (Res && *Res ==
false)
3342 if (Res && *Res ==
true)
3348 if (Res && *Res ==
true)
3361 auto *SelCond = dyn_cast<SelectInst>(CondVal);
3362 auto *SelFVal = dyn_cast<SelectInst>(FalseVal);
3363 bool MayNeedFreeze = SelCond && SelFVal &&
3364 match(SelFVal->getTrueValue(),
3377 auto *SelCond = dyn_cast<SelectInst>(CondVal);
3378 auto *SelFVal = dyn_cast<SelectInst>(FalseVal);
3379 bool MayNeedFreeze = SelCond && SelFVal &&
3380 match(SelCond->getTrueValue(),
3396 bool &ShouldDropNUW) {
3419 ShouldDropNUW =
false;
3425 auto MatchForward = [&](
Value *CommonAncestor) {
3426 const APInt *
C =
nullptr;
3427 if (CtlzOp == CommonAncestor)
3434 ShouldDropNUW =
true;
3445 const APInt *
C =
nullptr;
3446 Value *CommonAncestor;
3447 if (MatchForward(Cond0)) {
3451 if (!MatchForward(CommonAncestor))
3488 Type *SelType =
SI.getType();
3495 Value *Cond0, *Ctlz, *CtlzOp;
3511 !isSafeToRemoveBitCeilSelect(Pred, Cond0, Cond1, CtlzOp,
BitWidth,
3516 cast<Instruction>(CtlzOp)->setHasNoUnsignedWrap(
false);
3544 FastMathFlags FMF = cast<FPMathOperator>(TrueVal)->getFastMathFlags();
3566 if (
auto *
I = dyn_cast<Instruction>(V)) {
3567 if (isa<PHINode>(
I)) {
3573 return Op->getType()->isIntOrIntVectorTy() &&
3574 hasAffectedValue(Op, Affected, Depth + 1);
3582 Value *CondVal =
SI.getCondition();
3585 Type *SelType =
SI.getType();
3594 if (
Instruction *
I = canonicalizeScalarSelectOfVecs(SI, *
this))
3630 return new ZExtInst(CondVal, SelType);
3634 return new SExtInst(CondVal, SelType);
3639 return new ZExtInst(NotCond, SelType);
3645 return new SExtInst(NotCond, SelType);
3649 auto *SIFPOp = dyn_cast<FPMathOperator>(&SI);
3651 if (
auto *FCmp = dyn_cast<FCmpInst>(CondVal)) {
3653 Value *Cmp0 = FCmp->getOperand(0), *Cmp1 = FCmp->getOperand(1);
3655 if ((Cmp0 == TrueVal && Cmp1 == FalseVal) ||
3656 (Cmp0 == FalseVal && Cmp1 == TrueVal)) {
3668 FCmp->getName() +
".inv");
3688 Value *MatchCmp0 =
nullptr;
3689 Value *MatchCmp1 =
nullptr;
3701 if (Cmp0 == MatchCmp0 &&
3702 matchFMulByZeroIfResultEqZero(*
this, Cmp0, Cmp1, MatchCmp1, MatchCmp0,
3703 SI, SIFPOp->hasNoSignedZeros()))
3713 if (SIFPOp->hasNoNaNs() && SIFPOp->hasNoSignedZeros()) {
3726 if (
Instruction *Fabs = foldSelectWithFCmpToFabs(SI, *
this))
3730 if (
ICmpInst *ICI = dyn_cast<ICmpInst>(CondVal))
3744 auto *TI = dyn_cast<Instruction>(TrueVal);
3745 auto *FI = dyn_cast<Instruction>(FalseVal);
3746 if (TI && FI && TI->getOpcode() == FI->
getOpcode())
3765 if (isa<VectorType>(CondVal->
getType()) && !isa<VectorType>(
Idx->getType()))
3777 if (
auto *TrueGep = dyn_cast<GetElementPtrInst>(TrueVal))
3778 if (
auto *NewGep = SelectGepWithBase(TrueGep, FalseVal,
false))
3780 if (
auto *FalseGep = dyn_cast<GetElementPtrInst>(FalseVal))
3781 if (
auto *NewGep = SelectGepWithBase(FalseGep, TrueVal,
true))
3797 RHS2, SI, SPF, RHS))
3801 RHS2, SI, SPF, LHS))
3810 bool IsCastNeeded =
LHS->
getType() != SelType;
3811 Value *CmpLHS = cast<CmpInst>(CondVal)->getOperand(0);
3812 Value *CmpRHS = cast<CmpInst>(CondVal)->getOperand(1);
3815 ((CmpLHS != LHS && CmpLHS != RHS) ||
3816 (CmpRHS != LHS && CmpRHS != RHS)))) {
3825 cast<FPMathOperator>(
SI.getCondition())->getFastMathFlags();
3841 if (
auto *PN = dyn_cast<PHINode>(
SI.getCondition()))
3843 if (canSelectOperandBeMappingIntoPredBlock(TrueVal, SI) &&
3844 canSelectOperandBeMappingIntoPredBlock(FalseVal, SI))
3848 if (
SelectInst *TrueSI = dyn_cast<SelectInst>(TrueVal)) {
3849 if (TrueSI->getCondition()->getType() == CondVal->
getType()) {
3852 if (
Value *V = simplifyNestedSelectsUsingImpliedCond(
3853 *TrueSI, CondVal,
true,
DL))
3860 if (TrueSI->getFalseValue() == FalseVal && TrueSI->hasOneUse()) {
3868 if (
SelectInst *FalseSI = dyn_cast<SelectInst>(FalseVal)) {
3869 if (FalseSI->getCondition()->getType() == CondVal->
getType()) {
3872 if (
Value *V = simplifyNestedSelectsUsingImpliedCond(
3873 *FalseSI, CondVal,
false,
DL))
3877 if (FalseSI->getTrueValue() == TrueVal && FalseSI->hasOneUse()) {
3894 if (
auto *TrueBOSI = dyn_cast<SelectInst>(TrueBO->
getOperand(0))) {
3895 if (TrueBOSI->getCondition() == CondVal) {
3901 if (
auto *TrueBOSI = dyn_cast<SelectInst>(TrueBO->
getOperand(1))) {
3902 if (TrueBOSI->getCondition() == CondVal) {
3913 if (
auto *FalseBOSI = dyn_cast<SelectInst>(FalseBO->
getOperand(0))) {
3914 if (FalseBOSI->getCondition() == CondVal) {
3920 if (
auto *FalseBOSI = dyn_cast<SelectInst>(FalseBO->
getOperand(1))) {
3921 if (FalseBOSI->getCondition() == CondVal) {
3934 SI.swapProfMetadata();
3949 if (Known.One.isOne())
3951 if (Known.Zero.isOne())
3959 if (
Value *V = foldSelectCmpXchg(SI))
3977 if (
Value *V = foldRoundUpIntegerWithPow2Alignment(SI,
Builder))
3987 auto *MaskedInst = cast<IntrinsicInst>(TrueVal);
3988 if (isa<UndefValue>(MaskedInst->getArgOperand(3)))
3989 MaskedInst->setArgOperand(3, FalseVal );
4004 bool CanMergeSelectIntoLoad =
false;
4008 if (CanMergeSelectIntoLoad) {
4009 auto *MaskedInst = cast<IntrinsicInst>(FalseVal);
4010 if (isa<UndefValue>(MaskedInst->getArgOperand(3)))
4011 MaskedInst->setArgOperand(3, TrueVal );
4037 auto FoldSelectWithAndOrCond = [&](
bool IsAnd,
Value *
A,
4045 if (
ICmpInst *Cmp = dyn_cast<ICmpInst>(
B))
4046 if (
Value *V = canonicalizeSPF(*Cmp, TrueVal, FalseVal, *
this))
4048 IsAnd ? FalseVal : V);
4056 if (
Instruction *
I = FoldSelectWithAndOrCond(
true, LHS, RHS))
4058 if (
Instruction *
I = FoldSelectWithAndOrCond(
true, RHS, LHS))
4061 if (
Instruction *
I = FoldSelectWithAndOrCond(
false, LHS, RHS))
4063 if (
Instruction *
I = FoldSelectWithAndOrCond(
false, RHS, LHS))
4069 if (
Instruction *
I = FoldSelectWithAndOrCond(
true, LHS, RHS))
4072 if (
Instruction *
I = FoldSelectWithAndOrCond(
false, LHS, RHS))
4079 return BinaryOperator::CreateXor(CondVal, FalseVal);
4084 (!isa<Constant>(TrueVal) || !isa<Constant>(FalseVal))) {
4088 CC.AffectedValues.insert(V);
4091 if (!
CC.AffectedValues.empty()) {
4092 if (!isa<Constant>(TrueVal) &&
4093 hasAffectedValue(TrueVal,
CC.AffectedValues, 0)) {
4101 if (!isa<Constant>(FalseVal) &&
4102 hasAffectedValue(FalseVal,
CC.AffectedValues, 0)) {
SmallVector< AArch64_IMM::ImmInsnModel, 4 > Insn
amdgpu 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 ugt(const APInt &RHS) const
Unsigned greater than comparison.
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 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 function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CastInst * CreateBitOrPointerCast(Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
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 ...
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
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.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
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.
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.
bool noSignedZeros() const
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.
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.
Common base class shared among various IRBuilders.
CallInst * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
Value * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
Value * CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Value * CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name="")
Return a vector value that contains.
ConstantInt * getTrue()
Get the constant value for i1 true.
CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
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)
void setFastMathFlags(FastMathFlags NewFMF)
Set the fast-math flags to be used with generated fp-math operators.
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNSW=false)
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.
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="")
Value * CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy, 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)
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 * foldOpIntoPhi(Instruction &I, PHINode *PN)
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 * foldSelectValueEquivalence(SelectInst &SI, ICmpInst &ICI)
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
static bool isCanonicalPredicate(CmpInst::Predicate Pred)
Predicate canonicalization reduces the number of patterns that need to be matched by other transforms...
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)
static std::optional< std::pair< CmpInst::Predicate, Constant * > > getFlippedStrictnessPredicateAndConstant(CmpInst::Predicate Pred, Constant *C)
void replaceUse(Use &U, Value *NewValue)
Replace use and add the previously used value to the worklist.
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 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.
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.
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...
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 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.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
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.
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.
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.
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.
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
BinaryOp_match< LHS, RHS, Instruction::Xor, true > m_c_Xor(const LHS &L, const RHS &R)
Matches an Xor with LHS and RHS in either order.
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.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
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.
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
BinOpPred_match< LHS, RHS, is_bitwiselogic_op, true > m_c_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations in either order.
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.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate, true > m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
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.
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.
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty > m_OrdFMax(const LHS &L, const RHS &R)
Match an 'ordered' floating point maximum function.
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)
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.
MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty > m_OrdFMin(const LHS &L, const RHS &R)
Match an 'ordered' floating point minimum function.
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)
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.
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
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.
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 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.
@ SPF_UMIN
Signed minimum.
@ SPF_UMAX
Signed maximum.
@ SPF_SMAX
Unsigned minimum.
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 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:
constexpr int PoisonMaskElem
@ 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.
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
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
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)
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
bool decomposeBitTestICmp(Value *LHS, Value *RHS, CmpInst::Predicate &Pred, Value *&X, APInt &Mask, bool LookThroughTrunc=true)
Decompose an icmp into the form ((X & Mask) pred 0) if possible.
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