Lines Matching defs:Op1
1571 Value *Op0, Value *Op1) {
1586 match(Op1, m_OneUse(m_Intrinsic<Intrinsic::is_fpclass>(
1589 (IsRHSClass || matchIsFPClassLikeFCmp(Op1, ClassVal1, ClassMask1)))) &&
1614 auto *II = cast<IntrinsicInst>(Op1);
1662 Value *Op0 = BO.getOperand(0), *Op1 = BO.getOperand(1), *X;
1663 if (match(Op1, m_FCmp(m_Value(), m_AnyZeroFP())))
1664 std::swap(Op0, Op1);
1671 !match(Op1, m_BinOp(Opcode, m_Value(BO10), m_Value(BO11))))
1705 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1708 match(Op1, m_OneUse(m_Not(m_Value(B)))) &&
1723 match(Op1, m_Not(m_Value(C)))) {
1787 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1794 Value *Op1) -> Instruction * {
1801 match(Op1, m_OneUse(m_ZExt(m_ICmp(m_Value(), m_Value()))));
1808 auto *ICmpR = cast<ZExtInst>(Op1)->getOperand(0);
1814 if (auto *Ret = FoldBitwiseICmpZeroWithICmp(Op0, Op1))
1817 if (auto *Ret = FoldBitwiseICmpZeroWithICmp(Op1, Op0))
1834 CastInst *Cast1 = dyn_cast<CastInst>(Op1);
1884 Value *Op1 = I.getOperand(1);
1898 if (Op0->hasOneUse() || Op1->hasOneUse())
1910 Value *Op1 = I.getOperand(1);
1916 if (Op0->hasOneUse() || Op1->hasOneUse())
1918 match(Op1, m_Not(m_c_Or(m_Specific(A), m_Specific(B)))))
1924 if (Op0->hasOneUse() || Op1->hasOneUse())
1926 match(Op1, m_Not(m_c_Or(m_Specific(A), m_Specific(B)))))
1934 match(Op1, m_c_And(m_Not(m_Specific(A)), m_Specific(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)))))
1965 if (!match(Op1, m_ZExt(m_Value(X))) || Op1->hasNUsesOrMore(3))
1999 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2029 if (matchNotOrAnd(Op1, m_Specific(A), m_Specific(C), m_Specific(B), Dummy,
2039 if (matchNotOrAnd(Op1, m_Specific(B), m_Specific(C), m_Specific(A), Dummy,
2049 if (match(Op1, m_OneUse(m_Not(m_OneUse(
2056 if (match(Op1, m_OneUse(m_Not(m_OneUse(
2066 match(Op1, m_OneUse(m_Not(m_CombineAnd(
2094 if (match(Op1, m_OneUse(m_Not(m_c_BinOp(
2097 match(Op1, m_OneUse(m_Not(m_c_BinOp(
2100 match(Op1, m_OneUse(m_Not(m_c_BinOp(
2111 if (match(Op1, m_OneUse(m_Not(m_OneUse(
2119 if (match(Op1, m_OneUse(m_Not(m_OneUse(
2171 Value *Op1 = I.getOperand(1);
2176 match(Op1, m_APInt(C))))
2405 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2411 match(Op1, m_One())) {
2436 if (match(Op1, m_APInt(C))) {
2441 Value *And = Builder.CreateAnd(X, Op1);
2487 Value *NewAnd = Builder.CreateAnd(X, Op1);
2488 return BinaryOperator::CreateXor(NewAnd, Op1);
2561 Value *NewRHS = Builder.CreateAnd(Y, Op1, Y->getName() + ".masked");
2567 Value *NewLHS = Builder.CreateAnd(X, Op1, X->getName() + ".masked");
2639 match(Op1, m_MaxSignedValue()) &&
2659 return BinaryOperator::CreateAnd(SExt, Op1);
2668 foldAndOrOfSelectUsingImpliedCond(Op1, *SI0, /* IsAnd */ true))
2671 if (auto *SI1 = dyn_cast<SelectInst>(Op1)) {
2687 if (match(Op1, m_Not(m_c_Xor(m_Specific(Op0), m_Value(B)))))
2690 if (match(Op0, m_Not(m_c_Xor(m_Specific(Op1), m_Value(B)))))
2691 return BinaryOperator::CreateAnd(Op1, B);
2695 match(Op1, m_Xor(m_Xor(m_Specific(B), m_Value(C)), m_Specific(A)))) {
2696 Value *NotC = Op1->hasOneUse()
2705 match(Op1, m_Xor(m_Specific(B), m_Specific(A)))) {
2710 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(C));
2717 if (match(Op1, m_c_Xor(m_Not(m_Value(A)), m_Value(B))) &&
2726 match(Op1, m_c_Or(m_Specific(A), m_Specific(B))))
2734 match(Op1, m_c_Xor(m_Specific(A), m_Specific(B))))
2741 if (match(Op1, m_c_Or(m_Not(m_Value(A)), m_Value(B))) &&
2747 foldBooleanAndOr(Op0, Op1, I, /*IsAnd=*/true, /*IsLogical=*/false))
2750 if (match(Op1, m_OneUse(m_LogicalAnd(m_Value(X), m_Value(Y))))) {
2751 bool IsLogical = isa<SelectInst>(Op1);
2758 if (auto *V = reassociateBooleanAndOr(Op1, X, Y, I, /*IsAnd=*/true,
2840 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))
2850 simplifyAndOrWithOpReplaced(Op0, Op1, Constant::getAllOnesValue(Ty),
2852 return BinaryOperator::CreateAnd(V, Op1);
2854 simplifyAndOrWithOpReplaced(Op1, Op0, Constant::getAllOnesValue(Ty),
3073 Value *Op0 = Or.getOperand(0), *Op1 = Or.getOperand(1);
3083 std::swap(Op0, Op1);
3089 !match(Op1, m_OneUse(m_Shl(m_Value(ShlVal), m_APInt(C)))) ||
3587 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
3592 foldAndOrOfSelectUsingImpliedCond(Op1, *SI0, /* IsAnd */ false))
3595 if (auto *SI1 = dyn_cast<SelectInst>(Op1)) {
3653 match(Op1, m_And(m_Value(B), m_Value(D)))) {
3706 if (Op0->hasOneUse() || Op1->hasOneUse()) {
3728 match(Op1, m_Not(m_Or(m_Value(B), m_Value(D)))) &&
3729 (Op0->hasOneUse() || Op1->hasOneUse())) {
3743 if (match(Op1,
3745 match(Op1, m_c_Xor(m_c_Xor(m_Specific(A), m_Value(C)), m_Specific(B))))
3749 if (match(Op1, m_Xor(m_Value(A), m_Value(B))))
3753 return BinaryOperator::CreateOr(Op1, C);
3761 std::swap(Op0, Op1);
3765 if (match(Op1, m_Xor(m_Value(A), m_Value(B)))) {
3781 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3789 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3793 if ((Op0->hasOneUse() || Op1->hasOneUse()) &&
3800 if (Op0->hasOneUse() && Op1->hasOneUse() &&
3809 std::swap(Op0, Op1);
3812 foldBooleanAndOr(Op0, Op1, I, /*IsAnd=*/false, /*IsLogical=*/false))
3815 if (match(Op1, m_OneUse(m_LogicalOr(m_Value(X), m_Value(Y))))) {
3816 bool IsLogical = isa<SelectInst>(Op1);
3823 if (auto *V = reassociateBooleanAndOr(Op1, X, Y, I, /*IsAnd=*/false,
3852 if (Op0->hasOneUse() && !match(Op1, m_ConstantInt()) &&
3854 Value *Inner = Builder.CreateOr(A, Op1);
3864 if (Op0->hasOneUse() && Op1->hasOneUse() &&
3866 match(Op1, m_Select(m_Value(Y), m_Value(C), m_Value(D))) && X == Y) {
3900 if (Instruction *Result = TryXorOpt(Op0, Op1))
3902 if (Instruction *Result = TryXorOpt(Op1, Op0))
4021 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))
4040 match(Op1, m_SignMask()) &&
4053 match(Op1, m_APInt(C2))) {
4063 simplifyAndOrWithOpReplaced(Op0, Op1, Constant::getNullValue(Ty),
4065 return BinaryOperator::CreateOr(V, Op1);
4067 simplifyAndOrWithOpReplaced(Op1, Op0, Constant::getNullValue(Ty),
4084 Value *Op1 = I.getOperand(1);
4114 if (!Op0->hasOneUse() && !Op1->hasOneUse())
4123 match(Op1, m_Not(m_c_And(m_Specific(A), m_Specific(B))))) ||
4125 match(Op1, m_Not(m_c_Or(m_Specific(A), m_Specific(B))))))
4339 // There are 4 potential commuted variants. Move the 'ashr' candidate to Op1.
4343 Value *Op0 = Xor.getOperand(0), *Op1 = Xor.getOperand(1);
4345 std::swap(Op0, Op1);
4350 if (match(Op1, m_AShr(m_Value(A), m_APInt(ShAmt))) &&
4351 Op1->hasNUses(2) && *ShAmt == Ty->getScalarSizeInBits() - 1 &&
4352 match(Op0, m_OneUse(m_c_Add(m_Specific(A), m_Specific(Op1))))) {
4353 // Op1 = ashr i32 A, 31 ; smear the sign bit
4354 // xor (add A, Op1), Op1 ; add -1 and flip bits if negative
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))
4413 Op1 = freelyInvert(*this, Op1, &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)) {
4449 OpToInvert = &Op1;
4450 } else if (match(Op1, m_Not(m_Value(NotOp1))) &&
4452 Op1 = NotOp1;
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);
4725 if (match(Op1, m_Constant(C1))) {
4762 return SelectInst::Create(IsNotNeg, Op1, Builder.CreateNot(Op1));
4769 if (match(Op1, m_APInt(RHSC))) {
4830 match(Op1, m_SignMask()) &&
4846 if (match(Op1, m_ConstantInt(C3)) &&
4865 if (match(Op1, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op0)))))
4869 if (match(Op0, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op1)))))
4870 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op1));
4874 if (match(Op1, m_OneUse(m_c_And(m_Value(X), m_Specific(Op0)))))
4881 if (!match(Op1, m_Constant()) &&
4882 match(Op0, m_OneUse(m_c_And(m_Value(X), m_Specific(Op1)))))
4883 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(X));
4900 match(Op1, m_c_Xor(m_Specific(A), m_Specific(B))))
4904 match(Op1, m_c_And(m_Specific(A), m_Specific(B))))
4910 match(Op1, m_Not(m_Specific(A))))
4918 if (match(Op0, m_OneUse(m_c_Or(m_Not(m_Specific(Op1)), m_Value(B)))))
4919 return BinaryOperator::CreateNot(Builder.CreateAnd(Op1, B));
4922 if (match(Op1, m_OneUse(m_c_Or(m_Not(m_Specific(Op0)), m_Value(B)))))
4929 match(Op1, m_OneUse(m_Or(m_Value(C), m_Value(D))))) {
4944 bool NeedFreeze = isa<SelectInst>(Op0) && isa<SelectInst>(Op1) && B == D;
4984 if (Instruction *Folded = foldLogicOfIsFPClass(I, Op0, Op1))