37#define DEBUG_TYPE "instcombine"
41using namespace PatternMatch;
51 if (!V->hasOneUse())
return nullptr;
53 bool MadeChange =
false;
57 Value *
A =
nullptr, *
B =
nullptr, *One =
nullptr;
67 if (
I &&
I->isLogicalShift() &&
76 if (
I->getOpcode() == Instruction::LShr && !
I->isExact()) {
81 if (
I->getOpcode() == Instruction::Shl && !
I->hasNoUnsignedWrap()) {
82 I->setHasNoUnsignedWrap();
91 return MadeChange ? V :
nullptr;
107 bool HasAnyNoWrap =
I.hasNoSignedWrap() ||
I.hasNoUnsignedWrap();
108 Value *Neg =
Builder.CreateNeg(OtherOp,
"",
false, HasAnyNoWrap);
115 bool HasAnyNoWrap =
I.hasNoSignedWrap() ||
I.hasNoUnsignedWrap();
116 Value *Neg =
Builder.CreateNeg(OtherOp,
"",
false, HasAnyNoWrap);
126 Builder.setFastMathFlags(
I.getFastMathFlags());
136 Builder.setFastMathFlags(
I.getFastMathFlags());
157 bool PropagateNSW = HasNSW && cast<ShlOperator>(
Y)->hasNoSignedWrap();
170 Value *Shl =
Builder.CreateShl(FrX, Z,
"mulshl", HasNUW, PropagateNSW);
189 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
207 Type *Ty =
I.getType();
209 const bool HasNSW =
I.hasNoSignedWrap();
210 const bool HasNUW =
I.hasNoUnsignedWrap();
230 if (HasNUW &&
Mul->hasNoUnsignedWrap())
246 if (
match(NewCst,
m_APInt(V)) && *V != V->getBitWidth() - 1)
259 return BinaryOperator::CreateMul(
268 const APInt *NegPow2C;
272 unsigned SrcWidth =
X->getType()->getScalarSizeInBits();
274 if (ShiftAmt >=
BitWidth - SrcWidth) {
300 auto *BOp0 = cast<BinaryOperator>(Op0);
302 (BOp0->getOpcode() == Instruction::Or || BOp0->hasNoUnsignedWrap());
304 auto *BO = BinaryOperator::CreateAdd(NewMul, NewC);
305 if (HasNUW && Op0NUW) {
307 if (
auto *NewMulBO = dyn_cast<BinaryOperator>(NewMul))
308 NewMulBO->setHasNoUnsignedWrap();
309 BO->setHasNoUnsignedWrap();
321 return BinaryOperator::CreateMul(
X,
X);
324 return BinaryOperator::CreateMul(
X,
X);
335 auto *NewMul = BinaryOperator::CreateMul(
X,
Y);
336 if (HasNSW && cast<OverflowingBinaryOperator>(Op0)->
hasNoSignedWrap() &&
338 NewMul->setHasNoSignedWrap();
352 if (!Div || (Div->
getOpcode() != Instruction::UDiv &&
353 Div->
getOpcode() != Instruction::SDiv)) {
355 Div = dyn_cast<BinaryOperator>(Op1);
357 Value *Neg = dyn_castNegVal(
Y);
360 (Div->
getOpcode() == Instruction::UDiv ||
361 Div->
getOpcode() == Instruction::SDiv)) {
371 auto RemOpc = Div->
getOpcode() == Instruction::UDiv ? Instruction::URem
377 return BinaryOperator::CreateSub(XFreeze, Rem);
378 return BinaryOperator::CreateSub(Rem, XFreeze);
390 return BinaryOperator::CreateAnd(Op0, Op1);
402 X->getType()->isIntOrIntVectorTy(1) &&
X->getType() ==
Y->getType() &&
403 (Op0->
hasOneUse() || Op1->hasOneUse() ||
X ==
Y)) {
412 X->getType()->isIntOrIntVectorTy(1) &&
X->getType() ==
Y->getType() &&
413 (Op0->
hasOneUse() || Op1->hasOneUse())) {
436 *
C ==
C->getBitWidth() - 1) {
448 *
C ==
C->getBitWidth() - 1) {
474 bool Changed =
false;
475 if (!HasNSW && willNotOverflowSignedMul(Op0, Op1,
I)) {
477 I.setHasNoSignedWrap(
true);
480 if (!HasNUW && willNotOverflowUnsignedMul(Op0, Op1,
I)) {
482 I.setHasNoUnsignedWrap(
true);
485 return Changed ? &
I :
nullptr;
490 assert((Opcode == Instruction::FMul || Opcode == Instruction::FDiv) &&
491 "Expected fmul or fdiv");
493 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
509 (Op0->
hasOneUse() || Op1->hasOneUse())) {
523 I.getFastMathFlags(),
546 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
553 {
I.getType()}, {Op1, Op0}, &
I);
568 if (
I.hasAllowReassoc()) {
601 Instruction::FMul,
C, C1,
DL)) {
609 Instruction::FMul,
C, C1,
DL)) {
640 if (
I.hasNoSignedZeros() &&
644 if (
I.hasNoSignedZeros() &&
651 if (
I.hasNoNaNs() &&
I.hasNoSignedZeros() && Op0 == Op1 &&
677 if (
I.isOnlyUserOfAnyOperand()) {
696 Y->getType() == Z->getType()) {
699 Intrinsic::powi, {
X->getType(), YZ->getType()}, {
X, YZ}, &
I);
744 Log2 = cast<IntrinsicInst>(Op0);
749 Log2 = cast<IntrinsicInst>(Op1);
763 Value *Start =
nullptr, *Step =
nullptr;
800 Value *SelectCond =
SI->getCondition();
807 while (BBI != BBFront) {
815 for (
Use &Op : BBI->operands()) {
819 }
else if (Op == SelectCond) {
829 if (&*BBI == SelectCond)
830 SelectCond =
nullptr;
833 if (!SelectCond && !
SI)
844 Product = IsSigned ? C1.
smul_ov(C2, Overflow) : C1.
umul_ov(C2, Overflow);
872 assert((
I.getOpcode() == Instruction::SDiv ||
873 I.getOpcode() == Instruction::UDiv) &&
874 "Expected integer divide");
876 bool IsSigned =
I.getOpcode() == Instruction::SDiv;
877 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
878 Type *Ty =
I.getType();
888 auto *
Mul = cast<OverflowingBinaryOperator>(Op0);
889 auto *Shl = cast<OverflowingBinaryOperator>(Op1);
890 bool HasNUW =
Mul->hasNoUnsignedWrap() && Shl->hasNoUnsignedWrap();
891 bool HasNSW =
Mul->hasNoSignedWrap() && Shl->hasNoSignedWrap();
894 if (!IsSigned && HasNUW)
895 Ret = BinaryOperator::CreateLShr(
Y, Z);
898 if (IsSigned && HasNSW && (Op0->
hasOneUse() || Op1->hasOneUse())) {
900 Ret = BinaryOperator::CreateSDiv(
Y, Shl);
908 auto *Shl0 = cast<OverflowingBinaryOperator>(Op0);
909 auto *Shl1 = cast<OverflowingBinaryOperator>(Op1);
915 ((Shl0->hasNoUnsignedWrap() && Shl1->hasNoUnsignedWrap()) ||
916 (Shl0->hasNoUnsignedWrap() && Shl0->hasNoSignedWrap() &&
917 Shl1->hasNoSignedWrap())))
918 Ret = BinaryOperator::CreateUDiv(
X,
Y);
922 if (IsSigned && Shl0->hasNoSignedWrap() && Shl1->hasNoSignedWrap() &&
923 Shl1->hasNoUnsignedWrap())
924 Ret = BinaryOperator::CreateSDiv(
X,
Y);
930 Ret->setIsExact(
I.isExact());
942 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
943 bool IsSigned =
I.getOpcode() == Instruction::SDiv;
944 Type *Ty =
I.getType();
984 if (
isMultiple(*C2, *C1, Quotient, IsSigned)) {
987 NewDiv->setIsExact(
I.isExact());
992 if (
isMultiple(*C1, *C2, Quotient, IsSigned)) {
995 auto *OBO = cast<OverflowingBinaryOperator>(Op0);
996 Mul->setHasNoUnsignedWrap(!IsSigned && OBO->hasNoUnsignedWrap());
997 Mul->setHasNoSignedWrap(OBO->hasNoSignedWrap());
1010 if (
isMultiple(*C2, C1Shifted, Quotient, IsSigned)) {
1013 BO->setIsExact(
I.isExact());
1018 if (
isMultiple(C1Shifted, *C2, Quotient, IsSigned)) {
1021 auto *OBO = cast<OverflowingBinaryOperator>(Op0);
1022 Mul->setHasNoUnsignedWrap(!IsSigned && OBO->hasNoUnsignedWrap());
1023 Mul->setHasNoSignedWrap(OBO->hasNoSignedWrap());
1041 return BinaryOperator::CreateNUWAdd(
X,
1087 bool HasNSW = cast<OverflowingBinaryOperator>(Op1)->hasNoSignedWrap();
1088 bool HasNUW = cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap();
1089 if ((IsSigned && HasNSW) || (!IsSigned && HasNUW)) {
1098 if (!IsSigned && Op1->hasOneUse() &&
1116 auto *InnerDiv = cast<PossiblyExactOperator>(Op0);
1117 auto *
Mul = cast<OverflowingBinaryOperator>(InnerDiv->getOperand(0));
1119 if (!IsSigned &&
Mul->hasNoUnsignedWrap())
1120 NewDiv = BinaryOperator::CreateUDiv(
X,
Y);
1121 else if (IsSigned &&
Mul->hasNoSignedWrap())
1122 NewDiv = BinaryOperator::CreateSDiv(
X,
Y);
1126 NewDiv->
setIsExact(
I.isExact() && InnerDiv->isExact());
1143 return reinterpret_cast<Value *
>(-1);
1151 return IfFold([&]() {
1167 return IfFold([&]() {
return Builder.CreateZExt(LogX, Op->getType()); });
1173 return IfFold([&]() {
return Builder.CreateAdd(LogX,
Y); });
1183 return IfFold([&]() {
1184 return Builder.CreateSelect(
SI->getOperand(0), LogX, LogY);
1189 auto *
MinMax = dyn_cast<MinMaxIntrinsic>(Op);
1193 return IfFold([&]() {
1194 return Builder.CreateBinaryIntrinsic(
1195 MinMax->getIntrinsicID(), LogX, LogY);
1208 Type *Ty =
I.getType();
1211 X->getType() ==
Y->getType() && (
N->hasOneUse() ||
D->hasOneUse())) {
1257 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1259 const APInt *C1, *C2;
1276 Type *Ty =
I.getType();
1299 return BinaryOperator::CreateUDiv(
B,
X);
1302 return BinaryOperator::CreateUDiv(
A,
X);
1310 if (
I.isExact() && cast<PossiblyExactOperator>(Op0)->isExact())
1337 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1338 Type *Ty =
I.getType();
1354 return BinaryOperator::CreateExactAShr(Op0,
C);
1360 return BinaryOperator::CreateExactAShr(Op0, ShAmt);
1430 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1,
I.getName());
1431 BO->setIsExact(
I.isExact());
1449 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1,
I.getName());
1450 BO->setIsExact(
I.isExact());
1476 Intrinsic::copysign, {
C->getType()},
1485 if (!(
C->hasExactInverseFP() || (
I.hasAllowReciprocal() &&
C->isNormalFP())))
1494 if (!RecipC || !RecipC->isNormalFP())
1514 if (!
I.hasAllowReassoc() || !
I.hasAllowReciprocal())
1539 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1540 auto *II = dyn_cast<IntrinsicInst>(Op1);
1541 if (!II || !II->hasOneUse() || !
I.hasAllowReassoc() ||
1542 !
I.hasAllowReciprocal())
1552 case Intrinsic::pow:
1553 Args.push_back(II->getArgOperand(0));
1554 Args.push_back(
Builder.CreateFNegFMF(II->getArgOperand(1), &
I));
1556 case Intrinsic::powi: {
1564 Args.push_back(II->getArgOperand(0));
1565 Args.push_back(
Builder.CreateNeg(II->getArgOperand(1)));
1566 Type *Tys[] = {
I.getType(), II->getArgOperand(1)->getType()};
1570 case Intrinsic::exp:
1571 case Intrinsic::exp2:
1572 Args.push_back(
Builder.CreateFNegFMF(II->getArgOperand(0), &
I));
1577 Value *Pow =
Builder.CreateIntrinsic(IID,
I.getType(), Args, &
I);
1585 I.getFastMathFlags(),
1604 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1605 if (isa<Constant>(Op0))
1610 if (isa<Constant>(Op1))
1615 if (
I.hasAllowReassoc() &&
I.hasAllowReciprocal()) {
1618 (!isa<Constant>(
Y) || !isa<Constant>(Op1))) {
1624 (!isa<Constant>(
Y) || !isa<Constant>(Op0))) {
1639 if (
I.hasAllowReassoc() && Op0->
hasOneUse() && Op1->hasOneUse()) {
1643 bool IsTan =
match(Op0, m_Intrinsic<Intrinsic::sin>(
m_Value(
X))) &&
1646 !IsTan &&
match(Op0, m_Intrinsic<Intrinsic::cos>(
m_Value(
X))) &&
1649 if ((IsTan || IsCot) &&
hasFloatFn(M, &
TLI,
I.getType(), LibFunc_tan,
1650 LibFunc_tanf, LibFunc_tanl)) {
1653 B.setFastMathFlags(
I.getFastMathFlags());
1655 cast<CallBase>(Op0)->getCalledFunction()->getAttributes();
1657 LibFunc_tanl,
B, Attrs);
1668 if (
I.hasNoNaNs() &&
I.hasAllowReassoc() &&
1677 if (
I.hasNoNaNs() &&
I.hasNoInfs() &&
1689 if (
I.hasAllowReassoc() &&
1704 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1), *
X;
1712 bool IsSRem =
I.getOpcode() == Instruction::SRem;
1719 bool BO0NoWrap = IsSRem ? BO0HasNSW : BO0HasNUW;
1721 APInt RemYZ = IsSRem ?
Y->srem(*Z) :
Y->urem(*Z);
1725 if (RemYZ.
isZero() && BO0NoWrap)
1731 bool BO1NoWrap = IsSRem ? BO1HasNSW : BO1HasNUW;
1735 if (RemYZ == *
Y && BO1NoWrap) {
1747 if (
Y->uge(*Z) && (IsSRem ? (BO0HasNSW && BO1HasNSW) : BO0HasNUW)) {
1766 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1786 if (isa<Constant>(Op1)) {
1787 if (
Instruction *Op0I = dyn_cast<Instruction>(Op0)) {
1791 }
else if (
auto *PN = dyn_cast<PHINode>(Op0I)) {
1792 const APInt *Op1Int;
1794 (
I.getOpcode() == Instruction::URem ||
1831 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1832 Type *Ty =
I.getType();
1838 return BinaryOperator::CreateAnd(Op0,
Add);
1892 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1911 return BinaryOperator::CreateURem(Op0, Op1,
I.getName());
1915 if (isa<ConstantVector>(Op1) || isa<ConstantDataVector>(Op1)) {
1917 unsigned VWidth = cast<FixedVectorType>(
C->getType())->getNumElements();
1919 bool hasNegative =
false;
1920 bool hasMissing =
false;
1921 for (
unsigned i = 0; i != VWidth; ++i) {
1922 Constant *Elt =
C->getAggregateElement(i);
1929 if (
RHS->isNegative())
1933 if (hasNegative && !hasMissing) {
1935 for (
unsigned i = 0; i != VWidth; ++i) {
1936 Elts[i] =
C->getAggregateElement(i);
1938 if (
RHS->isNegative())
1954 I.getFastMathFlags(),
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file implements a class to represent arbitrary precision integral constant values and operations...
SmallVector< MachineOperand, 4 > Cond
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
This file provides internal interfaces used to implement the InstCombine.
static Value * takeLog2(IRBuilderBase &Builder, Value *Op, unsigned Depth, bool DoFold)
static Instruction * simplifyIRemMulShl(BinaryOperator &I, InstCombinerImpl &IC)
static Value * simplifyValueKnownNonZero(Value *V, InstCombinerImpl &IC, Instruction &CxtI)
The specific integer value is used in a context where it is known to be non-zero.
static Instruction * narrowUDivURem(BinaryOperator &I, InstCombiner::BuilderTy &Builder)
If we have zero-extended operands of an unsigned div or rem, we may be able to narrow the operation (...
static const unsigned MaxDepth
static Instruction * foldIDivShl(BinaryOperator &I, InstCombiner::BuilderTy &Builder)
static Value * foldMulSelectToNegate(BinaryOperator &I, InstCombiner::BuilderTy &Builder)
static Instruction * foldFDivPowDivisor(BinaryOperator &I, InstCombiner::BuilderTy &Builder)
Negate the exponent of pow/exp to fold division-by-pow() into multiply.
static bool multiplyOverflows(const APInt &C1, const APInt &C2, APInt &Product, bool IsSigned)
True if the multiply can not be expressed in an int this size.
static Value * foldMulShl1(BinaryOperator &Mul, bool CommuteOperands, InstCombiner::BuilderTy &Builder)
Reduce integer multiplication patterns that contain a (+/-1 << Z) factor.
static bool isMultiple(const APInt &C1, const APInt &C2, APInt &Quotient, bool IsSigned)
True if C1 is a multiple of C2. Quotient contains C1/C2.
static Instruction * foldFDivConstantDividend(BinaryOperator &I)
Remove negation and try to reassociate constant math.
This file provides the interface for the instcombine pass implementation.
static bool hasNoSignedWrap(BinaryOperator &I)
static bool hasNoUnsignedWrap(BinaryOperator &I)
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
Class for arbitrary precision integers.
APInt umul_ov(const APInt &RHS, bool &Overflow) const
APInt udiv(const APInt &RHS) const
Unsigned division operation.
static void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
Dual division/remainder interface.
static APInt getSignMask(unsigned BitWidth)
Get the SignMask for a specific bit width.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
static void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
bool isMinValue() const
Determine if this is the smallest unsigned value.
unsigned countr_zero() const
Count the number of trailing zero bits.
APInt ushl_ov(const APInt &Amt, bool &Overflow) const
unsigned getSignificantBits() const
Get the minimum bit size for this signed APInt.
APInt smul_ov(const APInt &RHS, bool &Overflow) const
static APInt getOneBitSet(unsigned numBits, unsigned BitNo)
Return an APInt with exactly one bit set in the result.
InstListType::iterator iterator
Instruction iterators...
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
static BinaryOperator * CreateFDivFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
static BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
BinaryOps getOpcode() const
static BinaryOperator * CreateNSWNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
static BinaryOperator * CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, Instruction *CopyO, const Twine &Name="", Instruction *InsertBefore=nullptr)
static BinaryOperator * CreateFMulFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
static BinaryOperator * CreateFSubFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
static BinaryOperator * CreateFAddFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
This class represents a function call, abstracting a target machine's calling convention.
static CastInst * CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a ZExt or BitCast cast instruction.
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
@ ICMP_ULT
unsigned less than
static Constant * getZExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getShl(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getExactLogBase2(Constant *C)
If C is a scalar/fixed width vector of known powers of 2, then this function returns a new scalar/fix...
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
static Constant * getInfinity(Type *Ty, bool Negative=false)
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
static ConstantInt * getFalse(LLVMContext &Context)
static ConstantInt * getBool(LLVMContext &Context, bool V)
static Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
static Constant * getAllOnesValue(Type *Ty)
bool isNormalFP() const
Return true if this is a normal (as opposed to denormal, infinity, nan, or zero) floating-point scala...
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
bool isNotMinSignedValue() const
Return true if the value is not the smallest signed value, or, for vectors, does not contain smallest...
A parsed version of the target data layout string in and methods for querying it.
Common base class shared among various IRBuilders.
Value * CreateFAddFMF(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 * 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 * CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateSRem(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateFMulFMF(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 * CreateFreeze(Value *V, const Twine &Name="")
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateIsNotNeg(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg > -1.
void setFastMathFlags(FastMathFlags NewFMF)
Set the fast-math flags to be used with generated fp-math operators.
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateIsNeg(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg < 0.
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
CallInst * 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 * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateSDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateAShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateMul(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Instruction * visitMul(BinaryOperator &I)
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 * foldBinOpIntoSelectOrPhi(BinaryOperator &I)
This is a convenience wrapper function for the above two functions.
Instruction * visitUDiv(BinaryOperator &I)
bool SimplifyAssociativeOrCommutative(BinaryOperator &I)
Performs a few simplifications for operators which are associative or commutative.
Value * foldUsingDistributiveLaws(BinaryOperator &I)
Tries to simplify binary operations which some other binary operation distributes over.
Instruction * visitURem(BinaryOperator &I)
Instruction * foldOpIntoPhi(Instruction &I, PHINode *PN)
Given a binary operator, cast instruction, or select which has a PHI node as operand #0,...
Instruction * visitSRem(BinaryOperator &I)
Instruction * visitFDiv(BinaryOperator &I)
bool simplifyDivRemOfSelectWithZeroOp(BinaryOperator &I)
Fold a divide or remainder with a select instruction divisor when one of the select operands is zero.
Instruction * commonIDivTransforms(BinaryOperator &I)
This function implements the transforms common to both integer division instructions (udiv and sdiv).
Instruction * foldBinopWithPhiOperands(BinaryOperator &BO)
For a binary operator with 2 phi operands, try to hoist the binary operation before the phi.
Instruction * visitFRem(BinaryOperator &I)
bool SimplifyDemandedInstructionBits(Instruction &Inst)
Tries to simplify operands to an integer instruction based on its demanded bits.
Instruction * visitFMul(BinaryOperator &I)
Instruction * foldVectorBinop(BinaryOperator &Inst)
Canonicalize the position of binops relative to shufflevector.
Value * SimplifySelectsFeedingBinaryOp(BinaryOperator &I, Value *LHS, Value *RHS)
Instruction * visitSDiv(BinaryOperator &I)
Instruction * commonIRemTransforms(BinaryOperator &I)
This function implements the transforms common to both integer remainder instructions (urem and srem)...
bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero=false, unsigned Depth=0, const Instruction *CxtI=nullptr)
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.
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
bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth=0, const Instruction *CxtI=nullptr) const
void push(Instruction *I)
Push the instruction onto the worklist stack.
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag.
bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag.
bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag.
A wrapper class for inspecting calls to intrinsic functions.
A Module instance is used to store all the information related to an LLVM module.
static Value * Negate(bool LHSIsZero, Value *Root, InstCombinerImpl &IC)
Attempt to negate Root.
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property.
bool hasNoUnsignedWrap() const
Test whether this operation is known to never undergo unsigned overflow, aka the nuw property.
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="", Instruction *InsertBefore=nullptr, Instruction *MDFrom=nullptr)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static UnaryOperator * CreateFNegFMF(Value *Op, Instruction *FMFSource, const Twine &Name="", Instruction *InsertBefore=nullptr)
A Use represents the edge between a Value definition and its users.
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.
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
This class represents zero extension of integer types.
An efficient, type-erasing, non-owning reference to a callable.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
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.
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
BinaryOp_match< LHS, RHS, Instruction::FMul, true > m_c_FMul(const LHS &L, const RHS &R)
Matches FMul with LHS and RHS in either order.
cst_pred_ty< is_sign_mask > m_SignMask()
Match an integer or vector with only the sign bit(s) set.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
apint_match m_APIntAllowUndef(const APInt *&Res)
Match APInt while allowing undefs in splat vector constants.
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
CastClass_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
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.
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
m_Intrinsic_Ty< Opnd0 >::Ty m_Sqrt(const Opnd0 &Op0)
BinaryOp_match< LHS, RHS, Instruction::FAdd > m_FAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
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()...
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'.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
cst_pred_ty< is_negated_power2 > m_NegatedPower2()
Match a integer or vector negated power-of-2.
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > > m_ZExtOrSExt(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
specific_intval< true > m_SpecificIntAllowUndef(APInt V)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
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'.
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)
BinaryOp_match< LHS, RHS, Instruction::FDiv > m_FDiv(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
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.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
This is an optimization pass for GlobalISel generic memory operations.
Value * emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Emit a call to the unary function named 'Name' (e.g.
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.
Value * simplifySDivInst(Value *LHS, Value *RHS, bool IsExact, const SimplifyQuery &Q)
Given operands for an SDiv, fold the result or return null.
Value * simplifyMulInst(Value *LHS, Value *RHS, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for a Mul, fold the result or return null.
bool hasFloatFn(const Module *M, const TargetLibraryInfo *TLI, Type *Ty, LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn)
Check whether the overloaded floating point function corresponding to Ty is available.
bool matchSimpleRecurrence(const PHINode *P, BinaryOperator *&BO, Value *&Start, Value *&Step)
Attempt to match a simple first order recurrence cycle of the form: iv = phi Ty [Start,...
Constant * ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, const DataLayout &DL)
Attempt to constant fold a unary operation with the specified operand.
SelectPatternFlavor
Specific patterns of select instructions we can match.
@ SPF_ABS
Floating point maxnum.
@ SPF_NABS
Absolute value.
Value * simplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FRem, fold the result or return null.
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...
Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
Value * simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an ICmpInst, fold the result or return null.
Value * simplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FDiv, fold the result or return null.
bool haveNoCommonBitsSet(const Value *LHS, const Value *RHS, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if LHS and RHS have no common bits set.
@ Mul
Product of integers.
@ And
Bitwise or logical AND of integers.
Value * simplifyUDivInst(Value *LHS, Value *RHS, bool IsExact, const SimplifyQuery &Q)
Given operands for a UDiv, fold the result or return null.
constexpr unsigned BitWidth
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
bool isKnownNonNegative(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Returns true if the give value is known to be non-negative.
Value * simplifySRemInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an SRem, fold the result or return null.
unsigned Log2(Align A)
Returns the log2 of the alignment.
Value * simplifyURemInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a URem, fold the result or return null.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
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.
SelectPatternFlavor Flavor
SimplifyQuery getWithInstruction(Instruction *I) const