Lines Matching defs:Op0
1319 Value *Op0 = Cmp.getOperand(0), *Op1 = Cmp.getOperand(1);
1323 match(Op0, m_Add(m_Add(m_Value(A), m_Value(B)), m_ConstantInt(CI2))))
1332 if (auto *Phi = dyn_cast<PHINode>(Op0))
3055 static Value *createLogicFromTable(const std::bitset<4> &Table, Value *Op0,
3060 if (Op0->getType()->isVectorTy())
3062 cast<VectorType>(Op0->getType())->getElementCount(), Res);
3070 return HasOneUse ? Builder.CreateNot(Builder.CreateOr(Op0, Op1)) : nullptr;
3072 return HasOneUse ? Builder.CreateAnd(Builder.CreateNot(Op0), Op1) : nullptr;
3074 return Builder.CreateNot(Op0);
3076 return HasOneUse ? Builder.CreateAnd(Op0, Builder.CreateNot(Op1)) : nullptr;
3080 return Builder.CreateXor(Op0, Op1);
3082 return HasOneUse ? Builder.CreateNot(Builder.CreateAnd(Op0, Op1)) : nullptr;
3084 return Builder.CreateAnd(Op0, Op1);
3086 return HasOneUse ? Builder.CreateNot(Builder.CreateXor(Op0, Op1)) : nullptr;
3090 return HasOneUse ? Builder.CreateOr(Builder.CreateNot(Op0), Op1) : nullptr;
3092 return Op0;
3094 return HasOneUse ? Builder.CreateOr(Op0, Builder.CreateNot(Op1)) : nullptr;
3096 return Builder.CreateOr(Op0, Op1);
3112 Value *Op0, *Op1;
3116 m_Add(m_CombineAnd(m_Instruction(Ext0), m_ZExtOrSExt(m_Value(Op0))),
3119 Op0->getType()->isIntOrIntVectorTy(1) &&
3137 createLogicFromTable(Table, Op0, Op1, Builder, Add->hasOneUse()))
3882 Value *Op0 = Cmp.getOperand(0);
3884 const auto *IIOp0 = dyn_cast<IntrinsicInst>(Op0);
3917 Op0->getType(), IIOp0->getIntrinsicID(),
4034 Value *Op0 = II->getOperand(0);
4093 Builder.CreateAdd(Op0, ConstantInt::get(Op1->getType(), EquivOffset)),
4263 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
4265 Instruction *LHSI = dyn_cast<Instruction>(Op0);
4467 static Value *foldICmpWithLowBitMaskedVal(CmpPredicate Pred, Value *Op0,
4528 if (match(Op0, m_c_And(m_Specific(Op1), m_Value(M)))) {
4543 match(Op0, m_OneUse(m_Or(m_Value(X), m_Value(M))))) {
4562 match(Op0, m_OneUse(m_And(m_Value(X), m_Value(M))))) {
4947 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A;
4950 if (match(Op1, m_c_And(m_Specific(Op0), m_Value()))) {
4951 std::swap(Op0, Op1);
4955 if (!match(Op0, m_c_And(m_Specific(Op1), m_Value(A))))
4960 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
4964 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
4966 if (ICmpInst::isEquality(Pred) && Op0->hasOneUse()) {
4987 return new ICmpInst(ICmpInst::getUnsignedPredicate(Pred), Op0, Op1);
5009 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A;
5013 if (match(Op1, m_c_Or(m_Specific(Op0), m_Value(A)))) {
5014 std::swap(Op0, Op1);
5016 } else if (!match(Op0, m_c_Or(m_Specific(Op1), m_Value(A)))) {
5022 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
5026 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
5028 if (ICmpInst::isEquality(Pred) && Op0->hasOneUse()) {
5044 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A;
5047 if (match(Op1, m_c_Xor(m_Specific(Op0), m_Value()))) {
5048 std::swap(Op0, Op1);
5051 if (!match(Op0, m_c_Xor(m_Specific(Op1), m_Value(A))))
5060 return new ICmpInst(PredOut, Op0, Op1);
5072 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
5075 BinaryOperator *BO0 = dyn_cast<BinaryOperator>(Op0);
5088 if (match(Op0, m_OneUse(m_c_Add(m_Specific(Op1), m_Value(X)))) &&
5091 // Op0 u>/u<= (Op0 + X) --> X u>/u<= ~Op0
5092 if (match(Op1, m_OneUse(m_c_Add(m_Specific(Op0), m_Value(X)))) &&
5094 return new ICmpInst(Pred, X, Builder.CreateNot(Op0));
5099 if (match(Op0, m_OneUse(m_Add(m_c_Add(m_Specific(Op1), m_Value(X)),
5105 // Op0 u>/u<= (Op0 + X) + C --> Op0 u>/u<= ~C - X
5106 if (match(Op1, m_OneUse(m_Add(m_c_Add(m_Specific(Op0), m_Value(X)),
5110 return new ICmpInst(Pred, Op0, Builder.CreateSub(C2, X));
5130 // Op0 u> ((Op0 + C) & C) --> Op0 != 0
5131 // Op0 u<= ((Op0 + C) & C) --> Op0 == 0
5135 match(Op0, m_And(m_BinOp(BO), m_LowBitMask(C))) &&
5145 match(BO, m_Add(m_Specific(Op0), m_SpecificIntAllowPoison(*C)))) {
5149 return new ICmpInst(NewPred, Op0, Zero);
5156 // Analyze the case when either Op0 or Op1 is an add instruction.
5157 // Op0 = A + B (or A and B are null); Op1 = C + D (or C and D are null).
5193 if ((C == Op0 || D == Op0) && NoOp1WrapProblem)
5194 return new ICmpInst(Pred, Constant::getNullValue(Op0->getType()),
5195 C == Op0 ? D : C);
5241 // icmp sgt Op0, (C + -1) -> icmp sge Op0, C
5244 return new ICmpInst(CmpInst::ICMP_SGE, Op0, C);
5246 // icmp sle Op0, (C + -1) -> icmp slt Op0, C
5249 return new ICmpInst(CmpInst::ICMP_SLT, Op0, C);
5251 // icmp sge Op0, (C + 1) -> icmp sgt Op0, C
5253 return new ICmpInst(CmpInst::ICMP_SGT, Op0, C);
5255 // icmp slt Op0, (C + 1) -> icmp sle Op0, C
5257 return new ICmpInst(CmpInst::ICMP_SLE, Op0, C);
5265 // icmp ugt Op0, (C - 1) -> icmp uge Op0, C
5266 // icmp ule Op0, (C - 1) -> icmp ult Op0, C
5268 // icmp ule (A + 1), Op0 -> icmp ult A, Op1
5272 // icmp ugt (A + 1), Op0 -> icmp uge A, Op1
5276 // icmp uge Op0, (C + 1) -> icmp ugt Op0, C
5278 return new ICmpInst(CmpInst::ICMP_UGT, Op0, C);
5280 // icmp ult Op0, (C + 1) -> icmp ule Op0, C
5282 return new ICmpInst(CmpInst::ICMP_ULE, Op0, C);
5324 // Analyze the case when either Op0 or Op1 is a sub instruction.
5325 // Op0 = A - B (or A and B are null); Op1 = C - D (or C and D are null).
5343 if (C == Op0 && NoOp1WrapProblem)
5344 return new ICmpInst(Pred, D, Constant::getNullValue(Op0->getType()));
5351 if (C == Op0 && (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_UGE))
5358 if (C == Op0 && (Pred == ICmpInst::ICMP_ULE || Pred == ICmpInst::ICMP_UGT) &&
5389 if ((match(Op0, m_Mul(m_Value(X), m_Value(Z))) &&
5391 (match(Op0, m_Mul(m_Value(Z), m_Value(X))) &&
5445 Op0 == BO1->getOperand(1))
5561 if (match(Op0, m_Shl(m_Specific(Op1), m_One())))
5564 else if (match(Op1, m_Shl(m_Specific(Op0), m_One())))
5566 Constant::getNullValue(Op0->getType()), Op0);
5728 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
5735 if (!match(Op0, m_OneUse(m_c_And(m_Add(m_Value(A), m_AllOnes()),
5742 if (match(Op0, m_OneUse(m_c_And(m_Neg(m_Specific(Op1)), m_Specific(Op1)))))
5745 m_OneUse(m_c_And(m_Neg(m_Specific(Op0)), m_Specific(Op0)))))
5746 A = Op0;
5754 match(Op0, m_OneUse(m_c_Xor(m_Add(m_Specific(Op1), m_AllOnes()),
5759 match(Op1, m_OneUse(m_c_Xor(m_Add(m_Specific(Op0), m_AllOnes()),
5760 m_Specific(Op0))))) {
5761 A = Op0;
5782 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
5785 if (match(Op0, m_Xor(m_Value(A), m_Value(B)))) {
5813 if (match(Op1, m_Xor(m_Value(A), m_Value(B))) && (A == Op0 || B == Op0)) {
5815 Value *OtherVal = A == Op0 ? B : A;
5820 if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
5850 // If either Op0/Op1 are both one use or X^Y will constant fold and one of
5851 // Op0/Op1 are one use, proceed. In those cases we are instruction neutral
5854 int(Op0->hasOneUse()) + int(Op1->hasOneUse()) +
5870 if (match(Op0, m_OneUse(m_Or(m_Value(X), m_Constant(C)))) &&
5879 (Op0->hasOneUse() || Op1->hasOneUse())) {
5883 if (match(Op0, m_And(m_Value(B), m_LowBitMask(MaskC))) &&
5891 if ((match(Op0, m_OneUse(m_LShr(m_Value(A), m_APIntAllowPoison(AP1)))) &&
5893 (match(Op0, m_OneUse(m_AShr(m_Value(A), m_APIntAllowPoison(AP1)))) &&
5910 if (match(Op0, m_OneUse(m_Shl(m_Value(A), m_ConstantInt(Cst1)))) &&
5926 if (Op0->hasOneUse() &&
5927 match(Op0, m_Trunc(m_OneUse(m_LShr(m_Value(A), m_ConstantInt(ShAmt))))) &&
5936 APInt::getLowBitsSet(ASize, Op0->getType()->getPrimitiveSizeInBits());
5954 unsigned BitWidth = Op0->getType()->getScalarSizeInBits();
5955 if (match(Op0, m_AShr(m_Trunc(m_Value(A)), m_SpecificInt(BitWidth - 1))) &&
5970 if (match(Op0, m_c_And(m_Specific(Op1), m_Value())) &&
5972 return new ICmpInst(CmpInst::getInversePredicate(Pred), Op0,
5973 ConstantInt::getNullValue(Op0->getType()));
5975 if (match(Op1, m_c_And(m_Specific(Op0), m_Value())) &&
5976 isKnownToBeAPowerOfTwo(Op0, /* OrZero */ false, 0, &I))
5990 Builder.CreateIntrinsic(Op0->getType(), Intrinsic::fshl, {A, A, B}));
6029 Value *Op0 = ICmp.getOperand(0), *Op1 = ICmp.getOperand(1);
6035 if (!match(Op0, m_OneUse(m_Trunc(m_Value(X)))) || !match(Op1, m_APInt(C)))
6040 if (auto Res = decomposeBitTestICmp(Op0, Op1, Pred, /*WithTrunc=*/true,
6060 if (llvm::Log2_32(MaxRet) + 1 <= Op0->getType()->getScalarSizeInBits())
6641 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
6642 Type *Ty = Op0->getType();
6670 if (!isa<Constant>(Op0) && Op0Known.isConstant())
6675 Pred, Op0, ConstantExpr::getIntegerValue(Ty, Op1Known.getConstant()));
6708 return match(Op0, m_MaxOrMin(m_Value(), m_Value())) ||
6717 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
6722 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6727 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6734 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
6739 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6744 return new ICmpInst(ICmpInst::ICMP_NE, Op0,
6751 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
6755 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6762 return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
6766 return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
6789 if (!match(Op0, m_And(m_Value(LHS), m_APInt(LHSC))) ||
6791 LHS = Op0;
6813 // Op0 eq C_Pow2 -> Op0 ne 0 if Op0 is known to be C_Pow2 or zero.
6816 return new ICmpInst(CmpInst::getInversePredicate(Pred), Op0,
6822 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
6826 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
6830 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
6834 return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Op1);
6949 Value *Op0 = I.getOperand(0);
6959 return new ICmpInst(FlippedStrictness->first, Op0, FlippedStrictness->second);
6991 // A boolean compared to true/false can be simplified to Op0/true/false in
6993 // Cases not handled by InstSimplify are always 'not' of Op0.
7180 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
7186 if (match(Op0, UAddOvResultPat) &&
7195 UAddOv = cast<ExtractValueInst>(Op0)->getAggregateOperand();
7197 Pred == ICmpInst::ICMP_UGT && (Op0 == A || Op0 == B))
7274 Value *Op0, Value *Op1,
7277 if (auto *GEP = dyn_cast<GEPOperator>(Op0))
7281 if (auto *SI = dyn_cast<SelectInst>(Op0))
7285 if (auto *MinMax = dyn_cast<MinMaxIntrinsic>(Op0))
7293 if (match(Op0, m_Add(m_Value(X), m_APInt(C))) && Op1 == X)
7310 if (match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(X), m_Constant(C))) &&
7349 if (Value *V = foldICmpWithLowBitMaskedVal(Pred, Op0, Op1, Q, *this))
7355 if (match(Op0, m_UDiv(m_Specific(Op1), m_CheckedInt(CheckUGT1)))) {
7361 match(Op0, m_SDiv(m_Specific(Op1), m_CheckedInt(CheckUGT1)))) {
7370 if (match(Op0, m_LShr(m_Specific(Op1), m_CheckedInt(CheckNE0)))) {
7376 match(Op0, m_AShr(m_Specific(Op1), m_CheckedInt(CheckNE0)))) {
7388 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
7389 unsigned Op0Cplxity = getComplexity(Op0);
7397 std::swap(Op0, Op1);
7401 if (Value *V = simplifyICmpInst(I.getCmpPredicate(), Op0, Op1, Q))
7408 if (match(Op0, m_Select(m_Value(Cond), m_Value(SelectTrue),
7421 if (Op0->getType()->isIntOrIntVectorTy(1))
7477 Constant *Zero = Constant::getNullValue(Op0->getType());
7478 return new ICmpInst(ICmpInst::ICMP_SLT, Op0, Zero);
7483 Constant *AllOnes = Constant::getAllOnesValue(Op0->getType());
7484 return new ICmpInst(ICmpInst::ICMP_SGT, Op0, AllOnes);
7508 if (Instruction *Res = foldICmpCommutative(I.getCmpPredicate(), Op0, Op1, I))
7511 foldICmpCommutative(I.getSwappedCmpPredicate(), Op1, Op0, I))
7537 if (match(Op0, m_Select(m_Value(Cond), m_Value(A), m_Value(B))) &&
7539 (Op0->hasOneUse() || Op1->hasOneUse())) {
7554 if (Op0->getType()->isPointerTy() && I.isEquality()) {
7556 if (auto *Alloca = dyn_cast<AllocaInst>(getUnderlyingObject(Op0)))
7576 if (match(Op0, m_And(m_Value(X), m_Not(m_Value(Y)))) &&
7582 // Op0 pred Op1 -> ~Op1 pred ~Op0, if this allows us to drop an instruction.
7583 if (Op0->getType()->isIntOrIntVectorTy()) {
7585 if (isFreeToInvert(Op0, Op0->hasOneUse(), ConsumesOp0) &&
7588 Value *InvOp0 = getFreelyInverted(Op0, Op0->hasOneUse(), &Builder);
7614 if (match(Op0, m_NUWMul(m_ZExt(m_Value(X)), m_ZExt(m_Value(Y)))) &&
7616 if (Instruction *R = processUMulZExtIdiom(I, Op0, C, *this))
7628 (Op0->hasOneUse() || Op1->hasOneUse())) {
7629 unsigned OpWidth = Op0->getType()->getScalarSizeInBits();
7631 if (match(Op0, m_CombineAnd(m_Instruction(ShiftI),
7666 if (auto *EVI = dyn_cast<ExtractValueInst>(Op0))
7692 if (match(Op0, m_And(m_SExt(m_Value(A)), m_APInt(C1))) &&
8161 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
8164 if (match(Op0, m_FNeg(m_Value())) && !match(Op1, m_FNeg(m_Value()))) {
8165 std::swap(Op0, Op1);
8169 if (!match(Op1, m_FNeg(m_Specific(Op0))))
8173 // fcmp Pred Op0, -Op0 --> fcmp Pred Op0, 0.0
8174 Constant *Zero = ConstantFP::getZero(Op0->getType());
8175 return new FCmpInst(Pred, Op0, Zero, "", &I);
8306 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
8307 if (Value *V = simplifyFCmpInst(Pred, Op0, Op1, I.getFastMathFlags(),
8312 Type *OpType = Op0->getType();
8314 if (Op0 == Op1) {
8348 if (!match(Op0, m_PosZeroFP()) &&
8349 isKnownNeverNaN(Op0, 0, getSimplifyQuery().getWithInstruction(&I)))
8359 if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_FNeg(m_Value(Y))))
8415 return new FCmpInst(FCmpInst::FCMP_ONE, Op0, Op1, "", &I);
8417 return new FCmpInst(FCmpInst::FCMP_ORD, Op0, ConstantFP::getZero(OpType),
8420 return new FCmpInst(FCmpInst::FCMP_OEQ, Op0, Op1, "", &I);
8422 return new FCmpInst(FCmpInst::FCMP_UNE, Op0, Op1, "", &I);
8424 return new FCmpInst(FCmpInst::FCMP_UNO, Op0, ConstantFP::getZero(OpType),
8427 return new FCmpInst(FCmpInst::FCMP_UEQ, Op0, Op1, "", &I);
8434 match(Op0, m_OneUse(m_ElementWiseBitCast(m_Value(X))))) {
8452 if (match(Op0, m_Instruction(LHSI)) && match(Op1, m_Constant(RHSC))) {
8499 if (match(Op0, m_FNeg(m_Value(X)))) {
8508 if (match(Op0, m_FAdd(m_Value(X), m_AnyZeroFP())))
8513 return new FCmpInst(Pred, Op0, Y, "", &I);
8515 if (match(Op0, m_FPExt(m_Value(X)))) {
8569 if (match(Op0, m_OneUse(m_Intrinsic<Intrinsic::copysign>(m_APFloat(C),
8586 match(Op0, m_Intrinsic<Intrinsic::canonicalize>(m_Value(CanonLHS)));
8594 if (CanonRHS == Op0)
8595 return new FCmpInst(Pred, Op0, Op0, "", &I);