Lines Matching defs:Op1
190 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
192 simplifyMulInst(Op0, Op1, I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
214 if (match(Op1, m_AllOnes())) {
258 if (Op0->hasOneUse() && match(Op1, m_NegatedPower2())) {
263 auto *Op1C = cast<Constant>(Op1);
279 match(Op1, m_APIntAllowPoison(NegPow2C))) {
298 if (match(Op1, m_ImmConstant(MulC))) {
323 if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(X))))
332 match(Op1, m_OneUse(m_Intrinsic<Intrinsic::abs>(m_Value(Y), m_One()))))
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)))) {
349 cast<OverflowingBinaryOperator>(Op1)->hasNoSignedWrap())
361 if (match(Op1, m_Neg(m_Value(X)))) {
377 if (match(Op1, m_APInt(C1)) &&
384 Op1));
391 Value *Y = Op1;
396 Div = dyn_cast<BinaryOperator>(Op1);
432 match(Op1, 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())) {
464 return SelectInst::Create(X, Op1, ConstantInt::getNullValue(Ty));
465 if (match(Op1, m_ZExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1))
476 if (match(Op1, m_ImmConstant(ImmC))) {
527 // (mul Op0 Op1):
529 // (shl Op1, Log2(Op0))
530 // if Log2(Op1) folds away ->
531 // (shl Op0, Log2(Op1))
533 BinaryOperator *Shl = BinaryOperator::CreateShl(Op1, Res);
538 if (Value *Res = tryGetLog2(Op1, /*AssumeNonZero=*/false)) {
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())) {
620 Value *Op1 = I.getOperand(1);
624 match(Op1, m_AllowReassoc(m_Intrinsic<Intrinsic::powi>(m_Specific(X),
637 m_Specific(Op1), m_Value(Y))))) &&
640 Instruction *NewPow = createPowiExpr(I, *this, Op1, Y, NegOne);
650 match(Op1, m_AllowReassoc(m_c_FMul(m_Specific(X), m_Value(Z)))) &&
751 Value *Op1 = I.getOperand(1);
758 if (match(Op1, m_Constant(C)) && C->isFiniteNonZeroFP() &&
811 BinaryOperator *DivOp = cast<BinaryOperator>(((Z == Op0) ? Op1 : Op0));
824 match(Op1, m_OneUse(m_Sqrt(m_Value(Y))))) {
838 match(Y, m_Sqrt(m_Value(X))) && Op1 == X)
841 match(Op1, (m_FDiv(m_SpecificFP(1.0), m_Value(Y)))) &&
847 if (I.hasNoNaNs() && I.hasNoSignedZeros() && Op0 == Op1 && Op0->hasNUses(2)) {
877 match(Op1, m_Intrinsic<Intrinsic::pow>(m_Specific(X), m_Value(Z)))) {
884 match(Op1, m_Intrinsic<Intrinsic::pow>(m_Value(Z), m_Specific(Y)))) {
892 match(Op1, m_Intrinsic<Intrinsic::exp>(m_Value(Y)))) {
900 match(Op1, m_Intrinsic<Intrinsic::exp2>(m_Value(Y)))) {
914 if (match(Op0, m_OneUse(m_c_FMul(m_Specific(Op1), m_Value(Y)))) && Op1 != Y) {
915 Value *XX = Builder.CreateFMulFMF(Op1, Op1, &I);
918 if (match(Op1, m_OneUse(m_c_FMul(m_Specific(Op0), m_Value(Y)))) && Op0 != Y) {
954 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
955 if (match(Op1, m_SpecificFP(-1.0)))
962 if (match(Op1, m_APFloatAllowPoison(FPC)) && FPC->isZero() &&
969 {I.getType()}, {Op1, Op0}, &I);
976 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_Constant(C)))
986 auto *SI = SelectInst::Create(X, Op1, ConstantFP::get(I.getType(), 0.0));
990 if (match(Op1, m_UIToFP(m_Value(X))) &&
999 if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))
1012 Y = Op1;
1014 if (match(Op1, m_OneUse(m_Intrinsic<Intrinsic::log2>(
1016 Log2 = cast<IntrinsicInst>(Op1);
1157 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1164 if (match(Op1, m_Shl(m_Value(X), m_Value(Z))) &&
1168 auto *Shl = cast<OverflowingBinaryOperator>(Op1);
1177 if (IsSigned && HasNSW && (Op0->hasOneUse() || Op1->hasOneUse())) {
1186 match(Op1, m_Shl(m_Value(Y), m_Specific(Z)))) {
1188 auto *Shl1 = cast<OverflowingBinaryOperator>(Op1);
1209 match(Op1, m_Shl(m_Specific(X), m_Value(Z)))) {
1211 auto *Shl1 = cast<OverflowingBinaryOperator>(Op1);
1234 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1238 auto *Op1C = dyn_cast<Constant>(Op1);
1266 match(Op1, m_Select(m_Value(), m_ImmConstant(), m_ImmConstant()))) {
1267 if (Instruction *R = FoldOpIntoSelect(I, cast<SelectInst>(Op1),
1283 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1288 if (match(Op1, m_APInt(C2))) {
1376 // (Op1 + 1) u< 3 ? Op1 : 0
1377 // Op1 must be frozen because we are increasing its number of uses.
1378 Value *F1 = Op1;
1379 if (!isGuaranteedNotToBeUndef(Op1))
1380 F1 = Builder.CreateFreeze(Op1, Op1->getName() + ".fr");
1385 // If Op1 is 0 then it's undefined behaviour. If Op1 is 1 then the
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
1398 if ((IsSigned && match(Z, m_SRem(m_Specific(X), m_Specific(Op1)))) ||
1399 (!IsSigned && match(Z, m_URem(m_Specific(X), m_Specific(Op1)))))
1400 return BinaryOperator::Create(I.getOpcode(), X, 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)))) {
1411 bool HasNSW = cast<OverflowingBinaryOperator>(Op1)->hasNoSignedWrap();
1412 bool HasNUW = cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap();
1422 if (!IsSigned && Op1->hasOneUse() &&
1424 match(Op1, m_c_Mul(m_Specific(X), m_Value(Y))))
1425 if (cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap()) {
1437 // ((Op1 * X) / Y) / Op1 --> X / Y
1438 if (match(Op0, m_BinOp(I.getOpcode(), m_c_Mul(m_Specific(Op1), m_Value(X)),
1461 auto OB1HasNSW = cast<OverflowingBinaryOperator>(Op1)->hasNoSignedWrap();
1463 cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap();
1478 if (match(Op1, m_c_Mul(m_Specific(X), m_Value(Z)))) {
1482 if (match(Op1, m_c_Mul(m_Specific(Y), m_Value(Z)))) {
1498 // FIXME: assert that Op1 isn't/doesn't contain undef.
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))) {
1665 if (match(Op1, m_Negative())) {
1666 Value *Cmp = Builder.CreateICmpUGE(Op0, Op1);
1670 if (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
1681 // ((Op1 *nuw A) >> B) / Op1 --> A >> B
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)))) {
1691 // Op0 udiv Op1 -> Op0 lshr log2(Op1), if log2() folds away.
1692 if (Value *Log2 = tryGetLog2(Op1, /*AssumeNonZero=*/true))
1695 // Op0 udiv Op1 -> Op0 lshr cttz(Op1), if Op1 is a power of 2.
1706 if (auto *Res = GetShiftableDenom(Op1))
1725 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1730 if (match(Op1, m_AllOnes()) ||
1731 (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)))
1735 if (match(Op1, m_SignMask()))
1736 return new ZExtInst(Builder.CreateICmpEQ(Op0, Op1), Ty);
1740 if (match(Op1, m_Power2()) && match(Op1, m_NonNegative())) {
1741 Constant *C = ConstantExpr::getExactLogBase2(cast<Constant>(Op1));
1747 if (match(Op1, m_NSWShl(m_One(), m_Value(ShAmt))))
1751 if (match(Op1, m_NegatedPower2())) {
1752 Constant *NegPow2C = ConstantExpr::getNeg(cast<Constant>(Op1));
1760 if (match(Op1, m_APInt(Op1C))) {
1774 ConstantExpr::getTrunc(cast<Constant>(Op1), Op0Src->getType());
1808 (match(Op1, m_Power2(Op1C)) || match(Op1, m_NegatedPower2(Op1C))) &&
1816 if (isKnownNonNegative(Op1, SQ.getWithInstruction(&I))) {
1817 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1, I.getName());
1822 if (match(Op1, m_NegatedPower2())) {
1826 ConstantExpr::getNeg(cast<Constant>(Op1)));
1831 if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, &I)) {
1836 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1, I.getName());
1843 if (isKnownNegation(Op0, Op1)) {
1935 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1936 auto *II = dyn_cast<IntrinsicInst>(Op1);
1984 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1985 auto *II = dyn_cast<IntrinsicInst>(Op1);
2096 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2116 if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
2120 if (isa<Constant>(Op1))
2128 (!isa<Constant>(Y) || !isa<Constant>(Op1))) {
2130 Value *YZ = Builder.CreateFMulFMF(Y, Op1, &I);
2133 if (match(Op1, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
2145 if (match(Op1, m_FDiv(m_SpecificFP(1.0), m_Value(Y))))
2149 if (I.hasAllowReassoc() && Op0->hasOneUse() && Op1->hasOneUse()) {
2154 match(Op1, m_Intrinsic<Intrinsic::cos>(m_Specific(X)));
2157 match(Op1, m_Intrinsic<Intrinsic::sin>(m_Specific(X)));
2179 match(Op1, m_c_FMul(m_Specific(Op0), m_Value(Y)))) {
2203 match(Op0, m_OneUse(m_Intrinsic<Intrinsic::pow>(m_Specific(Op1),
2207 Value *Pow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, Op1, Y1, &I);
2225 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *X = nullptr;
2265 MatchShiftOrMulXC(Op1, X, Z, Op1PreserveNSW)) {
2267 } else if (MatchShiftCX(Op0, Y, X) && MatchShiftCX(Op1, Z, X)) {
2290 // (RemSimplificationC * X) depending on whether we matched Op0/Op1 as
2300 OverflowingBinaryOperator *BO1 = cast<OverflowingBinaryOperator>(Op1);
2336 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2338 if (isa<Constant>(Op1)) {
2345 if (match(Op1, m_APInt(Op1Int)) && !Op1Int->isMinValue() &&
2383 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2385 if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, &I)) {
2389 Value *Add = Builder.CreateAdd(Op1, N1);
2395 Value *Cmp = Builder.CreateICmpNE(Op1, ConstantInt::get(Ty, 1));
2401 if (match(Op1, m_Negative())) {
2405 Value *Cmp = Builder.CreateICmpULT(F0, Op1);
2406 Value *Sub = Builder.CreateSub(F0, Op1);
2415 if (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
2424 // For "(X + 1) % Op1" and if (X u< Op1) => (X + 1) == Op1 ? 0 : X + 1 .
2427 simplifyICmpInst(ICmpInst::ICMP_ULT, X, Op1, SQ.getWithInstruction(&I));
2432 Value *Cmp = Builder.CreateICmpEQ(FrozenOp0, Op1);
2452 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2456 if (match(Op1, m_Negative(Y)) && !Y->isMinSignedValue())
2468 if (MaskedValueIsZero(Op1, Mask, 0, &I) &&
2471 return BinaryOperator::CreateURem(Op0, Op1, I.getName());
2475 if (isa<ConstantVector>(Op1) || isa<ConstantDataVector>(Op1)) {
2476 Constant *C = cast<Constant>(Op1);