24using namespace PatternMatch;
26#define DEBUG_TYPE "instcombine"
38 unsigned Opc =
I->getOpcode();
40 case Instruction::Add:
41 case Instruction::Sub:
42 case Instruction::Mul:
43 case Instruction::And:
45 case Instruction::Xor:
46 case Instruction::AShr:
47 case Instruction::LShr:
48 case Instruction::Shl:
49 case Instruction::UDiv:
50 case Instruction::URem: {
56 case Instruction::Trunc:
57 case Instruction::ZExt:
58 case Instruction::SExt:
62 if (
I->getOperand(0)->getType() == Ty)
63 return I->getOperand(0);
68 Opc == Instruction::SExt);
70 case Instruction::Select: {
76 case Instruction::PHI: {
87 case Instruction::FPToUI:
88 case Instruction::FPToSI:
92 case Instruction::Call:
94 switch (II->getIntrinsicID()) {
97 case Intrinsic::vscale: {
106 case Instruction::ShuffleVector: {
107 auto *ScalarTy = cast<VectorType>(Ty)->getElementType();
108 auto *VTy = cast<VectorType>(
I->getOperand(0)->getType());
113 cast<ShuffleVectorInst>(
I)->getShuffleMask());
126InstCombinerImpl::isEliminableCastPair(
const CastInst *CI1,
141 DstTy, SrcIntPtrTy, MidIntPtrTy,
146 if ((Res == Instruction::IntToPtr && SrcTy != DstIntPtrTy) ||
147 (Res == Instruction::PtrToInt && DstTy != SrcIntPtrTy))
158 if (
auto *SrcC = dyn_cast<Constant>(Src))
163 if (
auto *CSrc = dyn_cast<CastInst>(Src)) {
169 if (CSrc->hasOneUse())
175 if (
auto *Sel = dyn_cast<SelectInst>(Src)) {
181 auto *Cmp = dyn_cast<CmpInst>(Sel->getCondition());
182 if (!Cmp || Cmp->getOperand(0)->getType() != Sel->getType() ||
188 if (CI.
getOpcode() != Instruction::BitCast ||
199 if (
auto *PN = dyn_cast<PHINode>(Src)) {
216 auto *SrcTy = dyn_cast<FixedVectorType>(
X->getType());
217 auto *DestTy = dyn_cast<FixedVectorType>(Ty);
218 if (SrcTy && DestTy &&
219 SrcTy->getNumElements() == DestTy->getNumElements() &&
232 if (isa<Constant>(V))
246 if (!isa<Instruction>(V))
274 auto *
I = cast<Instruction>(V);
275 Type *OrigTy = V->getType();
276 switch (
I->getOpcode()) {
277 case Instruction::Add:
278 case Instruction::Sub:
279 case Instruction::Mul:
280 case Instruction::And:
281 case Instruction::Or:
282 case Instruction::Xor:
287 case Instruction::UDiv:
288 case Instruction::URem: {
301 case Instruction::Shl: {
312 case Instruction::LShr: {
330 case Instruction::AShr: {
340 unsigned ShiftedBits = OrigBitWidth -
BitWidth;
347 case Instruction::Trunc:
350 case Instruction::ZExt:
351 case Instruction::SExt:
355 case Instruction::Select: {
360 case Instruction::PHI: {
370 case Instruction::FPToUI:
371 case Instruction::FPToSI: {
375 Type *InputTy =
I->getOperand(0)->getType()->getScalarType();
379 I->getOpcode() == Instruction::FPToSI);
382 case Instruction::ShuffleVector:
403 if (!TruncOp->
hasOneUse() || !isa<IntegerType>(DestType))
406 Value *VecInput =
nullptr;
411 !isa<VectorType>(VecInput->
getType()))
415 unsigned VecWidth = VecType->getPrimitiveSizeInBits();
417 unsigned ShiftAmount = ShiftVal ? ShiftVal->
getZExtValue() : 0;
419 if ((VecWidth % DestWidth != 0) || (ShiftAmount % DestWidth != 0))
424 unsigned NumVecElts = VecWidth / DestWidth;
425 if (VecType->getElementType() != DestType) {
430 unsigned Elt = ShiftAmount / DestWidth;
432 Elt = NumVecElts - 1 - Elt;
442 "Don't narrow to an illegal scalar type");
458 Value *ShVal0, *ShVal1, *ShAmt0, *ShAmt1;
465 if (Or0->
getOpcode() == BinaryOperator::LShr) {
471 Or1->
getOpcode() == BinaryOperator::LShr &&
472 "Illegal or(shift,shift) pair");
481 unsigned MaxShiftAmountWidth =
Log2_32(NarrowWidth);
482 APInt HiBitMask =
~APInt::getLowBitsSet(WideWidth, MaxShiftAmountWidth);
489 if (ShVal0 != ShVal1)
495 unsigned Mask = Width - 1;
508 Value *ShAmt = matchShiftAmount(ShAmt0, ShAmt1, NarrowWidth);
511 ShAmt = matchShiftAmount(ShAmt1, ShAmt0, NarrowWidth);
533 if (ShVal0 != ShVal1)
535 Intrinsic::ID IID = IsFshl ? Intrinsic::fshl : Intrinsic::fshr;
548 if (!isa<VectorType>(SrcTy) && !shouldChangeType(SrcTy, DestTy))
558 case Instruction::And:
559 case Instruction::Or:
560 case Instruction::Xor:
561 case Instruction::Add:
562 case Instruction::Sub:
563 case Instruction::Mul: {
590 case Instruction::LShr:
591 case Instruction::AShr: {
596 unsigned MaxShiftAmt = SrcWidth - DestWidth;
600 APInt(SrcWidth, MaxShiftAmt)))) {
601 auto *OldShift = cast<Instruction>(Trunc.
getOperand(0));
602 bool IsExact = OldShift->isExact();
607 OldShift->getOpcode() == Instruction::AShr
619 if (
Instruction *NarrowOr = narrowFunnelShift(Trunc))
630 auto *Shuf = dyn_cast<ShuffleVectorInst>(Trunc.
getOperand(0));
631 if (Shuf && Shuf->hasOneUse() &&
match(Shuf->getOperand(1),
m_Undef()) &&
633 Shuf->getType() == Shuf->getOperand(0)->getType()) {
651 assert((Opcode == Instruction::Trunc || Opcode == Instruction::FPTrunc) &&
652 "Unexpected instruction for shrinking");
654 auto *InsElt = dyn_cast<InsertElementInst>(Trunc.
getOperand(0));
655 if (!InsElt || !InsElt->hasOneUse())
660 Value *VecOp = InsElt->getOperand(0);
661 Value *ScalarOp = InsElt->getOperand(1);
680 Type *DestTy = Trunc.
getType(), *SrcTy = Src->getType();
688 if ((DestTy->
isVectorTy() || shouldChangeType(SrcTy, DestTy)) &&
694 dbgs() <<
"ICE: EvaluateInDifferentType converting expression type"
706 if (
auto *DestITy = dyn_cast<IntegerType>(DestTy)) {
707 if (DestWidth * 2 < SrcWidth) {
708 auto *NewDestTy = DestITy->getExtendedType();
709 if (shouldChangeType(SrcTy, NewDestTy) &&
712 dbgs() <<
"ICE: EvaluateInDifferentType converting expression type"
713 " to reduce the width of operand of"
726 if (
SelectInst *Sel = dyn_cast<SelectInst>(Src))
735 if (DestWidth == 1) {
771 unsigned AWidth =
A->getType()->getScalarSizeInBits();
772 unsigned MaxShiftAmt = SrcWidth - std::max(DestWidth, AWidth);
773 auto *OldSh = cast<Instruction>(Src);
774 bool IsExact = OldSh->isExact();
779 APInt(SrcWidth, MaxShiftAmt)))) {
780 auto GetNewShAmt = [&](
unsigned Width) {
781 Constant *MaxAmt = ConstantInt::get(SrcTy, Width - 1,
false);
790 if (
A->getType() == DestTy) {
791 Constant *ShAmt = GetNewShAmt(DestWidth);
793 return IsExact ? BinaryOperator::CreateExactAShr(
A, ShAmt)
794 : BinaryOperator::CreateAShr(
A, ShAmt);
798 if (Src->hasOneUse()) {
799 Constant *ShAmt = GetNewShAmt(AWidth);
816 if (Src->hasOneUse() &&
817 (isa<VectorType>(SrcTy) || shouldChangeType(SrcTy, DestTy))) {
824 APInt Threshold =
APInt(
C->getType()->getScalarSizeInBits(), DestWidth);
847 auto *VecOpTy = cast<VectorType>(VecOp->
getType());
848 auto VecElts = VecOpTy->getElementCount();
851 if (SrcWidth % DestWidth == 0) {
852 uint64_t TruncRatio = SrcWidth / DestWidth;
853 uint64_t BitCastNumElts = VecElts.getKnownMinValue() * TruncRatio;
856 : VecOpIdx * TruncRatio;
857 assert(BitCastNumElts <= std::numeric_limits<uint32_t>::max() &&
870 unsigned AWidth =
A->getType()->getScalarSizeInBits();
871 if (AWidth == DestWidth && AWidth >
Log2_32(SrcWidth)) {
872 Value *WidthDiff = ConstantInt::get(
A->getType(), SrcWidth - AWidth);
875 return BinaryOperator::CreateAdd(NarrowCtlz, WidthDiff);
885 if (
Log2_32(*MaxVScale) < DestWidth) {
913 Value *In = Cmp->getOperand(0);
914 Value *Sh = ConstantInt::get(In->getType(),
915 In->getType()->getScalarSizeInBits() - 1);
917 if (In->getType() != Zext.
getType())
928 if (Op1CV->
isZero() && Cmp->isEquality()) {
933 uint32_t ShAmt = KnownZeroMask.logBase2();
934 bool IsExpectShAmt = KnownZeroMask.isPowerOf2() &&
937 (Cmp->getOperand(0)->getType() == Zext.
getType() ||
939 Value *In = Cmp->getOperand(0);
944 In->getName() +
".lobit");
960 if (
Cmp->isEquality() && Zext.
getType() ==
Cmp->getOperand(0)->getType()) {
1005 auto *
I = cast<Instruction>(V);
1007 switch (
I->getOpcode()) {
1008 case Instruction::ZExt:
1009 case Instruction::SExt:
1010 case Instruction::Trunc:
1012 case Instruction::And:
1013 case Instruction::Or:
1014 case Instruction::Xor:
1015 case Instruction::Add:
1016 case Instruction::Sub:
1017 case Instruction::Mul:
1022 if (BitsToClear == 0 && Tmp == 0)
1027 if (Tmp == 0 &&
I->isBitwiseLogicOp()) {
1030 unsigned VSize = V->getType()->getScalarSizeInBits();
1036 if (
I->getOpcode() == Instruction::And)
1045 case Instruction::Shl: {
1053 BitsToClear = ShiftAmt < BitsToClear ? BitsToClear - ShiftAmt : 0;
1058 case Instruction::LShr: {
1066 if (BitsToClear > V->getType()->getScalarSizeInBits())
1067 BitsToClear = V->getType()->getScalarSizeInBits();
1073 case Instruction::Select:
1082 case Instruction::PHI: {
1097 case Instruction::Call:
1101 if (II->getIntrinsicID() == Intrinsic::vscale)
1122 Type *SrcTy = Src->getType(), *DestTy = Zext.
getType();
1129 unsigned BitsToClear;
1130 if (shouldChangeType(SrcTy, DestTy) &&
1133 "Can't clear more bits than in SrcTy");
1137 dbgs() <<
"ICE: EvaluateInDifferentType converting expression type"
1138 " to avoid zero extend: "
1144 if (
auto *
SrcOp = dyn_cast<Instruction>(Src))
1145 if (
SrcOp->hasOneUse())
1155 DestBitSize - SrcBitsKept),
1162 return BinaryOperator::CreateAnd(Res,
C);
1168 if (
auto *CSrc = dyn_cast<TruncInst>(Src)) {
1173 Value *
A = CSrc->getOperand(0);
1174 unsigned SrcSize =
A->getType()->getScalarSizeInBits();
1175 unsigned MidSize = CSrc->getType()->getScalarSizeInBits();
1181 if (SrcSize < DstSize) {
1183 Constant *AndConst = ConstantInt::get(
A->getType(), AndValue);
1188 if (SrcSize == DstSize) {
1190 return BinaryOperator::CreateAnd(
A, ConstantInt::get(
A->getType(),
1193 if (SrcSize > DstSize) {
1196 return BinaryOperator::CreateAnd(Trunc,
1197 ConstantInt::get(Trunc->
getType(),
1202 if (
auto *Cmp = dyn_cast<ICmpInst>(Src))
1203 return transformZExtICmp(Cmp, Zext);
1209 X->getType() == DestTy)
1216 X->getType() == DestTy) {
1227 X->getType() == DestTy) {
1229 return BinaryOperator::CreateAnd(
X, ZextC);
1238 unsigned TypeWidth = Src->getType()->getScalarSizeInBits();
1239 if (
Log2_32(*MaxVScale) < TypeWidth) {
1269 Value *Op0 = Cmp->getOperand(0), *Op1 = Cmp->getOperand(1);
1273 if (!Op1->getType()->isIntOrIntVectorTy())
1281 if (In->getType() != Sext.
getType())
1287 if (
ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
1291 if (Cmp->hasOneUse() &&
1292 Cmp->isEquality() && (Op1C->isZero() || Op1C->getValue().isPowerOf2())){
1296 if (KnownZeroMask.isPowerOf2()) {
1297 Value *In = Cmp->getOperand(0);
1300 if (!Op1C->isZero() && Op1C->getValue() != KnownZeroMask) {
1310 unsigned ShiftAmt = KnownZeroMask.countr_zero();
1314 ConstantInt::get(
In->getType(), ShiftAmt));
1324 unsigned ShiftAmt = KnownZeroMask.countl_zero();
1328 ConstantInt::get(
In->getType(), ShiftAmt));
1332 KnownZeroMask.getBitWidth() - 1),
"sext");
1354 "Can't sign extend type to a smaller type");
1360 auto *
I = cast<Instruction>(V);
1361 switch (
I->getOpcode()) {
1362 case Instruction::SExt:
1363 case Instruction::ZExt:
1364 case Instruction::Trunc:
1366 case Instruction::And:
1367 case Instruction::Or:
1368 case Instruction::Xor:
1369 case Instruction::Add:
1370 case Instruction::Sub:
1371 case Instruction::Mul:
1379 case Instruction::Select:
1383 case Instruction::PHI: {
1410 Type *SrcTy = Src->getType(), *DestTy = Sext.
getType();
1417 CI->setNonNeg(
true);
1425 dbgs() <<
"ICE: EvaluateInDifferentType converting expression type"
1426 " to avoid sign extend: "
1437 Value *ShAmt = ConstantInt::get(DestTy, DestBitSize-SrcBitSize);
1446 unsigned XBitSize =
X->getType()->getScalarSizeInBits();
1451 if (Src->hasOneUse() &&
X->getType() == DestTy) {
1453 Constant *ShAmt = ConstantInt::get(DestTy, DestBitSize - SrcBitSize);
1462 if (Src->hasOneUse() &&
1470 if (
auto *Cmp = dyn_cast<ICmpInst>(Src))
1471 return transformSExtICmp(Cmp, Sext);
1488 Constant *BA =
nullptr, *CA =
nullptr;
1494 assert(WideCurrShAmt &&
"Constant folding of ImmConstant cannot fail");
1503 return BinaryOperator::CreateAShr(
A, NewShAmt);
1511 Type *XTy =
X->getType();
1513 Constant *ShlAmtC = ConstantInt::get(XTy, XBitSize - SrcBitSize);
1514 Constant *AshrAmtC = ConstantInt::get(XTy, XBitSize - 1);
1518 if (cast<BinaryOperator>(Src)->getOperand(0)->hasOneUse()) {
1530 if (
Log2_32(*MaxVScale) < (SrcBitSize - 1)) {
1573 auto *CV = dyn_cast<Constant>(V);
1574 auto *CVVTy = dyn_cast<FixedVectorType>(V->getType());
1578 Type *MinType =
nullptr;
1580 unsigned NumElts = CVVTy->getNumElements();
1584 for (
unsigned i = 0; i != NumElts; ++i) {
1585 if (isa<UndefValue>(CV->getAggregateElement(i)))
1588 auto *CFP = dyn_cast_or_null<ConstantFP>(CV->getAggregateElement(i));
1608 if (
auto *FPExt = dyn_cast<FPExtInst>(V))
1609 return FPExt->getOperand(0)->getType();
1614 if (
auto *CFP = dyn_cast<ConstantFP>(V))
1621 if (
auto *FPCExt = dyn_cast<ConstantExpr>(V))
1622 if (FPCExt->getOpcode() == Instruction::FPExt)
1623 return FPCExt->getOperand(0)->getType();
1630 return V->getType();
1637 assert((Opcode == CastInst::SIToFP || Opcode == CastInst::UIToFP) &&
1639 Value *Src =
I.getOperand(0);
1640 Type *SrcTy = Src->getType();
1641 Type *FPTy =
I.getType();
1642 bool IsSigned = Opcode == Instruction::SIToFP;
1648 if (SrcSize <= DestNumSigBits)
1657 int SrcNumSigBits =
F->getType()->getFPMantissaWidth();
1664 if (SrcNumSigBits > 0 && DestNumSigBits > 0 &&
1665 SrcNumSigBits <= DestNumSigBits)
1676 if (SigBits <= DestNumSigBits)
1694 auto *BO = dyn_cast<BinaryOperator>(FPT.
getOperand(0));
1695 if (BO && BO->hasOneUse()) {
1700 unsigned OpWidth = BO->getType()->getFPMantissaWidth();
1703 unsigned SrcWidth = std::max(LHSWidth, RHSWidth);
1705 switch (BO->getOpcode()) {
1707 case Instruction::FAdd:
1708 case Instruction::FSub:
1727 if (OpWidth >= 2*DstWidth+1 && DstWidth >= SrcWidth) {
1735 case Instruction::FMul:
1741 if (OpWidth >= LHSWidth + RHSWidth && DstWidth >= SrcWidth) {
1747 case Instruction::FDiv:
1754 if (OpWidth >= 2*DstWidth && DstWidth >= SrcWidth) {
1760 case Instruction::FRem: {
1765 if (SrcWidth == OpWidth)
1768 if (LHSWidth == SrcWidth) {
1785 if (
Op &&
Op->hasOneUse()) {
1788 if (isa<FPMathOperator>(
Op))
1801 X->getType() == Ty) {
1808 X->getType() == Ty) {
1816 if (
auto *II = dyn_cast<IntrinsicInst>(FPT.
getOperand(0))) {
1817 switch (II->getIntrinsicID()) {
1819 case Intrinsic::ceil:
1820 case Intrinsic::fabs:
1821 case Intrinsic::floor:
1822 case Intrinsic::nearbyint:
1823 case Intrinsic::rint:
1824 case Intrinsic::round:
1825 case Intrinsic::roundeven:
1826 case Intrinsic::trunc: {
1827 Value *Src = II->getArgOperand(0);
1828 if (!Src->hasOneUse())
1834 if (II->getIntrinsicID() != Intrinsic::fabs) {
1835 FPExtInst *FPExtSrc = dyn_cast<FPExtInst>(Src);
1836 if (!FPExtSrc || FPExtSrc->
getSrcTy() != Ty)
1844 II->getIntrinsicID(), Ty);
1846 II->getOperandBundlesAsDefs(OpBundles);
1859 if (isa<SIToFPInst>(Src) || isa<UIToFPInst>(Src)) {
1860 auto *FPCast = cast<CastInst>(Src);
1873 if (isa<SIToFPInst>(Src) || isa<UIToFPInst>(Src)) {
1874 auto *FPCast = cast<CastInst>(Src);
1890 auto *OpI = cast<CastInst>(FI.
getOperand(0));
1891 Value *
X = OpI->getOperand(0);
1892 Type *XType =
X->getType();
1894 bool IsOutputSigned = isa<FPToSIInst>(FI);
1909 if (OutputSize > OpI->getType()->getFPMantissaWidth())
1914 bool IsInputSigned = isa<SIToFPInst>(OpI);
1915 if (IsInputSigned && IsOutputSigned)
1922 assert(XType == DestType &&
"Unexpected types for int to FP to int casts");
1996 if (TySize != PtrSize) {
2009 Mask->getType() == Ty)
2012 if (
auto *
GEP = dyn_cast<GetElementPtrInst>(
SrcOp)) {
2017 if (
GEP->hasOneUse() &&
2018 isa<ConstantPointerNull>(
GEP->getPointerOperand())) {
2063 if (SrcTy->getElementType() != DestTy->getElementType()) {
2068 if (SrcTy->getElementType()->getPrimitiveSizeInBits() !=
2069 DestTy->getElementType()->getPrimitiveSizeInBits())
2074 cast<FixedVectorType>(SrcTy)->getNumElements());
2079 unsigned SrcElts = cast<FixedVectorType>(SrcTy)->getNumElements();
2080 unsigned DestElts = cast<FixedVectorType>(DestTy)->getNumElements();
2082 assert(SrcElts != DestElts &&
"Element counts should be different.");
2087 auto ShuffleMaskStorage = llvm::to_vector<16>(llvm::seq<int>(0, SrcElts));
2091 if (SrcElts > DestElts) {
2100 ShuffleMask = ShuffleMaskStorage;
2102 ShuffleMask = ShuffleMask.
take_back(DestElts);
2104 ShuffleMask = ShuffleMask.
take_front(DestElts);
2115 unsigned DeltaElts = DestElts - SrcElts;
2117 ShuffleMaskStorage.insert(ShuffleMaskStorage.begin(), DeltaElts, NullElt);
2119 ShuffleMaskStorage.append(DeltaElts, NullElt);
2120 ShuffleMask = ShuffleMaskStorage;
2148 "Shift should be a multiple of the element type size");
2151 if (isa<UndefValue>(V))
return true;
2155 if (V->getType() == VecEltTy) {
2157 if (
Constant *
C = dyn_cast<Constant>(V))
2158 if (
C->isNullValue())
2163 ElementIndex = Elements.size() - ElementIndex - 1;
2166 if (Elements[ElementIndex])
2169 Elements[ElementIndex] = V;
2173 if (
Constant *
C = dyn_cast<Constant>(V)) {
2186 if (!isa<IntegerType>(
C->getType()))
2188 C->getType()->getPrimitiveSizeInBits()));
2192 for (
unsigned i = 0; i != NumElts; ++i) {
2193 unsigned ShiftI = i * ElementSize;
2195 Instruction::LShr,
C, ConstantInt::get(
C->getType(), ShiftI));
2207 if (!V->hasOneUse())
return false;
2210 if (!
I)
return false;
2211 switch (
I->getOpcode()) {
2212 default:
return false;
2213 case Instruction::BitCast:
2214 if (
I->getOperand(0)->getType()->isVectorTy())
2218 case Instruction::ZExt:
2220 I->getOperand(0)->getType()->getPrimitiveSizeInBits(),
2225 case Instruction::Or:
2230 case Instruction::Shl: {
2232 ConstantInt *CI = dyn_cast<ConstantInt>(
I->getOperand(1));
2233 if (!CI)
return false;
2260 auto *DestVecTy = cast<FixedVectorType>(CI.
getType());
2265 DestVecTy->getElementType(),
2273 for (
unsigned i = 0, e = Elements.size(); i != e; ++i) {
2274 if (!Elements[i])
continue;
2306 auto *FixedVType = dyn_cast<FixedVectorType>(VecType);
2307 if (DestType->
isVectorTy() && FixedVType && FixedVType->getNumElements() == 1)
2334 if (
X->getType()->isFPOrFPVectorTy() &&
2335 Y->getType()->isIntOrIntVectorTy()) {
2341 if (
X->getType()->isIntOrIntVectorTy() &&
2342 Y->getType()->isFPOrFPVectorTy()) {
2357 X->getType() == DestTy && !isa<Constant>(
X)) {
2364 X->getType() == DestTy && !isa<Constant>(
X)) {
2396 if (
auto *CondVTy = dyn_cast<VectorType>(CondTy))
2398 CondVTy->getElementCount() !=
2399 cast<VectorType>(DestTy)->getElementCount())
2409 auto *Sel = cast<Instruction>(BitCast.
getOperand(0));
2412 !isa<Constant>(
X)) {
2419 !isa<Constant>(
X)) {
2431 if (!isa<StoreInst>(U))
2452 Type *SrcTy = Src->getType();
2464 while (!PhiWorklist.
empty()) {
2466 for (
Value *IncValue : OldPN->incoming_values()) {
2467 if (isa<Constant>(IncValue))
2470 if (
auto *
LI = dyn_cast<LoadInst>(IncValue)) {
2476 if (
Addr == &CI || isa<LoadInst>(
Addr))
2484 if (
LI->hasOneUse() &&
LI->isSimple())
2491 if (
auto *PNode = dyn_cast<PHINode>(IncValue)) {
2492 if (OldPhiNodes.
insert(PNode))
2497 auto *BCI = dyn_cast<BitCastInst>(IncValue);
2503 Type *TyA = BCI->getOperand(0)->getType();
2504 Type *TyB = BCI->getType();
2505 if (TyA != DestTy || TyB != SrcTy)
2512 for (
auto *OldPN : OldPhiNodes) {
2514 if (
auto *SI = dyn_cast<StoreInst>(V)) {
2515 if (!
SI->isSimple() ||
SI->getOperand(0) != OldPN)
2517 }
else if (
auto *BCI = dyn_cast<BitCastInst>(V)) {
2519 Type *TyB = BCI->getOperand(0)->getType();
2520 Type *TyA = BCI->getType();
2521 if (TyA != DestTy || TyB != SrcTy)
2523 }
else if (
auto *
PHI = dyn_cast<PHINode>(V)) {
2527 if (!OldPhiNodes.contains(
PHI))
2537 for (
auto *OldPN : OldPhiNodes) {
2540 NewPNodes[OldPN] = NewPN;
2544 for (
auto *OldPN : OldPhiNodes) {
2545 PHINode *NewPN = NewPNodes[OldPN];
2546 for (
unsigned j = 0, e = OldPN->getNumOperands(); j != e; ++j) {
2547 Value *
V = OldPN->getOperand(j);
2548 Value *NewV =
nullptr;
2549 if (
auto *
C = dyn_cast<Constant>(V)) {
2551 }
else if (
auto *
LI = dyn_cast<LoadInst>(V)) {
2560 }
else if (
auto *BCI = dyn_cast<BitCastInst>(V)) {
2561 NewV = BCI->getOperand(0);
2562 }
else if (
auto *PrevPN = dyn_cast<PHINode>(V)) {
2563 NewV = NewPNodes[PrevPN];
2566 NewPN->
addIncoming(NewV, OldPN->getIncomingBlock(j));
2580 for (
auto *OldPN : OldPhiNodes) {
2581 PHINode *NewPN = NewPNodes[OldPN];
2583 if (
auto *SI = dyn_cast<StoreInst>(V)) {
2584 assert(
SI->isSimple() &&
SI->getOperand(0) == OldPN);
2588 SI->setOperand(0, NewBC);
2592 else if (
auto *BCI = dyn_cast<BitCastInst>(V)) {
2593 Type *TyB = BCI->getOperand(0)->getType();
2594 Type *TyA = BCI->getType();
2595 assert(TyA == DestTy && TyB == SrcTy);
2601 }
else if (
auto *
PHI = dyn_cast<PHINode>(V)) {
2617 Type *SrcTy = Src->getType();
2622 if (DestTy == Src->getType())
2627 if (DestVTy->getNumElements() == 1 && SrcTy->
isX86_MMXTy()) {
2633 if (isa<IntegerType>(SrcTy)) {
2637 if (isa<TruncInst>(Src) || isa<ZExtInst>(Src)) {
2638 CastInst *SrcCast = cast<CastInst>(Src);
2640 if (isa<VectorType>(BCIn->getOperand(0)->getType()))
2642 BCIn->getOperand(0), cast<VectorType>(DestTy), *
this))
2655 if (SrcVTy->getNumElements() == 1) {
2668 if (
auto *InsElt = dyn_cast<InsertElementInst>(Src))
2669 return new BitCastInst(InsElt->getOperand(1), DestTy);
2679 Y->getType()->isIntegerTy() && isDesirableIntType(
BitWidth)) {
2682 IndexC = SrcVTy->getNumElements() - 1 - IndexC;
2688 unsigned EltWidth =
Y->getType()->getScalarSizeInBits();
2692 return BinaryOperator::CreateOr(AndX, ZextY);
2697 if (
auto *Shuf = dyn_cast<ShuffleVectorInst>(Src)) {
2700 Value *ShufOp0 = Shuf->getOperand(0);
2701 Value *ShufOp1 = Shuf->getOperand(1);
2702 auto ShufElts = cast<VectorType>(Shuf->getType())->getElementCount();
2703 auto SrcVecElts = cast<VectorType>(ShufOp0->
getType())->getElementCount();
2704 if (Shuf->hasOneUse() && DestTy->
isVectorTy() &&
2705 cast<VectorType>(DestTy)->getElementCount() == ShufElts &&
2706 ShufElts == SrcVecElts) {
2711 if (((Tmp = dyn_cast<BitCastInst>(ShufOp0)) &&
2713 ((Tmp = dyn_cast<BitCastInst>(ShufOp1)) &&
2727 if (DestTy->
isIntegerTy() && ShufElts.getKnownMinValue() % 2 == 0 &&
2728 Shuf->hasOneUse() && Shuf->isReverse()) {
2729 unsigned IntrinsicNum = 0;
2732 IntrinsicNum = Intrinsic::bswap;
2734 IntrinsicNum = Intrinsic::bitreverse;
2736 if (IntrinsicNum != 0) {
2737 assert(ShufOp0->
getType() == SrcTy &&
"Unexpected shuffle mask");
2748 if (
PHINode *PN = dyn_cast<PHINode>(Src))
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static std::optional< bool > isBigEndian(const SmallDenseMap< int64_t, int64_t, 8 > &MemOffset2Idx, int64_t LowestIdx)
Given a map from byte offsets in memory to indices in a load/store, determine if that map corresponds...
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static bool isSigned(unsigned int Opcode)
static bool collectInsertionElements(Value *V, unsigned Shift, SmallVectorImpl< Value * > &Elements, Type *VecEltTy, bool isBigEndian)
V is a value which is inserted into a vector of VecEltTy.
static bool canEvaluateSExtd(Value *V, Type *Ty)
Return true if we can take the specified value and return it as type Ty without inserting any new cas...
static bool hasStoreUsersOnly(CastInst &CI)
Check if all users of CI are StoreInsts.
static Type * shrinkFPConstantVector(Value *V, bool PreferBFloat)
static bool canEvaluateZExtd(Value *V, Type *Ty, unsigned &BitsToClear, InstCombinerImpl &IC, Instruction *CxtI)
Determine if the specified value can be computed in the specified wider type and produce the same low...
static Instruction * canonicalizeBitCastExtElt(BitCastInst &BitCast, InstCombinerImpl &IC)
Canonicalize scalar bitcasts of extracted elements into a bitcast of the vector followed by extract e...
static Instruction * shrinkSplatShuffle(TruncInst &Trunc, InstCombiner::BuilderTy &Builder)
Try to narrow the width of a splat shuffle.
static Type * shrinkFPConstant(ConstantFP *CFP, bool PreferBFloat)
static Instruction * foldFPtoI(Instruction &FI, InstCombiner &IC)
static Instruction * foldBitCastSelect(BitCastInst &BitCast, InstCombiner::BuilderTy &Builder)
Change the type of a select if we can eliminate a bitcast.
static Instruction * foldBitCastBitwiseLogic(BitCastInst &BitCast, InstCombiner::BuilderTy &Builder)
Change the type of a bitwise logic operation if we can eliminate a bitcast.
static bool fitsInFPType(ConstantFP *CFP, const fltSemantics &Sem)
Return a Constant* for the specified floating-point constant if it fits in the specified FP type with...
static Instruction * optimizeVectorResizeWithIntegerBitCasts(Value *InVal, VectorType *DestTy, InstCombinerImpl &IC)
This input value (which is known to have vector type) is being zero extended or truncated to the spec...
static Instruction * shrinkInsertElt(CastInst &Trunc, InstCombiner::BuilderTy &Builder)
Try to narrow the width of an insert element.
static Type * getMinimumFPType(Value *V, bool PreferBFloat)
Find the minimum FP type we can safely truncate to.
static bool isMultipleOfTypeSize(unsigned Value, Type *Ty)
static Value * optimizeIntegerToVectorInsertions(BitCastInst &CI, InstCombinerImpl &IC)
If the input is an 'or' instruction, we may be doing shifts and ors to assemble the elements of the v...
static bool canAlwaysEvaluateInType(Value *V, Type *Ty)
Constants and extensions/truncates from the destination type are always free to be evaluated in that ...
static bool canNotEvaluateInType(Value *V, Type *Ty)
Filter out values that we can not evaluate in the destination type for free.
static bool isKnownExactCastIntToFP(CastInst &I, InstCombinerImpl &IC)
Return true if the cast from integer to FP can be proven to be exact for all possible inputs (the con...
static unsigned getTypeSizeIndex(unsigned Value, Type *Ty)
static Instruction * foldVecTruncToExtElt(TruncInst &Trunc, InstCombinerImpl &IC)
Given a vector that is bitcast to an integer, optionally logically right-shifted, and truncated,...
static bool canEvaluateTruncated(Value *V, Type *Ty, InstCombinerImpl &IC, Instruction *CxtI)
Return true if we can evaluate the specified expression tree as type Ty instead of its larger type,...
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 a set that has insertion order iteration characteristics.
static SymbolRef::Type getType(const Symbol *Sym)
Class for arbitrary precision integers.
uint64_t getZExtValue() const
Get zero extended value.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Constructs an APInt value that has the bottom loBitsSet bits set.
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Constructs an APInt value that has the top hiBitsSet bits set.
static APInt getBitsSetFrom(unsigned numBits, unsigned loBit)
Constructs an APInt value that has a contiguous range of bits set.
This class represents a conversion between pointers from one address space to another.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
ArrayRef< T > take_front(size_t N=1) const
Return a copy of *this with only the first N elements.
ArrayRef< T > take_back(size_t N=1) const
Return a copy of *this with only the last N elements.
std::optional< unsigned > getVScaleRangeMax() const
Returns the maximum value for the vscale_range attribute or std::nullopt when unknown.
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.
BinaryOps getOpcode() const
static BinaryOperator * CreateFMulFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
This class represents a no-op cast from one type to another.
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr, BasicBlock::iterator InsertBefore)
This is the base class for all instructions that perform data casts.
Type * getSrcTy() const
Return the source type, as a convenience.
static CastInst * CreateFPCast(Value *S, Type *Ty, const Twine &Name, BasicBlock::iterator InsertBefore)
Create an FPExt, BitCast, or FPTrunc for fp -> fp casts.
Instruction::CastOps getOpcode() const
Return the opcode of this CastInst.
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 unsigned isEliminableCastPair(Instruction::CastOps firstOpcode, Instruction::CastOps secondOpcode, Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy, Type *DstIntPtrTy)
Determine how a pair of casts can be eliminated, if they can be at all.
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 * CreateTruncOrBitCast(Value *S, Type *Ty, const Twine &Name, BasicBlock::iterator InsertBefore)
Create a Trunc or BitCast cast instruction.
Type * getDestTy() const
Return the destination type, as a convenience.
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.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ ICMP_SLT
signed less than
@ ICMP_ULT
unsigned less than
@ ICMP_ULE
unsigned less or equal
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getShl(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
ConstantFP - Floating Point Values [float, double].
const APFloat & getValueAPF() const
This is the shared class of boolean and integer constants.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
This is an important base class in LLVM.
static Constant * mergeUndefsWith(Constant *C, Constant *Other)
Merges undefs of a Constant with another Constant, along with the undefs already present.
static Constant * getAllOnesValue(Type *Ty)
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
bool isElementWiseEqual(Value *Y) const
Return true if this constant and a constant 'Y' are element-wise equal.
This class represents an Operation in the Expression.
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
bool isLegalInteger(uint64_t Width) const
Returns true if the specified type is known to be a native integer type supported by the CPU.
IntegerType * getIntPtrType(LLVMContext &C, unsigned AddressSpace=0) const
Returns an integer type with size at least as big as that of a pointer in the given address space.
This class represents an extension of floating point types.
This class represents a cast from floating point to signed integer.
This class represents a cast from floating point to unsigned integer.
This class represents a truncation of floating point types.
Class to represent fixed width SIMD vectors.
static FixedVectorType * get(Type *ElementType, unsigned NumElts)
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
This instruction compares its operands according to the predicate given to the constructor.
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateVScale(Constant *Scaling, const Twine &Name="")
Create a call to llvm.vscale, multiplied by Scaling.
Value * CreateInsertElement(Type *VecTy, Value *NewElt, Value *Idx, const Twine &Name="")
Value * CreateExtractElement(Value *Vec, Value *Idx, const Twine &Name="")
Value * CreateFPTrunc(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Value * CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
void setFastMathFlags(FastMathFlags NewFMF)
Set the fast-math flags to be used with generated fp-math operators.
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Value * CreateNot(Value *V, const Twine &Name="")
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreatePtrToInt(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy, const Twine &Name="")
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Value * CreateAShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateXor(Value *LHS, Value *RHS, const Twine &Name="")
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, 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,...
Instruction * visitZExt(ZExtInst &Zext)
Instruction * visitAddrSpaceCast(AddrSpaceCastInst &CI)
Instruction * visitSExt(SExtInst &Sext)
Instruction * foldOpIntoPhi(Instruction &I, PHINode *PN)
Given a binary operator, cast instruction, or select which has a PHI node as operand #0,...
Instruction * visitFPToSI(FPToSIInst &FI)
Instruction * visitTrunc(TruncInst &CI)
Instruction * visitUIToFP(CastInst &CI)
Instruction * visitPtrToInt(PtrToIntInst &CI)
Instruction * visitSIToFP(CastInst &CI)
Instruction * commonCastTransforms(CastInst &CI)
Implement the transforms common to all CastInst visitors.
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Instruction * foldItoFPtoI(CastInst &FI)
fpto{s/u}i({u/s}itofp(X)) --> X or zext(X) or sext(X) or trunc(X) This is safe if the intermediate ty...
Instruction * visitFPTrunc(FPTruncInst &CI)
Instruction * visitBitCast(BitCastInst &CI)
Instruction * visitIntToPtr(IntToPtrInst &CI)
Instruction * visitFPToUI(FPToUIInst &FI)
Value * EvaluateInDifferentType(Value *V, Type *Ty, bool isSigned)
Given an expression that CanEvaluateTruncated or CanEvaluateSExtd returns true for,...
bool SimplifyDemandedInstructionBits(Instruction &Inst)
Tries to simplify operands to an integer instruction based on its demanded bits.
Instruction * visitFPExt(CastInst &CI)
LoadInst * combineLoadToNewType(LoadInst &LI, Type *NewTy, const Twine &Suffix="")
Helper to combine a load to a new type.
The core instruction combiner logic.
const DataLayout & getDataLayout() const
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
InstructionWorklist & Worklist
A worklist of the instructions that need to be simplified.
Instruction * InsertNewInstWith(Instruction *New, BasicBlock::iterator Old)
Same as InsertNewInstBefore, but also sets the debug loc.
unsigned ComputeNumSignBits(const Value *Op, unsigned Depth=0, const Instruction *CxtI=nullptr) const
void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth, const Instruction *CxtI) const
bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth=0, const Instruction *CxtI=nullptr) const
const SimplifyQuery & getSimplifyQuery() const
void push(Instruction *I)
Push the instruction onto the worklist stack.
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction,...
static bool isBitwiseLogicOp(unsigned Opcode)
Determine if the Opcode is and/or/xor.
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
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.
void setNonNeg(bool b=true)
Set or clear the nneg flag on this instruction, which must be a zext instruction.
bool hasNonNeg() const LLVM_READONLY
Determine whether the the nneg flag is set.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
This class represents a cast from an integer to a pointer.
unsigned getAddressSpace() const
Returns the address space of this instruction's pointer type.
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.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
op_range incoming_values()
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr, BasicBlock::iterator InsertBefore)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
This class represents a cast from a pointer to an integer.
Value * getPointerOperand()
Gets the pointer operand.
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
This class represents a sign extension of integer types.
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr, BasicBlock::iterator InsertBefore, Instruction *MDFrom=nullptr)
bool insert(const value_type &X)
Insert a new element into the SetVector.
This instruction constructs a fixed permutation of two input vectors.
A SetVector that performs no allocations if smaller than a certain size.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This class represents a truncation of integer types.
The instances of the Type class are immutable: once they are created, they are never changed.
static Type * getHalfTy(LLVMContext &C)
static Type * getDoubleTy(LLVMContext &C)
const fltSemantics & getFltSemantics() const
bool isVectorTy() const
True if this is an instance of VectorType.
static Type * getBFloatTy(LLVMContext &C)
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
bool isX86_MMXTy() const
Return true if this is X86 MMX.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
Type * getWithNewType(Type *EltTy) const
Given vector type, change the element type, whilst keeping the old number of elements.
int getFPMantissaWidth() const
Return the width of the mantissa of this type.
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isX86_AMXTy() const
Return true if this is X86 AMX.
static IntegerType * getInt32Ty(LLVMContext &C)
static Type * getFloatTy(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
static Type * getPPC_FP128Ty(LLVMContext &C)
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
static UnaryOperator * CreateFNegFMF(Value *Op, Instruction *FMFSource, const Twine &Name, BasicBlock::iterator InsertBefore)
'undef' values are things that do not have specified contents.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
bool hasOneUse() const
Return true if there is exactly one use of this value.
iterator_range< user_iterator > users()
LLVMContext & getContext() const
All values hold a context through their type.
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
This class represents zero extension of integer types.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
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.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
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)
specific_intval< false > m_SpecificInt(const APInt &V)
Match a specific integer value or vector with all elements equal to the value.
bool match(Val *V, const Pattern &P)
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement > m_ExtractElt(const Val_t &Val, const Idx_t &Idx)
Matches ExtractElementInst.
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.
BinOpPred_match< LHS, RHS, is_logical_shift_op > m_LogicalShift(const LHS &L, const RHS &R)
Matches logical shift operations.
CastOperator_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
CastInst_match< OpTy, FPToUIInst > m_FPToUI(const OpTy &Op)
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.
OneUse_match< T > m_OneUse(const T &SubPattern)
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.
CastOperator_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
VScaleVal_match m_VScale()
CastInst_match< OpTy, FPToSIInst > m_FPToSI(const OpTy &Op)
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.
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)
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.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
specific_intval< true > m_SpecificIntAllowUndef(const APInt &V)
auto m_Undef()
Match an arbitrary undef constant.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
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.
CastOperator_match< OpTy, Instruction::IntToPtr > m_IntToPtr(const OpTy &Op)
Matches IntToPtr.
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement > m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
Matches InsertElementInst.
ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
cst_pred_ty< icmp_pred_with_threshold > m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold)
Match an integer or vector with every element comparing 'pred' (eg/ne/...) to Threshold.
This is an optimization pass for GlobalISel generic memory operations.
Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
unsigned Log2_64_Ceil(uint64_t Value)
Return the ceil log base 2 of the specified value, 64 if the value is zero.
Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const Instruction *I=nullptr)
Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
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...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT)
Point debug users of From to To or salvage them.
@ And
Bitwise or logical AND of integers.
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 unsigned BitWidth
bool all_equal(std::initializer_list< T > Values)
Returns true if all Values in the initializer lists are equal or the list.
KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
static const fltSemantics & IEEEsingle() LLVM_READNONE
static constexpr roundingMode rmNearestTiesToEven
static const fltSemantics & IEEEdouble() LLVM_READNONE
static const fltSemantics & IEEEhalf() LLVM_READNONE
static const fltSemantics & BFloat() LLVM_READNONE
static unsigned int semanticsIntSizeInBits(const fltSemantics &, bool)
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
unsigned countMinLeadingZeros() const
Returns the minimum number of leading zero bits.
APInt getMaxValue() const
Return the maximal unsigned value possible given these KnownBits.
bool isKnownNever(FPClassTest Mask) const
Return true if it's known this can never be one of the mask entries.
SimplifyQuery getWithInstruction(const Instruction *I) const