Lines Matching defs:Op0
1297 Value *Op0 = Cmp.getOperand(0), *Op1 = Cmp.getOperand(1);
1301 match(Op0, m_Add(m_Add(m_Value(A), m_Value(B)), m_ConstantInt(CI2))))
1310 if (auto *Phi = dyn_cast<PHINode>(Op0))
2969 static Value *createLogicFromTable(const std::bitset<4> &Table, Value *Op0,
2974 if (Op0->getType()->isVectorTy())
2976 cast<VectorType>(Op0->getType())->getElementCount(), Res);
2984 return HasOneUse ? Builder.CreateNot(Builder.CreateOr(Op0, Op1)) : nullptr;
2986 return HasOneUse ? Builder.CreateAnd(Builder.CreateNot(Op0), Op1) : nullptr;
2988 return Builder.CreateNot(Op0);
2990 return HasOneUse ? Builder.CreateAnd(Op0, Builder.CreateNot(Op1)) : nullptr;
2994 return Builder.CreateXor(Op0, Op1);
2996 return HasOneUse ? Builder.CreateNot(Builder.CreateAnd(Op0, Op1)) : nullptr;
2998 return Builder.CreateAnd(Op0, Op1);
3000 return HasOneUse ? Builder.CreateNot(Builder.CreateXor(Op0, Op1)) : nullptr;
3004 return HasOneUse ? Builder.CreateOr(Builder.CreateNot(Op0), Op1) : nullptr;
3006 return Op0;
3008 return HasOneUse ? Builder.CreateOr(Op0, Builder.CreateNot(Op1)) : nullptr;
3010 return Builder.CreateOr(Op0, Op1);
3026 Value *Op0, *Op1;
3030 m_Add(m_CombineAnd(m_Instruction(Ext0), m_ZExtOrSExt(m_Value(Op0))),
3033 Op0->getType()->isIntOrIntVectorTy(1) &&
3051 createLogicFromTable(Table, Op0, Op1, Builder, Add->hasOneUse()))
3721 Value *Op0 = Cmp.getOperand(0);
3723 const auto *IIOp0 = dyn_cast<IntrinsicInst>(Op0);
3756 Op0->getType(), IIOp0->getIntrinsicID(),
3873 Value *Op0 = II->getOperand(0);
3932 Builder.CreateAdd(Op0, ConstantInt::get(Op1->getType(), EquivOffset)),
4092 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
4094 Instruction *LHSI = dyn_cast<Instruction>(Op0);
4289 static Value *foldICmpWithLowBitMaskedVal(ICmpInst::Predicate Pred, Value *Op0,
4350 if (match(Op0, m_c_And(m_Specific(Op1), m_Value(M)))) {
4365 match(Op0, m_OneUse(m_Or(m_Value(X), m_Value(M))))) {
4384 match(Op0, m_OneUse(m_And(m_Value(X), m_Value(M))))) {
4771 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A;
4774 if (match(Op1, m_c_And(m_Specific(Op0), m_Value()))) {
4775 std::swap(Op0, Op1);
4779 if (!match(Op0, m_c_And(m_Specific(Op1), m_Value(A))))
4784 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
4788 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
4790 if (ICmpInst::isEquality(Pred) && Op0->hasOneUse()) {
4811 return new ICmpInst(ICmpInst::getUnsignedPredicate(Pred), Op0, Op1);
4833 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A;
4837 if (match(Op1, m_c_Or(m_Specific(Op0), m_Value(A)))) {
4838 std::swap(Op0, Op1);
4840 } else if (!match(Op0, m_c_Or(m_Specific(Op1), m_Value(A)))) {
4846 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
4850 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
4852 if (ICmpInst::isEquality(Pred) && Op0->hasOneUse()) {
4868 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A;
4871 if (match(Op1, m_c_Xor(m_Specific(Op0), m_Value()))) {
4872 std::swap(Op0, Op1);
4875 if (!match(Op0, m_c_Xor(m_Specific(Op1), m_Value(A))))
4884 return new ICmpInst(PredOut, Op0, Op1);
4896 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
4899 BinaryOperator *BO0 = dyn_cast<BinaryOperator>(Op0);
4912 if (match(Op0, m_OneUse(m_c_Add(m_Specific(Op1), m_Value(X)))) &&
4915 // Op0 u>/u<= (Op0 + X) --> X u>/u<= ~Op0
4916 if (match(Op1, m_OneUse(m_c_Add(m_Specific(Op0), m_Value(X)))) &&
4918 return new ICmpInst(Pred, X, Builder.CreateNot(Op0));
4923 if (match(Op0, m_OneUse(m_Add(m_c_Add(m_Specific(Op1), m_Value(X)),
4929 // Op0 u>/u<= (Op0 + X) + C --> Op0 u>/u<= ~C - X
4930 if (match(Op1, m_OneUse(m_Add(m_c_Add(m_Specific(Op0), m_Value(X)),
4934 return new ICmpInst(Pred, Op0, Builder.CreateSub(C2, X));
4942 // Op0 u> ((Op0 + C) & C) --> Op0 != 0
4943 // Op0 u<= ((Op0 + C) & C) --> Op0 == 0
4947 match(Op0, m_And(m_BinOp(BO), m_LowBitMask(C))) &&
4957 match(BO, m_Add(m_Specific(Op0), m_SpecificIntAllowPoison(*C)))) {
4961 return new ICmpInst(NewPred, Op0, Zero);
4968 // Analyze the case when either Op0 or Op1 is an add instruction.
4969 // Op0 = A + B (or A and B are null); Op1 = C + D (or C and D are null).
5005 if ((C == Op0 || D == Op0) && NoOp1WrapProblem)
5006 return new ICmpInst(Pred, Constant::getNullValue(Op0->getType()),
5007 C == Op0 ? D : C);
5053 // icmp sgt Op0, (C + -1) -> icmp sge Op0, C
5056 return new ICmpInst(CmpInst::ICMP_SGE, Op0, C);
5058 // icmp sle Op0, (C + -1) -> icmp slt Op0, C
5061 return new ICmpInst(CmpInst::ICMP_SLT, Op0, C);
5063 // icmp sge Op0, (C + 1) -> icmp sgt Op0, C
5065 return new ICmpInst(CmpInst::ICMP_SGT, Op0, C);
5067 // icmp slt Op0, (C + 1) -> icmp sle Op0, C
5069 return new ICmpInst(CmpInst::ICMP_SLE, Op0, C);
5077 // icmp ugt Op0, (C - 1) -> icmp uge Op0, C
5078 // icmp ule Op0, (C - 1) -> icmp ult Op0, C
5080 // icmp ule (A + 1), Op0 -> icmp ult A, Op1
5084 // icmp ugt (A + 1), Op0 -> icmp uge A, Op1
5088 // icmp uge Op0, (C + 1) -> icmp ugt Op0, C
5090 return new ICmpInst(CmpInst::ICMP_UGT, Op0, C);
5092 // icmp ult Op0, (C + 1) -> icmp ule Op0, C
5094 return new ICmpInst(CmpInst::ICMP_ULE, Op0, C);
5136 // Analyze the case when either Op0 or Op1 is a sub instruction.
5137 // Op0 = A - B (or A and B are null); Op1 = C - D (or C and D are null).
5155 if (C == Op0 && NoOp1WrapProblem)
5156 return new ICmpInst(Pred, D, Constant::getNullValue(Op0->getType()));
5163 if (C == Op0 && (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_UGE))
5170 if (C == Op0 && (Pred == ICmpInst::ICMP_ULE || Pred == ICmpInst::ICMP_UGT) &&
5202 ((match(Op0, m_Mul(m_Value(X), m_Value(Z))) &&
5204 (match(Op0, m_Mul(m_Value(Z), m_Value(X))) &&
5234 Op0 == BO1->getOperand(1))
5350 if (match(Op0, m_Shl(m_Specific(Op1), m_One())))
5353 else if (match(Op1, m_Shl(m_Specific(Op0), m_One())))
5355 Constant::getNullValue(Op0->getType()), Op0);
5518 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
5525 if (!match(Op0, m_OneUse(m_c_And(m_Add(m_Value(A), m_AllOnes()),
5532 if (match(Op0, m_OneUse(m_c_And(m_Neg(m_Specific(Op1)), m_Specific(Op1)))))
5535 m_OneUse(m_c_And(m_Neg(m_Specific(Op0)), m_Specific(Op0)))))
5536 A = Op0;
5544 match(Op0, m_OneUse(m_c_Xor(m_Add(m_Specific(Op1), m_AllOnes()),
5549 match(Op1, m_OneUse(m_c_Xor(m_Add(m_Specific(Op0), m_AllOnes()),
5550 m_Specific(Op0))))) {
5551 A = Op0;
5572 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
5575 if (match(Op0, m_Xor(m_Value(A), m_Value(B)))) {
5603 if (match(Op1, m_Xor(m_Value(A), m_Value(B))) && (A == Op0 || B == Op0)) {
5605 Value *OtherVal = A == Op0 ? B : A;
5610 if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
5640 // If either Op0/Op1 are both one use or X^Y will constant fold and one of
5641 // Op0/Op1 are one use, proceed. In those cases we are instruction neutral
5644 int(Op0->hasOneUse()) + int(Op1->hasOneUse()) +
5660 if (match(Op0, m_OneUse(m_Or(m_Value(X), m_Constant(C)))) &&
5669 (Op0->hasOneUse() || Op1->hasOneUse())) {
5673 if (match(Op0, m_And(m_Value(B), m_LowBitMask(MaskC))) &&
5681 if ((match(Op0, m_OneUse(m_LShr(m_Value(A), m_APIntAllowPoison(AP1)))) &&
5683 (match(Op0, m_OneUse(m_AShr(m_Value(A), m_APIntAllowPoison(AP1)))) &&
5700 if (match(Op0, m_OneUse(m_Shl(m_Value(A), m_ConstantInt(Cst1)))) &&
5716 if (Op0->hasOneUse() &&
5717 match(Op0, m_Trunc(m_OneUse(m_LShr(m_Value(A), m_ConstantInt(ShAmt))))) &&
5726 APInt::getLowBitsSet(ASize, Op0->getType()->getPrimitiveSizeInBits());
5744 unsigned BitWidth = Op0->getType()->getScalarSizeInBits();
5745 if (match(Op0, m_AShr(m_Trunc(m_Value(A)), m_SpecificInt(BitWidth - 1))) &&
5760 if (match(Op0, m_c_And(m_Specific(Op1), m_Value())) &&
5762 return new ICmpInst(CmpInst::getInversePredicate(Pred), Op0,
5763 ConstantInt::getNullValue(Op0->getType()));
5765 if (match(Op1, m_c_And(m_Specific(Op0), m_Value())) &&
5766 isKnownToBeAPowerOfTwo(Op0, /* OrZero */ false, 0, &I))
5781 Builder.CreateIntrinsic(Op0->getType(), Intrinsic::fshl, {A, A, B}));
5822 Value *Op0 = ICmp.getOperand(0), *Op1 = ICmp.getOperand(1);
5828 if (!match(Op0, m_OneUse(m_Trunc(m_Value(X)))) || !match(Op1, m_APInt(C)))
5835 if (decomposeBitTestICmp(Op0, Op1, Pred, X, Mask, true /* WithTrunc */)) {
5870 if (llvm::Log2_32(MaxRet) + 1 <= Op0->getType()->getScalarSizeInBits())
6435 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
6436 Type *Ty = Op0->getType();
6484 if (!isa<Constant>(Op0) && Op0Min == Op0Max)
6487 return new ICmpInst(Pred, Op0, ConstantExpr::getIntegerValue(Ty, Op1Min));
6500 return match(Op0, m_MaxOrMin(m_Value(), m_Value())) ||
6509 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
6514 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6519 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6526 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
6531 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6536 return new ICmpInst(ICmpInst::ICMP_NE, Op0,
6543 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
6547 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6554 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
6558 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6585 if (!match(Op0, m_And(m_Value(LHS), m_APInt(LHSC))) ||
6587 LHS = Op0;
6609 // Op0 eq C_Pow2 -> Op0 ne 0 if Op0 is known to be C_Pow2 or zero.
6612 return new ICmpInst(CmpInst::getInversePredicate(Pred), Op0,
6651 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
6660 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
6669 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
6678 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
6687 return new ICmpInst(I.getUnsignedPredicate(), Op0, Op1);
6862 Value *Op0 = I.getOperand(0);
6873 return new ICmpInst(FlippedStrictness->first, Op0, FlippedStrictness->second);
6905 // A boolean compared to true/false can be simplified to Op0/true/false in
6907 // Cases not handled by InstSimplify are always 'not' of Op0.
7094 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
7100 if (match(Op0, UAddOvResultPat) &&
7109 UAddOv = cast<ExtractValueInst>(Op0)->getAggregateOperand();
7111 Pred == ICmpInst::ICMP_UGT && (Op0 == A || Op0 == B))
7188 Value *Op0, Value *Op1,
7191 if (auto *GEP = dyn_cast<GEPOperator>(Op0))
7195 if (auto *SI = dyn_cast<SelectInst>(Op0))
7199 if (auto *MinMax = dyn_cast<MinMaxIntrinsic>(Op0))
7207 if (match(Op0, m_Add(m_Value(X), m_APInt(C))) && Op1 == X)
7224 if (match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(X), m_Constant(C))) &&
7263 if (Value *V = foldICmpWithLowBitMaskedVal(Pred, Op0, Op1, Q, *this))
7269 if (match(Op0, m_UDiv(m_Specific(Op1), m_CheckedInt(CheckUGT1)))) {
7275 match(Op0, m_SDiv(m_Specific(Op1), m_CheckedInt(CheckUGT1)))) {
7284 if (match(Op0, m_LShr(m_Specific(Op1), m_CheckedInt(CheckNE0)))) {
7290 match(Op0, m_AShr(m_Specific(Op1), m_CheckedInt(CheckNE0)))) {
7302 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
7303 unsigned Op0Cplxity = getComplexity(Op0);
7311 std::swap(Op0, Op1);
7315 if (Value *V = simplifyICmpInst(I.getPredicate(), Op0, Op1, Q))
7322 if (match(Op0, m_Select(m_Value(Cond), m_Value(SelectTrue),
7335 if (Op0->getType()->isIntOrIntVectorTy(1))
7391 Constant *Zero = Constant::getNullValue(Op0->getType());
7392 return new ICmpInst(ICmpInst::ICMP_SLT, Op0, Zero);
7397 Constant *AllOnes = Constant::getAllOnesValue(Op0->getType());
7398 return new ICmpInst(ICmpInst::ICMP_SGT, Op0, AllOnes);
7422 if (Instruction *Res = foldICmpCommutative(I.getPredicate(), Op0, Op1, I))
7425 foldICmpCommutative(I.getSwappedPredicate(), Op1, Op0, I))
7451 if (match(Op0, m_Select(m_Value(Cond), m_Value(A), m_Value(B))) &&
7453 (Op0->hasOneUse() || Op1->hasOneUse())) {
7468 if (Op0->getType()->isPointerTy() && I.isEquality()) {
7470 if (auto *Alloca = dyn_cast<AllocaInst>(getUnderlyingObject(Op0)))
7490 if (match(Op0, m_And(m_Value(X), m_Not(m_Value(Y)))) &&
7496 // Op0 pred Op1 -> ~Op1 pred ~Op0, if this allows us to drop an instruction.
7497 if (Op0->getType()->isIntOrIntVectorTy()) {
7499 if (isFreeToInvert(Op0, Op0->hasOneUse(), ConsumesOp0) &&
7502 Value *InvOp0 = getFreelyInverted(Op0, Op0->hasOneUse(), &Builder);
7528 if (match(Op0, m_NUWMul(m_ZExt(m_Value(X)), m_ZExt(m_Value(Y)))) &&
7530 if (Instruction *R = processUMulZExtIdiom(I, Op0, C, *this))
7542 (Op0->hasOneUse() || Op1->hasOneUse())) {
7543 unsigned OpWidth = Op0->getType()->getScalarSizeInBits();
7545 if (match(Op0, m_CombineAnd(m_Instruction(ShiftI),
7580 if (auto *EVI = dyn_cast<ExtractValueInst>(Op0))
7988 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
7991 if (match(Op0, m_FNeg(m_Value())) && !match(Op1, m_FNeg(m_Value()))) {
7992 std::swap(Op0, Op1);
7996 if (!match(Op1, m_FNeg(m_Specific(Op0))))
8000 // fcmp Pred Op0, -Op0 --> fcmp Pred Op0, 0.0
8001 Constant *Zero = ConstantFP::getZero(Op0->getType());
8002 return new FCmpInst(Pred, Op0, Zero, "", &I);
8064 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
8065 if (Value *V = simplifyFCmpInst(Pred, Op0, Op1, I.getFastMathFlags(),
8070 Type *OpType = Op0->getType();
8072 if (Op0 == Op1) {
8106 if (!match(Op0, m_PosZeroFP()) &&
8107 isKnownNeverNaN(Op0, 0, getSimplifyQuery().getWithInstruction(&I)))
8117 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_FNeg(m_Value(Y))))
8173 return new FCmpInst(FCmpInst::FCMP_ONE, Op0, Op1, "", &I);
8175 return new FCmpInst(FCmpInst::FCMP_ORD, Op0, ConstantFP::getZero(OpType),
8178 return new FCmpInst(FCmpInst::FCMP_OEQ, Op0, Op1, "", &I);
8180 return new FCmpInst(FCmpInst::FCMP_UNE, Op0, Op1, "", &I);
8182 return new FCmpInst(FCmpInst::FCMP_UNO, Op0, ConstantFP::getZero(OpType),
8185 return new FCmpInst(FCmpInst::FCMP_UEQ, Op0, Op1, "", &I);
8192 match(Op0, m_OneUse(m_ElementWiseBitCast(m_Value(X))))) {
8210 if (match(Op0, m_Instruction(LHSI)) && match(Op1, m_Constant(RHSC))) {
8253 if (match(Op0, m_FNeg(m_Value(X)))) {
8262 if (match(Op0, m_FAdd(m_Value(X), m_AnyZeroFP())))
8267 return new FCmpInst(Pred, Op0, Y, "", &I);
8269 if (match(Op0, m_FPExt(m_Value(X)))) {
8323 if (match(Op0, m_OneUse(m_Intrinsic<Intrinsic::copysign>(m_APFloat(C),
8340 match(Op0, m_Intrinsic<Intrinsic::canonicalize>(m_Value(CanonLHS)));
8348 if (CanonRHS == Op0)
8349 return new FCmpInst(Pred, Op0, Op0, "", &I);