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>()))
4316 if (isa<FreezeInst>(
I))
4321 bool AnyReplaced =
false;
4322 for (
Value *InstOp :
I->operands()) {
4324 InstOp,
Op, RepOp, Q, AllowRefinement, DropFlags, MaxRecurse)) {
4326 AnyReplaced = InstOp != NewInstOp;
4335 if (!AllowRefinement) {
4340 if (
auto *BO = dyn_cast<BinaryOperator>(
I)) {
4341 unsigned Opcode = BO->getOpcode();
4350 if ((Opcode == Instruction::And || Opcode == Instruction::Or) &&
4351 NewOps[0] == NewOps[1]) {
4353 if (
auto *PDI = dyn_cast<PossiblyDisjointInst>(BO)) {
4354 if (PDI->isDisjoint()) {
4366 if ((Opcode == Instruction::Sub || Opcode == Instruction::Xor) &&
4367 NewOps[0] == RepOp && NewOps[1] == RepOp)
4379 if ((NewOps[0] == Absorber || NewOps[1] == Absorber) &&
4384 if (isa<GetElementPtrInst>(
I)) {
4400 auto PreventSelfSimplify = [V](
Value *Simplified) {
4401 return Simplified != V ? Simplified :
nullptr;
4404 return PreventSelfSimplify(
4411 for (
Value *NewOp : NewOps) {
4412 if (
Constant *ConstOp = dyn_cast<Constant>(NewOp))
4427 if (!AllowRefinement) {
4430 if (
auto *II = dyn_cast<IntrinsicInst>(
I);
4431 II && II->getIntrinsicID() == Intrinsic::abs) {
4432 if (!ConstOps[0]->isNotMinSignedValue())
4438 if (DropFlags && Res &&
I->hasPoisonGeneratingAnnotations())
4448 bool AllowRefinement,
4450 return ::simplifyWithOpReplaced(V,
Op, RepOp, Q, AllowRefinement, DropFlags,
4457 const APInt *
Y,
bool TrueWhenUnset) {
4464 return TrueWhenUnset ? FalseVal : TrueVal;
4470 return TrueWhenUnset ? FalseVal : TrueVal;
4472 if (
Y->isPowerOf2()) {
4478 if (TrueWhenUnset && cast<PossiblyDisjointInst>(TrueVal)->isDisjoint())
4480 return TrueWhenUnset ? TrueVal : FalseVal;
4488 if (!TrueWhenUnset && cast<PossiblyDisjointInst>(FalseVal)->isDisjoint())
4490 return TrueWhenUnset ? TrueVal : FalseVal;
4501 if (CmpRHS == TVal || CmpRHS == FVal) {
4503 Pred = ICmpInst::getSwappedPredicate(Pred);
4507 if (CmpLHS == FVal) {
4509 Pred = ICmpInst::getInversePredicate(Pred);
4514 Value *
X = CmpLHS, *
Y = CmpRHS;
4515 bool PeekedThroughSelectShuffle =
false;
4516 auto *Shuf = dyn_cast<ShuffleVectorInst>(FVal);
4517 if (Shuf && Shuf->isSelect()) {
4518 if (Shuf->getOperand(0) ==
Y)
4519 FVal = Shuf->getOperand(1);
4520 else if (Shuf->getOperand(1) ==
Y)
4521 FVal = Shuf->getOperand(0);
4524 PeekedThroughSelectShuffle =
true;
4528 auto *MMI = dyn_cast<MinMaxIntrinsic>(FVal);
4529 if (!MMI || TVal !=
X ||
4547 if (PeekedThroughSelectShuffle)
4580 Pred == ICmpInst::ICMP_EQ);
4588 unsigned MaxRecurse) {
4591 nullptr, MaxRecurse) == TrueVal)
4595 nullptr, MaxRecurse) == FalseVal)
4606 unsigned MaxRecurse) {
4608 Value *CmpLHS, *CmpRHS;
4616 if (Pred == ICmpInst::ICMP_NE) {
4617 Pred = ICmpInst::ICMP_EQ;
4624 if (TrueVal->getType()->isIntOrIntVectorTy()) {
4632 X->getType()->getScalarSizeInBits());
4638 if (Pred == ICmpInst::ICMP_EQ &&
match(CmpRHS,
m_Zero())) {
4652 if (
match(TrueVal, isFsh) && FalseVal ==
X && CmpLHS == ShAmt)
4665 if (
match(FalseVal, isRotate) && TrueVal ==
X && CmpLHS == ShAmt &&
4666 Pred == ICmpInst::ICMP_EQ)
4671 if (
match(TrueVal, m_Intrinsic<Intrinsic::abs>(
m_Specific(CmpLHS))) &&
4688 if (Pred == ICmpInst::ICMP_EQ) {
4738 bool HasNoSignedZeros =
4745 if (Pred == FCmpInst::FCMP_OEQ)
4750 if (Pred == FCmpInst::FCMP_UNE)
4761 if (
auto *CondC = dyn_cast<Constant>(
Cond)) {
4762 if (
auto *TrueC = dyn_cast<Constant>(TrueVal))
4763 if (
auto *FalseC = dyn_cast<Constant>(FalseVal))
4768 if (isa<PoisonValue>(CondC))
4773 return isa<Constant>(FalseVal) ? FalseVal : TrueVal;
4785 assert(
Cond->getType()->isIntOrIntVectorTy(1) &&
4786 "Select must have bool or bool vector condition");
4787 assert(TrueVal->getType() == FalseVal->getType() &&
4788 "Select must have same types for true/false ops");
4790 if (
Cond->getType() == TrueVal->getType()) {
4853 if (TrueVal == FalseVal)
4856 if (
Cond == TrueVal) {
4864 if (
Cond == FalseVal) {
4878 if (isa<PoisonValue>(TrueVal) ||
4883 if (isa<PoisonValue>(FalseVal) ||
4889 if (isa<FixedVectorType>(TrueVal->getType()) &&
4893 cast<FixedVectorType>(TrueC->
getType())->getNumElements();
4895 for (
unsigned i = 0; i != NumElts; ++i) {
4899 if (!TEltC || !FEltC)
4906 else if (isa<PoisonValue>(TEltC) ||
4909 else if (isa<PoisonValue>(FEltC) ||
4915 if (NewC.
size() == NumElts)
4931 return *Imp ? TrueVal : FalseVal;
4948 cast<PointerType>(
Ptr->getType()->getScalarType())->getAddressSpace();
4951 if (Indices.
empty())
4961 if (
VectorType *VT = dyn_cast<VectorType>(
Op->getType())) {
4962 GEPTy = VectorType::get(GEPTy, VT->getElementCount());
4969 if (
Ptr->getType() == GEPTy &&
4975 if (isa<PoisonValue>(
Ptr) ||
4976 any_of(Indices, [](
const auto *V) {
return isa<PoisonValue>(V); }))
4983 bool IsScalableVec =
4985 return isa<ScalableVectorType>(V->getType());
4988 if (Indices.
size() == 1) {
4990 if (!IsScalableVec && Ty->
isSized()) {
4995 if (TyAllocSize == 0 &&
Ptr->getType() == GEPTy)
5000 if (Indices[0]->
getType()->getScalarSizeInBits() ==
5002 auto CanSimplify = [GEPTy, &
P,
Ptr]() ->
bool {
5003 return P->getType() == GEPTy &&
5007 if (TyAllocSize == 1 &&
5018 TyAllocSize == 1ULL <<
C && CanSimplify())
5034 [](
Value *
Idx) { return match(Idx, m_Zero()); })) {
5038 APInt BasePtrOffset(IdxWidth, 0);
5039 Value *StrippedBasePtr =
5040 Ptr->stripAndAccumulateInBoundsConstantOffsets(Q.
DL, BasePtrOffset);
5049 !BasePtrOffset.
isZero()) {
5050 auto *CI = ConstantInt::get(GEPTy->
getContext(), BasePtrOffset);
5056 !BasePtrOffset.
isOne()) {
5057 auto *CI = ConstantInt::get(GEPTy->
getContext(), BasePtrOffset - 1);
5064 if (!isa<Constant>(
Ptr) ||
5065 !
all_of(Indices, [](
Value *V) {
return isa<Constant>(V); }))
5070 std::nullopt, Indices);
5087 if (
Constant *CAgg = dyn_cast<Constant>(Agg))
5088 if (
Constant *CVal = dyn_cast<Constant>(Val))
5093 if (isa<PoisonValue>(Val) ||
5099 if (EV->getAggregateOperand()->getType() == Agg->
getType() &&
5100 EV->getIndices() == Idxs) {
5103 if (isa<PoisonValue>(Agg) ||
5106 return EV->getAggregateOperand();
5109 if (Agg == EV->getAggregateOperand())
5119 return ::simplifyInsertValueInst(Agg, Val, Idxs, Q,
RecursionLimit);
5125 auto *VecC = dyn_cast<Constant>(Vec);
5126 auto *ValC = dyn_cast<Constant>(Val);
5127 auto *IdxC = dyn_cast<Constant>(
Idx);
5128 if (VecC && ValC && IdxC)
5132 if (
auto *CI = dyn_cast<ConstantInt>(
Idx)) {
5133 if (isa<FixedVectorType>(Vec->
getType()) &&
5134 CI->uge(cast<FixedVectorType>(Vec->
getType())->getNumElements()))
5144 if (isa<PoisonValue>(Val) ||
5161 if (
auto *CAgg = dyn_cast<Constant>(Agg))
5165 unsigned NumIdxs = Idxs.
size();
5166 for (
auto *IVI = dyn_cast<InsertValueInst>(Agg); IVI !=
nullptr;
5167 IVI = dyn_cast<InsertValueInst>(IVI->getAggregateOperand())) {
5169 unsigned NumInsertValueIdxs = InsertValueIdxs.
size();
5170 unsigned NumCommonIdxs = std::min(NumInsertValueIdxs, NumIdxs);
5171 if (InsertValueIdxs.
slice(0, NumCommonIdxs) ==
5172 Idxs.
slice(0, NumCommonIdxs)) {
5173 if (NumIdxs == NumInsertValueIdxs)
5174 return IVI->getInsertedValueOperand();
5191 auto *VecVTy = cast<VectorType>(Vec->
getType());
5192 if (
auto *CVec = dyn_cast<Constant>(Vec)) {
5193 if (
auto *CIdx = dyn_cast<Constant>(
Idx))
5207 if (
auto *IdxC = dyn_cast<ConstantInt>(
Idx)) {
5209 unsigned MinNumElts = VecVTy->getElementCount().getKnownMinValue();
5210 if (isa<FixedVectorType>(VecVTy) && IdxC->getValue().uge(MinNumElts))
5213 if (IdxC->getValue().ult(MinNumElts))
5223 auto *IE = dyn_cast<InsertElementInst>(Vec);
5224 if (IE && IE->getOperand(2) ==
Idx)
5225 return IE->getOperand(1);
5248 Value *CommonValue =
nullptr;
5249 bool HasUndefInput =
false;
5256 HasUndefInput =
true;
5259 if (CommonValue &&
Incoming != CommonValue)
5269 if (HasUndefInput) {
5281 if (
auto *
C = dyn_cast<Constant>(
Op))
5284 if (
auto *CI = dyn_cast<CastInst>(
Op)) {
5285 auto *Src = CI->getOperand(0);
5286 Type *SrcTy = Src->getType();
5287 Type *MidTy = CI->getType();
5289 if (Src->getType() == Ty) {
5299 SrcIntPtrTy, MidIntPtrTy,
5300 DstIntPtrTy) == Instruction::BitCast)
5306 if (CastOpc == Instruction::BitCast)
5307 if (
Op->getType() == Ty)
5322 int MaskVal,
Value *RootVec,
5323 unsigned MaxRecurse) {
5333 int InVecNumElts = cast<FixedVectorType>(Op0->
getType())->getNumElements();
5334 int RootElt = MaskVal;
5335 Value *SourceOp = Op0;
5336 if (MaskVal >= InVecNumElts) {
5337 RootElt = MaskVal - InVecNumElts;
5343 if (
auto *SourceShuf = dyn_cast<ShuffleVectorInst>(SourceOp)) {
5345 DestElt, SourceShuf->getOperand(0), SourceShuf->getOperand(1),
5346 SourceShuf->getMaskValue(RootElt), RootVec, MaxRecurse);
5358 if (RootVec != SourceOp)
5363 if (RootElt != DestElt)
5372 unsigned MaxRecurse) {
5376 auto *InVecTy = cast<VectorType>(Op0->
getType());
5377 unsigned MaskNumElts = Mask.size();
5378 ElementCount InVecEltCount = InVecTy->getElementCount();
5383 Indices.
assign(Mask.begin(), Mask.end());
5388 bool MaskSelects0 =
false, MaskSelects1 =
false;
5390 for (
unsigned i = 0; i != MaskNumElts; ++i) {
5391 if (Indices[i] == -1)
5393 if ((
unsigned)Indices[i] < InVecNumElts)
5394 MaskSelects0 =
true;
5396 MaskSelects1 =
true;
5404 auto *Op0Const = dyn_cast<Constant>(Op0);
5405 auto *Op1Const = dyn_cast<Constant>(Op1);
5410 if (Op0Const && Op1Const)
5416 if (!Scalable && Op0Const && !Op1Const) {
5434 if (
all_of(Indices, [InsertIndex](
int MaskElt) {
5435 return MaskElt == InsertIndex || MaskElt == -1;
5437 assert(isa<UndefValue>(Op1) &&
"Expected undef operand 1 for splat");
5441 for (
unsigned i = 0; i != MaskNumElts; ++i)
5442 if (Indices[i] == -1)
5450 if (
auto *OpShuf = dyn_cast<ShuffleVectorInst>(Op0))
5470 Value *RootVec =
nullptr;
5471 for (
unsigned i = 0; i != MaskNumElts; ++i) {
5493 if (
auto *
C = dyn_cast<Constant>(
Op))
5521 Type *Ty = In->getType();
5522 if (
auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
5523 unsigned NumElts = VecTy->getNumElements();
5525 for (
unsigned i = 0; i != NumElts; ++i) {
5526 Constant *EltC = In->getAggregateElement(i);
5529 if (EltC && isa<PoisonValue>(EltC))
5531 else if (EltC && EltC->
isNaN())
5532 NewC[i] = ConstantFP::get(
5533 EltC->
getType(), cast<ConstantFP>(EltC)->getValue().makeQuiet());
5547 if (isa<ScalableVectorType>(Ty)) {
5548 auto *
Splat = In->getSplatValue();
5550 "Found a scalable-vector NaN but not a splat");
5556 return ConstantFP::get(Ty, cast<ConstantFP>(In)->getValue().makeQuiet());
5571 for (
Value *V : Ops) {
5579 if (FMF.
noNaNs() && (IsNan || IsUndef))
5581 if (FMF.
noInfs() && (IsInf || IsUndef))
5607 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5673 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5788 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5794 return simplifyFMAFMul(Op0, Op1, FMF, Q, MaxRecurse, ExBehavior, Rounding);
5801 return ::simplifyFAddInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5809 return ::simplifyFSubInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5817 return ::simplifyFMulInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5825 return ::simplifyFMAFMul(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5833 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5858 return ConstantFP::get(Op0->
getType(), 1.0);
5870 return ConstantFP::get(Op0->
getType(), -1.0);
5884 return ::simplifyFDivInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5892 RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
5922 return ::simplifyFRemInst(Op0, Op1, FMF, Q,
RecursionLimit, ExBehavior,
5931 unsigned MaxRecurse) {
5933 case Instruction::FNeg:
5945 unsigned MaxRecurse) {
5947 case Instruction::FNeg:
5968 case Instruction::Add:
5971 case Instruction::Sub:
5974 case Instruction::Mul:
5977 case Instruction::SDiv:
5979 case Instruction::UDiv:
5981 case Instruction::SRem:
5983 case Instruction::URem:
5985 case Instruction::Shl:
5988 case Instruction::LShr:
5990 case Instruction::AShr:
5992 case Instruction::And:
5994 case Instruction::Or:
5996 case Instruction::Xor:
5998 case Instruction::FAdd:
6000 case Instruction::FSub:
6002 case Instruction::FMul:
6004 case Instruction::FDiv:
6006 case Instruction::FRem:
6018 unsigned MaxRecurse) {
6020 case Instruction::FAdd:
6022 case Instruction::FSub:
6024 case Instruction::FMul:
6026 case Instruction::FDiv:
6062 case Intrinsic::fabs:
6063 case Intrinsic::floor:
6064 case Intrinsic::ceil:
6065 case Intrinsic::trunc:
6066 case Intrinsic::rint:
6067 case Intrinsic::nearbyint:
6068 case Intrinsic::round:
6069 case Intrinsic::roundeven:
6070 case Intrinsic::canonicalize:
6071 case Intrinsic::arithmetic_fence:
6083 case Intrinsic::floor:
6084 case Intrinsic::ceil:
6085 case Intrinsic::trunc:
6086 case Intrinsic::rint:
6087 case Intrinsic::nearbyint:
6088 case Intrinsic::round:
6089 case Intrinsic::roundeven:
6103 auto *OffsetConstInt = dyn_cast<ConstantInt>(
Offset);
6104 if (!OffsetConstInt || OffsetConstInt->getBitWidth() > 64)
6108 DL.getIndexTypeSizeInBits(
Ptr->getType()));
6109 if (OffsetInt.
srem(4) != 0)
6117 auto *LoadedCE = dyn_cast<ConstantExpr>(Loaded);
6121 if (LoadedCE->getOpcode() == Instruction::Trunc) {
6122 LoadedCE = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0));
6127 if (LoadedCE->getOpcode() != Instruction::Sub)
6130 auto *LoadedLHS = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0));
6131 if (!LoadedLHS || LoadedLHS->getOpcode() != Instruction::PtrToInt)
6133 auto *LoadedLHSPtr = LoadedLHS->getOperand(0);
6137 APInt LoadedRHSOffset;
6140 PtrSym != LoadedRHSSym || PtrOffset != LoadedRHSOffset)
6143 return LoadedLHSPtr;
6151 if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
6174 if (
C && (
C->isZero() ||
C->isInfinity()))
6183 if (
C &&
C->isNaN())
6184 return ConstantFP::get(Op0->
getType(),
C->makeQuiet());
6202 if (
auto *II = dyn_cast<IntrinsicInst>(Op0))
6203 if (II->getIntrinsicID() == IID)
6212 auto *II = dyn_cast<IntrinsicInst>(Op0);
6220 case Intrinsic::fabs:
6224 case Intrinsic::bswap:
6229 case Intrinsic::bitreverse:
6234 case Intrinsic::ctpop: {
6238 return ConstantInt::get(Op0->
getType(), 1);
6247 case Intrinsic::exp:
6249 if (Call->hasAllowReassoc() &&
6253 case Intrinsic::exp2:
6255 if (Call->hasAllowReassoc() &&
6259 case Intrinsic::exp10:
6261 if (Call->hasAllowReassoc() &&
6265 case Intrinsic::log:
6267 if (Call->hasAllowReassoc() &&
6271 case Intrinsic::log2:
6273 if (Call->hasAllowReassoc() &&
6279 case Intrinsic::log10:
6282 if (Call->hasAllowReassoc() &&
6288 case Intrinsic::vector_reverse:
6296 case Intrinsic::frexp: {
6320 auto *MM0 = dyn_cast<IntrinsicInst>(Op0);
6325 if (Op1 ==
X || Op1 ==
Y ||
6342 assert((IID == Intrinsic::maxnum || IID == Intrinsic::minnum ||
6343 IID == Intrinsic::maximum || IID == Intrinsic::minimum) &&
6344 "Unsupported intrinsic");
6346 auto *
M0 = dyn_cast<IntrinsicInst>(Op0);
6350 if (!
M0 ||
M0->getIntrinsicID() != IID)
6352 Value *X0 =
M0->getOperand(0);
6353 Value *Y0 =
M0->getOperand(1);
6360 if (X0 == Op1 || Y0 == Op1)
6363 auto *
M1 = dyn_cast<IntrinsicInst>(Op1);
6366 Value *X1 =
M1->getOperand(0);
6367 Value *Y1 =
M1->getOperand(1);
6375 if ((X0 == X1 && Y0 == Y1) || (X0 == Y1 && Y0 == X1))
6386 unsigned BitWidth = ReturnType->getScalarSizeInBits();
6388 case Intrinsic::abs:
6396 case Intrinsic::cttz: {
6402 case Intrinsic::ctlz: {
6410 case Intrinsic::ptrmask: {
6411 if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
6421 "Invalid mask width");
6438 APInt IrrelevantPtrBits =
6441 Instruction::Or,
C, ConstantInt::get(
C->getType(), IrrelevantPtrBits),
6443 if (
C !=
nullptr &&
C->isAllOnesValue())
6448 case Intrinsic::smax:
6449 case Intrinsic::smin:
6450 case Intrinsic::umax:
6451 case Intrinsic::umin: {
6462 return ConstantInt::get(
6470 return ConstantInt::get(ReturnType, *
C);
6481 auto *MinMax0 = dyn_cast<IntrinsicInst>(Op0);
6482 if (MinMax0 && MinMax0->getIntrinsicID() == IID) {
6484 Value *M00 = MinMax0->getOperand(0), *M01 = MinMax0->getOperand(1);
6485 const APInt *InnerC;
6488 ICmpInst::getNonStrictPredicate(
6508 case Intrinsic::usub_with_overflow:
6509 case Intrinsic::ssub_with_overflow:
6516 case Intrinsic::uadd_with_overflow:
6517 case Intrinsic::sadd_with_overflow:
6522 cast<StructType>(ReturnType),
6527 case Intrinsic::umul_with_overflow:
6528 case Intrinsic::smul_with_overflow:
6538 case Intrinsic::uadd_sat:
6544 case Intrinsic::sadd_sat:
6559 case Intrinsic::usub_sat:
6564 case Intrinsic::ssub_sat:
6572 case Intrinsic::load_relative:
6573 if (
auto *C0 = dyn_cast<Constant>(Op0))
6574 if (
auto *C1 = dyn_cast<Constant>(Op1))
6577 case Intrinsic::powi:
6578 if (
auto *Power = dyn_cast<ConstantInt>(Op1)) {
6580 if (Power->isZero())
6581 return ConstantFP::get(Op0->
getType(), 1.0);
6587 case Intrinsic::ldexp:
6589 case Intrinsic::copysign:
6599 case Intrinsic::is_fpclass: {
6600 if (isa<PoisonValue>(Op0))
6603 uint64_t Mask = cast<ConstantInt>(Op1)->getZExtValue();
6606 return ConstantInt::get(ReturnType,
true);
6608 return ConstantInt::get(ReturnType,
false);
6613 case Intrinsic::maxnum:
6614 case Intrinsic::minnum:
6615 case Intrinsic::maximum:
6616 case Intrinsic::minimum: {
6622 if (isa<Constant>(Op0))
6629 bool PropagateNaN = IID == Intrinsic::minimum || IID == Intrinsic::maximum;
6630 bool IsMin = IID == Intrinsic::minimum || IID == Intrinsic::minnum;
6637 return PropagateNaN ?
propagateNaN(cast<Constant>(Op1)) : Op0;
6643 (
C->isInfinity() || (Call && Call->hasNoInfs() &&
C->isLargest()))) {
6648 if (
C->isNegative() == IsMin &&
6649 (!PropagateNaN || (Call && Call->hasNoNaNs())))
6650 return ConstantFP::get(ReturnType, *
C);
6656 if (
C->isNegative() != IsMin &&
6657 (PropagateNaN || (Call && Call->hasNoNaNs())))
6670 case Intrinsic::vector_extract: {
6672 unsigned IdxN = cast<ConstantInt>(Op1)->getZExtValue();
6676 IdxN == 0 &&
X->getType() == ReturnType)
6692 assert(Call->arg_size() == Args.size());
6693 unsigned NumOperands = Args.size();
6701 case Intrinsic::vscale: {
6705 return ConstantInt::get(
RetTy,
C->getZExtValue());
6713 if (NumOperands == 1)
6716 if (NumOperands == 2)
6722 case Intrinsic::masked_load:
6723 case Intrinsic::masked_gather: {
6724 Value *MaskArg = Args[2];
6725 Value *PassthruArg = Args[3];
6731 case Intrinsic::fshl:
6732 case Intrinsic::fshr: {
6733 Value *Op0 = Args[0], *Op1 = Args[1], *ShAmtArg = Args[2];
6741 return Args[IID == Intrinsic::fshl ? 0 : 1];
6743 const APInt *ShAmtC;
6748 return Args[IID == Intrinsic::fshl ? 0 : 1];
6753 return ConstantInt::getNullValue(
F->getReturnType());
6757 return ConstantInt::getAllOnesValue(
F->getReturnType());
6761 case Intrinsic::experimental_constrained_fma: {
6762 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6764 *FPI->getRoundingMode()))
6768 case Intrinsic::fma:
6769 case Intrinsic::fmuladd: {
6771 RoundingMode::NearestTiesToEven))
6775 case Intrinsic::smul_fix:
6776 case Intrinsic::smul_fix_sat: {
6777 Value *Op0 = Args[0];
6778 Value *Op1 = Args[1];
6779 Value *Op2 = Args[2];
6780 Type *ReturnType =
F->getReturnType();
6785 if (isa<Constant>(Op0))
6799 cast<ConstantInt>(Op2)->getZExtValue());
6805 case Intrinsic::vector_insert: {
6806 Value *Vec = Args[0];
6807 Value *SubVec = Args[1];
6809 Type *ReturnType =
F->getReturnType();
6813 unsigned IdxN = cast<ConstantInt>(
Idx)->getZExtValue();
6818 X->getType() == ReturnType)
6823 case Intrinsic::experimental_constrained_fadd: {
6824 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6826 *FPI->getExceptionBehavior(),
6827 *FPI->getRoundingMode());
6829 case Intrinsic::experimental_constrained_fsub: {
6830 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6832 *FPI->getExceptionBehavior(),
6833 *FPI->getRoundingMode());
6835 case Intrinsic::experimental_constrained_fmul: {
6836 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6838 *FPI->getExceptionBehavior(),
6839 *FPI->getRoundingMode());
6841 case Intrinsic::experimental_constrained_fdiv: {
6842 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6844 *FPI->getExceptionBehavior(),
6845 *FPI->getRoundingMode());
6847 case Intrinsic::experimental_constrained_frem: {
6848 auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
6850 *FPI->getExceptionBehavior(),
6851 *FPI->getRoundingMode());
6853 case Intrinsic::experimental_constrained_ldexp:
6855 case Intrinsic::experimental_gc_relocate: {
6861 if (isa<UndefValue>(DerivedPtr) || isa<UndefValue>(BasePtr)) {
6865 if (
auto *PT = dyn_cast<PointerType>(GCR.
getType())) {
6869 if (isa<ConstantPointerNull>(DerivedPtr)) {
6884 auto *
F = dyn_cast<Function>(Callee);
6889 ConstantArgs.
reserve(Args.size());
6890 for (
Value *Arg : Args) {
6893 if (isa<MetadataAsValue>(Arg))
6906 assert(Call->arg_size() == Args.size());
6910 if (Call->isMustTailCall())
6915 if (isa<UndefValue>(Callee) || isa<ConstantPointerNull>(Callee))
6921 auto *
F = dyn_cast<Function>(Callee);
6922 if (
F &&
F->isIntrinsic())
6930 assert(isa<ConstrainedFPIntrinsic>(Call));
6949 return ::simplifyFreezeInst(Op0, Q);
6957 if (
auto *PtrOpC = dyn_cast<Constant>(PtrOp))
6963 if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
6994 unsigned MaxRecurse) {
6995 assert(
I->getFunction() &&
"instruction should be inserted in a function");
6997 "context instruction should be in the same function");
7001 switch (
I->getOpcode()) {
7006 [](
Value *V) { return cast<Constant>(V); });
7010 case Instruction::FNeg:
7012 case Instruction::FAdd:
7015 case Instruction::Add:
7019 case Instruction::FSub:
7022 case Instruction::Sub:
7026 case Instruction::FMul:
7029 case Instruction::Mul:
7033 case Instruction::SDiv:
7037 case Instruction::UDiv:
7041 case Instruction::FDiv:
7044 case Instruction::SRem:
7046 case Instruction::URem:
7048 case Instruction::FRem:
7051 case Instruction::Shl:
7055 case Instruction::LShr:
7059 case Instruction::AShr:
7063 case Instruction::And:
7065 case Instruction::Or:
7067 case Instruction::Xor:
7069 case Instruction::ICmp:
7071 NewOps[1], Q, MaxRecurse);
7072 case Instruction::FCmp:
7074 NewOps[1],
I->getFastMathFlags(), Q, MaxRecurse);
7075 case Instruction::Select:
7078 case Instruction::GetElementPtr: {
7079 auto *GEPI = cast<GetElementPtrInst>(
I);
7081 ArrayRef(NewOps).slice(1), GEPI->isInBounds(), Q,
7084 case Instruction::InsertValue: {
7089 case Instruction::InsertElement:
7091 case Instruction::ExtractValue: {
7092 auto *EVI = cast<ExtractValueInst>(
I);
7096 case Instruction::ExtractElement:
7098 case Instruction::ShuffleVector: {
7099 auto *SVI = cast<ShuffleVectorInst>(
I);
7101 SVI->getShuffleMask(), SVI->getType(), Q,
7104 case Instruction::PHI:
7106 case Instruction::Call:
7108 cast<CallInst>(
I), NewOps.
back(),
7109 NewOps.
drop_back(1 + cast<CallInst>(
I)->getNumTotalBundleOperands()), Q);
7110 case Instruction::Freeze:
7112#define HANDLE_CAST_INST(num, opc, clas) case Instruction::opc:
7113#include "llvm/IR/Instruction.def"
7114#undef HANDLE_CAST_INST
7117 case Instruction::Alloca:
7120 case Instruction::Load:
7129 "Number of operands should match the instruction!");
7130 return ::simplifyInstructionWithOperands(
I, NewOps, SQ,
RecursionLimit);
7160 bool Simplified =
false;
7167 for (
User *U :
I->users())
7169 Worklist.
insert(cast<Instruction>(U));
7172 I->replaceAllUsesWith(SimpleV);
7174 if (!
I->isEHPad() && !
I->isTerminator() && !
I->mayHaveSideEffects())
7175 I->eraseFromParent();
7187 if (UnsimplifiedUsers)
7188 UnsimplifiedUsers->insert(
I);
7197 for (
User *U :
I->users())
7198 Worklist.
insert(cast<Instruction>(U));
7201 I->replaceAllUsesWith(SimpleV);
7203 if (!
I->isEHPad() && !
I->isTerminator() && !
I->mayHaveSideEffects())
7204 I->eraseFromParent();
7213 assert(
I != SimpleV &&
"replaceAndRecursivelySimplify(X,X) is not valid!");
7214 assert(SimpleV &&
"Must provide a simplified value.");
7222 auto *DT = DTWP ? &DTWP->
getDomTree() :
nullptr;
7224 auto *TLI = TLIWP ? &TLIWP->
getTLI(
F) :
nullptr;
7227 return {
F.getParent()->getDataLayout(), TLI, DT, AC};
7235template <
class T,
class... TArgs>
7238 auto *DT = AM.template getCachedResult<DominatorTreeAnalysis>(
F);
7239 auto *TLI = AM.template getCachedResult<TargetLibraryAnalysis>(
F);
7240 auto *AC = AM.template getCachedResult<AssumptionAnalysis>(
F);
7241 return {
F.getParent()->getDataLayout(), TLI, DT, AC};
7255void 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