110#define DEBUG_TYPE "instcombine"
118 "Number of instruction combining iterations performed");
119STATISTIC(NumOneIteration,
"Number of functions with one iteration");
120STATISTIC(NumTwoIterations,
"Number of functions with two iterations");
121STATISTIC(NumThreeIterations,
"Number of functions with three iterations");
123 "Number of functions with four or more iterations");
127STATISTIC(NumDeadInst ,
"Number of dead inst eliminated");
133 "Controls which instructions are visited");
140 "instcombine-max-sink-users",
cl::init(32),
141 cl::desc(
"Maximum number of undroppable users for instruction sinking"));
145 cl::desc(
"Maximum array size considered when doing a combine"));
161std::optional<Instruction *>
164 if (
II.getCalledFunction()->isTargetIntrinsic()) {
165 return TTIForTargetIntrinsicsOnly.instCombineIntrinsic(*
this,
II);
172 bool &KnownBitsComputed) {
174 if (
II.getCalledFunction()->isTargetIntrinsic()) {
175 return TTIForTargetIntrinsicsOnly.simplifyDemandedUseBitsIntrinsic(
176 *
this,
II, DemandedMask, Known, KnownBitsComputed);
187 if (
II.getCalledFunction()->isTargetIntrinsic()) {
188 return TTIForTargetIntrinsicsOnly.simplifyDemandedVectorEltsIntrinsic(
189 *
this,
II, DemandedElts, PoisonElts, PoisonElts2, PoisonElts3,
199 return TTIForTargetIntrinsicsOnly.isValidAddrSpaceCast(FromAS, ToAS);
209 Builder.SetInsertPoint(Inst);
213 if (Inst && !
GEP->hasAllConstantIndices() &&
214 !
GEP->getSourceElementType()->isIntegerTy(8)) {
216 *Inst, Builder.CreateGEP(Builder.getInt8Ty(),
GEP->getPointerOperand(),
234 Value *Sum =
nullptr;
235 Value *OneUseSum =
nullptr;
236 Value *OneUseBase =
nullptr;
243 IRBuilderBase::InsertPointGuard Guard(
Builder);
245 if (RewriteGEPs && Inst)
249 if (
Offset->getType() != IdxTy)
252 if (
GEP->hasOneUse()) {
257 OneUseBase =
GEP->getPointerOperand();
266 if (RewriteGEPs && Inst &&
267 !(
GEP->getSourceElementType()->isIntegerTy(8) &&
272 OneUseBase ? OneUseBase :
GEP->getPointerOperand(),
Offset,
"",
279 OneUseSum = OneUseBase =
nullptr;
283 Sum =
Add(Sum, OneUseSum);
294bool InstCombinerImpl::isDesirableIntType(
unsigned BitWidth)
const {
313bool InstCombinerImpl::shouldChangeType(
unsigned FromWidth,
314 unsigned ToWidth)
const {
315 bool FromLegal = FromWidth == 1 ||
DL.isLegalInteger(FromWidth);
316 bool ToLegal = ToWidth == 1 ||
DL.isLegalInteger(ToWidth);
320 if (ToWidth < FromWidth && isDesirableIntType(ToWidth))
325 if ((FromLegal || isDesirableIntType(FromWidth)) && !ToLegal)
330 if (!FromLegal && !ToLegal && ToWidth > FromWidth)
341bool InstCombinerImpl::shouldChangeType(
Type *From,
Type *To)
const {
349 return shouldChangeType(FromWidth, ToWidth);
359 if (!OBO || !OBO->hasNoSignedWrap())
362 const APInt *BVal, *CVal;
367 bool Overflow =
false;
368 switch (
I.getOpcode()) {
369 case Instruction::Add:
370 (void)BVal->
sadd_ov(*CVal, Overflow);
372 case Instruction::Sub:
373 (void)BVal->
ssub_ov(*CVal, Overflow);
375 case Instruction::Mul:
376 (void)BVal->
smul_ov(*CVal, Overflow);
387 return OBO && OBO->hasNoUnsignedWrap();
392 return OBO && OBO->hasNoSignedWrap();
401 I.clearSubclassOptionalData();
406 I.clearSubclassOptionalData();
407 I.setFastMathFlags(FMF);
417 if (!Cast || !Cast->hasOneUse())
421 auto CastOpcode = Cast->getOpcode();
422 if (CastOpcode != Instruction::ZExt)
431 if (!BinOp2 || !BinOp2->hasOneUse() || BinOp2->getOpcode() != AssocOpcode)
457 Cast->dropPoisonGeneratingFlags();
463Value *InstCombinerImpl::simplifyIntToPtrRoundTripCast(
Value *Val) {
465 if (IntToPtr &&
DL.getTypeSizeInBits(IntToPtr->getDestTy()) ==
466 DL.getTypeSizeInBits(IntToPtr->getSrcTy())) {
468 Type *CastTy = IntToPtr->getDestTy();
471 PtrToInt->getSrcTy()->getPointerAddressSpace() &&
472 DL.getTypeSizeInBits(PtrToInt->getSrcTy()) ==
473 DL.getTypeSizeInBits(PtrToInt->getDestTy()))
474 return PtrToInt->getOperand(0);
511 if (
I.isCommutative()) {
512 if (
auto Pair = matchSymmetricPair(
I.getOperand(0),
I.getOperand(1))) {
522 if (
I.isAssociative()) {
545 I.setHasNoUnsignedWrap(
true);
548 I.setHasNoSignedWrap(
true);
577 if (
I.isAssociative() &&
I.isCommutative()) {
654 I.setHasNoUnsignedWrap(
true);
672 if (LOp == Instruction::And)
673 return ROp == Instruction::Or || ROp == Instruction::Xor;
676 if (LOp == Instruction::Or)
677 return ROp == Instruction::And;
681 if (LOp == Instruction::Mul)
682 return ROp == Instruction::Add || ROp == Instruction::Sub;
719 assert(
Op &&
"Expected a binary operator");
720 LHS =
Op->getOperand(0);
721 RHS =
Op->getOperand(1);
722 if (TopOpcode == Instruction::Add || TopOpcode == Instruction::Sub) {
727 Instruction::Shl, ConstantInt::get(
Op->getType(), 1),
C);
728 assert(
RHS &&
"Constant folding of immediate constants failed");
729 return Instruction::Mul;
734 if (OtherOp && OtherOp->
getOpcode() == Instruction::AShr &&
737 return Instruction::AShr;
740 return Op->getOpcode();
749 assert(
A &&
B &&
C &&
D &&
"All values must be provided");
752 Value *RetVal =
nullptr;
763 if (
A ==
C || (InnerCommutative &&
A ==
D)) {
772 if (!V && (
LHS->hasOneUse() ||
RHS->hasOneUse()))
773 V = Builder.CreateBinOp(TopLevelOpcode,
B,
D,
RHS->getName());
775 RetVal = Builder.CreateBinOp(InnerOpcode,
A, V);
783 if (
B ==
D || (InnerCommutative &&
B ==
C)) {
792 if (!V && (
LHS->hasOneUse() ||
RHS->hasOneUse()))
793 V = Builder.CreateBinOp(TopLevelOpcode,
A,
C,
LHS->getName());
795 RetVal = Builder.CreateBinOp(InnerOpcode, V,
B);
810 HasNSW =
I.hasNoSignedWrap();
811 HasNUW =
I.hasNoUnsignedWrap();
814 HasNSW &= LOBO->hasNoSignedWrap();
815 HasNUW &= LOBO->hasNoUnsignedWrap();
819 HasNSW &= ROBO->hasNoSignedWrap();
820 HasNUW &= ROBO->hasNoUnsignedWrap();
823 if (TopLevelOpcode == Instruction::Add && InnerOpcode == Instruction::Mul) {
851 unsigned Opc =
I->getOpcode();
852 unsigned ConstIdx = 1;
859 case Instruction::Sub:
862 case Instruction::ICmp:
869 case Instruction::Or:
873 case Instruction::Add:
879 if (!
match(
I->getOperand(1 - ConstIdx),
889 Constant *BitWidthC = ConstantInt::get(Ty, Ty->getScalarSizeInBits());
895 if (!Cmp || !Cmp->isZeroValue())
900 bool Consumes =
false;
904 assert(NotOp !=
nullptr &&
905 "Desync between isFreeToInvert and getFreelyInverted");
907 Value *CtpopOfNotOp =
Builder.CreateIntrinsic(Ty, Intrinsic::ctpop, NotOp);
914 case Instruction::Sub:
917 case Instruction::Or:
918 case Instruction::Add:
921 case Instruction::ICmp:
957 auto IsValidBinOpc = [](
unsigned Opc) {
961 case Instruction::And:
962 case Instruction::Or:
963 case Instruction::Xor:
964 case Instruction::Add:
973 auto IsCompletelyDistributable = [](
unsigned BinOpc1,
unsigned BinOpc2,
975 assert(ShOpc != Instruction::AShr);
976 return (BinOpc1 != Instruction::Add && BinOpc2 != Instruction::Add) ||
977 ShOpc == Instruction::Shl;
980 auto GetInvShift = [](
unsigned ShOpc) {
981 assert(ShOpc != Instruction::AShr);
982 return ShOpc == Instruction::LShr ? Instruction::Shl : Instruction::LShr;
985 auto CanDistributeBinops = [&](
unsigned BinOpc1,
unsigned BinOpc2,
989 if (BinOpc1 == Instruction::And)
994 if (!IsCompletelyDistributable(BinOpc1, BinOpc2, ShOpc))
1000 if (BinOpc2 == Instruction::And)
1011 auto MatchBinOp = [&](
unsigned ShOpnum) ->
Instruction * {
1013 Value *
X, *
Y, *ShiftedX, *Mask, *Shift;
1014 if (!
match(
I.getOperand(ShOpnum),
1017 if (!
match(
I.getOperand(1 - ShOpnum),
1030 unsigned ShOpc = IY->getOpcode();
1031 if (ShOpc != IX->getOpcode())
1039 unsigned BinOpc = BO2->getOpcode();
1041 if (!IsValidBinOpc(
I.getOpcode()) || !IsValidBinOpc(BinOpc))
1044 if (ShOpc == Instruction::AShr) {
1058 if (BinOpc ==
I.getOpcode() &&
1059 IsCompletelyDistributable(
I.getOpcode(), BinOpc, ShOpc)) {
1074 if (!CanDistributeBinops(
I.getOpcode(), BinOpc, ShOpc, CMask, CShift))
1081 Value *NewBinOp1 =
Builder.CreateBinOp(
I.getOpcode(),
Y, NewBinOp2);
1088 return MatchBinOp(1);
1105 Value *LHS =
I.getOperand(0), *RHS =
I.getOperand(1);
1106 Value *
A, *CondVal, *TrueVal, *FalseVal;
1109 auto MatchSelectAndCast = [&](
Value *CastOp,
Value *SelectOp) {
1111 A->getType()->getScalarSizeInBits() == 1 &&
1118 if (MatchSelectAndCast(LHS, RHS))
1120 else if (MatchSelectAndCast(RHS, LHS))
1125 auto NewFoldedConst = [&](
bool IsTrueArm,
Value *V) {
1126 bool IsCastOpRHS = (CastOp == RHS);
1132 }
else if (IsZExt) {
1133 unsigned BitWidth = V->getType()->getScalarSizeInBits();
1139 return IsCastOpRHS ?
Builder.CreateBinOp(
Opc, V,
C)
1146 Value *NewTrueVal = NewFoldedConst(
false, TrueVal);
1148 NewFoldedConst(
true, FalseVal));
1152 Value *NewTrueVal = NewFoldedConst(
true, TrueVal);
1154 NewFoldedConst(
false, FalseVal));
1161 Value *LHS =
I.getOperand(0), *RHS =
I.getOperand(1);
1175 if (Op0 && Op1 && LHSOpcode == RHSOpcode)
1204 Value *LHS =
I.getOperand(0), *RHS =
I.getOperand(1);
1221 auto SQDistributive =
SQ.getWithInstruction(&
I).getWithoutUndef();
1229 C =
Builder.CreateBinOp(InnerOpcode, L, R);
1238 C =
Builder.CreateBinOp(TopLevelOpcode,
B,
C);
1247 C =
Builder.CreateBinOp(TopLevelOpcode,
A,
C);
1260 auto SQDistributive =
SQ.getWithInstruction(&
I).getWithoutUndef();
1268 A =
Builder.CreateBinOp(InnerOpcode, L, R);
1277 A =
Builder.CreateBinOp(TopLevelOpcode,
A,
C);
1286 A =
Builder.CreateBinOp(TopLevelOpcode,
A,
B);
1295static std::optional<std::pair<Value *, Value *>>
1297 if (
LHS->getParent() !=
RHS->getParent())
1298 return std::nullopt;
1300 if (
LHS->getNumIncomingValues() < 2)
1301 return std::nullopt;
1304 return std::nullopt;
1306 Value *L0 =
LHS->getIncomingValue(0);
1307 Value *R0 =
RHS->getIncomingValue(0);
1309 for (
unsigned I = 1,
E =
LHS->getNumIncomingValues();
I !=
E; ++
I) {
1313 if ((L0 == L1 && R0 == R1) || (L0 == R1 && R0 == L1))
1316 return std::nullopt;
1319 return std::optional(std::pair(L0, R0));
1322std::optional<std::pair<Value *, Value *>>
1327 return std::nullopt;
1329 case Instruction::PHI:
1331 case Instruction::Select: {
1337 return std::pair(TrueVal, FalseVal);
1338 return std::nullopt;
1340 case Instruction::Call: {
1344 if (LHSMinMax && RHSMinMax &&
1351 return std::pair(LHSMinMax->
getLHS(), LHSMinMax->
getRHS());
1352 return std::nullopt;
1355 return std::nullopt;
1365 if (!LHSIsSelect && !RHSIsSelect)
1375 FMF =
I.getFastMathFlags();
1376 Builder.setFastMathFlags(FMF);
1382 Value *
Cond, *True =
nullptr, *False =
nullptr;
1390 if (Opcode != Instruction::Add || (!True && !False) || (True && False))
1404 if (LHSIsSelect && RHSIsSelect &&
A ==
D) {
1410 if (LHS->hasOneUse() && RHS->hasOneUse()) {
1412 True =
Builder.CreateBinOp(Opcode,
B, E);
1413 else if (True && !False)
1414 False =
Builder.CreateBinOp(Opcode,
C,
F);
1416 }
else if (LHSIsSelect && LHS->hasOneUse()) {
1421 if (
Value *NewSel = foldAddNegate(
B,
C, RHS))
1423 }
else if (RHSIsSelect && RHS->hasOneUse()) {
1428 if (
Value *NewSel = foldAddNegate(E,
F, LHS))
1432 if (!True || !False)
1445 if (U == IgnoredUser)
1448 case Instruction::Select: {
1451 SI->swapProfMetadata();
1454 case Instruction::Br: {
1461 case Instruction::Xor:
1468 "canFreelyInvertAllUsersOf() ?");
1478 for (
unsigned Idx = 0, End = DbgVal->getNumVariableLocationOps();
1480 if (DbgVal->getVariableLocationOp(Idx) ==
I)
1481 DbgVal->setExpression(
1488Value *InstCombinerImpl::dyn_castNegVal(
Value *V)
const {
1498 if (
C->getType()->getElementType()->isIntegerTy())
1502 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1518 if (CV->getType()->isVectorTy() &&
1519 CV->getType()->getScalarType()->isIntegerTy() && CV->getSplatValue())
1532Instruction *InstCombinerImpl::foldFBinOpOfIntCastsFromSign(
1533 BinaryOperator &BO,
bool OpsFromSigned, std::array<Value *, 2> IntOps,
1537 Type *IntTy = IntOps[0]->getType();
1542 unsigned MaxRepresentableBits =
1547 unsigned NumUsedLeadingBits[2] = {IntSz, IntSz};
1551 auto IsNonZero = [&](
unsigned OpNo) ->
bool {
1552 if (OpsKnown[OpNo].hasKnownBits() &&
1553 OpsKnown[OpNo].getKnownBits(
SQ).isNonZero())
1558 auto IsNonNeg = [&](
unsigned OpNo) ->
bool {
1562 return OpsKnown[OpNo].getKnownBits(
SQ).isNonNegative();
1566 auto IsValidPromotion = [&](
unsigned OpNo) ->
bool {
1577 if (MaxRepresentableBits < IntSz) {
1587 NumUsedLeadingBits[OpNo] =
1588 IntSz - OpsKnown[OpNo].getKnownBits(
SQ).countMinLeadingZeros();
1596 if (MaxRepresentableBits < NumUsedLeadingBits[OpNo])
1599 return !OpsFromSigned || BO.
getOpcode() != Instruction::FMul ||
1604 if (Op1FpC !=
nullptr) {
1606 if (OpsFromSigned && BO.
getOpcode() == Instruction::FMul &&
1611 OpsFromSigned ? Instruction::FPToSI : Instruction::FPToUI, Op1FpC,
1613 if (Op1IntC ==
nullptr)
1616 : Instruction::UIToFP,
1617 Op1IntC, FPTy,
DL) != Op1FpC)
1621 IntOps[1] = Op1IntC;
1625 if (IntTy != IntOps[1]->
getType())
1628 if (Op1FpC ==
nullptr) {
1629 if (!IsValidPromotion(1))
1632 if (!IsValidPromotion(0))
1638 bool NeedsOverflowCheck =
true;
1641 unsigned OverflowMaxOutputBits = OpsFromSigned ? 2 : 1;
1642 unsigned OverflowMaxCurBits =
1643 std::max(NumUsedLeadingBits[0], NumUsedLeadingBits[1]);
1644 bool OutputSigned = OpsFromSigned;
1646 case Instruction::FAdd:
1647 IntOpc = Instruction::Add;
1648 OverflowMaxOutputBits += OverflowMaxCurBits;
1650 case Instruction::FSub:
1651 IntOpc = Instruction::Sub;
1652 OverflowMaxOutputBits += OverflowMaxCurBits;
1654 case Instruction::FMul:
1655 IntOpc = Instruction::Mul;
1656 OverflowMaxOutputBits += OverflowMaxCurBits * 2;
1662 if (OverflowMaxOutputBits < IntSz) {
1663 NeedsOverflowCheck =
false;
1666 if (IntOpc == Instruction::Sub)
1667 OutputSigned =
true;
1673 if (NeedsOverflowCheck &&
1674 !willNotOverflow(IntOpc, IntOps[0], IntOps[1], BO, OutputSigned))
1677 Value *IntBinOp =
Builder.CreateBinOp(IntOpc, IntOps[0], IntOps[1]);
1679 IntBO->setHasNoSignedWrap(OutputSigned);
1680 IntBO->setHasNoUnsignedWrap(!OutputSigned);
1683 return new SIToFPInst(IntBinOp, FPTy);
1684 return new UIToFPInst(IntBinOp, FPTy);
1698 std::array<Value *, 2> IntOps = {
nullptr,
nullptr};
1718 if (Instruction *R = foldFBinOpOfIntCastsFromSign(BO,
false,
1719 IntOps, Op1FpC, OpsKnown))
1721 return foldFBinOpOfIntCastsFromSign(BO,
true, IntOps,
1737 !
X->getType()->isIntOrIntVectorTy(1))
1745 return createSelectInstWithUnknownProfile(
X, TVal, FVal);
1754 V = IsTrueArm ?
SI->getTrueValue() :
SI->getFalseValue();
1755 }
else if (
match(
SI->getCondition(),
1780 bool FoldWithMultiUse) {
1782 if (!
SI->hasOneUse() && !FoldWithMultiUse)
1785 Value *TV =
SI->getTrueValue();
1786 Value *FV =
SI->getFalseValue();
1789 if (
SI->getType()->isIntOrIntVectorTy(1))
1795 for (
Value *IntrinOp :
Op.operands())
1797 for (
Value *PhiOp : PN->operands())
1809 if (CI->hasOneUse()) {
1810 Value *Op0 = CI->getOperand(0), *Op1 = CI->getOperand(1);
1811 if (((TV == Op0 && FV == Op1) || (FV == Op0 && TV == Op1)) &&
1812 !CI->isCommutative())
1821 if (!NewTV && !NewFV)
1841 Ops.push_back(InValue);
1873 bool AllowMultipleUses) {
1875 if (NumPHIValues == 0)
1882 bool IdenticalUsers =
false;
1883 if (!AllowMultipleUses && !OneUse) {
1887 if (UI != &
I && !
I.isIdenticalTo(UI))
1891 IdenticalUsers =
true;
1921 bool SeenNonSimplifiedInVal =
false;
1922 for (
unsigned i = 0; i != NumPHIValues; ++i) {
1933 auto WillFold = [&]() {
1938 const APInt *Ignored;
1959 if (!OneUse && !IdenticalUsers)
1962 if (SeenNonSimplifiedInVal)
1964 SeenNonSimplifiedInVal =
true;
1988 for (
auto OpIndex : OpsToMoveUseToIncomingBB) {
1999 U = U->DoPHITranslation(PN->
getParent(), OpBB);
2002 Clones.
insert({OpBB, Clone});
2007 NewPhiValues[
OpIndex] = Clone;
2016 for (
unsigned i = 0; i != NumPHIValues; ++i)
2019 if (IdenticalUsers) {
2050 BO0->getOpcode() !=
Opc || BO1->getOpcode() !=
Opc ||
2051 !BO0->isAssociative() || !BO1->isAssociative() ||
2052 BO0->getParent() != BO1->getParent())
2056 "Expected commutative instructions!");
2060 Value *Start0, *Step0, *Start1, *Step1;
2067 "Expected PHIs with two incoming values!");
2074 if (!Init0 || !Init1 || !C0 || !C1)
2089 if (
Opc == Instruction::FAdd ||
Opc == Instruction::FMul) {
2093 NewBO->setFastMathFlags(Intersect);
2097 Flags.AllKnownNonZero =
false;
2098 Flags.mergeFlags(*BO0);
2099 Flags.mergeFlags(*BO1);
2100 Flags.mergeFlags(BO);
2101 Flags.applyFlags(*NewBO);
2103 NewBO->takeName(&BO);
2113 "Invalid incoming block!");
2114 NewPN->addIncoming(
Init, BB);
2115 }
else if (V == BO0) {
2120 "Invalid incoming block!");
2121 NewPN->addIncoming(NewBO, BB);
2127 <<
"\n with " << *PN1 <<
"\n " << *BO1
2154 if (!Phi0 || !Phi1 || !Phi0->hasOneUse() || !Phi1->hasOneUse() ||
2155 Phi0->getNumOperands() != Phi1->getNumOperands())
2159 if (BO.
getParent() != Phi0->getParent() ||
2176 auto CanFoldIncomingValuePair = [&](std::tuple<Use &, Use &>
T) {
2177 auto &Phi0Use = std::get<0>(
T);
2178 auto &Phi1Use = std::get<1>(
T);
2179 if (Phi0->getIncomingBlock(Phi0Use) != Phi1->getIncomingBlock(Phi1Use))
2181 Value *Phi0UseV = Phi0Use.get();
2182 Value *Phi1UseV = Phi1Use.get();
2185 else if (Phi1UseV ==
C)
2192 if (
all_of(
zip(Phi0->operands(), Phi1->operands()),
2193 CanFoldIncomingValuePair)) {
2196 assert(NewIncomingValues.
size() == Phi0->getNumOperands() &&
2197 "The number of collected incoming values should equal the number "
2198 "of the original PHINode operands!");
2199 for (
unsigned I = 0;
I < Phi0->getNumOperands();
I++)
2200 NewPhi->
addIncoming(NewIncomingValues[
I], Phi0->getIncomingBlock(
I));
2205 if (Phi0->getNumOperands() != 2 || Phi1->getNumOperands() != 2)
2212 ConstBB = Phi0->getIncomingBlock(0);
2213 OtherBB = Phi0->getIncomingBlock(1);
2215 ConstBB = Phi0->getIncomingBlock(1);
2216 OtherBB = Phi0->getIncomingBlock(0);
2227 if (!PredBlockBranch || PredBlockBranch->isConditional() ||
2228 !
DT.isReachableFromEntry(OtherBB))
2234 for (
auto BBIter = BO.
getParent()->begin(); &*BBIter != &BO; ++BBIter)
2245 Builder.SetInsertPoint(PredBlockBranch);
2247 Phi0->getIncomingValueForBlock(OtherBB),
2248 Phi1->getIncomingValueForBlock(OtherBB));
2250 NotFoldedNewBO->copyIRFlags(&BO);
2277 if (
GEP.hasAllZeroIndices() && !Src.hasAllZeroIndices() &&
2306 for (
unsigned I = 0;
I < NumElts; ++
I) {
2308 if (ShMask[
I] >= 0) {
2309 assert(ShMask[
I] < (
int)NumElts &&
"Not expecting narrowing shuffle");
2320 NewVecC[ShMask[
I]] = CElt;
2340 Value *L0, *L1, *R0, *R1;
2344 LHS->hasOneUse() && RHS->hasOneUse() &&
2367 M, Intrinsic::vector_reverse, V->getType());
2378 (LHS->hasOneUse() || RHS->hasOneUse() ||
2379 (LHS == RHS && LHS->hasNUses(2))))
2380 return createBinOpReverse(V1, V2);
2384 return createBinOpReverse(V1, RHS);
2388 return createBinOpReverse(LHS, V2);
2399 M, Intrinsic::experimental_vp_reverse, V->getType());
2409 (LHS->hasOneUse() || RHS->hasOneUse() ||
2410 (LHS == RHS && LHS->hasNUses(2))))
2411 return createBinOpVPReverse(V1, V2, EVL);
2415 return createBinOpVPReverse(V1, RHS, EVL);
2421 return createBinOpVPReverse(LHS, V2, EVL);
2441 (LHS->hasOneUse() || RHS->hasOneUse() || LHS == RHS)) {
2443 return createBinOpShuffle(V1, V2, Mask);
2458 if (LShuf->isSelect() &&
2460 RShuf->isSelect() &&
2482 "Shuffle should not change scalar type");
2494 Value *NewLHS = ConstOp1 ? V1 : NewC;
2495 Value *NewRHS = ConstOp1 ? NewC : V1;
2496 return createBinOpShuffle(NewLHS, NewRHS, Mask);
2531 Value *NewSplat =
Builder.CreateShuffleVector(NewBO, NewMask);
2537 R->copyFastMathFlags(&Inst);
2541 NewInstBO->copyIRFlags(R);
2571 (Op0->
hasOneUse() || Op1->hasOneUse()))) {
2597 NewBinOp->setHasNoSignedWrap();
2599 NewBinOp->setHasNoUnsignedWrap();
2615 if (!
GEP.hasAllConstantIndices())
2631 Type *Ty =
GEP.getSourceElementType();
2632 Value *NewTrueC = Builder.CreateGEP(Ty, TrueC, IndexC,
"", NW);
2633 Value *NewFalseC = Builder.CreateGEP(Ty, FalseC, IndexC,
"", NW);
2643 if (
GEP.getNumIndices() != 1)
2653 unsigned IndexSizeInBits =
DL.getIndexTypeSizeInBits(PtrTy);
2664 if (NewOffset.
isZero() ||
2665 (Src->hasOneUse() &&
GEP.getOperand(1)->hasOneUse())) {
2667 if (
GEP.hasNoUnsignedWrap() &&
2687 if (!
GEP.hasAllConstantIndices())
2698 if (InnerGEP->hasAllConstantIndices())
2701 if (!InnerGEP->hasOneUse())
2710 if (Skipped.
empty())
2715 if (!InnerGEP->hasOneUse())
2720 if (InnerGEP->getType() != Ty)
2726 !InnerGEP->accumulateConstantOffset(
DL,
Offset))
2731 SkippedGEP->setNoWrapFlags(NW);
2753 if (Src->getResultElementType() !=
GEP.getSourceElementType())
2757 bool EndsWithSequential =
false;
2760 EndsWithSequential =
I.isSequential();
2761 if (!EndsWithSequential)
2766 Value *SO1 = Src->getOperand(Src->getNumOperands() - 1);
2784 Indices.
append(Src->op_begin() + 1, Src->op_end() - 1);
2789 unsigned NumNonZeroIndices =
count_if(Indices, [](
Value *Idx) {
2791 return !
C || !
C->isNullValue();
2793 if (NumNonZeroIndices > 1)
2798 Src->getSourceElementType(), Src->getOperand(0), Indices,
"",
2804 bool &DoesConsume,
unsigned Depth) {
2805 static Value *
const NonNull =
reinterpret_cast<Value *
>(uintptr_t(1));
2823 if (!WillInvertAllUses)
2830 return Builder->CreateCmp(
I->getInversePredicate(),
I->getOperand(0),
2839 DoesConsume,
Depth))
2842 DoesConsume,
Depth))
2851 DoesConsume,
Depth))
2854 DoesConsume,
Depth))
2863 DoesConsume,
Depth))
2872 DoesConsume,
Depth))
2884 bool LocalDoesConsume = DoesConsume;
2886 LocalDoesConsume,
Depth))
2889 LocalDoesConsume,
Depth)) {
2890 DoesConsume = LocalDoesConsume;
2893 DoesConsume,
Depth);
2894 assert(NotB !=
nullptr &&
2895 "Unable to build inverted value for known freely invertable op");
2897 return Builder->CreateBinaryIntrinsic(
2906 bool LocalDoesConsume = DoesConsume;
2908 for (
Use &U : PN->operands()) {
2909 BasicBlock *IncomingBlock = PN->getIncomingBlock(U);
2913 if (NewIncomingVal ==
nullptr)
2916 if (NewIncomingVal == V)
2919 IncomingValues.
emplace_back(NewIncomingVal, IncomingBlock);
2922 DoesConsume = LocalDoesConsume;
2927 Builder->CreatePHI(PN->getType(), PN->getNumIncomingValues());
2928 for (
auto [Val, Pred] : IncomingValues)
2937 DoesConsume,
Depth))
2938 return Builder ?
Builder->CreateSExt(AV, V->getType()) : NonNull;
2944 DoesConsume,
Depth))
2945 return Builder ?
Builder->CreateTrunc(AV, V->getType()) : NonNull;
2953 bool IsLogical,
Value *
A,
2955 bool LocalDoesConsume = DoesConsume;
2957 LocalDoesConsume,
Depth))
2960 LocalDoesConsume,
Depth)) {
2962 LocalDoesConsume,
Depth);
2963 DoesConsume = LocalDoesConsume;
2965 return Builder ?
Builder->CreateLogicalOp(Opcode, NotA, NotB) : NonNull;
2966 return Builder ?
Builder->CreateBinOp(Opcode, NotA, NotB) : NonNull;
2973 return TryInvertAndOrUsingDeMorgan(Instruction::And,
false,
A,
2977 return TryInvertAndOrUsingDeMorgan(Instruction::Or,
false,
A,
2981 return TryInvertAndOrUsingDeMorgan(Instruction::And,
true,
A,
2985 return TryInvertAndOrUsingDeMorgan(Instruction::Or,
true,
A,
2994 Type *GEPEltType =
GEP.getSourceElementType();
3005 if (
GEP.getNumIndices() == 1 &&
3014 return PtrOpGep && PtrOpGep->hasAllConstantIndices() &&
3017 return match(V, m_APInt(C)) && !C->isZero();
3041 if (!Op2 || Op1->getNumOperands() != Op2->getNumOperands() ||
3042 Op1->getSourceElementType() != Op2->getSourceElementType())
3050 Type *CurTy =
nullptr;
3052 for (
unsigned J = 0,
F = Op1->getNumOperands(); J !=
F; ++J) {
3053 if (Op1->getOperand(J)->getType() != Op2->getOperand(J)->getType())
3056 if (Op1->getOperand(J) != Op2->getOperand(J)) {
3065 assert(CurTy &&
"No current type?");
3085 CurTy = Op1->getSourceElementType();
3093 NW &= Op2->getNoWrapFlags();
3103 NewGEP->setNoWrapFlags(NW);
3115 Builder.SetInsertPoint(PN);
3116 NewPN = Builder.CreatePHI(Op1->getOperand(DI)->getType(),
3124 NewGEP->setOperand(DI, NewPN);
3127 NewGEP->insertBefore(*
GEP.getParent(),
GEP.getParent()->getFirstInsertionPt());
3134 Type *GEPType =
GEP.getType();
3135 Type *GEPEltType =
GEP.getSourceElementType();
3138 SQ.getWithInstruction(&
GEP)))
3145 auto VWidth = GEPFVTy->getNumElements();
3146 APInt PoisonElts(VWidth, 0);
3158 bool MadeChange =
false;
3162 Type *NewScalarIndexTy =
3163 DL.getIndexType(
GEP.getPointerOperandType()->getScalarType());
3172 Type *IndexTy = (*I)->getType();
3173 Type *NewIndexType =
3182 if (EltTy->
isSized() &&
DL.getTypeAllocSize(EltTy).isZero())
3188 if (IndexTy != NewIndexType) {
3194 if (
GEP.hasNoUnsignedWrap() &&
GEP.hasNoUnsignedSignedWrap())
3195 *
I =
Builder.CreateZExt(*
I, NewIndexType,
"",
true);
3197 *
I =
Builder.CreateSExt(*
I, NewIndexType);
3199 *
I =
Builder.CreateTrunc(*
I, NewIndexType,
"",
GEP.hasNoUnsignedWrap(),
3200 GEP.hasNoUnsignedSignedWrap());
3209 if (!GEPEltType->
isIntegerTy(8) &&
GEP.hasAllConstantIndices()) {
3214 GEP.getNoWrapFlags()));
3226 if (LastIdx && LastIdx->isNullValue() && !LastIdx->getType()->isVectorTy()) {
3234 if (FirstIdx && FirstIdx->isNullValue() &&
3235 !FirstIdx->getType()->isVectorTy()) {
3240 GEP.getPointerOperand(),
3242 GEP.getNoWrapFlags()));
3249 return Op->getType()->isVectorTy() && getSplatValue(Op);
3252 for (
auto &
Op :
GEP.operands()) {
3253 if (
Op->getType()->isVectorTy())
3263 GEP.getNoWrapFlags());
3266 Res =
Builder.CreateVectorSplat(EC, Res);
3271 bool SeenNonZeroIndex =
false;
3272 for (
auto [IdxNum, Idx] :
enumerate(Indices)) {
3274 if (
C &&
C->isNullValue())
3277 if (!SeenNonZeroIndex) {
3278 SeenNonZeroIndex =
true;
3285 Builder.CreateGEP(GEPEltType, PtrOp, FrontIndices,
3286 GEP.getName() +
".split",
GEP.getNoWrapFlags());
3293 BackIndices,
GEP.getNoWrapFlags());
3306 if (
GEP.getNumIndices() == 1) {
3307 unsigned AS =
GEP.getPointerAddressSpace();
3308 if (
GEP.getOperand(1)->getType()->getScalarSizeInBits() ==
3309 DL.getIndexSizeInBits(AS)) {
3310 uint64_t TyAllocSize =
DL.getTypeAllocSize(GEPEltType).getFixedValue();
3312 if (TyAllocSize == 1) {
3321 GEPType ==
Y->getType()) {
3322 bool HasSameUnderlyingObject =
3325 GEP.replaceUsesWithIf(
Y, [&](
Use &U) {
3326 bool ShouldReplace = HasSameUnderlyingObject ||
3330 return ShouldReplace;
3334 }
else if (
auto *ExactIns =
3338 if (ExactIns->isExact()) {
3346 GEP.getPointerOperand(), V,
3347 GEP.getNoWrapFlags());
3350 if (ExactIns->isExact() && ExactIns->hasOneUse()) {
3356 std::optional<APInt> NewC;
3376 if (NewC.has_value()) {
3379 ConstantInt::get(V->getType(), *NewC));
3382 GEP.getPointerOperand(), NewOp,
3383 GEP.getNoWrapFlags());
3393 if (!
GEP.isInBounds()) {
3396 APInt BasePtrOffset(IdxWidth, 0);
3397 Value *UnderlyingPtrOp =
3399 bool CanBeNull, CanBeFreed;
3401 DL, CanBeNull, CanBeFreed);
3402 if (!CanBeNull && !CanBeFreed && DerefBytes != 0) {
3403 if (
GEP.accumulateConstantOffset(
DL, BasePtrOffset) &&
3405 APInt AllocSize(IdxWidth, DerefBytes);
3406 if (BasePtrOffset.
ule(AllocSize)) {
3408 GEP.getSourceElementType(), PtrOp, Indices,
GEP.getName());
3415 if (
GEP.hasNoUnsignedSignedWrap() && !
GEP.hasNoUnsignedWrap() &&
3417 return isKnownNonNegative(Idx, SQ.getWithInstruction(&GEP));
3425 if (
GEP.getNumIndices() == 1) {
3428 auto GetPreservedNoWrapFlags = [&](
bool AddIsNUW) {
3431 if (
GEP.hasNoUnsignedWrap() && AddIsNUW)
3432 return GEP.getNoWrapFlags();
3448 Builder.CreateGEP(
GEP.getSourceElementType(),
GEP.getPointerOperand(),
3451 Builder.CreateGEP(
GEP.getSourceElementType(),
3452 NewPtr, Idx2,
"", NWFlags));
3463 bool NUW =
match(
GEP.getOperand(1),
3466 auto *NewPtr =
Builder.CreateGEP(
3467 GEP.getSourceElementType(),
GEP.getPointerOperand(),
3468 Builder.CreateSExt(Idx1,
GEP.getOperand(1)->getType()),
"", NWFlags);
3471 Builder.CreateGEP(
GEP.getSourceElementType(), NewPtr,
3472 Builder.CreateSExt(
C,
GEP.getOperand(1)->getType()),
3512 return Dest && Dest->Ptr == UsedV;
3515static std::optional<ModRefInfo>
3527 switch (
I->getOpcode()) {
3530 return std::nullopt;
3532 case Instruction::AddrSpaceCast:
3533 case Instruction::BitCast:
3534 case Instruction::GetElementPtr:
3539 case Instruction::ICmp: {
3545 return std::nullopt;
3546 unsigned OtherIndex = (ICI->
getOperand(0) == PI) ? 1 : 0;
3548 return std::nullopt;
3553 auto AlignmentAndSizeKnownValid = [](
CallBase *CB) {
3557 const APInt *Alignment;
3559 return match(CB->getArgOperand(0),
m_APInt(Alignment)) &&
3565 if (CB && TLI.
getLibFunc(*CB->getCalledFunction(), TheLibFunc) &&
3566 TLI.
has(TheLibFunc) && TheLibFunc == LibFunc_aligned_alloc &&
3567 !AlignmentAndSizeKnownValid(CB))
3568 return std::nullopt;
3573 case Instruction::Call:
3576 switch (
II->getIntrinsicID()) {
3578 return std::nullopt;
3580 case Intrinsic::memmove:
3581 case Intrinsic::memcpy:
3582 case Intrinsic::memset: {
3584 if (
MI->isVolatile())
3585 return std::nullopt;
3591 return std::nullopt;
3595 case Intrinsic::assume:
3596 case Intrinsic::invariant_start:
3597 case Intrinsic::invariant_end:
3598 case Intrinsic::lifetime_start:
3599 case Intrinsic::lifetime_end:
3600 case Intrinsic::objectsize:
3603 case Intrinsic::launder_invariant_group:
3604 case Intrinsic::strip_invariant_group:
3631 return std::nullopt;
3633 case Instruction::Store: {
3635 if (
SI->isVolatile() ||
SI->getPointerOperand() != PI)
3636 return std::nullopt;
3638 return std::nullopt;
3644 case Instruction::Load: {
3647 return std::nullopt;
3649 return std::nullopt;
3657 }
while (!Worklist.
empty());
3681 std::unique_ptr<DIBuilder> DIB;
3689 bool KnowInitUndef =
false;
3690 bool KnowInitZero =
false;
3695 KnowInitUndef =
true;
3696 else if (
Init->isNullValue())
3697 KnowInitZero =
true;
3701 auto &
F = *
MI.getFunction();
3702 if (
F.hasFnAttribute(Attribute::SanitizeMemory) ||
3703 F.hasFnAttribute(Attribute::SanitizeAddress))
3704 KnowInitUndef =
false;
3718 if (
II->getIntrinsicID() == Intrinsic::objectsize) {
3721 II,
DL, &
TLI,
AA,
true, &InsertedInstructions);
3722 for (
Instruction *Inserted : InsertedInstructions)
3730 if (KnowInitZero &&
isRefSet(*Removable)) {
3733 auto *M =
Builder.CreateMemSet(
3736 MTI->getLength(), MTI->getDestAlign());
3737 M->copyMetadata(*MTI);
3751 C->isFalseWhenEqual()));
3753 for (
auto *DVR : DVRs)
3754 if (DVR->isAddressOfVariable())
3761 assert(KnowInitZero || KnowInitUndef);
3776 F,
II->getNormalDest(),
II->getUnwindDest(), {},
"",
II->getParent());
3777 NewII->setDebugLoc(
II->getDebugLoc());
3805 for (
auto *DVR : DVRs)
3806 if (DVR->isAddressOfVariable() || DVR->getExpression()->startsWithDeref())
3807 DVR->eraseFromParent();
3853 if (FreeInstrBB->
size() != 2) {
3855 if (&Inst == &FI || &Inst == FreeInstrBBTerminator)
3858 if (!Cast || !Cast->isNoopCast(
DL))
3879 "Broken CFG: missing edge from predecessor to successor");
3884 if (&Instr == FreeInstrBBTerminator)
3889 "Only the branch instruction should remain");
3900 Attrs = Attrs.removeParamAttribute(FI.
getContext(), 0, Attribute::NonNull);
3901 Attribute Dereferenceable = Attrs.getParamAttr(0, Attribute::Dereferenceable);
3902 if (Dereferenceable.
isValid()) {
3904 Attrs = Attrs.removeParamAttribute(FI.
getContext(), 0,
3905 Attribute::Dereferenceable);
3906 Attrs = Attrs.addDereferenceableOrNullParamAttr(FI.
getContext(), 0, Bytes);
3945 if (
TLI.getLibFunc(FI, Func) &&
TLI.has(Func) && Func == LibFunc_free)
3961 bool HasDereferenceable =
3962 F->getAttributes().getRetDereferenceableBytes() > 0;
3963 if (
F->hasRetAttribute(Attribute::NonNull) ||
3964 (HasDereferenceable &&
3966 if (
Value *V = simplifyNonNullOperand(RetVal, HasDereferenceable))
3971 if (!AttributeFuncs::isNoFPClassCompatibleType(RetTy))
3974 FPClassTest ReturnClass =
F->getAttributes().getRetNoFPClass();
3975 if (ReturnClass ==
fcNone)
3998 if (Prev->isEHPad())
4030 if (BBI != FirstInstr)
4032 }
while (BBI != FirstInstr && BBI->isDebugOrPseudoInst());
4046 if (!
DeadEdges.insert({From, To}).second)
4051 for (
Use &U : PN.incoming_values())
4068 std::next(
I->getReverseIterator())))) {
4069 if (!Inst.use_empty() && !Inst.getType()->isTokenTy()) {
4073 if (Inst.isEHPad() || Inst.getType()->isTokenTy())
4076 Inst.dropDbgRecords();
4098 return DeadEdges.contains({Pred, BB}) ||
DT.dominates(BB, Pred);
4111 if (Succ == LiveSucc)
4185 if (
DT.dominates(Edge0, U)) {
4191 if (
DT.dominates(Edge1, U)) {
4198 DC.registerBranch(&BI);
4208 unsigned CstOpIdx = IsTrueArm ? 1 : 2;
4213 BasicBlock *CstBB =
SI.findCaseValue(
C)->getCaseSuccessor();
4214 if (CstBB !=
SI.getDefaultDest())
4227 for (
auto Case :
SI.cases())
4228 if (!CR.
contains(Case.getCaseValue()->getValue()))
4240 for (
auto Case :
SI.cases()) {
4243 "Result of expression should be constant");
4252 for (
auto Case :
SI.cases()) {
4255 "Result of expression should be constant");
4264 all_of(
SI.cases(), [&](
const auto &Case) {
4265 return Case.getCaseValue()->getValue().countr_zero() >= ShiftAmt;
4271 Value *NewCond = Op0;
4278 for (
auto Case :
SI.cases()) {
4279 const APInt &CaseVal = Case.getCaseValue()->getValue();
4281 : CaseVal.
lshr(ShiftAmt);
4282 Case.setValue(ConstantInt::get(
SI.getContext(), ShiftedCase));
4294 if (
all_of(
SI.cases(), [&](
const auto &Case) {
4295 const APInt &CaseVal = Case.getCaseValue()->getValue();
4296 return IsZExt ? CaseVal.isIntN(NewWidth)
4297 : CaseVal.isSignedIntN(NewWidth);
4299 for (
auto &Case :
SI.cases()) {
4300 APInt TruncatedCase = Case.getCaseValue()->getValue().
trunc(NewWidth);
4301 Case.setValue(ConstantInt::get(
SI.getContext(), TruncatedCase));
4323 for (
const auto &
C :
SI.cases()) {
4325 std::min(LeadingKnownZeros,
C.getCaseValue()->getValue().countl_zero());
4327 std::min(LeadingKnownOnes,
C.getCaseValue()->getValue().countl_one());
4330 unsigned NewWidth = Known.
getBitWidth() - std::max(LeadingKnownZeros, LeadingKnownOnes);
4336 if (NewWidth > 0 && NewWidth < Known.
getBitWidth() &&
4337 shouldChangeType(Known.
getBitWidth(), NewWidth)) {
4342 for (
auto Case :
SI.cases()) {
4343 APInt TruncatedCase = Case.getCaseValue()->getValue().
trunc(NewWidth);
4344 Case.setValue(ConstantInt::get(
SI.getContext(), TruncatedCase));
4355 SI.findCaseValue(CI)->getCaseSuccessor());
4369 const APInt *
C =
nullptr;
4371 if (*EV.
idx_begin() == 0 && (OvID == Intrinsic::smul_with_overflow ||
4372 OvID == Intrinsic::umul_with_overflow)) {
4377 if (
C->isPowerOf2()) {
4378 return BinaryOperator::CreateShl(
4380 ConstantInt::get(WO->getLHS()->getType(),
C->logBase2()));
4388 if (!WO->hasOneUse())
4402 assert(*EV.
idx_begin() == 1 &&
"Unexpected extract index for overflow inst");
4405 if (OvID == Intrinsic::usub_with_overflow)
4410 if (OvID == Intrinsic::smul_with_overflow &&
4411 WO->getLHS()->getType()->isIntOrIntVectorTy(1))
4412 return BinaryOperator::CreateAnd(WO->getLHS(), WO->getRHS());
4415 if (OvID == Intrinsic::umul_with_overflow && WO->getLHS() == WO->getRHS()) {
4416 unsigned BitWidth = WO->getLHS()->getType()->getScalarSizeInBits();
4419 return new ICmpInst(
4421 ConstantInt::get(WO->getLHS()->getType(),
4432 WO->getBinaryOp(), *
C, WO->getNoWrapKind());
4437 auto *OpTy = WO->getRHS()->getType();
4438 auto *NewLHS = WO->getLHS();
4440 NewLHS =
Builder.CreateAdd(NewLHS, ConstantInt::get(OpTy,
Offset));
4442 ConstantInt::get(OpTy, NewRHSC));
4459 const APFloat *ConstVal =
nullptr;
4460 Value *VarOp =
nullptr;
4461 bool ConstIsTrue =
false;
4468 ConstIsTrue =
false;
4473 Builder.SetInsertPoint(&EV);
4479 Value *NewEV = Builder.CreateExtractValue(NewFrexp, 0,
"mantissa");
4484 Constant *ConstantMantissa = ConstantFP::get(TrueVal->getType(), Mantissa);
4486 Value *NewSel = Builder.CreateSelectFMF(
4487 Cond, ConstIsTrue ? ConstantMantissa : NewEV,
4488 ConstIsTrue ? NewEV : ConstantMantissa,
SelectInst,
"select.frexp");
4498 SQ.getWithInstruction(&EV)))
4512 const unsigned *exti, *exte, *insi, *inse;
4513 for (exti = EV.
idx_begin(), insi =
IV->idx_begin(),
4514 exte = EV.
idx_end(), inse =
IV->idx_end();
4515 exti != exte && insi != inse;
4529 if (exti == exte && insi == inse)
4544 Value *NewEV =
Builder.CreateExtractValue(
IV->getAggregateOperand(),
4562 if (
Instruction *R = foldExtractOfOverflowIntrinsic(EV))
4568 STy && STy->isScalableTy())
4576 if (L->isSimple() && L->hasOneUse()) {
4581 for (
unsigned Idx : EV.
indices())
4588 L->getPointerOperand(), Indices);
4622 switch (Personality) {
4666 bool MakeNewInstruction =
false;
4672 bool isLastClause = i + 1 == e;
4680 if (AlreadyCaught.
insert(TypeInfo).second) {
4685 MakeNewInstruction =
true;
4692 MakeNewInstruction =
true;
4693 CleanupFlag =
false;
4712 if (!NumTypeInfos) {
4715 MakeNewInstruction =
true;
4716 CleanupFlag =
false;
4720 bool MakeNewFilter =
false;
4724 assert(NumTypeInfos > 0 &&
"Should have handled empty filter already!");
4730 MakeNewInstruction =
true;
4737 if (NumTypeInfos > 1)
4738 MakeNewFilter =
true;
4742 NewFilterElts.
reserve(NumTypeInfos);
4747 bool SawCatchAll =
false;
4748 for (
unsigned j = 0; j != NumTypeInfos; ++j) {
4776 if (SeenInFilter.
insert(TypeInfo).second)
4782 MakeNewInstruction =
true;
4787 if (NewFilterElts.
size() < NumTypeInfos)
4788 MakeNewFilter =
true;
4790 if (MakeNewFilter) {
4792 NewFilterElts.
size());
4794 MakeNewInstruction =
true;
4803 if (MakeNewFilter && !NewFilterElts.
size()) {
4804 assert(MakeNewInstruction &&
"New filter but not a new instruction!");
4805 CleanupFlag =
false;
4816 for (
unsigned i = 0, e = NewClauses.
size(); i + 1 < e; ) {
4819 for (j = i; j != e; ++j)
4826 for (
unsigned k = i; k + 1 < j; ++k)
4830 std::stable_sort(NewClauses.
begin() + i, NewClauses.
begin() + j,
4832 MakeNewInstruction =
true;
4851 for (
unsigned i = 0; i + 1 < NewClauses.
size(); ++i) {
4861 for (
unsigned j = NewClauses.
size() - 1; j != i; --j) {
4862 Value *LFilter = NewClauses[j];
4873 NewClauses.
erase(J);
4874 MakeNewInstruction =
true;
4878 unsigned LElts = LTy->getNumElements();
4888 assert(FElts <= LElts &&
"Should have handled this case earlier!");
4890 NewClauses.
erase(J);
4891 MakeNewInstruction =
true;
4900 assert(FElts > 0 &&
"Should have eliminated the empty filter earlier!");
4901 for (
unsigned l = 0; l != LElts; ++l)
4904 NewClauses.
erase(J);
4905 MakeNewInstruction =
true;
4916 bool AllFound =
true;
4917 for (
unsigned f = 0; f != FElts; ++f) {
4920 for (
unsigned l = 0; l != LElts; ++l) {
4922 if (LTypeInfo == FTypeInfo) {
4932 NewClauses.
erase(J);
4933 MakeNewInstruction =
true;
4941 if (MakeNewInstruction) {
4949 if (NewClauses.empty())
4958 assert(!CleanupFlag &&
"Adding a cleanup, not removing one?!");
4980 auto CanPushFreeze = [](
Value *V) {
5001 Value *V = U->get();
5002 if (!CanPushFreeze(V)) {
5008 Builder.SetInsertPoint(UserI);
5009 Value *Frozen =
Builder.CreateFreeze(V, V->getName() +
".fr");
5015 if (!Visited.
insert(
I).second)
5026 I->dropPoisonGeneratingAnnotations();
5027 this->Worklist.add(
I);
5030 return OrigUse->get();
5040 Use *StartU =
nullptr;
5058 Value *StartV = StartU->get();
5070 if (!Visited.
insert(V).second)
5073 if (Visited.
size() > 32)
5090 I->dropPoisonGeneratingAnnotations();
5092 if (StartNeedsFreeze) {
5120 MoveBefore = *MoveBeforeOpt;
5124 MoveBefore.setHeadBit(
false);
5127 if (&FI != &*MoveBefore) {
5128 FI.
moveBefore(*MoveBefore->getParent(), MoveBefore);
5132 Op->replaceUsesWithIf(&FI, [&](
Use &U) ->
bool {
5133 bool Dominates =
DT.dominates(&FI, U);
5143 for (
auto *U : V->users()) {
5153 Value *Op0 =
I.getOperand(0);
5183 auto getUndefReplacement = [&](
Type *Ty) {
5184 auto pickCommonConstantFromPHI = [](
PHINode &PN) ->
Value * {
5188 for (
Value *V : PN.incoming_values()) {
5199 if (BestValue && BestValue !=
C)
5208 Value *BestValue =
nullptr;
5209 for (
auto *U :
I.users()) {
5210 Value *V = NullValue;
5219 if (
Value *MaybeV = pickCommonConstantFromPHI(*
PHI))
5225 else if (BestValue != V)
5226 BestValue = NullValue;
5228 assert(BestValue &&
"Must have at least one use");
5229 assert(BestValue != &
I &&
"Cannot replace with itself");
5243 Type *Ty =
C->getType();
5247 unsigned NumElts = VTy->getNumElements();
5249 for (
unsigned i = 0; i != NumElts; ++i) {
5250 Constant *EltC =
C->getAggregateElement(i);
5261 !
C->containsConstantExpression()) {
5262 if (
Constant *Repl = getFreezeVectorReplacement(
C))
5296 for (
const User *U :
I.users()) {
5297 if (Visited.
insert(U).second)
5302 while (!AllocaUsers.
empty()) {
5325 if (
isa<PHINode>(
I) ||
I->isEHPad() ||
I->mayThrow() || !
I->willReturn() ||
5342 if (CI->isConvergent())
5348 if (
I->mayWriteToMemory()) {
5355 if (
I->mayReadFromMemory() &&
5356 !
I->hasMetadata(LLVMContext::MD_invariant_load)) {
5363 E =
I->getParent()->end();
5365 if (Scan->mayWriteToMemory())
5369 I->dropDroppableUses([&](
const Use *U) {
5371 if (
I &&
I->getParent() != DestBlock) {
5381 I->moveBefore(*DestBlock, InsertPos);
5391 if (!DbgVariableRecords.
empty())
5393 DbgVariableRecords);
5416 for (
auto &DVR : DbgVariableRecords)
5417 if (DVR->getParent() != DestBlock)
5418 DbgVariableRecordsToSalvage.
push_back(DVR);
5424 if (DVR->getParent() == SrcBlock)
5425 DbgVariableRecordsToSink.
push_back(DVR);
5432 return B->getInstruction()->comesBefore(
A->getInstruction());
5439 using InstVarPair = std::pair<const Instruction *, DebugVariable>;
5441 if (DbgVariableRecordsToSink.
size() > 1) {
5447 DVR->getDebugLoc()->getInlinedAt());
5448 CountMap[std::make_pair(DVR->getInstruction(), DbgUserVariable)] += 1;
5454 for (
auto It : CountMap) {
5455 if (It.second > 1) {
5456 FilterOutMap[It.first] =
nullptr;
5457 DupSet.
insert(It.first.first);
5468 DVR.getDebugLoc()->getInlinedAt());
5470 FilterOutMap.
find(std::make_pair(Inst, DbgUserVariable));
5471 if (FilterIt == FilterOutMap.
end())
5473 if (FilterIt->second !=
nullptr)
5475 FilterIt->second = &DVR;
5490 DVR->getDebugLoc()->getInlinedAt());
5494 if (!FilterOutMap.
empty()) {
5495 InstVarPair IVP = std::make_pair(DVR->getInstruction(), DbgUserVariable);
5496 auto It = FilterOutMap.
find(IVP);
5499 if (It != FilterOutMap.
end() && It->second != DVR)
5503 if (!SunkVariables.
insert(DbgUserVariable).second)
5506 if (DVR->isDbgAssign())
5514 if (DVRClones.
empty())
5528 assert(InsertPos.getHeadBit());
5530 InsertPos->getParent()->insertDbgRecordBefore(DVRClone, InsertPos);
5554 if (
I ==
nullptr)
continue;
5569 auto getOptionalSinkBlockForInst =
5570 [
this](
Instruction *
I) -> std::optional<BasicBlock *> {
5572 return std::nullopt;
5576 unsigned NumUsers = 0;
5578 for (
Use &U :
I->uses()) {
5583 return std::nullopt;
5589 UserBB = PN->getIncomingBlock(U);
5593 if (UserParent && UserParent != UserBB)
5594 return std::nullopt;
5595 UserParent = UserBB;
5599 if (NumUsers == 0) {
5602 if (UserParent == BB || !
DT.isReachableFromEntry(UserParent))
5603 return std::nullopt;
5615 return std::nullopt;
5617 assert(
DT.dominates(BB, UserParent) &&
"Dominance relation broken?");
5625 return std::nullopt;
5630 auto OptBB = getOptionalSinkBlockForInst(
I);
5632 auto *UserParent = *OptBB;
5640 for (
Use &U :
I->operands())
5648 Builder.CollectMetadataToCopy(
5649 I, {LLVMContext::MD_dbg, LLVMContext::MD_annotation});
5662 <<
" New = " << *Result <<
'\n');
5667 Result->setDebugLoc(Result->getDebugLoc().orElse(
I->getDebugLoc()));
5669 Result->copyMetadata(*
I, LLVMContext::MD_annotation);
5671 I->replaceAllUsesWith(Result);
5674 Result->takeName(
I);
5689 Result->insertInto(InstParent, InsertPos);
5692 Worklist.pushUsersToWorkList(*Result);
5698 <<
" New = " << *
I <<
'\n');
5730 if (!
I->hasMetadataOtherThanDebugLoc())
5733 auto Track = [](
Metadata *ScopeList,
auto &Container) {
5735 if (!MDScopeList || !Container.insert(MDScopeList).second)
5737 for (
const auto &
MDOperand : MDScopeList->operands())
5739 Container.insert(MDScope);
5742 Track(
I->getMetadata(LLVMContext::MD_alias_scope), UsedAliasScopesAndLists);
5743 Track(
I->getMetadata(LLVMContext::MD_noalias), UsedNoAliasScopesAndLists);
5752 "llvm.experimental.noalias.scope.decl in use ?");
5755 "llvm.experimental.noalias.scope should refer to a single scope");
5758 return !UsedAliasScopesAndLists.contains(MD) ||
5759 !UsedNoAliasScopesAndLists.contains(MD);
5783 if (Succ != LiveSucc &&
DeadEdges.insert({BB, Succ}).second)
5784 for (
PHINode &PN : Succ->phis())
5785 for (
Use &U : PN.incoming_values())
5794 return DeadEdges.contains({Pred, BB}) ||
DT.dominates(BB, Pred);
5796 HandleOnlyLiveSuccessor(BB,
nullptr);
5803 if (!Inst.use_empty() &&
5804 (Inst.getNumOperands() == 0 ||
isa<Constant>(Inst.getOperand(0))))
5808 Inst.replaceAllUsesWith(
C);
5811 Inst.eraseFromParent();
5817 for (
Use &U : Inst.operands()) {
5822 Constant *&FoldRes = FoldedConstants[
C];
5828 <<
"\n Old = " << *
C
5829 <<
"\n New = " << *FoldRes <<
'\n');
5838 if (!Inst.isDebugOrPseudoInst()) {
5839 InstrsForInstructionWorklist.
push_back(&Inst);
5840 SeenAliasScopes.
analyse(&Inst);
5850 HandleOnlyLiveSuccessor(BB,
nullptr);
5854 bool CondVal =
Cond->getZExtValue();
5855 HandleOnlyLiveSuccessor(BB, BI->getSuccessor(!CondVal));
5861 HandleOnlyLiveSuccessor(BB,
nullptr);
5865 HandleOnlyLiveSuccessor(BB,
5866 SI->findCaseValue(
Cond)->getCaseSuccessor());
5876 if (LiveBlocks.
count(&BB))
5879 unsigned NumDeadInstInBB;
5883 NumDeadInst += NumDeadInstInBB;
5900 Inst->eraseFromParent();
5929 auto &
DL =
F.getDataLayout();
5931 !
F.hasFnAttribute(
"instcombine-no-verify-fixpoint");
5947 bool MadeIRChange =
false;
5952 unsigned Iteration = 0;
5956 <<
" on " <<
F.getName()
5957 <<
" reached; stopping without verifying fixpoint\n");
5962 ++NumWorklistIterations;
5963 LLVM_DEBUG(
dbgs() <<
"\n\nINSTCOMBINE ITERATION #" << Iteration <<
" on "
5964 <<
F.getName() <<
"\n");
5966 InstCombinerImpl IC(Worklist, Builder,
F,
AA, AC, TLI,
TTI, DT, ORE, BFI,
5967 BPI, PSI,
DL, RPOT);
5970 MadeChangeInThisIteration |= IC.
run();
5971 if (!MadeChangeInThisIteration)
5974 MadeIRChange =
true;
5977 "Instruction Combining on " +
Twine(
F.getName()) +
5980 "Use 'instcombine<no-verify-fixpoint>' or function attribute "
5981 "'instcombine-no-verify-fixpoint' to suppress this error.");
5987 else if (Iteration == 2)
5989 else if (Iteration == 3)
5990 ++NumThreeIterations;
5992 ++NumFourOrMoreIterations;
5994 return MadeIRChange;
6002 OS, MapClassName2PassName);
6004 OS <<
"max-iterations=" << Options.MaxIterations <<
";";
6005 OS << (Options.VerifyFixpoint ?
"" :
"no-") <<
"verify-fixpoint";
6009char InstCombinePass::ID = 0;
6015 if (LRT.shouldSkip(&ID))
6028 auto *BFI = (PSI && PSI->hasProfileSummary()) ?
6033 BFI, BPI, PSI, Options)) {
6035 LRT.update(&ID,
false);
6041 LRT.update(&ID,
true);
6083 if (
auto *WrapperPass =
6085 BPI = &WrapperPass->getBPI();
6098 "Combine redundant instructions",
false,
false)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AMDGPU Register Bank Select
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This is the interface for LLVM's primary stateless and local alias analysis.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file provides an implementation of debug counters.
#define DEBUG_COUNTER(VARNAME, COUNTERNAME, DESC)
This file defines the DenseMap class.
static bool isSigned(unsigned int Opcode)
This is the interface for a simple mod/ref and alias analysis over globals.
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
This header defines various interfaces for pass management in LLVM.
This defines the Use class.
iv Induction Variable Users
static bool leftDistributesOverRight(Instruction::BinaryOps LOp, bool HasNUW, bool HasNSW, Intrinsic::ID ROp)
Return whether "X LOp (Y ROp Z)" is always equal to "(X LOp Y) ROp (X LOp Z)".
This file provides internal interfaces used to implement the InstCombine.
This file provides the primary interface to the instcombine pass.
static Value * simplifySwitchOnSelectUsingRanges(SwitchInst &SI, SelectInst *Select, bool IsTrueArm)
static bool isUsedWithinShuffleVector(Value *V)
static bool isNeverEqualToUnescapedAlloc(Value *V, const TargetLibraryInfo &TLI, Instruction *AI)
static bool shorter_filter(const Value *LHS, const Value *RHS)
static Instruction * combineConstantOffsets(GetElementPtrInst &GEP, InstCombinerImpl &IC)
Combine constant offsets separated by variable offsets.
static Instruction * foldSelectGEP(GetElementPtrInst &GEP, InstCombiner::BuilderTy &Builder)
Thread a GEP operation with constant indices through the constant true/false arms of a select.
static bool shouldMergeGEPs(GEPOperator &GEP, GEPOperator &Src)
static cl::opt< unsigned > MaxArraySize("instcombine-maxarray-size", cl::init(1024), cl::desc("Maximum array size considered when doing a combine"))
static cl::opt< unsigned > ShouldLowerDbgDeclare("instcombine-lower-dbg-declare", cl::Hidden, cl::init(true))
static bool hasNoSignedWrap(BinaryOperator &I)
static bool simplifyAssocCastAssoc(BinaryOperator *BinOp1, InstCombinerImpl &IC)
Combine constant operands of associative operations either before or after a cast to eliminate one of...
static bool combineInstructionsOverFunction(Function &F, InstructionWorklist &Worklist, AliasAnalysis *AA, AssumptionCache &AC, TargetLibraryInfo &TLI, TargetTransformInfo &TTI, DominatorTree &DT, OptimizationRemarkEmitter &ORE, BlockFrequencyInfo *BFI, BranchProbabilityInfo *BPI, ProfileSummaryInfo *PSI, const InstCombineOptions &Opts)
static Value * simplifyInstructionWithPHI(Instruction &I, PHINode *PN, Value *InValue, BasicBlock *InBB, const DataLayout &DL, const SimplifyQuery SQ)
static bool shouldCanonicalizeGEPToPtrAdd(GetElementPtrInst &GEP)
Return true if we should canonicalize the gep to an i8 ptradd.
static void ClearSubclassDataAfterReassociation(BinaryOperator &I)
Conservatively clears subclassOptionalData after a reassociation or commutation.
static Value * getIdentityValue(Instruction::BinaryOps Opcode, Value *V)
This function returns identity value for given opcode, which can be used to factor patterns like (X *...
static Value * foldFrexpOfSelect(ExtractValueInst &EV, IntrinsicInst *FrexpCall, SelectInst *SelectInst, InstCombiner::BuilderTy &Builder)
static std::optional< std::pair< Value *, Value * > > matchSymmetricPhiNodesPair(PHINode *LHS, PHINode *RHS)
static Value * foldOperationIntoSelectOperand(Instruction &I, SelectInst *SI, Value *NewOp, InstCombiner &IC)
static Instruction * canonicalizeGEPOfConstGEPI8(GetElementPtrInst &GEP, GEPOperator *Src, InstCombinerImpl &IC)
static Instruction * tryToMoveFreeBeforeNullTest(CallInst &FI, const DataLayout &DL)
Move the call to free before a NULL test.
static Value * simplifyOperationIntoSelectOperand(Instruction &I, SelectInst *SI, bool IsTrueArm)
static bool rightDistributesOverLeft(Instruction::BinaryOps LOp, Instruction::BinaryOps ROp)
Return whether "(X LOp Y) ROp Z" is always equal to "(X ROp Z) LOp (Y ROp Z)".
static Value * tryFactorization(BinaryOperator &I, const SimplifyQuery &SQ, InstCombiner::BuilderTy &Builder, Instruction::BinaryOps InnerOpcode, Value *A, Value *B, Value *C, Value *D)
This tries to simplify binary operations by factorizing out common terms (e.
static bool isRemovableWrite(CallBase &CB, Value *UsedV, const TargetLibraryInfo &TLI)
Given a call CB which uses an address UsedV, return true if we can prove the call's only possible eff...
static Instruction::BinaryOps getBinOpsForFactorization(Instruction::BinaryOps TopOpcode, BinaryOperator *Op, Value *&LHS, Value *&RHS, BinaryOperator *OtherOp)
This function predicates factorization using distributive laws.
static bool hasNoUnsignedWrap(BinaryOperator &I)
static bool SoleWriteToDeadLocal(Instruction *I, TargetLibraryInfo &TLI)
Check for case where the call writes to an otherwise dead alloca.
static cl::opt< unsigned > MaxSinkNumUsers("instcombine-max-sink-users", cl::init(32), cl::desc("Maximum number of undroppable users for instruction sinking"))
static Instruction * foldGEPOfPhi(GetElementPtrInst &GEP, PHINode *PN, IRBuilderBase &Builder)
static std::optional< ModRefInfo > isAllocSiteRemovable(Instruction *AI, SmallVectorImpl< WeakTrackingVH > &Users, const TargetLibraryInfo &TLI, bool KnowInit)
static bool isCatchAll(EHPersonality Personality, Constant *TypeInfo)
Return 'true' if the given typeinfo will match anything.
static cl::opt< bool > EnableCodeSinking("instcombine-code-sinking", cl::desc("Enable code sinking"), cl::init(true))
static bool maintainNoSignedWrap(BinaryOperator &I, Value *B, Value *C)
static GEPNoWrapFlags getMergedGEPNoWrapFlags(GEPOperator &GEP1, GEPOperator &GEP2)
Determine nowrap flags for (gep (gep p, x), y) to (gep p, (x + y)) transform.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
uint64_t IntrinsicInst * II
static bool IsSelect(MachineInstr &MI)
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
const SmallVectorImpl< MachineOperand > & Cond
static unsigned getNumElements(Type *Ty)
BaseType
A given derived pointer can have multiple base pointers through phi/selects.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
static SymbolRef::Type getType(const Symbol *Sym)
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
static const uint32_t IV[8]
bool isNoAliasScopeDeclDead(Instruction *Inst)
void analyse(Instruction *I)
A manager for alias analyses.
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object.
static constexpr roundingMode rmNearestTiesToEven
static LLVM_ABI unsigned int semanticsPrecision(const fltSemantics &)
Class for arbitrary precision integers.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
static LLVM_ABI void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
Dual division/remainder interface.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
static LLVM_ABI void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
LLVM_ABI APInt trunc(unsigned width) const
Truncate to new width.
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
unsigned getBitWidth() const
Return the number of bits in the APInt.
LLVM_ABI APInt sadd_ov(const APInt &RHS, bool &Overflow) const
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
LLVM_ABI APInt smul_ov(const APInt &RHS, bool &Overflow) const
bool isNonNegative() const
Determine if this APInt Value is non-negative (>= 0)
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
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.
LLVM_ABI APInt ssub_ov(const APInt &RHS, bool &Overflow) const
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
LLVM_ABI void setPreservesCFG()
This function should be called by the pass, iff they do not:
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
ArrayRef< T > take_front(size_t N=1) const
Return a copy of *this with only the first N elements.
size_t size() const
size - Get the array size.
Class to represent array types.
static LLVM_ABI ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
uint64_t getNumElements() const
Type * getElementType() const
A function analysis which provides an AssumptionCache.
An immutable pass that tracks lazily created AssumptionCache objects.
A cache of @llvm.assume calls within a function.
LLVM_ABI void registerAssumption(AssumeInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
Functions, function parameters, and return types can have attributes to indicate how they should be t...
LLVM_ABI uint64_t getDereferenceableBytes() const
Returns the number of dereferenceable bytes from the dereferenceable attribute.
bool isValid() const
Return true if the attribute is any kind of attribute.
Legacy wrapper pass to provide the BasicAAResult object.
LLVM Basic Block Representation.
iterator_range< const_phi_iterator > phis() const
Returns a range that iterates over the phis in the basic block.
LLVM_ABI const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
LLVM_ABI iterator_range< filter_iterator< BasicBlock::const_iterator, std::function< bool(const Instruction &)> > > instructionsWithoutDebug(bool SkipPseudoOp=true) const
Return a const iterator range over the instructions in the block, skipping any debug instructions.
LLVM_ABI InstListType::const_iterator getFirstNonPHIIt() const
Returns an iterator to the first instruction in this block that is not a PHINode instruction.
LLVM_ABI bool isEntryBlock() const
Return true if this is the entry block of the containing function.
LLVM_ABI const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
const Instruction & front() const
LLVM_ABI const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
InstListType::iterator iterator
Instruction iterators...
LLVM_ABI const_iterator getFirstNonPHIOrDbgOrAlloca() const
Returns an iterator to the first instruction in this block that is not a PHINode, a debug intrinsic,...
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...
static LLVM_ABI BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
BinaryOps getOpcode() const
static LLVM_ABI BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Analysis pass which computes BlockFrequencyInfo.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Conditional or Unconditional Branch instruction.
LLVM_ABI void swapSuccessors()
Swap the successors of this branch instruction.
bool isConditional() const
BasicBlock * getSuccessor(unsigned i) const
bool isUnconditional() const
Value * getCondition() const
Analysis pass which computes BranchProbabilityInfo.
Analysis providing branch probability information.
Represents analyses that only rely on functions' control flow.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
void setAttributes(AttributeList A)
Set the attributes for this call.
bool doesNotThrow() const
Determine if the call cannot unwind.
Value * getArgOperand(unsigned i) const
AttributeList getAttributes() const
Return the attributes for this call.
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static LLVM_ABI CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ ICMP_UGT
unsigned greater than
@ ICMP_ULT
unsigned less than
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
An abstraction over a floating-point predicate, and a pack of an integer predicate with samesign info...
ConstantArray - Constant Array Declarations.
static LLVM_ABI Constant * get(ArrayType *T, ArrayRef< Constant * > V)
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
static LLVM_ABI Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static LLVM_ABI Constant * getNot(Constant *C)
static LLVM_ABI Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static LLVM_ABI Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false, bool NSZ=false)
Return the identity constant for a binary opcode.
static LLVM_ABI Constant * getNeg(Constant *C, bool HasNSW=false)
This is the shared class of boolean and integer constants.
static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)
static LLVM_ABI ConstantInt * getFalse(LLVMContext &Context)
static LLVM_ABI ConstantInt * getBool(LLVMContext &Context, bool V)
This class represents a range of values.
LLVM_ABI bool getEquivalentICmp(CmpInst::Predicate &Pred, APInt &RHS) const
Set up Pred and RHS such that ConstantRange::makeExactICmpRegion(Pred, RHS) == *this.
static LLVM_ABI 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...
LLVM_ABI bool contains(const APInt &Val) const
Return true if the specified value is in the set.
static LLVM_ABI ConstantRange makeExactNoWrapRegion(Instruction::BinaryOps BinOp, const APInt &Other, unsigned NoWrapKind)
Produce the range that contains X if and only if "X BinOp Other" does not wrap.
Constant Vector Declarations.
static LLVM_ABI Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
static LLVM_ABI Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
static LLVM_ABI Constant * getIntegerValue(Type *Ty, const APInt &V)
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...
static LLVM_ABI Constant * replaceUndefsWith(Constant *C, Constant *Replacement)
Try to replace undefined constant C or undefined elements in C with Replacement.
static LLVM_ABI Constant * getAllOnesValue(Type *Ty)
const Constant * stripPointerCasts() const
static LLVM_ABI Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
LLVM_ABI Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
LLVM_ABI bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
static LLVM_ABI DIExpression * appendOpsToArg(const DIExpression *Expr, ArrayRef< uint64_t > Ops, unsigned ArgNo, bool StackValue=false)
Create a copy of Expr by appending the given list of Ops to each instance of the operand DW_OP_LLVM_a...
A parsed version of the target data layout string in and methods for querying it.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
static bool shouldExecute(unsigned CounterName)
Identifies a unique instance of a variable.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
iterator find(const_arg_type_t< KeyT > Val)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Analysis pass which computes a DominatorTree.
Legacy analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Utility class for floating point operations which can have information about relaxed accuracy require...
Convenience struct for specifying and reasoning about fast-math flags.
This class represents a freeze function that returns random concrete value if an operand is either a ...
FunctionPass class - This class is used to implement most global optimizations.
bool skipFunction(const Function &F) const
Optional passes call this function to check whether the pass should be skipped.
const BasicBlock & getEntryBlock() const
Represents flags for the getelementptr instruction/expression.
static GEPNoWrapFlags inBounds()
static GEPNoWrapFlags all()
static GEPNoWrapFlags noUnsignedWrap()
GEPNoWrapFlags intersectForReassociate(GEPNoWrapFlags Other) const
Given (gep (gep p, x), y), determine the nowrap flags for (gep (gep, p, y), x).
bool hasNoUnsignedWrap() const
GEPNoWrapFlags intersectForOffsetAdd(GEPNoWrapFlags Other) const
Given (gep (gep p, x), y), determine the nowrap flags for (gep p, x+y).
static GEPNoWrapFlags none()
GEPNoWrapFlags getNoWrapFlags() const
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
static LLVM_ABI Type * getTypeAtIndex(Type *Ty, Value *Idx)
Return the type of the element at the given index of an indexable type.
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static LLVM_ABI Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
static GetElementPtrInst * CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Create an "inbounds" getelementptr.
Legacy wrapper pass to provide the GlobalsAAResult object.
This instruction compares its operands according to the predicate given to the constructor.
CmpPredicate getCmpPredicate() const
static bool isEquality(Predicate P)
Return true if this predicate is either EQ or NE.
Common base class shared among various IRBuilders.
Value * CreatePtrAdd(Value *Ptr, Value *Offset, const Twine &Name="", GEPNoWrapFlags NW=GEPNoWrapFlags::none())
ConstantInt * getInt(const APInt &AI)
Get a constant integer value.
Provides an 'InsertHelper' that calls a user-provided callback after performing the default insertion...
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
This instruction inserts a struct field of array element value into an aggregate value.
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
LLVM_ABI InstCombinePass(InstCombineOptions Opts={})
LLVM_ABI void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
LLVM_ABI PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Instruction * FoldOpIntoSelect(Instruction &Op, SelectInst *SI, bool FoldWithMultiUse=false)
Given an instruction with a select as one operand and a constant as the other operand,...
Instruction * foldBinOpOfSelectAndCastOfSelectCondition(BinaryOperator &I)
Tries to simplify binops of select and cast of the select condition.
Instruction * foldBinOpIntoSelectOrPhi(BinaryOperator &I)
This is a convenience wrapper function for the above two functions.
bool SimplifyAssociativeOrCommutative(BinaryOperator &I)
Performs a few simplifications for operators which are associative or commutative.
Instruction * visitGEPOfGEP(GetElementPtrInst &GEP, GEPOperator *Src)
Value * foldUsingDistributiveLaws(BinaryOperator &I)
Tries to simplify binary operations which some other binary operation distributes over.
Instruction * foldBinOpShiftWithShift(BinaryOperator &I)
Instruction * visitUnreachableInst(UnreachableInst &I)
Instruction * foldOpIntoPhi(Instruction &I, PHINode *PN, bool AllowMultipleUses=false)
Given a binary operator, cast instruction, or select which has a PHI node as operand #0,...
void handleUnreachableFrom(Instruction *I, SmallVectorImpl< BasicBlock * > &Worklist)
Value * SimplifyDemandedVectorElts(Value *V, APInt DemandedElts, APInt &PoisonElts, unsigned Depth=0, bool AllowMultipleUsers=false) override
The specified value produces a vector with any number of elements.
Instruction * visitFreeze(FreezeInst &I)
void handlePotentiallyDeadBlocks(SmallVectorImpl< BasicBlock * > &Worklist)
bool prepareWorklist(Function &F)
Perform early cleanup and prepare the InstCombine worklist.
Instruction * visitFree(CallInst &FI, Value *FreedOp)
Instruction * visitExtractValueInst(ExtractValueInst &EV)
void handlePotentiallyDeadSuccessors(BasicBlock *BB, BasicBlock *LiveSucc)
Instruction * visitUnconditionalBranchInst(BranchInst &BI)
Instruction * foldBinopWithRecurrence(BinaryOperator &BO)
Try to fold binary operators whose operands are simple interleaved recurrences to a single recurrence...
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Instruction * visitLandingPadInst(LandingPadInst &LI)
Instruction * visitReturnInst(ReturnInst &RI)
Instruction * visitSwitchInst(SwitchInst &SI)
Instruction * foldBinopWithPhiOperands(BinaryOperator &BO)
For a binary operator with 2 phi operands, try to hoist the binary operation before the phi.
bool mergeStoreIntoSuccessor(StoreInst &SI)
Try to transform: if () { *P = v1; } else { *P = v2 } or: *P = v1; if () { *P = v2; }...
Instruction * tryFoldInstWithCtpopWithNot(Instruction *I)
void CreateNonTerminatorUnreachable(Instruction *InsertAt)
Create and insert the idiom we use to indicate a block is unreachable without having to rewrite the C...
Value * pushFreezeToPreventPoisonFromPropagating(FreezeInst &FI)
bool run()
Run the combiner over the entire worklist until it is empty.
Instruction * foldVectorBinop(BinaryOperator &Inst)
Canonicalize the position of binops relative to shufflevector.
bool removeInstructionsBeforeUnreachable(Instruction &I)
Value * SimplifySelectsFeedingBinaryOp(BinaryOperator &I, Value *LHS, Value *RHS)
void tryToSinkInstructionDbgVariableRecords(Instruction *I, BasicBlock::iterator InsertPos, BasicBlock *SrcBlock, BasicBlock *DestBlock, SmallVectorImpl< DbgVariableRecord * > &DPUsers)
void addDeadEdge(BasicBlock *From, BasicBlock *To, SmallVectorImpl< BasicBlock * > &Worklist)
Constant * unshuffleConstant(ArrayRef< int > ShMask, Constant *C, VectorType *NewCTy)
Find a constant NewC that has property: shuffle(NewC, ShMask) = C Returns nullptr if such a constant ...
Instruction * visitAllocSite(Instruction &FI)
Instruction * visitGetElementPtrInst(GetElementPtrInst &GEP)
Instruction * visitBranchInst(BranchInst &BI)
Value * tryFactorizationFolds(BinaryOperator &I)
This tries to simplify binary operations by factorizing out common terms (e.
Instruction * foldFreezeIntoRecurrence(FreezeInst &I, PHINode *PN)
Value * SimplifyDemandedUseFPClass(Value *V, FPClassTest DemandedMask, KnownFPClass &Known, Instruction *CxtI, unsigned Depth=0)
Attempts to replace V with a simpler value based on the demanded floating-point classes.
bool tryToSinkInstruction(Instruction *I, BasicBlock *DestBlock)
Try to move the specified instruction from its current block into the beginning of DestBlock,...
bool freezeOtherUses(FreezeInst &FI)
void freelyInvertAllUsersOf(Value *V, Value *IgnoredUser=nullptr)
Freely adapt every user of V as-if V was changed to !V.
The core instruction combiner logic.
const DataLayout & getDataLayout() const
IRBuilder< TargetFolder, IRBuilderCallbackInserter > BuilderTy
An IRBuilder that automatically inserts new instructions into the worklist.
bool isFreeToInvert(Value *V, bool WillInvertAllUses, bool &DoesConsume)
Return true if the specified value is free to invert (apply ~ to).
static unsigned getComplexity(Value *V)
Assign a complexity or rank value to LLVM Values.
unsigned ComputeNumSignBits(const Value *Op, const Instruction *CxtI=nullptr, unsigned Depth=0) const
Instruction * InsertNewInstBefore(Instruction *New, BasicBlock::iterator Old)
Inserts an instruction New before instruction Old.
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
uint64_t MaxArraySizeForCombine
Maximum size of array considered when transforming.
static bool shouldAvoidAbsorbingNotIntoSelect(const SelectInst &SI)
void replaceUse(Use &U, Value *NewValue)
Replace use and add the previously used value to the worklist.
static bool isCanonicalPredicate(CmpPredicate Pred)
Predicate canonicalization reduces the number of patterns that need to be matched by other transforms...
InstructionWorklist & Worklist
A worklist of the instructions that need to be simplified.
Instruction * InsertNewInstWith(Instruction *New, BasicBlock::iterator Old)
Same as InsertNewInstBefore, but also sets the debug loc.
BranchProbabilityInfo * BPI
ReversePostOrderTraversal< BasicBlock * > & RPOT
void computeKnownBits(const Value *V, KnownBits &Known, const Instruction *CxtI, unsigned Depth=0) const
std::optional< Instruction * > targetInstCombineIntrinsic(IntrinsicInst &II)
void addToWorklist(Instruction *I)
Value * getFreelyInvertedImpl(Value *V, bool WillInvertAllUses, BuilderTy *Builder, bool &DoesConsume, unsigned Depth)
Return nonnull value if V is free to invert under the condition of WillInvertAllUses.
SmallDenseSet< std::pair< const BasicBlock *, const BasicBlock * >, 8 > BackEdges
Backedges, used to avoid pushing instructions across backedges in cases where this may result in infi...
std::optional< Value * > targetSimplifyDemandedVectorEltsIntrinsic(IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts, APInt &UndefElts2, APInt &UndefElts3, std::function< void(Instruction *, unsigned, APInt, APInt &)> SimplifyAndSetOp)
Instruction * replaceOperand(Instruction &I, unsigned OpNum, Value *V)
Replace operand of instruction and add old operand to the worklist.
static Constant * getSafeVectorConstantForBinop(BinaryOperator::BinaryOps Opcode, Constant *In, bool IsRHSConstant)
Some binary operators require special handling to avoid poison and undefined behavior.
SmallDenseSet< std::pair< BasicBlock *, BasicBlock * >, 8 > DeadEdges
Edges that are known to never be taken.
std::optional< Value * > targetSimplifyDemandedUseBitsIntrinsic(IntrinsicInst &II, APInt DemandedMask, KnownBits &Known, bool &KnownBitsComputed)
bool isValidAddrSpaceCast(unsigned FromAS, unsigned ToAS) const
Value * getFreelyInverted(Value *V, bool WillInvertAllUses, BuilderTy *Builder, bool &DoesConsume)
bool isBackEdge(const BasicBlock *From, const BasicBlock *To)
void visit(Iterator Start, Iterator End)
The legacy pass manager's instcombine pass.
InstructionCombiningPass()
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
InstructionWorklist - This is the worklist management logic for InstCombine and other simplification ...
void add(Instruction *I)
Add instruction to the worklist.
LLVM_ABI void dropUBImplyingAttrsAndMetadata(ArrayRef< unsigned > Keep={})
Drop any attributes or metadata that can cause immediate undefined behavior.
static bool isBitwiseLogicOp(unsigned Opcode)
Determine if the Opcode is and/or/xor.
LLVM_ABI void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
LLVM_ABI const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
LLVM_ABI void setAAMetadata(const AAMDNodes &N)
Sets the AA metadata on this instruction from the AAMDNodes structure.
LLVM_ABI bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
LLVM_ABI bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
LLVM_ABI void moveBefore(InstListType::iterator InsertPos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
LLVM_ABI void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
LLVM_ABI const Function * getFunction() const
Return the function this instruction belongs to.
bool isTerminator() const
LLVM_ABI FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
LLVM_ABI bool willReturn() const LLVM_READONLY
Return true if the instruction will return (unwinding is considered as a form of returning control fl...
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
bool isBitwiseLogicOp() const
Return true if this is and/or/xor.
LLVM_ABI void dropPoisonGeneratingFlags()
Drops flags that may cause this instruction to evaluate to poison despite having non-poison inputs.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Class to represent integer types.
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
A wrapper class for inspecting calls to intrinsic functions.
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
The landingpad instruction holds all of the information necessary to generate correct exception handl...
bool isCleanup() const
Return 'true' if this landingpad instruction is a cleanup.
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
static LLVM_ABI LandingPadInst * Create(Type *RetTy, unsigned NumReservedClauses, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedClauses is a hint for the number of incoming clauses that this landingpad w...
LLVM_ABI void addClause(Constant *ClauseVal)
Add a catch or filter clause to the landing pad.
bool isCatch(unsigned Idx) const
Return 'true' if the clause and index Idx is a catch clause.
bool isFilter(unsigned Idx) const
Return 'true' if the clause and index Idx is a filter clause.
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
void setCleanup(bool V)
Indicate that this landingpad instruction is a cleanup.
A function/module analysis which provides an empty LastRunTrackingInfo.
This is an alternative analysis pass to BlockFrequencyInfoWrapperPass.
static void getLazyBFIAnalysisUsage(AnalysisUsage &AU)
Helper for client passes to set up the analysis usage on behalf of this pass.
An instruction for reading from memory.
Value * getPointerOperand()
bool isVolatile() const
Return true if this is a load from a volatile memory location.
const MDOperand & getOperand(unsigned I) const
unsigned getNumOperands() const
Return number of MDNode operands.
Tracking metadata reference owned by Metadata.
This is the common base class for memset/memcpy/memmove.
static LLVM_ABI MemoryLocation getForDest(const MemIntrinsic *MI)
Return a location representing the destination of a memory set or transfer.
static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)
Returns the comparison predicate underlying the intrinsic.
A Module instance is used to store all the information related to an LLVM module.
MDNode * getScopeList() const
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property.
bool hasNoUnsignedWrap() const
Test whether this operation is known to never undergo unsigned overflow, aka the nuw property.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
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.
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
static LLVM_ABI PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
AnalysisType & getAnalysis() const
getAnalysis<AnalysisType>() - This function is used by subclasses to get to the analysis information ...
AnalysisType * getAnalysisIfAvailable() const
getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to get analysis information tha...
In order to facilitate speculative execution, many instructions do not invoke immediate undefined beh...
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
PreservedAnalyses & preserveSet()
Mark an analysis set as preserved.
PreservedAnalyses & preserve()
Mark an analysis as preserved.
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
Analysis providing profile information.
bool hasProfileSummary() const
Returns true if profile summary is available.
A global registry used in conjunction with static constructors to make pluggable components (like tar...
Return a value (possibly void), from a function.
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, InsertPosition InsertBefore=nullptr)
This class represents the LLVM 'select' instruction.
const Value * getFalseValue() const
const Value * getCondition() const
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, const Instruction *MDFrom=nullptr)
const Value * getTrueValue() const
bool insert(const value_type &X)
Insert a new element into the SetVector.
This instruction constructs a fixed permutation of two input vectors.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
bool contains(ConstPtrType Ptr) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
A SetVector that performs no allocations if smaller than a certain size.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void reserve(size_type N)
iterator erase(const_iterator CI)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
typename SuperClass::iterator iterator
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
StringRef - Represent a constant reference to a string, i.e.
TargetFolder - Create constants with target dependent folding.
Analysis pass providing the TargetTransformInfo.
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
bool has(LibFunc F) const
Tests whether a library function is available.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
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.
LLVM_ABI bool isScalableTy(SmallPtrSetImpl< const Type * > &Visited) const
Return true if this is a type whose size is a known multiple of vscale.
bool isPointerTy() const
True if this is an instance of PointerType.
LLVM_ABI unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
static LLVM_ABI IntegerType * getInt8Ty(LLVMContext &C)
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
bool isStructTy() const
True if this is an instance of StructType.
LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
LLVM_ABI unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static LLVM_ABI IntegerType * getInt1Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
LLVM_ABI const fltSemantics & getFltSemantics() const
static LLVM_ABI UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
This function has undefined behavior.
A Use represents the edge between a Value definition and its users.
LLVM_ABI bool replaceUsesOfWith(Value *From, Value *To)
Replace uses of one Value with another.
const Use & getOperandUse(unsigned i) const
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
LLVM_ABI bool isDroppable() const
A droppable user is a user for which uses can be dropped without affecting correctness and should be ...
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const
This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...
LLVM_ABI bool hasOneUser() const
Return true if there is exactly one user of this value.
bool hasOneUse() const
Return true if there is exactly one use of this value.
iterator_range< user_iterator > users()
bool hasUseList() const
Check if this Value has a use-list.
LLVM_ABI bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
LLVM_ABI const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
LLVM_ABI LLVMContext & getContext() const
All values hold a context through their type.
LLVM_ABI uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull, bool &CanBeFreed) const
Returns the number of bytes known to be dereferenceable for the pointer value.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
LLVM_ABI void takeName(Value *V)
Transfer the name from V to this value.
Base class of all SIMD vector types.
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
static LLVM_ABI VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Value handle that is nullable, but tries to track the Value.
An efficient, type-erasing, non-owning reference to a callable.
Type * getIndexedType() const
const ParentTy * getParent() const
reverse_self_iterator getReverseIterator()
self_iterator getIterator()
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an std::string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Abstract Attribute helper functions.
@ C
The default llvm calling convention, compatible with C.
LLVM_ABI Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > Tys={})
Look up the Function declaration of the intrinsic id in the Module M.
BinaryOp_match< SpecificConstantMatch, SrcTy, TargetOpcode::G_SUB > m_Neg(const SrcTy &&Src)
Matches a register negated by a G_SUB.
BinaryOp_match< SrcTy, SpecificConstantMatch, TargetOpcode::G_XOR, true > m_Not(const SrcTy &&Src)
Matches a register not-ed by a G_XOR.
OneUse_match< SubPat > m_OneUse(const SubPat &SP)
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)
PtrAdd_match< PointerOpTy, OffsetOpTy > m_PtrAdd(const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp)
Matches GEP with i8 source element type.
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
CmpClass_match< LHS, RHS, FCmpInst > m_FCmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
OneOps_match< OpTy, Instruction::Freeze > m_Freeze(const OpTy &Op)
Matches FreezeInst.
ap_match< APInt > m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
CastInst_match< OpTy, TruncInst > m_Trunc(const OpTy &Op)
Matches Trunc.
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
br_match m_UnconditionalBr(BasicBlock *&Succ)
ap_match< APInt > m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
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.
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
DisjointOr_match< LHS, RHS > m_DisjointOr(const LHS &L, const RHS &R)
constantexpr_match m_ConstantExpr()
Match a constant expression or a constant that contains a constant expression.
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
ap_match< APFloat > m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
IntrinsicID_match m_Intrinsic()
Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
match_combine_and< LTy, RTy > m_CombineAnd(const LTy &L, const RTy &R)
Combine two pattern matchers matching L && R.
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
NNegZExt_match< OpTy > m_NNegZExt(const OpTy &Op)
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
ThreeOps_match< decltype(m_Value()), LHS, RHS, Instruction::Select, true > m_c_Select(const LHS &L, const RHS &R)
Match Select(C, LHS, RHS) or Select(C, RHS, LHS)
SpecificCmpClass_match< LHS, RHS, ICmpInst > m_SpecificICmp(CmpPredicate MatchPred, const LHS &L, const RHS &R)
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
match_immconstant_ty m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > > m_AddLike(const LHS &L, const RHS &R)
Match either "add" or "or disjoint".
CastInst_match< OpTy, UIToFPInst > m_UIToFP(const OpTy &Op)
CastOperator_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
match_combine_or< CastInst_match< OpTy, SExtInst >, NNegZExt_match< OpTy > > m_SExtLike(const OpTy &Op)
Match either "sext" or "zext nneg".
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > m_NSWAddLike(const LHS &L, const RHS &R)
Match either "add nsw" or "or disjoint".
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.
CastInst_match< OpTy, SIToFPInst > m_SIToFP(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, ICmpInst > m_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
cstfp_pred_ty< is_non_zero_fp > m_NonZeroFP()
Match a floating-point non-zero.
m_Intrinsic_Ty< Opnd0 >::Ty m_VecReverse(const Opnd0 &Op0)
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > > > m_MaxOrMin(const LHS &L, const RHS &R)
auto m_Undef()
Match an arbitrary undef constant.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > m_NUWAddLike(const LHS &L, const RHS &R)
Match either "add nuw" or "or disjoint".
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(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.
initializer< Ty > init(const Ty &Val)
friend class Instruction
Iterator for Instructions in a `BasicBlock.
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
LLVM_ABI Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
detail::zippy< detail::zip_shortest, T, U, Args... > zip(T &&t, U &&u, Args &&...args)
zip iterator for two or more iteratable types.
FunctionAddr VTableAddr Value
void stable_sort(R &&Range)
LLVM_ABI void initializeInstructionCombiningPassPass(PassRegistry &)
LLVM_ABI unsigned removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB)
Remove all instructions from a basic block other than its terminator and any present EH pad instructi...
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI Value * simplifyGEPInst(Type *SrcTy, Value *Ptr, ArrayRef< Value * > Indices, GEPNoWrapFlags NW, const SimplifyQuery &Q)
Given operands for a GetElementPtrInst, fold the result or return null.
LLVM_ABI Constant * getInitialValueOfAllocation(const Value *V, const TargetLibraryInfo *TLI, Type *Ty)
If this is a call to an allocation function that initializes memory to a fixed value,...
bool succ_empty(const Instruction *I)
LLVM_ABI Value * simplifyFreezeInst(Value *Op, const SimplifyQuery &Q)
Given an operand for a Freeze, see if we can fold the result.
LLVM_ABI FunctionPass * createInstructionCombiningPass()
LLVM_ABI void findDbgValues(Value *V, SmallVectorImpl< DbgVariableRecord * > &DbgVariableRecords)
Finds the dbg.values describing a value.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI void salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI)
Assuming the instruction MI is going to be deleted, attempt to salvage debug users of MI by writing t...
auto successors(const MachineBasicBlock *BB)
LLVM_ABI Constant * ConstantFoldInstruction(const Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstruction - Try to constant fold the specified instruction.
LLVM_ABI bool isRemovableAlloc(const CallBase *V, const TargetLibraryInfo *TLI)
Return true if this is a call to an allocation function that does not have side effects that we are r...
LLVM_ABI std::optional< StringRef > getAllocationFamily(const Value *I, const TargetLibraryInfo *TLI)
If a function is part of an allocation family (e.g.
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
LLVM_ABI Value * lowerObjectSizeCall(IntrinsicInst *ObjectSize, const DataLayout &DL, const TargetLibraryInfo *TLI, bool MustSucceed)
Try to turn a call to @llvm.objectsize into an integer value of the given Type.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
LLVM_ABI Value * simplifyInstructionWithOperands(Instruction *I, ArrayRef< Value * > NewOps, const SimplifyQuery &Q)
Like simplifyInstruction but the operands of I are replaced with NewOps.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
LLVM_ABI 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.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
gep_type_iterator gep_type_end(const User *GEP)
LLVM_ABI Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
LLVM_ABI Value * getReallocatedOperand(const CallBase *CB)
If this is a call to a realloc function, return the reallocated operand.
APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM)
Equivalent of C standard library function.
LLVM_ABI 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,...
LLVM_ABI bool handleUnreachableTerminator(Instruction *I, SmallVectorImpl< Value * > &PoisonedValues)
If a terminator in an unreachable basic block has an operand of type Instruction, transform it into p...
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
LLVM_ABI bool matchSimpleRecurrence(const PHINode *P, BinaryOperator *&BO, Value *&Start, Value *&Step)
Attempt to match a simple first order recurrence cycle of the form: iv = phi Ty [Start,...
LLVM_ABI Value * simplifyAddInst(Value *LHS, Value *RHS, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for an Add, fold the result or return null.
LLVM_ABI Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
auto dyn_cast_or_null(const Y &Val)
constexpr bool has_single_bit(T Value) noexcept
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction will return.
LLVM_ABI 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...
LLVM_ABI Value * emitGEPOffset(IRBuilderBase *Builder, const DataLayout &DL, User *GEP, bool NoAssumptions=false)
Given a getelementptr instruction/constantexpr, emit the code necessary to compute the offset from th...
constexpr unsigned MaxAnalysisRecursionDepth
auto reverse(ContainerTy &&C)
bool isModSet(const ModRefInfo MRI)
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
LLVM_ABI bool LowerDbgDeclare(Function &F)
Lowers dbg.declare records into appropriate set of dbg.value records.
LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
generic_gep_type_iterator<> gep_type_iterator
LLVM_ABI void ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, StoreInst *SI, DIBuilder &Builder)
Inserts a dbg.value record before a store to an alloca'd value that has an associated dbg....
LLVM_ABI void salvageDebugInfoForDbgValues(Instruction &I, ArrayRef< DbgVariableRecord * > DPInsns)
Implementation of salvageDebugInfo, applying only to instructions in Insns, rather than all debug use...
LLVM_ABI Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
LLVM_ABI bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...
LLVM_ABI EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI Value * simplifyExtractValueInst(Value *Agg, ArrayRef< unsigned > Idxs, const SimplifyQuery &Q)
Given operands for an ExtractValueInst, fold the result or return null.
LLVM_ABI Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
LLVM_ABI bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT)
Point debug users of From to To or salvage them.
LLVM_ABI 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
auto drop_end(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the last N elements excluded.
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
@ Ref
The access may reference the value stored in memory.
@ ModRef
The access may reference and may modify the value stored in memory.
@ Mod
The access may modify the value stored in memory.
@ NoModRef
The access neither references nor modifies the value stored in memory.
LLVM_ABI Value * simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a BinaryOperator, fold the result or return null.
@ Sub
Subtraction of integers.
DWARFExpression::Operation Op
bool isSafeToSpeculativelyExecuteWithVariableReplaced(const Instruction *I, bool IgnoreUBImplyingAttrs=true)
Don't use information from its non-constant operands.
LLVM_ABI 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.
ArrayRef(const T &OneElt) -> ArrayRef< T >
LLVM_ABI Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
constexpr unsigned BitWidth
LLVM_ABI bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
LLVM_ABI Constant * getLosslessInvCast(Constant *C, Type *InvCastTo, unsigned CastOp, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)
Try to cast C to InvC losslessly, satisfying CastOp(InvC) equals C, or CastOp(InvC) is a refined valu...
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
gep_type_iterator gep_type_begin(const User *GEP)
auto predecessors(const MachineBasicBlock *BB)
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
cl::opt< bool > ProfcheckDisableMetadataFixes("profcheck-disable-metadata-fixes", cl::Hidden, cl::init(false), cl::desc("Disable metadata propagation fixes discovered through Issue #147390"))
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
bool equal(L &&LRange, R &&RRange)
Wrapper function around std::equal to detect if pair-wise elements between two ranges are the same.
LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
AAResults AliasAnalysis
Temporary typedef for legacy code that uses a generic AliasAnalysis pointer or reference.
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DbgVariableRecord types only and downcast.
LLVM_ABI void initializeInstCombine(PassRegistry &)
Initialize all passes linked into the InstCombine library.
LLVM_ABI void findDbgUsers(Value *V, SmallVectorImpl< DbgVariableRecord * > &DbgVariableRecords)
Finds the debug info records describing a value.
LLVM_ABI Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
bool isRefSet(const ModRefInfo MRI)
LLVM_ABI 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.
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
unsigned countMinLeadingOnes() const
Returns the minimum number of leading one bits.
unsigned getBitWidth() const
Get the bit width of this value.
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
A CRTP mix-in to automatically provide informational APIs needed for passes.
SimplifyQuery getWithInstruction(const Instruction *I) const