Lines Matching defs:Op0
196 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
198 simplifyMulInst(Op0, Op1, I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
221 return HasNSW ? BinaryOperator::CreateNSWNeg(Op0)
222 : BinaryOperator::CreateNeg(Op0);
264 if (Op0->hasOneUse() && match(Op1, m_NegatedPower2())) {
268 Negator::Negate(/*IsNegation*/ true, HasNSW, Op0, *this)) {
284 if (match(Op0, m_ZExtOrSExt(m_Value(X))) &&
309 if (match(Op0, m_OneUse(m_AddLike(m_Value(X), m_ImmConstant(C1))))) {
312 auto *BOp0 = cast<BinaryOperator>(Op0);
329 if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(X))))
336 match(Op0,
348 if (match(Op0, m_Neg(m_Value(X))) && match(Op1, m_Constant(Op1C)))
352 if (match(Op0, m_Neg(m_Value(X))) && match(Op1, m_Neg(m_Value(Y)))) {
354 if (HasNSW && cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap() &&
368 if (Value *NegOp0 = Negator::Negate(false, /*IsNSW*/ false, Op0, *this))
372 if (Op0->hasOneUse()) {
384 (match(Op0, m_Exact(m_UDiv(m_Value(X), m_CheckedInt(UDivCheck)))) ||
385 match(Op0, m_Exact(m_SDiv(m_Value(X), m_CheckedInt(SDivCheck)))))) {
386 auto BOpc = cast<BinaryOperator>(Op0)->getOpcode();
389 Builder.CreateBinOp(BOpc, cast<BinaryOperator>(Op0)->getOperand(1),
398 BinaryOperator *Div = dyn_cast<BinaryOperator>(Op0);
401 Y = Op0;
437 (match(Op0, m_And(m_Value(), m_One())) &&
439 return BinaryOperator::CreateAnd(Op0, Op1);
449 if (((match(Op0, m_ZExt(m_Value(X))) && match(Op1, m_ZExt(m_Value(Y)))) ||
450 (match(Op0, m_SExt(m_Value(X))) && match(Op1, m_SExt(m_Value(Y))))) &&
452 (Op0->hasOneUse() || Op1->hasOneUse() || X == Y)) {
459 if (((match(Op0, m_SExt(m_Value(X))) && match(Op1, m_ZExt(m_Value(Y)))) ||
460 (match(Op0, m_ZExt(m_Value(X))) && match(Op1, m_SExt(m_Value(Y))))) &&
462 (Op0->hasOneUse() || Op1->hasOneUse())) {
469 if (match(Op0, m_ZExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1))
472 return SelectInst::Create(X, Op0, ConstantInt::getNullValue(Ty));
479 ConstantInt::getNullValue(Op0->getType()));
484 if (match(Op0, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
491 if (match(Op0, m_OneUse(m_AShr(m_Value(X), m_APInt(C)))) &&
533 // (mul Op0 Op1):
534 // if Log2(Op0) folds away ->
535 // (shl Op1, Log2(Op0))
537 // (shl Op0, Log2(Op1))
538 if (takeLog2(Builder, Op0, /*Depth*/ 0, /*AssumeNonZero*/ false,
540 Value *Res = takeLog2(Builder, Op0, /*Depth*/ 0, /*AssumeNonZero*/ false,
551 BinaryOperator *Shl = BinaryOperator::CreateShl(Op0, Res);
558 if (!HasNSW && willNotOverflowSignedMul(Op0, Op1, I)) {
563 if (!HasNUW && willNotOverflowUnsignedMul(Op0, Op1, I, I.hasNoSignedWrap())) {
576 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
581 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_FNeg(m_Value(Y))))
586 if (Op0 == Op1 && match(Op0, m_FAbs(m_Value(X))))
591 if (match(Op0, m_FAbs(m_Value(X))) && match(Op1, m_FAbs(m_Value(Y))) &&
592 (Op0->hasOneUse() || Op1->hasOneUse())) {
633 Value *Op0 = I.getOperand(0);
636 match(Op0, m_AllowReassoc(
650 if (match(Op0, m_OneUse(m_AllowReassoc(m_Intrinsic<Intrinsic::powi>(
662 if (match(Op0, m_OneUse(m_AllowReassoc(m_Intrinsic<Intrinsic::powi>(
676 Value *Op0 = I.getOperand(0);
685 match(Op0, m_AllowReassoc(m_BinOp(Op0BinOp)))) {
686 // Everything in this scope folds I with Op0, intersecting their FMF.
691 if (match(Op0, m_OneUse(m_FDiv(m_Constant(C1), m_Value(X))))) {
698 if (match(Op0, m_FDiv(m_Value(X), m_Constant(C1)))) {
710 if (C1DivC && Op0->hasOneUse() && C1DivC->isNormalFP())
717 if (match(Op0, m_OneUse(m_FAdd(m_Value(X), m_Constant(C1))))) {
725 if (match(Op0, m_OneUse(m_FSub(m_Constant(C1), m_Value(X))))) {
739 BinaryOperator *DivOp = cast<BinaryOperator>(((Z == Op0) ? Op1 : Op0));
753 if (I.hasNoNaNs() && match(Op0, m_OneUse(m_Sqrt(m_Value(X)))) &&
767 match(Op0, (m_FDiv(m_SpecificFP(1.0), m_Value(Y)))) &&
772 match(Y, m_Sqrt(m_Value(X))) && Op0 == X)
777 if (I.hasNoNaNs() && I.hasNoSignedZeros() && Op0 == Op1 && Op0->hasNUses(2)) {
780 if (match(Op0, m_FDiv(m_Value(X), m_Sqrt(m_Value(Y))))) {
785 if (match(Op0, m_FDiv(m_Sqrt(m_Value(Y)), m_Value(X)))) {
806 if (match(Op0, m_Intrinsic<Intrinsic::pow>(m_Value(X), m_Value(Y))) &&
813 if (match(Op0, m_Intrinsic<Intrinsic::pow>(m_Value(X), m_Value(Y))) &&
821 if (match(Op0, m_Intrinsic<Intrinsic::exp>(m_Value(X))) &&
829 if (match(Op0, m_Intrinsic<Intrinsic::exp2>(m_Value(X))) &&
844 if (match(Op0, m_OneUse(m_c_FMul(m_Specific(Op1), m_Value(Y)))) && Op1 != Y) {
848 if (match(Op1, m_OneUse(m_c_FMul(m_Specific(Op0), m_Value(Y)))) && Op0 != Y) {
849 Value *XX = Builder.CreateFMulFMF(Op0, Op0, &I);
884 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
886 return UnaryOperator::CreateFNegFMF(Op0, &I);
894 isKnownNeverNaN(Op0, /*Depth=*/0, SQ.getWithInstruction(&I))) ||
897 Op0 = Builder.CreateFNegFMF(Op0, &I);
899 {I.getType()}, {Op1, Op0}, &I);
906 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_Constant(C)))
914 if (match(Op0, m_UIToFP(m_Value(X))) &&
922 auto *SI = SelectInst::Create(X, Op0, ConstantFP::get(I.getType(), 0.0));
929 if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))
939 if (match(Op0, m_OneUse(m_Intrinsic<Intrinsic::log2>(
941 Log2 = cast<IntrinsicInst>(Op0);
947 Y = Op0;
1087 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1095 match(Op0, m_c_Mul(m_Specific(X), m_Value(Y)))) {
1097 auto *Mul = cast<OverflowingBinaryOperator>(Op0);
1107 if (IsSigned && HasNSW && (Op0->hasOneUse() || Op1->hasOneUse())) {
1115 if (match(Op0, m_Shl(m_Value(X), m_Value(Z))) &&
1117 auto *Shl0 = cast<OverflowingBinaryOperator>(Op0);
1138 if (match(Op0, m_Shl(m_Value(X), m_Value(Y))) &&
1140 auto *Shl0 = cast<OverflowingBinaryOperator>(Op0);
1169 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1185 if (match(Op0, m_ImmConstant()) &&
1198 if ((IsSigned && match(Op0, m_SDiv(m_Value(X), m_APInt(C1)))) ||
1199 (!IsSigned && match(Op0, m_UDiv(m_Value(X), m_APInt(C1))))) {
1207 if ((IsSigned && match(Op0, m_NSWMul(m_Value(X), m_APInt(C1)))) ||
1208 (!IsSigned && match(Op0, m_NUWMul(m_Value(X), m_APInt(C1))))) {
1222 auto *OBO = cast<OverflowingBinaryOperator>(Op0);
1229 if ((IsSigned && match(Op0, m_NSWShl(m_Value(X), m_APInt(C1))) &&
1231 (!IsSigned && match(Op0, m_NUWShl(m_Value(X), m_APInt(C1))) &&
1248 auto *OBO = cast<OverflowingBinaryOperator>(Op0);
1260 match(Op0, m_NSWAddLike(m_NSWMul(m_Value(X), m_SpecificInt(*C2)),
1266 match(Op0, m_NUWAddLike(m_NUWMul(m_Value(X), m_SpecificInt(*C2)),
1277 if (match(Op0, m_One())) {
1286 Value *Inc = Builder.CreateAdd(F1, Op0);
1292 return new ZExtInst(Builder.CreateICmpEQ(Op1, Op0), Ty);
1302 if (match(Op0, m_Sub(m_Value(X), m_Value(Z)))) // (X - Z) / Y; Y = Op1
1309 if (IsSigned && match(Op0, m_NSWShl(m_Specific(Op1), m_Value(Y))))
1311 if (!IsSigned && match(Op0, m_NUWShl(m_Specific(Op1), m_Value(Y))))
1315 if (match(Op1, m_c_Mul(m_Specific(Op0), m_Value(Y)))) {
1328 match(Op0, m_NUWShl(m_Value(X), m_Value(Z))) &&
1343 if (match(Op0, m_BinOp(I.getOpcode(), m_c_Mul(m_Specific(Op1), m_Value(X)),
1345 auto *InnerDiv = cast<PossiblyExactOperator>(Op0);
1361 if (match(Op0, m_Mul(m_Value(X), m_Value(Y)))) {
1362 auto OB0HasNSW = cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap();
1363 auto OB0HasNUW = cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap();
1526 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1529 if (match(Op0, m_LShr(m_Value(X), m_APInt(C1))) && match(Op1, m_APInt(C2))) {
1534 bool IsExact = I.isExact() && match(Op0, m_Exact(m_Value()));
1543 // Op0 / C where C is large (negative) --> zext (Op0 >= C)
1547 Value *Cmp = Builder.CreateICmpUGE(Op0, Op1);
1550 // Op0 / (sext i1 X) --> zext (Op0 == -1) (if X is 0, the div is undefined)
1552 Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnesValue(Ty));
1563 if (match(Op0, m_LShr(m_NUWMul(m_Specific(Op1), m_Value(A)), m_Value(B))) ||
1564 match(Op0, m_LShr(m_NUWMul(m_Value(A), m_Specific(Op1)), m_Value(B)))) {
1566 if (I.isExact() && cast<PossiblyExactOperator>(Op0)->isExact())
1577 I, Builder.CreateLShr(Op0, Res, I.getName(), I.isExact()));
1595 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1598 // sdiv Op0, -1 --> -Op0
1599 // sdiv Op0, (sext i1 X) --> -Op0 (because if X is 0, the op is undefined)
1602 return BinaryOperator::CreateNSWNeg(Op0);
1606 return new ZExtInst(Builder.CreateICmpEQ(Op0, Op1), Ty);
1612 return BinaryOperator::CreateExactAShr(Op0, C);
1618 return BinaryOperator::CreateExactAShr(Op0, ShAmt);
1624 Value *Ashr = Builder.CreateAShr(Op0, C, I.getName() + ".neg", true);
1635 if (match(Op0, m_OneUse(m_SExt(m_Value(Op0Src)))) &&
1652 if (!Op1C->isMinSignedValue() && match(Op0, m_NSWNeg(m_Value(X)))) {
1676 KnownBits KnownDividend = computeKnownBits(Op0, 0, &I);
1687 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1, I.getName());
1697 Value *Shr = Builder.CreateLShr(Op0, CNegLog2, I.getName(), I.isExact());
1706 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1, I.getName());
1713 if (isKnownNegation(Op0, Op1)) {
1715 Value *Cond = Builder.CreateICmpEQ(Op0, ConstantInt::get(Ty, MinVal));
1805 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1834 return BinaryOperator::CreateFMulFMF(Op0, Pow, &I);
1844 return BinaryOperator::CreateFMulFMF(Op0, Pow, &I);
1854 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1872 return BinaryOperator::CreateFMulFMF(Op0, NewSqrt, &I);
1898 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1899 if (isa<Constant>(Op0))
1905 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
1911 if (match(Op0, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
1918 (!isa<Constant>(Y) || !isa<Constant>(Op0))) {
1920 Value *YZ = Builder.CreateFMulFMF(Y, Op0, &I);
1930 return BinaryOperator::CreateFMulFMF(Y, Op0, &I);
1933 if (I.hasAllowReassoc() && Op0->hasOneUse() && Op1->hasOneUse()) {
1937 bool IsTan = match(Op0, m_Intrinsic<Intrinsic::sin>(m_Value(X))) &&
1940 !IsTan && match(Op0, m_Intrinsic<Intrinsic::cos>(m_Value(X))) &&
1949 cast<CallBase>(Op0)->getCalledFunction()->getAttributes();
1963 match(Op1, m_c_FMul(m_Specific(Op0), m_Value(Y)))) {
1987 match(Op0, m_OneUse(m_Intrinsic<Intrinsic::pow>(m_Specific(Op1),
2009 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *X = nullptr;
2043 if (MatchShiftOrMulXC(Op0, X, Y) && MatchShiftOrMulXC(Op1, X, Z)) {
2045 } else if (MatchShiftCX(Op0, Y, X) && MatchShiftCX(Op1, Z, X)) {
2053 OverflowingBinaryOperator *BO0 = cast<OverflowingBinaryOperator>(Op0);
2068 // (RemSimplificationC * X) depending on whether we matched Op0/Op1 as
2087 // Copy any overflow flags from Op0.
2114 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2127 if (match(Op0, m_ImmConstant()) &&
2135 if (Instruction *Op0I = dyn_cast<Instruction>(Op0)) {
2179 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2186 return BinaryOperator::CreateAnd(Op0, Add);
2190 if (match(Op0, m_One())) {
2195 // Op0 urem C -> Op0 < C ? Op0 : Op0 - C, where C >= signbit.
2196 // Op0 must be frozen because we are increasing its number of uses.
2198 Value *F0 = Op0;
2199 if (!isGuaranteedNotToBeUndef(Op0))
2200 F0 = Builder.CreateFreeze(Op0, Op0->getName() + ".fr");
2207 // unsigned value (-1). Therefore, the remainder is Op0 unless Op0 is also
2209 // urem Op0, (sext i1 X) --> (Op0 == -1) ? 0 : Op0
2212 Value *FrozenOp0 = Op0;
2213 if (!isGuaranteedNotToBeUndef(Op0))
2214 FrozenOp0 = Builder.CreateFreeze(Op0, Op0->getName() + ".frozen");
2221 if (match(Op0, m_Add(m_Value(X), m_One()))) {
2225 Value *FrozenOp0 = Op0;
2226 if (!isGuaranteedNotToBeUndef(Op0))
2227 FrozenOp0 = Builder.CreateFreeze(Op0, Op0->getName() + ".frozen");
2248 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2265 MaskedValueIsZero(Op0, Mask, 0, &I)) {
2267 return BinaryOperator::CreateURem(Op0, Op1, I.getName());