Lines Matching defs:X
89 // "select cond, X, 0" can simplify to "X".
147 Value *X = Mul.getOperand(0), *Y = Mul.getOperand(1);
149 std::swap(X, Y);
154 // X * (1 << Z) --> X << Z
158 return Builder.CreateShl(X, Z, Mul.getName(), HasNUW, PropagateNSW);
162 // X * ((1 << Z) + 1) --> (X * (1 << Z)) + X --> (X << Z) + X
163 // This increases uses of X, so it may require a freeze, but that is still
169 Value *FrX = X;
170 if (!isGuaranteedNotToBeUndef(X))
171 FrX = Builder.CreateFreeze(X, X->getName() + ".fr");
178 // X * (~(-1 << Z)) --> X * ((1 << Z) - 1) --> (X << Z) - X
179 // This increases uses of X, so it may require a freeze, but that is still
182 Value *FrX = X;
183 if (!isGuaranteedNotToBeUndef(X))
184 FrX = Builder.CreateFreeze(X, X->getName() + ".fr");
205 if (Instruction *X = foldVectorBinop(I))
206 return X;
219 // X * -1 --> 0 - X
233 // ((X << C2)*C1) == (X * (C1 << C2))
247 // Replace X*(2^C) with X << C, where C is either a scalar or a vector.
265 // Interpret X * (-1<<C) as (-X) * (1<<C) and try to sink the negation.
281 // ({z/s}ext X) * (-1<<C) --> (zext (-X)) << C
283 Value *X;
284 if (match(Op0, m_ZExtOrSExt(m_Value(X))) &&
286 unsigned SrcWidth = X->getType()->getScalarSizeInBits();
289 Value *N = Builder.CreateNeg(X, X->getName() + ".neg");
305 // Canonicalize (X+C1)*MulC -> X*MulC+C1*MulC.
306 // Canonicalize (X|C1)*MulC -> X*MulC+C1*MulC.
307 Value *X;
309 if (match(Op0, m_OneUse(m_AddLike(m_Value(X), m_ImmConstant(C1))))) {
315 Value *NewMul = Builder.CreateMul(X, MulC);
327 // abs(X) * abs(X) -> X * X
328 Value *X;
329 if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(X))))
330 return BinaryOperator::CreateMul(X, X);
334 // abs(X) * abs(Y) -> abs(X * Y)
337 m_OneUse(m_Intrinsic<Intrinsic::abs>(m_Value(X), m_One()))) &&
341 Builder.CreateNSWMul(X, Y),
345 // -X * C --> X * -C
348 if (match(Op0, m_Neg(m_Value(X))) && match(Op1, m_Constant(Op1C)))
349 return BinaryOperator::CreateMul(X, ConstantExpr::getNeg(Op1C));
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
367 if (match(Op1, m_Neg(m_Value(X)))) {
369 return BinaryOperator::CreateMul(NegOp0, X);
373 // (mul (div exact X, C0), C1)
374 // -> (div exact X, C0 / C1)
375 // iff C0 % C1 == 0 and X / (C0 / C1) doesn't create UB.
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)))))) {
388 BOpc, X,
394 // (X / Y) * Y = X - (X % Y)
395 // (X / Y) * -Y = (X % Y) - X
409 Value *X = Div->getOperand(0), *DivOp1 = Div->getOperand(1);
411 // If the division is exact, X % Y is zero, so we end up with X or -X.
414 return replaceInstUsesWith(I, X);
415 return BinaryOperator::CreateNeg(X);
420 // X must be frozen because we are increasing its number of uses.
421 Value *XFreeze = X;
422 if (!isGuaranteedNotToBeUndef(X))
423 XFreeze = Builder.CreateFreeze(X, X->getName() + ".fr");
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
469 if (match(Op0, m_ZExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1))
470 return SelectInst::Create(X, Op1, ConstantInt::getNullValue(Ty));
471 if (match(Op1, m_ZExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1))
472 return SelectInst::Create(X, Op0, ConstantInt::getNullValue(Ty));
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))) &&
477 X->getType()->isIntOrIntVectorTy(1))
478 return SelectInst::Create(X, Builder.CreateNeg(Y, "", I.hasNoSignedWrap()),
483 // (sext bool X) * C --> X ? -C : 0
484 if (match(Op0, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
486 return SelectInst::Create(X, NegC, ConstantInt::getNullValue(Ty));
489 // (ashr i32 X, 31) * C --> (X < 0) ? -C : 0
491 if (match(Op0, m_OneUse(m_AShr(m_Value(X), m_APInt(C)))) &&
494 Value *IsNeg = Builder.CreateIsNeg(X, "isneg");
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))) &&
505 Value *IsNeg = Builder.CreateIsNeg(X, "isneg");
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)))) {
511 Value *Tr = Builder.CreateTrunc(X, CmpInst::makeCmpResultType(Ty));
515 // ((ashr X, 31) | 1) * X --> abs(X)
516 // X * ((ashr X, 31) | 1) --> abs(X)
517 if (match(&I, m_c_BinOp(m_Or(m_AShr(m_Value(X),
520 m_Deferred(X)))) {
522 Intrinsic::abs, X, ConstantInt::getBool(I.getContext(), HasNSW));
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);
584 // fabs(X) * fabs(X) -> X * X
585 // fabs(X) / fabs(X) -> X / X
586 if (Op0 == Op1 && match(Op0, m_FAbs(m_Value(X))))
587 return BinaryOperator::CreateWithCopiedFlags(Opcode, X, X, &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);
605 auto createPowiExpr = [](BinaryOperator &I, InstCombinerImpl &IC, Value *X,
610 Intrinsic::powi, {X->getType(), YZ->getType()}, {X, YZ}, &I);
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)))),
624 m_Deferred(X)))) {
627 Instruction *NewPow = createPowiExpr(I, *this, X, Y, One);
637 m_Intrinsic<Intrinsic::powi>(m_Value(X), m_Value(Y)))) &&
638 match(Op1, m_AllowReassoc(m_Intrinsic<Intrinsic::powi>(m_Specific(X),
641 Instruction *NewPow = createPowiExpr(I, *this, X, Y, Z);
646 // powi(X, Y) / X --> powi(X, Y-1)
658 // powi(X, Y) / (X * Z) --> powi(X, Y-1) / Z
663 m_Value(X), m_Value(Y))))) &&
664 match(Op1, m_AllowReassoc(m_c_FMul(m_Specific(X), m_Value(Z)))) &&
667 auto *NewPow = createPowiExpr(I, *this, X, Y, NegOne);
678 Value *X, *Y;
691 if (match(Op0, m_OneUse(m_FDiv(m_Constant(C1), m_Value(X))))) {
692 // (C1 / X) * C --> (C * C1) / X
696 return BinaryOperator::CreateFDivFMF(CC1, X, FMF);
698 if (match(Op0, m_FDiv(m_Value(X), m_Constant(C1)))) {
700 // (X / C1) * C --> X * (C / C1)
704 return BinaryOperator::CreateFMulFMF(X, CDivC1, FMF);
707 // (X / C1) * C --> X / (C1 / C)
711 return BinaryOperator::CreateFDivFMF(X, C1DivC, FMF);
714 // We do not need to match 'fadd C, X' and 'fsub X, C' because they are
715 // canonicalized to 'fadd X, C'. Distributing the multiply may allow
716 // further folds and (X * C) + C2 is 'fma'.
717 if (match(Op0, m_OneUse(m_FAdd(m_Value(X), m_Constant(C1))))) {
718 // (X + C1) * C --> (X * C) + (C * C1)
721 Value *XC = Builder.CreateFMul(X, C);
725 if (match(Op0, m_OneUse(m_FSub(m_Constant(C1), m_Value(X))))) {
726 // (C1 - X) * C --> (C * C1) - (X * C)
729 Value *XC = Builder.CreateFMul(X, C);
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
745 auto *NewFMul = Builder.CreateFMul(X, Z);
750 // sqrt(X) * sqrt(Y) -> sqrt(X * Y)
753 if (I.hasNoNaNs() && match(Op0, m_OneUse(m_Sqrt(m_Value(X)))) &&
755 Value *XY = Builder.CreateFMulFMF(X, Y, &I);
761 // for the expression "1.0/sqrt(X)".
762 // 1) 1.0/sqrt(X) * X -> X/sqrt(X)
763 // 2) X * 1.0/sqrt(X) -> X/sqrt(X)
764 // We always expect the backend to reduce X/sqrt(X) to sqrt(X), if it
768 match(Y, m_Sqrt(m_Value(X))) && Op1 == X)
769 return BinaryOperator::CreateFDivFMF(X, Y, &I);
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))))) {
781 Value *XX = Builder.CreateFMulFMF(X, X, &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)))) {
786 Value *XX = Builder.CreateFMulFMF(X, X, &I);
791 // pow(X, Y) * X --> pow(X, Y+1)
792 // X * pow(X, Y) --> pow(X, Y+1)
793 if (match(&I, m_c_FMul(m_OneUse(m_Intrinsic<Intrinsic::pow>(m_Value(X),
795 m_Deferred(X)))) {
797 Value *Pow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, X, Y1, &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))) &&
807 match(Op1, m_Intrinsic<Intrinsic::pow>(m_Specific(X), m_Value(Z)))) {
809 auto *NewPow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, X, YZ, &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))) &&
815 auto *XZ = Builder.CreateFMulFMF(X, Z, &I);
820 // exp(X) * exp(Y) -> exp(X + Y)
821 if (match(Op0, m_Intrinsic<Intrinsic::exp>(m_Value(X))) &&
823 Value *XY = Builder.CreateFAddFMF(X, Y, &I);
828 // exp2(X) * exp2(Y) -> exp2(X + Y)
829 if (match(Op0, m_Intrinsic<Intrinsic::exp2>(m_Value(X))) &&
831 Value *XY = Builder.CreateFAddFMF(X, Y, &I);
837 // (X*Y) * X => (X*X) * Y where Y != X
839 // 1) to form a power expression (of X).
841 // latency of the instruction Y is amortized by the expression of X*X,
865 if (Instruction *X = foldVectorBinop(I))
866 return X;
883 // X * -1.0 --> -X
889 // X * 0.0 --> copysign(0.0, X)
890 // X * -0.0 --> copysign(0.0, -X)
903 // -X * C --> X * -C
904 Value *X, *Y;
906 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_Constant(C)))
908 return BinaryOperator::CreateFMulFMF(X, NegC, &I);
911 // (uitofp bool X) * Y --> X ? Y : 0
912 // Y * (uitofp bool X) --> X ? Y : 0
914 if (match(Op0, m_UIToFP(m_Value(X))) &&
915 X->getType()->isIntOrIntVectorTy(1)) {
916 auto *SI = SelectInst::Create(X, Op1, ConstantFP::get(I.getType(), 0.0));
920 if (match(Op1, m_UIToFP(m_Value(X))) &&
921 X->getType()->isIntOrIntVectorTy(1)) {
922 auto *SI = SelectInst::Create(X, Op0, ConstantFP::get(I.getType(), 0.0));
936 // log2(X * 0.5) * Y = log2(X) * Y - Y
940 m_OneUse(m_FMul(m_Value(X), m_SpecificFP(0.5))))))) {
945 m_OneUse(m_FMul(m_Value(X), m_SpecificFP(0.5))))))) {
950 Value *Log2 = Builder.CreateUnaryIntrinsic(Intrinsic::log2, X, &I);
965 // minimum(X, Y) * maximum(X, Y) => X * Y.
967 m_c_FMul(m_Intrinsic<Intrinsic::maximum>(m_Value(X), m_Value(Y)),
968 m_c_Intrinsic<Intrinsic::minimum>(m_Deferred(X),
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
1090 Value *X, *Y, *Z;
1094 if (match(Op1, m_Shl(m_Value(X), m_Value(Z))) &&
1095 match(Op0, m_c_Mul(m_Specific(X), m_Value(Y)))) {
1102 // (X * Y) u/ (X << Z) --> Y u>> Z
1106 // (X * Y) s/ (X << Z) --> Y s/ (1 << Z)
1115 if (match(Op0, m_Shl(m_Value(X), m_Value(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))) &&
1139 match(Op1, m_Shl(m_Specific(X), m_Value(Z)))) {
1145 Constant *One = ConstantInt::get(X->getType(), 1);
1177 // Handle cases involving: [su]div X, (select Cond, Y, Z)
1194 Value *X;
1197 // (X / C1) / C2 -> X / (C1*C2)
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))))) {
1202 return BinaryOperator::Create(I.getOpcode(), X,
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))))) {
1210 // (X * C1) / C2 -> X / (C2 / C1) if C2 is a multiple of C1.
1212 auto *NewDiv = BinaryOperator::Create(I.getOpcode(), X,
1218 // (X * C1) / C2 -> X * (C1 / C2) if C1 is a multiple of C2.
1220 auto *Mul = BinaryOperator::Create(Instruction::Mul, X,
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))) &&
1236 // (X << C1) / C2 -> X / (C2 >> C1) if C2 is a multiple of 1 << C1.
1238 auto *BO = BinaryOperator::Create(I.getOpcode(), X,
1244 // (X << C1) / C2 -> X * ((1 << C1) / C2) if 1 << C1 is a multiple of C2.
1246 auto *Mul = BinaryOperator::Create(Instruction::Mul, X,
1256 // ((X * C2) + C1) / C2 --> X + C1/C2
1260 match(Op0, m_NSWAddLike(m_NSWMul(m_Value(X), m_SpecificInt(*C2)),
1263 return BinaryOperator::CreateNSWAdd(X, ConstantInt::get(Ty, Quotient));
1266 match(Op0, m_NUWAddLike(m_NUWMul(m_Value(X), m_SpecificInt(*C2)),
1268 return BinaryOperator::CreateNUWAdd(X,
1272 if (!C2->isZero()) // avoid X udiv 0
1300 // (X - (X rem Y)) / Y -> X / Y; usually originates as ((X / Y) * Y) / Y
1301 Value *X, *Z;
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);
1307 // (X << Y) / X -> 1 << Y
1314 // X / (X * Y) -> 1 / Y if the multiplication does not overflow.
1325 // (X << Z) / (X * Y) -> (1 << Z) / Y
1328 match(Op0, m_NUWShl(m_Value(X), m_Value(Z))) &&
1329 match(Op1, m_c_Mul(m_Specific(X), m_Value(Y))))
1342 // ((Op1 * X) / Y) / Op1 --> X / Y
1343 if (match(Op0, m_BinOp(I.getOpcode(), m_c_Mul(m_Specific(Op1), m_Value(X)),
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)))) {
1383 if (match(Op1, m_c_Mul(m_Specific(X), m_Value(Z)))) {
1388 if (auto *Val = CreateDivOrNull(X, Z))
1423 // log2(zext X) -> zext log2(X)
1425 Value *X, *Y;
1426 if (match(Op, m_ZExt(m_Value(X))))
1427 if (Value *LogX = takeLog2(Builder, X, Depth, AssumeNonZero, DoFold))
1430 // log2(X << Y) -> log2(X) + Y
1431 // FIXME: Require one use unless X is 1?
1432 if (match(Op, m_Shl(m_Value(X), m_Value(Y)))) {
1436 if (Value *LogX = takeLog2(Builder, X, Depth, AssumeNonZero, DoFold))
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);
1488 if (isa<Instruction>(N) && match(N, m_OneUse(m_ZExt(m_Value(X)))) &&
1491 Constant *TruncC = IC.getLosslessUnsignedTrunc(C, X->getType());
1495 // udiv (zext X), C --> zext (udiv X, C')
1496 // urem (zext X), C --> zext (urem X, C')
1497 return new ZExtInst(IC.Builder.CreateBinOp(Opcode, X, TruncC), Ty);
1499 if (isa<Instruction>(D) && match(D, m_OneUse(m_ZExt(m_Value(X)))) &&
1502 Constant *TruncC = IC.getLosslessUnsignedTrunc(C, X->getType());
1506 // udiv C, (zext X) --> zext (udiv C', X)
1507 // urem C, (zext X) --> zext (urem C', X)
1508 return new ZExtInst(IC.Builder.CreateBinOp(Opcode, TruncC, X), Ty);
1519 if (Instruction *X = foldVectorBinop(I))
1520 return X;
1527 Value *X;
1529 if (match(Op0, m_LShr(m_Value(X), m_APInt(C1))) && match(Op1, m_APInt(C2))) {
1530 // (X lshr C1) udiv C2 --> X udiv (C2 << C1)
1536 X, ConstantInt::get(X->getType(), C2ShlC1));
1550 // Op0 / (sext i1 X) --> zext (Op0 == -1) (if X is 0, the div is undefined)
1551 if (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
1588 if (Instruction *X = foldVectorBinop(I))
1589 return X;
1597 Value *X;
1599 // sdiv Op0, (sext i1 X) --> -Op0 (because if X is 0, the op is undefined)
1601 (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)))
1604 // X / INT_MIN --> X == INT_MIN
1609 // sdiv exact X, 1<<C --> ashr exact X, C iff 1<<C is non-negative
1615 // sdiv exact X, (1<<ShAmt) --> ashr exact X, ShAmt (if shl is non-negative)
1620 // sdiv exact X, -1<<C --> -(ashr exact X, C)
1633 // (sext X) sdiv C --> sext (X sdiv C)
1649 // -X / C --> X / -C (if the negation doesn't overflow).
1652 if (!Op1C->isMinSignedValue() && match(Op0, m_NSWNeg(m_Value(X)))) {
1654 Instruction *BO = BinaryOperator::CreateSDiv(X, NegC);
1660 // -X / Y --> -(X / 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()));
1666 // abs(X) / X --> X > -1 ? 1 : -1
1667 // X / abs(X) --> X > -1 ? 1 : -1
1669 m_OneUse(m_Intrinsic<Intrinsic::abs>(m_Value(X), m_One())),
1670 m_Deferred(X)))) {
1671 Value *Cond = Builder.CreateIsNotNeg(X);
1693 // X sdiv (-(1 << C)) -> -(X sdiv (1 << C)) ->
1694 // -> -(X udiv (1 << C)) -> -(X u>> C)
1702 // X sdiv (1 << Y) -> X udiv (1 << Y) ( -> X u>> Y)
1704 // INT_MIN, and X sdiv INT_MIN == X udiv INT_MIN == 0 if X doesn't have
1712 // -X / X --> X == INT_MIN ? 1 : -1
1728 // -X / C --> X / -C
1729 Value *X;
1731 if (match(I.getOperand(0), m_FNeg(m_Value(X))))
1733 return BinaryOperator::CreateFDivFMF(X, NegC, &I);
1735 // nnan X / +0.0 -> copysign(inf, X)
1736 // nnan nsz X / -0.0 -> copysign(inf, X)
1763 // X / C --> X * (1 / C)
1773 // C / -X --> -C / X
1774 Value *X;
1776 if (match(I.getOperand(1), m_FNeg(m_Value(X))))
1778 return BinaryOperator::CreateFDivFMF(NegC, X, &I);
1783 // Try to reassociate C / X expressions where X includes another constant.
1785 if (match(I.getOperand(1), m_FMul(m_Value(X), m_Constant(C2)))) {
1786 // C / (X * C2) --> (C / C2) / X
1788 } else if (match(I.getOperand(1), m_FDiv(m_Value(X), m_Constant(C2)))) {
1789 // C / (X / C2) --> (C * C2) / X
1799 return BinaryOperator::CreateFDivFMF(NewC, X, &I);
1811 // Z / pow(X, Y) --> Z * pow(X, -Y)
1823 // Require 'ninf' assuming that makes powi(X, -INT_MIN) acceptable.
1824 // That is, X ** (huge negative number) is 0.0, ~1.0, or INF and so
1851 // X / sqrt(Y / Z) --> X * sqrt(Z / Y)
1883 if (Instruction *X = foldVectorBinop(I))
1884 return X;
1910 Value *X, *Y;
1911 if (match(Op0, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
1913 // (X / Y) / Z => X / (Y * Z)
1915 return BinaryOperator::CreateFDivFMF(X, YZ, &I);
1917 if (match(Op1, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))) &&
1919 // Z / (X / Y) => (Y * Z) / X
1921 return BinaryOperator::CreateFDivFMF(YZ, X, &I);
1925 // This is a special case of Z / (X / Y) => (Y * Z) / X, with X = 1.0. The
1934 // sin(X) / cos(X) -> tan(X)
1935 // cos(X) / sin(X) -> 1/tan(X) (cotangent)
1936 Value *X;
1937 bool IsTan = match(Op0, m_Intrinsic<Intrinsic::sin>(m_Value(X))) &&
1938 match(Op1, m_Intrinsic<Intrinsic::cos>(m_Specific(X)));
1940 !IsTan && match(Op0, m_Intrinsic<Intrinsic::cos>(m_Value(X))) &&
1941 match(Op1, m_Intrinsic<Intrinsic::sin>(m_Specific(X)));
1950 Value *Res = emitUnaryFloatFnCall(X, &TLI, LibFunc_tan, LibFunc_tanf,
1958 // X / (X * Y) --> 1.0 / Y
1959 // Reassociate to (X / X -> 1.0) is legal when NaNs are not allowed.
1960 // We can ignore the possibility that X is infinity because INF/INF is NaN.
1961 Value *X, *Y;
1969 // X / fabs(X) -> copysign(1.0, X)
1970 // fabs(X) / X -> copysign(1.0, X)
1972 (match(&I, m_FDiv(m_Value(X), m_FAbs(m_Deferred(X)))) ||
1973 match(&I, m_FDiv(m_FAbs(m_Value(X)), m_Deferred(X))))) {
1975 Intrinsic::copysign, ConstantFP::get(I.getType(), 1.0), X, &I);
1985 // pow(X, Y) / X --> pow(X, Y-1)
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))
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)) {
2061 // (rem (mul nuw/nsw X, Y), (mul X, Z))
2067 // Helper function to emit either (RemSimplificationC << X) or
2068 // (RemSimplificationC * X) depending on whether we matched Op0/Op1 as
2069 // (shl V, X) or (mul V, X) respectively.
2074 return ShiftByX ? BinaryOperator::CreateShl(RemSimplification, X)
2075 : BinaryOperator::CreateMul(X, RemSimplification);
2082 // (rem (mul X, Y), (mul nuw/nsw X, Z))
2084 // -> (mul nuw/nsw X, Y)
2093 // (rem (mul nuw/nsw X, Y), (mul {nsw} X, Z))
2095 // -> (mul {nuw} nsw X, (rem Y, Z))
2120 // Handle cases involving: rem X, (select Cond, Y, Z)
2169 if (Instruction *X = foldVectorBinop(I))
2170 return X;
2178 // X urem Y -> X and Y-1, where Y is a power of 2,
2189 // 1 urem X -> zext(X != 1)
2209 // urem Op0, (sext i1 X) --> (Op0 == -1) ? 0 : Op0
2210 Value *X;
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 .
2221 if (match(Op0, m_Add(m_Value(X), m_One()))) {
2223 simplifyICmpInst(ICmpInst::ICMP_ULT, X, Op1, SQ.getWithInstruction(&I));
2241 if (Instruction *X = foldVectorBinop(I))
2242 return X;
2251 // X % -Y -> X % 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
2314 if (Instruction *X = foldVectorBinop(I))
2315 return X;