Lines Matching defs:Op0
190 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
192 simplifyMulInst(Op0, Op1, I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
215 return HasNSW ? BinaryOperator::CreateNSWNeg(Op0)
216 : BinaryOperator::CreateNeg(Op0);
258 if (Op0->hasOneUse() && match(Op1, m_NegatedPower2())) {
262 Negator::Negate(/*IsNegation*/ true, HasNSW, Op0, *this)) {
278 if (match(Op0, m_ZExtOrSExt(m_Value(X))) &&
303 if (match(Op0, m_OneUse(m_AddLike(m_Value(X), m_ImmConstant(C1))))) {
306 auto *BOp0 = cast<BinaryOperator>(Op0);
323 if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(X))))
330 match(Op0,
342 if (match(Op0, m_Neg(m_Value(X))) && match(Op1, m_Constant(Op1C)))
346 if (match(Op0, m_Neg(m_Value(X))) && match(Op1, m_Neg(m_Value(Y)))) {
348 if (HasNSW && cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap() &&
362 if (Value *NegOp0 = Negator::Negate(false, /*IsNSW*/ false, Op0, *this))
366 if (Op0->hasOneUse()) {
378 (match(Op0, m_Exact(m_UDiv(m_Value(X), m_CheckedInt(UDivCheck)))) ||
379 match(Op0, m_Exact(m_SDiv(m_Value(X), m_CheckedInt(SDivCheck)))))) {
380 auto BOpc = cast<BinaryOperator>(Op0)->getOpcode();
383 Builder.CreateBinOp(BOpc, cast<BinaryOperator>(Op0)->getOperand(1),
392 BinaryOperator *Div = dyn_cast<BinaryOperator>(Op0);
395 Y = Op0;
431 (match(Op0, m_And(m_Value(), m_One())) &&
433 return BinaryOperator::CreateAnd(Op0, Op1);
443 if (((match(Op0, m_ZExt(m_Value(X))) && match(Op1, m_ZExt(m_Value(Y)))) ||
444 (match(Op0, m_SExt(m_Value(X))) && match(Op1, m_SExt(m_Value(Y))))) &&
446 (Op0->hasOneUse() || Op1->hasOneUse() || X == Y)) {
453 if (((match(Op0, m_SExt(m_Value(X))) && match(Op1, m_ZExt(m_Value(Y)))) ||
454 (match(Op0, m_ZExt(m_Value(X))) && match(Op1, m_SExt(m_Value(Y))))) &&
456 (Op0->hasOneUse() || Op1->hasOneUse())) {
463 if (match(Op0, m_ZExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1))
466 return SelectInst::Create(X, Op0, ConstantInt::getNullValue(Ty));
473 ConstantInt::getNullValue(Op0->getType()));
478 if (match(Op0, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
485 if (match(Op0, m_OneUse(m_AShr(m_Value(X), m_APInt(C)))) &&
527 // (mul Op0 Op1):
528 // if Log2(Op0) folds away ->
529 // (shl Op1, Log2(Op0))
531 // (shl Op0, Log2(Op1))
532 if (Value *Res = tryGetLog2(Op0, /*AssumeNonZero=*/false)) {
539 BinaryOperator *Shl = BinaryOperator::CreateShl(Op0, Res);
546 if (!HasNSW && willNotOverflowSignedMul(Op0, Op1, I)) {
551 if (!HasNUW && willNotOverflowUnsignedMul(Op0, Op1, I, I.hasNoSignedWrap())) {
564 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
569 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_FNeg(m_Value(Y))))
574 if (Op0 == Op1 && match(Op0, m_FAbs(m_Value(X))))
579 if (match(Op0, m_FAbs(m_Value(X))) && match(Op1, m_FAbs(m_Value(Y))) &&
580 (Op0->hasOneUse() || Op1->hasOneUse())) {
619 Value *Op0 = I.getOperand(0);
622 match(Op0, m_AllowReassoc(
636 if (match(Op0, m_OneUse(m_AllowReassoc(m_Intrinsic<Intrinsic::powi>(
648 if (match(Op0, m_OneUse(m_AllowReassoc(m_Intrinsic<Intrinsic::powi>(
750 Value *Op0 = I.getOperand(0);
759 match(Op0, m_AllowReassoc(m_BinOp(Op0BinOp)))) {
760 // Everything in this scope folds I with Op0, intersecting their FMF.
763 if (match(Op0, m_OneUse(m_FDiv(m_Constant(C1), m_Value(X))))) {
770 if (match(Op0, m_FDiv(m_Value(X), m_Constant(C1)))) {
782 if (C1DivC && Op0->hasOneUse() && C1DivC->isNormalFP())
789 if (match(Op0, m_OneUse(m_FAdd(m_Value(X), m_Constant(C1))))) {
797 if (match(Op0, m_OneUse(m_FSub(m_Constant(C1), m_Value(X))))) {
811 BinaryOperator *DivOp = cast<BinaryOperator>(((Z == Op0) ? Op1 : Op0));
823 if (I.hasNoNaNs() && match(Op0, m_OneUse(m_Sqrt(m_Value(X)))) &&
837 match(Op0, (m_FDiv(m_SpecificFP(1.0), m_Value(Y)))) &&
842 match(Y, m_Sqrt(m_Value(X))) && Op0 == X)
847 if (I.hasNoNaNs() && I.hasNoSignedZeros() && Op0 == Op1 && Op0->hasNUses(2)) {
850 if (match(Op0, m_FDiv(m_Value(X), m_Sqrt(m_Value(Y))))) {
855 if (match(Op0, m_FDiv(m_Sqrt(m_Value(Y)), m_Value(X)))) {
876 if (match(Op0, m_Intrinsic<Intrinsic::pow>(m_Value(X), m_Value(Y))) &&
883 if (match(Op0, m_Intrinsic<Intrinsic::pow>(m_Value(X), m_Value(Y))) &&
891 if (match(Op0, m_Intrinsic<Intrinsic::exp>(m_Value(X))) &&
899 if (match(Op0, m_Intrinsic<Intrinsic::exp2>(m_Value(X))) &&
914 if (match(Op0, m_OneUse(m_c_FMul(m_Specific(Op1), m_Value(Y)))) && Op1 != Y) {
918 if (match(Op1, m_OneUse(m_c_FMul(m_Specific(Op0), m_Value(Y)))) && Op0 != Y) {
919 Value *XX = Builder.CreateFMulFMF(Op0, Op0, &I);
954 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
956 return UnaryOperator::CreateFNegFMF(Op0, &I);
964 isKnownNeverNaN(Op0, /*Depth=*/0, SQ.getWithInstruction(&I))) ||
967 Op0 = Builder.CreateFNegFMF(Op0, &I);
969 {I.getType()}, {Op1, Op0}, &I);
976 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_Constant(C)))
984 if (match(Op0, m_UIToFP(m_Value(X))) &&
992 auto *SI = SelectInst::Create(X, Op0, ConstantFP::get(I.getType(), 0.0));
999 if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))
1009 if (match(Op0, m_OneUse(m_Intrinsic<Intrinsic::log2>(
1011 Log2 = cast<IntrinsicInst>(Op0);
1017 Y = Op0;
1157 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1165 match(Op0, m_c_Mul(m_Specific(X), m_Value(Y)))) {
1167 auto *Mul = cast<OverflowingBinaryOperator>(Op0);
1177 if (IsSigned && HasNSW && (Op0->hasOneUse() || Op1->hasOneUse())) {
1185 if (match(Op0, m_Shl(m_Value(X), m_Value(Z))) &&
1187 auto *Shl0 = cast<OverflowingBinaryOperator>(Op0);
1208 if (match(Op0, m_Shl(m_Value(X), m_Value(Y))) &&
1210 auto *Shl0 = cast<OverflowingBinaryOperator>(Op0);
1234 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1265 if (match(Op0, m_ImmConstant()) &&
1283 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1293 if ((IsSigned && match(Op0, m_SDiv(m_Value(X), m_APInt(C1)))) ||
1294 (!IsSigned && match(Op0, m_UDiv(m_Value(X), m_APInt(C1))))) {
1302 if ((IsSigned && match(Op0, m_NSWMul(m_Value(X), m_APInt(C1)))) ||
1303 (!IsSigned && match(Op0, m_NUWMul(m_Value(X), m_APInt(C1))))) {
1317 auto *OBO = cast<OverflowingBinaryOperator>(Op0);
1324 if ((IsSigned && match(Op0, m_NSWShl(m_Value(X), m_APInt(C1))) &&
1326 (!IsSigned && match(Op0, m_NUWShl(m_Value(X), m_APInt(C1))) &&
1343 auto *OBO = cast<OverflowingBinaryOperator>(Op0);
1355 match(Op0, m_NSWAddLike(m_NSWMul(m_Value(X), m_SpecificInt(*C2)),
1361 match(Op0, m_NUWAddLike(m_NUWMul(m_Value(X), m_SpecificInt(*C2)),
1372 if (match(Op0, m_One())) {
1381 Value *Inc = Builder.CreateAdd(F1, Op0);
1387 return new ZExtInst(Builder.CreateICmpEQ(Op1, Op0), Ty);
1397 if (match(Op0, m_Sub(m_Value(X), m_Value(Z)))) // (X - Z) / Y; Y = Op1
1404 if (IsSigned && match(Op0, m_NSWShl(m_Specific(Op1), m_Value(Y))))
1406 if (!IsSigned && match(Op0, m_NUWShl(m_Specific(Op1), m_Value(Y))))
1410 if (match(Op1, m_c_Mul(m_Specific(Op0), m_Value(Y)))) {
1423 match(Op0, m_NUWShl(m_Value(X), m_Value(Z))) &&
1438 if (match(Op0, m_BinOp(I.getOpcode(), m_c_Mul(m_Specific(Op1), m_Value(X)),
1440 auto *InnerDiv = cast<PossiblyExactOperator>(Op0);
1456 if (match(Op0, m_Mul(m_Value(X), m_Value(Y)))) {
1457 auto OB0HasNSW = cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap();
1458 auto OB0HasNUW = cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap();
1645 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1648 if (match(Op0, m_LShr(m_Value(X), m_APInt(C1))) && match(Op1, m_APInt(C2))) {
1653 bool IsExact = I.isExact() && match(Op0, m_Exact(m_Value()));
1662 // Op0 / C where C is large (negative) --> zext (Op0 >= C)
1666 Value *Cmp = Builder.CreateICmpUGE(Op0, Op1);
1669 // Op0 / (sext i1 X) --> zext (Op0 == -1) (if X is 0, the div is undefined)
1671 Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnesValue(Ty));
1682 if (match(Op0, m_LShr(m_NUWMul(m_Specific(Op1), m_Value(A)), m_Value(B))) ||
1683 match(Op0, m_LShr(m_NUWMul(m_Value(A), m_Specific(Op1)), m_Value(B)))) {
1685 if (I.isExact() && cast<PossiblyExactOperator>(Op0)->isExact())
1691 // Op0 udiv Op1 -> Op0 lshr log2(Op1), if log2() folds away.
1695 // Op0 udiv Op1 -> Op0 lshr cttz(Op1), if Op1 is a power of 2.
1708 I, Builder.CreateLShr(Op0, Res, I.getName(), I.isExact()));
1725 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1728 // sdiv Op0, -1 --> -Op0
1729 // sdiv Op0, (sext i1 X) --> -Op0 (because if X is 0, the op is undefined)
1732 return BinaryOperator::CreateNSWNeg(Op0);
1736 return new ZExtInst(Builder.CreateICmpEQ(Op0, Op1), Ty);
1742 return BinaryOperator::CreateExactAShr(Op0, C);
1748 return BinaryOperator::CreateExactAShr(Op0, ShAmt);
1754 Value *Ashr = Builder.CreateAShr(Op0, C, I.getName() + ".neg", true);
1765 if (match(Op0, m_OneUse(m_SExt(m_Value(Op0Src)))) &&
1782 if (!Op1C->isMinSignedValue() && match(Op0, m_NSWNeg(m_Value(X)))) {
1806 KnownBits KnownDividend = computeKnownBits(Op0, 0, &I);
1817 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1, I.getName());
1827 Value *Shr = Builder.CreateLShr(Op0, CNegLog2, I.getName(), I.isExact());
1836 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1, I.getName());
1843 if (isKnownNegation(Op0, Op1)) {
1845 Value *Cond = Builder.CreateICmpEQ(Op0, ConstantInt::get(Ty, MinVal));
1935 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1964 return BinaryOperator::CreateFMulFMF(Op0, Pow, &I);
1974 return BinaryOperator::CreateFMulFMF(Op0, Pow, &I);
1984 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2002 return BinaryOperator::CreateFMulFMF(Op0, NewSqrt, &I);
2096 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2115 if (isa<Constant>(Op0))
2121 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
2127 if (match(Op0, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
2134 (!isa<Constant>(Y) || !isa<Constant>(Op0))) {
2136 Value *YZ = Builder.CreateFMulFMF(Y, Op0, &I);
2146 return BinaryOperator::CreateFMulFMF(Y, Op0, &I);
2149 if (I.hasAllowReassoc() && Op0->hasOneUse() && Op1->hasOneUse()) {
2153 bool IsTan = match(Op0, m_Intrinsic<Intrinsic::sin>(m_Value(X))) &&
2156 !IsTan && match(Op0, m_Intrinsic<Intrinsic::cos>(m_Value(X))) &&
2165 cast<CallBase>(Op0)->getCalledFunction()->getAttributes();
2179 match(Op1, m_c_FMul(m_Specific(Op0), m_Value(Y)))) {
2203 match(Op0, m_OneUse(m_Intrinsic<Intrinsic::pow>(m_Specific(Op1),
2225 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *X = nullptr;
2264 if (MatchShiftOrMulXC(Op0, X, Y, Op0PreserveNSW) &&
2267 } else if (MatchShiftCX(Op0, Y, X) && MatchShiftCX(Op1, Z, X)) {
2275 OverflowingBinaryOperator *BO0 = cast<OverflowingBinaryOperator>(Op0);
2290 // (RemSimplificationC * X) depending on whether we matched Op0/Op1 as
2309 // Copy any overflow flags from Op0.
2336 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2339 if (Instruction *Op0I = dyn_cast<Instruction>(Op0)) {
2383 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2390 return BinaryOperator::CreateAnd(Op0, Add);
2394 if (match(Op0, m_One())) {
2399 // Op0 urem C -> Op0 < C ? Op0 : Op0 - C, where C >= signbit.
2400 // Op0 must be frozen because we are increasing its number of uses.
2402 Value *F0 = Op0;
2403 if (!isGuaranteedNotToBeUndef(Op0))
2404 F0 = Builder.CreateFreeze(Op0, Op0->getName() + ".fr");
2411 // unsigned value (-1). Therefore, the remainder is Op0 unless Op0 is also
2413 // urem Op0, (sext i1 X) --> (Op0 == -1) ? 0 : Op0
2416 Value *FrozenOp0 = Op0;
2417 if (!isGuaranteedNotToBeUndef(Op0))
2418 FrozenOp0 = Builder.CreateFreeze(Op0, Op0->getName() + ".frozen");
2425 if (match(Op0, m_Add(m_Value(X), m_One()))) {
2429 Value *FrozenOp0 = Op0;
2430 if (!isGuaranteedNotToBeUndef(Op0))
2431 FrozenOp0 = Builder.CreateFreeze(Op0, Op0->getName() + ".frozen");
2452 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2469 MaskedValueIsZero(Op0, Mask, 0, &I)) {
2471 return BinaryOperator::CreateURem(Op0, Op1, I.getName());