46#include "llvm/IR/IntrinsicsAArch64.h"
47#include "llvm/IR/IntrinsicsAMDGPU.h"
48#include "llvm/IR/IntrinsicsARM.h"
49#include "llvm/IR/IntrinsicsHexagon.h"
80#define DEBUG_TYPE "instcombine"
86STATISTIC(NumSimplified,
"Number of library calls simplified");
89 "instcombine-guard-widening-window",
91 cl::desc(
"How wide an instruction window to bypass looking for "
98 if (ITy->getBitWidth() < 32)
108 auto *Src =
MI->getRawSource();
110 if (!Src->hasOneUse())
120 if (!CopyDstAlign || *CopyDstAlign < DstAlign) {
121 MI->setDestAlignment(DstAlign);
127 if (!CopySrcAlign || *CopySrcAlign < SrcAlign) {
128 MI->setSourceAlignment(SrcAlign);
152 if (!MemOpLength)
return nullptr;
159 assert(
Size &&
"0-sized memory transferring should be removed already.");
169 if (*CopyDstAlign <
Size || *CopySrcAlign <
Size)
179 Value *Src =
MI->getArgOperand(1);
180 Value *Dest =
MI->getArgOperand(0);
183 L->setAlignment(*CopySrcAlign);
184 L->setAAMetadata(AACopyMD);
185 MDNode *LoopMemParallelMD =
186 MI->getMetadata(LLVMContext::MD_mem_parallel_loop_access);
187 if (LoopMemParallelMD)
188 L->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
189 MDNode *AccessGroupMD =
MI->getMetadata(LLVMContext::MD_access_group);
191 L->setMetadata(LLVMContext::MD_access_group, AccessGroupMD);
197 if (LoopMemParallelMD)
198 S->
setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
200 S->
setMetadata(LLVMContext::MD_access_group, AccessGroupMD);
205 L->setVolatile(MT->isVolatile());
208 if (
MI->isAtomic()) {
220 const Align KnownAlignment =
223 if (!MemSetAlign || *MemSetAlign < KnownAlignment) {
224 MI->setDestAlignment(KnownAlignment);
252 assert(Len &&
"0-sized memory setting should be removed already.");
253 const Align Alignment =
MI->getDestAlign().valueOrOne();
259 if (
MI->isAtomic() && Alignment < Len)
267 Constant *FillVal = ConstantInt::get(
273 DbgAssign->replaceVariableLocationOp(FillC, FillVal);
291 Value *LoadPtr =
II.getArgOperand(0);
292 const Align Alignment =
II.getParamAlign(0).valueOrOne();
297 LoadInst *L = Builder.CreateAlignedLoad(
II.getType(), LoadPtr, Alignment,
306 II.getDataLayout(), &
II, &
AC)) {
307 LoadInst *LI = Builder.CreateAlignedLoad(
II.getType(), LoadPtr, Alignment,
310 return Builder.CreateSelect(
II.getArgOperand(1), LI,
II.getArgOperand(2));
320 Value *StorePtr =
II.getArgOperand(1);
321 Align Alignment =
II.getParamAlign(1).valueOrOne();
333 new StoreInst(
II.getArgOperand(0), StorePtr,
false, Alignment);
365 if (ConstMask->isAllOnesValue())
368 const Align Alignment =
II.getParamAlign(0).valueOrOne();
369 LoadInst *
L =
Builder.CreateAlignedLoad(VecTy->getElementType(), SplatPtr,
370 Alignment,
"load.scalar");
372 Builder.CreateVectorSplat(VecTy->getElementCount(), L,
"broadcast");
398 Align Alignment =
II.getParamAlign(1).valueOrOne();
399 StoreInst *S =
new StoreInst(SplatValue, SplatPtr,
false,
407 if (ConstMask->isAllOnesValue()) {
408 Align Alignment =
II.getParamAlign(1).valueOrOne();
410 ElementCount VF = WideLoadTy->getElementCount();
414 Builder.CreateExtractElement(
II.getArgOperand(0), LastLane);
416 new StoreInst(Extract, SplatPtr,
false, Alignment);
447 auto *Arg =
II.getArgOperand(0);
448 auto *StrippedArg = Arg->stripPointerCasts();
449 auto *StrippedInvariantGroupsArg = StrippedArg;
451 if (Intr->getIntrinsicID() != Intrinsic::launder_invariant_group &&
452 Intr->getIntrinsicID() != Intrinsic::strip_invariant_group)
454 StrippedInvariantGroupsArg = Intr->getArgOperand(0)->stripPointerCasts();
456 if (StrippedArg == StrippedInvariantGroupsArg)
459 Value *Result =
nullptr;
461 if (
II.getIntrinsicID() == Intrinsic::launder_invariant_group)
463 else if (
II.getIntrinsicID() == Intrinsic::strip_invariant_group)
467 "simplifyInvariantGroupIntrinsic only handles launder and strip");
468 if (Result->getType()->getPointerAddressSpace() !=
469 II.getType()->getPointerAddressSpace())
476 assert((
II.getIntrinsicID() == Intrinsic::cttz ||
477 II.getIntrinsicID() == Intrinsic::ctlz) &&
478 "Expected cttz or ctlz intrinsic");
479 bool IsTZ =
II.getIntrinsicID() == Intrinsic::cttz;
480 Value *Op0 =
II.getArgOperand(0);
481 Value *Op1 =
II.getArgOperand(1);
492 if (
II.getType()->isIntOrIntVectorTy(1)) {
505 II.dropUBImplyingAttrsAndMetadata();
552 return BinaryOperator::CreateAdd(ConstCttz,
X);
560 return BinaryOperator::CreateSub(ConstCttz,
X);
566 ConstantInt::get(
II.getType(),
II.getType()->getScalarSizeInBits());
567 return BinaryOperator::CreateSub(Width,
X);
575 return BinaryOperator::CreateAdd(ConstCtlz,
X);
583 return BinaryOperator::CreateSub(ConstCtlz,
X);
593 ConstantInt::get(R->getType(), R->getType()->getScalarSizeInBits() - 1),
612 if (PossibleZeros == DefiniteZeros) {
613 auto *
C = ConstantInt::get(Op0->
getType(), DefiniteZeros);
628 if (
BitWidth != 1 && !
II.hasRetAttr(Attribute::Range) &&
629 !
II.getMetadata(LLVMContext::MD_range)) {
640 assert(
II.getIntrinsicID() == Intrinsic::ctpop &&
641 "Expected ctpop intrinsic");
643 unsigned BitWidth = Ty->getScalarSizeInBits();
644 Value *Op0 =
II.getArgOperand(0);
690 if ((~Known.
Zero).isPowerOf2())
691 return BinaryOperator::CreateLShr(
692 Op0, ConstantInt::get(Ty, (~Known.
Zero).exactLogBase2()));
706 II.getRange().value_or(ConstantRange::getFull(
BitWidth));
718 if (
Range != OldRange) {
739 unsigned NumElts = VecTy->getNumElements();
742 if (!VecTy->getElementType()->isIntegerTy(8) || NumElts != 8)
747 for (
unsigned I = 0;
I < NumElts; ++
I) {
756 if ((
unsigned)Indexes[
I] >= NumElts)
760 auto *V1 =
II.getArgOperand(0);
762 return Builder.CreateShuffleVector(V1, V2,
ArrayRef(Indexes));
768 unsigned NumOperands) {
769 assert(
I.arg_size() >= NumOperands &&
"Not enough operands");
770 assert(
E.arg_size() >= NumOperands &&
"Not enough operands");
771 for (
unsigned i = 0; i < NumOperands; i++)
772 if (
I.getArgOperand(i) !=
E.getArgOperand(i))
793 for (; BI != BE; ++BI) {
795 if (
I->isDebugOrPseudoInst() ||
818 return II.getIntrinsicID() == Intrinsic::vastart ||
819 (
II.getIntrinsicID() == Intrinsic::vacopy &&
820 I.getArgOperand(0) !=
II.getArgOperand(1));
826 assert(
Call.arg_size() > 1 &&
"Need at least 2 args to swap");
827 Value *Arg0 =
Call.getArgOperand(0), *Arg1 =
Call.getArgOperand(1);
829 Call.setArgOperand(0, Arg1);
830 Call.setArgOperand(1, Arg0);
849 Value *OperationResult =
nullptr;
856 for (User *U : WO->
users()) {
860 for (
auto &AssumeVH :
AC.assumptionsFor(U)) {
874 Inst->setHasNoSignedWrap();
876 Inst->setHasNoUnsignedWrap();
887 Ty = Ty->getScalarType();
892 Ty = Ty->getScalarType();
893 return F.getDenormalMode(Ty->getFltSemantics()).inputsAreZero();
901 switch (
static_cast<unsigned>(Mask)) {
958 Value *Src0 =
II.getArgOperand(0);
959 Value *Src1 =
II.getArgOperand(1);
965 const FPClassTest OrderedInvertedMask = ~OrderedMask & ~fcNan;
967 const bool IsStrict =
968 II.getFunction()->getAttributes().hasFnAttr(Attribute::StrictFP);
974 II.setArgOperand(1, ConstantInt::get(Src1->
getType(),
fneg(Mask)));
984 if ((OrderedMask ==
fcInf || OrderedInvertedMask ==
fcInf) &&
985 (IsOrdered || IsUnordered) && !IsStrict) {
993 if (OrderedInvertedMask ==
fcInf)
996 Value *Fabs =
Builder.CreateUnaryIntrinsic(Intrinsic::fabs, Src0);
1003 (IsOrdered || IsUnordered) && !IsStrict) {
1010 Value *EqInf = IsUnordered ?
Builder.CreateFCmpUEQ(Src0, Inf)
1011 :
Builder.CreateFCmpOEQ(Src0, Inf);
1017 if ((OrderedInvertedMask ==
fcPosInf || OrderedInvertedMask ==
fcNegInf) &&
1018 (IsOrdered || IsUnordered) && !IsStrict) {
1025 Value *NeInf = IsUnordered ?
Builder.CreateFCmpUNE(Src0, Inf)
1026 :
Builder.CreateFCmpONE(Src0, Inf);
1031 if (Mask ==
fcNan && !IsStrict) {
1063 if (!IsStrict && (IsOrdered || IsUnordered) &&
1108 return std::nullopt;
1120 return std::nullopt;
1132 return *Known0 == *Known1;
1140 assert((MinMaxID == Intrinsic::smax || MinMaxID == Intrinsic::smin ||
1141 MinMaxID == Intrinsic::umax || MinMaxID == Intrinsic::umin) &&
1142 "Expected a min or max intrinsic");
1145 Value *Op0 =
II->getArgOperand(0), *Op1 =
II->getArgOperand(1);
1147 const APInt *C0, *C1;
1153 bool IsSigned = MinMaxID == Intrinsic::smax || MinMaxID == Intrinsic::smin;
1155 if ((IsSigned && !
Add->hasNoSignedWrap()) ||
1156 (!IsSigned && !
Add->hasNoUnsignedWrap()))
1163 IsSigned ? C1->
ssub_ov(*C0, Overflow) : C1->
usub_ov(*C0, Overflow);
1164 assert(!Overflow &&
"Expected simplify of min/max");
1168 Constant *NewMinMaxC = ConstantInt::get(
II->getType(), CDiff);
1169 Value *NewMinMax = Builder.CreateBinaryIntrinsic(MinMaxID,
X, NewMinMaxC);
1170 return IsSigned ? BinaryOperator::CreateNSWAdd(NewMinMax,
Add->getOperand(1))
1171 : BinaryOperator::CreateNUWAdd(NewMinMax,
Add->getOperand(1));
1182 const APInt *MinValue, *MaxValue;
1186 }
else if (
match(&MinMax1,
1195 if (!(*MaxValue + 1).isPowerOf2() || -*MinValue != *MaxValue + 1)
1198 unsigned NewBitWidth = (*MaxValue + 1).logBase2() + 1;
1212 if (
AddSub->getOpcode() == Instruction::Add)
1213 IntrinsicID = Intrinsic::sadd_sat;
1214 else if (
AddSub->getOpcode() == Instruction::Sub)
1215 IntrinsicID = Intrinsic::ssub_sat;
1228 Value *Sat =
Builder.CreateIntrinsic(IntrinsicID, NewTy, {AT,
BT});
1238 Value *I0 =
II->getArgOperand(0), *I1 =
II->getArgOperand(1);
1240 const APInt *C0, *C1;
1245 switch (
II->getIntrinsicID()) {
1246 case Intrinsic::smax:
1250 case Intrinsic::smin:
1254 case Intrinsic::umax:
1258 case Intrinsic::umin:
1270 Value *Cmp = Builder.CreateICmp(Pred,
X, I1);
1294 if (InnerMinMaxID != MinMaxID &&
1295 !(((MinMaxID == Intrinsic::umax && InnerMinMaxID == Intrinsic::smax) ||
1296 (MinMaxID == Intrinsic::smin && InnerMinMaxID == Intrinsic::umin)) &&
1301 Value *CondC = Builder.CreateICmp(Pred, C0, C1);
1302 Value *NewC = Builder.CreateSelect(CondC, C0, C1);
1303 return Builder.CreateIntrinsic(InnerMinMaxID,
II->getType(),
1304 {LHS->getArgOperand(0), NewC});
1325 if (!InnerMM || InnerMM->getIntrinsicID() != MinMaxID ||
1331 MinMaxID,
II->getType());
1332 Value *NewInner = Builder.CreateBinaryIntrinsic(MinMaxID,
X,
Y);
1343 if (!
LHS || !
RHS ||
LHS->getIntrinsicID() != MinMaxID ||
1344 RHS->getIntrinsicID() != MinMaxID ||
1345 (!
LHS->hasOneUse() && !
RHS->hasOneUse()))
1354 Value *MinMaxOp =
nullptr;
1355 Value *ThirdOp =
nullptr;
1356 if (
LHS->hasOneUse()) {
1359 if (
D ==
A ||
C ==
A) {
1364 }
else if (
D ==
B ||
C ==
B) {
1371 assert(
RHS->hasOneUse() &&
"Expected one-use operand");
1373 if (
D ==
A ||
D ==
B) {
1378 }
else if (
C ==
A ||
C ==
B) {
1386 if (!MinMaxOp || !ThirdOp)
1400 !
II->getCalledFunction()->isSpeculatable())
1407 return isa<Constant>(Arg.get()) ||
1408 isVectorIntrinsicWithScalarOpAtArg(II->getIntrinsicID(),
1409 Arg.getOperandNo(), nullptr);
1422 Type *SrcTy =
X->getType();
1423 for (
Use &Arg :
II->args()) {
1427 else if (
match(&Arg,
1429 X->getType() == SrcTy)
1448 Value *NewIntrinsic =
1449 Builder.CreateIntrinsic(ResTy,
II->getIntrinsicID(), NewArgs, FPI);
1462 return match(V, m_OneUse(m_VecReverse(m_Value())));
1469 for (
Use &Arg :
II->args()) {
1471 Arg.getOperandNo(),
nullptr))
1486 II->getType(),
II->getIntrinsicID(), NewArgs, FPI);
1487 return Builder.CreateVectorReverse(NewIntrinsic);
1493template <Intrinsic::ID IntrID>
1496 static_assert(IntrID == Intrinsic::bswap || IntrID == Intrinsic::bitreverse,
1497 "This helper only supports BSWAP and BITREVERSE intrinsics");
1504 Value *OldReorderX, *OldReorderY;
1517 Value *NewReorder = Builder.CreateUnaryIntrinsic(IntrID,
Y);
1522 Value *NewReorder = Builder.CreateUnaryIntrinsic(IntrID,
X);
1533 case Intrinsic::smax:
1534 case Intrinsic::smin:
1535 case Intrinsic::umax:
1536 case Intrinsic::umin:
1537 case Intrinsic::maximum:
1538 case Intrinsic::minimum:
1539 case Intrinsic::maximumnum:
1540 case Intrinsic::minimumnum:
1541 case Intrinsic::maxnum:
1542 case Intrinsic::minnum:
1561 auto IID =
II->getIntrinsicID();
1567 auto *InvariantBinaryInst =
1571 return InvariantBinaryInst;
1575 if (!CanReorderLanes)
1588 int Sz = Mask.size();
1590 for (
int Idx : Mask) {
1593 UsedIndices.
set(Idx);
1598 return UsedIndices.
all() ? V :
nullptr;
1605template <Intrinsic::ID IntrID>
1610 static_assert(IntrID == Intrinsic::cttz || IntrID == Intrinsic::ctlz,
1611 "This helper only supports cttz and ctlz intrinsics");
1619 unsigned BitWidth = I1->getType()->getScalarSizeInBits();
1626 Type *Ty = I1->getType();
1628 IntrID == Intrinsic::cttz ? Instruction::Shl : Instruction::LShr,
1629 IntrID == Intrinsic::cttz
1630 ? ConstantInt::get(Ty, 1)
1633 return Builder.CreateBinaryIntrinsic(
1634 IntrID, Builder.CreateOr(CtOp, NewConst),
1643 case Intrinsic::umax:
1644 case Intrinsic::umin:
1645 if (HasNUW && LOp == Instruction::Add)
1647 if (HasNUW && LOp == Instruction::Shl)
1650 case Intrinsic::smax:
1651 case Intrinsic::smin:
1652 return HasNSW && LOp == Instruction::Add;
1695 if (
A ==
D ||
B ==
C)
1703 Value *NewIntrinsic = Builder.CreateBinaryIntrinsic(TopLevelOpcode,
B,
D);
1706 }
else if (
B ==
D) {
1707 Value *NewIntrinsic = Builder.CreateBinaryIntrinsic(TopLevelOpcode,
A,
C);
1729 SQ.getWithInstruction(&CI)))
1745 return visitCallBase(CI);
1750 if (
auto NumBytes =
MI->getLengthInBytes()) {
1752 if (NumBytes->isZero())
1757 if (
MI->isAtomic() &&
1758 (NumBytes->isNegative() ||
1759 (NumBytes->getZExtValue() %
MI->getElementSizeInBytes() != 0))) {
1761 assert(
MI->getType()->isVoidTy() &&
1762 "non void atomic unordered mem intrinsic");
1768 if (
MI->isVolatile())
1773 if (MTI->getSource() == MTI->getDest())
1783 bool SrcIsUndefined =
false;
1789 SrcIsUndefined = IsPointerUndefined(MTI->getRawSource());
1796 if (SrcIsUndefined || IsPointerUndefined(
MI->getRawDest())) {
1806 if (GVSrc->isConstant()) {
1810 ? Intrinsic::memcpy_element_unordered_atomic
1811 : Intrinsic::memcpy;
1825 auto VWidth = IIFVTy->getNumElements();
1826 APInt PoisonElts(VWidth, 0);
1835 if (
II->isCommutative()) {
1836 if (
auto Pair = matchSymmetricPair(
II->getOperand(0),
II->getOperand(1))) {
1857 case Intrinsic::objectsize: {
1860 &InsertedInstructions)) {
1861 for (
Instruction *Inserted : InsertedInstructions)
1867 case Intrinsic::abs: {
1868 Value *IIOperand =
II->getArgOperand(0);
1883 if (
match(IIOperand,
1892 if (std::optional<bool> Known =
1918 return BinaryOperator::CreateAnd(
X, ConstantInt::get(
II->getType(), 1));
1922 case Intrinsic::umin: {
1923 Value *I0 =
II->getArgOperand(0), *I1 =
II->getArgOperand(1);
1926 assert(
II->getType()->getScalarSizeInBits() != 1 &&
1927 "Expected simplify of umin with max constant");
1933 if (
Value *FoldedCttz =
1938 if (
Value *FoldedCtlz =
1944 case Intrinsic::umax: {
1945 Value *I0 =
II->getArgOperand(0), *I1 =
II->getArgOperand(1);
1948 (I0->
hasOneUse() || I1->hasOneUse()) &&
X->getType() ==
Y->getType()) {
1956 Value *NarrowMaxMin =
Builder.CreateBinaryIntrinsic(IID,
X, NarrowC);
1975 Value *Cmp =
Builder.CreateICmpEQ(
X, ConstantInt::get(
X->getType(), 0));
1977 Builder.CreateSelect(Cmp, ConstantInt::get(
X->getType(), 1),
A);
1981 if (IID == Intrinsic::umax) {
1992 case Intrinsic::smax:
1993 case Intrinsic::smin: {
1994 Value *I0 =
II->getArgOperand(0), *I1 =
II->getArgOperand(1);
1997 (I0->
hasOneUse() || I1->hasOneUse()) &&
X->getType() ==
Y->getType()) {
2006 Value *NarrowMaxMin =
Builder.CreateBinaryIntrinsic(IID,
X, NarrowC);
2013 const APInt *MinC, *MaxC;
2014 auto CreateCanonicalClampForm = [&](
bool IsSigned) {
2015 auto MaxIID = IsSigned ? Intrinsic::smax : Intrinsic::umax;
2016 auto MinIID = IsSigned ? Intrinsic::smin : Intrinsic::umin;
2018 MaxIID,
X, ConstantInt::get(
X->getType(), *MaxC));
2021 MinIID, NewMax, ConstantInt::get(
X->getType(), *MinC)));
2023 if (IID == Intrinsic::smax &&
2027 return CreateCanonicalClampForm(
true);
2028 if (IID == Intrinsic::umax &&
2032 return CreateCanonicalClampForm(
false);
2036 if ((IID == Intrinsic::umin || IID == Intrinsic::smax) &&
2037 II->getType()->isIntOrIntVectorTy(1)) {
2038 return BinaryOperator::CreateAnd(I0, I1);
2043 if ((IID == Intrinsic::umax || IID == Intrinsic::smin) &&
2044 II->getType()->isIntOrIntVectorTy(1)) {
2045 return BinaryOperator::CreateOr(I0, I1);
2053 if (IID == Intrinsic::smin) {
2056 Value *Zero = ConstantInt::get(
X->getType(), 0);
2059 Builder.CreateIntrinsic(
II->getType(), Intrinsic::scmp, {X, Zero}));
2063 if (IID == Intrinsic::smax || IID == Intrinsic::smin) {
2090 bool UseOr = IID == Intrinsic::smax || IID == Intrinsic::umax;
2091 bool UseAndN = IID == Intrinsic::smin || IID == Intrinsic::umin;
2093 if (IID == Intrinsic::smax || IID == Intrinsic::smin) {
2095 if (KnownSign == std::nullopt) {
2098 }
else if (*KnownSign ) {
2110 return BinaryOperator::CreateOr(I0,
X);
2112 return BinaryOperator::CreateAnd(I0,
Builder.CreateNot(
X));
2128 Value *InvMaxMin =
Builder.CreateBinaryIntrinsic(InvID,
A, NotY);
2147 return BinaryOperator::CreateAnd(
Builder.CreateBinaryIntrinsic(IID,
X,
Y),
2148 ConstantInt::get(
II->getType(), *RHSC));
2158 if (I0->
hasOneUse() && !I1->hasOneUse())
2170 if (IID == Intrinsic::smin || IID == Intrinsic::umax)
2171 Abs =
Builder.CreateNeg(Abs,
"nabs", IntMinIsPoison);
2196 I0, IsSigned,
SQ.getWithInstruction(
II));
2198 if (LHS_CR.
icmp(Pred, *RHSC))
2202 ConstantInt::get(
II->getType(), *RHSC));
2211 case Intrinsic::scmp: {
2212 Value *I0 =
II->getArgOperand(0), *I1 =
II->getArgOperand(1);
2217 Builder.CreateIntrinsic(
II->getType(), Intrinsic::scmp, {LHS, RHS}));
2220 case Intrinsic::bitreverse: {
2221 Value *IIOperand =
II->getArgOperand(0);
2225 X->getType()->isIntOrIntVectorTy(1)) {
2226 Type *Ty =
II->getType();
2234 return crossLogicOpFold;
2238 case Intrinsic::bswap: {
2239 Value *IIOperand =
II->getArgOperand(0);
2249 Value *NewSwap =
Builder.CreateUnaryIntrinsic(Intrinsic::bswap,
X);
2264 if (BW - LZ - TZ == 8) {
2265 assert(LZ != TZ &&
"active byte cannot be in the middle");
2267 return BinaryOperator::CreateNUWShl(
2268 IIOperand, ConstantInt::get(IIOperand->
getType(), LZ - TZ));
2270 return BinaryOperator::CreateExactLShr(
2271 IIOperand, ConstantInt::get(IIOperand->
getType(), TZ - LZ));
2276 unsigned C =
X->getType()->getScalarSizeInBits() - BW;
2277 Value *CV = ConstantInt::get(
X->getType(),
C);
2284 return crossLogicOpFold;
2293 case Intrinsic::masked_load:
2294 if (
Value *SimplifiedMaskedOp = simplifyMaskedLoad(*
II))
2297 case Intrinsic::masked_store:
2298 return simplifyMaskedStore(*
II);
2299 case Intrinsic::masked_gather:
2300 return simplifyMaskedGather(*
II);
2301 case Intrinsic::masked_scatter:
2302 return simplifyMaskedScatter(*
II);
2303 case Intrinsic::launder_invariant_group:
2304 case Intrinsic::strip_invariant_group:
2308 case Intrinsic::powi:
2312 if (Power->isMinusOne())
2314 II->getArgOperand(0),
II);
2316 if (Power->equalsInt(2))
2318 II->getArgOperand(0),
II);
2320 if (!Power->getValue()[0]) {
2335 case Intrinsic::cttz:
2336 case Intrinsic::ctlz:
2341 case Intrinsic::ctpop:
2346 case Intrinsic::fshl:
2347 case Intrinsic::fshr: {
2348 Value *Op0 =
II->getArgOperand(0), *Op1 =
II->getArgOperand(1);
2349 Type *Ty =
II->getType();
2350 unsigned BitWidth = Ty->getScalarSizeInBits();
2359 if (ModuloC != ShAmtC)
2365 "Shift amount expected to be modulo bitwidth");
2370 if (IID == Intrinsic::fshr) {
2381 assert(IID == Intrinsic::fshl &&
2382 "All funnel shifts by simple constants should go left");
2387 return BinaryOperator::CreateShl(Op0, ShAmtC);
2392 return BinaryOperator::CreateLShr(Op1,
2410 const APInt *ShAmtInnerC, *ShAmtOuterC;
2414 APInt Sum = *ShAmtOuterC + *ShAmtInnerC;
2418 Constant *ModuloC = ConstantInt::get(Ty, Modulo);
2420 {InnerOp, InnerOp, ModuloC});
2432 Mod, IID == Intrinsic::fshl ? Intrinsic::fshr : Intrinsic::fshl, Ty);
2440 Value *Op2 =
II->getArgOperand(2);
2442 return BinaryOperator::CreateShl(Op0,
And);
2460 case Intrinsic::ptrmask: {
2461 unsigned BitWidth =
DL.getPointerTypeSizeInBits(
II->getType());
2466 Value *InnerPtr, *InnerMask;
2471 if (
match(
II->getArgOperand(0),
2475 "Mask types must match");
2478 Value *NewMask =
Builder.CreateAnd(
II->getArgOperand(1), InnerMask);
2492 unsigned NewAlignmentLog =
2506 case Intrinsic::uadd_with_overflow:
2507 case Intrinsic::sadd_with_overflow: {
2515 const APInt *C0, *C1;
2516 Value *Arg0 =
II->getArgOperand(0);
2517 Value *Arg1 =
II->getArgOperand(1);
2518 bool IsSigned = IID == Intrinsic::sadd_with_overflow;
2519 bool HasNWAdd = IsSigned
2525 IsSigned ? C1->
sadd_ov(*C0, Overflow) : C1->
uadd_ov(*C0, Overflow);
2529 IID,
X, ConstantInt::get(Arg1->
getType(), NewC)));
2534 case Intrinsic::umul_with_overflow:
2535 case Intrinsic::smul_with_overflow:
2536 case Intrinsic::usub_with_overflow:
2541 case Intrinsic::ssub_with_overflow: {
2546 Value *Arg0 =
II->getArgOperand(0);
2547 Value *Arg1 =
II->getArgOperand(1);
2557 *
II,
Builder.CreateBinaryIntrinsic(Intrinsic::sadd_with_overflow,
2564 case Intrinsic::uadd_sat:
2565 case Intrinsic::sadd_sat:
2566 case Intrinsic::usub_sat:
2567 case Intrinsic::ssub_sat: {
2569 Type *Ty =
SI->getType();
2585 unsigned BitWidth = Ty->getScalarSizeInBits();
2590 unsigned BitWidth = Ty->getScalarSizeInBits();
2602 if (IID == Intrinsic::usub_sat &&
2605 auto *NewC =
Builder.CreateBinaryIntrinsic(Intrinsic::usub_sat,
C, C1);
2607 Builder.CreateBinaryIntrinsic(Intrinsic::usub_sat, NewC,
A);
2613 C->isNotMinSignedValue()) {
2617 Intrinsic::sadd_sat, Arg0, NegVal));
2625 const APInt *Val, *Val2;
2628 IID == Intrinsic::uadd_sat || IID == Intrinsic::usub_sat;
2629 if (
Other->getIntrinsicID() == IID &&
2637 NewVal = Val->
sadd_ov(*Val2, Overflow);
2650 IID,
X, ConstantInt::get(
II->getType(), NewVal)));
2656 case Intrinsic::minnum:
2657 case Intrinsic::maxnum:
2658 case Intrinsic::minimum:
2659 case Intrinsic::maximum: {
2660 Value *Arg0 =
II->getArgOperand(0);
2661 Value *Arg1 =
II->getArgOperand(1);
2670 case Intrinsic::maxnum:
2671 NewIID = Intrinsic::minnum;
2673 case Intrinsic::minnum:
2674 NewIID = Intrinsic::maxnum;
2676 case Intrinsic::maximum:
2677 NewIID = Intrinsic::minimum;
2679 case Intrinsic::minimum:
2680 NewIID = Intrinsic::maximum;
2686 Instruction *FNeg = UnaryOperator::CreateFNeg(NewCall);
2701 case Intrinsic::maxnum:
2704 case Intrinsic::minnum:
2707 case Intrinsic::maximum:
2710 case Intrinsic::minimum:
2720 IID,
X, ConstantFP::get(Arg0->
getType(), Res),
2729 X->getType() ==
Y->getType()) {
2731 Builder.CreateBinaryIntrinsic(IID,
X,
Y,
II,
II->getName());
2741 auto IsMinMaxOrXNegX = [IID, &
X](
Value *Op0,
Value *Op1) {
2743 return Op0->hasOneUse() ||
2744 (IID != Intrinsic::minimum && IID != Intrinsic::minnum);
2748 if (IsMinMaxOrXNegX(Arg0, Arg1) || IsMinMaxOrXNegX(Arg1, Arg0)) {
2750 if (IID == Intrinsic::minimum || IID == Intrinsic::minnum)
2757 case Intrinsic::matrix_multiply: {
2769 Value *Op0 =
II->getOperand(0);
2770 Value *Op1 =
II->getOperand(1);
2771 Value *OpNotNeg, *NegatedOp;
2772 unsigned NegatedOpArg, OtherOpArg;
2789 Value *OtherOp =
II->getOperand(OtherOpArg);
2807 NewArgs[NegatedOpArg] = OpNotNeg;
2809 Builder.CreateIntrinsic(
II->getType(), IID, NewArgs,
II);
2814 case Intrinsic::fmuladd: {
2818 II->getFastMathFlags(),
SQ.getWithInstruction(
II)))
2820 II->getFastMathFlags());
2824 case Intrinsic::fma: {
2826 Value *Src0 =
II->getArgOperand(0);
2827 Value *Src1 =
II->getArgOperand(1);
2828 Value *Src2 =
II->getArgOperand(2);
2847 SQ.getWithInstruction(
II)))
2863 case Intrinsic::copysign: {
2864 Value *Mag =
II->getArgOperand(0), *Sign =
II->getArgOperand(1);
2867 if (*KnownSignBit) {
2870 Value *Fabs =
Builder.CreateUnaryIntrinsic(Intrinsic::fabs, Mag,
II);
2876 Value *Fabs =
Builder.CreateUnaryIntrinsic(Intrinsic::fabs, Mag,
II);
2907 case Intrinsic::fabs: {
2909 Value *Arg =
II->getArgOperand(0);
2927 SI->setFastMathFlags(FMF1 | FMF2);
2938 Value *Magnitude, *Sign;
2939 if (
match(
II->getArgOperand(0),
2943 Builder.CreateUnaryIntrinsic(Intrinsic::fabs, Magnitude,
II);
2949 case Intrinsic::ceil:
2950 case Intrinsic::floor:
2951 case Intrinsic::round:
2952 case Intrinsic::roundeven:
2953 case Intrinsic::nearbyint:
2954 case Intrinsic::rint:
2955 case Intrinsic::trunc: {
2964 case Intrinsic::cos:
2965 case Intrinsic::amdgcn_cos: {
2967 Value *Src =
II->getArgOperand(0);
2977 case Intrinsic::sin:
2978 case Intrinsic::amdgcn_sin: {
2987 case Intrinsic::ldexp: {
3000 Value *Src =
II->getArgOperand(0);
3001 Value *Exp =
II->getArgOperand(1);
3006 Exp->getType() == InnerExp->
getType()) {
3015 II->setArgOperand(1, NewExp);
3016 II->setFastMathFlags(InnerFlags);
3027 Builder.CreateSelect(ExtSrc, ConstantFP::get(
II->getType(), 2.0),
3028 ConstantFP::get(
II->getType(), 1.0));
3034 Builder.CreateSelect(ExtSrc, ConstantFP::get(
II->getType(), 0.5),
3035 ConstantFP::get(
II->getType(), 1.0));
3043 Value *SelectCond, *SelectLHS, *SelectRHS;
3044 if (
match(
II->getArgOperand(1),
3047 Value *NewLdexp =
nullptr;
3050 NewLdexp =
Builder.CreateLdexp(Src, SelectLHS,
II);
3053 NewLdexp =
Builder.CreateLdexp(Src, SelectRHS,
II);
3065 case Intrinsic::ptrauth_auth:
3066 case Intrinsic::ptrauth_resign: {
3069 bool NeedSign =
II->getIntrinsicID() == Intrinsic::ptrauth_resign;
3072 Value *Disc =
II->getArgOperand(2);
3076 Value *AuthKey =
nullptr, *AuthDisc =
nullptr, *BasePtr;
3093 if (!CPA || !CPA->isKnownCompatibleWith(
Key, Disc,
DL))
3102 SignDisc, SignAddrDisc);
3109 BasePtr =
Builder.CreatePtrToInt(CPA->getPointer(),
II->getType());
3114 if (AuthKey && NeedSign) {
3116 NewIntrin = Intrinsic::ptrauth_resign;
3117 }
else if (AuthKey) {
3119 NewIntrin = Intrinsic::ptrauth_auth;
3120 }
else if (NeedSign) {
3122 NewIntrin = Intrinsic::ptrauth_sign;
3145 case Intrinsic::arm_neon_vtbl1:
3146 case Intrinsic::aarch64_neon_tbl1:
3151 case Intrinsic::arm_neon_vmulls:
3152 case Intrinsic::arm_neon_vmullu:
3153 case Intrinsic::aarch64_neon_smull:
3154 case Intrinsic::aarch64_neon_umull: {
3155 Value *Arg0 =
II->getArgOperand(0);
3156 Value *Arg1 =
II->getArgOperand(1);
3164 bool Zext = (IID == Intrinsic::arm_neon_vmullu ||
3165 IID == Intrinsic::aarch64_neon_umull);
3188 case Intrinsic::arm_neon_aesd:
3189 case Intrinsic::arm_neon_aese:
3190 case Intrinsic::aarch64_crypto_aesd:
3191 case Intrinsic::aarch64_crypto_aese:
3192 case Intrinsic::aarch64_sve_aesd:
3193 case Intrinsic::aarch64_sve_aese: {
3194 Value *DataArg =
II->getArgOperand(0);
3195 Value *KeyArg =
II->getArgOperand(1);
3211 case Intrinsic::hexagon_V6_vandvrt:
3212 case Intrinsic::hexagon_V6_vandvrt_128B: {
3216 if (ID0 != Intrinsic::hexagon_V6_vandqrt &&
3217 ID0 != Intrinsic::hexagon_V6_vandqrt_128B)
3219 Value *Bytes = Op0->getArgOperand(1), *Mask =
II->getArgOperand(1);
3224 if ((
C & 0xFF) && (
C & 0xFF00) && (
C & 0xFF0000) && (
C & 0xFF000000))
3229 case Intrinsic::stackrestore: {
3230 enum class ClassifyResult {
3234 CallWithSideEffects,
3238 return ClassifyResult::Alloca;
3242 if (
II->getIntrinsicID() == Intrinsic::stackrestore)
3243 return ClassifyResult::StackRestore;
3245 if (
II->mayHaveSideEffects())
3246 return ClassifyResult::CallWithSideEffects;
3249 return ClassifyResult::CallWithSideEffects;
3253 return ClassifyResult::None;
3260 if (SS->getIntrinsicID() == Intrinsic::stacksave &&
3261 SS->getParent() ==
II->getParent()) {
3263 bool CannotRemove =
false;
3264 for (++BI; &*BI !=
II; ++BI) {
3265 switch (Classify(&*BI)) {
3266 case ClassifyResult::None:
3270 case ClassifyResult::StackRestore:
3274 CannotRemove =
true;
3277 case ClassifyResult::Alloca:
3278 case ClassifyResult::CallWithSideEffects:
3281 CannotRemove =
true;
3297 bool CannotRemove =
false;
3298 for (++BI; &*BI != TI; ++BI) {
3299 switch (Classify(&*BI)) {
3300 case ClassifyResult::None:
3304 case ClassifyResult::StackRestore:
3308 case ClassifyResult::Alloca:
3309 case ClassifyResult::CallWithSideEffects:
3313 CannotRemove =
true;
3327 case Intrinsic::lifetime_end:
3330 if (
II->getFunction()->hasFnAttribute(Attribute::SanitizeAddress) ||
3331 II->getFunction()->hasFnAttribute(Attribute::SanitizeMemory) ||
3332 II->getFunction()->hasFnAttribute(Attribute::SanitizeHWAddress))
3336 return I.getIntrinsicID() == Intrinsic::lifetime_start;
3340 case Intrinsic::assume: {
3341 Value *IIOperand =
II->getArgOperand(0);
3343 II->getOperandBundlesAsDefs(OpBundles);
3360 return RemoveConditionFromAssume(
Next);
3366 Value *AssumeIntrinsic =
II->getCalledOperand();
3369 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic,
A, OpBundles,
3371 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic,
B,
II->getName());
3376 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic,
3377 Builder.CreateNot(
A), OpBundles,
II->getName());
3378 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic,
3388 LHS->getOpcode() == Instruction::Load &&
3389 LHS->getType()->isPointerTy() &&
3392 LHS->setMetadata(LLVMContext::MD_nonnull, MD);
3393 LHS->setMetadata(LLVMContext::MD_noundef, MD);
3394 return RemoveConditionFromAssume(
II);
3400 for (
unsigned Idx = 0; Idx <
II->getNumOperandBundles(); Idx++) {
3407 if (OBU.
getTagName() ==
"separate_storage") {
3409 auto MaybeSimplifyHint = [&](
const Use &U) {
3410 Value *Hint = U.get();
3417 MaybeSimplifyHint(OBU.
Inputs[0]);
3418 MaybeSimplifyHint(OBU.
Inputs[1]);
3425 if (!RK || RK.
AttrKind != Attribute::Alignment ||
3460 A->getType()->isPointerTy()) {
3464 Replacement->insertBefore(
Next->getIterator());
3465 AC.registerAssumption(Replacement);
3466 return RemoveConditionFromAssume(
II);
3494 if (
auto *Replacement =
3497 Replacement->insertAfter(
II->getIterator());
3498 AC.registerAssumption(Replacement);
3500 return RemoveConditionFromAssume(
II);
3507 for (
unsigned Idx = 0; Idx <
II->getNumOperandBundles(); Idx++) {
3508 auto &BOI =
II->bundle_op_info_begin()[Idx];
3511 if (BOI.End - BOI.Begin > 2)
3522 if (BOI.End - BOI.Begin > 0) {
3523 Worklist.pushValue(
II->op_begin()[BOI.Begin]);
3529 if (BOI.End - BOI.Begin > 0)
3530 II->op_begin()[BOI.Begin].set(CanonRK.
WasOn);
3531 if (BOI.End - BOI.Begin > 1)
3532 II->op_begin()[BOI.Begin + 1].set(ConstantInt::get(
3558 case Intrinsic::experimental_guard: {
3569 Value *NextCond =
nullptr;
3572 Value *CurrCond =
II->getArgOperand(0);
3576 if (CurrCond != NextCond) {
3578 while (MoveI != NextInst) {
3590 case Intrinsic::vector_insert: {
3591 Value *Vec =
II->getArgOperand(0);
3592 Value *SubVec =
II->getArgOperand(1);
3593 Value *Idx =
II->getArgOperand(2);
3600 if (DstTy && VecTy && SubVecTy) {
3601 unsigned DstNumElts = DstTy->getNumElements();
3602 unsigned VecNumElts = VecTy->getNumElements();
3603 unsigned SubVecNumElts = SubVecTy->getNumElements();
3607 if (VecNumElts == SubVecNumElts)
3616 for (i = 0; i != SubVecNumElts; ++i)
3618 for (; i != VecNumElts; ++i)
3621 Value *WidenShuffle =
Builder.CreateShuffleVector(SubVec, WidenMask);
3624 for (
unsigned i = 0; i != IdxN; ++i)
3626 for (
unsigned i = DstNumElts; i != DstNumElts + SubVecNumElts; ++i)
3628 for (
unsigned i = IdxN + SubVecNumElts; i != DstNumElts; ++i)
3631 Value *Shuffle =
Builder.CreateShuffleVector(Vec, WidenShuffle, Mask);
3636 case Intrinsic::vector_extract: {
3637 Value *Vec =
II->getArgOperand(0);
3638 Value *Idx =
II->getArgOperand(1);
3640 Type *ReturnType =
II->getType();
3644 Value *InsertTuple, *InsertIdx, *InsertValue;
3648 InsertValue->
getType() == ReturnType) {
3653 if (ExtractIdx == Index)
3667 if (DstTy && VecTy) {
3668 auto DstEltCnt = DstTy->getElementCount();
3669 auto VecEltCnt = VecTy->getElementCount();
3673 if (DstEltCnt == VecTy->getElementCount()) {
3680 if (VecEltCnt.isScalable() || DstEltCnt.isScalable())
3684 for (
unsigned i = 0; i != DstEltCnt.getKnownMinValue(); ++i)
3685 Mask.push_back(IdxN + i);
3687 Value *Shuffle =
Builder.CreateShuffleVector(Vec, Mask);
3692 case Intrinsic::experimental_vp_reverse: {
3694 Value *Vec =
II->getArgOperand(0);
3695 Value *Mask =
II->getArgOperand(1);
3698 Value *EVL =
II->getArgOperand(2);
3706 OldUnOp->getOpcode(),
X, OldUnOp, OldUnOp->getName(),
3712 case Intrinsic::vector_reduce_or:
3713 case Intrinsic::vector_reduce_and: {
3721 Value *Arg =
II->getArgOperand(0);
3732 if (FTy->getElementType() ==
Builder.getInt1Ty()) {
3734 Vect,
Builder.getIntNTy(FTy->getNumElements()));
3735 if (IID == Intrinsic::vector_reduce_and) {
3739 assert(IID == Intrinsic::vector_reduce_or &&
3740 "Expected or reduction.");
3741 Res =
Builder.CreateIsNotNull(Res);
3751 case Intrinsic::vector_reduce_add: {
3752 if (IID == Intrinsic::vector_reduce_add) {
3759 Value *Arg =
II->getArgOperand(0);
3770 if (FTy->getElementType() ==
Builder.getInt1Ty()) {
3772 Vect,
Builder.getIntNTy(FTy->getNumElements()));
3773 Value *Res =
Builder.CreateUnaryIntrinsic(Intrinsic::ctpop, V);
3775 Res =
Builder.CreateZExtOrTrunc(Res,
II->getType());
3787 if (VecToReduceCount.
isFixed()) {
3789 return BinaryOperator::CreateMul(
3790 Splat, ConstantInt::get(
Splat->getType(), VectorSize));
3796 case Intrinsic::vector_reduce_xor: {
3797 if (IID == Intrinsic::vector_reduce_xor) {
3805 Value *Arg =
II->getArgOperand(0);
3816 if (VTy->getElementType() ==
Builder.getInt1Ty()) {
3827 case Intrinsic::vector_reduce_mul: {
3828 if (IID == Intrinsic::vector_reduce_mul) {
3835 Value *Arg =
II->getArgOperand(0);
3846 if (VTy->getElementType() ==
Builder.getInt1Ty()) {
3849 Res =
Builder.CreateZExt(Res,
II->getType());
3856 case Intrinsic::vector_reduce_umin:
3857 case Intrinsic::vector_reduce_umax: {
3858 if (IID == Intrinsic::vector_reduce_umin ||
3859 IID == Intrinsic::vector_reduce_umax) {
3866 Value *Arg =
II->getArgOperand(0);
3877 if (VTy->getElementType() ==
Builder.getInt1Ty()) {
3878 Value *Res = IID == Intrinsic::vector_reduce_umin
3879 ?
Builder.CreateAndReduce(Vect)
3880 :
Builder.CreateOrReduce(Vect);
3890 case Intrinsic::vector_reduce_smin:
3891 case Intrinsic::vector_reduce_smax: {
3892 if (IID == Intrinsic::vector_reduce_smin ||
3893 IID == Intrinsic::vector_reduce_smax) {
3908 Value *Arg =
II->getArgOperand(0);
3919 if (VTy->getElementType() ==
Builder.getInt1Ty()) {
3923 Value *Res = ((IID == Intrinsic::vector_reduce_smin) ==
3924 (ExtOpc == Instruction::CastOps::ZExt))
3925 ?
Builder.CreateAndReduce(Vect)
3926 :
Builder.CreateOrReduce(Vect);
3928 Res =
Builder.CreateCast(ExtOpc, Res,
II->getType());
3935 case Intrinsic::vector_reduce_fmax:
3936 case Intrinsic::vector_reduce_fmin:
3937 case Intrinsic::vector_reduce_fadd:
3938 case Intrinsic::vector_reduce_fmul: {
3939 bool CanReorderLanes = (IID != Intrinsic::vector_reduce_fadd &&
3940 IID != Intrinsic::vector_reduce_fmul) ||
3941 II->hasAllowReassoc();
3942 const unsigned ArgIdx = (IID == Intrinsic::vector_reduce_fadd ||
3943 IID == Intrinsic::vector_reduce_fmul)
3946 Value *Arg =
II->getArgOperand(ArgIdx);
3953 case Intrinsic::is_fpclass: {
3958 case Intrinsic::threadlocal_address: {
3967 case Intrinsic::frexp: {
3982 case Intrinsic::get_active_lane_mask: {
3983 const APInt *Op0, *Op1;
3986 Type *OpTy =
II->getOperand(0)->getType();
3989 II->getType(), Intrinsic::get_active_lane_mask,
3990 {Constant::getNullValue(OpTy),
3991 ConstantInt::get(OpTy, Op1->usub_sat(*Op0))}));
4030 return visitCallBase(*
II);
4045 if (FI1SyncScope != FI2->getSyncScopeID() ||
4052 if (NFI && isIdenticalOrStrongerFence(NFI, &FI))
4056 if (isIdenticalOrStrongerFence(PFI, &FI))
4063 return visitCallBase(
II);
4068 return visitCallBase(CBI);
4087 InstCombineRAUW, InstCombineErase);
4088 if (
Value *With = Simplifier.optimizeCall(CI,
Builder)) {
4100 if (Underlying != TrampMem &&
4101 (!Underlying->hasOneUse() || Underlying->user_back() != TrampMem))
4111 if (
II->getIntrinsicID() == Intrinsic::init_trampoline) {
4115 InitTrampoline =
II;
4118 if (
II->getIntrinsicID() == Intrinsic::adjust_trampoline)
4125 if (!InitTrampoline)
4129 if (InitTrampoline->
getOperand(0) != TrampMem)
4132 return InitTrampoline;
4144 if (
II->getIntrinsicID() == Intrinsic::init_trampoline &&
4145 II->getOperand(0) == TrampMem)
4157 Callee = Callee->stripPointerCasts();
4175 if (!IPC || !IPC->isNoopCast(
DL))
4183 if (IIID != Intrinsic::ptrauth_resign && IIID != Intrinsic::ptrauth_sign)
4187 std::optional<OperandBundleUse> PtrAuthBundleOrNone;
4192 PtrAuthBundleOrNone = Bundle;
4197 if (!PtrAuthBundleOrNone)
4200 Value *NewCallee =
nullptr;
4204 case Intrinsic::ptrauth_resign: {
4206 if (
II->getOperand(3) != PtrAuthBundleOrNone->Inputs[0])
4209 if (
II->getOperand(4) != PtrAuthBundleOrNone->Inputs[1])
4214 if (
II->getOperand(1) != PtrAuthBundleOrNone->Inputs[0])
4217 Value *NewBundleOps[] = {
II->getOperand(1),
II->getOperand(2)};
4219 NewCallee =
II->getOperand(0);
4226 case Intrinsic::ptrauth_sign: {
4228 if (
II->getOperand(1) != PtrAuthBundleOrNone->Inputs[0])
4231 if (
II->getOperand(2) != PtrAuthBundleOrNone->Inputs[1])
4233 NewCallee =
II->getOperand(0);
4243 NewCallee =
Builder.CreateBitOrPointerCast(NewCallee,
Callee->getType());
4268 if (!CPA->isKnownCompatibleWith(
Key, Discriminator,
DL))
4277bool InstCombinerImpl::annotateAnyAllocSite(
CallBase &
Call,
4314 if (NewAlign > ExistingAlign) {
4331 SmallVector<unsigned, 4> ArgNos;
4335 if (
V->getType()->isPointerTy()) {
4340 (HasDereferenceable &&
4342 V->getType()->getPointerAddressSpace()))) {
4343 if (
Value *Res = simplifyNonNullOperand(V, HasDereferenceable)) {
4357 if (!ArgNos.
empty()) {
4360 AS = AS.addParamAttribute(Ctx, ArgNos,
4371 transformConstExprCastCall(
Call))
4435 return transformCallThroughTrampoline(
Call, *
II);
4438 if (Instruction *NewCall = foldPtrAuthIntrinsicCallee(
Call))
4442 if (Instruction *NewCall = foldPtrAuthConstantCallee(
Call))
4447 if (!
IA->canThrow()) {
4468 Type *RetArgTy = ReturnedArg->getType();
4471 Call,
Builder.CreateBitOrPointerCast(ReturnedArg, CallTy));
4487 ConstantInt *FunctionType =
nullptr;
4490 if (MDNode *MD = CalleeF->
getMetadata(LLVMContext::MD_kcfi_type))
4497 <<
": call to " << CalleeF->
getName()
4498 <<
" using a mismatching function pointer type\n";
4510 case Intrinsic::experimental_gc_statepoint: {
4512 SmallPtrSet<Value *, 32> LiveGcValues;
4514 GCRelocateInst &GCR = *
const_cast<GCRelocateInst *
>(Reloc);
4565 LiveGcValues.
insert(BasePtr);
4566 LiveGcValues.
insert(DerivedPtr);
4568 std::optional<OperandBundleUse> Bundle =
4570 unsigned NumOfGCLives = LiveGcValues.
size();
4571 if (!Bundle || NumOfGCLives == Bundle->Inputs.size())
4574 DenseMap<Value *, unsigned> Val2Idx;
4575 std::vector<Value *> NewLiveGc;
4576 for (
Value *V : Bundle->Inputs) {
4580 if (LiveGcValues.
count(V)) {
4581 It->second = NewLiveGc.size();
4582 NewLiveGc.push_back(V);
4584 It->second = NumOfGCLives;
4588 GCRelocateInst &GCR = *
const_cast<GCRelocateInst *
>(Reloc);
4590 assert(Val2Idx.
count(BasePtr) && Val2Idx[BasePtr] != NumOfGCLives &&
4591 "Missed live gc for base pointer");
4593 GCR.
setOperand(1, ConstantInt::get(OpIntTy1, Val2Idx[BasePtr]));
4595 assert(Val2Idx.
count(DerivedPtr) && Val2Idx[DerivedPtr] != NumOfGCLives &&
4596 "Missed live gc for derived pointer");
4598 GCR.
setOperand(2, ConstantInt::get(OpIntTy2, Val2Idx[DerivedPtr]));
4613bool InstCombinerImpl::transformConstExprCastCall(
CallBase &
Call) {
4620 "CallBr's don't have a single point after a def to insert at");
4625 if (
Callee->isDeclaration())
4631 if (
Callee->hasFnAttribute(
"thunk"))
4637 if (
Callee->hasFnAttribute(Attribute::Naked))
4653 FunctionType *FT =
Callee->getFunctionType();
4655 Type *NewRetTy = FT->getReturnType();
4658 if (OldRetTy != NewRetTy) {
4664 if (!
Caller->use_empty())
4668 if (!CallerPAL.isEmpty() && !
Caller->use_empty()) {
4669 AttrBuilder RAttrs(FT->getContext(), CallerPAL.getRetAttrs());
4670 if (RAttrs.overlaps(AttributeFuncs::typeIncompatible(
4671 NewRetTy, CallerPAL.getRetAttrs())))
4679 if (!
Caller->use_empty()) {
4682 PhisNotSupportedBlock =
II->getNormalDest();
4683 if (PhisNotSupportedBlock)
4684 for (User *U :
Caller->users())
4686 if (PN->getParent() == PhisNotSupportedBlock)
4692 unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs);
4702 if (
Callee->getAttributes().hasAttrSomewhere(Attribute::InAlloca) ||
4703 Callee->getAttributes().hasAttrSomewhere(Attribute::Preallocated))
4707 for (
unsigned i = 0, e = NumCommonArgs; i !=
e; ++i, ++AI) {
4708 Type *ParamTy = FT->getParamType(i);
4709 Type *ActTy = (*AI)->getType();
4715 if (AttrBuilder(FT->getContext(), CallerPAL.getParamAttrs(i))
4716 .overlaps(AttributeFuncs::typeIncompatible(
4717 ParamTy, CallerPAL.getParamAttrs(i),
4718 AttributeFuncs::ASK_UNSAFE_TO_DROP)))
4722 CallerPAL.hasParamAttr(i, Attribute::Preallocated))
4725 if (CallerPAL.hasParamAttr(i, Attribute::SwiftError))
4728 if (CallerPAL.hasParamAttr(i, Attribute::ByVal) !=
4729 Callee->getAttributes().hasParamAttr(i, Attribute::ByVal))
4733 if (FT->getNumParams() < NumActualArgs && FT->isVarArg() &&
4734 !CallerPAL.isEmpty()) {
4739 if (CallerPAL.hasAttrSomewhere(Attribute::StructRet, &SRetIdx) &&
4740 SRetIdx - AttributeList::FirstArgIndex >= FT->getNumParams())
4746 SmallVector<Value *, 8>
Args;
4748 Args.reserve(NumActualArgs);
4749 ArgAttrs.
reserve(NumActualArgs);
4752 AttrBuilder RAttrs(FT->getContext(), CallerPAL.getRetAttrs());
4757 AttributeFuncs::typeIncompatible(NewRetTy, CallerPAL.getRetAttrs()));
4761 for (
unsigned i = 0; i != NumCommonArgs; ++i, ++AI) {
4762 Type *ParamTy = FT->getParamType(i);
4764 Value *NewArg = *AI;
4765 if ((*AI)->getType() != ParamTy)
4766 NewArg =
Builder.CreateBitOrPointerCast(*AI, ParamTy);
4767 Args.push_back(NewArg);
4771 AttributeMask IncompatibleAttrs = AttributeFuncs::typeIncompatible(
4772 ParamTy, CallerPAL.getParamAttrs(i), AttributeFuncs::ASK_SAFE_TO_DROP);
4774 CallerPAL.getParamAttrs(i).removeAttributes(Ctx, IncompatibleAttrs));
4779 for (
unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i) {
4785 if (FT->getNumParams() < NumActualArgs) {
4787 if (FT->isVarArg()) {
4789 for (
unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) {
4791 Value *NewArg = *AI;
4792 if (PTy != (*AI)->getType()) {
4796 NewArg =
Builder.CreateCast(opcode, *AI, PTy);
4798 Args.push_back(NewArg);
4801 ArgAttrs.
push_back(CallerPAL.getParamAttrs(i));
4806 AttributeSet FnAttrs = CallerPAL.getFnAttrs();
4811 assert((ArgAttrs.
size() == FT->getNumParams() || FT->isVarArg()) &&
4812 "missing argument attributes");
4813 AttributeList NewCallerPAL = AttributeList::get(
4821 NewCall =
Builder.CreateInvoke(Callee,
II->getNormalDest(),
4822 II->getUnwindDest(), Args, OpBundles);
4824 NewCall =
Builder.CreateCall(Callee, Args, OpBundles);
4833 NewCall->
copyMetadata(*Caller, {LLVMContext::MD_prof});
4838 if (OldRetTy !=
NV->getType() && !
Caller->use_empty()) {
4839 assert(!
NV->getType()->isVoidTy());
4841 NC->setDebugLoc(
Caller->getDebugLoc());
4844 assert(OptInsertPt &&
"No place to insert cast");
4846 Worklist.pushUsersToWorkList(*Caller);
4849 if (!
Caller->use_empty())
4851 else if (
Caller->hasValueHandle()) {
4852 if (OldRetTy ==
NV->getType())
4867InstCombinerImpl::transformCallThroughTrampoline(
CallBase &
Call,
4874 if (
Attrs.hasAttrSomewhere(Attribute::Nest))
4881 if (!NestAttrs.isEmpty()) {
4882 unsigned NestArgNo = 0;
4883 Type *NestTy =
nullptr;
4884 AttributeSet NestAttr;
4888 E = NestFTy->param_end();
4889 I !=
E; ++NestArgNo, ++
I) {
4890 AttributeSet AS = NestAttrs.getParamAttrs(NestArgNo);
4900 std::vector<Value*> NewArgs;
4901 std::vector<AttributeSet> NewArgAttrs;
4912 if (ArgNo == NestArgNo) {
4915 if (NestVal->
getType() != NestTy)
4916 NestVal =
Builder.CreateBitCast(NestVal, NestTy,
"nest");
4917 NewArgs.push_back(NestVal);
4918 NewArgAttrs.push_back(NestAttr);
4925 NewArgs.push_back(*
I);
4926 NewArgAttrs.push_back(
Attrs.getParamAttrs(ArgNo));
4937 std::vector<Type*> NewTypes;
4938 NewTypes.reserve(FTy->getNumParams()+1);
4945 E = FTy->param_end();
4948 if (ArgNo == NestArgNo)
4950 NewTypes.push_back(NestTy);
4956 NewTypes.push_back(*
I);
4965 FunctionType *NewFTy =
4967 AttributeList NewPAL =
4968 AttributeList::get(FTy->getContext(),
Attrs.getFnAttrs(),
4969 Attrs.getRetAttrs(), NewArgAttrs);
4977 II->getUnwindDest(), NewArgs, OpBundles);
4983 CBI->getIndirectDests(), NewArgs, OpBundles);
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AMDGPU Register Bank Select
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
Atomic ordering constants.
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static SDValue foldBitOrderCrossLogicOp(SDNode *N, SelectionDAG &DAG)
static Type * getPromotedType(Type *Ty)
Return the specified type promoted as it would be to pass though a va_arg area.
static Instruction * createOverflowTuple(IntrinsicInst *II, Value *Result, Constant *Overflow)
Creates a result tuple for an overflow intrinsic II with a given Result and a constant Overflow value...
static IntrinsicInst * findInitTrampolineFromAlloca(Value *TrampMem)
static bool removeTriviallyEmptyRange(IntrinsicInst &EndI, InstCombinerImpl &IC, std::function< bool(const IntrinsicInst &)> IsStart)
static bool inputDenormalIsDAZ(const Function &F, const Type *Ty)
static Instruction * reassociateMinMaxWithConstantInOperand(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
If this min/max has a matching min/max operand with a constant, try to push the constant operand into...
static bool isIdempotentBinaryIntrinsic(Intrinsic::ID IID)
Helper to match idempotent binary intrinsics, namely, intrinsics where f(f(x, y), y) == f(x,...
static bool signBitMustBeTheSame(Value *Op0, Value *Op1, const SimplifyQuery &SQ)
Return true if two values Op0 and Op1 are known to have the same sign.
static Instruction * moveAddAfterMinMax(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
Try to canonicalize min/max(X + C0, C1) as min/max(X, C1 - C0) + C0.
static Instruction * simplifyInvariantGroupIntrinsic(IntrinsicInst &II, InstCombinerImpl &IC)
This function transforms launder.invariant.group and strip.invariant.group like: launder(launder(x)) ...
static bool haveSameOperands(const IntrinsicInst &I, const IntrinsicInst &E, unsigned NumOperands)
static std::optional< bool > getKnownSign(Value *Op, const SimplifyQuery &SQ)
static cl::opt< unsigned > GuardWideningWindow("instcombine-guard-widening-window", cl::init(3), cl::desc("How wide an instruction window to bypass looking for " "another guard"))
static bool hasUndefSource(AnyMemTransferInst *MI)
Recognize a memcpy/memmove from a trivially otherwise unused alloca.
static Instruction * factorizeMinMaxTree(IntrinsicInst *II)
Reduce a sequence of min/max intrinsics with a common operand.
static Value * simplifyNeonTbl1(const IntrinsicInst &II, InstCombiner::BuilderTy &Builder)
Convert a table lookup to shufflevector if the mask is constant.
static Instruction * foldClampRangeOfTwo(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
If we have a clamp pattern like max (min X, 42), 41 – where the output can only be one of two possibl...
static Value * simplifyReductionOperand(Value *Arg, bool CanReorderLanes)
static IntrinsicInst * findInitTrampolineFromBB(IntrinsicInst *AdjustTramp, Value *TrampMem)
static Value * foldIntrinsicUsingDistributiveLaws(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
static std::optional< bool > getKnownSignOrZero(Value *Op, const SimplifyQuery &SQ)
static Value * foldMinimumOverTrailingOrLeadingZeroCount(Value *I0, Value *I1, const DataLayout &DL, InstCombiner::BuilderTy &Builder)
Fold an unsigned minimum of trailing or leading zero bits counts: umin(cttz(CtOp, ZeroUndef),...
static Value * foldIdempotentBinaryIntrinsicRecurrence(InstCombinerImpl &IC, IntrinsicInst *II)
Attempt to simplify value-accumulating recurrences of kind: umax.acc = phi i8 [ umax,...
static Instruction * foldCtpop(IntrinsicInst &II, InstCombinerImpl &IC)
static Instruction * foldCttzCtlz(IntrinsicInst &II, InstCombinerImpl &IC)
static IntrinsicInst * findInitTrampoline(Value *Callee)
static FCmpInst::Predicate fpclassTestIsFCmp0(FPClassTest Mask, const Function &F, Type *Ty)
static bool leftDistributesOverRight(Instruction::BinaryOps LOp, bool HasNUW, bool HasNSW, Intrinsic::ID ROp)
Return whether "X LOp (Y ROp Z)" is always equal to "(X LOp Y) ROp (X LOp Z)".
static Value * reassociateMinMaxWithConstants(IntrinsicInst *II, IRBuilderBase &Builder, const SimplifyQuery &SQ)
If this min/max has a constant operand and an operand that is a matching min/max with a constant oper...
static CallInst * canonicalizeConstantArg0ToArg1(CallInst &Call)
This file provides internal interfaces used to implement the InstCombine.
This file provides the interface for the instcombine pass implementation.
static bool hasNoSignedWrap(BinaryOperator &I)
static bool inputDenormalIsIEEE(DenormalMode Mode)
Return true if it's possible to assume IEEE treatment of input denormals in F for Val.
static const Function * getCalledFunction(const Value *V)
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
if(auto Err=PB.parsePassPipeline(MPM, Passes)) return wrap(std MPM run * Mod
const SmallVectorImpl< MachineOperand > & Cond
This file implements the SmallBitVector 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)
#define DEBUG_WITH_TYPE(TYPE,...)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
Class for arbitrary precision integers.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
static APInt getSignMask(unsigned BitWidth)
Get the SignMask for a specific bit width.
bool sgt(const APInt &RHS) const
Signed greater than comparison.
LLVM_ABI APInt usub_ov(const APInt &RHS, bool &Overflow) const
bool ugt(const APInt &RHS) const
Unsigned greater than comparison.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
LLVM_ABI APInt urem(const APInt &RHS) const
Unsigned remainder operation.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
LLVM_ABI APInt sadd_ov(const APInt &RHS, bool &Overflow) const
LLVM_ABI APInt uadd_ov(const APInt &RHS, bool &Overflow) const
static LLVM_ABI APInt getSplat(unsigned NewLen, const APInt &V)
Return a value containing V broadcasted over NewLen bits.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
LLVM_ABI APInt uadd_sat(const APInt &RHS) const
bool isNonNegative() const
Determine if this APInt Value is non-negative (>= 0)
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Constructs an APInt value that has the bottom loBitsSet bits set.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
LLVM_ABI APInt ssub_ov(const APInt &RHS, bool &Overflow) const
static APSInt getMinValue(uint32_t numBits, bool Unsigned)
Return the APSInt representing the minimum integer value with the given bit width and signedness.
static APSInt getMaxValue(uint32_t numBits, bool Unsigned)
Return the APSInt representing the maximum integer value with the given bit width and signedness.
This class represents any memset intrinsic.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM_ABI bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists in this set.
static LLVM_ABI AttributeSet get(LLVMContext &C, const AttrBuilder &B)
static LLVM_ABI Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
static LLVM_ABI Attribute getWithDereferenceableBytes(LLVMContext &Context, uint64_t Bytes)
static LLVM_ABI Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context, uint64_t Bytes)
static LLVM_ABI Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
InstListType::reverse_iterator reverse_iterator
InstListType::iterator iterator
Instruction iterators...
LLVM_ABI bool isSigned() const
Whether the intrinsic is signed or unsigned.
LLVM_ABI Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
static BinaryOperator * CreateFAddFMF(Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name="")
static LLVM_ABI BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
static LLVM_ABI BinaryOperator * CreateNot(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
static LLVM_ABI BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
static BinaryOperator * CreateFMulFMF(Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name="")
static BinaryOperator * CreateFDivFMF(Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name="")
static BinaryOperator * CreateFSubFMF(Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name="")
static LLVM_ABI BinaryOperator * CreateNSWNeg(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
void setCallingConv(CallingConv::ID CC)
MaybeAlign getRetAlign() const
Extract the alignment of the return value.
LLVM_ABI void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
OperandBundleUse getOperandBundleAt(unsigned Index) const
Return the operand bundle at a specific index.
std::optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool isInAllocaArgument(unsigned ArgNo) const
Determine whether this argument is passed in an alloca.
bool hasRetAttr(Attribute::AttrKind Kind) const
Determine whether the return value has the given attribute.
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
uint64_t getParamDereferenceableBytes(unsigned i) const
Extract the number of dereferenceable bytes for a call or parameter (0=unknown).
CallingConv::ID getCallingConv() const
LLVM_ABI bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
LLVM_ABI bool isIndirectCall() const
Return true if the callsite is an indirect call.
Value * getCalledOperand() const
void setAttributes(AttributeList A)
Set the attributes for this call.
bool doesNotThrow() const
Determine if the call cannot unwind.
void addRetAttr(Attribute::AttrKind Kind)
Adds the attribute to the return value.
Value * getArgOperand(unsigned i) const
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
bool isConvergent() const
Determine if the invoke is convergent.
FunctionType * getFunctionType() const
LLVM_ABI Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
Value * getReturnedArgOperand() const
If one of the arguments has the 'returned' attribute, returns its operand value.
static LLVM_ABI CallBase * Create(CallBase *CB, ArrayRef< OperandBundleDef > Bundles, InsertPosition InsertPt=nullptr)
Create a clone of CB with a different set of operand bundles and insert it before InsertPt.
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
void setCalledOperand(Value *V)
static LLVM_ABI CallBase * removeOperandBundle(CallBase *CB, uint32_t ID, InsertPosition InsertPt=nullptr)
Create a clone of CB with operand bundle ID removed.
unsigned arg_size() const
AttributeList getAttributes() const
Return the attributes for this call.
void setCalledFunction(Function *Fn)
Sets the function called, including updating the function type.
LLVM_ABI Function * getCaller()
Helper to get the caller (the parent function).
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
static CallBrInst * Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
This class represents a function call, abstracting a target machine's calling convention.
bool isNoTailCall() const
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
bool isMustTailCall() const
static LLVM_ABI Instruction::CastOps getCastOpcode(const Value *Val, bool SrcIsSigned, Type *Ty, bool DstIsSigned)
Returns the opcode necessary to cast Val into Ty using usual casting rules.
static LLVM_ABI CastInst * CreateIntegerCast(Value *S, Type *Ty, bool isSigned, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Create a ZExt, BitCast, or Trunc for int -> int casts.
static LLVM_ABI bool isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy, const DataLayout &DL)
Check whether a bitcast, inttoptr, or ptrtoint cast between these types is valid and a no-op.
static LLVM_ABI CastInst * CreateBitOrPointerCast(Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
static LLVM_ABI CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ FCMP_OLT
0 1 0 0 True if ordered and less than
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ ICMP_ULT
unsigned less than
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Predicate getNonStrictPredicate() const
For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
Predicate getUnorderedPredicate() const
static LLVM_ABI ConstantAggregateZero * get(Type *Ty)
static LLVM_ABI Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
static LLVM_ABI Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static LLVM_ABI Constant * getNeg(Constant *C, bool HasNSW=false)
static LLVM_ABI Constant * getInfinity(Type *Ty, bool Negative=false)
static LLVM_ABI Constant * getZero(Type *Ty, bool Negative=false)
This is the shared class of boolean and integer constants.
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)
static LLVM_ABI ConstantInt * getFalse(LLVMContext &Context)
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
const APInt & getValue() const
Return the constant as an APInt value reference.
static LLVM_ABI ConstantInt * getBool(LLVMContext &Context, bool V)
static LLVM_ABI ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
static LLVM_ABI ConstantPtrAuth * get(Constant *Ptr, ConstantInt *Key, ConstantInt *Disc, Constant *AddrDisc)
Return a pointer signed with the specified parameters.
This class represents a range of values.
LLVM_ABI bool isFullSet() const
Return true if this set contains all of the elements possible for this data-type.
LLVM_ABI bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const
Does the predicate Pred hold between ranges this and Other?
LLVM_ABI bool contains(const APInt &Val) const
Return true if the specified value is in the set.
static LLVM_ABI Constant * get(StructType *T, ArrayRef< Constant * > V)
This is an important base class in LLVM.
static LLVM_ABI Constant * getIntegerValue(Type *Ty, const APInt &V)
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...
static LLVM_ABI Constant * getAllOnesValue(Type *Ty)
static LLVM_ABI Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
A parsed version of the target data layout string in and methods for querying it.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&...Args)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
LLVM_ABI bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
static FMFSource intersect(Value *A, Value *B)
Intersect the FMF from two instructions.
This class represents an extension of floating point types.
Convenience struct for specifying and reasoning about fast-math flags.
void setNoSignedZeros(bool B=true)
bool allowReassoc() const
Flag queries.
An instruction for ordering other memory operations.
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this fence instruction.
AtomicOrdering getOrdering() const
Returns the ordering constraint of this fence instruction.
Class to represent function types.
Type::subtype_iterator param_iterator
static LLVM_ABI FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
bool isConvergent() const
Determine if the call is convergent.
FunctionType * getFunctionType() const
Returns the FunctionType for me.
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
AttributeList getAttributes() const
Return the attribute list for this Function.
bool doesNotThrow() const
Determine if the function cannot unwind.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
LLVM_ABI Value * getBasePtr() const
unsigned getBasePtrIndex() const
The index into the associate statepoint's argument list which contains the base pointer of the pointe...
LLVM_ABI Value * getDerivedPtr() const
unsigned getDerivedPtrIndex() const
The index into the associate statepoint's argument list which contains the pointer whose relocation t...
std::vector< const GCRelocateInst * > getGCRelocates() const
Get list of all gc reloactes linked to this statepoint May contain several relocations for the same b...
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
LLVM_ABI bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
PointerType * getType() const
Global values are always pointers.
Common base class shared among various IRBuilders.
LLVM_ABI Value * CreateLaunderInvariantGroup(Value *Ptr)
Create a launder.invariant.group intrinsic call.
ConstantInt * getTrue()
Get the constant value for i1 true.
LLVM_ABI Value * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
LLVM_ABI CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
LLVM_ABI CallInst * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
ConstantInt * getFalse()
Get the constant value for i1 false.
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
LLVM_ABI Value * CreateStripInvariantGroup(Value *Ptr)
Create a strip.invariant.group intrinsic call.
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
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,...
KnownFPClass computeKnownFPClass(Value *Val, FastMathFlags FMF, FPClassTest Interested=fcAllFlags, const Instruction *CtxI=nullptr, unsigned Depth=0) const
Instruction * foldOpIntoPhi(Instruction &I, PHINode *PN, bool AllowMultipleUses=false)
Given a binary operator, cast instruction, or select which has a PHI node as operand #0,...
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.
bool SimplifyDemandedBits(Instruction *I, unsigned Op, const APInt &DemandedMask, KnownBits &Known, const SimplifyQuery &Q, unsigned Depth=0) override
This form of SimplifyDemandedBits simplifies the specified instruction operand if possible,...
Instruction * SimplifyAnyMemSet(AnyMemSetInst *MI)
Instruction * visitFree(CallInst &FI, Value *FreedOp)
Instruction * visitCallBrInst(CallBrInst &CBI)
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Value * foldReversedIntrinsicOperands(IntrinsicInst *II)
If all arguments of the intrinsic are reverses, try to pull the reverse after the intrinsic.
Value * tryGetLog2(Value *Op, bool AssumeNonZero)
Instruction * visitFenceInst(FenceInst &FI)
Instruction * foldShuffledIntrinsicOperands(IntrinsicInst *II)
If all arguments of the intrinsic are unary shuffles with the same mask, try to shuffle after the int...
Instruction * visitInvokeInst(InvokeInst &II)
bool SimplifyDemandedInstructionBits(Instruction &Inst)
Tries to simplify operands to an integer instruction based on its demanded bits.
void CreateNonTerminatorUnreachable(Instruction *InsertAt)
Create and insert the idiom we use to indicate a block is unreachable without having to rewrite the C...
Instruction * visitVAEndInst(VAEndInst &I)
Instruction * matchBSwapOrBitReverse(Instruction &I, bool MatchBSwaps, bool MatchBitReversals)
Given an initial instruction, check to see if it is the root of a bswap/bitreverse idiom.
Constant * unshuffleConstant(ArrayRef< int > ShMask, Constant *C, VectorType *NewCTy)
Find a constant NewC that has property: shuffle(NewC, ShMask) = C Returns nullptr if such a constant ...
Instruction * visitAllocSite(Instruction &FI)
Instruction * SimplifyAnyMemTransfer(AnyMemTransferInst *MI)
OverflowResult computeOverflow(Instruction::BinaryOps BinaryOp, bool IsSigned, Value *LHS, Value *RHS, Instruction *CxtI) const
Instruction * visitCallInst(CallInst &CI)
CallInst simplification.
unsigned ComputeMaxSignificantBits(const Value *Op, const Instruction *CxtI=nullptr, unsigned Depth=0) const
IRBuilder< TargetFolder, IRBuilderCallbackInserter > BuilderTy
An IRBuilder that automatically inserts new instructions into the worklist.
bool isFreeToInvert(Value *V, bool WillInvertAllUses, bool &DoesConsume)
Return true if the specified value is free to invert (apply ~ to).
DominatorTree & getDominatorTree() const
Instruction * InsertNewInstBefore(Instruction *New, BasicBlock::iterator Old)
Inserts an instruction New before instruction Old.
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
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.
void computeKnownBits(const Value *V, KnownBits &Known, const Instruction *CxtI, unsigned Depth=0) const
std::optional< Instruction * > targetInstCombineIntrinsic(IntrinsicInst &II)
Instruction * replaceOperand(Instruction &I, unsigned OpNum, Value *V)
Replace operand of instruction and add old operand to the worklist.
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const Instruction *CxtI=nullptr, unsigned Depth=0) const
AssumptionCache & getAssumptionCache() const
OptimizationRemarkEmitter & ORE
Value * getFreelyInverted(Value *V, bool WillInvertAllUses, BuilderTy *Builder, bool &DoesConsume)
const SimplifyQuery & getSimplifyQuery() const
bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero=false, const Instruction *CxtI=nullptr, unsigned Depth=0)
LLVM_ABI void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag.
LLVM_ABI bool mayWriteToMemory() const LLVM_READONLY
Return true if this instruction may modify memory.
LLVM_ABI void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
LLVM_ABI void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag.
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
LLVM_ABI const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
LLVM_ABI void setAAMetadata(const AAMDNodes &N)
Sets the AA metadata on this instruction from the AAMDNodes structure.
LLVM_ABI void moveBefore(InstListType::iterator InsertPos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
LLVM_ABI const Function * getFunction() const
Return the function this instruction belongs to.
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
bool isTerminator() const
LLVM_ABI void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
LLVM_ABI std::optional< InstListType::iterator > getInsertionPointAfterDef()
Get the first insertion point at which the result of this instruction is defined.
LLVM_ABI bool isIdenticalTo(const Instruction *I) const LLVM_READONLY
Return true if the specified instruction is exactly identical to the current one.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
LLVM_ABI void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
Class to represent integer types.
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
A wrapper class for inspecting calls to intrinsic functions.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
An instruction for reading from memory.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)
Returns the comparison predicate underlying the intrinsic.
ICmpInst::Predicate getPredicate() const
Returns the comparison predicate underlying the intrinsic.
bool isSigned() const
Whether the intrinsic is signed or unsigned.
A Module instance is used to store all the information related to an LLVM module.
StringRef getName() const
Get a short "name" for the module.
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
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.
bool isCommutative() const
Return true if the instruction is commutative.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Represents a saturating add/sub intrinsic.
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, const Instruction *MDFrom=nullptr)
This instruction constructs a fixed permutation of two input vectors.
This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is ...
bool test(unsigned Idx) const
bool all() const
Returns true if all bits are set.
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.
reference emplace_back(ArgTypes &&... Args)
void reserve(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
void setVolatile(bool V)
Specify whether this is a volatile store or not.
void setAlignment(Align Align)
void setOrdering(AtomicOrdering Ordering)
Sets the ordering constraint of this store instruction.
Class to represent struct types.
static LLVM_ABI bool isCallingConvCCompatible(CallBase *CI)
Returns true if call site / callee has cdecl-compatible calling conventions.
Provides information about what library functions are available for the current target.
This class represents a truncation of integer types.
The instances of the Type class are immutable: once they are created, they are never changed.
static LLVM_ABI IntegerType * getInt64Ty(LLVMContext &C)
LLVM_ABI unsigned getIntegerBitWidth() const
static LLVM_ABI IntegerType * getInt32Ty(LLVMContext &C)
bool isPointerTy() const
True if this is an instance of PointerType.
LLVM_ABI bool canLosslesslyBitCastTo(Type *Ty) const
Return true if this type could be converted with a lossless BitCast to type 'Ty'.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
bool isStructTy() const
True if this is an instance of StructType.
LLVM_ABI Type * getWithNewBitWidth(unsigned NewBitWidth) const
Given an integer or vector type, change the lane bitwidth to NewBitwidth, whilst keeping the old numb...
LLVM_ABI unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isVoidTy() const
Return true if this is 'void'.
static UnaryOperator * CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO, const Twine &Name="", InsertPosition InsertBefore=nullptr)
static UnaryOperator * CreateFNegFMF(Value *Op, Instruction *FMFSource, const Twine &Name="", InsertPosition InsertBefore=nullptr)
static LLVM_ABI UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
A Use represents the edge between a Value definition and its users.
LLVM_ABI unsigned getOperandNo() const
Return the operand # of this use in its User.
void setOperand(unsigned i, Value *Val)
Value * getOperand(unsigned i) const
This represents the llvm.va_end intrinsic.
static LLVM_ABI void ValueIsDeleted(Value *V)
static LLVM_ABI void ValueIsRAUWd(Value *Old, Value *New)
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
static constexpr uint64_t MaximumAlignment
bool hasOneUse() const
Return true if there is exactly one use of this value.
iterator_range< user_iterator > users()
static LLVM_ABI void dropDroppableUse(Use &U)
Remove the droppable use U.
LLVM_ABI const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
LLVM_ABI LLVMContext & getContext() const
All values hold a context through their type.
static constexpr unsigned MaxAlignmentExponent
The maximum alignment for instructions.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
LLVM_ABI void takeName(Value *V)
Transfer the name from V to this value.
Base class of all SIMD vector types.
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
static LLVM_ABI VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
constexpr ScalarTy getFixedValue() const
static constexpr bool isKnownLT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
constexpr bool isFixed() const
Returns true if the quantity is not scaled by vscale.
static constexpr bool isKnownGT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
const ParentTy * getParent() const
self_iterator getIterator()
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
@ BasicBlock
Various leaf nodes.
LLVM_ABI Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > Tys={})
Look up the Function declaration of the intrinsic id in the Module M.
SpecificConstantMatch m_ZeroInt()
Convenience matchers for specific integer values.
BinaryOp_match< SpecificConstantMatch, SrcTy, TargetOpcode::G_SUB > m_Neg(const SrcTy &&Src)
Matches a register negated by a G_SUB.
BinaryOp_match< SrcTy, SpecificConstantMatch, TargetOpcode::G_XOR, true > m_Not(const SrcTy &&Src)
Matches a register not-ed by a G_XOR.
OneUse_match< SubPat > m_OneUse(const SubPat &SP)
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
class_match< PoisonValue > m_Poison()
Match an arbitrary poison constant.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
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.
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
ap_match< APInt > m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
BinaryOp_match< LHS, RHS, Instruction::And, true > m_c_And(const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
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)
ap_match< APInt > m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
specific_intval< false > m_SpecificInt(const APInt &V)
Match a specific integer value or vector with all elements equal to the value.
bool match(Val *V, const Pattern &P)
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.
ap_match< APFloat > m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
OverflowingBinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWNeg(const ValTy &V)
Matches a 'Neg' as 'sub nsw 0, V'.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
IntrinsicID_match m_Intrinsic()
Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()
Match a floating-point negative zero.
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
BinOpPred_match< LHS, RHS, is_logical_shift_op > m_LogicalShift(const LHS &L, const RHS &R)
Matches logical shift operations.
match_combine_and< LTy, RTy > m_CombineAnd(const LTy &L, const RTy &R)
Combine two pattern matchers matching L && R.
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Xor, true > m_c_Xor(const LHS &L, const RHS &R)
Matches an Xor with LHS and RHS in either order.
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >, OpTy > m_ZExtOrSExtOrSelf(const OpTy &Op)
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
cst_pred_ty< is_strictlypositive > m_StrictlyPositive()
Match an integer or vector of strictly positive values.
ThreeOps_match< decltype(m_Value()), LHS, RHS, Instruction::Select, true > m_c_Select(const LHS &L, const RHS &R)
Match Select(C, LHS, RHS) or Select(C, RHS, LHS)
CastInst_match< OpTy, FPExtInst > m_FPExt(const OpTy &Op)
SpecificCmpClass_match< LHS, RHS, ICmpInst > m_SpecificICmp(CmpPredicate MatchPred, const LHS &L, const RHS &R)
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
cst_pred_ty< is_negated_power2 > m_NegatedPower2()
Match a integer or vector negated power-of-2.
match_immconstant_ty m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
cst_pred_ty< custom_checkfn< APInt > > m_CheckedInt(function_ref< bool(const APInt &)> CheckFn)
Match an integer or vector where CheckFn(ele) for each element is true.
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > > m_c_MaxOrMin(const LHS &L, const RHS &R)
class_match< UnaryOperator > m_UnOp()
Match an arbitrary unary operation and ignore it.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > m_NSWAddLike(const LHS &L, const RHS &R)
Match either "add nsw" or "or disjoint".
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Exact_match< T > m_Exact(const T &SubPattern)
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
cstfp_pred_ty< is_pos_zero_fp > m_PosZeroFP()
Match a floating-point positive zero.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
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)
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
auto m_Undef()
Match an arbitrary undef constant.
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > m_NUWAddLike(const LHS &L, const RHS &R)
Match either "add nuw" or "or disjoint".
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_CopySign(const Opnd0 &Op0, const Opnd1 &Op1)
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
MatchFunctor< Val, Pattern > match_fn(const Pattern &P)
A match functor that can be used as a UnaryPredicate in functional algorithms like all_of.
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
@ SingleThread
Synchronized with respect to signal handlers executing in the same thread.
@ System
Synchronized with respect to all concurrently executing threads.
SmallVector< DbgVariableRecord * > getDVRAssignmentMarkers(const Instruction *Inst)
Return a range of dbg_assign records for which Inst performs the assignment they encode.
initializer< Ty > init(const Ty &Val)
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
DiagnosticInfoOptimizationBase::Argument NV
friend class Instruction
Iterator for Instructions in a `BasicBlock.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI cl::opt< bool > EnableKnowledgeRetention
LLVM_ABI Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
FunctionAddr VTableAddr Value
@ NeverOverflows
Never overflows.
@ AlwaysOverflowsHigh
Always overflows in the direction of signed/unsigned max value.
@ AlwaysOverflowsLow
Always overflows in the direction of signed/unsigned min value.
@ MayOverflow
May or may not overflow.
LLVM_ABI Value * simplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FMul, fold the result or return null.
LLVM_ABI bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)
Return true if it is valid to use the assumptions provided by an assume intrinsic,...
LLVM_ABI APInt possiblyDemandedEltsInMask(Value *Mask)
Given a mask vector of the form <Y x i1>, return an APInt (of bitwidth Y) for each lane which may be ...
LLVM_ABI RetainedKnowledge simplifyRetainedKnowledge(AssumeInst *Assume, RetainedKnowledge RK, AssumptionCache *AC, DominatorTree *DT)
canonicalize the RetainedKnowledge RK.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI bool isRemovableAlloc(const CallBase *V, const TargetLibraryInfo *TLI)
Return true if this is a call to an allocation function that does not have side effects that we are r...
LLVM_ABI 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.
LLVM_ABI Value * getAllocAlignment(const CallBase *V, const TargetLibraryInfo *TLI)
Gets the alignment argument for an aligned_alloc-like function, using either built-in knowledge based...
LLVM_ABI RetainedKnowledge getKnowledgeFromOperandInAssume(AssumeInst &Assume, unsigned Idx)
Retreive the information help by Assume on the operand at index Idx.
LLVM_READONLY APFloat maximum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 maximum semantics.
LLVM_ABI Value * simplifyCall(CallBase *Call, Value *Callee, ArrayRef< Value * > Args, const SimplifyQuery &Q)
Given a callsite, callee, and arguments, fold the result or return null.
LLVM_ABI Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const Instruction *I=nullptr)
Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands.
constexpr T alignDown(U Value, V Align, W Skew=0)
Returns the largest unsigned integer less than or equal to Value and is Skew mod Align.
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
LLVM_ABI bool isAssumeWithEmptyBundle(const AssumeInst &Assume)
Return true iff the operand bundles of the provided llvm.assume doesn't contain any valuable informat...
LLVM_ABI bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true, bool IgnoreUBImplyingAttrs=true)
Return true if the instruction does not have any effects besides calculating the result and does not ...
LLVM_ABI Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
constexpr T MinAlign(U A, V B)
A and B are either alignments or offsets.
LLVM_ABI RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI)
This extracts the Knowledge from an element of an operand bundle.
auto dyn_cast_or_null(const Y &Val)
Align getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to infer an alignment for the specified pointer.
LLVM_ABI bool isSplatValue(const Value *V, int Index=-1, unsigned Depth=0)
Return true if each element of the vector value V is poisoned or equal to every other non-poisoned el...
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2008 maxNum semantics.
LLVM_ABI FPClassTest fneg(FPClassTest Mask)
Return the test mask which returns true if the value's sign bit is flipped.
SelectPatternFlavor
Specific patterns of select instructions we can match.
@ SPF_ABS
Floating point maxnum.
@ SPF_NABS
Absolute value.
LLVM_ABI Constant * getLosslessUnsignedTrunc(Constant *C, Type *DestTy, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
bool isModSet(const ModRefInfo MRI)
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
LLVM_ABI SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
LLVM_ABI bool matchSimpleBinaryIntrinsicRecurrence(const IntrinsicInst *I, PHINode *&P, Value *&Init, Value *&OtherOp)
Attempt to match a simple value-accumulating recurrence of the form: llvm.intrinsic....
LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
auto find_if_not(R &&Range, UnaryPredicate P)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
bool isAtLeastOrStrongerThan(AtomicOrdering AO, AtomicOrdering Other)
LLVM_ABI Constant * getLosslessSignedTrunc(Constant *C, Type *DestTy, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)
LLVM_ABI AssumeInst * buildAssumeFromKnowledge(ArrayRef< RetainedKnowledge > Knowledge, Instruction *CtxI, AssumptionCache *AC=nullptr, DominatorTree *DT=nullptr)
Build and return a new assume created from the provided knowledge if the knowledge in the assume is f...
LLVM_ABI FPClassTest inverse_fabs(FPClassTest Mask)
Return the test mask which returns true after fabs is applied to the value.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI bool isNotCrossLaneOperation(const Instruction *I)
Return true if the instruction doesn't potentially cross vector lanes.
LLVM_ABI bool maskIsAllOneOrUndef(Value *Mask)
Given a mask vector of i1, Return true if all of the elements of this predicate mask are known to be ...
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
LLVM_ABI Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
LLVM_ABI bool 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
@ Mod
The access may modify the value stored in memory.
LLVM_ABI Value * simplifyFMAFMul(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for the multiplication of a FMA, fold the result or return null.
FunctionAddr VTableAddr uintptr_t uintptr_t Data
LLVM_ABI Value * simplifyConstrainedFPCall(CallBase *Call, const SimplifyQuery &Q)
Given a constrained FP intrinsic call, tries to compute its simplified version.
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2008 minNum semantics.
OperandBundleDefT< Value * > OperandBundleDef
LLVM_ABI bool isVectorIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, unsigned ScalarOpdIdx, const TargetTransformInfo *TTI)
Identifies if the vector form of the intrinsic has a scalar operand.
LLVM_ABI ConstantRange computeConstantRangeIncludingKnownBits(const WithCache< const Value * > &V, bool ForSigned, const SimplifyQuery &SQ)
Combine constant ranges from computeConstantRange() and computeKnownBits().
FunctionAddr VTableAddr Next
DWARFExpression::Operation Op
bool isSafeToSpeculativelyExecuteWithVariableReplaced(const Instruction *I, bool IgnoreUBImplyingAttrs=true)
Don't use information from its non-constant operands.
ArrayRef(const T &OneElt) -> ArrayRef< T >
LLVM_ABI Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
constexpr unsigned BitWidth
LLVM_ABI bool isDereferenceablePointer(const Value *V, Type *Ty, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if this is always a dereferenceable pointer.
LLVM_ABI bool maskIsAllZeroOrUndef(Value *Mask)
Given a mask vector of i1, Return true if all of the elements of this predicate mask are known to be ...
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
LLVM_ABI std::optional< APInt > getAllocSize(const CallBase *CB, const TargetLibraryInfo *TLI, function_ref< const Value *(const Value *)> Mapper=[](const Value *V) { return V;})
Return the size of the requested allocation.
unsigned Log2(Align A)
Returns the log2 of the alignment.
LLVM_ABI bool maskContainsAllOneOrUndef(Value *Mask)
Given a mask vector of i1, Return true if any of the elements of this predicate mask are known to be ...
LLVM_ABI std::optional< bool > isImpliedByDomCondition(const Value *Cond, const Instruction *ContextI, const DataLayout &DL)
Return the boolean condition value in the context of the given instruction if it is known based on do...
LLVM_READONLY APFloat minimum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 minimum semantics.
LLVM_ABI bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
LLVM_ABI bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
LLVM_ABI bool isTriviallyVectorizable(Intrinsic::ID ID)
Identify if the intrinsic is trivially vectorizable.
LLVM_ABI std::optional< bool > computeKnownFPSignBit(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return false if we can prove that the specified FP value's sign bit is 0.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
This struct is a compact representation of a valid (non-zero power of two) alignment.
@ IEEE
IEEE-754 denormal numbers preserved.
bool isNonNegative() const
Returns true if this value is known to be non-negative.
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
unsigned countMaxTrailingZeros() const
Returns the maximum number of trailing zero bits possible.
unsigned countMaxPopulation() const
Returns the maximum number of bits that could be one.
unsigned getBitWidth() const
Get the bit width of this value.
bool isNonZero() const
Returns true if this value is known to be non-zero.
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
bool isNegative() const
Returns true if this value is known to be negative.
unsigned countMaxLeadingZeros() const
Returns the maximum number of leading zero bits possible.
unsigned countMinPopulation() const
Returns the number of bits known to be one.
bool isAllOnes() const
Returns true if value is all one bits.
FPClassTest KnownFPClasses
Floating-point classes the value could be one of.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
A lightweight accessor for an operand bundle meant to be passed around by value.
StringRef getTagName() const
Return the tag of this operand bundle as a string.
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.
Represent one information held inside an operand bundle of an llvm.assume.
Attribute::AttrKind AttrKind
SelectPatternFlavor Flavor
SimplifyQuery getWithInstruction(const Instruction *I) const