46#include "llvm/IR/IntrinsicsAArch64.h"
47#include "llvm/IR/IntrinsicsAMDGPU.h"
48#include "llvm/IR/IntrinsicsARM.h"
49#include "llvm/IR/IntrinsicsHexagon.h"
78#define DEBUG_TYPE "instcombine"
82using namespace PatternMatch;
84STATISTIC(NumSimplified,
"Number of library calls simplified");
87 "instcombine-guard-widening-window",
89 cl::desc(
"How wide an instruction window to bypass looking for "
96 if (ITy->getBitWidth() < 32)
106 auto *Src =
MI->getRawSource();
107 while (isa<GetElementPtrInst>(Src) || isa<BitCastInst>(Src)) {
108 if (!Src->hasOneUse())
110 Src = cast<Instruction>(Src)->getOperand(0);
112 return isa<AllocaInst>(Src) && Src->hasOneUse();
118 if (!CopyDstAlign || *CopyDstAlign < DstAlign) {
119 MI->setDestAlignment(DstAlign);
125 if (!CopySrcAlign || *CopySrcAlign < SrcAlign) {
126 MI->setSourceAlignment(SrcAlign);
149 ConstantInt *MemOpLength = dyn_cast<ConstantInt>(
MI->getLength());
150 if (!MemOpLength)
return nullptr;
157 assert(
Size &&
"0-sized memory transferring should be removed already.");
166 if (isa<AtomicMemTransferInst>(
MI))
167 if (*CopyDstAlign <
Size || *CopySrcAlign <
Size)
177 Value *Src =
MI->getArgOperand(1);
178 Value *Dest =
MI->getArgOperand(0);
181 L->setAlignment(*CopySrcAlign);
182 L->setAAMetadata(AACopyMD);
183 MDNode *LoopMemParallelMD =
184 MI->getMetadata(LLVMContext::MD_mem_parallel_loop_access);
185 if (LoopMemParallelMD)
186 L->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
187 MDNode *AccessGroupMD =
MI->getMetadata(LLVMContext::MD_access_group);
189 L->setMetadata(LLVMContext::MD_access_group, AccessGroupMD);
195 if (LoopMemParallelMD)
196 S->
setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
198 S->
setMetadata(LLVMContext::MD_access_group, AccessGroupMD);
201 if (
auto *MT = dyn_cast<MemTransferInst>(
MI)) {
203 L->setVolatile(MT->isVolatile());
206 if (isa<AtomicMemTransferInst>(
MI)) {
218 const Align KnownAlignment =
221 if (!MemSetAlign || *MemSetAlign < KnownAlignment) {
222 MI->setDestAlignment(KnownAlignment);
238 if (isa<UndefValue>(
MI->getValue())) {
250 assert(Len &&
"0-sized memory setting should be removed already.");
251 const Align Alignment =
MI->getDestAlign().valueOrOne();
257 if (isa<AtomicMemSetInst>(
MI))
269 Constant *FillVal = ConstantInt::get(ITy, Fill);
272 auto replaceOpForAssignmentMarkers = [FillC, FillVal](
auto *DbgAssign) {
274 DbgAssign->replaceVariableLocationOp(FillC, FillVal);
280 if (isa<AtomicMemSetInst>(
MI))
295 const Align Alignment =
313 LI->copyMetadata(II);
329 if (ConstMask->isNullValue())
333 if (ConstMask->isAllOnesValue()) {
342 if (isa<ScalableVectorType>(ConstMask->getType()))
369 if (ConstMask->isAllOnesValue())
371 auto *VecTy = cast<VectorType>(II.
getType());
372 const Align Alignment =
375 Alignment,
"load.scalar");
395 if (ConstMask->isNullValue())
413 if (ConstMask->isAllOnesValue()) {
422 new StoreInst(Extract, SplatPtr,
false, Alignment);
427 if (isa<ScalableVectorType>(ConstMask->getType()))
455 auto *StrippedInvariantGroupsArg = StrippedArg;
456 while (
auto *
Intr = dyn_cast<IntrinsicInst>(StrippedInvariantGroupsArg)) {
457 if (
Intr->getIntrinsicID() != Intrinsic::launder_invariant_group &&
458 Intr->getIntrinsicID() != Intrinsic::strip_invariant_group)
460 StrippedInvariantGroupsArg =
Intr->getArgOperand(0)->stripPointerCasts();
462 if (StrippedArg == StrippedInvariantGroupsArg)
465 Value *Result =
nullptr;
473 "simplifyInvariantGroupIntrinsic only handles launder and strip");
474 if (Result->getType()->getPointerAddressSpace() !=
478 return cast<Instruction>(Result);
484 "Expected cttz or ctlz intrinsic");
555 return BinaryOperator::CreateAdd(ConstCttz,
X);
563 return BinaryOperator::CreateSub(ConstCttz,
X);
571 return BinaryOperator::CreateAdd(ConstCtlz,
X);
579 return BinaryOperator::CreateSub(ConstCtlz,
X);
595 if (PossibleZeros == DefiniteZeros) {
596 auto *
C = ConstantInt::get(Op0->
getType(), DefiniteZeros);
612 if (
IT &&
IT->getBitWidth() != 1 && !II.
getMetadata(LLVMContext::MD_range)) {
626 "Expected ctpop intrinsic");
676 if ((~Known.
Zero).isPowerOf2())
677 return BinaryOperator::CreateLShr(
678 Op0, ConstantInt::get(Ty, (~Known.
Zero).exactLogBase2()));
693 if (
IT->getBitWidth() != 1 && !II.
getMetadata(LLVMContext::MD_range)) {
716 auto *VecTy = cast<FixedVectorType>(II.
getType());
717 unsigned NumElts = VecTy->getNumElements();
720 if (!VecTy->getElementType()->isIntegerTy(8) || NumElts != 8)
725 for (
unsigned I = 0;
I < NumElts; ++
I) {
728 if (!COp || !isa<ConstantInt>(COp))
731 Indexes[
I] = cast<ConstantInt>(COp)->getLimitedValue();
734 if ((
unsigned)Indexes[
I] >= NumElts)
746 unsigned NumOperands) {
747 assert(
I.arg_size() >= NumOperands &&
"Not enough operands");
748 assert(
E.arg_size() >= NumOperands &&
"Not enough operands");
749 for (
unsigned i = 0; i < NumOperands; i++)
750 if (
I.getArgOperand(i) !=
E.getArgOperand(i))
771 for (; BI != BE; ++BI) {
772 if (
auto *
I = dyn_cast<IntrinsicInst>(&*BI)) {
773 if (
I->isDebugOrPseudoInst() ||
794 return I.getIntrinsicID() == Intrinsic::vastart ||
795 I.getIntrinsicID() == Intrinsic::vacopy;
801 assert(Call.arg_size() > 1 &&
"Need at least 2 args to swap");
802 Value *Arg0 = Call.getArgOperand(0), *Arg1 = Call.getArgOperand(1);
803 if (isa<Constant>(Arg0) && !isa<Constant>(Arg1)) {
804 Call.setArgOperand(0, Arg1);
805 Call.setArgOperand(1, Arg0);
822InstCombinerImpl::foldIntrinsicWithOverflowCommon(
IntrinsicInst *II) {
824 Value *OperationResult =
nullptr;
847 switch (
static_cast<unsigned>(Mask)) {
888 case ~fcZero & ~fcNan:
906 const ConstantInt *CMask = cast<ConstantInt>(Src1);
911 const FPClassTest OrderedInvertedMask = ~OrderedMask & ~fcNan;
913 const bool IsStrict =
930 if ((OrderedMask ==
fcInf || OrderedInvertedMask ==
fcInf) &&
931 (IsOrdered || IsUnordered) && !IsStrict) {
939 if (OrderedInvertedMask ==
fcInf)
949 (IsOrdered || IsUnordered) && !IsStrict) {
964 (IsOrdered || IsUnordered) && !IsStrict) {
977 if (Mask ==
fcNan && !IsStrict) {
1009 if (!IsStrict && (IsOrdered || IsUnordered) &&
1071 return std::nullopt;
1078 std::optional<bool> Known1 =
getKnownSign(Op1, CxtI,
DL, AC, DT);
1081 std::optional<bool> Known0 =
getKnownSign(Op0, CxtI,
DL, AC, DT);
1084 return *Known0 == *Known1;
1092 assert((MinMaxID == Intrinsic::smax || MinMaxID == Intrinsic::smin ||
1093 MinMaxID == Intrinsic::umax || MinMaxID == Intrinsic::umin) &&
1094 "Expected a min or max intrinsic");
1099 const APInt *C0, *C1;
1105 bool IsSigned = MinMaxID == Intrinsic::smax || MinMaxID == Intrinsic::smin;
1106 auto *
Add = cast<BinaryOperator>(Op0);
1107 if ((IsSigned && !
Add->hasNoSignedWrap()) ||
1108 (!IsSigned && !
Add->hasNoUnsignedWrap()))
1115 IsSigned ? C1->
ssub_ov(*C0, Overflow) : C1->
usub_ov(*C0, Overflow);
1116 assert(!Overflow &&
"Expected simplify of min/max");
1122 return IsSigned ? BinaryOperator::CreateNSWAdd(NewMinMax,
Add->getOperand(1))
1123 : BinaryOperator::CreateNUWAdd(NewMinMax,
Add->getOperand(1));
1134 const APInt *MinValue, *MaxValue;
1138 }
else if (
match(&MinMax1,
1147 if (!(*MaxValue + 1).isPowerOf2() || -*MinValue != *MaxValue + 1)
1150 unsigned NewBitWidth = (*MaxValue + 1).logBase2() + 1;
1164 if (
AddSub->getOpcode() == Instruction::Add)
1165 IntrinsicID = Intrinsic::sadd_sat;
1166 else if (
AddSub->getOpcode() == Instruction::Sub)
1167 IntrinsicID = Intrinsic::ssub_sat;
1194 const APInt *C0, *C1;
1200 case Intrinsic::smax:
1204 case Intrinsic::smin:
1208 case Intrinsic::umax:
1212 case Intrinsic::umin:
1248 if (InnerMinMaxID != MinMaxID &&
1249 !(((MinMaxID == Intrinsic::umax && InnerMinMaxID == Intrinsic::smax) ||
1250 (MinMaxID == Intrinsic::smin && InnerMinMaxID == Intrinsic::umin)) &&
1258 {LHS->getArgOperand(0), NewC});
1278 auto *InnerMM = dyn_cast<IntrinsicInst>(Inner);
1279 if (!InnerMM || InnerMM->getIntrinsicID() != MinMaxID ||
1297 if (!
LHS || !
RHS ||
LHS->getIntrinsicID() != MinMaxID ||
1298 RHS->getIntrinsicID() != MinMaxID ||
1308 Value *MinMaxOp =
nullptr;
1309 Value *ThirdOp =
nullptr;
1313 if (
D ==
A ||
C ==
A) {
1318 }
else if (
D ==
B ||
C ==
B) {
1327 if (
D ==
A ||
D ==
B) {
1332 }
else if (
C ==
A ||
C ==
B) {
1340 if (!MinMaxOp || !ThirdOp)
1357 case Intrinsic::smax:
1358 case Intrinsic::smin:
1359 case Intrinsic::umax:
1360 case Intrinsic::umin:
1361 case Intrinsic::fma:
1362 case Intrinsic::fshl:
1363 case Intrinsic::fshr:
1382 Type *SrcTy =
X->getType();
1383 for (
unsigned i = 1, e = II->
arg_size(); i != e; ++i) {
1386 X->getType() != SrcTy)
1392 Instruction *FPI = isa<FPMathOperator>(II) ? II :
nullptr;
1393 Value *NewIntrinsic =
1401template <Intrinsic::ID IntrID>
1404 static_assert(IntrID == Intrinsic::bswap || IntrID == Intrinsic::bitreverse,
1405 "This helper only supports BSWAP and BITREVERSE intrinsics");
1411 isa<BinaryOperator>(V)) {
1412 Value *OldReorderX, *OldReorderY;
1464 if (!II)
return visitCallBase(CI);
1468 if (
auto *AMI = dyn_cast<AtomicMemIntrinsic>(II))
1469 if (
ConstantInt *NumBytes = dyn_cast<ConstantInt>(AMI->getLength()))
1470 if (NumBytes->isNegative() ||
1471 (NumBytes->getZExtValue() % AMI->getElementSizeInBytes() != 0)) {
1473 assert(AMI->getType()->isVoidTy() &&
1474 "non void atomic unordered mem intrinsic");
1480 if (
auto *
MI = dyn_cast<AnyMemIntrinsic>(II)) {
1481 bool Changed =
false;
1484 if (
Constant *NumBytes = dyn_cast<Constant>(
MI->getLength())) {
1485 if (NumBytes->isNullValue())
1490 if (
auto *M = dyn_cast<MemIntrinsic>(
MI))
1491 if (M->isVolatile())
1497 if (
auto *MMI = dyn_cast<AnyMemMoveInst>(
MI)) {
1498 if (
GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource()))
1499 if (GVSrc->isConstant()) {
1502 isa<AtomicMemMoveInst>(MMI)
1503 ? Intrinsic::memcpy_element_unordered_atomic
1504 : Intrinsic::memcpy;
1515 if (MTI->getSource() == MTI->getDest())
1521 if (
auto *MTI = dyn_cast<AnyMemTransferInst>(
MI)) {
1524 }
else if (
auto *MSI = dyn_cast<AnyMemSetInst>(
MI)) {
1529 if (Changed)
return II;
1534 if (
auto *IIFVTy = dyn_cast<FixedVectorType>(II->
getType())) {
1535 auto VWidth = IIFVTy->getNumElements();
1536 APInt PoisonElts(VWidth, 0);
1560 if (CI.
use_empty() && isa<ConstrainedFPIntrinsic>(CI)) {
1567 case Intrinsic::objectsize: {
1570 &InsertedInstructions)) {
1571 for (
Instruction *Inserted : InsertedInstructions)
1577 case Intrinsic::abs: {
1579 bool IntMinIsPoison = cast<Constant>(II->
getArgOperand(1))->isOneValue();
1593 if (
match(IIOperand,
1595 m_Intrinsic<Intrinsic::abs>(
m_Value(
Y)))))) {
1597 cast<Instruction>(IIOperand)->hasNoSignedWrap() && IntMinIsPoison;
1602 if (std::optional<bool> Known =
1628 return BinaryOperator::CreateAnd(
X, ConstantInt::get(II->
getType(), 1));
1632 case Intrinsic::umin: {
1637 "Expected simplify of umin with max constant");
1644 case Intrinsic::umax: {
1648 (I0->
hasOneUse() || I1->hasOneUse()) &&
X->getType() ==
Y->getType()) {
1664 case Intrinsic::smax:
1665 case Intrinsic::smin: {
1669 (I0->
hasOneUse() || I1->hasOneUse()) &&
X->getType() ==
Y->getType()) {
1685 if ((IID == Intrinsic::umin || IID == Intrinsic::smax) &&
1687 return BinaryOperator::CreateAnd(I0, I1);
1692 if ((IID == Intrinsic::umax || IID == Intrinsic::smin) &&
1694 return BinaryOperator::CreateOr(I0, I1);
1697 if (IID == Intrinsic::smax || IID == Intrinsic::smin) {
1724 bool UseOr = IID == Intrinsic::smax || IID == Intrinsic::umax;
1725 bool UseAndN = IID == Intrinsic::smin || IID == Intrinsic::umin;
1727 if (IID == Intrinsic::smax || IID == Intrinsic::smin) {
1729 if (KnownSign == std::nullopt) {
1732 }
else if (*KnownSign ) {
1744 return BinaryOperator::CreateOr(I0,
X);
1785 if (I0->
hasOneUse() && !I1->hasOneUse())
1797 if (IID == Intrinsic::smin || IID == Intrinsic::umax)
1826 if (LHS_CR.
icmp(Pred, *RHSC))
1830 ConstantInt::get(II->
getType(), *RHSC));
1836 case Intrinsic::bitreverse: {
1841 X->getType()->isIntOrIntVectorTy(1)) {
1849 foldBitOrderCrossLogicOp<Intrinsic::bitreverse>(IIOperand,
Builder))
1850 return crossLogicOpFold;
1854 case Intrinsic::bswap: {
1871 cast<BinaryOperator>(IIOperand)->
getOpcode() == Instruction::Shl
1884 if (BW - LZ - TZ == 8) {
1885 assert(LZ != TZ &&
"active byte cannot be in the middle");
1887 return BinaryOperator::CreateNUWShl(
1888 IIOperand, ConstantInt::get(IIOperand->
getType(), LZ - TZ));
1890 return BinaryOperator::CreateExactLShr(
1891 IIOperand, ConstantInt::get(IIOperand->
getType(), TZ - LZ));
1896 unsigned C =
X->getType()->getScalarSizeInBits() - BW;
1897 Value *CV = ConstantInt::get(
X->getType(),
C);
1903 foldBitOrderCrossLogicOp<Intrinsic::bswap>(IIOperand,
Builder)) {
1904 return crossLogicOpFold;
1913 case Intrinsic::masked_load:
1914 if (
Value *SimplifiedMaskedOp = simplifyMaskedLoad(*II))
1917 case Intrinsic::masked_store:
1918 return simplifyMaskedStore(*II);
1919 case Intrinsic::masked_gather:
1920 return simplifyMaskedGather(*II);
1921 case Intrinsic::masked_scatter:
1922 return simplifyMaskedScatter(*II);
1923 case Intrinsic::launder_invariant_group:
1924 case Intrinsic::strip_invariant_group:
1928 case Intrinsic::powi:
1932 if (Power->isMinusOne())
1936 if (Power->equalsInt(2))
1940 if (!Power->getValue()[0]) {
1955 case Intrinsic::cttz:
1956 case Intrinsic::ctlz:
1961 case Intrinsic::ctpop:
1966 case Intrinsic::fshl:
1967 case Intrinsic::fshr: {
1979 if (ModuloC != ShAmtC)
1984 "Shift amount expected to be modulo bitwidth");
1989 if (IID == Intrinsic::fshr) {
1996 assert(IID == Intrinsic::fshl &&
1997 "All funnel shifts by simple constants should go left");
2002 return BinaryOperator::CreateShl(Op0, ShAmtC);
2007 return BinaryOperator::CreateLShr(Op1,
2037 case Intrinsic::ptrmask: {
2043 Value *InnerPtr, *InnerMask;
2044 bool Changed =
false;
2052 "Mask types must match");
2069 unsigned NewAlignmentLog =
2083 case Intrinsic::uadd_with_overflow:
2084 case Intrinsic::sadd_with_overflow: {
2085 if (
Instruction *
I = foldIntrinsicWithOverflowCommon(II))
2092 const APInt *C0, *C1;
2095 bool IsSigned = IID == Intrinsic::sadd_with_overflow;
2101 IsSigned ? C1->
sadd_ov(*C0, Overflow) : C1->
uadd_ov(*C0, Overflow);
2105 IID,
X, ConstantInt::get(Arg1->
getType(), NewC)));
2110 case Intrinsic::umul_with_overflow:
2111 case Intrinsic::smul_with_overflow:
2112 case Intrinsic::usub_with_overflow:
2113 if (
Instruction *
I = foldIntrinsicWithOverflowCommon(II))
2117 case Intrinsic::ssub_with_overflow: {
2118 if (
Instruction *
I = foldIntrinsicWithOverflowCommon(II))
2140 case Intrinsic::uadd_sat:
2141 case Intrinsic::sadd_sat:
2142 case Intrinsic::usub_sat:
2143 case Intrinsic::ssub_sat: {
2145 Type *Ty = SI->getType();
2146 Value *Arg0 = SI->getLHS();
2147 Value *Arg1 = SI->getRHS();
2178 if (IID == Intrinsic::usub_sat &&
2189 C->isNotMinSignedValue()) {
2193 Intrinsic::sadd_sat, Arg0, NegVal));
2199 if (
auto *
Other = dyn_cast<IntrinsicInst>(Arg0)) {
2201 const APInt *Val, *Val2;
2204 IID == Intrinsic::uadd_sat || IID == Intrinsic::usub_sat;
2205 if (
Other->getIntrinsicID() == IID &&
2213 NewVal = Val->
sadd_ov(*Val2, Overflow);
2226 IID,
X, ConstantInt::get(II->
getType(), NewVal)));
2232 case Intrinsic::minnum:
2233 case Intrinsic::maxnum:
2234 case Intrinsic::minimum:
2235 case Intrinsic::maximum: {
2246 case Intrinsic::maxnum:
2247 NewIID = Intrinsic::minnum;
2249 case Intrinsic::minnum:
2250 NewIID = Intrinsic::maxnum;
2252 case Intrinsic::maximum:
2253 NewIID = Intrinsic::minimum;
2255 case Intrinsic::minimum:
2256 NewIID = Intrinsic::maximum;
2262 Instruction *FNeg = UnaryOperator::CreateFNeg(NewCall);
2269 if (
auto *M = dyn_cast<IntrinsicInst>(Arg0)) {
2277 case Intrinsic::maxnum:
2280 case Intrinsic::minnum:
2283 case Intrinsic::maximum:
2286 case Intrinsic::minimum:
2293 IID,
X, ConstantFP::get(Arg0->
getType(), Res), II);
2297 if (
auto *CI = dyn_cast<CallInst>(V))
2306 X->getType() ==
Y->getType()) {
2318 auto IsMinMaxOrXNegX = [IID, &
X](
Value *Op0,
Value *Op1) {
2320 return Op0->hasOneUse() ||
2321 (IID != Intrinsic::minimum && IID != Intrinsic::minnum);
2325 if (IsMinMaxOrXNegX(Arg0, Arg1) || IsMinMaxOrXNegX(Arg1, Arg0)) {
2327 if (IID == Intrinsic::minimum || IID == Intrinsic::minnum)
2334 case Intrinsic::matrix_multiply: {
2348 Value *OpNotNeg, *NegatedOp;
2349 unsigned NegatedOpArg, OtherOpArg;
2384 NewArgs[NegatedOpArg] = OpNotNeg;
2391 case Intrinsic::fmuladd: {
2408 FAdd->copyFastMathFlags(II);
2414 case Intrinsic::fma: {
2439 FAdd->copyFastMathFlags(II);
2453 case Intrinsic::copysign: {
2457 if (*KnownSignBit) {
2484 case Intrinsic::fabs: {
2489 if (isa<Constant>(TVal) && isa<Constant>(FVal)) {
2502 Value *Magnitude, *Sign;
2514 case Intrinsic::ceil:
2515 case Intrinsic::floor:
2516 case Intrinsic::round:
2517 case Intrinsic::roundeven:
2518 case Intrinsic::nearbyint:
2519 case Intrinsic::rint:
2520 case Intrinsic::trunc: {
2529 case Intrinsic::cos:
2530 case Intrinsic::amdgcn_cos: {
2542 case Intrinsic::sin: {
2547 Instruction *FNeg = UnaryOperator::CreateFNeg(NewSin);
2553 case Intrinsic::ldexp: {
2572 Exp->getType() == InnerExp->
getType()) {
2574 FastMathFlags InnerFlags = cast<FPMathOperator>(Src)->getFastMathFlags();
2589 case Intrinsic::ptrauth_auth:
2590 case Intrinsic::ptrauth_resign: {
2593 bool NeedSign = II->
getIntrinsicID() == Intrinsic::ptrauth_resign;
2599 Value *AuthKey =
nullptr, *AuthDisc =
nullptr, *BasePtr;
2616 if (AuthKey && NeedSign) {
2618 NewIntrin = Intrinsic::ptrauth_resign;
2619 }
else if (AuthKey) {
2621 NewIntrin = Intrinsic::ptrauth_auth;
2622 }
else if (NeedSign) {
2624 NewIntrin = Intrinsic::ptrauth_sign;
2647 case Intrinsic::arm_neon_vtbl1:
2648 case Intrinsic::aarch64_neon_tbl1:
2653 case Intrinsic::arm_neon_vmulls:
2654 case Intrinsic::arm_neon_vmullu:
2655 case Intrinsic::aarch64_neon_smull:
2656 case Intrinsic::aarch64_neon_umull: {
2661 if (isa<ConstantAggregateZero>(Arg0) || isa<ConstantAggregateZero>(Arg1)) {
2666 bool Zext = (IID == Intrinsic::arm_neon_vmullu ||
2667 IID == Intrinsic::aarch64_neon_umull);
2669 if (
Constant *CV0 = dyn_cast<Constant>(Arg0)) {
2670 if (
Constant *CV1 = dyn_cast<Constant>(Arg1)) {
2681 if (
Constant *CV1 = dyn_cast<Constant>(Arg1))
2683 dyn_cast_or_null<ConstantInt>(CV1->getSplatValue()))
2690 case Intrinsic::arm_neon_aesd:
2691 case Intrinsic::arm_neon_aese:
2692 case Intrinsic::aarch64_crypto_aesd:
2693 case Intrinsic::aarch64_crypto_aese: {
2707 case Intrinsic::hexagon_V6_vandvrt:
2708 case Intrinsic::hexagon_V6_vandvrt_128B: {
2710 if (
auto Op0 = dyn_cast<IntrinsicInst>(II->
getArgOperand(0))) {
2712 if (ID0 != Intrinsic::hexagon_V6_vandqrt &&
2713 ID0 != Intrinsic::hexagon_V6_vandqrt_128B)
2720 if ((
C & 0xFF) && (
C & 0xFF00) && (
C & 0xFF0000) && (
C & 0xFF000000))
2725 case Intrinsic::stackrestore: {
2726 enum class ClassifyResult {
2730 CallWithSideEffects,
2733 if (isa<AllocaInst>(
I))
2734 return ClassifyResult::Alloca;
2736 if (
auto *CI = dyn_cast<CallInst>(
I)) {
2737 if (
auto *II = dyn_cast<IntrinsicInst>(CI)) {
2739 return ClassifyResult::StackRestore;
2742 return ClassifyResult::CallWithSideEffects;
2745 return ClassifyResult::CallWithSideEffects;
2749 return ClassifyResult::None;
2756 if (SS->getIntrinsicID() == Intrinsic::stacksave &&
2759 bool CannotRemove =
false;
2760 for (++BI; &*BI != II; ++BI) {
2761 switch (Classify(&*BI)) {
2762 case ClassifyResult::None:
2766 case ClassifyResult::StackRestore:
2769 if (cast<IntrinsicInst>(*BI).getArgOperand(0) != SS)
2770 CannotRemove =
true;
2773 case ClassifyResult::Alloca:
2774 case ClassifyResult::CallWithSideEffects:
2777 CannotRemove =
true;
2793 bool CannotRemove =
false;
2794 for (++BI; &*BI != TI; ++BI) {
2795 switch (Classify(&*BI)) {
2796 case ClassifyResult::None:
2800 case ClassifyResult::StackRestore:
2804 case ClassifyResult::Alloca:
2805 case ClassifyResult::CallWithSideEffects:
2809 CannotRemove =
true;
2819 if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))
2823 case Intrinsic::lifetime_end:
2832 return I.getIntrinsicID() == Intrinsic::lifetime_start;
2836 case Intrinsic::assume: {
2845 assert(isa<AssumeInst>(Assume));
2855 if (
match(Next, m_Intrinsic<Intrinsic::assume>(
m_Specific(IIOperand))))
2856 return RemoveConditionFromAssume(Next);
2890 return RemoveConditionFromAssume(II);
2902 if (OBU.
getTagName() ==
"separate_storage") {
2904 auto MaybeSimplifyHint = [&](
const Use &U) {
2905 Value *Hint = U.get();
2912 MaybeSimplifyHint(OBU.
Inputs[0]);
2913 MaybeSimplifyHint(OBU.
Inputs[1]);
2928 Replacement->insertBefore(Next);
2930 return RemoveConditionFromAssume(II);
2957 if (
auto *Replacement =
2960 Replacement->insertAfter(II);
2963 return RemoveConditionFromAssume(II);
2974 if (BOI.End - BOI.Begin > 2)
2985 if (BOI.End - BOI.Begin > 0) {
2992 if (BOI.End - BOI.Begin > 0)
2994 if (BOI.End - BOI.Begin > 1)
2995 II->
op_begin()[BOI.Begin + 1].
set(ConstantInt::get(
3021 case Intrinsic::experimental_guard: {
3032 Value *NextCond =
nullptr;
3034 m_Intrinsic<Intrinsic::experimental_guard>(
m_Value(NextCond)))) {
3039 if (CurrCond != NextCond) {
3041 while (MoveI != NextInst) {
3053 case Intrinsic::vector_insert: {
3057 auto *DstTy = dyn_cast<FixedVectorType>(II->
getType());
3058 auto *VecTy = dyn_cast<FixedVectorType>(Vec->
getType());
3059 auto *SubVecTy = dyn_cast<FixedVectorType>(SubVec->
getType());
3063 if (DstTy && VecTy && SubVecTy) {
3064 unsigned DstNumElts = DstTy->getNumElements();
3065 unsigned VecNumElts = VecTy->getNumElements();
3066 unsigned SubVecNumElts = SubVecTy->getNumElements();
3067 unsigned IdxN = cast<ConstantInt>(
Idx)->getZExtValue();
3070 if (VecNumElts == SubVecNumElts)
3079 for (i = 0; i != SubVecNumElts; ++i)
3081 for (; i != VecNumElts; ++i)
3087 for (
unsigned i = 0; i != IdxN; ++i)
3089 for (
unsigned i = DstNumElts; i != DstNumElts + SubVecNumElts; ++i)
3091 for (
unsigned i = IdxN + SubVecNumElts; i != DstNumElts; ++i)
3099 case Intrinsic::vector_extract: {
3106 unsigned ExtractIdx = cast<ConstantInt>(
Idx)->getZExtValue();
3107 Value *InsertTuple, *InsertIdx, *InsertValue;
3108 if (
match(Vec, m_Intrinsic<Intrinsic::vector_insert>(
m_Value(InsertTuple),
3111 InsertValue->
getType() == ReturnType) {
3112 unsigned Index = cast<ConstantInt>(InsertIdx)->getZExtValue();
3116 if (ExtractIdx ==
Index)
3127 auto *DstTy = dyn_cast<VectorType>(ReturnType);
3128 auto *VecTy = dyn_cast<VectorType>(Vec->
getType());
3130 if (DstTy && VecTy) {
3131 auto DstEltCnt = DstTy->getElementCount();
3132 auto VecEltCnt = VecTy->getElementCount();
3133 unsigned IdxN = cast<ConstantInt>(
Idx)->getZExtValue();
3136 if (DstEltCnt == VecTy->getElementCount()) {
3143 if (VecEltCnt.isScalable() || DstEltCnt.isScalable())
3147 for (
unsigned i = 0; i != DstEltCnt.getKnownMinValue(); ++i)
3148 Mask.push_back(IdxN + i);
3155 case Intrinsic::experimental_vector_reverse: {
3159 auto *OldBinOp = cast<BinaryOperator>(Vec);
3164 OldBinOp->getOpcode(),
X,
Y,
3165 OldBinOp, OldBinOp->getName(),
3170 OldBinOp->getOpcode(),
X, BO1,
3171 OldBinOp, OldBinOp->
getName(),
3178 OldBinOp->getOpcode(), BO0,
Y, OldBinOp,
3183 auto *OldUnOp = cast<UnaryOperator>(Vec);
3185 OldUnOp->getOpcode(),
X, OldUnOp, OldUnOp->getName(),
3191 case Intrinsic::vector_reduce_or:
3192 case Intrinsic::vector_reduce_and: {
3203 if (
auto *FTy = dyn_cast<FixedVectorType>(Vect->
getType()))
3207 if (IID == Intrinsic::vector_reduce_and) {
3211 assert(IID == Intrinsic::vector_reduce_or &&
3212 "Expected or reduction.");
3223 case Intrinsic::vector_reduce_add: {
3224 if (IID == Intrinsic::vector_reduce_add) {
3234 if (
auto *FTy = dyn_cast<FixedVectorType>(Vect->
getType()))
3242 cast<Instruction>(Arg)->
getOpcode() == Instruction::SExt)
3250 case Intrinsic::vector_reduce_xor: {
3251 if (IID == Intrinsic::vector_reduce_xor) {
3262 if (
auto *FTy = dyn_cast<FixedVectorType>(Vect->
getType()))
3274 case Intrinsic::vector_reduce_mul: {
3275 if (IID == Intrinsic::vector_reduce_mul) {
3285 if (
auto *FTy = dyn_cast<FixedVectorType>(Vect->
getType()))
3296 case Intrinsic::vector_reduce_umin:
3297 case Intrinsic::vector_reduce_umax: {
3298 if (IID == Intrinsic::vector_reduce_umin ||
3299 IID == Intrinsic::vector_reduce_umax) {
3309 if (
auto *FTy = dyn_cast<FixedVectorType>(Vect->
getType()))
3311 Value *Res = IID == Intrinsic::vector_reduce_umin
3323 case Intrinsic::vector_reduce_smin:
3324 case Intrinsic::vector_reduce_smax: {
3325 if (IID == Intrinsic::vector_reduce_smin ||
3326 IID == Intrinsic::vector_reduce_smax) {
3344 if (
auto *FTy = dyn_cast<FixedVectorType>(Vect->
getType()))
3348 ExtOpc = cast<CastInst>(Arg)->getOpcode();
3349 Value *Res = ((IID == Intrinsic::vector_reduce_smin) ==
3350 (ExtOpc == Instruction::CastOps::ZExt))
3361 case Intrinsic::vector_reduce_fmax:
3362 case Intrinsic::vector_reduce_fmin:
3363 case Intrinsic::vector_reduce_fadd:
3364 case Intrinsic::vector_reduce_fmul: {
3365 bool CanBeReassociated = (IID != Intrinsic::vector_reduce_fadd &&
3366 IID != Intrinsic::vector_reduce_fmul) ||
3368 const unsigned ArgIdx = (IID == Intrinsic::vector_reduce_fadd ||
3369 IID == Intrinsic::vector_reduce_fmul)
3375 if (!isa<FixedVectorType>(Arg->
getType()) || !CanBeReassociated ||
3377 !cast<ShuffleVectorInst>(Arg)->isSingleSource())
3379 int Sz = Mask.size();
3381 for (
int Idx : Mask) {
3388 if (UsedIndices.
all()) {
3394 case Intrinsic::is_fpclass: {
3413 case Intrinsic::ctlz:
3414 case Intrinsic::cttz:
3415 case Intrinsic::ctpop:
3416 case Intrinsic::umin:
3417 case Intrinsic::umax:
3418 case Intrinsic::smin:
3419 case Intrinsic::smax:
3420 case Intrinsic::usub_sat:
3421 case Intrinsic::uadd_sat:
3422 case Intrinsic::ssub_sat:
3423 case Intrinsic::sadd_sat:
3425 if (
auto *Sel = dyn_cast<SelectInst>(
Op))
3438 return visitCallBase(*II);
3453 if (FI1SyncScope != FI2->getSyncScopeID() ||
3460 if (NFI && isIdenticalOrStrongerFence(NFI, &FI))
3464 if (isIdenticalOrStrongerFence(PFI, &FI))
3471 return visitCallBase(II);
3476 return visitCallBase(CBI);
3496 if (
Value *With = Simplifier.optimizeCall(CI,
Builder)) {
3508 if (Underlying != TrampMem &&
3509 (!Underlying->hasOneUse() || Underlying->user_back() != TrampMem))
3511 if (!isa<AllocaInst>(Underlying))
3523 InitTrampoline = II;
3533 if (!InitTrampoline)
3537 if (InitTrampoline->
getOperand(0) != TrampMem)
3540 return InitTrampoline;
3565 Callee = Callee->stripPointerCasts();
3566 IntrinsicInst *AdjustTramp = dyn_cast<IntrinsicInst>(Callee);
3580bool InstCombinerImpl::annotateAnyAllocSite(
CallBase &Call,
3586 bool Changed =
false;
3588 if (!
Call.getType()->isPointerTy())
3595 if (
Call.hasRetAttr(Attribute::NonNull)) {
3596 Changed = !
Call.hasRetAttr(Attribute::Dereferenceable);
3598 Call.getContext(),
Size->getLimitedValue()));
3600 Changed = !
Call.hasRetAttr(Attribute::DereferenceableOrNull);
3602 Call.getContext(),
Size->getLimitedValue()));
3611 ConstantInt *AlignOpC = dyn_cast<ConstantInt>(Alignment);
3615 Align ExistingAlign =
Call.getRetAlign().valueOrOne();
3617 if (NewAlign > ExistingAlign) {
3629 bool Changed = annotateAnyAllocSite(Call, &
TLI);
3638 if (
V->getType()->isPointerTy() &&
3639 !
Call.paramHasAttr(ArgNo, Attribute::NonNull) &&
3645 assert(ArgNo ==
Call.arg_size() &&
"Call arguments not processed correctly.");
3647 if (!ArgNos.
empty()) {
3652 Call.setAttributes(AS);
3659 Function *CalleeF = dyn_cast<Function>(Callee);
3661 transformConstExprCastCall(Call))
3668 LLVM_DEBUG(
dbgs() <<
"Removing convergent attr from instr " << Call
3670 Call.setNotConvergent();
3692 if (isa<CallInst>(OldCall))
3697 cast<CallBase>(OldCall)->setCalledFunction(
3706 if ((isa<ConstantPointerNull>(Callee) &&
3708 isa<UndefValue>(Callee)) {
3711 if (!
Call.getType()->isVoidTy())
3714 if (
Call.isTerminator()) {
3725 return transformCallThroughTrampoline(Call, *II);
3727 if (isa<InlineAsm>(Callee) && !
Call.doesNotThrow()) {
3729 if (!
IA->canThrow()) {
3732 Call.setDoesNotThrow();
3740 if (
CallInst *CI = dyn_cast<CallInst>(&Call)) {
3747 if (!
Call.use_empty() && !
Call.isMustTailCall())
3748 if (
Value *ReturnedArg =
Call.getReturnedArgOperand()) {
3750 Type *RetArgTy = ReturnedArg->getType();
3759 if (Bundle && !
Call.isIndirectCall()) {
3763 ConstantInt *ExpectedType = cast<ConstantInt>(Bundle->Inputs[0]);
3766 FunctionType = mdconst::extract<ConstantInt>(MD->getOperand(0));
3770 dbgs() <<
Call.getModule()->getName()
3771 <<
": warning: kcfi: " <<
Call.getCaller()->getName()
3772 <<
": call to " << CalleeF->
getName()
3773 <<
" using a mismatching function pointer type\n";
3784 switch (
Call.getIntrinsicID()) {
3785 case Intrinsic::experimental_gc_statepoint: {
3801 if (isa<UndefValue>(DerivedPtr) || isa<UndefValue>(BasePtr)) {
3807 if (
auto *PT = dyn_cast<PointerType>(GCR.
getType())) {
3811 if (isa<ConstantPointerNull>(DerivedPtr)) {
3839 LiveGcValues.
insert(BasePtr);
3840 LiveGcValues.
insert(DerivedPtr);
3842 std::optional<OperandBundleUse> Bundle =
3844 unsigned NumOfGCLives = LiveGcValues.
size();
3845 if (!Bundle || NumOfGCLives == Bundle->Inputs.size())
3849 std::vector<Value *> NewLiveGc;
3850 for (
Value *V : Bundle->Inputs) {
3851 if (Val2Idx.
count(V))
3853 if (LiveGcValues.
count(V)) {
3854 Val2Idx[
V] = NewLiveGc.
size();
3855 NewLiveGc.push_back(V);
3857 Val2Idx[
V] = NumOfGCLives;
3863 assert(Val2Idx.
count(BasePtr) && Val2Idx[BasePtr] != NumOfGCLives &&
3864 "Missed live gc for base pointer");
3866 GCR.
setOperand(1, ConstantInt::get(OpIntTy1, Val2Idx[BasePtr]));
3868 assert(Val2Idx.
count(DerivedPtr) && Val2Idx[DerivedPtr] != NumOfGCLives &&
3869 "Missed live gc for derived pointer");
3871 GCR.
setOperand(2, ConstantInt::get(OpIntTy2, Val2Idx[DerivedPtr]));
3880 return Changed ? &
Call :
nullptr;
3886bool InstCombinerImpl::transformConstExprCastCall(
CallBase &Call) {
3888 dyn_cast<Function>(
Call.getCalledOperand()->stripPointerCasts());
3892 assert(!isa<CallBrInst>(Call) &&
3893 "CallBr's don't have a single point after a def to insert at");
3898 if (
Callee->hasFnAttribute(
"thunk"))
3904 if (
Callee->hasFnAttribute(Attribute::Naked))
3911 if (
Call.isMustTailCall())
3922 Type *NewRetTy = FT->getReturnType();
3925 if (OldRetTy != NewRetTy) {
3931 if (
Callee->isDeclaration())
3934 if (!
Caller->use_empty() &&
3950 if (!
Caller->use_empty()) {
3952 if (
auto *II = dyn_cast<InvokeInst>(Caller))
3953 PhisNotSupportedBlock = II->getNormalDest();
3954 if (PhisNotSupportedBlock)
3956 if (
PHINode *PN = dyn_cast<PHINode>(U))
3957 if (PN->getParent() == PhisNotSupportedBlock)
3962 unsigned NumActualArgs =
Call.arg_size();
3963 unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs);
3973 if (
Callee->getAttributes().hasAttrSomewhere(Attribute::InAlloca) ||
3974 Callee->getAttributes().hasAttrSomewhere(Attribute::Preallocated))
3977 auto AI =
Call.arg_begin();
3978 for (
unsigned i = 0, e = NumCommonArgs; i !=
e; ++i, ++AI) {
3979 Type *ParamTy = FT->getParamType(i);
3980 Type *ActTy = (*AI)->getType();
3991 if (
Call.isInAllocaArgument(i) ||
3999 Callee->getAttributes().hasParamAttr(i, Attribute::ByVal))
4003 if (
Callee->isDeclaration()) {
4005 if (FT->getNumParams() < NumActualArgs && !FT->isVarArg())
4011 if (FT->isVarArg() !=
Call.getFunctionType()->isVarArg())
4017 if (FT->isVarArg() &&
Call.getFunctionType()->isVarArg() &&
4018 FT->getNumParams() !=
Call.getFunctionType()->getNumParams())
4022 if (FT->getNumParams() < NumActualArgs && FT->isVarArg() &&
4037 Args.reserve(NumActualArgs);
4038 ArgAttrs.
reserve(NumActualArgs);
4048 AI =
Call.arg_begin();
4049 for (
unsigned i = 0; i != NumCommonArgs; ++i, ++AI) {
4050 Type *ParamTy = FT->getParamType(i);
4052 Value *NewArg = *AI;
4053 if ((*AI)->getType() != ParamTy)
4055 Args.push_back(NewArg);
4067 for (
unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i) {
4073 if (FT->getNumParams() < NumActualArgs) {
4075 if (FT->isVarArg()) {
4077 for (
unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) {
4079 Value *NewArg = *AI;
4080 if (PTy != (*AI)->getType()) {
4086 Args.push_back(NewArg);
4099 assert((ArgAttrs.
size() == FT->getNumParams() || FT->isVarArg()) &&
4100 "missing argument attributes");
4105 Call.getOperandBundlesAsDefs(OpBundles);
4108 if (
InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
4110 II->getUnwindDest(), Args, OpBundles);
4114 cast<CallInst>(Caller)->getTailCallKind());
4121 NewCall->
copyMetadata(*Caller, {LLVMContext::MD_prof});
4126 if (OldRetTy !=
NV->getType() && !
Caller->use_empty()) {
4127 if (!
NV->getType()->isVoidTy()) {
4129 NC->setDebugLoc(
Caller->getDebugLoc());
4132 assert(OptInsertPt &&
"No place to insert cast");
4140 if (!
Caller->use_empty())
4142 else if (
Caller->hasValueHandle()) {
4143 if (OldRetTy ==
NV->getType())
4158InstCombinerImpl::transformCallThroughTrampoline(
CallBase &Call,
4165 if (
Attrs.hasAttrSomewhere(Attribute::Nest))
4173 unsigned NestArgNo = 0;
4174 Type *NestTy =
nullptr;
4179 E = NestFTy->param_end();
4180 I !=
E; ++NestArgNo, ++
I) {
4191 std::vector<Value*> NewArgs;
4192 std::vector<AttributeSet> NewArgAttrs;
4193 NewArgs.reserve(
Call.arg_size() + 1);
4194 NewArgAttrs.reserve(
Call.arg_size());
4201 auto I =
Call.arg_begin(),
E =
Call.arg_end();
4203 if (ArgNo == NestArgNo) {
4206 if (NestVal->
getType() != NestTy)
4208 NewArgs.push_back(NestVal);
4209 NewArgAttrs.push_back(NestAttr);
4216 NewArgs.push_back(*
I);
4217 NewArgAttrs.push_back(
Attrs.getParamAttrs(ArgNo));
4228 std::vector<Type*> NewTypes;
4229 NewTypes.reserve(FTy->getNumParams()+1);
4236 E = FTy->param_end();
4239 if (ArgNo == NestArgNo)
4241 NewTypes.push_back(NestTy);
4247 NewTypes.push_back(*
I);
4260 Attrs.getRetAttrs(), NewArgAttrs);
4263 Call.getOperandBundlesAsDefs(OpBundles);
4266 if (
InvokeInst *II = dyn_cast<InvokeInst>(&Call)) {
4268 II->getUnwindDest(), NewArgs, OpBundles);
4269 cast<InvokeInst>(NewCaller)->setCallingConv(II->
getCallingConv());
4270 cast<InvokeInst>(NewCaller)->setAttributes(NewPAL);
4271 }
else if (
CallBrInst *CBI = dyn_cast<CallBrInst>(&Call)) {
4274 CBI->getIndirectDests(), NewArgs, OpBundles);
4275 cast<CallBrInst>(NewCaller)->setCallingConv(CBI->getCallingConv());
4276 cast<CallBrInst>(NewCaller)->setAttributes(NewPAL);
4279 cast<CallInst>(NewCaller)->setTailCallKind(
4280 cast<CallInst>(Call).getTailCallKind());
4281 cast<CallInst>(NewCaller)->setCallingConv(
4282 cast<CallInst>(Call).getCallingConv());
4283 cast<CallInst>(NewCaller)->setAttributes(NewPAL);
4294 Call.setCalledFunction(FTy, NestF);
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
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...
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...
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static SDValue foldBitOrderCrossLogicOp(SDNode *N, SelectionDAG &DAG)
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
#define DEBUG_WITH_TYPE(TYPE, X)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
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 signBitMustBeTheSame(Value *Op0, Value *Op1, Instruction *CxtI, const DataLayout &DL, AssumptionCache *AC, DominatorTree *DT)
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 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 * foldShuffledIntrinsicOperands(IntrinsicInst *II, InstCombiner::BuilderTy &Builder)
If all arguments of the intrinsic are unary shuffles with the same mask, try to shuffle after the int...
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 IntrinsicInst * findInitTrampolineFromBB(IntrinsicInst *AdjustTramp, Value *TrampMem)
static std::optional< bool > getKnownSignOrZero(Value *Op, Instruction *CxtI, const DataLayout &DL, AssumptionCache *AC, DominatorTree *DT)
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 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 std::optional< bool > getKnownSign(Value *Op, Instruction *CxtI, const DataLayout &DL, AssumptionCache *AC, DominatorTree *DT)
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 GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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)
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
static bool inputDenormalIsIEEE(const Function &F, const Type *Ty)
Return true if it's possible to assume IEEE treatment of input denormals in F for Val.
ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, bool IgnoreLocals=false)
Returns a bitmask that should be unconditionally applied to the ModRef info of a memory location.
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.
APInt usub_ov(const APInt &RHS, bool &Overflow) const
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
APInt sadd_ov(const APInt &RHS, bool &Overflow) const
APInt uadd_ov(const APInt &RHS, bool &Overflow) const
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
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.
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),...
A cache of @llvm.assume calls within a function.
void registerAssumption(AssumeInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
void updateAffectedValues(AssumeInst *CI)
Update the cache of values being affected by this assumption (i.e.
bool overlaps(const AttributeMask &AM) const
Return true if the builder has any attribute that's in the specified builder.
AttributeSet getFnAttrs() const
The function attributes are returned.
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute > > Attrs)
Create an AttributeList with the specified parameters in it.
bool isEmpty() const
Return true if there are no attributes.
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the function.
bool hasAttrSomewhere(Attribute::AttrKind Kind, unsigned *Index=nullptr) const
Return true if the specified attribute is set for at least one parameter or for the return value.
bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Return true if the attribute exists for the given argument.
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists in this set.
AttributeSet removeAttributes(LLVMContext &C, const AttributeMask &AttrsToRemove) const
Remove the specified attributes from this set.
static AttributeSet get(LLVMContext &C, const AttrBuilder &B)
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
static Attribute getWithDereferenceableBytes(LLVMContext &Context, uint64_t Bytes)
static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context, uint64_t Bytes)
static Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
InstListType::reverse_iterator reverse_iterator
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
static BinaryOperator * CreateFDivFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name, BasicBlock::iterator InsertBefore)
Construct a binary instruction, given the opcode and the two operands.
static BinaryOperator * CreateNSWNeg(Value *Op, const Twine &Name, BasicBlock::iterator InsertBefore)
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
static BinaryOperator * CreateNeg(Value *Op, const Twine &Name, BasicBlock::iterator InsertBefore)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
static BinaryOperator * CreateFMulFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
static BinaryOperator * CreateNot(Value *Op, const Twine &Name, BasicBlock::iterator InsertBefore)
static BinaryOperator * CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, Value *CopyO, const Twine &Name, BasicBlock::iterator InsertBefore)
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
void setCallingConv(CallingConv::ID CC)
bundle_op_iterator bundle_op_info_begin()
Return the start of the list of BundleOpInfo instances associated with this OperandBundleUser.
MaybeAlign getRetAlign() const
Extract the alignment of the return value.
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 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.
CallingConv::ID getCallingConv() const
static CallBase * Create(CallBase *CB, ArrayRef< OperandBundleDef > Bundles, BasicBlock::iterator InsertPt)
Create a clone of CB with a different set of operand bundles and insert it before InsertPt.
static CallBase * removeOperandBundle(CallBase *CB, uint32_t ID, Instruction *InsertPt=nullptr)
Create a clone of CB with operand bundle ID removed.
Value * getCalledOperand() const
void setAttributes(AttributeList A)
Set the parameter 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
void setArgOperand(unsigned i, Value *v)
FunctionType * getFunctionType() const
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
unsigned arg_size() const
bool hasOperandBundles() const
Return true if this User has any operand bundles.
void setCalledFunction(Function *Fn)
Sets the function called, including updating the function type.
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, BasicBlock::iterator InsertBefore)
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, BasicBlock::iterator InsertBefore)
void setTailCallKind(TailCallKind TCK)
bool isMustTailCall() const
static 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 CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name, BasicBlock::iterator InsertBefore)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
static 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 CastInst * CreateBitOrPointerCast(Value *S, Type *Ty, const Twine &Name, BasicBlock::iterator InsertBefore)
Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
static CastInst * CreateIntegerCast(Value *S, Type *Ty, bool isSigned, const Twine &Name, BasicBlock::iterator InsertBefore)
Create a ZExt, BitCast, or Trunc for int -> int casts.
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
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 ConstantAggregateZero * get(Type *Ty)
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
static Constant * getInfinity(Type *Ty, bool Negative=false)
static 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 ConstantInt * getTrue(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 ConstantInt * getBool(LLVMContext &Context, bool V)
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
This class represents a range of values.
bool isFullSet() const
Return true if this set contains all of the elements possible for this data-type.
bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const
Does the predicate Pred hold between ranges this and Other? NOTE: false does not mean that inverse pr...
static Constant * get(StructType *T, ArrayRef< Constant * > V)
This is an important base class in LLVM.
static Constant * getIntegerValue(Type *Ty, const APInt &V)
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...
static Constant * getAllOnesValue(Type *Ty)
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
This class represents an extension of floating point types.
Convenience struct for specifying and reasoning about fast-math flags.
bool noSignedZeros() const
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 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.".
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Represents calls to the gc.relocate intrinsic.
Value * getBasePtr() const
unsigned getBasePtrIndex() const
The index into the associate statepoint's argument list which contains the base pointer of the pointe...
Value * getDerivedPtr() const
unsigned getDerivedPtrIndex() const
The index into the associate statepoint's argument list which contains the pointer whose relocation t...
Represents a gc.statepoint intrinsic call.
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.
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.
Value * CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
CallInst * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateLaunderInvariantGroup(Value *Ptr)
Create a launder.invariant.group intrinsic call.
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
Value * CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
IntegerType * getInt1Ty()
Fetch the type representing a single bit.
Value * CreateExtractElement(Value *Vec, Value *Idx, const Twine &Name="")
IntegerType * getIntNTy(unsigned N)
Fetch the type representing an N-bit integer.
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const char *Name)
Value * CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Value * CreateFAdd(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
CallInst * CreateAndReduce(Value *Src)
Create a vector int AND reduction intrinsic of the source vector.
Value * CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name="")
Return a vector value that contains.
ConstantInt * getTrue()
Get the constant value for i1 true.
CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
Value * CreateFNegFMF(Value *V, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
InvokeInst * CreateInvoke(FunctionType *Ty, Value *Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="")
Create an invoke instruction.
Value * CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
CallInst * CreateAddReduce(Value *Src)
Create a vector int add reduction intrinsic of the source vector.
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
void setFastMathFlags(FastMathFlags NewFMF)
Set the fast-math flags to be used with generated fp-math operators.
Value * CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
CallInst * CreateOrReduce(Value *Src)
Create a vector int OR reduction intrinsic of the source vector.
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Value * CreateBitOrPointerCast(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateNot(Value *V, const Twine &Name="")
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
Value * CreateShuffleVector(Value *V1, Value *V2, Value *Mask, const Twine &Name="")
Value * CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
ConstantInt * getFalse()
Get the constant value for i1 false.
Value * CreateIsNotNull(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg != 0.
Value * CreateElementCount(Type *DstType, ElementCount EC)
Create an expression which evaluates to the number of elements in EC at runtime.
Value * CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy, const Twine &Name="")
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
Value * CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateFMul(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Value * CreateFNeg(Value *V, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateMul(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateStripInvariantGroup(Value *Ptr)
Create a strip.invariant.group intrinsic call.
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr, BasicBlock::iterator InsertBefore)
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
bool SimplifyDemandedBits(Instruction *I, unsigned Op, const APInt &DemandedMask, KnownBits &Known, unsigned Depth=0) override
This form of SimplifyDemandedBits simplifies the specified instruction operand if possible,...
Value * SimplifyDemandedVectorElts(Value *V, APInt DemandedElts, APInt &PoisonElts, unsigned Depth=0, bool AllowMultipleUsers=false) override
The specified value produces a vector with any number of elements.
Instruction * SimplifyAnyMemSet(AnyMemSetInst *MI)
Constant * getLosslessUnsignedTrunc(Constant *C, Type *TruncTy)
Instruction * visitFree(CallInst &FI, Value *FreedOp)
Instruction * visitCallBrInst(CallBrInst &CBI)
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Instruction * visitFenceInst(FenceInst &FI)
Instruction * visitInvokeInst(InvokeInst &II)
Constant * getLosslessSignedTrunc(Constant *C, Type *TruncTy)
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.
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.
const DataLayout & getDataLayout() const
bool isFreeToInvert(Value *V, bool WillInvertAllUses, bool &DoesConsume)
Return true if the specified value is free to invert (apply ~ to).
DominatorTree & getDominatorTree() const
bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero=false, unsigned Depth=0, const Instruction *CxtI=nullptr)
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.
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.
void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth, const Instruction *CxtI) const
AssumptionCache & getAssumptionCache() const
bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth=0, const Instruction *CxtI=nullptr) const
OptimizationRemarkEmitter & ORE
Value * getFreelyInverted(Value *V, bool WillInvertAllUses, BuilderTy *Builder, bool &DoesConsume)
const SimplifyQuery & getSimplifyQuery() const
unsigned ComputeMaxSignificantBits(const Value *Op, unsigned Depth=0, const Instruction *CxtI=nullptr) const
void pushUsersToWorkList(Instruction &I)
When an instruction is simplified, add all users of the instruction to the work lists because they mi...
void add(Instruction *I)
Add instruction to the worklist.
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction,...
bool mayWriteToMemory() const LLVM_READONLY
Return true if this instruction may modify memory.
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
void setAAMetadata(const AAMDNodes &N)
Sets the AA metadata on this instruction from the AAMDNodes structure.
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction.
const Instruction * getPrevNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the previous non-debug instruction in the same basic block as 'this',...
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
const BasicBlock * getParent() const
bool isFast() const LLVM_READONLY
Determine whether all fast-math-flags are set.
Instruction * user_back()
Specialize the methods defined in Value, as we know that an instruction can only be used by other ins...
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 mayHaveSideEffects() const LLVM_READONLY
Return true if the instruction may have side effects.
const Instruction * getNextNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the next non-debug instruction in the same basic block as 'this',...
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
std::optional< InstListType::iterator > getInsertionPointAfterDef()
Get the first insertion point at which the result of this instruction is defined.
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.
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
bool hasAllowReassoc() const LLVM_READONLY
Determine whether the allow-reassociation flag is set.
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Class to represent integer types.
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
A wrapper class for inspecting calls to intrinsic functions.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
bool isCommutative() const
Return true if swapping the first two arguments to the intrinsic produces the same result.
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, BasicBlock::iterator InsertBefore)
This is an important class for using LLVM in a threaded context.
LibCallSimplifier - This class implements a collection of optimizations that replace well formed call...
An instruction for reading from memory.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
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.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
A container for an operand bundle being viewed as a set of values rather than a set of uses.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Represents a saturating add/sub intrinsic.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr, BasicBlock::iterator InsertBefore, 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.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
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 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.
unsigned getIntegerBitWidth() const
const fltSemantics & getFltSemantics() const
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isStructTy() const
True if this is an instance of StructType.
Type * getWithNewBitWidth(unsigned NewBitWidth) const
Given an integer or vector type, change the lane bitwidth to NewBitwidth, whilst keeping the old numb...
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
bool canLosslesslyBitCastTo(Type *Ty) const
Return true if this type could be converted with a lossless BitCast to type 'Ty'.
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isVoidTy() const
Return true if this is 'void'.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
static UnaryOperator * CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO, const Twine &Name, BasicBlock::iterator InsertBefore)
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
A Use represents the edge between a Value definition and its users.
const Use & getOperandUse(unsigned i) const
void setOperand(unsigned i, Value *Val)
Value * getOperand(unsigned i) const
This represents the llvm.va_end intrinsic.
static void ValueIsDeleted(Value *V)
static 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
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
bool hasOneUse() const
Return true if there is exactly one use of this value.
iterator_range< user_iterator > users()
static void dropDroppableUse(Use &U)
Remove the droppable use U.
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
LLVMContext & getContext() const
All values hold a context through their type.
static constexpr unsigned MaxAlignmentExponent
The maximum alignment for instructions.
StringRef getName() const
Return a constant reference to the value's name.
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...
Represents an op.with.overflow intrinsic.
static constexpr bool isKnownLT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
static constexpr bool isKnownGT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
AttributeMask typeIncompatible(Type *Ty, AttributeSafetyKind ASK=ASK_ALL)
Which attributes cannot be applied to a type.
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.
@ C
The default llvm calling convention, compatible with C.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
specific_intval< false > m_SpecificInt(APInt V)
Match a specific integer value or vector with all elements equal to the value.
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.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
apint_match m_APIntAllowUndef(const APInt *&Res)
Match APInt while allowing undefs in splat vector constants.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
BinaryOp_match< LHS, RHS, Instruction::And, true > m_c_And(const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
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.
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.
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.
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)
CastOperator_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
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()...
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >, OpTy > m_ZExtOrSExtOrSelf(const OpTy &Op)
OneUse_match< T > m_OneUse(const T &SubPattern)
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
CastInst_match< OpTy, FPExtInst > m_FPExt(const OpTy &Op)
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)
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
class_match< CmpInst > m_Cmp()
Matches any compare instruction and ignore it.
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)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
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)
apfloat_match m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
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.
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
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.
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.
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.
AssignmentMarkerRange getAssignmentMarkers(DIAssignID *ID)
Return a range of dbg.assign intrinsics which use \ID as an operand.
SmallVector< DPValue * > getDPVAssignmentMarkers(const Instruction *Inst)
initializer< Ty > init(const Ty &Val)
DiagnosticInfoOptimizationBase::Argument NV
This is an optimization pass for GlobalISel generic memory operations.
cl::opt< bool > EnableKnowledgeRetention
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.
@ 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.
bool isKnownNonZero(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given value is known to be non-zero when defined.
UnaryFunction for_each(R &&Range, UnaryFunction F)
Provide wrappers to std::for_each which take ranges instead of having to pass begin/end explicitly.
Value * simplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FMul, fold the result or return null.
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)
Return true if it is valid to use the assumptions provided by an assume intrinsic,...
bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false)
Return true if the two given values are negation.
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 ...
RetainedKnowledge simplifyRetainedKnowledge(AssumeInst *Assume, RetainedKnowledge RK, AssumptionCache *AC, DominatorTree *DT)
canonicalize the RetainedKnowledge RK.
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...
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.
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_READONLY APFloat maximum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 maximum semantics.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments and pointer casts from the specified value,...
Value * simplifyCall(CallBase *Call, Value *Callee, ArrayRef< Value * > Args, const SimplifyQuery &Q)
Given a callsite, callee, and arguments, fold the result or return null.
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
bool isAssumeWithEmptyBundle(const AssumeInst &Assume)
Return true iff the operand bundles of the provided llvm.assume doesn't contain any valuable informat...
Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI)
This extracts the Knowledge from an element of an operand bundle.
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.
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 2019 maximumNumber semantics.
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.
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.
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...
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
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)
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...
FPClassTest inverse_fabs(FPClassTest Mask)
Return the test mask which returns true after fabs is applied to the value.
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 ...
Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
constexpr int PoisonMaskElem
@ Mod
The access may modify the value stored in memory.
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.
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 2019 minimumNumber semantics.
@ Mul
Product of integers.
ConstantRange computeConstantRangeIncludingKnownBits(const WithCache< const Value * > &V, bool ForSigned, const SimplifyQuery &SQ)
Combine constant ranges from computeConstantRange() and computeKnownBits().
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
constexpr uint64_t MinAlign(uint64_t A, uint64_t B)
A and B are either alignments or offsets.
Value * getFreedOperand(const CallBase *CB, const TargetLibraryInfo *TLI)
If this if a call to a free function, return the freed operand.
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
constexpr unsigned BitWidth
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.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
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.
std::optional< bool > computeKnownFPSignBit(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return false if we can prove that the specified FP value's sign bit is 0.
unsigned Log2(Align A)
Returns the log2 of the alignment.
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 ...
uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the largest uint64_t less than or equal to Value and is Skew mod Align.
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.
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
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.
Represent one information held inside an operand bundle of an llvm.assume.
Attribute::AttrKind AttrKind
SelectPatternFlavor Flavor
SimplifyQuery getWithInstruction(const Instruction *I) const