Lines Matching defs:Op1
1527 Value *Op0, Value *Op1) {
1542 match(Op1, m_OneUse(m_Intrinsic<Intrinsic::is_fpclass>(
1545 (IsRHSClass || matchIsFPClassLikeFCmp(Op1, ClassVal1, ClassMask1)))) &&
1570 auto *II = cast<IntrinsicInst>(Op1);
1618 Value *Op0 = BO.getOperand(0), *Op1 = BO.getOperand(1), *X;
1620 if (match(Op1, m_FCmp(Pred, m_Value(), m_AnyZeroFP())))
1621 std::swap(Op0, Op1);
1628 !match(Op1, m_BinOp(Opcode, m_Value(BO10), m_Value(BO11))))
1665 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1668 match(Op1, m_OneUse(m_Not(m_Value(B)))) &&
1683 match(Op1, m_Not(m_Value(C)))) {
1747 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1754 Value *Op1) -> Instruction * {
1762 match(Op1, m_OneUse(m_ZExt(m_ICmp(Pred, m_Value(), m_Value()))));
1769 auto *ICmpR = cast<ZExtInst>(Op1)->getOperand(0);
1775 if (auto *Ret = FoldBitwiseICmpZeroWithICmp(Op0, Op1))
1778 if (auto *Ret = FoldBitwiseICmpZeroWithICmp(Op1, Op0))
1795 CastInst *Cast1 = dyn_cast<CastInst>(Op1);
1845 Value *Op1 = I.getOperand(1);
1859 if (Op0->hasOneUse() || Op1->hasOneUse())
1871 Value *Op1 = I.getOperand(1);
1877 if (Op0->hasOneUse() || Op1->hasOneUse())
1879 match(Op1, m_Not(m_c_Or(m_Specific(A), m_Specific(B)))))
1885 if (Op0->hasOneUse() || Op1->hasOneUse())
1887 match(Op1, m_Not(m_c_Or(m_Specific(A), m_Specific(B)))))
1895 match(Op1, m_c_And(m_Not(m_Specific(A)), m_Specific(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)))))
1926 if (!match(Op1, m_ZExt(m_Value(X))) || Op1->hasNUsesOrMore(3))
1960 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1990 if (matchNotOrAnd(Op1, m_Specific(A), m_Specific(C), m_Specific(B), Dummy,
2000 if (matchNotOrAnd(Op1, m_Specific(B), m_Specific(C), m_Specific(A), Dummy,
2010 if (match(Op1, m_OneUse(m_Not(m_OneUse(
2017 if (match(Op1, m_OneUse(m_Not(m_OneUse(
2027 match(Op1, m_OneUse(m_Not(m_CombineAnd(
2055 if (match(Op1, m_OneUse(m_Not(m_c_BinOp(
2058 match(Op1, m_OneUse(m_Not(m_c_BinOp(
2061 match(Op1, m_OneUse(m_Not(m_c_BinOp(
2072 if (match(Op1, m_OneUse(m_Not(m_OneUse(
2080 if (match(Op1, m_OneUse(m_Not(m_OneUse(
2132 Value *Op1 = I.getOperand(1);
2137 match(Op1, m_APInt(C))))
2344 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2350 match(Op1, m_One())) {
2375 if (match(Op1, m_APInt(C))) {
2380 Value *And = Builder.CreateAnd(X, Op1);
2426 Value *NewAnd = Builder.CreateAnd(X, Op1);
2427 return BinaryOperator::CreateXor(NewAnd, Op1);
2500 Value *NewRHS = Builder.CreateAnd(Y, Op1, Y->getName() + ".masked");
2506 Value *NewLHS = Builder.CreateAnd(X, Op1, X->getName() + ".masked");
2578 match(Op1, m_MaxSignedValue()) &&
2598 return BinaryOperator::CreateAnd(SExt, Op1);
2607 foldAndOrOfSelectUsingImpliedCond(Op1, *SI0, /* IsAnd */ true))
2610 if (auto *SI1 = dyn_cast<SelectInst>(Op1)) {
2626 if (match(Op1, m_Not(m_c_Xor(m_Specific(Op0), m_Value(B)))))
2629 if (match(Op0, m_Not(m_c_Xor(m_Specific(Op1), m_Value(B)))))
2630 return BinaryOperator::CreateAnd(Op1, B);
2634 match(Op1, m_Xor(m_Xor(m_Specific(B), m_Value(C)), m_Specific(A)))) {
2635 Value *NotC = Op1->hasOneUse()
2644 match(Op1, m_Xor(m_Specific(B), m_Specific(A)))) {
2649 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(C));
2656 if (match(Op1, m_c_Xor(m_Not(m_Value(A)), m_Value(B))) &&
2665 match(Op1, m_c_Or(m_Specific(A), m_Specific(B))))
2673 match(Op1, m_c_Xor(m_Specific(A), m_Specific(B))))
2680 if (match(Op1, m_c_Or(m_Not(m_Value(A)), m_Value(B))) &&
2687 ICmpInst *RHS = dyn_cast<ICmpInst>(Op1);
2694 if (LHS && match(Op1, m_OneUse(m_LogicalAnd(m_Value(X), m_Value(Y))))) {
2695 bool IsLogical = isa<SelectInst>(Op1);
2812 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))
2822 simplifyAndOrWithOpReplaced(Op0, Op1, Constant::getAllOnesValue(Ty),
2824 return BinaryOperator::CreateAnd(V, Op1);
2826 simplifyAndOrWithOpReplaced(Op1, Op0, Constant::getAllOnesValue(Ty),
3042 Value *Op0 = Or.getOperand(0), *Op1 = Or.getOperand(1);
3052 std::swap(Op0, Op1);
3058 !match(Op1, m_OneUse(m_Shl(m_Value(ShlVal), m_APInt(C)))) ||
3534 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
3539 foldAndOrOfSelectUsingImpliedCond(Op1, *SI0, /* IsAnd */ false))
3542 if (auto *SI1 = dyn_cast<SelectInst>(Op1)) {
3589 match(Op1, m_And(m_Value(B), m_Value(D)))) {
3642 if (Op0->hasOneUse() || Op1->hasOneUse()) {
3664 match(Op1, m_Not(m_Or(m_Value(B), m_Value(D)))) &&
3665 (Op0->hasOneUse() || Op1->hasOneUse())) {
3679 if (match(Op1,
3681 match(Op1, m_c_Xor(m_c_Xor(m_Specific(A), m_Value(C)), m_Specific(B))))
3685 if (match(Op1, m_Xor(m_Value(A), m_Value(B))))
3689 return BinaryOperator::CreateOr(Op1, C);
3697 std::swap(Op0, Op1);
3701 if (match(Op1, m_Xor(m_Value(A), m_Value(B)))) {
3717 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3725 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3729 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3736 if (Op0->hasOneUse() && Op1->hasOneUse() &&
3745 std::swap(Op0, Op1);
3749 ICmpInst *RHS = dyn_cast<ICmpInst>(Op1);
3757 if (LHS && match(Op1, m_OneUse(m_LogicalOr(m_Value(X), m_Value(Y))))) {
3758 bool IsLogical = isa<SelectInst>(Op1);
3822 if (Op0->hasOneUse() && !match(Op1, m_ConstantInt()) &&
3824 Value *Inner = Builder.CreateOr(A, Op1);
3834 if (Op0->hasOneUse() && Op1->hasOneUse() &&
3836 match(Op1, m_Select(m_Value(Y), m_Value(C), m_Value(D))) && X == Y) {
3870 if (Instruction *Result = TryXorOpt(Op0, Op1))
3872 if (Instruction *Result = TryXorOpt(Op1, Op0))
3991 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))
4010 match(Op1, m_SignMask()) &&
4023 match(Op1, m_APInt(C2))) {
4033 simplifyAndOrWithOpReplaced(Op0, Op1, Constant::getNullValue(Ty),
4035 return BinaryOperator::CreateOr(V, Op1);
4037 simplifyAndOrWithOpReplaced(Op1, Op0, Constant::getNullValue(Ty),
4054 Value *Op1 = I.getOperand(1);
4084 if (!Op0->hasOneUse() && !Op1->hasOneUse())
4093 match(Op1, m_Not(m_c_And(m_Specific(A), m_Specific(B))))) ||
4095 match(Op1, m_Not(m_c_Or(m_Specific(A), m_Specific(B))))))
4309 // There are 4 potential commuted variants. Move the 'ashr' candidate to Op1.
4313 Value *Op0 = Xor.getOperand(0), *Op1 = Xor.getOperand(1);
4315 std::swap(Op0, Op1);
4320 if (match(Op1, m_AShr(m_Value(A), m_APInt(ShAmt))) &&
4321 Op1->hasNUses(2) && *ShAmt == Ty->getScalarSizeInBits() - 1 &&
4322 match(Op0, m_OneUse(m_c_Add(m_Specific(A), m_Specific(Op1))))) {
4323 // Op1 = ashr i32 A, 31 ; smear the sign bit
4324 // xor (add A, Op1), Op1 ; add -1 and flip bits if negative
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))
4383 Op1 = freelyInvert(*this, Op1, &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)) {
4419 OpToInvert = &Op1;
4420 } else if (match(Op1, m_Not(m_Value(NotOp1))) &&
4422 Op1 = NotOp1;
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);
4684 if (match(Op1, m_Constant(C1))) {
4721 return SelectInst::Create(IsNotNeg, Op1, Builder.CreateNot(Op1));
4728 if (match(Op1, m_APInt(RHSC))) {
4788 match(Op1, m_SignMask()) &&
4804 if (match(Op1, m_ConstantInt(C3)) &&
4823 if (match(Op1, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op0)))))
4827 if (match(Op0, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op1)))))
4828 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op1));
4832 if (match(Op1, m_OneUse(m_c_And(m_Value(X), m_Specific(Op0)))))
4839 if (!match(Op1, m_Constant()) &&
4840 match(Op0, m_OneUse(m_c_And(m_Value(X), m_Specific(Op1)))))
4841 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(X));
4858 match(Op1, m_c_Xor(m_Specific(A), m_Specific(B))))
4862 match(Op1, m_c_And(m_Specific(A), m_Specific(B))))
4868 match(Op1, m_Not(m_Specific(A))))
4876 if (match(Op0, m_OneUse(m_c_Or(m_Not(m_Specific(Op1)), m_Value(B)))))
4877 return BinaryOperator::CreateNot(Builder.CreateAnd(Op1, B));
4880 if (match(Op1, m_OneUse(m_c_Or(m_Not(m_Specific(Op0)), m_Value(B)))))
4887 match(Op1, m_OneUse(m_Or(m_Value(C), m_Value(D))))) {
4901 match(Op1, m_OneUse(m_LogicalOr(m_Value(C), m_Value(D))))) {
4902 bool NeedFreeze = isa<SelectInst>(Op0) && isa<SelectInst>(Op1) && B == D;
4942 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))