108#define DEBUG_TYPE "instcombine"
116 "Number of instruction combining iterations performed");
117STATISTIC(NumOneIteration,
"Number of functions with one iteration");
118STATISTIC(NumTwoIterations,
"Number of functions with two iterations");
119STATISTIC(NumThreeIterations,
"Number of functions with three iterations");
121 "Number of functions with four or more iterations");
125STATISTIC(NumDeadInst ,
"Number of dead inst eliminated");
131 "Controls which instructions are visited");
138 "instcombine-max-sink-users",
cl::init(32),
139 cl::desc(
"Maximum number of undroppable users for instruction sinking"));
143 cl::desc(
"Maximum array size considered when doing a combine"));
155std::optional<Instruction *>
158 if (
II.getCalledFunction()->isTargetIntrinsic()) {
166 bool &KnownBitsComputed) {
168 if (
II.getCalledFunction()->isTargetIntrinsic()) {
181 if (
II.getCalledFunction()->isTargetIntrinsic()) {
183 *
this,
II, DemandedElts, PoisonElts, PoisonElts2, PoisonElts3,
198 auto *Inst = dyn_cast<Instruction>(
GEP);
205 if (Inst && !
GEP->hasOneUse() && !
GEP->hasAllConstantIndices() &&
206 !
GEP->getSourceElementType()->isIntegerTy(8)) {
220bool InstCombinerImpl::isDesirableIntType(
unsigned BitWidth)
const {
239bool InstCombinerImpl::shouldChangeType(
unsigned FromWidth,
240 unsigned ToWidth)
const {
246 if (ToWidth < FromWidth && isDesirableIntType(ToWidth))
251 if ((FromLegal || isDesirableIntType(FromWidth)) && !ToLegal)
256 if (!FromLegal && !ToLegal && ToWidth > FromWidth)
267bool InstCombinerImpl::shouldChangeType(
Type *
From,
Type *To)
const {
273 unsigned FromWidth =
From->getPrimitiveSizeInBits();
275 return shouldChangeType(FromWidth, ToWidth);
284 auto *OBO = dyn_cast<OverflowingBinaryOperator>(&
I);
285 if (!OBO || !OBO->hasNoSignedWrap())
290 if (Opcode != Instruction::Add && Opcode != Instruction::Sub)
293 const APInt *BVal, *CVal;
297 bool Overflow =
false;
298 if (Opcode == Instruction::Add)
299 (void)BVal->
sadd_ov(*CVal, Overflow);
301 (
void)BVal->
ssub_ov(*CVal, Overflow);
307 auto *OBO = dyn_cast<OverflowingBinaryOperator>(&
I);
308 return OBO && OBO->hasNoUnsignedWrap();
312 auto *OBO = dyn_cast<OverflowingBinaryOperator>(&
I);
313 return OBO && OBO->hasNoSignedWrap();
322 I.clearSubclassOptionalData();
327 I.clearSubclassOptionalData();
328 I.setFastMathFlags(FMF);
337 auto *Cast = dyn_cast<CastInst>(BinOp1->
getOperand(0));
338 if (!Cast || !Cast->hasOneUse())
342 auto CastOpcode = Cast->getOpcode();
343 if (CastOpcode != Instruction::ZExt)
351 auto *BinOp2 = dyn_cast<BinaryOperator>(Cast->getOperand(0));
352 if (!BinOp2 || !BinOp2->hasOneUse() || BinOp2->getOpcode() != AssocOpcode)
378 Cast->dropPoisonGeneratingFlags();
384Value *InstCombinerImpl::simplifyIntToPtrRoundTripCast(
Value *Val) {
385 auto *IntToPtr = dyn_cast<IntToPtrInst>(Val);
388 auto *PtrToInt = dyn_cast<PtrToIntInst>(IntToPtr->getOperand(0));
389 Type *CastTy = IntToPtr->getDestTy();
392 PtrToInt->getSrcTy()->getPointerAddressSpace() &&
395 return PtrToInt->getOperand(0);
422 bool Changed =
false;
430 Changed = !
I.swapOperands();
432 if (
I.isCommutative()) {
433 if (
auto Pair = matchSymmetricPair(
I.getOperand(0),
I.getOperand(1))) {
443 if (
I.isAssociative()) {
466 I.setHasNoUnsignedWrap(
true);
469 I.setHasNoSignedWrap(
true);
498 if (
I.isAssociative() &&
I.isCommutative()) {
561 if (isa<FPMathOperator>(NewBO)) {
575 I.setHasNoUnsignedWrap(
true);
593 if (LOp == Instruction::And)
594 return ROp == Instruction::Or || ROp == Instruction::Xor;
597 if (LOp == Instruction::Or)
598 return ROp == Instruction::And;
602 if (LOp == Instruction::Mul)
603 return ROp == Instruction::Add || ROp == Instruction::Sub;
626 if (isa<Constant>(V))
640 assert(
Op &&
"Expected a binary operator");
641 LHS =
Op->getOperand(0);
642 RHS =
Op->getOperand(1);
643 if (TopOpcode == Instruction::Add || TopOpcode == Instruction::Sub) {
648 Instruction::Shl, ConstantInt::get(
Op->getType(), 1),
C);
649 assert(
RHS &&
"Constant folding of immediate constants failed");
650 return Instruction::Mul;
655 if (OtherOp && OtherOp->
getOpcode() == Instruction::AShr &&
658 return Instruction::AShr;
661 return Op->getOpcode();
670 assert(
A &&
B &&
C &&
D &&
"All values must be provided");
673 Value *RetVal =
nullptr;
684 if (
A ==
C || (InnerCommutative &&
A ==
D)) {
704 if (
B ==
D || (InnerCommutative &&
B ==
C)) {
727 if (isa<OverflowingBinaryOperator>(RetVal)) {
730 if (isa<OverflowingBinaryOperator>(&
I)) {
731 HasNSW =
I.hasNoSignedWrap();
732 HasNUW =
I.hasNoUnsignedWrap();
734 if (
auto *LOBO = dyn_cast<OverflowingBinaryOperator>(
LHS)) {
735 HasNSW &= LOBO->hasNoSignedWrap();
736 HasNUW &= LOBO->hasNoUnsignedWrap();
739 if (
auto *ROBO = dyn_cast<OverflowingBinaryOperator>(
RHS)) {
740 HasNSW &= ROBO->hasNoSignedWrap();
741 HasNUW &= ROBO->hasNoUnsignedWrap();
744 if (TopLevelOpcode == Instruction::Add && InnerOpcode == Instruction::Mul) {
754 cast<Instruction>(RetVal)->setHasNoSignedWrap(HasNSW);
757 cast<Instruction>(RetVal)->setHasNoUnsignedWrap(HasNUW);
772 unsigned Opc =
I->getOpcode();
773 unsigned ConstIdx = 1;
780 case Instruction::Sub:
783 case Instruction::ICmp:
790 case Instruction::Or:
794 case Instruction::Add:
800 if (!
match(
I->getOperand(1 - ConstIdx),
813 if (Opc == Instruction::ICmp && !cast<ICmpInst>(
I)->isEquality()) {
816 if (!Cmp || !Cmp->isZeroValue())
821 bool Consumes =
false;
825 assert(NotOp !=
nullptr &&
826 "Desync between isFreeToInvert and getFreelyInverted");
835 case Instruction::Sub:
838 case Instruction::Or:
839 case Instruction::Add:
842 case Instruction::ICmp:
878 auto IsValidBinOpc = [](
unsigned Opc) {
882 case Instruction::And:
883 case Instruction::Or:
884 case Instruction::Xor:
885 case Instruction::Add:
894 auto IsCompletelyDistributable = [](
unsigned BinOpc1,
unsigned BinOpc2,
896 assert(ShOpc != Instruction::AShr);
897 return (BinOpc1 != Instruction::Add && BinOpc2 != Instruction::Add) ||
898 ShOpc == Instruction::Shl;
901 auto GetInvShift = [](
unsigned ShOpc) {
902 assert(ShOpc != Instruction::AShr);
903 return ShOpc == Instruction::LShr ? Instruction::Shl : Instruction::LShr;
906 auto CanDistributeBinops = [&](
unsigned BinOpc1,
unsigned BinOpc2,
910 if (BinOpc1 == Instruction::And)
915 if (!IsCompletelyDistributable(BinOpc1, BinOpc2, ShOpc))
921 if (BinOpc2 == Instruction::And)
932 auto MatchBinOp = [&](
unsigned ShOpnum) ->
Instruction * {
934 Value *
X, *
Y, *ShiftedX, *Mask, *Shift;
935 if (!
match(
I.getOperand(ShOpnum),
938 if (!
match(
I.getOperand(1 - ShOpnum),
946 auto *IY = dyn_cast<Instruction>(
I.getOperand(ShOpnum));
947 auto *IX = dyn_cast<Instruction>(ShiftedX);
952 unsigned ShOpc = IY->getOpcode();
953 if (ShOpc != IX->getOpcode())
957 auto *BO2 = dyn_cast<Instruction>(
I.getOperand(1 - ShOpnum));
961 unsigned BinOpc = BO2->getOpcode();
963 if (!IsValidBinOpc(
I.getOpcode()) || !IsValidBinOpc(BinOpc))
966 if (ShOpc == Instruction::AShr) {
980 if (BinOpc ==
I.getOpcode() &&
981 IsCompletelyDistributable(
I.getOpcode(), BinOpc, ShOpc)) {
996 if (!CanDistributeBinops(
I.getOpcode(), BinOpc, ShOpc, CMask, CShift))
1010 return MatchBinOp(1);
1028 Value *
A, *CondVal, *TrueVal, *FalseVal;
1031 auto MatchSelectAndCast = [&](
Value *CastOp,
Value *SelectOp) {
1033 A->getType()->getScalarSizeInBits() == 1 &&
1040 if (MatchSelectAndCast(
LHS,
RHS))
1042 else if (MatchSelectAndCast(
RHS,
LHS))
1047 auto NewFoldedConst = [&](
bool IsTrueArm,
Value *V) {
1048 bool IsCastOpRHS = (CastOp ==
RHS);
1049 bool IsZExt = isa<ZExtInst>(CastOp);
1054 }
else if (IsZExt) {
1055 unsigned BitWidth = V->getType()->getScalarSizeInBits();
1068 Value *NewTrueVal = NewFoldedConst(
false, TrueVal);
1070 NewFoldedConst(
true, FalseVal));
1074 Value *NewTrueVal = NewFoldedConst(
true, TrueVal);
1076 NewFoldedConst(
false, FalseVal));
1097 if (Op0 && Op1 && LHSOpcode == RHSOpcode)
1217static std::optional<std::pair<Value *, Value *>>
1219 if (
LHS->getParent() !=
RHS->getParent())
1220 return std::nullopt;
1222 if (
LHS->getNumIncomingValues() < 2)
1223 return std::nullopt;
1226 return std::nullopt;
1228 Value *L0 =
LHS->getIncomingValue(0);
1229 Value *R0 =
RHS->getIncomingValue(0);
1231 for (
unsigned I = 1, E =
LHS->getNumIncomingValues();
I != E; ++
I) {
1235 if ((L0 == L1 && R0 == R1) || (L0 == R1 && R0 == L1))
1238 return std::nullopt;
1241 return std::optional(std::pair(L0, R0));
1244std::optional<std::pair<Value *, Value *>>
1245InstCombinerImpl::matchSymmetricPair(
Value *LHS,
Value *RHS) {
1246 Instruction *LHSInst = dyn_cast<Instruction>(LHS);
1247 Instruction *RHSInst = dyn_cast<Instruction>(RHS);
1249 return std::nullopt;
1251 case Instruction::PHI:
1253 case Instruction::Select: {
1259 return std::pair(TrueVal, FalseVal);
1260 return std::nullopt;
1262 case Instruction::Call: {
1266 if (LHSMinMax && RHSMinMax &&
1273 return std::pair(LHSMinMax->
getLHS(), LHSMinMax->
getRHS());
1274 return std::nullopt;
1277 return std::nullopt;
1287 if (!LHSIsSelect && !RHSIsSelect)
1292 if (isa<FPMathOperator>(&
I)) {
1293 FMF =
I.getFastMathFlags();
1300 Value *
Cond, *True =
nullptr, *False =
nullptr;
1308 if (Opcode != Instruction::Add || (!True && !False) || (True && False))
1323 if (LHSIsSelect && RHSIsSelect &&
A ==
D) {
1332 else if (True && !False)
1340 if (
Value *NewSel = foldAddNegate(
B,
C,
RHS))
1347 if (
Value *NewSel = foldAddNegate(E,
F,
LHS))
1351 if (!True || !False)
1362 assert(!isa<Constant>(
I) &&
"Shouldn't invert users of constant");
1364 if (U == IgnoredUser)
1366 switch (cast<Instruction>(U)->
getOpcode()) {
1367 case Instruction::Select: {
1368 auto *SI = cast<SelectInst>(U);
1370 SI->swapProfMetadata();
1373 case Instruction::Br: {
1380 case Instruction::Xor:
1387 "canFreelyInvertAllUsersOf() ?");
1394Value *InstCombinerImpl::dyn_castNegVal(
Value *V)
const {
1404 if (
C->getType()->getElementType()->isIntegerTy())
1408 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1413 if (isa<UndefValue>(Elt))
1416 if (!isa<ConstantInt>(Elt))
1423 if (
auto *CV = dyn_cast<Constant>(V))
1424 if (CV->getType()->isVectorTy() &&
1425 CV->getType()->getScalarType()->isIntegerTy() && CV->getSplatValue())
1438Instruction *InstCombinerImpl::foldFBinOpOfIntCastsFromSign(
1439 BinaryOperator &BO,
bool OpsFromSigned, std::array<Value *, 2> IntOps,
1443 Type *IntTy = IntOps[0]->getType();
1448 unsigned MaxRepresentableBits =
1453 unsigned NumUsedLeadingBits[2] = {IntSz, IntSz};
1457 auto IsNonZero = [&](
unsigned OpNo) ->
bool {
1458 if (OpsKnown[OpNo].hasKnownBits() &&
1459 OpsKnown[OpNo].getKnownBits(
SQ).isNonZero())
1464 auto IsNonNeg = [&](
unsigned OpNo) ->
bool {
1468 return OpsKnown[OpNo].getKnownBits(
SQ).isNonNegative();
1472 auto IsValidPromotion = [&](
unsigned OpNo) ->
bool {
1474 if (OpsFromSigned != isa<SIToFPInst>(BO.
getOperand(OpNo)) &&
1483 if (MaxRepresentableBits < IntSz) {
1493 NumUsedLeadingBits[OpNo] =
1494 IntSz - OpsKnown[OpNo].getKnownBits(
SQ).countMinLeadingZeros();
1502 if (MaxRepresentableBits < NumUsedLeadingBits[OpNo])
1505 return !OpsFromSigned || BO.
getOpcode() != Instruction::FMul ||
1510 if (Op1FpC !=
nullptr) {
1512 if (OpsFromSigned && BO.
getOpcode() == Instruction::FMul &&
1517 OpsFromSigned ? Instruction::FPToSI : Instruction::FPToUI, Op1FpC,
1519 if (Op1IntC ==
nullptr)
1522 : Instruction::UIToFP,
1523 Op1IntC, FPTy,
DL) != Op1FpC)
1527 IntOps[1] = Op1IntC;
1531 if (IntTy != IntOps[1]->
getType())
1534 if (Op1FpC ==
nullptr) {
1535 if (!IsValidPromotion(1))
1538 if (!IsValidPromotion(0))
1544 bool NeedsOverflowCheck =
true;
1547 unsigned OverflowMaxOutputBits = OpsFromSigned ? 2 : 1;
1548 unsigned OverflowMaxCurBits =
1549 std::max(NumUsedLeadingBits[0], NumUsedLeadingBits[1]);
1550 bool OutputSigned = OpsFromSigned;
1552 case Instruction::FAdd:
1553 IntOpc = Instruction::Add;
1554 OverflowMaxOutputBits += OverflowMaxCurBits;
1556 case Instruction::FSub:
1557 IntOpc = Instruction::Sub;
1558 OverflowMaxOutputBits += OverflowMaxCurBits;
1560 case Instruction::FMul:
1561 IntOpc = Instruction::Mul;
1562 OverflowMaxOutputBits += OverflowMaxCurBits * 2;
1568 if (OverflowMaxOutputBits < IntSz) {
1569 NeedsOverflowCheck =
false;
1572 if (IntOpc == Instruction::Sub)
1573 OutputSigned =
true;
1579 if (NeedsOverflowCheck &&
1580 !willNotOverflow(IntOpc, IntOps[0], IntOps[1], BO, OutputSigned))
1584 if (
auto *IntBO = dyn_cast<BinaryOperator>(IntBinOp)) {
1585 IntBO->setHasNoSignedWrap(OutputSigned);
1586 IntBO->setHasNoUnsignedWrap(!OutputSigned);
1599 std::array<Value *, 2> IntOps = {
nullptr,
nullptr};
1619 if (
Instruction *R = foldFBinOpOfIntCastsFromSign(BO,
false,
1620 IntOps, Op1FpC, OpsKnown))
1622 return foldFBinOpOfIntCastsFromSign(BO,
true, IntOps,
1638 !
X->getType()->isIntOrIntVectorTy(1))
1656 C = dyn_cast<Constant>(IsTrueArm ? SI->getTrueValue()
1657 : SI->getFalseValue());
1658 }
else if (
match(SI->getCondition(),
1665 C = dyn_cast<Constant>(
Op);
1686 bool FoldWithMultiUse) {
1688 if (!SI->hasOneUse() && !FoldWithMultiUse)
1691 Value *TV = SI->getTrueValue();
1692 Value *FV = SI->getFalseValue();
1693 if (!(isa<Constant>(TV) || isa<Constant>(FV)))
1697 if (SI->getType()->isIntOrIntVectorTy(1))
1707 if (
auto *CI = dyn_cast<FCmpInst>(SI->getCondition())) {
1708 if (CI->hasOneUse()) {
1709 Value *Op0 = CI->getOperand(0), *Op1 = CI->getOperand(1);
1710 if ((TV == Op0 && FV == Op1) || (FV == Op0 && TV == Op1))
1718 if (!NewTV && !NewFV)
1756 const ICmpInst *ICmp = dyn_cast<ICmpInst>(&
I);
1760 std::optional<bool> ImpliedCond =
1762 Ops[0], Ops[1],
DL, LHSIsTrue);
1772 if (NumPHIValues == 0)
1782 if (UI != &
I && !
I.isIdenticalTo(UI))
1793 Value *NonSimplifiedInVal =
nullptr;
1794 for (
unsigned i = 0; i != NumPHIValues; ++i) {
1803 if (NonSimplifiedBB)
return nullptr;
1805 NonSimplifiedBB = InBB;
1806 NonSimplifiedInVal = InVal;
1811 if (isa<InvokeInst>(InVal))
1812 if (cast<Instruction>(InVal)->
getParent() == NonSimplifiedBB)
1829 if (NonSimplifiedBB !=
nullptr) {
1845 if (NonSimplifiedBB) {
1849 U = NonSimplifiedInVal;
1851 U = U->DoPHITranslation(PN->
getParent(), NonSimplifiedBB);
1856 for (
unsigned i = 0; i != NumPHIValues; ++i) {
1857 if (NewPhiValues[i])
1865 if (
User == &
I)
continue;
1871 const_cast<PHINode &
>(*NewPN),
1880 auto *Phi0 = dyn_cast<PHINode>(BO.
getOperand(0));
1881 auto *Phi1 = dyn_cast<PHINode>(BO.
getOperand(1));
1882 if (!Phi0 || !Phi1 || !Phi0->hasOneUse() || !Phi1->hasOneUse() ||
1883 Phi0->getNumOperands() != Phi1->getNumOperands())
1887 if (BO.
getParent() != Phi0->getParent() ||
1904 auto CanFoldIncomingValuePair = [&](std::tuple<Use &, Use &>
T) {
1905 auto &Phi0Use = std::get<0>(
T);
1906 auto &Phi1Use = std::get<1>(
T);
1907 if (Phi0->getIncomingBlock(Phi0Use) != Phi1->getIncomingBlock(Phi1Use))
1909 Value *Phi0UseV = Phi0Use.get();
1910 Value *Phi1UseV = Phi1Use.get();
1913 else if (Phi1UseV ==
C)
1920 if (
all_of(
zip(Phi0->operands(), Phi1->operands()),
1921 CanFoldIncomingValuePair)) {
1924 assert(NewIncomingValues.
size() == Phi0->getNumOperands() &&
1925 "The number of collected incoming values should equal the number "
1926 "of the original PHINode operands!");
1927 for (
unsigned I = 0;
I < Phi0->getNumOperands();
I++)
1928 NewPhi->
addIncoming(NewIncomingValues[
I], Phi0->getIncomingBlock(
I));
1933 if (Phi0->getNumOperands() != 2 || Phi1->getNumOperands() != 2)
1940 ConstBB = Phi0->getIncomingBlock(0);
1941 OtherBB = Phi0->getIncomingBlock(1);
1943 ConstBB = Phi0->getIncomingBlock(1);
1944 OtherBB = Phi0->getIncomingBlock(0);
1954 auto *PredBlockBranch = dyn_cast<BranchInst>(OtherBB->
getTerminator());
1955 if (!PredBlockBranch || PredBlockBranch->isConditional() ||
1962 for (
auto BBIter = BO.
getParent()->begin(); &*BBIter != &BO; ++BBIter)
1975 Phi0->getIncomingValueForBlock(OtherBB),
1976 Phi1->getIncomingValueForBlock(OtherBB));
1977 if (
auto *NotFoldedNewBO = dyn_cast<BinaryOperator>(NewBO))
1978 NotFoldedNewBO->copyIRFlags(&BO);
1988 if (!isa<Constant>(
I.getOperand(1)))
1991 if (
auto *Sel = dyn_cast<SelectInst>(
I.getOperand(0))) {
1994 }
else if (
auto *PN = dyn_cast<PHINode>(
I.getOperand(0))) {
2005 if (
GEP.hasAllZeroIndices() && !Src.hasAllZeroIndices() &&
2012 if (!isa<VectorType>(Inst.
getType()))
2018 cast<VectorType>(Inst.
getType())->getElementCount());
2020 cast<VectorType>(Inst.
getType())->getElementCount());
2025 Value *L0, *L1, *R0, *R1;
2030 cast<ShuffleVectorInst>(
LHS)->isConcat() &&
2031 cast<ShuffleVectorInst>(
RHS)->isConcat()) {
2038 if (
auto *BO = dyn_cast<BinaryOperator>(NewBO0))
2041 if (
auto *BO = dyn_cast<BinaryOperator>(NewBO1))
2048 if (
auto *BO = dyn_cast<BinaryOperator>(V))
2065 return createBinOpReverse(V1, V2);
2069 return createBinOpReverse(V1,
RHS);
2073 return createBinOpReverse(
LHS, V2);
2083 if (
auto *BO = dyn_cast<BinaryOperator>(XY))
2092 V1->
getType() == V2->getType() &&
2095 return createBinOpShuffle(V1, V2, Mask);
2104 auto *LShuf = cast<ShuffleVectorInst>(
LHS);
2105 auto *RShuf = cast<ShuffleVectorInst>(
RHS);
2110 if (LShuf->isSelect() &&
2112 RShuf->isSelect() &&
2130 auto *InstVTy = dyn_cast<FixedVectorType>(Inst.
getType());
2135 cast<FixedVectorType>(V1->
getType())->getNumElements() <=
2136 InstVTy->getNumElements()) {
2138 "Shuffle should not change scalar type");
2145 bool ConstOp1 = isa<Constant>(
RHS);
2147 unsigned SrcVecNumElts =
2148 cast<FixedVectorType>(V1->
getType())->getNumElements();
2151 bool MayChange =
true;
2152 unsigned NumElts = InstVTy->getNumElements();
2153 for (
unsigned I = 0;
I < NumElts; ++
I) {
2155 if (ShMask[
I] >= 0) {
2156 assert(ShMask[
I] < (
int)NumElts &&
"Not expecting narrowing shuffle");
2164 if (!CElt || (!isa<PoisonValue>(NewCElt) && NewCElt != CElt) ||
2165 I >= SrcVecNumElts) {
2169 NewVecC[ShMask[
I]] = CElt;
2180 if (
I >= SrcVecNumElts || ShMask[
I] < 0) {
2185 if (!MaybePoison || !isa<PoisonValue>(MaybePoison)) {
2202 Value *NewLHS = ConstOp1 ? V1 : NewC;
2203 Value *NewRHS = ConstOp1 ? NewC : V1;
2204 return createBinOpShuffle(NewLHS, NewRHS, Mask);
2211 if (isa<ShuffleVectorInst>(
RHS))
2244 if (isa<FPMathOperator>(R)) {
2245 R->copyFastMathFlags(&Inst);
2248 if (
auto *NewInstBO = dyn_cast<BinaryOperator>(NewBO))
2249 NewInstBO->copyIRFlags(R);
2278 cast<Operator>(Op1)->getOpcode() == CastOpc &&
2279 (Op0->
hasOneUse() || Op1->hasOneUse()))) {
2297 if (!willNotOverflow(BO.
getOpcode(),
X,
Y, BO, IsSext))
2303 if (
auto *NewBinOp = dyn_cast<BinaryOperator>(NarrowBO)) {
2305 NewBinOp->setHasNoSignedWrap();
2307 NewBinOp->setHasNoUnsignedWrap();
2320 if (!
GEP.hasAllConstantIndices())
2336 Type *Ty =
GEP.getSourceElementType();
2338 Value *NewFalseC = Builder.
CreateGEP(Ty, FalseC, IndexC,
"", NW);
2348 if (
GEP.getNumIndices() != 1)
2357 Type *PtrTy = Src->getType()->getScalarType();
2358 unsigned IndexSizeInBits =
DL.getIndexTypeSizeInBits(PtrTy);
2365 if (isa<ScalableVectorType>(
BaseType))
2369 if (NewOffset.
isZero() ||
2370 (Src->hasOneUse() &&
GEP.getOperand(1)->hasOneUse())) {
2391 Type *PtrTy = Src->getType()->getScalarType();
2392 if (
GEP.hasAllConstantIndices() &&
2393 (Src->hasOneUse() || Src->hasAllConstantIndices())) {
2397 bool IsFirstType =
true;
2398 unsigned NumVarIndices = 0;
2399 for (
auto Pair :
enumerate(Src->indices())) {
2400 if (!isa<ConstantInt>(Pair.value())) {
2402 IsFirstType =
false;
2403 NumVarIndices = Pair.index() + 1;
2410 if (NumVarIndices != Src->getNumIndices()) {
2431 if (!
Offset.isZero() || (!IsFirstType && !ConstIndices[0].isZero())) {
2434 if (Src->hasAllConstantIndices())
2446 Src->getNumIndices() - NumVarIndices));
2453 IsInBounds &=
Idx.isNonNegative() == ConstIndices[0].isNonNegative();
2458 Indices,
"", IsInBounds));
2461 if (Src->getResultElementType() !=
GEP.getSourceElementType())
2467 bool EndsWithSequential =
false;
2470 EndsWithSequential =
I.isSequential();
2473 if (EndsWithSequential) {
2476 Value *SO1 = Src->getOperand(Src->getNumOperands()-1);
2494 if (Src->getNumOperands() == 2) {
2500 Indices.
append(Src->op_begin()+1, Src->op_end()-1);
2503 }
else if (isa<Constant>(*
GEP.idx_begin()) &&
2504 cast<Constant>(*
GEP.idx_begin())->isNullValue() &&
2505 Src->getNumOperands() != 1) {
2507 Indices.
append(Src->op_begin()+1, Src->op_end());
2511 if (!Indices.
empty())
2514 Src->getSourceElementType(), Src->getOperand(0), Indices,
"",
2522 bool &DoesConsume,
unsigned Depth) {
2523 static Value *
const NonNull =
reinterpret_cast<Value *
>(uintptr_t(1));
2541 if (!WillInvertAllUses)
2546 if (
auto *
I = dyn_cast<CmpInst>(V)) {
2557 DoesConsume,
Depth))
2560 DoesConsume,
Depth))
2569 DoesConsume,
Depth))
2572 DoesConsume,
Depth))
2581 DoesConsume,
Depth))
2590 DoesConsume,
Depth))
2602 bool LocalDoesConsume = DoesConsume;
2604 LocalDoesConsume,
Depth))
2607 LocalDoesConsume,
Depth)) {
2608 DoesConsume = LocalDoesConsume;
2611 DoesConsume,
Depth);
2612 assert(NotB !=
nullptr &&
2613 "Unable to build inverted value for known freely invertable op");
2614 if (
auto *
II = dyn_cast<IntrinsicInst>(V))
2623 if (
PHINode *PN = dyn_cast<PHINode>(V)) {
2624 bool LocalDoesConsume = DoesConsume;
2626 for (
Use &U : PN->operands()) {
2627 BasicBlock *IncomingBlock = PN->getIncomingBlock(U);
2631 if (NewIncomingVal ==
nullptr)
2634 if (NewIncomingVal == V)
2637 IncomingValues.
emplace_back(NewIncomingVal, IncomingBlock);
2640 DoesConsume = LocalDoesConsume;
2646 for (
auto [Val, Pred] : IncomingValues)
2655 DoesConsume,
Depth))
2662 DoesConsume,
Depth))
2671 bool IsLogical,
Value *
A,
2673 bool LocalDoesConsume = DoesConsume;
2675 LocalDoesConsume,
Depth))
2678 LocalDoesConsume,
Depth)) {
2680 LocalDoesConsume,
Depth);
2681 DoesConsume = LocalDoesConsume;
2691 return TryInvertAndOrUsingDeMorgan(Instruction::And,
false,
A,
2695 return TryInvertAndOrUsingDeMorgan(Instruction::Or,
false,
A,
2699 return TryInvertAndOrUsingDeMorgan(Instruction::And,
true,
A,
2703 return TryInvertAndOrUsingDeMorgan(Instruction::Or,
true,
A,
2712 Type *GEPType =
GEP.getType();
2713 Type *GEPEltType =
GEP.getSourceElementType();
2722 if (
auto *GEPFVTy = dyn_cast<FixedVectorType>(GEPType)) {
2723 auto VWidth = GEPFVTy->getNumElements();
2724 APInt PoisonElts(VWidth, 0);
2740 bool MadeChange =
false;
2744 Type *NewScalarIndexTy =
2754 Type *IndexTy = (*I)->getType();
2755 Type *NewIndexType =
2758 cast<VectorType>(IndexTy)->getElementCount())
2770 if (IndexTy != NewIndexType) {
2782 if (!GEPEltType->
isIntegerTy(8) &&
GEP.hasAllConstantIndices()) {
2787 GEP.getNoWrapFlags()));
2806 if (
auto *PN = dyn_cast<PHINode>(PtrOp)) {
2807 auto *Op1 = dyn_cast<GetElementPtrInst>(PN->getOperand(0));
2822 for (
auto I = PN->op_begin()+1, E = PN->op_end();
I !=E; ++
I) {
2823 auto *Op2 = dyn_cast<GetElementPtrInst>(*
I);
2824 if (!Op2 || Op1->getNumOperands() != Op2->getNumOperands() ||
2825 Op1->getSourceElementType() != Op2->getSourceElementType())
2833 Type *CurTy =
nullptr;
2835 for (
unsigned J = 0,
F = Op1->getNumOperands(); J !=
F; ++J) {
2836 if (Op1->getOperand(J)->getType() != Op2->getOperand(J)->getType())
2839 if (Op1->getOperand(J) != Op2->getOperand(J)) {
2848 assert(CurTy &&
"No current type?");
2868 CurTy = Op1->getSourceElementType();
2880 if (DI != -1 && !PN->hasOneUse())
2883 auto *NewGEP = cast<GetElementPtrInst>(Op1->clone());
2896 PN->getNumOperands());
2899 for (
auto &
I : PN->operands())
2900 NewPN->
addIncoming(cast<GEPOperator>(
I)->getOperand(DI),
2901 PN->getIncomingBlock(
I));
2903 NewGEP->setOperand(DI, NewPN);
2906 NewGEP->insertBefore(*
GEP.getParent(),
GEP.getParent()->getFirstInsertionPt());
2910 if (
auto *Src = dyn_cast<GEPOperator>(PtrOp))
2914 if (
GEP.getNumIndices() == 1) {
2915 unsigned AS =
GEP.getPointerAddressSpace();
2916 if (
GEP.getOperand(1)->getType()->getScalarSizeInBits() ==
2920 if (TyAllocSize == 1) {
2929 GEPType ==
Y->getType()) {
2930 bool HasSameUnderlyingObject =
2932 bool Changed =
false;
2933 GEP.replaceUsesWithIf(
Y, [&](
Use &U) {
2934 bool ShouldReplace = HasSameUnderlyingObject ||
2935 isa<ICmpInst>(U.getUser()) ||
2936 isa<PtrToIntInst>(U.getUser());
2937 Changed |= ShouldReplace;
2938 return ShouldReplace;
2940 return Changed ? &
GEP :
nullptr;
2942 }
else if (
auto *ExactIns =
2943 dyn_cast<PossiblyExactOperator>(
GEP.getOperand(1))) {
2946 if (ExactIns->isExact()) {
2954 GEP.getPointerOperand(), V,
2955 GEP.getNoWrapFlags());
2958 if (ExactIns->isExact() && ExactIns->hasOneUse()) {
2964 std::optional<APInt> NewC;
2984 if (NewC.has_value()) {
2987 ConstantInt::get(V->getType(), *NewC));
2988 cast<BinaryOperator>(NewOp)->setIsExact();
2990 GEP.getPointerOperand(), NewOp,
2991 GEP.getNoWrapFlags());
3001 if (
GEP.getNumIndices() == 1) {
3004 auto CanPreserveInBounds = [&](
bool AddIsNSW,
Value *Idx1,
Value *Idx2) {
3019 bool IsInBounds = CanPreserveInBounds(
3020 cast<OverflowingBinaryOperator>(
GEP.getOperand(1))->hasNoSignedWrap(),
3024 Idx1,
"", IsInBounds);
3038 bool IsInBounds = CanPreserveInBounds(
3041 GEP.getSourceElementType(),
GEP.getPointerOperand(),
3052 if (!
GEP.isInBounds()) {
3055 APInt BasePtrOffset(IdxWidth, 0);
3056 Value *UnderlyingPtrOp =
3059 bool CanBeNull, CanBeFreed;
3061 DL, CanBeNull, CanBeFreed);
3062 if (!CanBeNull && !CanBeFreed && DerefBytes != 0) {
3063 if (
GEP.accumulateConstantOffset(
DL, BasePtrOffset) &&
3065 APInt AllocSize(IdxWidth, DerefBytes);
3066 if (BasePtrOffset.
ule(AllocSize)) {
3068 GEP.getSourceElementType(), PtrOp, Indices,
GEP.getName());
3082 if (isa<ConstantPointerNull>(V))
3084 if (
auto *LI = dyn_cast<LoadInst>(V))
3085 return isa<GlobalVariable>(LI->getPointerOperand());
3109 return Dest && Dest->Ptr == UsedV;
3123 switch (
I->getOpcode()) {
3128 case Instruction::AddrSpaceCast:
3129 case Instruction::BitCast:
3130 case Instruction::GetElementPtr:
3135 case Instruction::ICmp: {
3142 unsigned OtherIndex = (ICI->
getOperand(0) == PI) ? 1 : 0;
3149 auto AlignmentAndSizeKnownValid = [](
CallBase *CB) {
3153 const APInt *Alignment;
3155 return match(CB->getArgOperand(0),
m_APInt(Alignment)) &&
3159 auto *CB = dyn_cast<CallBase>(AI);
3161 if (CB && TLI.
getLibFunc(*CB->getCalledFunction(), TheLibFunc) &&
3162 TLI.
has(TheLibFunc) && TheLibFunc == LibFunc_aligned_alloc &&
3163 !AlignmentAndSizeKnownValid(CB))
3169 case Instruction::Call:
3172 switch (
II->getIntrinsicID()) {
3176 case Intrinsic::memmove:
3177 case Intrinsic::memcpy:
3178 case Intrinsic::memset: {
3180 if (
MI->isVolatile() ||
MI->getRawDest() != PI)
3184 case Intrinsic::assume:
3185 case Intrinsic::invariant_start:
3186 case Intrinsic::invariant_end:
3187 case Intrinsic::lifetime_start:
3188 case Intrinsic::lifetime_end:
3189 case Intrinsic::objectsize:
3192 case Intrinsic::launder_invariant_group:
3193 case Intrinsic::strip_invariant_group:
3222 case Instruction::Store: {
3224 if (SI->isVolatile() || SI->getPointerOperand() != PI)
3232 }
while (!Worklist.
empty());
3255 std::unique_ptr<DIBuilder> DIB;
3256 if (isa<AllocaInst>(
MI)) {
3262 for (
unsigned i = 0, e =
Users.size(); i != e; ++i) {
3271 if (
II->getIntrinsicID() == Intrinsic::objectsize) {
3274 II,
DL, &
TLI,
AA,
true, &InsertedInstructions);
3275 for (
Instruction *Inserted : InsertedInstructions)
3283 for (
unsigned i = 0, e =
Users.size(); i != e; ++i) {
3292 C->isFalseWhenEqual()));
3293 }
else if (
auto *SI = dyn_cast<StoreInst>(
I)) {
3294 for (
auto *DVI : DVIs)
3295 if (DVI->isAddressOfVariable())
3297 for (
auto *DVR : DVRs)
3298 if (DVR->isAddressOfVariable())
3313 std::nullopt,
"",
II->getParent());
3341 for (
auto *DVI : DVIs)
3342 if (DVI->isAddressOfVariable() || DVI->getExpression()->startsWithDeref())
3343 DVI->eraseFromParent();
3344 for (
auto *DVR : DVRs)
3345 if (DVR->isAddressOfVariable() || DVR->getExpression()->startsWithDeref())
3346 DVR->eraseFromParent();
3392 if (FreeInstrBB->
size() != 2) {
3394 if (&Inst == &FI || &Inst == FreeInstrBBTerminator)
3396 auto *Cast = dyn_cast<CastInst>(&Inst);
3397 if (!Cast || !Cast->isNoopCast(
DL))
3418 "Broken CFG: missing edge from predecessor to successor");
3423 if (&Instr == FreeInstrBBTerminator)
3425 Instr.moveBeforePreserving(TI);
3428 "Only the branch instruction should remain");
3439 Attrs = Attrs.removeParamAttribute(FI.
getContext(), 0, Attribute::NonNull);
3440 Attribute Dereferenceable = Attrs.getParamAttr(0, Attribute::Dereferenceable);
3441 if (Dereferenceable.
isValid()) {
3443 Attrs = Attrs.removeParamAttribute(FI.
getContext(), 0,
3444 Attribute::Dereferenceable);
3445 Attrs = Attrs.addDereferenceableOrNullParamAttr(FI.
getContext(), 0, Bytes);
3454 if (isa<UndefValue>(
Op)) {
3462 if (isa<ConstantPointerNull>(
Op))
3498 FPClassTest ReturnClass =
F->getAttributes().getRetNoFPClass();
3499 if (ReturnClass ==
fcNone)
3516 bool Changed =
false;
3517 while (
Instruction *Prev =
I.getPrevNonDebugInstruction()) {
3522 if (Prev->isEHPad())
3553 return BBI->isDebugOrPseudoInst() ||
3554 (isa<BitCastInst>(BBI) && BBI->getType()->isPointerTy());
3559 if (BBI != FirstInstr)
3561 }
while (BBI != FirstInstr && IsNoopInstrForStoreMerging(BBI));
3563 return dyn_cast<StoreInst>(BBI);
3575 if (!
DeadEdges.insert({From, To}).second)
3580 for (
Use &U : PN.incoming_values())
3581 if (PN.getIncomingBlock(U) ==
From && !isa<PoisonValue>(U)) {
3597 std::next(
I->getReverseIterator())))) {
3598 if (!Inst.use_empty() && !Inst.getType()->isTokenTy()) {
3602 if (Inst.isEHPad() || Inst.getType()->isTokenTy())
3605 Inst.dropDbgRecords();
3613 for (
Value *V : Changed)
3640 if (Succ == LiveSucc)
3668 if (isa<SelectInst>(
Cond) &&
3689 auto *Cmp = cast<CmpInst>(
Cond);
3698 if (isa<UndefValue>(
Cond)) {
3702 if (
auto *CI = dyn_cast<ConstantInt>(
Cond)) {
3718 unsigned CstOpIdx = IsTrueArm ? 1 : 2;
3719 auto *
C = dyn_cast<ConstantInt>(
Select->getOperand(CstOpIdx));
3723 BasicBlock *CstBB = SI.findCaseValue(
C)->getCaseSuccessor();
3724 if (CstBB != SI.getDefaultDest())
3737 for (
auto Case : SI.cases())
3738 if (!CR.
contains(Case.getCaseValue()->getValue()))
3750 for (
auto Case : SI.cases()) {
3752 assert(isa<ConstantInt>(NewCase) &&
3753 "Result of expression should be constant");
3754 Case.setValue(cast<ConstantInt>(NewCase));
3762 for (
auto Case : SI.cases()) {
3764 assert(isa<ConstantInt>(NewCase) &&
3765 "Result of expression should be constant");
3766 Case.setValue(cast<ConstantInt>(NewCase));
3774 all_of(SI.cases(), [&](
const auto &Case) {
3775 return Case.getCaseValue()->getValue().countr_zero() >= ShiftAmt;
3781 Value *NewCond = Op0;
3788 for (
auto Case : SI.cases()) {
3789 const APInt &CaseVal = Case.getCaseValue()->getValue();
3791 : CaseVal.
lshr(ShiftAmt);
3792 Case.setValue(ConstantInt::get(SI.getContext(), ShiftedCase));
3800 bool IsZExt = isa<ZExtInst>(
Cond);
3804 if (
all_of(SI.cases(), [&](
const auto &Case) {
3805 const APInt &CaseVal = Case.getCaseValue()->getValue();
3806 return IsZExt ? CaseVal.isIntN(NewWidth)
3807 : CaseVal.isSignedIntN(NewWidth);
3809 for (
auto &Case : SI.cases()) {
3810 APInt TruncatedCase = Case.getCaseValue()->getValue().
trunc(NewWidth);
3811 Case.setValue(ConstantInt::get(SI.getContext(), TruncatedCase));
3818 if (
auto *
Select = dyn_cast<SelectInst>(
Cond)) {
3833 for (
const auto &
C : SI.cases()) {
3835 std::min(LeadingKnownZeros,
C.getCaseValue()->getValue().countl_zero());
3837 std::min(LeadingKnownOnes,
C.getCaseValue()->getValue().countl_one());
3840 unsigned NewWidth = Known.
getBitWidth() - std::max(LeadingKnownZeros, LeadingKnownOnes);
3846 if (NewWidth > 0 && NewWidth < Known.
getBitWidth() &&
3847 shouldChangeType(Known.
getBitWidth(), NewWidth)) {
3852 for (
auto Case : SI.cases()) {
3853 APInt TruncatedCase = Case.getCaseValue()->getValue().
trunc(NewWidth);
3854 Case.setValue(ConstantInt::get(SI.getContext(), TruncatedCase));
3859 if (isa<UndefValue>(
Cond)) {
3863 if (
auto *CI = dyn_cast<ConstantInt>(
Cond)) {
3865 SI.findCaseValue(CI)->getCaseSuccessor());
3879 const APInt *
C =
nullptr;
3881 if (*EV.
idx_begin() == 0 && (OvID == Intrinsic::smul_with_overflow ||
3882 OvID == Intrinsic::umul_with_overflow)) {
3887 if (
C->isPowerOf2()) {
3888 return BinaryOperator::CreateShl(
3890 ConstantInt::get(WO->getLHS()->getType(),
C->logBase2()));
3898 if (!WO->hasOneUse())
3912 assert(*EV.
idx_begin() == 1 &&
"Unexpected extract index for overflow inst");
3915 if (OvID == Intrinsic::usub_with_overflow)
3920 if (OvID == Intrinsic::smul_with_overflow &&
3921 WO->getLHS()->getType()->isIntOrIntVectorTy(1))
3922 return BinaryOperator::CreateAnd(WO->getLHS(), WO->getRHS());
3925 if (OvID == Intrinsic::umul_with_overflow && WO->getLHS() == WO->getRHS()) {
3926 unsigned BitWidth = WO->getLHS()->getType()->getScalarSizeInBits();
3931 ConstantInt::get(WO->getLHS()->getType(),
3942 WO->getBinaryOp(), *
C, WO->getNoWrapKind());
3947 auto *OpTy = WO->getRHS()->getType();
3948 auto *NewLHS = WO->getLHS();
3952 ConstantInt::get(OpTy, NewRHSC));
3970 const unsigned *exti, *exte, *insi, *inse;
3971 for (exti = EV.
idx_begin(), insi =
IV->idx_begin(),
3972 exte = EV.
idx_end(), inse =
IV->idx_end();
3973 exti != exte && insi != inse;
3987 if (exti == exte && insi == inse)
4020 if (
Instruction *R = foldExtractOfOverflowIntrinsic(EV))
4023 if (
LoadInst *L = dyn_cast<LoadInst>(Agg)) {
4025 if (
auto *STy = dyn_cast<StructType>(Agg->
getType());
4026 STy && STy->containsScalableVectorType())
4034 if (L->isSimple() && L->hasOneUse()) {
4046 L->getPointerOperand(), Indices);
4050 NL->setAAMetadata(L->getAAMetadata());
4057 if (
auto *PN = dyn_cast<PHINode>(Agg))
4063 if (
auto *SI = dyn_cast<SelectInst>(Agg))
4080 switch (Personality) {
4110 cast<ArrayType>(
LHS->
getType())->getNumElements()
4112 cast<ArrayType>(
RHS->
getType())->getNumElements();
4124 bool MakeNewInstruction =
false;
4126 bool CleanupFlag =
LI.isCleanup();
4129 for (
unsigned i = 0, e =
LI.getNumClauses(); i != e; ++i) {
4130 bool isLastClause = i + 1 == e;
4131 if (
LI.isCatch(i)) {
4138 if (AlreadyCaught.
insert(TypeInfo).second) {
4143 MakeNewInstruction =
true;
4150 MakeNewInstruction =
true;
4151 CleanupFlag =
false;
4162 assert(
LI.isFilter(i) &&
"Unsupported landingpad clause!");
4170 if (!NumTypeInfos) {
4173 MakeNewInstruction =
true;
4174 CleanupFlag =
false;
4178 bool MakeNewFilter =
false;
4180 if (isa<ConstantAggregateZero>(FilterClause)) {
4182 assert(NumTypeInfos > 0 &&
"Should have handled empty filter already!");
4188 MakeNewInstruction =
true;
4195 if (NumTypeInfos > 1)
4196 MakeNewFilter =
true;
4200 NewFilterElts.
reserve(NumTypeInfos);
4205 bool SawCatchAll =
false;
4206 for (
unsigned j = 0; j != NumTypeInfos; ++j) {
4234 if (SeenInFilter.
insert(TypeInfo).second)
4235 NewFilterElts.
push_back(cast<Constant>(Elt));
4240 MakeNewInstruction =
true;
4245 if (NewFilterElts.
size() < NumTypeInfos)
4246 MakeNewFilter =
true;
4248 if (MakeNewFilter) {
4250 NewFilterElts.
size());
4252 MakeNewInstruction =
true;
4261 if (MakeNewFilter && !NewFilterElts.
size()) {
4262 assert(MakeNewInstruction &&
"New filter but not a new instruction!");
4263 CleanupFlag =
false;
4274 for (
unsigned i = 0, e = NewClauses.
size(); i + 1 < e; ) {
4277 for (j = i; j != e; ++j)
4278 if (!isa<ArrayType>(NewClauses[j]->
getType()))
4284 for (
unsigned k = i; k + 1 < j; ++k)
4288 std::stable_sort(NewClauses.
begin() + i, NewClauses.
begin() + j,
4290 MakeNewInstruction =
true;
4309 for (
unsigned i = 0; i + 1 < NewClauses.
size(); ++i) {
4319 for (
unsigned j = NewClauses.
size() - 1; j != i; --j) {
4320 Value *LFilter = NewClauses[j];
4331 NewClauses.
erase(J);
4332 MakeNewInstruction =
true;
4342 if (isa<ConstantAggregateZero>(LFilter)) {
4345 if (isa<ConstantAggregateZero>(
Filter)) {
4346 assert(FElts <= LElts &&
"Should have handled this case earlier!");
4348 NewClauses.
erase(J);
4349 MakeNewInstruction =
true;
4355 if (isa<ConstantAggregateZero>(
Filter)) {
4358 assert(FElts > 0 &&
"Should have eliminated the empty filter earlier!");
4359 for (
unsigned l = 0; l != LElts; ++l)
4362 NewClauses.
erase(J);
4363 MakeNewInstruction =
true;
4374 bool AllFound =
true;
4375 for (
unsigned f = 0; f != FElts; ++f) {
4378 for (
unsigned l = 0; l != LElts; ++l) {
4380 if (LTypeInfo == FTypeInfo) {
4390 NewClauses.
erase(J);
4391 MakeNewInstruction =
true;
4399 if (MakeNewInstruction) {
4407 if (NewClauses.empty())
4415 if (
LI.isCleanup() != CleanupFlag) {
4416 assert(!CleanupFlag &&
"Adding a cleanup, not removing one?!");
4417 LI.setCleanup(CleanupFlag);
4441 auto *OrigOpInst = dyn_cast<Instruction>(OrigOp);
4446 if (!OrigOpInst || !OrigOpInst->hasOneUse() || isa<PHINode>(OrigOp))
4460 Use *MaybePoisonOperand =
nullptr;
4461 for (
Use &U : OrigOpInst->operands()) {
4462 if (isa<MetadataAsValue>(U.get()) ||
4465 if (!MaybePoisonOperand)
4466 MaybePoisonOperand = &U;
4471 OrigOpInst->dropPoisonGeneratingAnnotations();
4474 if (!MaybePoisonOperand)
4479 MaybePoisonOperand->get(), MaybePoisonOperand->get()->
getName() +
".fr");
4481 replaceUse(*MaybePoisonOperand, FrozenMaybePoisonOperand);
4492 Use *StartU =
nullptr;
4510 Value *StartV = StartU->get();
4522 if (!Visited.
insert(V).second)
4525 if (Visited.
size() > 32)
4542 I->dropPoisonGeneratingAnnotations();
4544 if (StartNeedsFreeze) {
4556 if (isa<Constant>(
Op) ||
Op->hasOneUse())
4565 if (isa<Argument>(
Op)) {
4569 auto MoveBeforeOpt = cast<Instruction>(
Op)->getInsertionPointAfterDef();
4572 MoveBefore = *MoveBeforeOpt;
4576 if (isa<DbgInfoIntrinsic>(MoveBefore))
4577 MoveBefore = MoveBefore->getNextNonDebugInstruction()->getIterator();
4580 MoveBefore.setHeadBit(
false);
4582 bool Changed =
false;
4583 if (&FI != &*MoveBefore) {
4584 FI.
moveBefore(*MoveBefore->getParent(), MoveBefore);
4588 Op->replaceUsesWithIf(&FI, [&](
Use &U) ->
bool {
4590 Changed |= Dominates;
4599 for (
auto *U : V->users()) {
4600 if (isa<ShuffleVectorInst>(U))
4609 Value *Op0 =
I.getOperand(0);
4615 if (
auto *PN = dyn_cast<PHINode>(Op0)) {
4638 auto getUndefReplacement = [&
I](
Type *Ty) {
4641 for (
const auto *U :
I.users()) {
4650 else if (BestValue !=
C)
4651 BestValue = NullValue;
4653 assert(BestValue &&
"Must have at least one use");
4668 Constant *ReplaceC = getUndefReplacement(
I.getType()->getScalarType());
4683 auto *CB = dyn_cast<CallBase>(
I);
4702 for (
const User *U :
I.users()) {
4703 if (Visited.
insert(U).second)
4708 while (!AllocaUsers.
empty()) {
4709 auto *UserI = cast<Instruction>(AllocaUsers.
pop_back_val());
4710 if (isa<BitCastInst>(UserI) || isa<GetElementPtrInst>(UserI) ||
4711 isa<AddrSpaceCastInst>(UserI)) {
4732 if (isa<PHINode>(
I) ||
I->isEHPad() ||
I->mayThrow() || !
I->willReturn() ||
4740 if (isa<AllocaInst>(
I))
4748 if (
auto *CI = dyn_cast<CallInst>(
I)) {
4749 if (CI->isConvergent())
4755 if (
I->mayWriteToMemory()) {
4762 if (
I->mayReadFromMemory()) {
4769 E =
I->getParent()->end();
4771 if (Scan->mayWriteToMemory())
4775 I->dropDroppableUses([&](
const Use *U) {
4776 auto *
I = dyn_cast<Instruction>(U->getUser());
4777 if (
I &&
I->getParent() != DestBlock) {
4787 I->moveBefore(*DestBlock, InsertPos);
4798 if (!DbgUsers.
empty())
4800 if (!DbgVariableRecords.
empty())
4802 DbgVariableRecords);
4822 for (
auto &DbgUser : DbgUsers)
4823 if (DbgUser->getParent() != DestBlock)
4830 if (DVI->getParent() == SrcBlock)
4833 [](
auto *
A,
auto *
B) {
return B->comesBefore(
A); });
4837 for (
auto *
User : DbgUsersToSink) {
4842 if (isa<DbgDeclareInst>(
User))
4847 User->getDebugLoc()->getInlinedAt());
4849 if (!SunkVariables.
insert(DbgUserVariable).second)
4854 if (isa<DbgAssignIntrinsic>(
User))
4857 DIIClones.emplace_back(cast<DbgVariableIntrinsic>(
User->clone()));
4858 if (isa<DbgDeclareInst>(
User) && isa<CastInst>(
I))
4859 DIIClones.back()->replaceVariableLocationOp(
I,
I->getOperand(0));
4864 if (!DIIClones.empty()) {
4869 DIIClone->insertBefore(&*InsertPos);
4884 for (
auto &DVR : DbgVariableRecords)
4885 if (DVR->getParent() != DestBlock)
4886 DbgVariableRecordsToSalvage.
push_back(DVR);
4892 if (DVR->getParent() == SrcBlock)
4893 DbgVariableRecordsToSink.
push_back(DVR);
4900 return B->getInstruction()->comesBefore(
A->getInstruction());
4907 using InstVarPair = std::pair<const Instruction *, DebugVariable>;
4909 if (DbgVariableRecordsToSink.
size() > 1) {
4915 DVR->getDebugLoc()->getInlinedAt());
4916 CountMap[std::make_pair(DVR->getInstruction(), DbgUserVariable)] += 1;
4922 for (
auto It : CountMap) {
4923 if (It.second > 1) {
4924 FilterOutMap[It.first] =
nullptr;
4925 DupSet.
insert(It.first.first);
4936 DVR.getDebugLoc()->getInlinedAt());
4938 FilterOutMap.
find(std::make_pair(Inst, DbgUserVariable));
4939 if (FilterIt == FilterOutMap.
end())
4941 if (FilterIt->second !=
nullptr)
4943 FilterIt->second = &DVR;
4958 DVR->getDebugLoc()->getInlinedAt());
4962 if (!FilterOutMap.
empty()) {
4963 InstVarPair IVP = std::make_pair(DVR->getInstruction(), DbgUserVariable);
4964 auto It = FilterOutMap.
find(IVP);
4967 if (It != FilterOutMap.
end() && It->second != DVR)
4971 if (!SunkVariables.
insert(DbgUserVariable).second)
4974 if (DVR->isDbgAssign())
4982 if (DVRClones.
empty())
4996 assert(InsertPos.getHeadBit());
4998 InsertPos->getParent()->insertDbgRecordBefore(DVRClone, InsertPos);
5022 if (
I ==
nullptr)
continue;
5037 auto getOptionalSinkBlockForInst =
5038 [
this](
Instruction *
I) -> std::optional<BasicBlock *> {
5040 return std::nullopt;
5044 unsigned NumUsers = 0;
5046 for (
Use &U :
I->uses()) {
5051 return std::nullopt;
5056 if (
PHINode *PN = dyn_cast<PHINode>(UserInst))
5057 UserBB = PN->getIncomingBlock(U);
5061 if (UserParent && UserParent != UserBB)
5062 return std::nullopt;
5063 UserParent = UserBB;
5067 if (NumUsers == 0) {
5071 return std::nullopt;
5083 return std::nullopt;
5093 return std::nullopt;
5098 auto OptBB = getOptionalSinkBlockForInst(
I);
5100 auto *UserParent = *OptBB;
5108 for (
Use &U :
I->operands())
5109 if (
Instruction *OpI = dyn_cast<Instruction>(U.get()))
5117 I, {LLVMContext::MD_dbg, LLVMContext::MD_annotation});
5130 <<
" New = " << *Result <<
'\n');
5132 Result->copyMetadata(*
I,
5133 {LLVMContext::MD_dbg, LLVMContext::MD_annotation});
5135 I->replaceAllUsesWith(Result);
5138 Result->takeName(
I);
5145 if (isa<PHINode>(Result) != isa<PHINode>(
I)) {
5147 if (isa<PHINode>(
I))
5153 Result->insertInto(InstParent, InsertPos);
5162 <<
" New = " << *
I <<
'\n');
5194 if (!
I->hasMetadataOtherThanDebugLoc())
5197 auto Track = [](
Metadata *ScopeList,
auto &Container) {
5198 const auto *MDScopeList = dyn_cast_or_null<MDNode>(ScopeList);
5199 if (!MDScopeList || !Container.insert(MDScopeList).second)
5201 for (
const auto &
MDOperand : MDScopeList->operands())
5202 if (
auto *MDScope = dyn_cast<MDNode>(
MDOperand))
5203 Container.insert(MDScope);
5206 Track(
I->getMetadata(LLVMContext::MD_alias_scope), UsedAliasScopesAndLists);
5207 Track(
I->getMetadata(LLVMContext::MD_noalias), UsedNoAliasScopesAndLists);
5216 "llvm.experimental.noalias.scope.decl in use ?");
5219 "llvm.experimental.noalias.scope should refer to a single scope");
5221 if (
auto *MD = dyn_cast<MDNode>(
MDOperand))
5222 return !UsedAliasScopesAndLists.
contains(MD) ||
5223 !UsedNoAliasScopesAndLists.
contains(MD);
5248 if (Succ != LiveSucc &&
DeadEdges.insert({BB, Succ}).second)
5249 for (
PHINode &PN : Succ->phis())
5250 for (
Use &U : PN.incoming_values())
5251 if (PN.getIncomingBlock(U) == BB && !isa<PoisonValue>(U)) {
5261 HandleOnlyLiveSuccessor(BB,
nullptr);
5268 if (!Inst.use_empty() &&
5269 (Inst.getNumOperands() == 0 || isa<Constant>(Inst.getOperand(0))))
5273 Inst.replaceAllUsesWith(
C);
5276 Inst.eraseFromParent();
5282 for (
Use &U : Inst.operands()) {
5283 if (!isa<ConstantVector>(U) && !isa<ConstantExpr>(U))
5286 auto *
C = cast<Constant>(U);
5287 Constant *&FoldRes = FoldedConstants[
C];
5293 <<
"\n Old = " << *
C
5294 <<
"\n New = " << *FoldRes <<
'\n');
5303 if (!Inst.isDebugOrPseudoInst()) {
5304 InstrsForInstructionWorklist.
push_back(&Inst);
5305 SeenAliasScopes.
analyse(&Inst);
5313 if (isa<UndefValue>(BI->getCondition())) {
5315 HandleOnlyLiveSuccessor(BB,
nullptr);
5318 if (
auto *
Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
5319 bool CondVal =
Cond->getZExtValue();
5320 HandleOnlyLiveSuccessor(BB, BI->getSuccessor(!CondVal));
5323 }
else if (
SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
5324 if (isa<UndefValue>(SI->getCondition())) {
5326 HandleOnlyLiveSuccessor(BB,
nullptr);
5329 if (
auto *
Cond = dyn_cast<ConstantInt>(SI->getCondition())) {
5330 HandleOnlyLiveSuccessor(BB,
5331 SI->findCaseValue(
Cond)->getCaseSuccessor());
5341 if (LiveBlocks.
count(&BB))
5344 unsigned NumDeadInstInBB;
5345 unsigned NumDeadDbgInstInBB;
5346 std::tie(NumDeadInstInBB, NumDeadDbgInstInBB) =
5349 MadeIRChange |= NumDeadInstInBB + NumDeadDbgInstInBB > 0;
5350 NumDeadInst += NumDeadInstInBB;
5367 Inst->eraseFromParent();
5384 auto &
DL =
F.getDataLayout();
5392 if (
auto *Assume = dyn_cast<AssumeInst>(
I))
5400 bool MadeIRChange =
false;
5405 unsigned Iteration = 0;
5411 <<
" on " <<
F.getName()
5412 <<
" reached; stopping without verifying fixpoint\n");
5416 ++NumWorklistIterations;
5417 LLVM_DEBUG(
dbgs() <<
"\n\nINSTCOMBINE ITERATION #" << Iteration <<
" on "
5418 <<
F.getName() <<
"\n");
5421 ORE, BFI, BPI, PSI,
DL, LI);
5424 MadeChangeInThisIteration |= IC.
run();
5425 if (!MadeChangeInThisIteration)
5428 MadeIRChange =
true;
5431 "Instruction Combining did not reach a fixpoint after " +
5439 else if (Iteration == 2)
5441 else if (Iteration == 3)
5442 ++NumThreeIterations;
5444 ++NumFourOrMoreIterations;
5446 return MadeIRChange;
5454 OS, MapClassName2PassName);
5457 OS << (Options.
UseLoopInfo ?
"" :
"no-") <<
"use-loop-info;";
5480 auto *BFI = (PSI && PSI->hasProfileSummary()) ?
5485 BFI, BPI, PSI, LI, Options))
5516 auto AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
5517 auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
F);
5518 auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(
F);
5519 auto &
TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
F);
5520 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
5521 auto &ORE = getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE();
5524 auto *LIWP = getAnalysisIfAvailable<LoopInfoWrapperPass>();
5525 auto *LI = LIWP ? &LIWP->getLoopInfo() :
nullptr;
5527 &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
5530 &getAnalysis<LazyBlockFrequencyInfoPass>().getBFI() :
5533 if (
auto *WrapperPass =
5534 getAnalysisIfAvailable<BranchProbabilityInfoWrapperPass>())
5535 BPI = &WrapperPass->getBPI();
5549 "Combine redundant instructions",
false,
false)
amdgpu AMDGPU Register Bank Select
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Expand Atomic instructions
static const Function * getParent(const Value *V)
This is the interface for LLVM's primary stateless and local alias analysis.
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file provides an implementation of debug counters.
#define DEBUG_COUNTER(VARNAME, COUNTERNAME, DESC)
This file defines the DenseMap class.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
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 defines the Use class.
iv Induction Variable Users
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 combineInstructionsOverFunction(Function &F, InstructionWorklist &Worklist, AliasAnalysis *AA, AssumptionCache &AC, TargetLibraryInfo &TLI, TargetTransformInfo &TTI, DominatorTree &DT, OptimizationRemarkEmitter &ORE, BlockFrequencyInfo *BFI, BranchProbabilityInfo *BPI, ProfileSummaryInfo *PSI, LoopInfo *LI, const InstCombineOptions &Opts)
static bool shorter_filter(const Value *LHS, const Value *RHS)
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 Value * simplifyInstructionWithPHI(Instruction &I, PHINode *PN, Value *InValue, BasicBlock *InBB, const DataLayout &DL, const SimplifyQuery SQ)
static void ClearSubclassDataAfterReassociation(BinaryOperator &I)
Conservatively clears subclassOptionalData after a reassociation or commutation.
static bool isAllocSiteRemovable(Instruction *AI, SmallVectorImpl< WeakTrackingVH > &Users, const TargetLibraryInfo &TLI)
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 bool leftDistributesOverRight(Instruction::BinaryOps LOp, Instruction::BinaryOps ROp)
Return whether "X LOp (Y ROp Z)" is always equal to "(X LOp Y) ROp (X LOp Z)".
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 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 Constant * constantFoldOperationIntoSelectOperand(Instruction &I, SelectInst *SI, bool IsTrueArm)
static bool isCatchAll(EHPersonality Personality, Constant *TypeInfo)
Return 'true' if the given typeinfo will match anything.
static bool isMergedGEPInBounds(GEPOperator &GEP1, GEPOperator &GEP2)
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)
uint64_t IntrinsicInst * II
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
static bool IsSelect(MachineInstr &MI)
This header defines various interfaces for pass management in LLVM.
#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
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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 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.
Class for arbitrary precision integers.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
static 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 void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
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.
APInt sadd_ov(const APInt &RHS, bool &Overflow) const
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
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.
APInt ssub_ov(const APInt &RHS, bool &Overflow) const
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
A container for analyses that lazily runs them and caches their results.
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.
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),...
size_t size() const
size - Get the array size.
Class to represent array types.
uint64_t getNumElements() const
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
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.
void registerAssumption(AssumeInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
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.
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
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.
InstListType::const_iterator getFirstNonPHIIt() const
Iterator returning form of getFirstNonPHI.
const Instruction & front() const
bool isEntryBlock() const
Return true if this is the entry block of the containing function.
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
InstListType::iterator iterator
Instruction iterators...
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 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 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.
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.
void swapSuccEdgesProbabilities(const BasicBlock *Src)
Swap outgoing edges probabilities for Src with branch terminator.
Represents analyses that only rely on functions' control flow.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
bool doesNotThrow() const
Determine if the call cannot unwind.
Value * getArgOperand(unsigned i) const
AttributeList getAttributes() const
Return the parameter 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 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,...
Predicate getPredicate() const
Return the predicate for this instruction.
ConstantArray - Constant Array Declarations.
static 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 Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getNot(Constant *C)
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false, bool NSZ=false)
Return the identity constant for a binary opcode.
static Constant * getNeg(Constant *C, bool HasNSW=false)
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getFalse(LLVMContext &Context)
static ConstantInt * getBool(LLVMContext &Context, bool V)
This class represents a range of values.
bool getEquivalentICmp(CmpInst::Predicate &Pred, APInt &RHS) const
Set up Pred and RHS such that ConstantRange::makeExactICmpRegion(Pred, RHS) == *this.
static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred, const APInt &Other)
Produce the exact range such that all values in the returned range satisfy the given predicate with a...
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
static 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 Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
static 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 Constant * replaceUndefsWith(Constant *C, Constant *Replacement)
Try to replace undefined constant C or undefined elements in C with Replacement.
static Constant * getAllOnesValue(Type *Ty)
const Constant * stripPointerCasts() const
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
SmallVector< APInt > getGEPIndicesForOffset(Type *&ElemTy, APInt &Offset) const
Get GEP indices to access Offset inside ElemTy.
bool isLegalInteger(uint64_t Width) const
Returns true if the specified type is known to be a native integer type supported by the CPU.
unsigned getIndexTypeSizeInBits(Type *Ty) const
Layout size of the index used in GEP calculation.
IntegerType * getIndexType(LLVMContext &C, unsigned AddressSpace) const
Returns the type of a GEP index in AddressSpace.
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
unsigned getIndexSizeInBits(unsigned AS) const
Size in bits of index used for address calculation in getelementptr.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
int64_t getIndexedOffsetInType(Type *ElemTy, ArrayRef< Value * > Indices) const
Returns the offset from the beginning of the type for the specified indices.
This is the common base class for debug info intrinsics for variables.
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.
iterator find(const_arg_type_t< KeyT > Val)
void registerBranch(BranchInst *BI)
Add a branch condition to the cache.
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.
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
Utility class for floating point operations which can have information about relaxed accuracy require...
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.
bool isInBounds() const
Test whether this is an inbounds GEP, as defined by LangRef.html.
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
static 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 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.
static bool isEquality(Predicate P)
Return true if this predicate is either EQ or NE.
Value * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
Value * CreateLogicalOp(Instruction::BinaryOps Opc, Value *Cond1, Value *Cond2, const Twine &Name="")
Value * CreateExtractValue(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &Name="")
CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
Value * CreateSExt(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateFreeze(Value *V, const Twine &Name="")
Value * CreatePtrAdd(Value *Ptr, Value *Offset, const Twine &Name="", GEPNoWrapFlags NW=GEPNoWrapFlags::none())
void setFastMathFlags(FastMathFlags NewFMF)
Set the fast-math flags to be used with generated fp-math operators.
Value * CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Value * CreateGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="", GEPNoWrapFlags NW=GEPNoWrapFlags::none())
void CollectMetadataToCopy(Instruction *Src, ArrayRef< unsigned > MetadataKinds)
Collect metadata with IDs MetadataKinds from Src which should be added to all created instructions.
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Value * CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Value * CreateNot(Value *V, const Twine &Name="")
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Value * CreateShuffleVector(Value *V1, Value *V2, Value *Mask, const Twine &Name="")
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="", bool IsNUW=false, bool IsNSW=false)
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Value * CreateAShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateXor(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name="")
IntegerType * getInt8Ty()
Fetch the type representing an 8-bit integer.
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 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)
InstCombinePass(InstCombineOptions Opts={})
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Instruction * FoldOpIntoSelect(Instruction &Op, SelectInst *SI, bool FoldWithMultiUse=false)
Given an instruction with a select as one operand and a constant as the other operand,...
Instruction * foldBinOpOfSelectAndCastOfSelectCondition(BinaryOperator &I)
Tries to simplify binops of select and cast of the select condition.
Instruction * foldBinOpIntoSelectOrPhi(BinaryOperator &I)
This is a convenience wrapper function for the above two functions.
bool SimplifyAssociativeOrCommutative(BinaryOperator &I)
Performs a few simplifications for operators which are associative or commutative.
Instruction * visitGEPOfGEP(GetElementPtrInst &GEP, GEPOperator *Src)
Value * foldUsingDistributiveLaws(BinaryOperator &I)
Tries to simplify binary operations which some other binary operation distributes over.
Instruction * foldBinOpShiftWithShift(BinaryOperator &I)
Instruction * visitUnreachableInst(UnreachableInst &I)
Instruction * foldOpIntoPhi(Instruction &I, PHINode *PN)
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)
Instruction * visitFree(CallInst &FI, Value *FreedOp)
Instruction * visitExtractValueInst(ExtractValueInst &EV)
void handlePotentiallyDeadSuccessors(BasicBlock *BB, BasicBlock *LiveSucc)
Instruction * visitUnconditionalBranchInst(BranchInst &BI)
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Instruction * visitLandingPadInst(LandingPadInst &LI)
bool prepareWorklist(Function &F, ReversePostOrderTraversal< BasicBlock * > &RPOT)
Perform early cleanup and prepare the InstCombine worklist.
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.
Constant * getLosslessTrunc(Constant *C, Type *TruncTy, unsigned ExtOp)
Value * SimplifyDemandedUseFPClass(Value *V, FPClassTest DemandedMask, KnownFPClass &Known, unsigned Depth, Instruction *CxtI)
Attempts to replace V with a simpler value based on the demanded floating-point classes.
bool mergeStoreIntoSuccessor(StoreInst &SI)
Try to transform: if () { *P = v1; } else { *P = v2 } or: *P = v1; if () { *P = v2; } into a phi node...
Instruction * tryFoldInstWithCtpopWithNot(Instruction *I)
void tryToSinkInstructionDbgValues(Instruction *I, BasicBlock::iterator InsertPos, BasicBlock *SrcBlock, BasicBlock *DestBlock, SmallVectorImpl< DbgVariableIntrinsic * > &DbgUsers)
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)
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)
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
static bool isCanonicalPredicate(CmpInst::Predicate Pred)
Predicate canonicalization reduces the number of patterns that need to be matched by other transforms...
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.
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.
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
unsigned ComputeNumSignBits(const Value *Op, unsigned Depth=0, const Instruction *CxtI=nullptr) 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.
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)
void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth, const Instruction *CxtI) const
bool isValidAddrSpaceCast(unsigned FromAS, unsigned ToAS) const
Value * getFreelyInverted(Value *V, bool WillInvertAllUses, BuilderTy *Builder, bool &DoesConsume)
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 ...
Instruction * removeOne()
void pushUsersToWorkList(Instruction &I)
When an instruction is simplified, add all users of the instruction to the work lists because they mi...
void add(Instruction *I)
Add instruction to the worklist.
void push(Instruction *I)
Push the instruction onto the worklist stack.
Instruction * popDeferred()
void zap()
Check that the worklist is empty and nuke the backing store for the map.
void reserve(size_t Size)
static bool isBitwiseLogicOp(unsigned Opcode)
Determine if the Opcode is and/or/xor.
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.
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
const Function * getFunction() const
Return the function this instruction belongs to.
bool isTerminator() const
void dropUBImplyingAttrsAndMetadata()
Drop any attributes or metadata that can cause immediate undefined behavior.
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
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.
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.
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Class to represent integer types.
static 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...
static 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...
void addClause(Constant *ClauseVal)
Add a catch or filter clause to the landing pad.
void setCleanup(bool V)
Indicate that this landingpad instruction is a cleanup.
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.
Analysis pass that exposes the LoopInfo for a function.
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 MemoryLocation getForDest(const MemIntrinsic *MI)
Return a location representing the destination of a memory set or transfer.
This class represents min/max intrinsics.
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
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
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 PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
In order to facilitate speculative execution, many instructions do not invoke immediate undefined beh...
static 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.
void preserveSet()
Mark an analysis set 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 a cast from signed integer to floating point.
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, Instruction *MDFrom=nullptr)
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.
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.
const fltSemantics & getFltSemantics() const
bool isVectorTy() const
True if this is an instance of VectorType.
static IntegerType * getInt1Ty(LLVMContext &C)
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isStructTy() const
True if this is an instance of StructType.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
bool isScalableTy() const
Return true if this is a type whose size is a known multiple of vscale.
static IntegerType * getInt32Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
This class represents a cast unsigned integer to floating point.
This function has undefined behavior.
A Use represents the edge between a Value definition and its users.
bool replaceUsesOfWith(Value *From, Value *To)
Replace uses of one Value with another.
Value * getOperand(unsigned i) const
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...
bool hasOneUse() const
Return true if there is exactly one use of this value.
iterator_range< user_iterator > users()
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
LLVMContext & getContext() const
All values hold a context through their type.
uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull, bool &CanBeFreed) const
Returns the number of bytes known to be dereferenceable for the pointer value.
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
constexpr ScalarTy getFixedValue() const
constexpr bool isZero() const
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.
bool isNoFPClassCompatibleType(Type *Ty)
Returns true if this is a type legal for the 'nofpclass' attribute.
@ C
The default llvm calling convention, compatible with C.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
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.
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.
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)
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.
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.
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
apint_match m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
OneUse_match< T > m_OneUse(const T &SubPattern)
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
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_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".
SpecificCmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_SpecificICmp(ICmpInst::Predicate MatchPred, const LHS &L, const RHS &R)
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)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
CastInst_match< OpTy, SIToFPInst > m_SIToFP(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
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< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
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.
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)
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.
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.
void stable_sort(R &&Range)
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Value * simplifyGEPInst(Type *SrcTy, Value *Ptr, ArrayRef< Value * > Indices, GEPNoWrapFlags NW, const SimplifyQuery &Q)
Given operands for a GetElementPtrInst, fold the result or return null.
bool succ_empty(const Instruction *I)
Value * simplifyFreezeInst(Value *Op, const SimplifyQuery &Q)
Given an operand for a Freeze, see if we can fold the result.
FunctionPass * createInstructionCombiningPass()
std::pair< unsigned, unsigned > removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB)
Remove all instructions from a basic block other than its terminator and any present EH pad instructi...
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
void salvageDebugInfoForDbgValues(Instruction &I, ArrayRef< DbgVariableIntrinsic * > Insns, ArrayRef< DbgVariableRecord * > DPInsns)
Implementation of salvageDebugInfo, applying only to instructions in Insns, rather than all debug use...
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V, SmallVectorImpl< DbgVariableRecord * > *DbgVariableRecords=nullptr)
Finds the debug info intrinsics describing a value.
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)
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...
std::optional< StringRef > getAllocationFamily(const Value *I, const TargetLibraryInfo *TLI)
If a function is part of an allocation family (e.g.
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.
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.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
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)
Value * getReallocatedOperand(const CallBase *CB)
If this is a call to a realloc function, return the reallocated operand.
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,...
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.
Value * simplifyAddInst(Value *LHS, Value *RHS, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for an Add, fold the result or return null.
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
constexpr bool has_single_bit(T Value) noexcept
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.
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...
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)
void sort(IteratorTy Start, IteratorTy End)
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
bool LowerDbgDeclare(Function &F)
Lowers llvm.dbg.declare intrinsics into appropriate set of llvm.dbg.value intrinsics.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true)
Return true if the instruction does not have any effects besides calculating the result and does not ...
void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, StoreInst *SI, DIBuilder &Builder)
===------------------------------------------------------------------—===// Dbg Intrinsic utilities
Constant * ConstantFoldInstOperands(Instruction *I, ArrayRef< Constant * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, bool AllowNonDeterministic=true)
ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands.
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)
canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
Value * simplifyExtractValueInst(Value *Agg, ArrayRef< unsigned > Idxs, const SimplifyQuery &Q)
Given operands for an ExtractValueInst, fold the result or return null.
Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT)
Point debug users of From to To or salvage them.
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.
Value * simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a BinaryOperator, fold the result or return null.
@ Or
Bitwise or logical OR of integers.
DWARFExpression::Operation Op
Constant * ConstantFoldInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstruction - Try to constant fold the specified instruction.
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.
Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
constexpr unsigned BitWidth
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
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.
bool equal(L &&LRange, R &&RRange)
Wrapper function around std::equal to detect if pair-wise elements between two ranges are the same.
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DbgVariableRecord types only and downcast.
void initializeInstCombine(PassRegistry &)
Initialize all passes linked into the InstCombine library.
void initializeInstructionCombiningPassPass(PassRegistry &)
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
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.
bool isPotentiallyReachable(const Instruction *From, const Instruction *To, const SmallPtrSetImpl< BasicBlock * > *ExclusionSet=nullptr, const DominatorTree *DT=nullptr, const LoopInfo *LI=nullptr)
Determine whether instruction 'To' is reachable from 'From', without passing through any blocks in Ex...
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
static unsigned int semanticsPrecision(const fltSemantics &)
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
SimplifyQuery getWithoutUndef() const