Lines Matching defs:Op1
196 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
198 simplifyMulInst(Op0, Op1, I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
220 if (match(Op1, m_AllOnes())) {
264 if (Op0->hasOneUse() && match(Op1, m_NegatedPower2())) {
269 auto *Op1C = cast<Constant>(Op1);
285 match(Op1, m_APIntAllowPoison(NegPow2C))) {
304 if (match(Op1, m_ImmConstant(MulC))) {
329 if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(X))))
338 match(Op1, m_OneUse(m_Intrinsic<Intrinsic::abs>(m_Value(Y), m_One()))))
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)))) {
355 cast<OverflowingBinaryOperator>(Op1)->hasNoSignedWrap())
367 if (match(Op1, m_Neg(m_Value(X)))) {
383 if (match(Op1, m_APInt(C1)) &&
390 Op1));
397 Value *Y = Op1;
402 Div = dyn_cast<BinaryOperator>(Op1);
438 match(Op1, 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())) {
470 return SelectInst::Create(X, Op1, ConstantInt::getNullValue(Ty));
471 if (match(Op1, m_ZExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1))
482 if (match(Op1, m_ImmConstant(ImmC))) {
533 // (mul Op0 Op1):
535 // (shl Op1, Log2(Op0))
536 // if Log2(Op1) folds away ->
537 // (shl Op0, Log2(Op1))
542 BinaryOperator *Shl = BinaryOperator::CreateShl(Op1, Res);
547 if (takeLog2(Builder, Op1, /*Depth*/ 0, /*AssumeNonZero*/ false,
549 Value *Res = takeLog2(Builder, Op1, /*Depth*/ 0, /*AssumeNonZero*/ false,
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())) {
634 Value *Op1 = I.getOperand(1);
638 match(Op1, m_AllowReassoc(m_Intrinsic<Intrinsic::powi>(m_Specific(X),
651 m_Specific(Op1), m_Value(Y))))) &&
654 Instruction *NewPow = createPowiExpr(I, *this, Op1, Y, NegOne);
664 match(Op1, m_AllowReassoc(m_c_FMul(m_Specific(X), m_Value(Z)))) &&
677 Value *Op1 = I.getOperand(1);
684 if (match(Op1, m_Constant(C)) && C->isFiniteNonZeroFP() &&
739 BinaryOperator *DivOp = cast<BinaryOperator>(((Z == Op0) ? Op1 : Op0));
754 match(Op1, m_OneUse(m_Sqrt(m_Value(Y))))) {
768 match(Y, m_Sqrt(m_Value(X))) && Op1 == X)
771 match(Op1, (m_FDiv(m_SpecificFP(1.0), m_Value(Y)))) &&
777 if (I.hasNoNaNs() && I.hasNoSignedZeros() && Op0 == Op1 && Op0->hasNUses(2)) {
807 match(Op1, m_Intrinsic<Intrinsic::pow>(m_Specific(X), m_Value(Z)))) {
814 match(Op1, m_Intrinsic<Intrinsic::pow>(m_Value(Z), m_Specific(Y)))) {
822 match(Op1, m_Intrinsic<Intrinsic::exp>(m_Value(Y)))) {
830 match(Op1, m_Intrinsic<Intrinsic::exp2>(m_Value(Y)))) {
844 if (match(Op0, m_OneUse(m_c_FMul(m_Specific(Op1), m_Value(Y)))) && Op1 != Y) {
845 Value *XX = Builder.CreateFMulFMF(Op1, Op1, &I);
848 if (match(Op1, m_OneUse(m_c_FMul(m_Specific(Op0), m_Value(Y)))) && Op0 != Y) {
884 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
885 if (match(Op1, m_SpecificFP(-1.0)))
892 if (match(Op1, m_APFloatAllowPoison(FPC)) && FPC->isZero() &&
899 {I.getType()}, {Op1, Op0}, &I);
906 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_Constant(C)))
916 auto *SI = SelectInst::Create(X, Op1, ConstantFP::get(I.getType(), 0.0));
920 if (match(Op1, m_UIToFP(m_Value(X))) &&
929 if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))
942 Y = Op1;
944 if (match(Op1, m_OneUse(m_Intrinsic<Intrinsic::log2>(
946 Log2 = cast<IntrinsicInst>(Op1);
1087 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1094 if (match(Op1, m_Shl(m_Value(X), m_Value(Z))) &&
1098 auto *Shl = cast<OverflowingBinaryOperator>(Op1);
1107 if (IsSigned && HasNSW && (Op0->hasOneUse() || Op1->hasOneUse())) {
1116 match(Op1, m_Shl(m_Value(Y), m_Specific(Z)))) {
1118 auto *Shl1 = cast<OverflowingBinaryOperator>(Op1);
1139 match(Op1, m_Shl(m_Specific(X), m_Value(Z)))) {
1141 auto *Shl1 = cast<OverflowingBinaryOperator>(Op1);
1169 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1186 match(Op1, m_Select(m_Value(), m_ImmConstant(), m_ImmConstant()))) {
1187 if (Instruction *R = FoldOpIntoSelect(I, cast<SelectInst>(Op1),
1193 if (match(Op1, m_APInt(C2))) {
1281 // (Op1 + 1) u< 3 ? Op1 : 0
1282 // Op1 must be frozen because we are increasing its number of uses.
1283 Value *F1 = Op1;
1284 if (!isGuaranteedNotToBeUndef(Op1))
1285 F1 = Builder.CreateFreeze(Op1, Op1->getName() + ".fr");
1290 // If Op1 is 0 then it's undefined behaviour. If Op1 is 1 then the
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
1303 if ((IsSigned && match(Z, m_SRem(m_Specific(X), m_Specific(Op1)))) ||
1304 (!IsSigned && match(Z, m_URem(m_Specific(X), m_Specific(Op1)))))
1305 return BinaryOperator::Create(I.getOpcode(), X, 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)))) {
1316 bool HasNSW = cast<OverflowingBinaryOperator>(Op1)->hasNoSignedWrap();
1317 bool HasNUW = cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap();
1327 if (!IsSigned && Op1->hasOneUse() &&
1329 match(Op1, m_c_Mul(m_Specific(X), m_Value(Y))))
1330 if (cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap()) {
1342 // ((Op1 * X) / Y) / Op1 --> X / Y
1343 if (match(Op0, m_BinOp(I.getOpcode(), m_c_Mul(m_Specific(Op1), m_Value(X)),
1366 auto OB1HasNSW = cast<OverflowingBinaryOperator>(Op1)->hasNoSignedWrap();
1368 cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap();
1383 if (match(Op1, m_c_Mul(m_Specific(X), m_Value(Z)))) {
1387 if (match(Op1, m_c_Mul(m_Specific(Y), m_Value(Z)))) {
1408 // FIXME: assert that Op1 isn't/doesn't contain undef.
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))) {
1546 if (match(Op1, m_Negative())) {
1547 Value *Cmp = Builder.CreateICmpUGE(Op0, Op1);
1551 if (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
1562 // ((Op1 *nuw A) >> B) / Op1 --> A >> B
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)))) {
1571 // Op1 udiv Op2 -> Op1 lshr log2(Op2), if log2() folds away.
1572 if (takeLog2(Builder, Op1, /*Depth*/ 0, /*AssumeNonZero*/ true,
1574 Value *Res = takeLog2(Builder, Op1, /*Depth*/ 0,
1595 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1600 if (match(Op1, m_AllOnes()) ||
1601 (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)))
1605 if (match(Op1, m_SignMask()))
1606 return new ZExtInst(Builder.CreateICmpEQ(Op0, Op1), Ty);
1610 if (match(Op1, m_Power2()) && match(Op1, m_NonNegative())) {
1611 Constant *C = ConstantExpr::getExactLogBase2(cast<Constant>(Op1));
1617 if (match(Op1, m_NSWShl(m_One(), m_Value(ShAmt))))
1621 if (match(Op1, m_NegatedPower2())) {
1622 Constant *NegPow2C = ConstantExpr::getNeg(cast<Constant>(Op1));
1630 if (match(Op1, m_APInt(Op1C))) {
1644 ConstantExpr::getTrunc(cast<Constant>(Op1), Op0Src->getType());
1678 (match(Op1, m_Power2(Op1C)) || match(Op1, m_NegatedPower2(Op1C))) &&
1686 if (isKnownNonNegative(Op1, SQ.getWithInstruction(&I))) {
1687 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1, I.getName());
1692 if (match(Op1, m_NegatedPower2())) {
1696 ConstantExpr::getNeg(cast<Constant>(Op1)));
1701 if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, &I)) {
1706 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1, I.getName());
1713 if (isKnownNegation(Op0, Op1)) {
1805 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1806 auto *II = dyn_cast<IntrinsicInst>(Op1);
1854 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1855 auto *II = dyn_cast<IntrinsicInst>(Op1);
1898 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1900 if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
1904 if (isa<Constant>(Op1))
1912 (!isa<Constant>(Y) || !isa<Constant>(Op1))) {
1914 Value *YZ = Builder.CreateFMulFMF(Y, Op1, &I);
1917 if (match(Op1, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
1929 if (match(Op1, m_FDiv(m_SpecificFP(1.0), m_Value(Y))))
1933 if (I.hasAllowReassoc() && Op0->hasOneUse() && Op1->hasOneUse()) {
1938 match(Op1, m_Intrinsic<Intrinsic::cos>(m_Specific(X)));
1941 match(Op1, m_Intrinsic<Intrinsic::sin>(m_Specific(X)));
1963 match(Op1, m_c_FMul(m_Specific(Op0), m_Value(Y)))) {
1987 match(Op0, m_OneUse(m_Intrinsic<Intrinsic::pow>(m_Specific(Op1),
1991 Value *Pow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, Op1, Y1, &I);
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)) {
2068 // (RemSimplificationC * X) depending on whether we matched Op0/Op1 as
2078 OverflowingBinaryOperator *BO1 = cast<OverflowingBinaryOperator>(Op1);
2114 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2128 match(Op1, m_Select(m_Value(), m_ImmConstant(), m_ImmConstant()))) {
2129 if (Instruction *R = FoldOpIntoSelect(I, cast<SelectInst>(Op1),
2134 if (isa<Constant>(Op1)) {
2141 if (match(Op1, m_APInt(Op1Int)) && !Op1Int->isMinValue() &&
2179 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2181 if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, &I)) {
2185 Value *Add = Builder.CreateAdd(Op1, N1);
2191 Value *Cmp = Builder.CreateICmpNE(Op1, ConstantInt::get(Ty, 1));
2197 if (match(Op1, m_Negative())) {
2201 Value *Cmp = Builder.CreateICmpULT(F0, Op1);
2202 Value *Sub = Builder.CreateSub(F0, Op1);
2211 if (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
2220 // For "(X + 1) % Op1" and if (X u< Op1) => (X + 1) == Op1 ? 0 : X + 1 .
2223 simplifyICmpInst(ICmpInst::ICMP_ULT, X, Op1, SQ.getWithInstruction(&I));
2228 Value *Cmp = Builder.CreateICmpEQ(FrozenOp0, Op1);
2248 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2252 if (match(Op1, m_Negative(Y)) && !Y->isMinSignedValue())
2264 if (MaskedValueIsZero(Op1, Mask, 0, &I) &&
2267 return BinaryOperator::CreateURem(Op0, Op1, I.getName());
2271 if (isa<ConstantVector>(Op1) || isa<ConstantDataVector>(Op1)) {
2272 Constant *C = cast<Constant>(Op1);