Lines Matching defs:Y
147 Value *X = Mul.getOperand(0), *Y = Mul.getOperand(1);
149 std::swap(X, Y);
156 if (match(Y, m_Shl(m_One(), m_Value(Z)))) {
157 bool PropagateNSW = HasNSW && cast<ShlOperator>(Y)->hasNoSignedWrap();
166 if (match(Y, m_OneUse(m_Add(m_BinOp(Shift), m_One()))) &&
181 if (match(Y, m_OneUse(m_Not(m_OneUse(m_Shl(m_AllOnes(), m_Value(Z))))))) {
333 Value *Y;
334 // abs(X) * abs(Y) -> abs(X * Y)
338 match(Op1, m_OneUse(m_Intrinsic<Intrinsic::abs>(m_Value(Y), m_One()))))
341 Builder.CreateNSWMul(X, Y),
346 Value *Y;
351 // -X * -Y --> X * Y
352 if (match(Op0, m_Neg(m_Value(X))) && match(Op1, m_Neg(m_Value(Y)))) {
353 auto *NewMul = BinaryOperator::CreateMul(X, Y);
360 // -X * Y --> -(X * Y)
361 // X * -Y --> -(X * Y)
362 if (match(&I, m_c_Mul(m_OneUse(m_Neg(m_Value(X))), m_Value(Y))))
363 return BinaryOperator::CreateNeg(Builder.CreateMul(X, Y));
365 // (-X * Y) * -X --> (X * Y) * X
366 // (-X << Y) * -X --> (X << Y) * X
394 // (X / Y) * Y = X - (X % Y)
395 // (X / Y) * -Y = (X % Y) - X
397 Value *Y = Op1;
401 Y = Op0;
404 Value *Neg = dyn_castNegVal(Y);
406 (Div->getOperand(1) == Y || Div->getOperand(1) == Neg) &&
411 // If the division is exact, X % Y is zero, so we end up with X or -X.
413 if (DivOp1 == Y)
425 if (DivOp1 == Y)
433 // 2) X * Y --> X & Y, iff X, Y can be only {0,1}.
446 // (zext bool X) * (zext bool Y) --> zext (and X, Y)
447 // (sext bool X) * (sext bool Y) --> zext (and X, Y)
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))))) &&
451 X->getType()->isIntOrIntVectorTy(1) && X->getType() == Y->getType() &&
452 (Op0->hasOneUse() || Op1->hasOneUse() || X == Y)) {
453 Value *And = Builder.CreateAnd(X, Y, "mulbool");
456 // (sext bool X) * (zext bool Y) --> sext (and X, Y)
457 // (zext bool X) * (sext bool Y) --> sext (and 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))))) &&
461 X->getType()->isIntOrIntVectorTy(1) && X->getType() == Y->getType() &&
463 Value *And = Builder.CreateAnd(X, Y, "mulbool");
467 // (zext bool X) * Y --> X ? Y : 0
468 // Y * (zext bool X) --> X ? Y : 0
474 // mul (sext X), Y -> select X, -Y, 0
475 // mul Y, (sext X) -> select X, -Y, 0
476 if (match(&I, m_c_Mul(m_OneUse(m_SExt(m_Value(X))), m_Value(Y))) &&
478 return SelectInst::Create(X, Builder.CreateNeg(Y, "", I.hasNoSignedWrap()),
499 // (lshr X, 31) * Y --> (X < 0) ? Y : 0
503 if (match(&I, m_c_BinOp(m_LShr(m_Value(X), m_APInt(C)), m_Value(Y))) &&
506 return SelectInst::Create(IsNeg, Y, ConstantInt::getNullValue(Ty));
509 // (and X, 1) * Y --> (trunc X) ? Y : 0
510 if (match(&I, m_c_BinOp(m_OneUse(m_And(m_Value(X), m_One())), m_Value(Y)))) {
512 return SelectInst::Create(Tr, Y, ConstantInt::getNullValue(Ty));
577 Value *X, *Y;
579 // -X * -Y --> X * Y
580 // -X / -Y --> X / Y
581 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_FNeg(m_Value(Y))))
582 return BinaryOperator::CreateWithCopiedFlags(Opcode, X, Y, &I);
589 // fabs(X) * fabs(Y) --> fabs(X * Y)
590 // fabs(X) / fabs(Y) --> fabs(X / Y)
591 if (match(Op0, m_FAbs(m_Value(X))) && match(Op1, m_FAbs(m_Value(Y))) &&
595 Value *XY = Builder.CreateBinOp(Opcode, X, Y);
606 Value *Y, Value *Z) {
608 Value *YZ = Builder.CreateAdd(Y, Z);
615 Value *X, *Y, *Z;
620 // powi(X, Y) * X --> powi(X, Y+1)
621 // X * powi(X, Y) --> powi(X, Y+1)
623 m_Value(X), m_Value(Y)))),
625 Constant *One = ConstantInt::get(Y->getType(), 1);
626 if (willNotOverflowSignedAdd(Y, One, I)) {
627 Instruction *NewPow = createPowiExpr(I, *this, X, Y, One);
637 m_Intrinsic<Intrinsic::powi>(m_Value(X), m_Value(Y)))) &&
640 Y->getType() == Z->getType()) {
641 Instruction *NewPow = createPowiExpr(I, *this, X, Y, Z);
646 // powi(X, Y) / X --> powi(X, Y-1)
647 // This is legal when (Y - 1) can't wraparound, in which case reassoc and
651 m_Specific(Op1), m_Value(Y))))) &&
652 willNotOverflowSignedSub(Y, ConstantInt::get(Y->getType(), 1), I)) {
653 Constant *NegOne = ConstantInt::getAllOnesValue(Y->getType());
654 Instruction *NewPow = createPowiExpr(I, *this, Op1, Y, NegOne);
658 // powi(X, Y) / (X * Z) --> powi(X, Y-1) / Z
659 // This is legal when (Y - 1) can't wraparound, in which case reassoc and
663 m_Value(X), m_Value(Y))))) &&
665 willNotOverflowSignedSub(Y, ConstantInt::get(Y->getType(), 1), I)) {
666 Constant *NegOne = ConstantInt::getAllOnesValue(Y->getType());
667 auto *NewPow = createPowiExpr(I, *this, X, Y, NegOne);
678 Value *X, *Y;
737 m_c_FMul(m_AllowReassoc(m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))),
742 // Sink division: (X / Y) * Z --> (X * Z) / Y
746 return BinaryOperator::CreateFDivFMF(NewFMul, Y, FMF);
750 // sqrt(X) * sqrt(Y) -> sqrt(X * Y)
754 match(Op1, m_OneUse(m_Sqrt(m_Value(Y))))) {
755 Value *XY = Builder.CreateFMulFMF(X, Y, &I);
767 match(Op0, (m_FDiv(m_SpecificFP(1.0), m_Value(Y)))) &&
768 match(Y, m_Sqrt(m_Value(X))) && Op1 == X)
769 return BinaryOperator::CreateFDivFMF(X, Y, &I);
771 match(Op1, (m_FDiv(m_SpecificFP(1.0), m_Value(Y)))) &&
772 match(Y, m_Sqrt(m_Value(X))) && Op0 == X)
773 return BinaryOperator::CreateFDivFMF(X, Y, &I);
779 // (X / sqrt(Y)) * (X / sqrt(Y)) --> (X * X) / Y
780 if (match(Op0, m_FDiv(m_Value(X), m_Sqrt(m_Value(Y))))) {
782 return BinaryOperator::CreateFDivFMF(XX, Y, &I);
784 // (sqrt(Y) / X) * (sqrt(Y) / X) --> Y / (X * X)
785 if (match(Op0, m_FDiv(m_Sqrt(m_Value(Y)), m_Value(X)))) {
787 return BinaryOperator::CreateFDivFMF(Y, XX, &I);
791 // pow(X, Y) * X --> pow(X, Y+1)
792 // X * pow(X, Y) --> pow(X, Y+1)
794 m_Value(Y))),
796 Value *Y1 = Builder.CreateFAddFMF(Y, ConstantFP::get(I.getType(), 1.0), &I);
805 // pow(X, Y) * pow(X, Z) -> pow(X, Y + Z)
806 if (match(Op0, m_Intrinsic<Intrinsic::pow>(m_Value(X), m_Value(Y))) &&
808 auto *YZ = Builder.CreateFAddFMF(Y, Z, &I);
812 // pow(X, Y) * pow(Z, Y) -> pow(X * Z, Y)
813 if (match(Op0, m_Intrinsic<Intrinsic::pow>(m_Value(X), m_Value(Y))) &&
814 match(Op1, m_Intrinsic<Intrinsic::pow>(m_Value(Z), m_Specific(Y)))) {
816 auto *NewPow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, XZ, Y, &I);
820 // exp(X) * exp(Y) -> exp(X + Y)
822 match(Op1, m_Intrinsic<Intrinsic::exp>(m_Value(Y)))) {
823 Value *XY = Builder.CreateFAddFMF(X, Y, &I);
828 // exp2(X) * exp2(Y) -> exp2(X + Y)
830 match(Op1, m_Intrinsic<Intrinsic::exp2>(m_Value(Y)))) {
831 Value *XY = Builder.CreateFAddFMF(X, Y, &I);
837 // (X*Y) * X => (X*X) * Y where Y != X
841 // latency of the instruction Y is amortized by the expression of X*X,
842 // and therefore Y is in a "less critical" position compared to what it
844 if (match(Op0, m_OneUse(m_c_FMul(m_Specific(Op1), m_Value(Y)))) && Op1 != Y) {
846 return BinaryOperator::CreateFMulFMF(XX, Y, &I);
848 if (match(Op1, m_OneUse(m_c_FMul(m_Specific(Op0), m_Value(Y)))) && Op0 != Y) {
850 return BinaryOperator::CreateFMulFMF(XX, Y, &I);
904 Value *X, *Y;
911 // (uitofp bool X) * Y --> X ? Y : 0
912 // Y * (uitofp bool X) --> X ? Y : 0
936 // log2(X * 0.5) * Y = log2(X) * Y - Y
942 Y = Op1;
947 Y = Op0;
951 Value *LogXTimesY = Builder.CreateFMulFMF(Log2, Y, &I);
952 return BinaryOperator::CreateFSubFMF(LogXTimesY, Y, &I);
965 // minimum(X, Y) * maximum(X, Y) => X * Y.
967 m_c_FMul(m_Intrinsic<Intrinsic::maximum>(m_Value(X), m_Value(Y)),
969 m_Deferred(Y))))) {
970 BinaryOperator *Result = BinaryOperator::CreateFMulFMF(X, Y, &I);
972 // If X is NaN and Y is Inf then in original program we had NaN * NaN,
992 // div/rem X, (Cond ? 0 : Y) -> div/rem X, Y
995 // div/rem X, (Cond ? Y : 0) -> div/rem X, Y
1000 // Change the div/rem to use 'Y' instead of the select.
1003 // Okay, we know we replace the operand of the div/rem with 'Y' with no
1090 Value *X, *Y, *Z;
1095 match(Op0, m_c_Mul(m_Specific(X), m_Value(Y)))) {
1102 // (X * Y) u/ (X << Z) --> Y u>> Z
1104 return Builder.CreateLShr(Y, Z, "", I.isExact());
1106 // (X * Y) s/ (X << Z) --> Y s/ (1 << Z)
1109 return Builder.CreateSDiv(Y, Shl, "", I.isExact());
1116 match(Op1, m_Shl(m_Value(Y), m_Specific(Z)))) {
1122 // (X << Z) / (Y << Z) --> X / Y
1127 return Builder.CreateUDiv(X, Y, "", I.isExact());
1130 // (X << Z) / (Y << Z) --> X / Y
1133 return Builder.CreateSDiv(X, Y, "", I.isExact());
1136 // If X << Y and X << Z does not overflow, then:
1137 // (X << Y) / (X << Z) -> (1 << Y) / (1 << Z) -> 1 << Y >> Z
1138 if (match(Op0, m_Shl(m_Value(X), m_Value(Y))) &&
1149 One, Y, "shl.dividend",
1177 // Handle cases involving: [su]div X, (select Cond, Y, Z)
1300 // (X - (X rem Y)) / Y -> X / Y; usually originates as ((X / Y) * Y) / Y
1302 if (match(Op0, m_Sub(m_Value(X), m_Value(Z)))) // (X - Z) / Y; Y = Op1
1307 // (X << Y) / X -> 1 << Y
1308 Value *Y;
1309 if (IsSigned && match(Op0, m_NSWShl(m_Specific(Op1), m_Value(Y))))
1310 return BinaryOperator::CreateNSWShl(ConstantInt::get(Ty, 1), Y);
1311 if (!IsSigned && match(Op0, m_NUWShl(m_Specific(Op1), m_Value(Y))))
1312 return BinaryOperator::CreateNUWShl(ConstantInt::get(Ty, 1), Y);
1314 // X / (X * Y) -> 1 / Y if the multiplication does not overflow.
1315 if (match(Op1, m_c_Mul(m_Specific(Op0), m_Value(Y)))) {
1320 replaceOperand(I, 1, Y);
1325 // (X << Z) / (X * Y) -> (1 << Z) / Y
1329 match(Op1, m_c_Mul(m_Specific(X), m_Value(Y))))
1332 Builder.CreateShl(ConstantInt::get(Ty, 1), Z, "", /*NUW*/ true), Y);
1342 // ((Op1 * X) / Y) / Op1 --> X / Y
1344 m_Value(Y)))) {
1349 NewDiv = BinaryOperator::CreateUDiv(X, Y);
1351 NewDiv = BinaryOperator::CreateSDiv(X, Y);
1360 // (X * Y) / (X * Z) --> Y / Z (and commuted variants)
1361 if (match(Op0, m_Mul(m_Value(X), m_Value(Y)))) {
1384 if (auto *Val = CreateDivOrNull(Y, Z))
1387 if (match(Op1, m_c_Mul(m_Specific(Y), m_Value(Z)))) {
1425 Value *X, *Y;
1430 // log2(X << Y) -> log2(X) + Y
1432 if (match(Op, m_Shl(m_Value(X), m_Value(Y)))) {
1437 return IfFold([&]() { return Builder.CreateAdd(LogX, Y); });
1440 // log2(Cond ? X : Y) -> Cond ? log2(X) : log2(Y)
1451 // log2(umin(X, Y)) -> umin(log2(X), log2(Y))
1452 // log2(umax(X, Y)) -> umax(log2(X), log2(Y))
1456 // log2(umax(X, Y)) != umax(log2(X), log2(Y)) (because overflow).
1478 Value *X, *Y;
1479 if (match(N, m_ZExt(m_Value(X))) && match(D, m_ZExt(m_Value(Y))) &&
1480 X->getType() == Y->getType() && (N->hasOneUse() || D->hasOneUse())) {
1481 // udiv (zext X), (zext Y) --> zext (udiv X, Y)
1482 // urem (zext X), (zext Y) --> zext (urem X, Y)
1483 Value *NarrowOp = IC.Builder.CreateBinOp(Opcode, X, Y);
1660 // -X / Y --> -(X / Y)
1661 Value *Y;
1662 if (match(&I, m_SDiv(m_OneUse(m_NSWNeg(m_Value(X))), m_Value(Y))))
1664 Builder.CreateSDiv(X, Y, I.getName(), I.isExact()));
1702 // X sdiv (1 << Y) -> X udiv (1 << Y) ( -> X u>> Y)
1703 // Safe because the only negative value (1 << Y) can take on is
1811 // Z / pow(X, Y) --> Z * pow(X, -Y)
1812 // Z / exp{2}(Y) --> Z * exp{2}(-Y)
1851 // X / sqrt(Y / Z) --> X * sqrt(Z / Y)
1860 Value *Y, *Z;
1864 if (!match(DivOp, m_FDiv(m_Value(Y), m_Value(Z))))
1869 Value *SwapDiv = Builder.CreateFDivFMF(Z, Y, DivOp);
1910 Value *X, *Y;
1911 if (match(Op0, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
1912 (!isa<Constant>(Y) || !isa<Constant>(Op1))) {
1913 // (X / Y) / Z => X / (Y * Z)
1914 Value *YZ = Builder.CreateFMulFMF(Y, Op1, &I);
1917 if (match(Op1, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
1918 (!isa<Constant>(Y) || !isa<Constant>(Op0))) {
1919 // Z / (X / Y) => (Y * Z) / X
1920 Value *YZ = Builder.CreateFMulFMF(Y, Op0, &I);
1923 // Z / (1.0 / Y) => (Y * Z)
1925 // This is a special case of Z / (X / Y) => (Y * Z) / X, with X = 1.0. The
1927 // for 1.0/Y, the number of instructions remain the same and a division is
1929 if (match(Op1, m_FDiv(m_SpecificFP(1.0), m_Value(Y))))
1930 return BinaryOperator::CreateFMulFMF(Y, Op0, &I);
1958 // X / (X * Y) --> 1.0 / Y
1961 Value *X, *Y;
1963 match(Op1, m_c_FMul(m_Specific(Op0), m_Value(Y)))) {
1965 replaceOperand(I, 1, Y);
1985 // pow(X, Y) / X --> pow(X, Y-1)
1988 m_Value(Y))))) {
1990 Builder.CreateFAddFMF(Y, ConstantFP::get(I.getType(), -1.0), &I);
2002 // (urem/srem (mul X, Y), (mul X, Z))
2003 // (urem/srem (shl X, Y), (shl X, Z))
2004 // (urem/srem (shl Y, X), (shl Z, X))
2010 APInt Y, Z;
2043 if (MatchShiftOrMulXC(Op0, X, Y) && MatchShiftOrMulXC(Op1, X, Z)) {
2045 } else if (MatchShiftCX(Op0, Y, X) && MatchShiftCX(Op1, Z, X)) {
2054 // TODO: We may be able to deduce more about nsw/nuw of BO0/BO1 based on Y >=
2055 // Z or Z >= Y.
2060 APInt RemYZ = IsSRem ? Y.srem(Z) : Y.urem(Z);
2061 // (rem (mul nuw/nsw X, Y), (mul X, Z))
2062 // if (rem Y, Z) == 0
2082 // (rem (mul X, Y), (mul nuw/nsw X, Z))
2083 // if (rem Y, Z) == Y
2084 // -> (mul nuw/nsw X, Y)
2085 if (RemYZ == Y && BO1NoWrap) {
2086 BinaryOperator *BO = CreateMulOrShift(Y);
2093 // (rem (mul nuw/nsw X, Y), (mul {nsw} X, Z))
2094 // if Y >= Z
2095 // -> (mul {nuw} nsw X, (rem Y, Z))
2096 if (Y.uge(Z) && (IsSRem ? (BO0HasNSW && BO1HasNSW) : BO0HasNUW)) {
2120 // Handle cases involving: rem X, (select Cond, Y, Z)
2178 // X urem Y -> X and Y-1, where Y is a power of 2,
2182 // This may increase instruction count, we don't enforce that Y is a
2250 const APInt *Y;
2251 // X % -Y -> X % Y
2252 if (match(Op1, m_Negative(Y)) && !Y->isMinSignedValue())
2253 return replaceOperand(I, 1, ConstantInt::get(I.getType(), -*Y));
2256 // -X srem Y --> -(X srem Y)
2257 Value *X, *Y;
2258 if (match(&I, m_SRem(m_OneUse(m_NSWNeg(m_Value(X))), m_Value(Y))))
2259 return BinaryOperator::CreateNSWNeg(Builder.CreateSRem(X, Y));
2266 // X srem Y -> X urem Y, iff X and Y don't have sign bit set