49#define DEBUG_TYPE "instsimplify"
86 if (
auto *BO = dyn_cast<BinaryOperator>(
Cond))
87 BinOpCode = BO->getOpcode();
92 if (BinOpCode == BinaryOperator::Or) {
93 ExpectedPred = ICmpInst::ICMP_NE;
94 }
else if (BinOpCode == BinaryOperator::And) {
95 ExpectedPred = ICmpInst::ICMP_EQ;
116 Pred1 != Pred2 || Pred1 != ExpectedPred)
119 if (
X == TrueVal ||
X == FalseVal ||
Y == TrueVal ||
Y == FalseVal)
120 return BinOpCode == BinaryOperator::Or ? TrueVal : FalseVal;
136 CmpInst *Cmp = dyn_cast<CmpInst>(V);
140 Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1);
141 if (CPred == Pred && CLHS ==
LHS && CRHS ==
RHS)
157 if (SimplifiedCmp ==
Cond) {
165 return SimplifiedCmp;
172 unsigned MaxRecurse) {
181 unsigned MaxRecurse) {
191 unsigned MaxRecurse) {
228 if (
I->getParent()->isEntryBlock() && !isa<InvokeInst>(
I) &&
241 auto *
B = dyn_cast<BinaryOperator>(V);
242 if (!
B ||
B->getOpcode() != OpcodeToExpand)
244 Value *B0 =
B->getOperand(0), *B1 =
B->getOperand(1);
255 if ((L == B0 && R == B1) ||
276 unsigned MaxRecurse) {
293 unsigned MaxRecurse) {
396 unsigned MaxRecurse) {
402 if (isa<SelectInst>(
LHS)) {
403 SI = cast<SelectInst>(
LHS);
405 assert(isa<SelectInst>(
RHS) &&
"No select instruction operand!");
406 SI = cast<SelectInst>(
RHS);
433 if (TV == SI->getTrueValue() && FV == SI->getFalseValue())
439 if ((FV && !TV) || (TV && !FV)) {
442 Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV);
443 if (Simplified && Simplified->getOpcode() ==
unsigned(Opcode) &&
444 !Simplified->hasPoisonGeneratingFlags()) {
448 Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue();
449 Value *UnsimplifiedLHS = SI ==
LHS ? UnsimplifiedBranch :
LHS;
450 Value *UnsimplifiedRHS = SI ==
LHS ?
RHS : UnsimplifiedBranch;
451 if (Simplified->getOperand(0) == UnsimplifiedLHS &&
452 Simplified->getOperand(1) == UnsimplifiedRHS)
454 if (Simplified->isCommutative() &&
455 Simplified->getOperand(1) == UnsimplifiedLHS &&
456 Simplified->getOperand(0) == UnsimplifiedRHS)
475 unsigned MaxRecurse) {
481 if (!isa<SelectInst>(
LHS)) {
485 assert(isa<SelectInst>(
LHS) &&
"Not comparing with a select instruction!");
488 Value *TV = SI->getTrueValue();
489 Value *FV = SI->getFalseValue();
521 unsigned MaxRecurse) {
527 if (isa<PHINode>(
LHS)) {
528 PI = cast<PHINode>(
LHS);
533 assert(isa<PHINode>(
RHS) &&
"No PHI instruction operand!");
534 PI = cast<PHINode>(
RHS);
541 Value *CommonValue =
nullptr;
554 if (!V || (CommonValue && V != CommonValue))
573 if (!isa<PHINode>(
LHS)) {
577 assert(isa<PHINode>(
LHS) &&
"Not comparing with a phi instruction!");
585 Value *CommonValue =
nullptr;
599 if (!V || (CommonValue && V != CommonValue))
610 if (
auto *CLHS = dyn_cast<Constant>(Op0)) {
611 if (
auto *CRHS = dyn_cast<Constant>(Op1)) {
615 case Instruction::FAdd:
616 case Instruction::FSub:
617 case Instruction::FMul:
618 case Instruction::FDiv:
619 case Instruction::FRem:
620 if (Q.
CxtI !=
nullptr)
641 if (isa<PoisonValue>(Op1))
704 return ::simplifyAddInst(Op0, Op1, IsNSW, IsNUW, Query,
RecursionLimit);
717 bool AllowNonInbounds =
false) {
718 assert(V->getType()->isPtrOrPtrVectorTy());
721 V = V->stripAndAccumulateConstantOffsets(
DL,
Offset, AllowNonInbounds);
724 return Offset.sextOrTrunc(
DL.getIndexTypeSizeInBits(V->getType()));
744 if (
auto *VecTy = dyn_cast<VectorType>(
LHS->
getType()))
759 std::optional<bool> Imp =
764 case Instruction::Sub:
765 case Instruction::Xor:
766 case Instruction::URem:
767 case Instruction::SRem:
770 case Instruction::SDiv:
771 case Instruction::UDiv:
772 return ConstantInt::get(Ty, 1);
774 case Instruction::And:
775 case Instruction::Or:
794 if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
830 Value *
X =
nullptr, *
Y =
nullptr, *Z = Op1;
888 if (
X->getType() ==
Y->getType())
925 return ::simplifySubInst(Op0, Op1, IsNSW, IsNUW, Q,
RecursionLimit);
936 if (isa<PoisonValue>(Op1))
960 return ConstantInt::getNullValue(Op0->
getType());
975 Instruction::Add, Q, MaxRecurse))
980 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
987 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
997 return ::simplifyMulInst(Op0, Op1, IsNSW, IsNUW, Q,
RecursionLimit);
1006 Constant *
C = dyn_cast_or_null<Constant>(V);
1007 return (
C &&
C->isAllOnesValue());
1013 unsigned MaxRecurse,
bool IsSigned) {
1030 Type *Ty =
X->getType();
1036 Constant *PosDividendC = ConstantInt::get(Ty,
C->abs());
1037 Constant *NegDividendC = ConstantInt::get(Ty, -
C->abs());
1046 if (
C->isMinSignedValue())
1052 Constant *PosDivisorC = ConstantInt::get(Ty,
C->abs());
1053 Constant *NegDivisorC = ConstantInt::get(Ty, -
C->abs());
1073 return isICmpTrue(ICmpInst::ICMP_ULT,
X,
Y, Q, MaxRecurse);
1080 unsigned MaxRecurse) {
1081 bool IsDiv = (Opcode == Instruction::SDiv || Opcode == Instruction::UDiv);
1082 bool IsSigned = (Opcode == Instruction::SDiv || Opcode == Instruction::SRem);
1099 auto *Op1C = dyn_cast<Constant>(Op1);
1100 auto *VTy = dyn_cast<FixedVectorType>(Ty);
1102 unsigned NumElts = VTy->getNumElements();
1103 for (
unsigned i = 0; i != NumElts; ++i) {
1112 if (isa<PoisonValue>(Op0))
1152 auto *
Mul = cast<OverflowingBinaryOperator>(Op0);
1163 if (
isDivZero(Op0, Op1, Q, MaxRecurse, IsSigned))
1171 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1177 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1187 unsigned MaxRecurse) {
1210 (Opcode == Instruction::UDiv
1230 ((Opcode == Instruction::SRem &&
1232 (Opcode == Instruction::URem &&
1247 return simplifyDiv(Instruction::SDiv, Op0, Op1, IsExact, Q, MaxRecurse);
1259 return simplifyDiv(Instruction::UDiv, Op0, Op1, IsExact, Q, MaxRecurse);
1270 unsigned MaxRecurse) {
1275 return ConstantInt::getNullValue(Op0->
getType());
1279 return ConstantInt::getNullValue(Op0->
getType());
1281 return simplifyRem(Instruction::SRem, Op0, Op1, Q, MaxRecurse);
1291 unsigned MaxRecurse) {
1292 return simplifyRem(Instruction::URem, Op0, Op1, Q, MaxRecurse);
1301 Constant *
C = dyn_cast<Constant>(Amount);
1311 const APInt *AmountC;
1317 if (isa<ConstantVector>(
C) || isa<ConstantDataVector>(
C)) {
1318 for (
unsigned I = 0,
1319 E = cast<FixedVectorType>(
C->getType())->getNumElements();
1333 unsigned MaxRecurse) {
1338 if (isa<PoisonValue>(Op0))
1359 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1365 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1383 assert(Opcode == Instruction::Shl &&
"Expected shl for nsw instruction");
1402 Value *Op1,
bool IsExact,
1421 if (Op0Known.
One[0])
1433 simplifyShift(Instruction::Shl, Op0, Op1, IsNSW, Q, MaxRecurse))
1457 if (IsNSW && IsNUW &&
1466 return ::simplifyShlInst(Op0, Op1, IsNSW, IsNUW, Q,
RecursionLimit);
1488 const APInt *ShRAmt, *ShLAmt;
1491 *ShRAmt == *ShLAmt) {
1494 if (ShRAmt->
uge(EffWidthY))
1542 ICmpInst *UnsignedICmp,
bool IsAnd,
1556 if (
match(UnsignedICmp,
1558 ICmpInst::isUnsigned(UnsignedPred)) {
1560 if ((UnsignedPred == ICmpInst::ICMP_UGE ||
1561 UnsignedPred == ICmpInst::ICMP_ULE) &&
1562 EqPred == ICmpInst::ICMP_NE && !IsAnd)
1565 if ((UnsignedPred == ICmpInst::ICMP_ULT ||
1566 UnsignedPred == ICmpInst::ICMP_UGT) &&
1567 EqPred == ICmpInst::ICMP_EQ && IsAnd)
1572 if (EqPred == ICmpInst::ICMP_NE && (UnsignedPred == ICmpInst::ICMP_ULT ||
1573 UnsignedPred == ICmpInst::ICMP_UGT))
1574 return IsAnd ? UnsignedICmp : ZeroICmp;
1578 if (EqPred == ICmpInst::ICMP_EQ && (UnsignedPred == ICmpInst::ICMP_ULE ||
1579 UnsignedPred == ICmpInst::ICMP_UGE))
1580 return IsAnd ? ZeroICmp : UnsignedICmp;
1586 if (
match(UnsignedICmp,
1588 if (UnsignedPred == ICmpInst::ICMP_UGE && IsAnd &&
1590 return UnsignedICmp;
1591 if (UnsignedPred == ICmpInst::ICMP_ULT && !IsAnd &&
1593 return UnsignedICmp;
1598 ICmpInst::isUnsigned(UnsignedPred))
1600 else if (
match(UnsignedICmp,
1602 ICmpInst::isUnsigned(UnsignedPred))
1603 UnsignedPred = ICmpInst::getSwappedPredicate(UnsignedPred);
1609 if (UnsignedPred == ICmpInst::ICMP_UGT && EqPred == ICmpInst::ICMP_EQ &&
1611 return IsAnd ? ZeroICmp : UnsignedICmp;
1615 if (UnsignedPred == ICmpInst::ICMP_ULE && EqPred == ICmpInst::ICMP_NE &&
1617 return IsAnd ? UnsignedICmp : ZeroICmp;
1626 if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_NE)
1627 return IsAnd ? UnsignedICmp : ZeroICmp;
1631 if (UnsignedPred == ICmpInst::ICMP_UGE && EqPred == ICmpInst::ICMP_EQ)
1632 return IsAnd ? ZeroICmp : UnsignedICmp;
1635 if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_EQ &&
1640 if (UnsignedPred == ICmpInst::ICMP_UGE && EqPred == ICmpInst::ICMP_NE &&
1656 const APInt *C0, *C1;
1666 if (IsAnd && Range0.intersectWith(Range1).isEmptySet())
1671 if (!IsAnd && Range0.unionWith(Range1).isFullSet())
1679 if (Range0.contains(Range1))
1680 return IsAnd ? Cmp1 : Cmp0;
1681 if (Range1.contains(Range0))
1682 return IsAnd ? Cmp0 : Cmp1;
1691 const APInt *C0, *C1;
1699 auto *AddInst = cast<OverflowingBinaryOperator>(Op0->
getOperand(0));
1700 if (AddInst->getOperand(1) != Op1->
getOperand(1))
1707 const APInt Delta = *C1 - *C0;
1710 if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_SGT)
1712 if (Pred0 == ICmpInst::ICMP_SLT && Pred1 == ICmpInst::ICMP_SGT && IsNSW)
1716 if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_SGT)
1718 if (Pred0 == ICmpInst::ICMP_SLE && Pred1 == ICmpInst::ICMP_SGT && IsNSW)
1724 if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_UGT)
1727 if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_UGT)
1746 if (!IsAnd && Pred0 == ICmpInst::ICMP_EQ && Pred1 == ICmpInst::ICMP_NE)
1749 if (IsAnd && Pred0 == ICmpInst::ICMP_NE && Pred1 == ICmpInst::ICMP_EQ)
1782 const APInt *C0, *C1;
1790 auto *AddInst = cast<BinaryOperator>(Op0->
getOperand(0));
1791 if (AddInst->getOperand(1) != Op1->
getOperand(1))
1798 const APInt Delta = *C1 - *C0;
1801 if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_SLE)
1803 if (Pred0 == ICmpInst::ICMP_SGE && Pred1 == ICmpInst::ICMP_SLE && IsNSW)
1807 if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_SLE)
1809 if (Pred0 == ICmpInst::ICMP_SGT && Pred1 == ICmpInst::ICMP_SLE && IsNSW)
1815 if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_ULE)
1818 if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_ULE)
1850 Value *LHS0 =
LHS->getOperand(0), *LHS1 =
LHS->getOperand(1);
1851 Value *RHS0 =
RHS->getOperand(0), *RHS1 =
RHS->getOperand(1);
1856 if ((PredL == FCmpInst::FCMP_ORD || PredL == FCmpInst::FCMP_UNO) &&
1857 ((FCmpInst::isOrdered(PredR) && IsAnd) ||
1858 (FCmpInst::isUnordered(PredR) && !IsAnd))) {
1863 if (((LHS1 == RHS0 || LHS1 == RHS1) &&
1865 ((LHS0 == RHS0 || LHS0 == RHS1) &&
1867 return FCmpInst::isOrdered(PredL) == FCmpInst::isOrdered(PredR)
1872 if ((PredR == FCmpInst::FCMP_ORD || PredR == FCmpInst::FCMP_UNO) &&
1873 ((FCmpInst::isOrdered(PredL) && IsAnd) ||
1874 (FCmpInst::isUnordered(PredL) && !IsAnd))) {
1879 if (((RHS1 == LHS0 || RHS1 == LHS1) &&
1881 ((RHS0 == LHS0 || RHS0 == LHS1) &&
1883 return FCmpInst::isOrdered(PredL) == FCmpInst::isOrdered(PredR)
1892 Value *Op1,
bool IsAnd) {
1894 auto *Cast0 = dyn_cast<CastInst>(Op0);
1895 auto *Cast1 = dyn_cast<CastInst>(Op1);
1896 if (Cast0 && Cast1 && Cast0->getOpcode() == Cast1->getOpcode() &&
1897 Cast0->getSrcTy() == Cast1->getSrcTy()) {
1898 Op0 = Cast0->getOperand(0);
1899 Op1 = Cast1->getOperand(0);
1903 auto *ICmp0 = dyn_cast<ICmpInst>(Op0);
1904 auto *ICmp1 = dyn_cast<ICmpInst>(Op1);
1909 auto *FCmp0 = dyn_cast<FCmpInst>(Op0);
1910 auto *FCmp1 = dyn_cast<FCmpInst>(Op1);
1921 if (
auto *
C = dyn_cast<Constant>(V))
1930 bool AllowRefinement,
1932 unsigned MaxRecurse);
1936 unsigned MaxRecurse) {
1937 assert((Opcode == Instruction::And || Opcode == Instruction::Or) &&
1952 (Opcode == Instruction::And ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE)) {
1953 if (Res == Absorber)
1963 if (Res == Absorber)
1970 nullptr, MaxRecurse))
1971 return Simplify(Res);
1974 nullptr, MaxRecurse))
1975 return Simplify(Res);
1985 assert(BinaryOperator::isBitwiseLogicOp(Opcode) &&
"Expected logic op");
1997 return Opcode == Instruction::And ? ConstantInt::getNullValue(Ty)
1998 : ConstantInt::getAllOnesValue(Ty);
2007 unsigned MaxRecurse) {
2041 const APInt *Shift1, *Shift2;
2046 Shift1->
uge(*Shift2))
2059 unsigned MaxRecurse) {
2064 if (isa<PoisonValue>(Op1))
2099 (~(*Mask)).lshr(*ShAmt).isZero())
2105 (~(*Mask)).shl(*ShAmt).isZero())
2110 const APInt *PowerC;
2119 return ConstantInt::getNullValue(Op1->
getType());
2132 Instruction::Or, Q, MaxRecurse))
2137 Instruction::Xor, Q, MaxRecurse))
2140 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) {
2158 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
2182 if (EffWidthY <= ShftCnt) {
2215 if (*Implied ==
true)
2218 if (*Implied ==
false)
2243 assert(
X->getType() ==
Y->getType() &&
"Expected same type for 'or' ops");
2244 Type *Ty =
X->getType();
2248 return ConstantInt::getAllOnesValue(Ty);
2252 return ConstantInt::getAllOnesValue(Ty);
2270 return ConstantInt::getAllOnesValue(Ty);
2294 return ConstantInt::getAllOnesValue(Ty);
2334 unsigned MaxRecurse) {
2339 if (isa<PoisonValue>(Op1))
2373 C->ule(
X->getType()->getScalarSizeInBits())) {
2374 return ConstantInt::getAllOnesValue(
X->getType());
2428 Instruction::And, Q, MaxRecurse))
2431 if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) {
2449 const APInt *C1, *C2;
2475 if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
2485 if (std::optional<bool> Implied =
2488 if (*Implied ==
false)
2491 if (*Implied ==
true)
2494 if (std::optional<bool> Implied =
2497 if (*Implied ==
false)
2500 if (*Implied ==
true)
2518 unsigned MaxRecurse) {
2523 if (isa<PoisonValue>(Op1))
2560 if (
Value *R = foldAndOrNot(Op0, Op1))
2562 if (
Value *R = foldAndOrNot(Op1, Op0))
2604 CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition());
2607 Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1);
2608 if (Pred == Cmp->getPredicate() &&
LHS == CmpLHS &&
RHS == CmpRHS)
2611 LHS == CmpRHS &&
RHS == CmpLHS)
2624 if (
const AllocaInst *AI = dyn_cast<AllocaInst>(V))
2625 return AI->isStaticAlloca();
2626 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V))
2627 return (GV->hasLocalLinkage() || GV->hasHiddenVisibility() ||
2628 GV->hasProtectedVisibility() || GV->hasGlobalUnnamedAddr()) &&
2629 !GV->isThreadLocal();
2630 if (
const Argument *
A = dyn_cast<Argument>(V))
2631 return A->hasByValAttr();
2664 auto isByValArg = [](
const Value *V) {
2665 const Argument *
A = dyn_cast<Argument>(V);
2666 return A &&
A->hasByValAttr();
2672 return isa<AllocaInst>(V2) || isa<GlobalVariable>(V2) || isByValArg(V2);
2674 return isa<AllocaInst>(V1) || isa<GlobalVariable>(V1) || isByValArg(V1);
2676 return isa<AllocaInst>(V1) &&
2677 (isa<AllocaInst>(V2) || isa<GlobalVariable>(V2));
2746 unsigned IndexSize =
DL.getIndexTypeSizeInBits(
LHS->
getType());
2747 APInt LHSOffset(IndexSize, 0), RHSOffset(IndexSize, 0);
2767 Opts.
EvalMode = ObjectSizeOpts::Mode::Min;
2769 if (
auto *
I = dyn_cast<Instruction>(V))
2770 return I->getFunction();
2771 if (
auto *
A = dyn_cast<Argument>(V))
2772 return A->getParent();
2778 APInt Dist = LHSOffset - RHSOffset;
2806 if ((IsNAC(LHSUObjs) && IsAllocDisjoint(RHSUObjs)) ||
2807 (IsNAC(RHSUObjs) && IsAllocDisjoint(LHSUObjs)))
2827 bool Captured =
false;
2830 if (
auto *ICmp = dyn_cast<ICmpInst>(U->getUser())) {
2834 unsigned OtherIdx = 1 - U->getOperandNo();
2835 auto *LI = dyn_cast<LoadInst>(ICmp->getOperand(OtherIdx));
2836 if (LI && isa<GlobalVariable>(LI->getPointerOperand()))
2844 CustomCaptureTracker Tracker;
2846 if (!Tracker.Captured)
2868 auto ExtractNotLHS = [](
Value *V) ->
Value * {
2930 case ICmpInst::ICMP_UGE:
2934 case ICmpInst::ICMP_SGE:
2945 case ICmpInst::ICMP_ULE:
2949 case ICmpInst::ICMP_SLE:
2969 case ICmpInst::ICMP_ULT:
2971 case ICmpInst::ICMP_UGE:
2973 case ICmpInst::ICMP_EQ:
2974 case ICmpInst::ICMP_ULE:
2978 case ICmpInst::ICMP_NE:
2979 case ICmpInst::ICMP_UGT:
2983 case ICmpInst::ICMP_SLT: {
2991 case ICmpInst::ICMP_SLE: {
2999 case ICmpInst::ICMP_SGE: {
3007 case ICmpInst::ICMP_SGT: {
3060 *MulC != 0 &&
C->urem(*MulC) != 0) ||
3062 *MulC != 0 &&
C->srem(*MulC) != 0)))
3063 return ConstantInt::get(ITy, Pred == ICmpInst::ICMP_NE);
3071 unsigned MaxRecurse) {
3077 if (Pred == ICmpInst::ICMP_ULT)
3079 if (Pred == ICmpInst::ICMP_UGE)
3082 if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SGE) {
3094 if (Pred == ICmpInst::ICMP_UGT)
3096 if (Pred == ICmpInst::ICMP_ULE)
3105 case ICmpInst::ICMP_SGT:
3106 case ICmpInst::ICMP_SGE: {
3112 case ICmpInst::ICMP_EQ:
3113 case ICmpInst::ICMP_UGT:
3114 case ICmpInst::ICMP_UGE:
3116 case ICmpInst::ICMP_SLT:
3117 case ICmpInst::ICMP_SLE: {
3123 case ICmpInst::ICMP_NE:
3124 case ICmpInst::ICMP_ULT:
3125 case ICmpInst::ICMP_ULE:
3132 if (Pred == ICmpInst::ICMP_ULE)
3134 if (Pred == ICmpInst::ICMP_UGT)
3145 if (Pred == ICmpInst::ICMP_UGT)
3147 if (Pred == ICmpInst::ICMP_ULE)
3168 case ICmpInst::ICMP_EQ:
3169 case ICmpInst::ICMP_UGE:
3171 case ICmpInst::ICMP_NE:
3172 case ICmpInst::ICMP_ULT:
3174 case ICmpInst::ICMP_UGT:
3175 case ICmpInst::ICMP_ULE:
3191 const APInt *C1, *C2;
3198 if (Pred == ICmpInst::ICMP_UGT)
3200 if (Pred == ICmpInst::ICMP_ULE)
3238 const APInt *C1, *C2;
3252 unsigned MaxRecurse) {
3255 if (MaxRecurse && (LBO || RBO)) {
3257 Value *
A =
nullptr, *
B =
nullptr, *
C =
nullptr, *
D =
nullptr;
3259 bool NoLHSWrapProblem =
false, NoRHSWrapProblem =
false;
3260 if (LBO && LBO->
getOpcode() == Instruction::Add) {
3270 if (RBO && RBO->
getOpcode() == Instruction::Add) {
3282 if ((
A ==
RHS ||
B ==
RHS) && NoLHSWrapProblem)
3289 if ((
C ==
LHS ||
D ==
LHS) && NoRHSWrapProblem)
3292 C ==
LHS ?
D :
C, Q, MaxRecurse - 1))
3296 bool CanSimplify = (NoLHSWrapProblem && NoRHSWrapProblem) ||
3298 if (
A &&
C && (
A ==
C ||
A ==
D ||
B ==
C ||
B ==
D) && CanSimplify) {
3305 }
else if (
A ==
D) {
3309 }
else if (
B ==
C) {
3330 ICmpInst::getSwappedPredicate(Pred), RBO,
LHS, Q, MaxRecurse))
3337 if (
C->isStrictlyPositive()) {
3338 if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_NE)
3340 if (Pred == ICmpInst::ICMP_SGE || Pred == ICmpInst::ICMP_EQ)
3343 if (
C->isNonNegative()) {
3344 if (Pred == ICmpInst::ICMP_SLE)
3346 if (Pred == ICmpInst::ICMP_SGT)
3369 if (Pred == ICmpInst::ICMP_EQ)
3371 if (Pred == ICmpInst::ICMP_NE)
3380 if (Pred == ICmpInst::ICMP_UGT)
3382 if (Pred == ICmpInst::ICMP_ULE)
3393 case Instruction::Shl: {
3396 if (!NUW || (ICmpInst::isSigned(Pred) && !NSW) ||
3409 case Instruction::And:
3410 case Instruction::Or: {
3411 const APInt *C1, *C2;
3417 Pred = ICmpInst::getSwappedPredicate(Pred);
3420 if (Pred == ICmpInst::ICMP_ULE)
3422 if (Pred == ICmpInst::ICMP_UGT)
3425 if (Pred == ICmpInst::ICMP_SLE)
3427 if (Pred == ICmpInst::ICMP_SGT)
3441 case Instruction::UDiv:
3442 case Instruction::LShr:
3443 if (ICmpInst::isSigned(Pred) || !Q.
IIQ.
isExact(LBO) ||
3450 case Instruction::SDiv:
3458 case Instruction::AShr:
3465 case Instruction::Shl: {
3470 if (!NSW && ICmpInst::isSigned(Pred))
3486 unsigned MaxRecurse) {
3642 Pred = ICmpInst::getSwappedPredicate(Pred);
3648 (
A ==
C ||
A ==
D ||
B ==
C ||
B ==
D)) {
3657 (
A ==
C ||
A ==
D ||
B ==
C ||
B ==
D)) {
3681 CallInst *Assume = cast<CallInst>(AssumeVH);
3694 auto *II = dyn_cast<IntrinsicInst>(
LHS);
3698 switch (II->getIntrinsicID()) {
3699 case Intrinsic::uadd_sat:
3701 if (II->getArgOperand(0) ==
RHS || II->getArgOperand(1) ==
RHS) {
3702 if (Pred == ICmpInst::ICMP_UGE)
3704 if (Pred == ICmpInst::ICMP_ULT)
3708 case Intrinsic::usub_sat:
3710 if (II->getArgOperand(0) ==
RHS) {
3711 if (Pred == ICmpInst::ICMP_ULE)
3713 if (Pred == ICmpInst::ICMP_UGT)
3729 if (
const Argument *
A = dyn_cast<Argument>(V))
3730 return A->getRange();
3731 else if (
const CallBase *CB = dyn_cast<CallBase>(V))
3732 return CB->getRange();
3734 return std::nullopt;
3752 assert(!isa<UndefValue>(
LHS) &&
"Unexpected icmp undef,%X");
3757 if (isa<PoisonValue>(
RHS))
3786 if (LhsCr->icmp(Pred, *RhsCr))
3794 if (isa<CastInst>(
LHS) && (isa<Constant>(
RHS) || isa<CastInst>(
RHS))) {
3802 if (MaxRecurse && isa<PtrToIntInst>(LI) &&
3811 if (RI->getOperand(0)->getType() == SrcTy)
3819 if (isa<ZExtInst>(
LHS)) {
3823 if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
3827 RI->getOperand(0), Q, MaxRecurse - 1))
3831 else if (
SExtInst *RI = dyn_cast<SExtInst>(
RHS)) {
3832 if (
SrcOp == RI->getOperand(0)) {
3833 if (Pred == ICmpInst::ICMP_ULE || Pred == ICmpInst::ICMP_SGE)
3835 if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_SLT)
3849 assert(Trunc &&
"Constant-fold of ImmConstant should not fail");
3852 assert(RExt &&
"Constant-fold of ImmConstant should not fail");
3855 assert(AnyEq &&
"Constant-fold of ImmConstant should not fail");
3862 SrcOp, Trunc, Q, MaxRecurse - 1))
3872 case ICmpInst::ICMP_EQ:
3873 case ICmpInst::ICMP_UGT:
3874 case ICmpInst::ICMP_UGE:
3877 case ICmpInst::ICMP_NE:
3878 case ICmpInst::ICMP_ULT:
3879 case ICmpInst::ICMP_ULE:
3884 case ICmpInst::ICMP_SGT:
3885 case ICmpInst::ICMP_SGE:
3889 case ICmpInst::ICMP_SLT:
3890 case ICmpInst::ICMP_SLE:
3899 if (isa<SExtInst>(
LHS)) {
3903 if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
3910 else if (
ZExtInst *RI = dyn_cast<ZExtInst>(
RHS)) {
3911 if (
SrcOp == RI->getOperand(0)) {
3912 if (Pred == ICmpInst::ICMP_UGE || Pred == ICmpInst::ICMP_SLE)
3914 if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_SGT)
3927 assert(Trunc &&
"Constant-fold of ImmConstant should not fail");
3930 assert(RExt &&
"Constant-fold of ImmConstant should not fail");
3933 assert(AnyEq &&
"Constant-fold of ImmConstant should not fail");
3948 case ICmpInst::ICMP_EQ:
3950 case ICmpInst::ICMP_NE:
3955 case ICmpInst::ICMP_SGT:
3956 case ICmpInst::ICMP_SGE:
3959 case ICmpInst::ICMP_SLT:
3960 case ICmpInst::ICMP_SLE:
3966 case ICmpInst::ICMP_UGT:
3967 case ICmpInst::ICMP_UGE:
3975 case ICmpInst::ICMP_ULT:
3976 case ICmpInst::ICMP_ULE:
4007 ICmpInst::getSwappedPredicate(Pred),
RHS,
LHS))
4013 if (std::optional<bool> Res =
4022 if (
auto *CLHS = dyn_cast<PtrToIntOperator>(
LHS))
4023 if (
auto *CRHS = dyn_cast<PtrToIntOperator>(
RHS))
4024 if (CLHS->getPointerOperandType() == CRHS->getPointerOperandType() &&
4028 CRHS->getPointerOperand(), Q))
4033 if (isa<SelectInst>(
LHS) || isa<SelectInst>(
RHS))
4039 if (isa<PHINode>(
LHS) || isa<PHINode>(
RHS))
4055 unsigned MaxRecurse) {
4071 if (Pred == FCmpInst::FCMP_FALSE)
4073 if (Pred == FCmpInst::FCMP_TRUE)
4078 if (isa<PoisonValue>(
LHS) || isa<PoisonValue>(
RHS))
4101 if (Pred == FCmpInst::FCMP_ORD || Pred == FCmpInst::FCMP_UNO) {
4104 return ConstantInt::get(
RetTy, Pred == FCmpInst::FCMP_ORD);
4109 std::optional<KnownFPClass> FullKnownClassLHS;
4113 auto computeLHSClass = [=, &FullKnownClassLHS](
FPClassTest InterestedFlags =
4115 if (FullKnownClassLHS)
4116 return *FullKnownClassLHS;
4129 FullKnownClassLHS = computeLHSClass();
4130 if ((FullKnownClassLHS->KnownFPClasses & ClassTest) ==
fcNone)
4132 if ((FullKnownClassLHS->KnownFPClasses & ~ClassTest) ==
fcNone)
4147 if (
C->isNegative() && !
C->isNegZero()) {
4153 case FCmpInst::FCMP_UGE:
4154 case FCmpInst::FCMP_UGT:
4155 case FCmpInst::FCMP_UNE: {
4163 case FCmpInst::FCMP_OEQ:
4164 case FCmpInst::FCMP_OLE:
4165 case FCmpInst::FCMP_OLT: {
4184 cast<IntrinsicInst>(
LHS)->getIntrinsicID() == Intrinsic::maxnum;
4188 case FCmpInst::FCMP_OEQ:
4189 case FCmpInst::FCMP_UEQ:
4193 case FCmpInst::FCMP_ONE:
4194 case FCmpInst::FCMP_UNE:
4198 case FCmpInst::FCMP_OGE:
4199 case FCmpInst::FCMP_UGE:
4200 case FCmpInst::FCMP_OGT:
4201 case FCmpInst::FCMP_UGT:
4206 return ConstantInt::get(
RetTy, IsMaxNum);
4207 case FCmpInst::FCMP_OLE:
4208 case FCmpInst::FCMP_ULE:
4209 case FCmpInst::FCMP_OLT:
4210 case FCmpInst::FCMP_ULT:
4215 return ConstantInt::get(
RetTy, !IsMaxNum);
4227 case FCmpInst::FCMP_OGE:
4228 case FCmpInst::FCMP_ULT: {
4231 Interested |=
fcNan;
4242 case FCmpInst::FCMP_UGE:
4243 case FCmpInst::FCMP_OLT: {
4260 if (isa<SelectInst>(
LHS) || isa<SelectInst>(
RHS))
4266 if (isa<PHINode>(
LHS) || isa<PHINode>(
RHS))
4280 bool AllowRefinement,
4282 unsigned MaxRecurse) {
4291 if (isa<Constant>(
Op))
4294 auto *
I = dyn_cast<Instruction>(V);
4300 if (isa<PHINode>(
I))
4303 if (
Op->getType()->isVectorTy()) {
4306 if (!
I->getType()->isVectorTy() || isa<ShuffleVectorInst>(
I) ||
4307 isa<CallBase>(
I) || isa<BitCastInst>(
I))
4312 if (
match(
I, m_Intrinsic<Intrinsic::is_constant>()))
4317 bool AnyReplaced =
false;
4318 for (
Value *InstOp :
I->operands()) {
4320 InstOp,
Op, RepOp, Q, AllowRefinement, DropFlags, MaxRecurse)) {
4322 AnyReplaced = InstOp != NewInstOp;
4331 if (!AllowRefinement) {
4336 if (
auto *BO = dyn_cast<BinaryOperator>(
I)) {
4337 unsigned Opcode = BO->getOpcode();
4346 if ((Opcode == Instruction::And || Opcode == Instruction::Or) &&
4347 NewOps[0] == NewOps[1]) {
4349 if (
auto *PDI = dyn_cast<PossiblyDisjointInst>(BO)) {
4350 if (PDI->isDisjoint()) {
4362 if ((Opcode == Instruction::Sub || Opcode == Instruction::Xor) &&
4363 NewOps[0] == RepOp && NewOps[1] == RepOp)
4375 if ((NewOps[0] == Absorber || NewOps[1] == Absorber) &&
4380 if (isa<GetElementPtrInst>(
I)) {
4396 auto PreventSelfSimplify = [V](
Value *Simplified) {
4397 return Simplified != V ? Simplified :
nullptr;
4400 return PreventSelfSimplify(
4407 for (
Value *NewOp : NewOps) {
4408 if (
Constant *ConstOp = dyn_cast<Constant>(NewOp))
4423 if (!AllowRefinement) {
4426 if (
auto *II = dyn_cast<IntrinsicInst>(
I);
4427 II && II->getIntrinsicID() == Intrinsic::abs) {
4428 if (!ConstOps[0]->isNotMinSignedValue())
4434 if (DropFlags && Res &&
I->hasPoisonGeneratingAnnotations())
4444 bool AllowRefinement,
4446 return ::simplifyWithOpReplaced(V,
Op, RepOp, Q, AllowRefinement, DropFlags,
4453 const APInt *
Y,
bool TrueWhenUnset) {
4460 return TrueWhenUnset ? FalseVal : TrueVal;
4466 return TrueWhenUnset ? FalseVal : TrueVal;
4468 if (
Y->isPowerOf2()) {
4474 if (TrueWhenUnset && cast<PossiblyDisjointInst>(TrueVal)->isDisjoint())
4476 return TrueWhenUnset ? TrueVal : FalseVal;
4484 if (!TrueWhenUnset && cast<PossiblyDisjointInst>(FalseVal)->isDisjoint())
4486 return TrueWhenUnset ? TrueVal : FalseVal;
4497 if (CmpRHS == TVal || CmpRHS == FVal) {
4499 Pred = ICmpInst::getSwappedPredicate(Pred);
4503 if (CmpLHS == FVal) {
4505 Pred = ICmpInst::getInversePredicate(Pred);
4510 Value *
X = CmpLHS, *
Y = CmpRHS;
4511 bool PeekedThroughSelectShuffle =
false;
4512 auto *Shuf = dyn_cast<ShuffleVectorInst>(FVal);
4513 if (Shuf && Shuf->isSelect()) {
4514 if (Shuf->getOperand(0) ==
Y)
4515 FVal = Shuf->getOperand(1);
4516 else if (Shuf->getOperand(1) ==
Y)
4517 FVal = Shuf->getOperand(0);
4520 PeekedThroughSelectShuffle =
true;
4524 auto *MMI = dyn_cast<MinMaxIntrinsic>(FVal);
4525 if (!MMI || TVal !=
X ||
4543 if (PeekedThroughSelectShuffle)
4576 Pred == ICmpInst::ICMP_EQ);
4584 unsigned MaxRecurse) {
4587 nullptr, MaxRecurse) == TrueVal)
4591 nullptr, MaxRecurse) == FalseVal)
4602 unsigned MaxRecurse) {
4604 Value *CmpLHS, *CmpRHS;
4612 if (Pred == ICmpInst::ICMP_NE) {
4613 Pred = ICmpInst::ICMP_EQ;
4620 if (TrueVal->getType()->isIntOrIntVectorTy()) {
4628 X->getType()->getScalarSizeInBits());
4634 if (Pred == ICmpInst::ICMP_EQ &&
match(CmpRHS,
m_Zero())) {
4648 if (
match(TrueVal, isFsh) && FalseVal ==
X && CmpLHS == ShAmt)
4661 if (
match(FalseVal, isRotate) && TrueVal ==
X && CmpLHS == ShAmt &&
4662 Pred == ICmpInst::ICMP_EQ)
4667 if (
match(TrueVal, m_Intrinsic<Intrinsic::abs>(
m_Specific(CmpLHS))) &&
4684 if (Pred == ICmpInst::ICMP_EQ) {
4734 bool HasNoSignedZeros =
4741 if (Pred == FCmpInst::FCMP_OEQ)
4746 if (Pred == FCmpInst::FCMP_UNE)
4757 if (
auto *CondC = dyn_cast<Constant>(
Cond)) {
4758 if (
auto *TrueC = dyn_cast<Constant>(TrueVal))
4759 if (
auto *FalseC = dyn_cast<Constant>(FalseVal))
4764 if (isa<PoisonValue>(CondC))
4769 return isa<Constant>(FalseVal) ? FalseVal : TrueVal;
4781 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
4782 "Select must have bool or bool vector condition");
4783 assert(TrueVal->getType() == FalseVal->getType() &&
4784 "Select must have same types for true/false ops");
4786 if (
Cond->getType() == TrueVal->getType()) {
4849 if (TrueVal == FalseVal)
4852 if (
Cond == TrueVal) {
4860 if (
Cond == FalseVal) {
4874 if (isa<PoisonValue>(TrueVal) ||
4879 if (isa<PoisonValue>(FalseVal) ||
4885 if (isa<FixedVectorType>(TrueVal->getType()) &&
4889 cast<FixedVectorType>(TrueC->
getType())->getNumElements();
4891 for (
unsigned i = 0; i != NumElts; ++i) {
4895 if (!TEltC || !FEltC)
4902 else if (isa<PoisonValue>(TEltC) ||
4905 else if (isa<PoisonValue>(FEltC) ||
4911 if (NewC.
size() == NumElts)
4927 return *Imp ? TrueVal : FalseVal;
4944 cast<PointerType>(
Ptr->getType()->getScalarType())->getAddressSpace();
4947 if (Indices.
empty())
4957 if (
VectorType *VT = dyn_cast<VectorType>(
Op->getType())) {
4958 GEPTy = VectorType::get(GEPTy, VT->getElementCount());
4965 if (
Ptr->getType() == GEPTy &&
4971 if (isa<PoisonValue>(
Ptr) ||
4972 any_of(Indices, [](
const auto *V) {
return isa<PoisonValue>(V); }))
4979 bool IsScalableVec =
4981 return isa<ScalableVectorType>(V->getType());
4984 if (Indices.
size() == 1) {
4986 if (!IsScalableVec && Ty->
isSized()) {
4991 if (TyAllocSize == 0 &&
Ptr->getType() == GEPTy)
4996 if (Indices[0]->
getType()->getScalarSizeInBits() ==
4998 auto CanSimplify = [GEPTy, &
P,
Ptr]() ->
bool {
4999 return P->getType() == GEPTy &&
5003 if (TyAllocSize == 1 &&
5014 TyAllocSize == 1ULL <<
C && CanSimplify())
5030 [](
Value *
Idx) { return match(Idx, m_Zero()); })) {
5034 APInt BasePtrOffset(IdxWidth, 0);
5035 Value *StrippedBasePtr =
5036 Ptr->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, BasePtrOffset);
5045 !BasePtrOffset.
isZero()) {
5046 auto *CI = ConstantInt::get(GEPTy->
getContext(), BasePtrOffset);
5052 !BasePtrOffset.
isOne()) {
5053 auto *CI = ConstantInt::get(GEPTy->
getContext(), BasePtrOffset - 1);
5060 if (!isa<Constant>(
Ptr) ||
5061 !
all_of(Indices, [](
Value *V) {
return isa<Constant>(V); }))
5066 std::nullopt, Indices);
5083 if (
Constant *CAgg = dyn_cast<Constant>(Agg))
5084 if (
Constant *CVal = dyn_cast<Constant>(Val))
5089 if (isa<PoisonValue>(Val) ||
5095 if (EV->getAggregateOperand()->getType() == Agg->
getType() &&
5096 EV->getIndices() == Idxs) {
5099 if (isa<PoisonValue>(Agg) ||
5102 return EV->getAggregateOperand();
5105 if (Agg == EV->getAggregateOperand())
5115 return ::simplifyInsertValueInst(Agg, Val, Idxs, Q,
RecursionLimit);
5121 auto *VecC = dyn_cast<Constant>(Vec);
5122 auto *ValC = dyn_cast<Constant>(Val);
5123 auto *IdxC = dyn_cast<Constant>(
Idx);
5124 if (VecC && ValC && IdxC)
5128 if (
auto *CI = dyn_cast<ConstantInt>(
Idx)) {
5129 if (isa<FixedVectorType>(Vec->
getType()) &&
5130 CI->uge(cast<FixedVectorType>(Vec->
getType())->getNumElements()))
5140 if (isa<PoisonValue>(Val) ||
5157 if (
auto *CAgg = dyn_cast<Constant>(Agg))
5161 unsigned NumIdxs = Idxs.
size();
5162 for (
auto *IVI = dyn_cast<InsertValueInst>(Agg); IVI !=
nullptr;
5163 IVI = dyn_cast<InsertValueInst>(IVI->getAggregateOperand())) {
5165 unsigned NumInsertValueIdxs = InsertValueIdxs.
size();
5166 unsigned NumCommonIdxs = std::min(NumInsertValueIdxs, NumIdxs);
5167 if (InsertValueIdxs.
slice(0, NumCommonIdxs) ==
5168 Idxs.
slice(0, NumCommonIdxs)) {
5169 if (NumIdxs == NumInsertValueIdxs)
5170 return IVI->getInsertedValueOperand();
5187 auto *VecVTy = cast<VectorType>(Vec->
getType());
5188 if (
auto *CVec = dyn_cast<Constant>(Vec)) {
5189 if (
auto *CIdx = dyn_cast<Constant>(
Idx))
5203 if (
auto *IdxC = dyn_cast<ConstantInt>(
Idx)) {
5205 unsigned MinNumElts = VecVTy->getElementCount().getKnownMinValue();
5206 if (isa<FixedVectorType>(VecVTy) && IdxC->getValue().uge(MinNumElts))
5209 if (IdxC->getValue().ult(MinNumElts))
5219 auto *IE = dyn_cast<InsertElementInst>(Vec);
5220 if (IE && IE->getOperand(2) ==
Idx)
5221 return IE->getOperand(1);
5244 Value *CommonValue =
nullptr;
5245 bool HasUndefInput =
false;
5252 HasUndefInput =
true;
5255 if (CommonValue &&
Incoming != CommonValue)
5265 if (HasUndefInput) {
5277 if (
auto *
C = dyn_cast<Constant>(
Op))
5280 if (
auto *CI = dyn_cast<CastInst>(
Op)) {
5281 auto *Src = CI->getOperand(0);
5282 Type *SrcTy = Src->getType();
5283 Type *MidTy = CI->getType();
5285 if (Src->getType() == Ty) {
5295 SrcIntPtrTy, MidIntPtrTy,
5296 DstIntPtrTy) == Instruction::BitCast)
5302 if (CastOpc == Instruction::BitCast)
5303 if (
Op->getType() == Ty)
5318 int MaskVal,
Value *RootVec,
5319 unsigned MaxRecurse) {
5329 int InVecNumElts = cast<FixedVectorType>(Op0->
getType())->getNumElements();
5330 int RootElt = MaskVal;
5331 Value *SourceOp = Op0;
5332 if (MaskVal >= InVecNumElts) {
5333 RootElt = MaskVal - InVecNumElts;
5339 if (
auto *SourceShuf = dyn_cast<ShuffleVectorInst>(SourceOp)) {
5341 DestElt, SourceShuf->getOperand(0), SourceShuf->getOperand(1),
5342 SourceShuf->getMaskValue(RootElt), RootVec, MaxRecurse);
5354 if (RootVec != SourceOp)
5359 if (RootElt != DestElt)
5368 unsigned MaxRecurse) {
5372 auto *InVecTy = cast<VectorType>(Op0->
getType());
5373 unsigned MaskNumElts = Mask.size();
5374 ElementCount InVecEltCount = InVecTy->getElementCount();
5379 Indices.
assign(Mask.begin(), Mask.end());
5384 bool MaskSelects0 =
false, MaskSelects1 =
false;
5386 for (
unsigned i = 0; i != MaskNumElts; ++i) {
5387 if (Indices[i] == -1)
5389 if ((
unsigned)Indices[i] < InVecNumElts)
5390 MaskSelects0 =
true;
5392 MaskSelects1 =
true;
5400 auto *Op0Const = dyn_cast<Constant>(Op0);
5401 auto *Op1Const = dyn_cast<Constant>(Op1);
5406 if (Op0Const && Op1Const)
5412 if (!Scalable && Op0Const && !Op1Const) {
5430 if (
all_of(Indices, [InsertIndex](
int MaskElt) {
5431 return MaskElt == InsertIndex || MaskElt == -1;
5433 assert(isa<UndefValue>(Op1) &&
"Expected undef operand 1 for splat");
5437 for (
unsigned i = 0; i != MaskNumElts; ++i)
5438 if (Indices[i] == -1)
5446 if (
auto *OpShuf = dyn_cast<ShuffleVectorInst>(Op0))
5466 Value *RootVec =
nullptr;
5467 for (
unsigned i = 0; i != MaskNumElts; ++i) {
5489 if (
auto *
C = dyn_cast<Constant>(
Op))
5517 Type *Ty = In->getType();
5518 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
5519 unsigned NumElts = VecTy->getNumElements();
5521 for (
unsigned i = 0; i != NumElts; ++i) {
5522 Constant *EltC = In->getAggregateElement(i);
5525 if (EltC && isa<PoisonValue>(EltC))
5527 else if (EltC && EltC->
isNaN())
5528 NewC[i] = ConstantFP::get(
5529 EltC->
getType(), cast<ConstantFP>(EltC)->getValue().makeQuiet());
5543 if (isa<ScalableVectorType>(Ty)) {
5544 auto *
Splat = In->getSplatValue();
5546 "Found a scalable-vector NaN but not a splat");
5552 return ConstantFP::get(Ty, cast<ConstantFP>(In)->getValue().makeQuiet());
5567 for (
Value *V : Ops) {
5575 if (FMF.
noNaNs() && (IsNan || IsUndef))
5577 if (FMF.
noInfs() && (IsInf || IsUndef))
5603 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5669 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5784 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5790 return simplifyFMAFMul(Op0, Op1, FMF, Q, MaxRecurse, ExBehavior, Rounding);
5797 return ::simplifyFAddInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5805 return ::simplifyFSubInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5813 return ::simplifyFMulInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5821 return ::simplifyFMAFMul(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5829 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5854 return ConstantFP::get(Op0->
getType(), 1.0);
5866 return ConstantFP::get(Op0->
getType(), -1.0);
5880 return ::simplifyFDivInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5888 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5918 return ::simplifyFRemInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5927 unsigned MaxRecurse) {
5929 case Instruction::FNeg:
5941 unsigned MaxRecurse) {
5943 case Instruction::FNeg:
5964 case Instruction::Add:
5967 case Instruction::Sub:
5970 case Instruction::Mul:
5973 case Instruction::SDiv:
5975 case Instruction::UDiv:
5977 case Instruction::SRem:
5979 case Instruction::URem:
5981 case Instruction::Shl:
5984 case Instruction::LShr:
5986 case Instruction::AShr:
5988 case Instruction::And:
5990 case Instruction::Or:
5992 case Instruction::Xor:
5994 case Instruction::FAdd:
5996 case Instruction::FSub:
5998 case Instruction::FMul:
6000 case Instruction::FDiv:
6002 case Instruction::FRem:
6014 unsigned MaxRecurse) {
6016 case Instruction::FAdd:
6018 case Instruction::FSub:
6020 case Instruction::FMul:
6022 case Instruction::FDiv:
6058 case Intrinsic::fabs:
6059 case Intrinsic::floor:
6060 case Intrinsic::ceil:
6061 case Intrinsic::trunc:
6062 case Intrinsic::rint:
6063 case Intrinsic::nearbyint:
6064 case Intrinsic::round:
6065 case Intrinsic::roundeven:
6066 case Intrinsic::canonicalize:
6067 case Intrinsic::arithmetic_fence:
6079 case Intrinsic::floor:
6080 case Intrinsic::ceil:
6081 case Intrinsic::trunc:
6082 case Intrinsic::rint:
6083 case Intrinsic::nearbyint:
6084 case Intrinsic::round:
6085 case Intrinsic::roundeven:
6099 auto *OffsetConstInt = dyn_cast<ConstantInt>(
Offset);
6100 if (!OffsetConstInt || OffsetConstInt->getBitWidth() > 64)
6104 DL.getIndexTypeSizeInBits(
Ptr->getType()));
6105 if (OffsetInt.
srem(4) != 0)
6113 auto *LoadedCE = dyn_cast<ConstantExpr>(Loaded);
6117 if (LoadedCE->getOpcode() == Instruction::Trunc) {
6118 LoadedCE = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0));
6123 if (LoadedCE->getOpcode() != Instruction::Sub)
6126 auto *LoadedLHS = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0));
6127 if (!LoadedLHS || LoadedLHS->getOpcode() != Instruction::PtrToInt)
6129 auto *LoadedLHSPtr = LoadedLHS->getOperand(0);
6133 APInt LoadedRHSOffset;
6136 PtrSym != LoadedRHSSym || PtrOffset != LoadedRHSOffset)
6139 return LoadedLHSPtr;
6147 if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
6170 if (
C && (
C->isZero() ||
C->isInfinity()))
6179 if (
C &&
C->isNaN())
6180 return ConstantFP::get(Op0->
getType(),
C->makeQuiet());
6198 if (
auto *II = dyn_cast<IntrinsicInst>(Op0))
6199 if (II->getIntrinsicID() == IID)
6208 auto *II = dyn_cast<IntrinsicInst>(Op0);
6216 case Intrinsic::fabs:
6220 case Intrinsic::bswap:
6225 case Intrinsic::bitreverse:
6230 case Intrinsic::ctpop: {
6234 return ConstantInt::get(Op0->
getType(), 1);
6243 case Intrinsic::exp:
6245 if (Call->hasAllowReassoc() &&
6249 case Intrinsic::exp2:
6251 if (Call->hasAllowReassoc() &&
6255 case Intrinsic::exp10:
6257 if (Call->hasAllowReassoc() &&
6261 case Intrinsic::log:
6263 if (Call->hasAllowReassoc() &&
6267 case Intrinsic::log2:
6269 if (Call->hasAllowReassoc() &&
6275 case Intrinsic::log10:
6278 if (Call->hasAllowReassoc() &&
6284 case Intrinsic::experimental_vector_reverse:
6292 case Intrinsic::frexp: {
6316 auto *MM0 = dyn_cast<IntrinsicInst>(Op0);
6321 if (Op1 ==
X || Op1 ==
Y ||
6338 assert((IID == Intrinsic::maxnum || IID == Intrinsic::minnum ||
6339 IID == Intrinsic::maximum || IID == Intrinsic::minimum) &&
6340 "Unsupported intrinsic");
6342 auto *
M0 = dyn_cast<IntrinsicInst>(Op0);
6346 if (!
M0 ||
M0->getIntrinsicID() != IID)
6348 Value *X0 =
M0->getOperand(0);
6349 Value *Y0 =
M0->getOperand(1);
6356 if (X0 == Op1 || Y0 == Op1)
6359 auto *
M1 = dyn_cast<IntrinsicInst>(Op1);
6362 Value *X1 =
M1->getOperand(0);
6363 Value *Y1 =
M1->getOperand(1);
6371 if ((X0 == X1 && Y0 == Y1) || (X0 == Y1 && Y0 == X1))
6382 unsigned BitWidth = ReturnType->getScalarSizeInBits();
6384 case Intrinsic::abs:
6392 case Intrinsic::cttz: {
6398 case Intrinsic::ctlz: {
6406 case Intrinsic::ptrmask: {
6407 if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
6417 "Invalid mask width");
6434 APInt IrrelevantPtrBits =
6437 Instruction::Or,
C, ConstantInt::get(
C->getType(), IrrelevantPtrBits),
6439 if (
C !=
nullptr &&
C->isAllOnesValue())
6444 case Intrinsic::smax:
6445 case Intrinsic::smin:
6446 case Intrinsic::umax:
6447 case Intrinsic::umin: {
6458 return ConstantInt::get(
6466 return ConstantInt::get(ReturnType, *
C);
6477 auto *MinMax0 = dyn_cast<IntrinsicInst>(Op0);
6478 if (MinMax0 && MinMax0->getIntrinsicID() == IID) {
6480 Value *M00 = MinMax0->getOperand(0), *M01 = MinMax0->getOperand(1);
6481 const APInt *InnerC;
6484 ICmpInst::getNonStrictPredicate(
6504 case Intrinsic::usub_with_overflow:
6505 case Intrinsic::ssub_with_overflow:
6512 case Intrinsic::uadd_with_overflow:
6513 case Intrinsic::sadd_with_overflow:
6518 cast<StructType>(ReturnType),
6523 case Intrinsic::umul_with_overflow:
6524 case Intrinsic::smul_with_overflow:
6534 case Intrinsic::uadd_sat:
6540 case Intrinsic::sadd_sat:
6555 case Intrinsic::usub_sat:
6560 case Intrinsic::ssub_sat:
6568 case Intrinsic::load_relative:
6569 if (
auto *C0 = dyn_cast<Constant>(Op0))
6570 if (
auto *C1 = dyn_cast<Constant>(Op1))
6573 case Intrinsic::powi:
6574 if (
auto *Power = dyn_cast<ConstantInt>(Op1)) {
6576 if (Power->isZero())
6577 return ConstantFP::get(Op0->
getType(), 1.0);
6583 case Intrinsic::ldexp:
6585 case Intrinsic::copysign:
6595 case Intrinsic::is_fpclass: {
6596 if (isa<PoisonValue>(Op0))
6599 uint64_t Mask = cast<ConstantInt>(Op1)->getZExtValue();
6602 return ConstantInt::get(ReturnType,
true);
6604 return ConstantInt::get(ReturnType,
false);
6609 case Intrinsic::maxnum:
6610 case Intrinsic::minnum:
6611 case Intrinsic::maximum:
6612 case Intrinsic::minimum: {
6618 if (isa<Constant>(Op0))
6625 bool PropagateNaN = IID == Intrinsic::minimum || IID == Intrinsic::maximum;
6626 bool IsMin = IID == Intrinsic::minimum || IID == Intrinsic::minnum;
6633 return PropagateNaN ?
propagateNaN(cast<Constant>(Op1)) : Op0;
6639 (
C->isInfinity() || (Call && Call->hasNoInfs() &&
C->isLargest()))) {
6644 if (
C->isNegative() == IsMin &&
6645 (!PropagateNaN || (Call && Call->hasNoNaNs())))
6646 return ConstantFP::get(ReturnType, *
C);
6652 if (
C->isNegative() != IsMin &&
6653 (PropagateNaN || (Call && Call->hasNoNaNs())))
6666 case Intrinsic::vector_extract: {
6668 unsigned IdxN = cast<ConstantInt>(Op1)->getZExtValue();
6672 IdxN == 0 &&
X->getType() == ReturnType)
6688 assert(Call->arg_size() == Args.size());
6689 unsigned NumOperands = Args.size();
6697 case Intrinsic::vscale: {
6701 return ConstantInt::get(
RetTy,
C->getZExtValue());
6709 if (NumOperands == 1)
6712 if (NumOperands == 2)
6718 case Intrinsic::masked_load:
6719 case Intrinsic::masked_gather: {
6720 Value *MaskArg = Args[2];
6721 Value *PassthruArg = Args[3];
6727 case Intrinsic::fshl:
6728 case Intrinsic::fshr: {
6729 Value *Op0 = Args[0], *Op1 = Args[1], *ShAmtArg = Args[2];
6737 return Args[IID == Intrinsic::fshl ? 0 : 1];
6739 const APInt *ShAmtC;
6744 return Args[IID == Intrinsic::fshl ? 0 : 1];
6749 return ConstantInt::getNullValue(
F->getReturnType());
6753 return ConstantInt::getAllOnesValue(
F->getReturnType());
6757 case Intrinsic::experimental_constrained_fma: {
6758 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6760 *FPI->getRoundingMode()))
6764 case Intrinsic::fma:
6765 case Intrinsic::fmuladd: {
6767 RoundingMode::NearestTiesToEven))
6771 case Intrinsic::smul_fix:
6772 case Intrinsic::smul_fix_sat: {
6773 Value *Op0 = Args[0];
6774 Value *Op1 = Args[1];
6775 Value *Op2 = Args[2];
6776 Type *ReturnType =
F->getReturnType();
6781 if (isa<Constant>(Op0))
6795 cast<ConstantInt>(Op2)->getZExtValue());
6801 case Intrinsic::vector_insert: {
6802 Value *Vec = Args[0];
6803 Value *SubVec = Args[1];
6805 Type *ReturnType =
F->getReturnType();
6809 unsigned IdxN = cast<ConstantInt>(
Idx)->getZExtValue();
6814 X->getType() == ReturnType)
6819 case Intrinsic::experimental_constrained_fadd: {
6820 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6822 *FPI->getExceptionBehavior(),
6823 *FPI->getRoundingMode());
6825 case Intrinsic::experimental_constrained_fsub: {
6826 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6828 *FPI->getExceptionBehavior(),
6829 *FPI->getRoundingMode());
6831 case Intrinsic::experimental_constrained_fmul: {
6832 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6834 *FPI->getExceptionBehavior(),
6835 *FPI->getRoundingMode());
6837 case Intrinsic::experimental_constrained_fdiv: {
6838 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6840 *FPI->getExceptionBehavior(),
6841 *FPI->getRoundingMode());
6843 case Intrinsic::experimental_constrained_frem: {
6844 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6846 *FPI->getExceptionBehavior(),
6847 *FPI->getRoundingMode());
6849 case Intrinsic::experimental_constrained_ldexp:
6851 case Intrinsic::experimental_gc_relocate: {
6857 if (isa<UndefValue>(DerivedPtr) || isa<UndefValue>(BasePtr)) {
6861 if (
auto *PT = dyn_cast<PointerType>(GCR.
getType())) {
6865 if (isa<ConstantPointerNull>(DerivedPtr)) {
6880 auto *
F = dyn_cast<Function>(Callee);
6885 ConstantArgs.
reserve(Args.size());
6886 for (
Value *Arg : Args) {
6889 if (isa<MetadataAsValue>(Arg))
6902 assert(Call->arg_size() == Args.size());
6906 if (Call->isMustTailCall())
6911 if (isa<UndefValue>(Callee) || isa<ConstantPointerNull>(Callee))
6917 auto *
F = dyn_cast<Function>(Callee);
6918 if (
F &&
F->isIntrinsic())
6926 assert(isa<ConstrainedFPIntrinsic>(Call));
6945 return ::simplifyFreezeInst(Op0, Q);
6953 if (
auto *PtrOpC = dyn_cast<Constant>(PtrOp))
6959 if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
6990 unsigned MaxRecurse) {
6991 assert(
I->getFunction() &&
"instruction should be inserted in a function");
6993 "context instruction should be in the same function");
6997 switch (
I->getOpcode()) {
7002 [](
Value *V) { return cast<Constant>(V); });
7006 case Instruction::FNeg:
7008 case Instruction::FAdd:
7011 case Instruction::Add:
7015 case Instruction::FSub:
7018 case Instruction::Sub:
7022 case Instruction::FMul:
7025 case Instruction::Mul:
7029 case Instruction::SDiv:
7033 case Instruction::UDiv:
7037 case Instruction::FDiv:
7040 case Instruction::SRem:
7042 case Instruction::URem:
7044 case Instruction::FRem:
7047 case Instruction::Shl:
7051 case Instruction::LShr:
7055 case Instruction::AShr:
7059 case Instruction::And:
7061 case Instruction::Or:
7063 case Instruction::Xor:
7065 case Instruction::ICmp:
7067 NewOps[1], Q, MaxRecurse);
7068 case Instruction::FCmp:
7070 NewOps[1],
I->getFastMathFlags(), Q, MaxRecurse);
7071 case Instruction::Select:
7074 case Instruction::GetElementPtr: {
7075 auto *GEPI = cast<GetElementPtrInst>(
I);
7077 ArrayRef(NewOps).slice(1), GEPI->isInBounds(), Q,
7080 case Instruction::InsertValue: {
7085 case Instruction::InsertElement:
7087 case Instruction::ExtractValue: {
7088 auto *EVI = cast<ExtractValueInst>(
I);
7092 case Instruction::ExtractElement:
7094 case Instruction::ShuffleVector: {
7095 auto *SVI = cast<ShuffleVectorInst>(
I);
7097 SVI->getShuffleMask(), SVI->getType(), Q,
7100 case Instruction::PHI:
7102 case Instruction::Call:
7104 cast<CallInst>(
I), NewOps.
back(),
7105 NewOps.
drop_back(1 + cast<CallInst>(
I)->getNumTotalBundleOperands()), Q);
7106 case Instruction::Freeze:
7108#define HANDLE_CAST_INST(num, opc, clas) case Instruction::opc:
7109#include "llvm/IR/Instruction.def"
7110#undef HANDLE_CAST_INST
7113 case Instruction::Alloca:
7116 case Instruction::Load:
7125 "Number of operands should match the instruction!");
7126 return ::simplifyInstructionWithOperands(
I, NewOps, SQ,
RecursionLimit);
7156 bool Simplified =
false;
7163 for (
User *U :
I->users())
7165 Worklist.
insert(cast<Instruction>(U));
7168 I->replaceAllUsesWith(SimpleV);
7170 if (!
I->isEHPad() && !
I->isTerminator() && !
I->mayHaveSideEffects())
7171 I->eraseFromParent();
7183 if (UnsimplifiedUsers)
7184 UnsimplifiedUsers->insert(
I);
7193 for (
User *U :
I->users())
7194 Worklist.
insert(cast<Instruction>(U));
7197 I->replaceAllUsesWith(SimpleV);
7199 if (!
I->isEHPad() && !
I->isTerminator() && !
I->mayHaveSideEffects())
7200 I->eraseFromParent();
7209 assert(
I != SimpleV &&
"replaceAndRecursivelySimplify(X,X) is not valid!");
7210 assert(SimpleV &&
"Must provide a simplified value.");
7218 auto *DT = DTWP ? &DTWP->
getDomTree() :
nullptr;
7220 auto *TLI = TLIWP ? &TLIWP->
getTLI(
F) :
nullptr;
7223 return {
F.getParent()->getDataLayout(), TLI, DT, AC};
7231template <
class T,
class... TArgs>
7234 auto *DT = AM.template getCachedResult<DominatorTreeAnalysis>(
F);
7235 auto *TLI = AM.template getCachedResult<TargetLibraryAnalysis>(
F);
7236 auto *AC = AM.template getCachedResult<AssumptionAnalysis>(
F);
7237 return {
F.getParent()->getDataLayout(), TLI, DT, AC};
7251void InstSimplifyFolder::anchor() {}
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")
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")
static Value * simplifyFreezeInst(Value *Op0, const SimplifyQuery &Q)
Given operands for a Freeze, see if we can fold the result.
static Value * simplifyLShrInst(Value *Op0, Value *Op1, bool IsExact, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an LShr, see if we can fold the result.
static Value * simplifyUDivInst(Value *Op0, Value *Op1, bool IsExact, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for a UDiv, see if we can fold the result.
static Value * simplifyShuffleVectorInst(Value *Op0, Value *Op1, ArrayRef< int > Mask, Type *RetTy, const SimplifyQuery &Q, unsigned MaxRecurse)
static Value * foldMinMaxSharedOp(Intrinsic::ID IID, Value *Op0, Value *Op1)
Given a min/max intrinsic, see if it can be removed based on having an operand that is another min/ma...
static Value * simplifyGEPInst(Type *, Value *, ArrayRef< Value * >, bool, const SimplifyQuery &, unsigned)
Given operands for an GetElementPtrInst, see if we can fold the result.
static Value * simplifySubInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for a Sub, see if we can fold the result.
static Value * simplifyICmpWithIntrinsicOnLHS(CmpInst::Predicate Pred, Value *LHS, Value *RHS)
static Value * expandCommutativeBinOp(Instruction::BinaryOps Opcode, Value *L, Value *R, Instruction::BinaryOps OpcodeToExpand, const SimplifyQuery &Q, unsigned MaxRecurse)
Try to simplify binops of form "A op (B op' C)" or the commuted variant by distributing op over op'.
static Constant * foldOrCommuteConstant(Instruction::BinaryOps Opcode, Value *&Op0, Value *&Op1, const SimplifyQuery &Q)
static bool haveNonOverlappingStorage(const Value *V1, const Value *V2)
Return true if V1 and V2 are each the base of some distict storage region [V, object_size(V)] which d...
static Constant * foldConstant(Instruction::UnaryOps Opcode, Value *&Op, const SimplifyQuery &Q)
static Value * handleOtherCmpSelSimplifications(Value *TCmp, Value *FCmp, Value *Cond, const SimplifyQuery &Q, unsigned MaxRecurse)
We know comparison with both branches of select can be simplified, but they are not equal.
static Constant * propagateNaN(Constant *In)
Try to propagate existing NaN values when possible.
static Value * simplifyAShrInst(Value *Op0, Value *Op1, bool IsExact, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an AShr, see if we can fold the result.
static Value * simplifyRelativeLoad(Constant *Ptr, Constant *Offset, const DataLayout &DL)
static Value * simplifyICmpWithDominatingAssume(CmpInst::Predicate Predicate, Value *LHS, Value *RHS, const SimplifyQuery &Q)
static Value * simplifyCmpSelTrueCase(CmpInst::Predicate Pred, Value *LHS, Value *RHS, Value *Cond, const SimplifyQuery &Q, unsigned MaxRecurse)
Simplify comparison with true branch of select.
static Value * simplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, bool IsExact, const SimplifyQuery &Q, unsigned MaxRecurse)
These are simplifications common to SDiv and UDiv.
static Value * simplifyCmpSelOfMaxMin(Value *CmpLHS, Value *CmpRHS, ICmpInst::Predicate Pred, Value *TVal, Value *FVal)
static Value * simplifyPHINode(PHINode *PN, ArrayRef< Value * > IncomingValues, const SimplifyQuery &Q)
See if we can fold the given phi. If not, returns null.
static Value * simplifyICmpWithMinMax(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
simplify integer comparisons where at least one operand of the compare matches an integer min/max idi...
static Value * simplifySelectWithFakeICmpEq(Value *CmpLHS, Value *CmpRHS, ICmpInst::Predicate Pred, Value *TrueVal, Value *FalseVal)
An alternative way to test if a bit is set or not uses sgt/slt instead of eq/ne.
static Value * simplifyCmpInst(unsigned, Value *, Value *, const SimplifyQuery &, unsigned)
Given operands for a CmpInst, see if we can fold the result.
static Value * simplifyExtractValueInst(Value *Agg, ArrayRef< unsigned > Idxs, const SimplifyQuery &, unsigned)
Given operands for an ExtractValueInst, see if we can fold the result.
static Value * simplifySelectInst(Value *, Value *, Value *, const SimplifyQuery &, unsigned)
Given operands for a SelectInst, see if we can fold the result.
static Value * simplifyAddInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an Add, see if we can fold the result.
static Value * threadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
In the case of a comparison with a select instruction, try to simplify the comparison by seeing wheth...
static Value * simplifyUnOp(unsigned, Value *, const SimplifyQuery &, unsigned)
Given the operand for a UnaryOperator, see if we can fold the result.
static Value * simplifyICmpWithBinOpOnLHS(CmpInst::Predicate Pred, BinaryOperator *LBO, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
static Value * simplifyAndCommutative(Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
static Value * simplifyInstructionWithOperands(Instruction *I, ArrayRef< Value * > NewOps, const SimplifyQuery &SQ, unsigned MaxRecurse)
See if we can compute a simplified version of this instruction.
static bool isIdempotent(Intrinsic::ID ID)
static std::optional< ConstantRange > getRange(Value *V, const InstrInfoQuery &IIQ)
Helper method to get range from metadata or attribute.
static Value * simplifyAndOrOfICmpsWithCtpop(ICmpInst *Cmp0, ICmpInst *Cmp1, bool IsAnd)
Try to simplify and/or of icmp with ctpop intrinsic.
static Value * simplifyUnsignedRangeCheck(ICmpInst *ZeroICmp, ICmpInst *UnsignedICmp, bool IsAnd, const SimplifyQuery &Q)
Commuted variants are assumed to be handled by calling this function again with the parameters swappe...
static Value * tryConstantFoldCall(CallBase *Call, Value *Callee, ArrayRef< Value * > Args, const SimplifyQuery &Q)
static Value * simplifyExtractElementInst(Value *Vec, Value *Idx, const SimplifyQuery &Q, unsigned)
Given operands for an ExtractElementInst, see if we can fold the result.
static Value * simplifyAndOfICmpsWithAdd(ICmpInst *Op0, ICmpInst *Op1, const InstrInfoQuery &IIQ)
static Value * threadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
In the case of a comparison with a PHI instruction, try to simplify the comparison by seeing whether ...
static Value * simplifyIntrinsic(CallBase *Call, Value *Callee, ArrayRef< Value * > Args, const SimplifyQuery &Q)
static bool isPoisonShift(Value *Amount, const SimplifyQuery &Q)
Returns true if a shift by Amount always yields poison.
static APInt stripAndComputeConstantOffsets(const DataLayout &DL, Value *&V, bool AllowNonInbounds=false)
Compute the base pointer and cumulative constant offsets for V.
static Value * simplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse, fp::ExceptionBehavior ExBehavior, RoundingMode Rounding)
static Value * simplifyRightShift(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, bool IsExact, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an LShr or AShr, see if we can fold the result.
static Value * simplifyICmpWithConstant(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const InstrInfoQuery &IIQ)
static Value * simplifySDivInst(Value *Op0, Value *Op1, bool IsExact, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an SDiv, see if we can fold the result.
static Value * simplifyByDomEq(unsigned Opcode, Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
Test if there is a dominating equivalence condition for the two operands.
static Value * simplifyFPUnOp(unsigned, Value *, const FastMathFlags &, const SimplifyQuery &, unsigned)
Given the operand for a UnaryOperator, see if we can fold the result.
static bool isICmpTrue(ICmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
Given a predicate and two operands, return true if the comparison is true.
static Value * simplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FAdd, see if we can fold the result.
static Value * simplifyOrOfICmps(ICmpInst *Op0, ICmpInst *Op1, const SimplifyQuery &Q)
static Value * expandBinOp(Instruction::BinaryOps Opcode, Value *V, Value *OtherOp, Instruction::BinaryOps OpcodeToExpand, const SimplifyQuery &Q, unsigned MaxRecurse)
Try to simplify a binary operator of form "V op OtherOp" where V is "(B0 opex B1)" by distributing 'o...
static Constant * getFalse(Type *Ty)
For a boolean type or a vector of boolean type, return false or a vector with every element false.
static Value * simplifyDivRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
Check for common or similar folds of integer division or integer remainder.
static bool removesFPFraction(Intrinsic::ID ID)
Return true if the intrinsic rounds a floating-point value to an integral floating-point value (not a...
static Value * simplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
static Value * simplifyOrOfICmpsWithAdd(ICmpInst *Op0, ICmpInst *Op1, const InstrInfoQuery &IIQ)
static Value * simplifyMulInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for a Mul, see if we can fold the result.
static Value * simplifyFNegInst(Value *Op, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse)
Given the operand for an FNeg, see if we can fold the result.
static Value * simplifyOrInst(Value *, Value *, const SimplifyQuery &, unsigned)
Given operands for an Or, see if we can fold the result.
static Value * simplifySelectBitTest(Value *TrueVal, Value *FalseVal, Value *X, const APInt *Y, bool TrueWhenUnset)
Try to simplify a select instruction when its condition operand is an integer comparison where one op...
static Value * simplifyAssociativeBinOp(Instruction::BinaryOps Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
Generic simplifications for associative binary operations.
static Value * simplifyICmpWithZero(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Try hard to fold icmp with zero RHS because this is a common case.
static Value * foldSelectWithBinaryOp(Value *Cond, Value *TrueVal, Value *FalseVal)
static Value * simplifyShlInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an Shl, see if we can fold the result.
static Value * threadBinOpOverPHI(Instruction::BinaryOps Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
In the case of a binary operation with an operand that is a PHI instruction, try to simplify the bino...
static Value * simplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
static Value * simplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FSub, see if we can fold the result.
static bool trySimplifyICmpWithAdds(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const InstrInfoQuery &IIQ)
static Value * simplifyXorInst(Value *, Value *, const SimplifyQuery &, unsigned)
Given operands for a Xor, see if we can fold the result.
static Value * simplifyURemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for a URem, see if we can fold the result.
static Value * simplifySelectWithFCmp(Value *Cond, Value *T, Value *F, const SimplifyQuery &Q)
Try to simplify a select instruction when its condition operand is a floating-point comparison.
static Constant * simplifyFPOp(ArrayRef< Value * > Ops, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior, RoundingMode Rounding)
Perform folds that are common to any floating-point operation.
static bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI, const DominatorTree *DT, AssumptionCache *AC, SmallSetVector< Instruction *, 8 > *UnsimplifiedUsers=nullptr)
Implementation of recursive simplification through an instruction's uses.
static Value * simplifySelectWithICmpEq(Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, const SimplifyQuery &Q, unsigned MaxRecurse)
Try to simplify a select instruction when its condition operand is an integer equality comparison.
static bool isAllocDisjoint(const Value *V)
Return true if the underlying object (storage) must be disjoint from storage returned by any noalias ...
static Constant * getTrue(Type *Ty)
For a boolean type or a vector of boolean type, return true or a vector with every element true.
static bool isDivZero(Value *X, Value *Y, const SimplifyQuery &Q, unsigned MaxRecurse, bool IsSigned)
Return true if we can simplify X / Y to 0.
static Value * simplifyCmpSelCase(CmpInst::Predicate Pred, Value *LHS, Value *RHS, Value *Cond, const SimplifyQuery &Q, unsigned MaxRecurse, Constant *TrueOrFalse)
Simplify comparison with true or false branch of select: sel = select i1 cond, i32 tv,...
static Value * simplifyLdexp(Value *Op0, Value *Op1, const SimplifyQuery &Q, bool IsStrict)
static Value * simplifyLogicOfAddSub(Value *Op0, Value *Op1, Instruction::BinaryOps Opcode)
Given a bitwise logic op, check if the operands are add/sub with a common source value and inverted c...
static Value * simplifyOrLogic(Value *X, Value *Y)
static Type * getCompareTy(Value *Op)
static Value * simplifyCastInst(unsigned, Value *, Type *, const SimplifyQuery &, unsigned)
static Value * simplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1, const SimplifyQuery &Q)
static Value * simplifyBinOp(unsigned, Value *, Value *, const SimplifyQuery &, unsigned)
Given operands for a BinaryOperator, see if we can fold the result.
static Value * simplifyInsertValueInst(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const SimplifyQuery &Q, unsigned)
Given operands for an InsertValueInst, see if we can fold the result.
static Value * simplifyAndInst(Value *, Value *, const SimplifyQuery &, unsigned)
Given operands for an And, see if we can fold the result.
static Value * foldIdentityShuffles(int DestElt, Value *Op0, Value *Op1, int MaskVal, Value *RootVec, unsigned MaxRecurse)
For the given destination element of a shuffle, peek through shuffles to match a root vector source o...
static Constant * computePointerICmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q)
static Value * simplifyAndOrOfFCmps(const SimplifyQuery &Q, FCmpInst *LHS, FCmpInst *RHS, bool IsAnd)
static Value * simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an FCmpInst, see if we can fold the result.
static Value * simplifyAndOrOfCmps(const SimplifyQuery &Q, Value *Op0, Value *Op1, bool IsAnd)
static Value * simplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp, const SimplifyQuery &Q, bool AllowRefinement, SmallVectorImpl< Instruction * > *DropFlags, unsigned MaxRecurse)
static Value * threadBinOpOverSelect(Instruction::BinaryOps Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
In the case of a binary operation with a select instruction as an operand, try to simplify the binop ...
static Constant * computePointerDifference(const DataLayout &DL, Value *LHS, Value *RHS)
Compute the constant difference between two pointer values.
static Value * simplifySRemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an SRem, see if we can fold the result.
static Value * simplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given the operands for an FMul, see if we can fold the result.
static Value * simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an ICmpInst, see if we can fold the result.
static Value * simplifyICmpOfBools(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Fold an icmp when its operands have i1 scalar type.
static Value * simplifyAndOrOfICmpsWithConstants(ICmpInst *Cmp0, ICmpInst *Cmp1, bool IsAnd)
Test if a pair of compares with a shared operand and 2 constants has an empty set intersection,...
static Value * simplifyAndOrWithICmpEq(unsigned Opcode, Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
static Value * simplifyICmpWithBinOp(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
TODO: A large part of this logic is duplicated in InstCombine's foldICmpBinOp().
static Value * simplifyShift(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, bool IsNSW, const SimplifyQuery &Q, unsigned MaxRecurse)
Given operands for an Shl, LShr or AShr, see if we can fold the result.
static Value * extractEquivalentCondition(Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS)
Rummage around inside V looking for something equivalent to the comparison "LHS Pred RHS".
static Value * simplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
These are simplifications common to SRem and URem.
static bool valueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT)
Does the given value dominate the specified phi node?
static Value * simplifyCmpSelFalseCase(CmpInst::Predicate Pred, Value *LHS, Value *RHS, Value *Cond, const SimplifyQuery &Q, unsigned MaxRecurse)
Simplify comparison with false branch of select.
static Value * simplifySelectWithICmpCond(Value *CondVal, Value *TrueVal, Value *FalseVal, const SimplifyQuery &Q, unsigned MaxRecurse)
Try to simplify a select instruction when its condition operand is an integer comparison.
static bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS)
isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"?
static Value * foldMinimumMaximumSharedOp(Intrinsic::ID IID, Value *Op0, Value *Op1)
Given a min/max intrinsic, see if it can be removed based on having an operand that is another min/ma...
static Value * simplifyUnaryIntrinsic(Function *F, Value *Op0, const SimplifyQuery &Q, const CallBase *Call)
This header provides classes for managing per-loop analyses.
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements a set that has insertion order iteration characteristics.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
static SymbolRef::Type getType(const Symbol *Sym)
static const uint32_t IV[8]
Class for arbitrary precision integers.
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
unsigned getActiveBits() const
Compute the number of active bits in the value.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
void setSignBit()
Set the sign bit to 1.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
bool intersects(const APInt &RHS) const
This operation tests if there are any pairs of corresponding bits between this APInt and RHS that are...
unsigned countr_zero() const
Count the number of trailing zero bits.
bool isNonPositive() const
Determine if this APInt Value is non-positive (<= 0).
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
bool isStrictlyPositive() const
Determine if this APInt Value is positive.
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const
If this value is smaller than the specified limit, return it, otherwise return the limit value.
bool getBoolValue() const
Convert APInt to a boolean value.
APInt srem(const APInt &RHS) const
Function for signed remainder operation.
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 ule(const APInt &RHS) const
Unsigned less or equal comparison.
bool isSubsetOf(const APInt &RHS) const
This operation checks that all bits set in this APInt are also set in RHS.
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Constructs an APInt value that has the bottom loBitsSet bits set.
bool isSignBitSet() const
Determine if sign bit of this APInt is set.
bool slt(const APInt &RHS) const
Signed less than comparison.
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Constructs an APInt value that has the top hiBitsSet bits set.
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 uge(const APInt &RHS) const
Unsigned greater or equal comparison.
an instruction to allocate memory on the stack
A container for analyses that lazily runs them and caches their results.
This class represents an incoming formal argument to a Function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
const T & back() const
back - Get the last element.
size_t size() const
size - Get the array size.
ArrayRef< T > drop_back(size_t N=1) const
Drop the last N elements of the array.
bool empty() const
empty - Check if the array is empty.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
An immutable pass that tracks lazily created AssumptionCache objects.
AssumptionCache & getAssumptionCache(Function &F)
Get the cached assumptions for a function.
A cache of @llvm.assume calls within a function.
MutableArrayRef< ResultElem > assumptionsFor(const Value *V)
Access the list of assumptions which affect this value.
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
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Value * getArgOperand(unsigned i) const
This class represents a function call, abstracting a target machine's calling convention.
static unsigned isEliminableCastPair(Instruction::CastOps firstOpcode, Instruction::CastOps secondOpcode, Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy, Type *DstIntPtrTy)
Determine how a pair of casts can be eliminated, if they can be at all.
This class is the base class for the comparison instructions.
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Predicate getStrictPredicate() const
For example, SGE -> SGT, SLE -> SLT, ULE -> ULT, UGE -> UGT.
bool isFalseWhenEqual() const
This is just a convenience.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ ICMP_ULT
unsigned less than
@ ICMP_SGE
signed greater or equal
@ ICMP_ULE
unsigned less or equal
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
bool isTrueWhenEqual() const
This is just a convenience.
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.
bool isIntPredicate() const
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
static Constant * getNot(Constant *C)
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
static Constant * getShuffleVector(Constant *V1, Constant *V2, ArrayRef< int > Mask, Type *OnlyIfReducedTy=nullptr)
static bool isSupportedGetElementPtr(const Type *SrcElemTy)
Whether creating a constant expression for this getelementptr type is supported.
static Constant * getBinOpAbsorber(unsigned Opcode, Type *Ty)
Return the absorbing element for the given binary operation, i.e.
static Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false, bool NSZ=false)
Return the identity constant for a binary opcode.
static Constant * getZero(Type *Ty, bool Negative=false)
static Constant * getNegativeZero(Type *Ty)
static Constant * getNaN(Type *Ty, bool Negative=false, uint64_t Payload=0)
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getFalse(LLVMContext &Context)
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
static ConstantInt * getBool(LLVMContext &Context, bool V)
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
This class represents a range of values.
const APInt * getSingleElement() const
If this set contains a single element, return it, otherwise return null.
bool isFullSet() const
Return true if this set contains all of the elements possible for this data-type.
bool isEmptySet() const
Return true if this set contains no members.
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 inverse() const
Return a new range that is the logical not of the current set.
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
static Constant * get(StructType *T, ArrayRef< Constant * > V)
static Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
static Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
static Constant * getAllOnesValue(Type *Ty)
bool isAllOnesValue() const
Return true if this is the value that would be returned by getAllOnesValue.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
bool isNaN() const
Return true if this is a floating-point NaN constant or a vector floating-point constant with all NaN...
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.
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
IntegerType * getIntPtrType(LLVMContext &C, unsigned AddressSpace=0) const
Returns an integer type with size at least as big as that of a pointer in the given address space.
unsigned getIndexTypeSizeInBits(Type *Ty) const
Layout size of the index used in GEP calculation.
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
unsigned getIndexSizeInBits(unsigned AS) const
Size in bits of index used for address calculation in getelementptr.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
Legacy analysis pass which computes a DominatorTree.
DominatorTree & getDomTree()
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.
This instruction compares its operands according to the predicate given to the constructor.
Convenience struct for specifying and reasoning about fast-math flags.
bool noSignedZeros() const
bool allowReassoc() const
Flag queries.
Represents calls to the gc.relocate intrinsic.
Value * getBasePtr() const
Value * getDerivedPtr() const
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
This instruction compares its operands according to the predicate given to the constructor.
static bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
Predicate getSignedPredicate() const
For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
bool isEquality() const
Return true if this predicate is either EQ or NE.
bool isRelational() const
Return true if the predicate is relational (not EQ or NE).
Predicate getUnsignedPredicate() const
For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
This instruction inserts a struct field of array element value into an aggregate value.
bool hasNoSignedZeros() const LLVM_READONLY
Determine whether the no-signed-zeros flag is set.
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
const Function * getFunction() const
Return the function this instruction belongs to.
An instruction for reading from memory.
bool isVolatile() const
Return true if this is a load from a volatile memory location.
static APInt getSaturationPoint(Intrinsic::ID ID, unsigned numBits)
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
ICmpInst::Predicate getPredicate() const
Returns the comparison predicate underlying the intrinsic.
op_range incoming_values()
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
Pass interface - Implemented by all 'passes'.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
This class represents a cast from a pointer to an integer.
This class represents a sign extension of integer types.
This class represents the LLVM 'select' instruction.
size_type size() const
Determine the number of elements in the SetVector.
bool insert(const value_type &X)
Insert a new element into the SetVector.
static void commuteShuffleMask(MutableArrayRef< int > Mask, unsigned InVecNumElts)
Change values in a shuffle permute mask assuming the two vector operands of length InVecNumElts have ...
A SetVector that performs no allocations if smaller than a certain size.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void assign(size_type NumElts, ValueParamT Elt)
void reserve(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
TargetLibraryInfo & getTLI(const Function &F)
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.
bool isPointerTy() const
True if this is an instance of PointerType.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isScalableTy() const
Return true if this is a type whose size is a known multiple of vscale.
static IntegerType * getInt32Ty(LLVMContext &C)
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
A Use represents the edge between a Value definition and its users.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr) const
Accumulate the constant offset this value has compared to a base pointer.
LLVMContext & getContext() const
All values hold a context through their type.
This class represents zero extension of integer types.
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
class_match< PoisonValue > m_Poison()
Match an arbitrary poison constant.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
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.
cst_pred_ty< is_sign_mask > m_SignMask()
Match an integer or vector with only the sign bit(s) set.
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
cstfp_pred_ty< is_inf > m_Inf()
Match a positive or negative infinity FP constant.
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
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.
BinaryOp_match< cstfp_pred_ty< is_any_zero_fp >, RHS, Instruction::FSub > m_FNegNSZ(const RHS &X)
Match 'fneg X' as 'fsub +-0.0, X'.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
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.
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.
bool match(Val *V, const Pattern &P)
BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)
Matches integer division operations.
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.
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
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.
cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()
Match a floating-point negative zero.
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
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)
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
CastOperator_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
m_Intrinsic_Ty< Opnd0 >::Ty m_Sqrt(const Opnd0 &Op0)
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.
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(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.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
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.
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
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.
CastInst_match< OpTy, UIToFPInst > m_UIToFP(const OpTy &Op)
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > > m_c_MaxOrMin(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
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.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
CastInst_match< OpTy, SIToFPInst > m_SIToFP(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Exact_match< T > m_Exact(const T &SubPattern)
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.
BinaryOp_match< LHS, RHS, Instruction::FAdd, true > m_c_FAdd(const LHS &L, const RHS &R)
Matches FAdd with LHS and RHS in either order.
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)
apfloat_match m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
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)
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
auto m_Undef()
Match an arbitrary undef constant.
cstfp_pred_ty< is_nan > m_NaN()
Match an arbitrary NaN 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)
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
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.
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement > m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
Matches InsertElementInst.
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.
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
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)
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
ExceptionBehavior
Exception behavior used for floating point operations.
@ ebStrict
This corresponds to "fpexcept.strict".
@ ebIgnore
This corresponds to "fpexcept.ignore".
This is an optimization pass for GlobalISel generic memory operations.
Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
Value * simplifyAShrInst(Value *Op0, Value *Op1, bool IsExact, const SimplifyQuery &Q)
Given operands for a AShr, fold the result or return nulll.
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
Constant * ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds, std::optional< ConstantRange > InRange, ArrayRef< Value * > Idxs)
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Value * simplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FMul, fold the result or return null.
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)
Return true if it is valid to use the assumptions provided by an assume intrinsic,...
bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
Value * simplifyFreezeInst(Value *Op, const SimplifyQuery &Q)
Given an operand for a Freeze, see if we can fold the result.
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &DL, unsigned Depth=0)
Return true if 'V & Mask' is known to be zero.
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.
bool canConstantFoldCallTo(const CallBase *Call, const Function *F)
canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function.
APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth)
Return the minimum or maximum constant value for the specified integer min/max flavor and type.
Value * simplifySDivInst(Value *LHS, Value *RHS, bool IsExact, const SimplifyQuery &Q)
Given operands for an SDiv, fold the result or return null.
Value * simplifyUnOp(unsigned Opcode, Value *Op, const SimplifyQuery &Q)
Given operand for a UnaryOperator, fold the result or return null.
bool isDefaultFPEnvironment(fp::ExceptionBehavior EB, RoundingMode RM)
Returns true if the exception handling behavior and rounding mode match what is used in the default f...
Constant * ConstantFoldFPInstOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL, const Instruction *I)
Attempt to constant fold a floating point binary operation with the specified operands,...
Value * simplifyMulInst(Value *LHS, Value *RHS, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for a Mul, fold the result or return null.
bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)
If this constant is a constant offset from a global, return the global and the constant.
Value * simplifyInstructionWithOperands(Instruction *I, ArrayRef< Value * > NewOps, const SimplifyQuery &Q)
Like simplifyInstruction but the operands of I are replaced with NewOps.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
Value * simplifyCall(CallBase *Call, Value *Callee, ArrayRef< Value * > Args, const SimplifyQuery &Q)
Given a callsite, callee, and arguments, fold the result or return null.
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.
bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given value is known to have exactly one bit set when defined.
bool canRoundingModeBe(RoundingMode RM, RoundingMode QRM)
Returns true if the rounding mode RM may be QRM at compile time or at run time.
bool isNoAliasCall(const Value *V)
Return true if this pointer is returned by a noalias function.
Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)
Return the canonical comparison predicate for the specified minimum/maximum flavor.
Value * simplifyShuffleVectorInst(Value *Op0, Value *Op1, ArrayRef< int > Mask, Type *RetTy, const SimplifyQuery &Q)
Given operands for a ShuffleVectorInst, fold the result or return null.
Value * simplifyOrInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an Or, fold the result or return null.
Value * simplifyXorInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an Xor, fold the result or return null.
ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
ConstantRange computeConstantRange(const Value *V, bool ForSigned, bool UseInstrInfo=true, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Determine the possible constant range of an integer or vector of integer value.
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices.
bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI)
Tests if a value is a call or invoke to a library function that allocates memory (either malloc,...
Value * simplifyCastInst(unsigned CastOpc, Value *Op, Type *Ty, const SimplifyQuery &Q)
Given operands for a CastInst, fold the result or return null.
Constant * ConstantFoldCall(const CallBase *Call, Function *F, ArrayRef< Constant * > Operands, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified argum...
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
unsigned M1(unsigned Val)
Value * simplifySubInst(Value *LHS, Value *RHS, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for a Sub, fold the result or return null.
Value * simplifyAddInst(Value *LHS, Value *RHS, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for an Add, fold the result or return null.
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
OutputIt transform(R &&Range, OutputIt d_first, UnaryFunction F)
Wrapper function around std::transform to apply a function to a range and store the result elsewhere.
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 getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, const TargetLibraryInfo *TLI, ObjectSizeOpts Opts={})
Compute the size of the object pointed by Ptr.
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...
Constant * ConstantFoldLoadFromUniformValue(Constant *C, Type *Ty, const DataLayout &DL)
If C is a uniform value where all bits are the same (either all zero, all ones, all undef or all pois...
SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF)
Return the inverse minimum/maximum flavor of the specified flavor.
bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, SmallSetVector< Instruction *, 8 > *UnsimplifiedUsers=nullptr)
Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively.
Constant * ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, const DataLayout &DL)
Attempt to constant fold a unary operation with the specified operand.
SelectPatternFlavor
Specific patterns of select instructions we can match.
Value * simplifyShlInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for a Shl, fold the result or return null.
Value * simplifyFNegInst(Value *Op, FastMathFlags FMF, const SimplifyQuery &Q)
Given operand for an FNeg, fold the result or return null.
Value * simplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FSub, fold the result or return null.
bool impliesPoison(const Value *ValAssumedPoison, const Value *V)
Return true if V is poison given that ValAssumedPoison is already poison.
Constant * ConstantFoldInstOperands(Instruction *I, ArrayRef< Constant * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands.
Value * simplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FRem, fold the result or return null.
Value * simplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FAdd, fold the result or return null.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
bool PointerMayBeCaptured(const Value *V, bool ReturnCaptures, bool StoreCaptures, unsigned MaxUsesToExplore=0)
PointerMayBeCaptured - Return true if this pointer value may be captured by the enclosing function (w...
Value * simplifyLShrInst(Value *Op0, Value *Op1, bool IsExact, const SimplifyQuery &Q)
Given operands for a LShr, fold the result or return null.
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
ConstantRange getVScaleRange(const Function *F, unsigned BitWidth)
Determine the possible constant range of vscale with the given bit width, based on the vscale_range f...
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.
Value * simplifyExtractValueInst(Value *Agg, ArrayRef< unsigned > Idxs, const SimplifyQuery &Q)
Given operands for an ExtractValueInst, fold the result or return null.
Value * simplifyInsertValueInst(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const SimplifyQuery &Q)
Given operands for an InsertValueInst, fold the result or return null.
Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
Value * simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an ICmpInst, fold the result or return null.
Value * simplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FDiv, fold the result or return null.
bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth=0)
Return true if the given value is known to be non-zero when defined.
constexpr int PoisonMaskElem
Value * simplifyLoadInst(LoadInst *LI, Value *PtrOp, const SimplifyQuery &Q)
Given a load instruction and its pointer operand, fold the result or return null.
Value * simplifyFMAFMul(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for the multiplication of a FMA, fold the result or return null.
void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
Value * simplifyConstrainedFPCall(CallBase *Call, const SimplifyQuery &Q)
Given a constrained FP intrinsic call, tries to compute its simplified version.
Value * simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a BinaryOperator, fold the result or return null.
bool isKnownNonEqual(const Value *V1, const Value *V2, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given values are known to be non-equal when defined.
@ Or
Bitwise or logical OR of integers.
Value * simplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a CmpInst, fold the result or return null.
Value * findScalarElement(Value *V, unsigned EltNo)
Given a vector and an element number, see if the scalar value is already around as a register,...
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...
Value * simplifyUDivInst(Value *LHS, Value *RHS, bool IsExact, const SimplifyQuery &Q)
Given operands for a UDiv, fold the result or return null.
Value * simplifyBinaryIntrinsic(Intrinsic::ID IID, Type *ReturnType, Value *Op0, Value *Op1, const SimplifyQuery &Q, const CallBase *Call)
Given operands for a BinaryIntrinsic, fold the result or return null.
RoundingMode
Rounding mode.
bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Return true if this function can prove that V does not have undef bits and is never poison.
unsigned M0(unsigned Val)
Value * simplifyInsertElementInst(Value *Vec, Value *Elt, Value *Idx, const SimplifyQuery &Q)
Given operands for an InsertElement, fold the result or return null.
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.
bool maskIsAllZeroOrUndef(Value *Mask)
Given a mask vector of i1, Return true if all of the elements of this predicate mask are known to be ...
std::pair< Value *, FPClassTest > fcmpToClassTest(CmpInst::Predicate Pred, const Function &F, Value *LHS, Value *RHS, bool LookThroughSrc=true)
Returns a pair of values, which if passed to llvm.is.fpclass, returns the same result as an fcmp with...
Value * simplifySRemInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an SRem, fold the result or return null.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
std::optional< bool > computeKnownFPSignBit(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return false if we can prove that the specified FP value's sign bit is 0.
unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return the number of times the sign bit of the register is replicated into the other bits.
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 all_equal(std::initializer_list< T > Values)
Returns true if all Values in the initializer lists are equal or the list.
Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue instruction with the spe...
Constant * ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, APInt Offset, const DataLayout &DL)
Return the value that a load from C with offset Offset would produce if it is constant and determinab...
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...
std::optional< bool > isImpliedByDomCondition(const Value *Cond, const Instruction *ContextI, const DataLayout &DL)
Return the boolean condition value in the context of the given instruction if it is known based on do...
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.
KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...
const SimplifyQuery getBestSimplifyQuery(Pass &, Function &)
Value * simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q)
Given operands for an FCmpInst, fold the result or return null.
Value * simplifyGEPInst(Type *SrcTy, Value *Ptr, ArrayRef< Value * > Indices, bool InBounds, const SimplifyQuery &Q)
Given operands for a GetElementPtrInst, fold the result or return null.
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,...
bool canIgnoreSNaN(fp::ExceptionBehavior EB, FastMathFlags FMF)
Returns true if the possibility of a signaling NaN can be safely ignored.
Value * simplifyURemInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a URem, fold the result or return null.
Value * simplifyExtractElementInst(Value *Vec, Value *Idx, const SimplifyQuery &Q)
Given operands for an ExtractElementInst, fold the result or return null.
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 swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
This callback is used in conjunction with PointerMayBeCaptured.
virtual void tooManyUses()=0
tooManyUses - The depth of traversal has breached a limit.
virtual bool captured(const Use *U)=0
captured - Information about the pointer was captured by the user of use U.
Incoming for lane maks phi as machine instruction, incoming register Reg and incoming block Block are...
InstrInfoQuery provides an interface to query additional information for instructions like metadata o...
bool isExact(const BinaryOperator *Op) const
MDNode * getMetadata(const Instruction *I, unsigned KindID) const
bool hasNoSignedWrap(const InstT *Op) const
bool hasNoUnsignedWrap(const InstT *Op) const
bool isNonNegative() const
Returns true if this value is known to be non-negative.
bool isZero() const
Returns true if value is all zero.
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
unsigned countMaxTrailingZeros() const
Returns the maximum number of trailing zero bits possible.
bool hasConflict() const
Returns true if there is conflicting information.
unsigned getBitWidth() const
Get the bit width of this value.
unsigned countMaxActiveBits() const
Returns the maximum number of bits needed to represent all possible unsigned values with these known ...
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
APInt getMaxValue() const
Return the maximal unsigned value possible given these KnownBits.
APInt getMinValue() const
Return the minimal unsigned value possible given these KnownBits.
bool isNegative() const
Returns true if this value is known to be negative.
static KnownBits shl(const KnownBits &LHS, const KnownBits &RHS, bool NUW=false, bool NSW=false, bool ShAmtNonZero=false)
Compute known bits for shl(LHS, RHS).
static constexpr FPClassTest OrderedLessThanZeroMask
std::optional< bool > SignBit
std::nullopt if the sign bit is unknown, true if the sign bit is definitely set or false if the sign ...
bool isKnownNeverNaN() const
Return true if it's known this can never be a nan.
bool isKnownNever(FPClassTest Mask) const
Return true if it's known this can never be one of the mask entries.
bool cannotBeOrderedLessThanZero() const
Return true if we can prove that the analyzed floating-point value is either NaN or never less than -...
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
Various options to control the behavior of getObjectSize.
bool NullIsUnknownSize
If this is true, null pointers in address space 0 will be treated as though they can't be evaluated.
Mode EvalMode
How we want to evaluate this object's size.
SelectPatternFlavor Flavor
static bool isMinOrMax(SelectPatternFlavor SPF)
When implementing this min/max pattern as fcmp; select, does the fcmp have to be ordered?
bool CanUseUndef
Controls whether simplifications are allowed to constrain the range of possible values for uses of un...
SimplifyQuery getWithInstruction(const Instruction *I) const
bool isUndefValue(Value *V) const
If CanUseUndef is true, returns whether V is undef.
const TargetLibraryInfo * TLI
SimplifyQuery getWithoutUndef() const