Lines Matching defs:Op0
1527 Value *Op0, Value *Op1) {
1539 match(Op0, m_OneUse(m_Intrinsic<Intrinsic::is_fpclass>(
1544 if ((((IsLHSClass || matchIsFPClassLikeFCmp(Op0, ClassVal0, ClassMask0)) &&
1563 auto *II = cast<IntrinsicInst>(Op0);
1618 Value *Op0 = BO.getOperand(0), *Op1 = BO.getOperand(1), *X;
1621 std::swap(Op0, Op1);
1627 if (!match(Op0, m_FCmp(Pred, m_Value(X), m_AnyZeroFP())) || Pred != NanPred ||
1646 NewFCmpInst->copyIRFlags(Op0);
1665 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1667 if (match(Op0, m_OneUse(m_Not(m_Value(A)))) &&
1682 if (match(Op0, m_OneUse(m_c_BinOp(Opcode, m_Value(A), m_Not(m_Value(B))))) &&
1747 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1753 auto FoldBitwiseICmpZeroWithICmp = [&](Value *Op0,
1758 match(Op0,
1761 m_SpecificInt(Op0->getType()->getScalarSizeInBits() - 1)))) &&
1772 return new ZExtInst(BitwiseOp, Op0->getType());
1775 if (auto *Ret = FoldBitwiseICmpZeroWithICmp(Op0, Op1))
1778 if (auto *Ret = FoldBitwiseICmpZeroWithICmp(Op1, Op0))
1781 CastInst *Cast0 = dyn_cast<CastInst>(Op0);
1844 Value *Op0 = I.getOperand(0);
1848 // Operand complexity canonicalization guarantees that the 'or' is Op0.
1859 if (Op0->hasOneUse() || Op1->hasOneUse())
1870 Value *Op0 = I.getOperand(0);
1874 // Operand complexity canonicalization guarantees that the 'and' is Op0.
1877 if (Op0->hasOneUse() || Op1->hasOneUse())
1878 if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
1882 // Operand complexity canonicalization guarantees that the 'xor' is Op0.
1885 if (Op0->hasOneUse() || Op1->hasOneUse())
1886 if (match(Op0, m_Xor(m_Value(A), m_Value(B))) &&
1894 if (match(Op0, m_c_And(m_Value(A), m_Not(m_Value(B)))) &&
1916 Value *Op0 = And.getOperand(0), *Op1 = And.getOperand(1);
1918 if (!match(Op0, m_OneUse(m_Add(m_Specific(Op1), m_Constant(C)))) &&
1919 !match(Op0, m_OneUse(m_Mul(m_Specific(Op1), m_Constant(C)))) &&
1920 !match(Op0, m_OneUse(m_LShr(m_Specific(Op1), m_Constant(C)))) &&
1921 !match(Op0, m_OneUse(m_Shl(m_Specific(Op1), m_Constant(C)))) &&
1922 !match(Op0, m_OneUse(m_Sub(m_Constant(C), m_Specific(Op1)))))
1936 Instruction::BinaryOps Opc = cast<BinaryOperator>(Op0)->getOpcode();
1960 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1987 if (matchNotOrAnd(Op0, m_Value(A), m_Value(B), m_Value(C), X)) {
2026 if (Opcode == Instruction::Or && Op0->hasOneUse() &&
2043 if (match(Op0,
2047 match(Op0, m_OneUse(m_c_BinOp(
2131 Value *Op0 = I.getOperand(0);
2136 if (!(match(Op0, m_OneUse(m_Add(m_Value(X), m_APInt(C2)))) &&
2159 ConstantInt::get(Ty, *C2), Op0);
2344 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2348 if ((match(Op0, m_OneUse(m_LogicalShift(m_One(), m_Value(X)))) ||
2349 (match(Op0, m_OneUse(m_Shl(m_APInt(C), m_Value(X)))) && (*C)[0])) &&
2377 if (match(Op0, m_OneUse(m_Xor(m_Value(X), m_APInt(XorC))))) {
2381 And->takeName(Op0);
2386 if (match(Op0, m_OneUse(m_Or(m_Value(X), m_APInt(OrC))))) {
2395 And->takeName(Op0);
2401 if (match(Op0, m_OneUse(m_SExt(m_AShr(m_Value(X), m_APInt(ShiftC))))) &&
2414 if (match(Op0, m_AShr(m_Value(X), m_APInt(ShiftC))) && ShiftC->ult(Width) &&
2419 if (match(Op0, m_Add(m_Value(X), m_APInt(AddC)))) {
2424 if (Op0->hasOneUse() && C->isPowerOf2() && (*AddC & (*C - 1)) == 0) {
2446 if (match(Op0, m_OneUse(m_BinOp(BO))) && isNarrowableBinOpcode(BO)) {
2493 if (match(Op0, m_OneUse(m_Xor(m_Value(X), m_Value(Y)))) ||
2494 match(Op0, m_OneUse(m_Or(m_Value(X), m_Value(Y))))) {
2496 BinaryOperator::BinaryOps BinOp = cast<BinaryOperator>(Op0)->getOpcode();
2516 match(Op0, m_OneUse(m_LogicalShift(m_Power2(ShiftC), m_Value(X))))) {
2520 cast<BinaryOperator>(Op0)->getOpcode() == Instruction::Shl;
2533 if (match(Op0, m_OneUse(m_LShr(m_Shl(m_ImmConstant(C1), m_Value(X)),
2549 if (match(Op0, m_OneUse(m_Shl(m_LShr(m_ImmConstant(C1), m_Value(X)),
2577 if (match(Op0, m_ElementWiseBitCast(m_Value(CastOp))) &&
2605 if (auto *SI0 = dyn_cast<SelectInst>(Op0)) {
2612 foldAndOrOfSelectUsingImpliedCond(Op0, *SI1, /* IsAnd */ true))
2626 if (match(Op1, m_Not(m_c_Xor(m_Specific(Op0), m_Value(B)))))
2627 return BinaryOperator::CreateAnd(Op0, B);
2629 if (match(Op0, m_Not(m_c_Xor(m_Specific(Op1), m_Value(B)))))
2633 if (match(Op0, m_Xor(m_Value(A), m_Value(B))) &&
2639 return BinaryOperator::CreateAnd(Op0, NotC);
2643 if (match(Op0, m_Xor(m_Xor(m_Value(A), m_Value(C)), m_Value(B))) &&
2645 Value *NotC = Op0->hasOneUse()
2657 match(Op0, m_c_Or(m_Specific(A), m_Specific(B))))
2664 if (match(Op0, m_c_Xor(m_Not(m_Value(A)), m_Value(B))) &&
2672 if (match(Op0, m_c_Or(m_Not(m_Value(A)), m_Value(B))) &&
2681 match(Op0, m_c_Xor(m_Specific(A), m_Specific(B))))
2686 ICmpInst *LHS = dyn_cast<ICmpInst>(Op0);
2711 if (RHS && match(Op0, m_OneUse(m_LogicalAnd(m_Value(X), m_Value(Y))))) {
2712 bool IsLogical = isa<SelectInst>(Op0);
2812 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))
2822 simplifyAndOrWithOpReplaced(Op0, Op1, Constant::getAllOnesValue(Ty),
2826 simplifyAndOrWithOpReplaced(Op1, Op0, Constant::getAllOnesValue(Ty),
2828 return BinaryOperator::CreateAnd(Op0, V);
3042 Value *Op0 = Or.getOperand(0), *Op1 = Or.getOperand(1);
3051 if (!isa<ZExtInst>(Op0))
3052 std::swap(Op0, Op1);
3057 if (!match(Op0, m_OneUse(m_ZExt(m_Value(LowerSrc)))) ||
3534 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
3537 if (auto *SI0 = dyn_cast<SelectInst>(Op0)) {
3544 foldAndOrOfSelectUsingImpliedCond(Op0, *SI1, /* IsAnd */ false))
3588 if (match(Op0, m_And(m_Value(A), m_Value(C))) &&
3642 if (Op0->hasOneUse() || Op1->hasOneUse()) {
3663 if (match(Op0, m_And(m_Value(A), m_Value(C))) &&
3665 (Op0->hasOneUse() || Op1->hasOneUse())) {
3678 if (match(Op0, m_Xor(m_Value(A), m_Value(B))))
3682 return BinaryOperator::CreateOr(Op0, C);
3686 if (match(Op0,
3688 match(Op0, m_c_Xor(m_c_Xor(m_Specific(A), m_Value(C)), m_Specific(B))))
3696 if (match(Op0, m_Xor(m_Value(), m_Value()))) {
3697 std::swap(Op0, Op1);
3704 if (match(Op0, m_c_Or(m_Specific(A), m_Value())))
3705 return BinaryOperator::CreateOr(Op0, B);
3706 if (match(Op0, m_c_Or(m_Specific(B), m_Value())))
3707 return BinaryOperator::CreateOr(Op0, A);
3711 if (match(Op0, m_c_And(m_Specific(A), m_Specific(B))))
3716 // The swap above should always make Op0 the 'not'.
3717 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3718 (match(Op0, m_Not(m_Specific(A))) || match(Op0, m_Not(m_Specific(B)))))
3725 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3726 match(Op0, m_Not(m_CombineAnd(m_Instruction(And),
3729 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3730 match(Op0, m_Not(m_CombineAnd(m_Instruction(And),
3736 if (Op0->hasOneUse() && Op1->hasOneUse() &&
3737 (match(Op0, m_c_Or(m_Not(m_Specific(A)), m_Value(C))) ||
3738 match(Op0, m_c_Or(m_Not(m_Specific(B)), m_Value(C))))) {
3745 std::swap(Op0, Op1);
3748 ICmpInst *LHS = dyn_cast<ICmpInst>(Op0);
3774 if (RHS && match(Op0, m_OneUse(m_LogicalOr(m_Value(X), m_Value(Y))))) {
3775 bool IsLogical = isa<SelectInst>(Op0);
3822 if (Op0->hasOneUse() && !match(Op1, m_ConstantInt()) &&
3823 match(Op0, m_Or(m_Value(A), m_ConstantInt(CI)))) {
3825 Inner->takeName(Op0);
3834 if (Op0->hasOneUse() && Op1->hasOneUse() &&
3835 match(Op0, m_Select(m_Value(X), m_Value(A), m_Value(B))) &&
3870 if (Instruction *Result = TryXorOpt(Op0, Op1))
3872 if (Instruction *Result = TryXorOpt(Op1, Op0))
3991 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))
4009 if (match(Op0, m_ElementWiseBitCast(m_Value(CastOp))) &&
4022 if (match(Op0, m_OneUse(m_And(m_Value(X), m_APInt(C1)))) &&
4033 simplifyAndOrWithOpReplaced(Op0, Op1, Constant::getNullValue(Ty),
4037 simplifyAndOrWithOpReplaced(Op1, Op0, Constant::getNullValue(Ty),
4039 return BinaryOperator::CreateOr(Op0, V);
4053 Value *Op0 = I.getOperand(0);
4084 if (!Op0->hasOneUse() && !Op1->hasOneUse())
4092 if ((match(Op0, m_Or(m_Value(A), m_Value(B))) &&
4094 (match(Op0, m_And(m_Value(A), m_Value(B))) &&
4313 Value *Op0 = Xor.getOperand(0), *Op1 = Xor.getOperand(1);
4314 if (Op0->hasNUses(2))
4315 std::swap(Op0, Op1);
4322 match(Op0, m_OneUse(m_c_Add(m_Specific(A), m_Specific(Op1))))) {
4328 auto *Add = cast<BinaryOperator>(Op0);
4361 Value *Op0, *Op1;
4362 if (!match(&I, m_LogicalOp(m_Value(Op0), m_Value(Op1))))
4367 if (Op0 == Op1)
4379 if (!canFreelyInvert(*this, Op0, &I) || !canFreelyInvert(*this, Op1, &I))
4382 Op0 = freelyInvert(*this, Op0, &I);
4388 NewLogicOp = Builder.CreateBinOp(NewOpc, Op0, Op1, I.getName() + ".not");
4391 Builder.CreateLogicalOp(NewOpc, Op0, Op1, I.getName() + ".not");
4407 Value *Op0, *Op1;
4408 if (!match(&I, m_LogicalOp(m_Value(Op0), m_Value(Op1))))
4417 if (match(Op0, m_Not(m_Value(NotOp0))) && canFreelyInvert(*this, Op1, &I)) {
4418 Op0 = NotOp0;
4421 canFreelyInvert(*this, Op0, &I)) {
4423 OpToInvert = &Op0;
4436 NewBinOp = Builder.CreateBinOp(NewOpc, Op0, Op1, I.getName() + ".not");
4438 NewBinOp = Builder.CreateLogicalOp(NewOpc, Op0, Op1, I.getName() + ".not");
4669 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
4674 return BinaryOperator::CreateDisjointOr(Op0, Op1);
4676 return BinaryOperator::CreateOr(Op0, Op1);
4687 if (match(Op0, m_OneUse(m_Or(m_Value(X), m_ImmConstant(C2)))) &&
4699 if (match(Op0, m_OneUse(m_Or(m_Not(m_Value(X)), m_Constant(C2))))) {
4704 if (match(Op0, m_OneUse(m_And(m_Not(m_Value(X)), m_Constant(C2))))) {
4715 if (match(Op0, m_OneUse(m_TruncOrSelf(
4732 if (RHSC->isSignMask() && match(Op0, m_Sub(m_APInt(C), m_Value(X))))
4736 if (RHSC->isSignMask() && match(Op0, m_Add(m_Value(X), m_APInt(C))))
4740 if (match(Op0, m_Or(m_Value(X), m_APInt(C))) &&
4747 auto *II = dyn_cast<IntrinsicInst>(Op0);
4762 if (match(Op0, m_OneUse(m_Shl(m_Value(X), m_APInt(C)))) &&
4768 if (match(Op0, m_OneUse(m_LShr(m_Value(X), m_APInt(C)))) &&
4787 if (match(Op0, m_ElementWiseBitCast(m_Value(CastOp))) &&
4805 match(Op0, m_LShr(m_Xor(m_Value(X), m_ConstantInt(C1)),
4807 Op0->hasOneUse()) {
4813 Opnd0->takeName(Op0);
4823 if (match(Op1, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op0)))))
4824 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op0));
4827 if (match(Op0, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op1)))))
4832 if (match(Op1, m_OneUse(m_c_And(m_Value(X), m_Specific(Op0)))))
4833 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(X));
4840 match(Op0, m_OneUse(m_c_And(m_Value(X), m_Specific(Op1)))))
4857 if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
4861 if (match(Op0, m_Xor(m_Value(A), m_Value(B))) &&
4867 if (match(Op0, m_c_And(m_Value(A), m_Not(m_Value(B)))) &&
4876 if (match(Op0, m_OneUse(m_c_Or(m_Not(m_Specific(Op1)), m_Value(B)))))
4880 if (match(Op1, m_OneUse(m_c_Or(m_Not(m_Specific(Op0)), m_Value(B)))))
4881 return BinaryOperator::CreateNot(Builder.CreateAnd(Op0, B));
4886 if (match(Op0, m_OneUse(m_Or(m_Value(A), m_Value(B)))) &&
4900 match(Op0, m_OneUse(m_LogicalAnd(m_Value(A), m_Value(B)))) &&
4902 bool NeedFreeze = isa<SelectInst>(Op0) && isa<SelectInst>(Op1) && B == D;
4942 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))