Lines Matching defs:Op0
1571 Value *Op0, Value *Op1) {
1583 match(Op0, m_OneUse(m_Intrinsic<Intrinsic::is_fpclass>(
1588 if ((((IsLHSClass || matchIsFPClassLikeFCmp(Op0, ClassVal0, ClassMask0)) &&
1607 auto *II = cast<IntrinsicInst>(Op0);
1662 Value *Op0 = BO.getOperand(0), *Op1 = BO.getOperand(1), *X;
1664 std::swap(Op0, Op1);
1670 if (!match(Op0, m_SpecificFCmp(NanPred, m_Value(X), m_AnyZeroFP())) ||
1688 Builder.CreateFCmpFMF(NanPred, X, Y, FMFSource::intersect(Op0, BO10));
1705 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1707 if (match(Op0, m_OneUse(m_Not(m_Value(A)))) &&
1722 if (match(Op0, m_OneUse(m_c_BinOp(Opcode, m_Value(A), m_Not(m_Value(B))))) &&
1787 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1793 auto FoldBitwiseICmpZeroWithICmp = [&](Value *Op0,
1797 match(Op0,
1800 m_SpecificInt(Op0->getType()->getScalarSizeInBits() - 1)))) &&
1811 return new ZExtInst(BitwiseOp, Op0->getType());
1814 if (auto *Ret = FoldBitwiseICmpZeroWithICmp(Op0, Op1))
1817 if (auto *Ret = FoldBitwiseICmpZeroWithICmp(Op1, Op0))
1820 CastInst *Cast0 = dyn_cast<CastInst>(Op0);
1883 Value *Op0 = I.getOperand(0);
1887 // Operand complexity canonicalization guarantees that the 'or' is Op0.
1898 if (Op0->hasOneUse() || Op1->hasOneUse())
1909 Value *Op0 = I.getOperand(0);
1913 // Operand complexity canonicalization guarantees that the 'and' is Op0.
1916 if (Op0->hasOneUse() || Op1->hasOneUse())
1917 if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
1921 // Operand complexity canonicalization guarantees that the 'xor' is Op0.
1924 if (Op0->hasOneUse() || Op1->hasOneUse())
1925 if (match(Op0, m_Xor(m_Value(A), m_Value(B))) &&
1933 if (match(Op0, m_c_And(m_Value(A), m_Not(m_Value(B)))) &&
1955 Value *Op0 = And.getOperand(0), *Op1 = And.getOperand(1);
1957 if (!match(Op0, m_OneUse(m_Add(m_Specific(Op1), m_Constant(C)))) &&
1958 !match(Op0, m_OneUse(m_Mul(m_Specific(Op1), m_Constant(C)))) &&
1959 !match(Op0, m_OneUse(m_LShr(m_Specific(Op1), m_Constant(C)))) &&
1960 !match(Op0, m_OneUse(m_Shl(m_Specific(Op1), m_Constant(C)))) &&
1961 !match(Op0, m_OneUse(m_Sub(m_Constant(C), m_Specific(Op1)))))
1975 Instruction::BinaryOps Opc = cast<BinaryOperator>(Op0)->getOpcode();
1999 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2026 if (matchNotOrAnd(Op0, m_Value(A), m_Value(B), m_Value(C), X)) {
2065 if (Opcode == Instruction::Or && Op0->hasOneUse() &&
2082 if (match(Op0,
2086 match(Op0, m_OneUse(m_c_BinOp(
2170 Value *Op0 = I.getOperand(0);
2175 if (!(match(Op0, m_OneUse(m_Add(m_Value(X), m_APInt(C2)))) &&
2198 ConstantInt::get(Ty, *C2), Op0);
2405 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2409 if ((match(Op0, m_OneUse(m_LogicalShift(m_One(), m_Value(X)))) ||
2410 (match(Op0, m_OneUse(m_Shl(m_APInt(C), m_Value(X)))) && (*C)[0])) &&
2438 if (match(Op0, m_OneUse(m_Xor(m_Value(X), m_APInt(XorC))))) {
2442 And->takeName(Op0);
2447 if (match(Op0, m_OneUse(m_Or(m_Value(X), m_APInt(OrC))))) {
2456 And->takeName(Op0);
2462 if (match(Op0, m_OneUse(m_SExt(m_AShr(m_Value(X), m_APInt(ShiftC))))) &&
2475 if (match(Op0, m_AShr(m_Value(X), m_APInt(ShiftC))) && ShiftC->ult(Width) &&
2480 if (match(Op0, m_Add(m_Value(X), m_APInt(AddC)))) {
2485 if (Op0->hasOneUse() && C->isPowerOf2() && (*AddC & (*C - 1)) == 0) {
2507 if (match(Op0, m_OneUse(m_BinOp(BO))) && isNarrowableBinOpcode(BO)) {
2554 if (match(Op0, m_OneUse(m_Xor(m_Value(X), m_Value(Y)))) ||
2555 match(Op0, m_OneUse(m_Or(m_Value(X), m_Value(Y))))) {
2557 BinaryOperator::BinaryOps BinOp = cast<BinaryOperator>(Op0)->getOpcode();
2577 match(Op0, m_OneUse(m_LogicalShift(m_Power2(ShiftC), m_Value(X))))) {
2581 cast<BinaryOperator>(Op0)->getOpcode() == Instruction::Shl;
2594 if (match(Op0, m_OneUse(m_LShr(m_Shl(m_ImmConstant(C1), m_Value(X)),
2610 if (match(Op0, m_OneUse(m_Shl(m_LShr(m_ImmConstant(C1), m_Value(X)),
2638 if (match(Op0, m_ElementWiseBitCast(m_Value(CastOp))) &&
2666 if (auto *SI0 = dyn_cast<SelectInst>(Op0)) {
2673 foldAndOrOfSelectUsingImpliedCond(Op0, *SI1, /* IsAnd */ true))
2687 if (match(Op1, m_Not(m_c_Xor(m_Specific(Op0), m_Value(B)))))
2688 return BinaryOperator::CreateAnd(Op0, B);
2690 if (match(Op0, m_Not(m_c_Xor(m_Specific(Op1), m_Value(B)))))
2694 if (match(Op0, m_Xor(m_Value(A), m_Value(B))) &&
2700 return BinaryOperator::CreateAnd(Op0, NotC);
2704 if (match(Op0, m_Xor(m_Xor(m_Value(A), m_Value(C)), m_Value(B))) &&
2706 Value *NotC = Op0->hasOneUse()
2718 match(Op0, m_c_Or(m_Specific(A), m_Specific(B))))
2725 if (match(Op0, m_c_Xor(m_Not(m_Value(A)), m_Value(B))) &&
2733 if (match(Op0, m_c_Or(m_Not(m_Value(A)), m_Value(B))) &&
2742 match(Op0, m_c_Xor(m_Specific(A), m_Specific(B))))
2747 foldBooleanAndOr(Op0, Op1, I, /*IsAnd=*/true, /*IsLogical=*/false))
2752 if (auto *V = reassociateBooleanAndOr(Op0, X, Y, I, /*IsAnd=*/true,
2756 if (match(Op0, m_OneUse(m_LogicalAnd(m_Value(X), m_Value(Y))))) {
2757 bool IsLogical = isa<SelectInst>(Op0);
2840 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))
2850 simplifyAndOrWithOpReplaced(Op0, Op1, Constant::getAllOnesValue(Ty),
2854 simplifyAndOrWithOpReplaced(Op1, Op0, Constant::getAllOnesValue(Ty),
2856 return BinaryOperator::CreateAnd(Op0, V);
3073 Value *Op0 = Or.getOperand(0), *Op1 = Or.getOperand(1);
3082 if (!isa<ZExtInst>(Op0))
3083 std::swap(Op0, Op1);
3088 if (!match(Op0, m_OneUse(m_ZExt(m_Value(LowerSrc)))) ||
3587 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
3590 if (auto *SI0 = dyn_cast<SelectInst>(Op0)) {
3597 foldAndOrOfSelectUsingImpliedCond(Op0, *SI1, /* IsAnd */ false))
3652 if (match(Op0, m_And(m_Value(A), m_Value(C))) &&
3706 if (Op0->hasOneUse() || Op1->hasOneUse()) {
3727 if (match(Op0, m_And(m_Value(A), m_Value(C))) &&
3729 (Op0->hasOneUse() || Op1->hasOneUse())) {
3742 if (match(Op0, m_Xor(m_Value(A), m_Value(B))))
3746 return BinaryOperator::CreateOr(Op0, C);
3750 if (match(Op0,
3752 match(Op0, m_c_Xor(m_c_Xor(m_Specific(A), m_Value(C)), m_Specific(B))))
3760 if (match(Op0, m_Xor(m_Value(), m_Value()))) {
3761 std::swap(Op0, Op1);
3768 if (match(Op0, m_c_Or(m_Specific(A), m_Value())))
3769 return BinaryOperator::CreateOr(Op0, B);
3770 if (match(Op0, m_c_Or(m_Specific(B), m_Value())))
3771 return BinaryOperator::CreateOr(Op0, A);
3775 if (match(Op0, m_c_And(m_Specific(A), m_Specific(B))))
3780 // The swap above should always make Op0 the 'not'.
3781 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3782 (match(Op0, m_Not(m_Specific(A))) || match(Op0, m_Not(m_Specific(B)))))
3789 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3790 match(Op0, m_Not(m_CombineAnd(m_Instruction(And),
3793 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3794 match(Op0, m_Not(m_CombineAnd(m_Instruction(And),
3800 if (Op0->hasOneUse() && Op1->hasOneUse() &&
3801 (match(Op0, m_c_Or(m_Not(m_Specific(A)), m_Value(C))) ||
3802 match(Op0, m_c_Or(m_Not(m_Specific(B)), m_Value(C))))) {
3809 std::swap(Op0, Op1);
3812 foldBooleanAndOr(Op0, Op1, I, /*IsAnd=*/false, /*IsLogical=*/false))
3817 if (auto *V = reassociateBooleanAndOr(Op0, X, Y, I, /*IsAnd=*/false,
3821 if (match(Op0, m_OneUse(m_LogicalOr(m_Value(X), m_Value(Y))))) {
3822 bool IsLogical = isa<SelectInst>(Op0);
3852 if (Op0->hasOneUse() && !match(Op1, m_ConstantInt()) &&
3853 match(Op0, m_Or(m_Value(A), m_ConstantInt(CI)))) {
3855 Inner->takeName(Op0);
3864 if (Op0->hasOneUse() && Op1->hasOneUse() &&
3865 match(Op0, m_Select(m_Value(X), m_Value(A), m_Value(B))) &&
3900 if (Instruction *Result = TryXorOpt(Op0, Op1))
3902 if (Instruction *Result = TryXorOpt(Op1, Op0))
4021 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))
4039 if (match(Op0, m_ElementWiseBitCast(m_Value(CastOp))) &&
4052 if (match(Op0, m_OneUse(m_And(m_Value(X), m_APInt(C1)))) &&
4063 simplifyAndOrWithOpReplaced(Op0, Op1, Constant::getNullValue(Ty),
4067 simplifyAndOrWithOpReplaced(Op1, Op0, Constant::getNullValue(Ty),
4069 return BinaryOperator::CreateOr(Op0, V);
4083 Value *Op0 = I.getOperand(0);
4114 if (!Op0->hasOneUse() && !Op1->hasOneUse())
4122 if ((match(Op0, m_Or(m_Value(A), m_Value(B))) &&
4124 (match(Op0, m_And(m_Value(A), m_Value(B))) &&
4343 Value *Op0 = Xor.getOperand(0), *Op1 = Xor.getOperand(1);
4344 if (Op0->hasNUses(2))
4345 std::swap(Op0, Op1);
4352 match(Op0, m_OneUse(m_c_Add(m_Specific(A), m_Specific(Op1))))) {
4358 auto *Add = cast<BinaryOperator>(Op0);
4391 Value *Op0, *Op1;
4392 if (!match(&I, m_LogicalOp(m_Value(Op0), m_Value(Op1))))
4397 if (Op0 == Op1)
4409 if (!canFreelyInvert(*this, Op0, &I) || !canFreelyInvert(*this, Op1, &I))
4412 Op0 = freelyInvert(*this, Op0, &I);
4418 NewLogicOp = Builder.CreateBinOp(NewOpc, Op0, Op1, I.getName() + ".not");
4421 Builder.CreateLogicalOp(NewOpc, Op0, Op1, I.getName() + ".not");
4437 Value *Op0, *Op1;
4438 if (!match(&I, m_LogicalOp(m_Value(Op0), m_Value(Op1))))
4447 if (match(Op0, m_Not(m_Value(NotOp0))) && canFreelyInvert(*this, Op1, &I)) {
4448 Op0 = NotOp0;
4451 canFreelyInvert(*this, Op0, &I)) {
4453 OpToInvert = &Op0;
4466 NewBinOp = Builder.CreateBinOp(NewOpc, Op0, Op1, I.getName() + ".not");
4468 NewBinOp = Builder.CreateLogicalOp(NewOpc, Op0, Op1, I.getName() + ".not");
4695 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
4716 return BinaryOperator::CreateDisjointOr(Op0, Op1);
4718 return BinaryOperator::CreateOr(Op0, Op1);
4728 if (match(Op0, m_OneUse(m_Or(m_Value(X), m_ImmConstant(C2)))) &&
4740 if (match(Op0, m_OneUse(m_Or(m_Not(m_Value(X)), m_Constant(C2))))) {
4745 if (match(Op0, m_OneUse(m_And(m_Not(m_Value(X)), m_Constant(C2))))) {
4756 if (match(Op0, m_OneUse(m_TruncOrSelf(
4773 if (RHSC->isSignMask() && match(Op0, m_Sub(m_APInt(C), m_Value(X))))
4777 if (RHSC->isSignMask() && match(Op0, m_Add(m_Value(X), m_APInt(C))))
4781 if (match(Op0, m_Or(m_Value(X), m_APInt(C))) &&
4788 auto *II = dyn_cast<IntrinsicInst>(Op0);
4804 if (match(Op0, m_OneUse(m_Shl(m_Value(X), m_APInt(C)))) &&
4810 if (match(Op0, m_OneUse(m_LShr(m_Value(X), m_APInt(C)))) &&
4829 if (match(Op0, m_ElementWiseBitCast(m_Value(CastOp))) &&
4847 match(Op0, m_LShr(m_Xor(m_Value(X), m_ConstantInt(C1)),
4849 Op0->hasOneUse()) {
4855 Opnd0->takeName(Op0);
4865 if (match(Op1, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op0)))))
4866 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op0));
4869 if (match(Op0, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op1)))))
4874 if (match(Op1, m_OneUse(m_c_And(m_Value(X), m_Specific(Op0)))))
4875 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(X));
4882 match(Op0, m_OneUse(m_c_And(m_Value(X), m_Specific(Op1)))))
4899 if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
4903 if (match(Op0, m_Xor(m_Value(A), m_Value(B))) &&
4909 if (match(Op0, m_c_And(m_Value(A), m_Not(m_Value(B)))) &&
4918 if (match(Op0, m_OneUse(m_c_Or(m_Not(m_Specific(Op1)), m_Value(B)))))
4922 if (match(Op1, m_OneUse(m_c_Or(m_Not(m_Specific(Op0)), m_Value(B)))))
4923 return BinaryOperator::CreateNot(Builder.CreateAnd(Op0, B));
4928 if (match(Op0, m_OneUse(m_Or(m_Value(A), m_Value(B)))) &&
4944 bool NeedFreeze = isa<SelectInst>(Op0) && isa<SelectInst>(Op1) && B == D;
4984 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))