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,
1781 bool SimplifyBothArms) {
1783 if (!
SI->hasOneUse() && !FoldWithMultiUse)
1786 Value *TV =
SI->getTrueValue();
1787 Value *FV =
SI->getFalseValue();
1790 if (
SI->getType()->isIntOrIntVectorTy(1))
1796 for (
Value *IntrinOp :
Op.operands())
1798 for (
Value *PhiOp : PN->operands())
1810 if (CI->hasOneUse()) {
1811 Value *Op0 = CI->getOperand(0), *Op1 = CI->getOperand(1);
1812 if (((TV == Op0 && FV == Op1) || (FV == Op0 && TV == Op1)) &&
1813 !CI->isCommutative())
1822 if (!NewTV && !NewFV)
1825 if (SimplifyBothArms && !(NewTV && NewFV))
1845 Ops.push_back(InValue);
1877 bool AllowMultipleUses) {
1879 if (NumPHIValues == 0)
1886 bool IdenticalUsers =
false;
1887 if (!AllowMultipleUses && !OneUse) {
1891 if (UI != &
I && !
I.isIdenticalTo(UI))
1895 IdenticalUsers =
true;
1925 bool SeenNonSimplifiedInVal =
false;
1926 for (
unsigned i = 0; i != NumPHIValues; ++i) {
1937 auto WillFold = [&]() {
1942 const APInt *Ignored;
1963 if (!OneUse && !IdenticalUsers)
1966 if (SeenNonSimplifiedInVal)
1968 SeenNonSimplifiedInVal =
true;
1992 for (
auto OpIndex : OpsToMoveUseToIncomingBB) {
2003 U = U->DoPHITranslation(PN->
getParent(), OpBB);
2006 Clones.
insert({OpBB, Clone});
2011 NewPhiValues[
OpIndex] = Clone;
2020 for (
unsigned i = 0; i != NumPHIValues; ++i)
2023 if (IdenticalUsers) {
2054 BO0->getOpcode() !=
Opc || BO1->getOpcode() !=
Opc ||
2055 !BO0->isAssociative() || !BO1->isAssociative() ||
2056 BO0->getParent() != BO1->getParent())
2060 "Expected commutative instructions!");
2064 Value *Start0, *Step0, *Start1, *Step1;
2071 "Expected PHIs with two incoming values!");
2078 if (!Init0 || !Init1 || !C0 || !C1)
2093 if (
Opc == Instruction::FAdd ||
Opc == Instruction::FMul) {
2097 NewBO->setFastMathFlags(Intersect);
2101 Flags.AllKnownNonZero =
false;
2102 Flags.mergeFlags(*BO0);
2103 Flags.mergeFlags(*BO1);
2104 Flags.mergeFlags(BO);
2105 Flags.applyFlags(*NewBO);
2107 NewBO->takeName(&BO);
2117 "Invalid incoming block!");
2118 NewPN->addIncoming(
Init, BB);
2119 }
else if (V == BO0) {
2124 "Invalid incoming block!");
2125 NewPN->addIncoming(NewBO, BB);
2131 <<
"\n with " << *PN1 <<
"\n " << *BO1
2158 if (!Phi0 || !Phi1 || !Phi0->hasOneUse() || !Phi1->hasOneUse() ||
2159 Phi0->getNumOperands() != Phi1->getNumOperands())
2163 if (BO.
getParent() != Phi0->getParent() ||
2180 auto CanFoldIncomingValuePair = [&](std::tuple<Use &, Use &>
T) {
2181 auto &Phi0Use = std::get<0>(
T);
2182 auto &Phi1Use = std::get<1>(
T);
2183 if (Phi0->getIncomingBlock(Phi0Use) != Phi1->getIncomingBlock(Phi1Use))
2185 Value *Phi0UseV = Phi0Use.get();
2186 Value *Phi1UseV = Phi1Use.get();
2189 else if (Phi1UseV ==
C)
2196 if (
all_of(
zip(Phi0->operands(), Phi1->operands()),
2197 CanFoldIncomingValuePair)) {
2200 assert(NewIncomingValues.
size() == Phi0->getNumOperands() &&
2201 "The number of collected incoming values should equal the number "
2202 "of the original PHINode operands!");
2203 for (
unsigned I = 0;
I < Phi0->getNumOperands();
I++)
2204 NewPhi->
addIncoming(NewIncomingValues[
I], Phi0->getIncomingBlock(
I));
2209 if (Phi0->getNumOperands() != 2 || Phi1->getNumOperands() != 2)
2216 ConstBB = Phi0->getIncomingBlock(0);
2217 OtherBB = Phi0->getIncomingBlock(1);
2219 ConstBB = Phi0->getIncomingBlock(1);
2220 OtherBB = Phi0->getIncomingBlock(0);
2231 if (!PredBlockBranch || PredBlockBranch->isConditional() ||
2232 !
DT.isReachableFromEntry(OtherBB))
2238 for (
auto BBIter = BO.
getParent()->begin(); &*BBIter != &BO; ++BBIter)
2249 Builder.SetInsertPoint(PredBlockBranch);
2251 Phi0->getIncomingValueForBlock(OtherBB),
2252 Phi1->getIncomingValueForBlock(OtherBB));
2254 NotFoldedNewBO->copyIRFlags(&BO);
2281 if (
GEP.hasAllZeroIndices() && !Src.hasAllZeroIndices() &&
2310 for (
unsigned I = 0;
I < NumElts; ++
I) {
2312 if (ShMask[
I] >= 0) {
2313 assert(ShMask[
I] < (
int)NumElts &&
"Not expecting narrowing shuffle");
2324 NewVecC[ShMask[
I]] = CElt;
2344 Value *L0, *L1, *R0, *R1;
2348 LHS->hasOneUse() && RHS->hasOneUse() &&
2371 M, Intrinsic::vector_reverse, V->getType());
2382 (LHS->hasOneUse() || RHS->hasOneUse() ||
2383 (LHS == RHS && LHS->hasNUses(2))))
2384 return createBinOpReverse(V1, V2);
2388 return createBinOpReverse(V1, RHS);
2392 return createBinOpReverse(LHS, V2);
2403 M, Intrinsic::experimental_vp_reverse, V->getType());
2413 (LHS->hasOneUse() || RHS->hasOneUse() ||
2414 (LHS == RHS && LHS->hasNUses(2))))
2415 return createBinOpVPReverse(V1, V2, EVL);
2419 return createBinOpVPReverse(V1, RHS, EVL);
2425 return createBinOpVPReverse(LHS, V2, EVL);
2445 (LHS->hasOneUse() || RHS->hasOneUse() || LHS == RHS)) {
2447 return createBinOpShuffle(V1, V2, Mask);
2462 if (LShuf->isSelect() &&
2464 RShuf->isSelect() &&
2486 "Shuffle should not change scalar type");
2498 Value *NewLHS = ConstOp1 ? V1 : NewC;
2499 Value *NewRHS = ConstOp1 ? NewC : V1;
2500 return createBinOpShuffle(NewLHS, NewRHS, Mask);
2535 Value *NewSplat =
Builder.CreateShuffleVector(NewBO, NewMask);
2541 R->copyFastMathFlags(&Inst);
2545 NewInstBO->copyIRFlags(R);
2575 (Op0->
hasOneUse() || Op1->hasOneUse()))) {
2601 NewBinOp->setHasNoSignedWrap();
2603 NewBinOp->setHasNoUnsignedWrap();
2619 if (!
GEP.hasAllConstantIndices())
2635 Type *Ty =
GEP.getSourceElementType();
2636 Value *NewTrueC = Builder.CreateGEP(Ty, TrueC, IndexC,
"", NW);
2637 Value *NewFalseC = Builder.CreateGEP(Ty, FalseC, IndexC,
"", NW);
2647 if (
GEP.getNumIndices() != 1)
2657 unsigned IndexSizeInBits =
DL.getIndexTypeSizeInBits(PtrTy);
2668 if (NewOffset.
isZero() ||
2669 (Src->hasOneUse() &&
GEP.getOperand(1)->hasOneUse())) {
2671 if (
GEP.hasNoUnsignedWrap() &&
2691 if (!
GEP.hasAllConstantIndices())
2702 if (InnerGEP->hasAllConstantIndices())
2705 if (!InnerGEP->hasOneUse())
2714 if (Skipped.
empty())
2719 if (!InnerGEP->hasOneUse())
2724 if (InnerGEP->getType() != Ty)
2730 !InnerGEP->accumulateConstantOffset(
DL,
Offset))
2735 SkippedGEP->setNoWrapFlags(NW);
2757 if (Src->getResultElementType() !=
GEP.getSourceElementType())
2761 bool EndsWithSequential =
false;
2764 EndsWithSequential =
I.isSequential();
2765 if (!EndsWithSequential)
2770 Value *SO1 = Src->getOperand(Src->getNumOperands() - 1);
2788 Indices.
append(Src->op_begin() + 1, Src->op_end() - 1);
2793 unsigned NumNonZeroIndices =
count_if(Indices, [](
Value *Idx) {
2795 return !
C || !
C->isNullValue();
2797 if (NumNonZeroIndices > 1)
2802 Src->getSourceElementType(), Src->getOperand(0), Indices,
"",
2808 bool &DoesConsume,
unsigned Depth) {
2809 static Value *
const NonNull =
reinterpret_cast<Value *
>(uintptr_t(1));
2827 if (!WillInvertAllUses)
2834 return Builder->CreateCmp(
I->getInversePredicate(),
I->getOperand(0),
2843 DoesConsume,
Depth))
2846 DoesConsume,
Depth))
2855 DoesConsume,
Depth))
2858 DoesConsume,
Depth))
2867 DoesConsume,
Depth))
2876 DoesConsume,
Depth))
2888 bool LocalDoesConsume = DoesConsume;
2890 LocalDoesConsume,
Depth))
2893 LocalDoesConsume,
Depth)) {
2894 DoesConsume = LocalDoesConsume;
2897 DoesConsume,
Depth);
2898 assert(NotB !=
nullptr &&
2899 "Unable to build inverted value for known freely invertable op");
2901 return Builder->CreateBinaryIntrinsic(
2910 bool LocalDoesConsume = DoesConsume;
2912 for (
Use &U : PN->operands()) {
2913 BasicBlock *IncomingBlock = PN->getIncomingBlock(U);
2917 if (NewIncomingVal ==
nullptr)
2920 if (NewIncomingVal == V)
2923 IncomingValues.
emplace_back(NewIncomingVal, IncomingBlock);
2926 DoesConsume = LocalDoesConsume;
2931 Builder->CreatePHI(PN->getType(), PN->getNumIncomingValues());
2932 for (
auto [Val, Pred] : IncomingValues)
2941 DoesConsume,
Depth))
2942 return Builder ?
Builder->CreateSExt(AV, V->getType()) : NonNull;
2948 DoesConsume,
Depth))
2949 return Builder ?
Builder->CreateTrunc(AV, V->getType()) : NonNull;
2957 bool IsLogical,
Value *
A,
2959 bool LocalDoesConsume = DoesConsume;
2961 LocalDoesConsume,
Depth))
2964 LocalDoesConsume,
Depth)) {
2966 LocalDoesConsume,
Depth);
2967 DoesConsume = LocalDoesConsume;
2969 return Builder ?
Builder->CreateLogicalOp(Opcode, NotA, NotB) : NonNull;
2970 return Builder ?
Builder->CreateBinOp(Opcode, NotA, NotB) : NonNull;
2977 return TryInvertAndOrUsingDeMorgan(Instruction::And,
false,
A,
2981 return TryInvertAndOrUsingDeMorgan(Instruction::Or,
false,
A,
2985 return TryInvertAndOrUsingDeMorgan(Instruction::And,
true,
A,
2989 return TryInvertAndOrUsingDeMorgan(Instruction::Or,
true,
A,
2998 Type *GEPEltType =
GEP.getSourceElementType();
3009 if (
GEP.getNumIndices() == 1 &&
3018 return PtrOpGep && PtrOpGep->hasAllConstantIndices() &&
3021 return match(V, m_APInt(C)) && !C->isZero();
3045 if (!Op2 || Op1->getNumOperands() != Op2->getNumOperands() ||
3046 Op1->getSourceElementType() != Op2->getSourceElementType())
3054 Type *CurTy =
nullptr;
3056 for (
unsigned J = 0,
F = Op1->getNumOperands(); J !=
F; ++J) {
3057 if (Op1->getOperand(J)->getType() != Op2->getOperand(J)->getType())
3060 if (Op1->getOperand(J) != Op2->getOperand(J)) {
3069 assert(CurTy &&
"No current type?");
3089 CurTy = Op1->getSourceElementType();
3097 NW &= Op2->getNoWrapFlags();
3107 NewGEP->setNoWrapFlags(NW);
3119 Builder.SetInsertPoint(PN);
3120 NewPN = Builder.CreatePHI(Op1->getOperand(DI)->getType(),
3128 NewGEP->setOperand(DI, NewPN);
3131 NewGEP->insertBefore(*
GEP.getParent(),
GEP.getParent()->getFirstInsertionPt());
3138 Type *GEPType =
GEP.getType();
3139 Type *GEPEltType =
GEP.getSourceElementType();
3142 SQ.getWithInstruction(&
GEP)))
3149 auto VWidth = GEPFVTy->getNumElements();
3150 APInt PoisonElts(VWidth, 0);
3162 bool MadeChange =
false;
3166 Type *NewScalarIndexTy =
3167 DL.getIndexType(
GEP.getPointerOperandType()->getScalarType());
3176 Type *IndexTy = (*I)->getType();
3177 Type *NewIndexType =
3186 if (EltTy->
isSized() &&
DL.getTypeAllocSize(EltTy).isZero())
3192 if (IndexTy != NewIndexType) {
3198 if (
GEP.hasNoUnsignedWrap() &&
GEP.hasNoUnsignedSignedWrap())
3199 *
I =
Builder.CreateZExt(*
I, NewIndexType,
"",
true);
3201 *
I =
Builder.CreateSExt(*
I, NewIndexType);
3203 *
I =
Builder.CreateTrunc(*
I, NewIndexType,
"",
GEP.hasNoUnsignedWrap(),
3204 GEP.hasNoUnsignedSignedWrap());
3213 if (!GEPEltType->
isIntegerTy(8) &&
GEP.hasAllConstantIndices()) {
3218 GEP.getNoWrapFlags()));
3230 if (LastIdx && LastIdx->isNullValue() && !LastIdx->getType()->isVectorTy()) {
3238 if (FirstIdx && FirstIdx->isNullValue() &&
3239 !FirstIdx->getType()->isVectorTy()) {
3244 GEP.getPointerOperand(),
3246 GEP.getNoWrapFlags()));
3253 return Op->getType()->isVectorTy() && getSplatValue(Op);
3256 for (
auto &
Op :
GEP.operands()) {
3257 if (
Op->getType()->isVectorTy())
3267 GEP.getNoWrapFlags());
3270 Res =
Builder.CreateVectorSplat(EC, Res);
3275 bool SeenNonZeroIndex =
false;
3276 for (
auto [IdxNum, Idx] :
enumerate(Indices)) {
3278 if (
C &&
C->isNullValue())
3281 if (!SeenNonZeroIndex) {
3282 SeenNonZeroIndex =
true;
3289 Builder.CreateGEP(GEPEltType, PtrOp, FrontIndices,
3290 GEP.getName() +
".split",
GEP.getNoWrapFlags());
3297 BackIndices,
GEP.getNoWrapFlags());
3310 if (
GEP.getNumIndices() == 1) {
3311 unsigned AS =
GEP.getPointerAddressSpace();
3312 if (
GEP.getOperand(1)->getType()->getScalarSizeInBits() ==
3313 DL.getIndexSizeInBits(AS)) {
3314 uint64_t TyAllocSize =
DL.getTypeAllocSize(GEPEltType).getFixedValue();
3316 if (TyAllocSize == 1) {
3325 GEPType ==
Y->getType()) {
3326 bool HasSameUnderlyingObject =
3329 GEP.replaceUsesWithIf(
Y, [&](
Use &U) {
3330 bool ShouldReplace = HasSameUnderlyingObject ||
3334 return ShouldReplace;
3338 }
else if (
auto *ExactIns =
3342 if (ExactIns->isExact()) {
3350 GEP.getPointerOperand(), V,
3351 GEP.getNoWrapFlags());
3354 if (ExactIns->isExact() && ExactIns->hasOneUse()) {
3360 std::optional<APInt> NewC;
3380 if (NewC.has_value()) {
3383 ConstantInt::get(V->getType(), *NewC));
3386 GEP.getPointerOperand(), NewOp,
3387 GEP.getNoWrapFlags());
3397 if (!
GEP.isInBounds()) {
3400 APInt BasePtrOffset(IdxWidth, 0);
3401 Value *UnderlyingPtrOp =
3403 bool CanBeNull, CanBeFreed;
3405 DL, CanBeNull, CanBeFreed);
3406 if (!CanBeNull && !CanBeFreed && DerefBytes != 0) {
3407 if (
GEP.accumulateConstantOffset(
DL, BasePtrOffset) &&
3409 APInt AllocSize(IdxWidth, DerefBytes);
3410 if (BasePtrOffset.
ule(AllocSize)) {
3412 GEP.getSourceElementType(), PtrOp, Indices,
GEP.getName());
3419 if (
GEP.hasNoUnsignedSignedWrap() && !
GEP.hasNoUnsignedWrap() &&
3421 return isKnownNonNegative(Idx, SQ.getWithInstruction(&GEP));
3429 if (
GEP.getNumIndices() == 1) {
3432 auto GetPreservedNoWrapFlags = [&](
bool AddIsNUW) {
3435 if (
GEP.hasNoUnsignedWrap() && AddIsNUW)
3436 return GEP.getNoWrapFlags();
3452 Builder.CreateGEP(
GEP.getSourceElementType(),
GEP.getPointerOperand(),
3455 Builder.CreateGEP(
GEP.getSourceElementType(),
3456 NewPtr, Idx2,
"", NWFlags));
3467 bool NUW =
match(
GEP.getOperand(1),
3470 auto *NewPtr =
Builder.CreateGEP(
3471 GEP.getSourceElementType(),
GEP.getPointerOperand(),
3472 Builder.CreateSExt(Idx1,
GEP.getOperand(1)->getType()),
"", NWFlags);
3475 Builder.CreateGEP(
GEP.getSourceElementType(), NewPtr,
3476 Builder.CreateSExt(
C,
GEP.getOperand(1)->getType()),
3516 return Dest && Dest->Ptr == UsedV;
3519static std::optional<ModRefInfo>
3531 switch (
I->getOpcode()) {
3534 return std::nullopt;
3536 case Instruction::AddrSpaceCast:
3537 case Instruction::BitCast:
3538 case Instruction::GetElementPtr:
3543 case Instruction::ICmp: {
3549 return std::nullopt;
3550 unsigned OtherIndex = (ICI->
getOperand(0) == PI) ? 1 : 0;
3552 return std::nullopt;
3557 auto AlignmentAndSizeKnownValid = [](
CallBase *CB) {
3561 const APInt *Alignment;
3563 return match(CB->getArgOperand(0),
m_APInt(Alignment)) &&
3569 if (CB && TLI.
getLibFunc(*CB->getCalledFunction(), TheLibFunc) &&
3570 TLI.
has(TheLibFunc) && TheLibFunc == LibFunc_aligned_alloc &&
3571 !AlignmentAndSizeKnownValid(CB))
3572 return std::nullopt;
3577 case Instruction::Call:
3580 switch (
II->getIntrinsicID()) {
3582 return std::nullopt;
3584 case Intrinsic::memmove:
3585 case Intrinsic::memcpy:
3586 case Intrinsic::memset: {
3588 if (
MI->isVolatile())
3589 return std::nullopt;
3595 return std::nullopt;
3599 case Intrinsic::assume:
3600 case Intrinsic::invariant_start:
3601 case Intrinsic::invariant_end:
3602 case Intrinsic::lifetime_start:
3603 case Intrinsic::lifetime_end:
3604 case Intrinsic::objectsize:
3607 case Intrinsic::launder_invariant_group:
3608 case Intrinsic::strip_invariant_group:
3635 return std::nullopt;
3637 case Instruction::Store: {
3639 if (
SI->isVolatile() ||
SI->getPointerOperand() != PI)
3640 return std::nullopt;
3642 return std::nullopt;
3648 case Instruction::Load: {
3651 return std::nullopt;
3653 return std::nullopt;
3661 }
while (!Worklist.
empty());
3685 std::unique_ptr<DIBuilder> DIB;
3693 bool KnowInitUndef =
false;
3694 bool KnowInitZero =
false;
3699 KnowInitUndef =
true;
3700 else if (
Init->isNullValue())
3701 KnowInitZero =
true;
3705 auto &
F = *
MI.getFunction();
3706 if (
F.hasFnAttribute(Attribute::SanitizeMemory) ||
3707 F.hasFnAttribute(Attribute::SanitizeAddress))
3708 KnowInitUndef =
false;
3722 if (
II->getIntrinsicID() == Intrinsic::objectsize) {
3725 II,
DL, &
TLI,
AA,
true, &InsertedInstructions);
3726 for (
Instruction *Inserted : InsertedInstructions)
3734 if (KnowInitZero &&
isRefSet(*Removable)) {
3737 auto *M =
Builder.CreateMemSet(
3740 MTI->getLength(), MTI->getDestAlign());
3741 M->copyMetadata(*MTI);
3755 C->isFalseWhenEqual()));
3757 for (
auto *DVR : DVRs)
3758 if (DVR->isAddressOfVariable())
3765 assert(KnowInitZero || KnowInitUndef);
3780 F,
II->getNormalDest(),
II->getUnwindDest(), {},
"",
II->getParent());
3781 NewII->setDebugLoc(
II->getDebugLoc());
3809 for (
auto *DVR : DVRs)
3810 if (DVR->isAddressOfVariable() || DVR->getExpression()->startsWithDeref())
3811 DVR->eraseFromParent();
3857 if (FreeInstrBB->
size() != 2) {
3859 if (&Inst == &FI || &Inst == FreeInstrBBTerminator)
3862 if (!Cast || !Cast->isNoopCast(
DL))
3883 "Broken CFG: missing edge from predecessor to successor");
3888 if (&Instr == FreeInstrBBTerminator)
3893 "Only the branch instruction should remain");
3904 Attrs = Attrs.removeParamAttribute(FI.
getContext(), 0, Attribute::NonNull);
3905 Attribute Dereferenceable = Attrs.getParamAttr(0, Attribute::Dereferenceable);
3906 if (Dereferenceable.
isValid()) {
3908 Attrs = Attrs.removeParamAttribute(FI.
getContext(), 0,
3909 Attribute::Dereferenceable);
3910 Attrs = Attrs.addDereferenceableOrNullParamAttr(FI.
getContext(), 0, Bytes);
3949 if (
TLI.getLibFunc(FI, Func) &&
TLI.has(Func) && Func == LibFunc_free)
3965 bool HasDereferenceable =
3966 F->getAttributes().getRetDereferenceableBytes() > 0;
3967 if (
F->hasRetAttribute(Attribute::NonNull) ||
3968 (HasDereferenceable &&
3970 if (
Value *V = simplifyNonNullOperand(RetVal, HasDereferenceable))
3975 if (!AttributeFuncs::isNoFPClassCompatibleType(RetTy))
3978 FPClassTest ReturnClass =
F->getAttributes().getRetNoFPClass();
3979 if (ReturnClass ==
fcNone)
4002 if (Prev->isEHPad())
4034 if (BBI != FirstInstr)
4036 }
while (BBI != FirstInstr && BBI->isDebugOrPseudoInst());
4050 if (!
DeadEdges.insert({From, To}).second)
4055 for (
Use &U : PN.incoming_values())
4072 std::next(
I->getReverseIterator())))) {
4073 if (!Inst.use_empty() && !Inst.getType()->isTokenTy()) {
4077 if (Inst.isEHPad() || Inst.getType()->isTokenTy())
4080 Inst.dropDbgRecords();
4102 return DeadEdges.contains({Pred, BB}) ||
DT.dominates(BB, Pred);
4115 if (Succ == LiveSucc)
4189 if (
DT.dominates(Edge0, U)) {
4195 if (
DT.dominates(Edge1, U)) {
4202 DC.registerBranch(&BI);
4212 unsigned CstOpIdx = IsTrueArm ? 1 : 2;
4217 BasicBlock *CstBB =
SI.findCaseValue(
C)->getCaseSuccessor();
4218 if (CstBB !=
SI.getDefaultDest())
4231 for (
auto Case :
SI.cases())
4232 if (!CR.
contains(Case.getCaseValue()->getValue()))
4244 for (
auto Case :
SI.cases()) {
4247 "Result of expression should be constant");
4256 for (
auto Case :
SI.cases()) {
4259 "Result of expression should be constant");
4268 all_of(
SI.cases(), [&](
const auto &Case) {
4269 return Case.getCaseValue()->getValue().countr_zero() >= ShiftAmt;
4275 Value *NewCond = Op0;
4282 for (
auto Case :
SI.cases()) {
4283 const APInt &CaseVal = Case.getCaseValue()->getValue();
4285 : CaseVal.
lshr(ShiftAmt);
4286 Case.setValue(ConstantInt::get(
SI.getContext(), ShiftedCase));
4298 if (
all_of(
SI.cases(), [&](
const auto &Case) {
4299 const APInt &CaseVal = Case.getCaseValue()->getValue();
4300 return IsZExt ? CaseVal.isIntN(NewWidth)
4301 : CaseVal.isSignedIntN(NewWidth);
4303 for (
auto &Case :
SI.cases()) {
4304 APInt TruncatedCase = Case.getCaseValue()->getValue().
trunc(NewWidth);
4305 Case.setValue(ConstantInt::get(
SI.getContext(), TruncatedCase));
4327 for (
const auto &
C :
SI.cases()) {
4329 std::min(LeadingKnownZeros,
C.getCaseValue()->getValue().countl_zero());
4331 std::min(LeadingKnownOnes,
C.getCaseValue()->getValue().countl_one());
4334 unsigned NewWidth = Known.
getBitWidth() - std::max(LeadingKnownZeros, LeadingKnownOnes);
4340 if (NewWidth > 0 && NewWidth < Known.
getBitWidth() &&
4341 shouldChangeType(Known.
getBitWidth(), NewWidth)) {
4346 for (
auto Case :
SI.cases()) {
4347 APInt TruncatedCase = Case.getCaseValue()->getValue().
trunc(NewWidth);
4348 Case.setValue(ConstantInt::get(
SI.getContext(), TruncatedCase));
4359 SI.findCaseValue(CI)->getCaseSuccessor());
4373 const APInt *
C =
nullptr;
4375 if (*EV.
idx_begin() == 0 && (OvID == Intrinsic::smul_with_overflow ||
4376 OvID == Intrinsic::umul_with_overflow)) {
4381 if (
C->isPowerOf2()) {
4382 return BinaryOperator::CreateShl(
4384 ConstantInt::get(WO->getLHS()->getType(),
C->logBase2()));
4392 if (!WO->hasOneUse())
4406 assert(*EV.
idx_begin() == 1 &&
"Unexpected extract index for overflow inst");
4409 if (OvID == Intrinsic::usub_with_overflow)
4414 if (OvID == Intrinsic::smul_with_overflow &&
4415 WO->getLHS()->getType()->isIntOrIntVectorTy(1))
4416 return BinaryOperator::CreateAnd(WO->getLHS(), WO->getRHS());
4419 if (OvID == Intrinsic::umul_with_overflow && WO->getLHS() == WO->getRHS()) {
4420 unsigned BitWidth = WO->getLHS()->getType()->getScalarSizeInBits();
4423 return new ICmpInst(
4425 ConstantInt::get(WO->getLHS()->getType(),
4436 WO->getBinaryOp(), *
C, WO->getNoWrapKind());
4441 auto *OpTy = WO->getRHS()->getType();
4442 auto *NewLHS = WO->getLHS();
4444 NewLHS =
Builder.CreateAdd(NewLHS, ConstantInt::get(OpTy,
Offset));
4446 ConstantInt::get(OpTy, NewRHSC));
4463 const APFloat *ConstVal =
nullptr;
4464 Value *VarOp =
nullptr;
4465 bool ConstIsTrue =
false;
4472 ConstIsTrue =
false;
4477 Builder.SetInsertPoint(&EV);
4483 Value *NewEV = Builder.CreateExtractValue(NewFrexp, 0,
"mantissa");
4488 Constant *ConstantMantissa = ConstantFP::get(TrueVal->getType(), Mantissa);
4490 Value *NewSel = Builder.CreateSelectFMF(
4491 Cond, ConstIsTrue ? ConstantMantissa : NewEV,
4492 ConstIsTrue ? NewEV : ConstantMantissa,
SelectInst,
"select.frexp");
4502 SQ.getWithInstruction(&EV)))
4516 const unsigned *exti, *exte, *insi, *inse;
4517 for (exti = EV.
idx_begin(), insi =
IV->idx_begin(),
4518 exte = EV.
idx_end(), inse =
IV->idx_end();
4519 exti != exte && insi != inse;
4533 if (exti == exte && insi == inse)
4548 Value *NewEV =
Builder.CreateExtractValue(
IV->getAggregateOperand(),
4566 if (
Instruction *R = foldExtractOfOverflowIntrinsic(EV))
4572 STy && STy->isScalableTy())
4580 if (L->isSimple() && L->hasOneUse()) {
4585 for (
unsigned Idx : EV.
indices())
4592 L->getPointerOperand(), Indices);
4626 switch (Personality) {
4670 bool MakeNewInstruction =
false;
4676 bool isLastClause = i + 1 == e;
4684 if (AlreadyCaught.
insert(TypeInfo).second) {
4689 MakeNewInstruction =
true;
4696 MakeNewInstruction =
true;
4697 CleanupFlag =
false;
4716 if (!NumTypeInfos) {
4719 MakeNewInstruction =
true;
4720 CleanupFlag =
false;
4724 bool MakeNewFilter =
false;
4728 assert(NumTypeInfos > 0 &&
"Should have handled empty filter already!");
4734 MakeNewInstruction =
true;
4741 if (NumTypeInfos > 1)
4742 MakeNewFilter =
true;
4746 NewFilterElts.
reserve(NumTypeInfos);
4751 bool SawCatchAll =
false;
4752 for (
unsigned j = 0; j != NumTypeInfos; ++j) {
4780 if (SeenInFilter.
insert(TypeInfo).second)
4786 MakeNewInstruction =
true;
4791 if (NewFilterElts.
size() < NumTypeInfos)
4792 MakeNewFilter =
true;
4794 if (MakeNewFilter) {
4796 NewFilterElts.
size());
4798 MakeNewInstruction =
true;
4807 if (MakeNewFilter && !NewFilterElts.
size()) {
4808 assert(MakeNewInstruction &&
"New filter but not a new instruction!");
4809 CleanupFlag =
false;
4820 for (
unsigned i = 0, e = NewClauses.
size(); i + 1 < e; ) {
4823 for (j = i; j != e; ++j)
4830 for (
unsigned k = i; k + 1 < j; ++k)
4834 std::stable_sort(NewClauses.
begin() + i, NewClauses.
begin() + j,
4836 MakeNewInstruction =
true;
4855 for (
unsigned i = 0; i + 1 < NewClauses.
size(); ++i) {
4865 for (
unsigned j = NewClauses.
size() - 1; j != i; --j) {
4866 Value *LFilter = NewClauses[j];
4877 NewClauses.
erase(J);
4878 MakeNewInstruction =
true;
4882 unsigned LElts = LTy->getNumElements();
4892 assert(FElts <= LElts &&
"Should have handled this case earlier!");
4894 NewClauses.
erase(J);
4895 MakeNewInstruction =
true;
4904 assert(FElts > 0 &&
"Should have eliminated the empty filter earlier!");
4905 for (
unsigned l = 0; l != LElts; ++l)
4908 NewClauses.
erase(J);
4909 MakeNewInstruction =
true;
4920 bool AllFound =
true;
4921 for (
unsigned f = 0; f != FElts; ++f) {
4924 for (
unsigned l = 0; l != LElts; ++l) {
4926 if (LTypeInfo == FTypeInfo) {
4936 NewClauses.
erase(J);
4937 MakeNewInstruction =
true;
4945 if (MakeNewInstruction) {
4953 if (NewClauses.empty())
4962 assert(!CleanupFlag &&
"Adding a cleanup, not removing one?!");
4984 auto CanPushFreeze = [](
Value *V) {
5005 Value *V = U->get();
5006 if (!CanPushFreeze(V)) {
5012 Builder.SetInsertPoint(UserI);
5013 Value *Frozen =
Builder.CreateFreeze(V, V->getName() +
".fr");
5019 if (!Visited.
insert(
I).second)
5030 I->dropPoisonGeneratingAnnotations();
5031 this->Worklist.add(
I);
5034 return OrigUse->get();
5044 Use *StartU =
nullptr;
5062 Value *StartV = StartU->get();
5074 if (!Visited.
insert(V).second)
5077 if (Visited.
size() > 32)
5094 I->dropPoisonGeneratingAnnotations();
5096 if (StartNeedsFreeze) {
5124 MoveBefore = *MoveBeforeOpt;
5128 MoveBefore.setHeadBit(
false);
5131 if (&FI != &*MoveBefore) {
5132 FI.
moveBefore(*MoveBefore->getParent(), MoveBefore);
5136 Op->replaceUsesWithIf(&FI, [&](
Use &U) ->
bool {
5137 bool Dominates =
DT.dominates(&FI, U);
5147 for (
auto *U : V->users()) {
5157 Value *Op0 =
I.getOperand(0);
5187 auto getUndefReplacement = [&](
Type *Ty) {
5188 auto pickCommonConstantFromPHI = [](
PHINode &PN) ->
Value * {
5192 for (
Value *V : PN.incoming_values()) {
5203 if (BestValue && BestValue !=
C)
5212 Value *BestValue =
nullptr;
5213 for (
auto *U :
I.users()) {
5214 Value *V = NullValue;
5223 if (
Value *MaybeV = pickCommonConstantFromPHI(*
PHI))
5229 else if (BestValue != V)
5230 BestValue = NullValue;
5232 assert(BestValue &&
"Must have at least one use");
5233 assert(BestValue != &
I &&
"Cannot replace with itself");
5247 Type *Ty =
C->getType();
5251 unsigned NumElts = VTy->getNumElements();
5253 for (
unsigned i = 0; i != NumElts; ++i) {
5254 Constant *EltC =
C->getAggregateElement(i);
5265 !
C->containsConstantExpression()) {
5266 if (
Constant *Repl = getFreezeVectorReplacement(
C))
5300 for (
const User *U :
I.users()) {
5301 if (Visited.
insert(U).second)
5306 while (!AllocaUsers.
empty()) {
5329 if (
isa<PHINode>(
I) ||
I->isEHPad() ||
I->mayThrow() || !
I->willReturn() ||
5346 if (CI->isConvergent())
5352 if (
I->mayWriteToMemory()) {
5359 if (
I->mayReadFromMemory() &&
5360 !
I->hasMetadata(LLVMContext::MD_invariant_load)) {
5367 E =
I->getParent()->end();
5369 if (Scan->mayWriteToMemory())
5373 I->dropDroppableUses([&](
const Use *U) {
5375 if (
I &&
I->getParent() != DestBlock) {
5385 I->moveBefore(*DestBlock, InsertPos);
5395 if (!DbgVariableRecords.
empty())
5397 DbgVariableRecords);
5420 for (
auto &DVR : DbgVariableRecords)
5421 if (DVR->getParent() != DestBlock)
5422 DbgVariableRecordsToSalvage.
push_back(DVR);
5428 if (DVR->getParent() == SrcBlock)
5429 DbgVariableRecordsToSink.
push_back(DVR);
5436 return B->getInstruction()->comesBefore(
A->getInstruction());
5443 using InstVarPair = std::pair<const Instruction *, DebugVariable>;
5445 if (DbgVariableRecordsToSink.
size() > 1) {
5451 DVR->getDebugLoc()->getInlinedAt());
5452 CountMap[std::make_pair(DVR->getInstruction(), DbgUserVariable)] += 1;
5458 for (
auto It : CountMap) {
5459 if (It.second > 1) {
5460 FilterOutMap[It.first] =
nullptr;
5461 DupSet.
insert(It.first.first);
5472 DVR.getDebugLoc()->getInlinedAt());
5474 FilterOutMap.
find(std::make_pair(Inst, DbgUserVariable));
5475 if (FilterIt == FilterOutMap.
end())
5477 if (FilterIt->second !=
nullptr)
5479 FilterIt->second = &DVR;
5494 DVR->getDebugLoc()->getInlinedAt());
5498 if (!FilterOutMap.
empty()) {
5499 InstVarPair IVP = std::make_pair(DVR->getInstruction(), DbgUserVariable);
5500 auto It = FilterOutMap.
find(IVP);
5503 if (It != FilterOutMap.
end() && It->second != DVR)
5507 if (!SunkVariables.
insert(DbgUserVariable).second)
5510 if (DVR->isDbgAssign())
5518 if (DVRClones.
empty())
5532 assert(InsertPos.getHeadBit());
5534 InsertPos->getParent()->insertDbgRecordBefore(DVRClone, InsertPos);
5558 if (
I ==
nullptr)
continue;
5573 auto getOptionalSinkBlockForInst =
5574 [
this](
Instruction *
I) -> std::optional<BasicBlock *> {
5576 return std::nullopt;
5580 unsigned NumUsers = 0;
5582 for (
Use &U :
I->uses()) {
5587 return std::nullopt;
5593 UserBB = PN->getIncomingBlock(U);
5597 if (UserParent && UserParent != UserBB)
5598 return std::nullopt;
5599 UserParent = UserBB;
5603 if (NumUsers == 0) {
5606 if (UserParent == BB || !
DT.isReachableFromEntry(UserParent))
5607 return std::nullopt;
5619 return std::nullopt;
5621 assert(
DT.dominates(BB, UserParent) &&
"Dominance relation broken?");
5629 return std::nullopt;
5634 auto OptBB = getOptionalSinkBlockForInst(
I);
5636 auto *UserParent = *OptBB;
5644 for (
Use &U :
I->operands())
5652 Builder.CollectMetadataToCopy(
5653 I, {LLVMContext::MD_dbg, LLVMContext::MD_annotation});
5666 <<
" New = " << *Result <<
'\n');
5671 Result->setDebugLoc(Result->getDebugLoc().orElse(
I->getDebugLoc()));
5673 Result->copyMetadata(*
I, LLVMContext::MD_annotation);
5675 I->replaceAllUsesWith(Result);
5678 Result->takeName(
I);
5693 Result->insertInto(InstParent, InsertPos);
5696 Worklist.pushUsersToWorkList(*Result);
5702 <<
" New = " << *
I <<
'\n');
5734 if (!
I->hasMetadataOtherThanDebugLoc())
5737 auto Track = [](
Metadata *ScopeList,
auto &Container) {
5739 if (!MDScopeList || !Container.insert(MDScopeList).second)
5741 for (
const auto &
MDOperand : MDScopeList->operands())
5743 Container.insert(MDScope);
5746 Track(
I->getMetadata(LLVMContext::MD_alias_scope), UsedAliasScopesAndLists);
5747 Track(
I->getMetadata(LLVMContext::MD_noalias), UsedNoAliasScopesAndLists);
5756 "llvm.experimental.noalias.scope.decl in use ?");
5759 "llvm.experimental.noalias.scope should refer to a single scope");
5762 return !UsedAliasScopesAndLists.contains(MD) ||
5763 !UsedNoAliasScopesAndLists.contains(MD);
5787 if (Succ != LiveSucc &&
DeadEdges.insert({BB, Succ}).second)
5788 for (
PHINode &PN : Succ->phis())
5789 for (
Use &U : PN.incoming_values())
5798 return DeadEdges.contains({Pred, BB}) ||
DT.dominates(BB, Pred);
5800 HandleOnlyLiveSuccessor(BB,
nullptr);
5807 if (!Inst.use_empty() &&
5808 (Inst.getNumOperands() == 0 ||
isa<Constant>(Inst.getOperand(0))))
5812 Inst.replaceAllUsesWith(
C);
5815 Inst.eraseFromParent();
5821 for (
Use &U : Inst.operands()) {
5826 Constant *&FoldRes = FoldedConstants[
C];
5832 <<
"\n Old = " << *
C
5833 <<
"\n New = " << *FoldRes <<
'\n');
5842 if (!Inst.isDebugOrPseudoInst()) {
5843 InstrsForInstructionWorklist.
push_back(&Inst);
5844 SeenAliasScopes.
analyse(&Inst);
5854 HandleOnlyLiveSuccessor(BB,
nullptr);
5858 bool CondVal =
Cond->getZExtValue();
5859 HandleOnlyLiveSuccessor(BB, BI->getSuccessor(!CondVal));
5865 HandleOnlyLiveSuccessor(BB,
nullptr);
5869 HandleOnlyLiveSuccessor(BB,
5870 SI->findCaseValue(
Cond)->getCaseSuccessor());
5880 if (LiveBlocks.
count(&BB))
5883 unsigned NumDeadInstInBB;
5887 NumDeadInst += NumDeadInstInBB;
5904 Inst->eraseFromParent();
5933 auto &
DL =
F.getDataLayout();
5935 !
F.hasFnAttribute(
"instcombine-no-verify-fixpoint");
5951 bool MadeIRChange =
false;
5956 unsigned Iteration = 0;
5960 <<
" on " <<
F.getName()
5961 <<
" reached; stopping without verifying fixpoint\n");
5966 ++NumWorklistIterations;
5967 LLVM_DEBUG(
dbgs() <<
"\n\nINSTCOMBINE ITERATION #" << Iteration <<
" on "
5968 <<
F.getName() <<
"\n");
5970 InstCombinerImpl IC(Worklist, Builder,
F,
AA, AC, TLI,
TTI, DT, ORE, BFI,
5971 BPI, PSI,
DL, RPOT);
5974 MadeChangeInThisIteration |= IC.
run();
5975 if (!MadeChangeInThisIteration)
5978 MadeIRChange =
true;
5981 "Instruction Combining on " +
Twine(
F.getName()) +
5984 "Use 'instcombine<no-verify-fixpoint>' or function attribute "
5985 "'instcombine-no-verify-fixpoint' to suppress this error.");
5991 else if (Iteration == 2)
5993 else if (Iteration == 3)
5994 ++NumThreeIterations;
5996 ++NumFourOrMoreIterations;
5998 return MadeIRChange;
6006 OS, MapClassName2PassName);
6008 OS <<
"max-iterations=" << Options.MaxIterations <<
";";
6009 OS << (Options.VerifyFixpoint ?
"" :
"no-") <<
"verify-fixpoint";
6013char InstCombinePass::ID = 0;
6019 if (LRT.shouldSkip(&ID))
6032 auto *BFI = (PSI && PSI->hasProfileSummary()) ?
6037 BFI, BPI, PSI, Options)) {
6039 LRT.update(&ID,
false);
6045 LRT.update(&ID,
true);
6087 if (
auto *WrapperPass =
6089 BPI = &WrapperPass->getBPI();
6102 "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 * 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 * FoldOpIntoSelect(Instruction &Op, SelectInst *SI, bool FoldWithMultiUse=false, bool SimplifyBothArms=false)
Given an instruction with a select as one operand and a constant as the other operand,...
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