reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/IR/InstrTypes.h

  824   bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
  825   bool isIntPredicate() const { return isIntPredicate(getPredicate()); }
  832     return getInversePredicate(getPredicate());
  848     return getSwappedPredicate(getPredicate());
  863     return getFlippedStrictnessPredicate(getPredicate());
  874     return getNonStrictPredicate(getPredicate());
  903     return isSigned(getPredicate());
  909     return isUnsigned(getPredicate());
  922     return getSignedPredicate(getPredicate());
  928     return isTrueWhenEqual(getPredicate());
  934     return isFalseWhenEqual(getPredicate());

include/llvm/IR/Instructions.h

 1220     return getSignedPredicate(getPredicate());
 1232     return getUnsignedPredicate(getPredicate());
 1248     return isEquality(getPredicate());
 1359   bool isEquality() const { return isEquality(getPredicate()); }
 1365            getPredicate() == FCMP_FALSE ||
 1366            getPredicate() == FCMP_TRUE ||
 1367            getPredicate() == FCMP_ORD ||
 1368            getPredicate() == FCMP_UNO;

include/llvm/IR/PatternMatch.h

 1137         Predicate = I->getPredicate();
 1457         LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();

lib/Analysis/BranchProbabilityInfo.cpp

  422   bool isProb = CI->getPredicate() == ICmpInst::ICMP_NE;
  560       Constant *Result = ConstantExpr::getCompare(CI->getPredicate(),
  709     switch (CI->getPredicate()) {
  720     switch (CI->getPredicate()) {
  740   } else if (CV->isOne() && CI->getPredicate() == CmpInst::ICMP_SLT) {
  745     switch (CI->getPredicate()) {
  795   } else if (FCmp->getPredicate() == FCmpInst::FCMP_ORD) {
  800   } else if (FCmp->getPredicate() == FCmpInst::FCMP_UNO) {

lib/Analysis/CmpInstAnalysis.cpp

   23                                         : ICI->getPredicate();

lib/Analysis/ConstantFolding.cpp

 1167     return ConstantFoldCompareInstOperands(CI->getPredicate(), Ops[0], Ops[1],

lib/Analysis/InlineCost.cpp

  986         return ConstantExpr::getCompare(I.getPredicate(), COps[0], COps[1]);
 1005       if (Constant *C = ConstantExpr::getICmp(I.getPredicate(), CLHS, CRHS)) {
 1017     bool IsNotEqual = I.getPredicate() == CmpInst::ICMP_NE;

lib/Analysis/InstructionSimplify.cpp

  132   CmpInst::Predicate CPred = Cmp->getPredicate();
 1547   auto Range0 = ConstantRange::makeExactICmpRegion(Cmp0->getPredicate(), *C0);
 1548   auto Range1 = ConstantRange::makeExactICmpRegion(Cmp1->getPredicate(), *C1);
 1575   ICmpInst::Predicate P0 = Cmp0->getPredicate(), P1 = Cmp1->getPredicate();
 1575   ICmpInst::Predicate P0 = Cmp0->getPredicate(), P1 = Cmp1->getPredicate();
 1763   FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 1763   FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 2263   if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS)
 2265   if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) &&
 3710         return SimplifyCmpInst(C->getPredicate(), RepOp, C->getOperand(1), Q,
 3713         return SimplifyCmpInst(C->getPredicate(), C->getOperand(0), RepOp, Q,
 3748         return ConstantFoldCompareInstOperands(C->getPredicate(), ConstOps[0],
 5321     Result = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(),
 5326         SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), I->getOperand(0),

lib/Analysis/LazyValueInfo.cpp

  956     ICmpInst::Predicate Pred = ICI->getPredicate();
 1194   CmpInst::Predicate Predicate = ICI->getPredicate();

lib/Analysis/LoopInfo.cpp

  242                                  ? LatchCmpInst->getPredicate()

lib/Analysis/LoopUnrollAnalyzer.cpp

  195         if (Constant *C = ConstantExpr::getCompare(I.getPredicate(), CLHS, CRHS)) {

lib/Analysis/MustExecute.cpp

  141   auto *SimpleValOrNull = SimplifyCmpInst(Cond->getPredicate(),

lib/Analysis/ScalarEvolution.cpp

 5343   switch (ICI->getPredicate()) {
 7364     Pred = ExitCond->getPredicate();
 7837     return ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
 8249             C = ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
 9704     FoundPred = ICI->getPredicate();

lib/Analysis/ValueTracking.cpp

  633     switch (Cmp->getPredicate()) {
 5073   CmpInst::Predicate Pred = CmpI->getPredicate();
 5279       LHSIsTrue ? LHS->getPredicate() : LHS->getInversePredicate();
 5283   ICmpInst::Predicate BPred = RHS->getPredicate();

lib/Bitcode/Writer/BitcodeWriter.cpp

 2700     Vals.push_back(cast<CmpInst>(I).getPredicate());

lib/CodeGen/CodeGenPrepare.cpp

 1237   ICmpInst::Predicate Pred = Cmp->getPredicate();
 1292   ICmpInst::Predicate Pred = Cmp->getPredicate();
 1389           CmpInst::Create(Cmp->getOpcode(), Cmp->getPredicate(),

lib/CodeGen/GlobalISel/IRTranslator.cpp

  343       CI ? CI->getPredicate() : static_cast<CmpInst::Predicate>(

lib/CodeGen/HardwareLoops.cpp

  310   unsigned SuccIdx = ICmp->getPredicate() == ICmpInst::ICMP_NE ? 0 : 1;

lib/CodeGen/SelectionDAG/FastISel.cpp

 2439   CmpInst::Predicate Predicate = CI->getPredicate();

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 2044             InvertCond ? IC->getInversePredicate() : IC->getPredicate();
 2049             InvertCond ? FC->getInversePredicate() : FC->getPredicate();
 3199     predicate = IC->getPredicate();
 3226     predicate = FC->getPredicate();

lib/ExecutionEngine/Interpreter/Execution.cpp

  338   switch (I.getPredicate()) {
  670   switch (I.getPredicate()) {

lib/IR/AsmWriter.cpp

 3709     Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());

lib/IR/Core.cpp

 2737     return (LLVMIntPredicate)I->getPredicate();
 2746     return (LLVMRealPredicate)I->getPredicate();

lib/IR/Instruction.cpp

  401     return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
  401     return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();

lib/IR/Instructions.cpp

 4114   return new FCmpInst(getPredicate(), Op<0>(), Op<1>());
 4118   return new ICmpInst(getPredicate(), Op<0>(), Op<1>());

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  349   NewICmp = Builder.CreateICmp(I.getPredicate(), ExtOp0, ExtOp1);

lib/Target/ARM/ARMFastISel.cpp

 1250       CmpInst::Predicate Predicate = CI->getPredicate();
 1473   ARMCC::CondCodes ARMPred = getComparePred(CI->getPredicate());

lib/Target/Mips/MipsFastISel.cpp

  647   CmpInst::Predicate P = CI->getPredicate();

lib/Target/PowerPC/PPCFastISel.cpp

  778       Optional<PPC::Predicate> OptPPCPred = getComparePred(CI->getPredicate());

lib/Target/SystemZ/SystemZTDC.cpp

  124   auto Pred = I.getPredicate();
  234   auto Pred = I.getPredicate();

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

  819         switch (cast<CmpInst>(I)->getPredicate()) {

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

 1005   switch (ICmp->getPredicate()) {
 1074   switch (FCmp->getPredicate()) {

lib/Target/X86/X86FastISel.cpp

 2305     std::tie(CC, NeedSwap) = X86::getX86ConditionCode(CI->getPredicate());

lib/Target/X86/X86TargetTransformInfo.cpp

 1711       switch (cast<CmpInst>(I)->getPredicate()) {

lib/Transforms/IPO/GlobalOpt.cpp

  916       switch (ICI->getPredicate()) {
 1208     Value *New = new ICmpInst(SCI, SCI->getPredicate(), NPtr,

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

  609   ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
  609   ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
  761                                Cmp0->getPredicate());
  769                                Cmp1->getPredicate());
  817   ICmpInst::Predicate Pred = LHS->getPredicate();
  818   if (Pred !=  RHS->getPredicate())
  863   ICmpInst::Predicate Pred = LHS->getPredicate();
  864   if (Pred != RHS->getPredicate())
  964     CmpInst::Predicate Pred = ICmp->getPredicate();
 1026   if (JoinedByAnd && Cmp1->getPredicate() == ICmpInst::ICMP_NE)
 1028   else if (!JoinedByAnd && Cmp1->getPredicate() == ICmpInst::ICMP_EQ)
 1154   ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 1154   ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 1363   FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 1363   FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 2196   ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 2196   ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 2250           return Builder.CreateICmp(LHS->getPredicate(), NewAdd, LHSC);
 2802   if (predicatesFoldable(LHS->getPredicate(), RHS->getPredicate())) {
 2802   if (predicatesFoldable(LHS->getPredicate(), RHS->getPredicate())) {
 2819   ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
 2819   ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();

lib/Transforms/InstCombine/InstCombineCasts.cpp

  856     if ((ICI->getPredicate() == ICmpInst::ICMP_SLT && Op1CV->isNullValue()) ||
  857         (ICI->getPredicate() == ICmpInst::ICMP_SGT && Op1CV->isAllOnesValue())) {
  867       if (ICI->getPredicate() == ICmpInst::ICMP_SGT) {
  893         bool isNE = ICI->getPredicate() == ICmpInst::ICMP_NE;
  952           if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
 1226   ICmpInst::Predicate Pred = ICI->getPredicate();

lib/Transforms/InstCombine/InstCombineCompares.cpp

  235     Constant *C = ConstantFoldCompareInstOperands(ICI.getPredicate(), Elt,
 1098       ConstantInt::get(CmpTy, !CmpInst::isTrueWhenEqual(ICI.getPredicate())));
 1158     if (I.getPredicate() == I.ICMP_NE)
 1205   auto *TorF = ConstantInt::get(I.getType(), I.getPredicate() == I.ICMP_NE);
 1217     if (I.getPredicate() == I.ICMP_NE)
 1244   auto *TorF = ConstantInt::get(I.getType(), I.getPredicate() == I.ICMP_NE);
 1393   CmpInst::Predicate Pred = Cmp.getPredicate();
 1445   CmpInst::Predicate Pred = Cmp.getPredicate();
 1483   CmpInst::Predicate Pred = Cmp.getPredicate();
 1531   ICmpInst::Predicate Pred = Cmp.getPredicate();
 1572   ICmpInst::Predicate Pred = Cmp.getPredicate();
 1574   if (isSignBitCheck(Cmp.getPredicate(), C, TrueIfSigned)) {
 1681         if (Cmp.getPredicate() == ICmpInst::ICMP_EQ)
 1683         if (Cmp.getPredicate() == ICmpInst::ICMP_NE)
 1719   bool isICMP_NE = Cmp.getPredicate() == ICmpInst::ICMP_NE;
 1776       return new ICmpInst(Cmp.getPredicate(), NewAnd, ZextC1);
 1853     auto NewPred = Cmp.getPredicate() == CmpInst::ICMP_EQ ? CmpInst::ICMP_UGT
 1869       auto NewPred = Cmp.getPredicate() == CmpInst::ICMP_EQ ? CmpInst::ICMP_SGE
 1881   ICmpInst::Predicate Pred = Cmp.getPredicate();
 1949   ICmpInst::Predicate Pred = Cmp.getPredicate();
 1970   ICmpInst::Predicate Pred = Cmp.getPredicate();
 2040   ICmpInst::Predicate Pred = Cmp.getPredicate();
 2169   CmpInst::Predicate Pred = Cmp.getPredicate();
 2262   const ICmpInst::Predicate Pred = Cmp.getPredicate();
 2306   if (Cmp.getPredicate() == ICmpInst::ICMP_UGT) {
 2314   if (Cmp.getPredicate() == ICmpInst::ICMP_ULT) {
 2368   ICmpInst::Predicate Pred = Cmp.getPredicate();
 2498   ICmpInst::Predicate Pred = Cmp.getPredicate();
 2504     return new ICmpInst(Cmp.getPredicate(), Y,
 2567   CmpInst::Predicate Pred = Cmp.getPredicate();
 2692         ConstantExpr::getCompare(Cmp.getPredicate(), C1LessThan, C)
 2695         ConstantExpr::getCompare(Cmp.getPredicate(), C2Equal, C)
 2698         ConstantExpr::getCompare(Cmp.getPredicate(), C3GreaterThan, C)
 2731   ICmpInst::Predicate Pred = Cmp.getPredicate();
 2912   ICmpInst::Predicate Pred = Cmp.getPredicate();
 3085           Cmp.getPredicate(), Or, Constant::getNullValue(Ty)));
 3094       ICmpInst::Predicate NewPred = Cmp.getPredicate() == ICmpInst::ICMP_EQ
 3120     if (Cmp.getPredicate() == ICmpInst::ICMP_UGT && C.ult(BitWidth)) {
 3128     if (Cmp.getPredicate() == ICmpInst::ICMP_ULT &&
 3143     if (Cmp.getPredicate() == ICmpInst::ICMP_UGT && C.ult(BitWidth)) {
 3151     if (Cmp.getPredicate() == ICmpInst::ICMP_ULT &&
 3181           I.getPredicate(), LHSI->getOperand(0),
 3199       Op1 = ConstantExpr::getICmp(I.getPredicate(), C, RHSC);
 3203       Op2 = ConstantExpr::getICmp(I.getPredicate(), C, RHSC);
 3231         Op1 = Builder.CreateICmp(I.getPredicate(), LHSI->getOperand(1), RHSC,
 3234         Op2 = Builder.CreateICmp(I.getPredicate(), LHSI->getOperand(2), RHSC,
 3245           I.getPredicate(), LHSI->getOperand(0),
 3592   return Builder.CreateICmp(I.getPredicate(), T1,
 3677   const CmpInst::Predicate Pred = I.getPredicate();
 4036   ICmpInst::Predicate Pred = Cmp.getPredicate();
 4126   const CmpInst::Predicate Pred = I.getPredicate();
 4334       return new ICmpInst(ICmp.getPredicate(), X, Y);
 4339       return new ICmpInst(ICmp.getPredicate(), X, Y);
 4360       return new ICmpInst(ICmp.getPredicate(), X, Res1);
 4365       return new ICmpInst(ICmp.getPredicate(), X, Res1);
 4381   if (ICmp.getPredicate() == ICmpInst::ICMP_ULT)
 4386   assert(ICmp.getPredicate() == ICmpInst::ICMP_UGT && "ICmp should be folded!");
 4428       return new ICmpInst(ICmp.getPredicate(), Op0Src, NewOp1);
 4594   switch (I.getPredicate()) {
 4725   switch (I.getPredicate()) {
 4765   if (isSignBitCheck(I.getPredicate(), *RHS, UnusedBit))
 4768   switch (I.getPredicate()) {
 4901   if (isChainSelectCmpBranch(SI) && Icmp->getPredicate() == ICmpInst::ICMP_EQ) {
 4928   ICmpInst::Predicate Pred = I.getPredicate();
 5208   ICmpInst::Predicate Pred = I.getPredicate();
 5236     switch (I.getPredicate()) {
 5245     switch (I.getPredicate()) {
 5255   switch (I.getPredicate()) {
 5369     CmpInst::Predicate P = Cmp.getPredicate();
 5394   if (Value *V = SimplifyICmpInst(I.getPredicate(), Op0, Op1, Q))
 5399   if (I.getPredicate() == ICmpInst::ICMP_NE && match(Op1, m_Zero())) {
 5405           return CmpInst::Create(Instruction::ICmp, I.getPredicate(), V, Op1);
 5409           return CmpInst::Create(Instruction::ICmp, I.getPredicate(), V, Op1);
 5459   ICmpInst::Predicate Pred = I.getPredicate();
 5488     if (Instruction *NI = foldGEPICmp(GEP, Op1, I.getPredicate(), I))
 5492                            ICmpInst::getSwappedPredicate(I.getPredicate()), I))
 5530         return new ICmpInst(I.getPredicate(), B, A);
 5574   if (I.getPredicate() == ICmpInst::ICMP_EQ)
 5586       return foldICmpAddOpConst(X, *C, I.getPredicate());
 5619     FCmpInst::Predicate P = I.getPredicate();
 5674   switch (I.getPredicate()) {
 5858   FCmpInst::Predicate Pred = I.getPredicate();
 5902   switch (I.getPredicate()) {
 5946     return replacePredAndOp0(&I, I.getPredicate(), X);
 5964   const CmpInst::Predicate Pred = I.getPredicate();

lib/Transforms/InstCombine/InstCombinePHI.cpp

  305       if (CI->getPredicate() != cast<CmpInst>(FirstInst)->getPredicate())
  305       if (CI->getPredicate() != cast<CmpInst>(FirstInst)->getPredicate())
  357     CmpInst *NewCI = CmpInst::Create(CIOp->getOpcode(), CIOp->getPredicate(),
  825   CmpInst *NewCI = CmpInst::Create(CIOp->getOpcode(), CIOp->getPredicate(),

lib/Transforms/InstCombine/InstCombineSelect.cpp

  138   ICmpInst::Predicate Pred = Cmp->getPredicate();
  505         Cmp->getPredicate() == ICmpInst::ICMP_EQ &&
  542   ICmpInst::Predicate Pred = IC->getPredicate();
  613     IsEqualZero = IC->getPredicate() == ICmpInst::ICMP_EQ;
  614   } else if (IC->getPredicate() == ICmpInst::ICMP_SLT ||
  615              IC->getPredicate() == ICmpInst::ICMP_SGT) {
  618     IsEqualZero = IC->getPredicate() == ICmpInst::ICMP_SGT;
  684   ICmpInst::Predicate Pred = ICI->getPredicate();
  735   ICmpInst::Predicate Pred = Cmp->getPredicate();
  810   if (ICI->getPredicate() == ICmpInst::ICMP_NE)
  844   ICmpInst::Predicate Pred = ICI->getPredicate();
  895   ICmpInst::Predicate Pred = Cmp.getPredicate();
 1005       Cmp.getPredicate() == CanonicalPred)
 1055                           Cmp.getPredicate() == ICmpInst::ICMP_SLT;
 1144   if (Cmp.getPredicate() == ICmpInst::ICMP_NE)
 1194   switch (Cmp0.getPredicate()) {
 1409   ICmpInst::Predicate Pred = ICI->getPredicate();
 2312       if (FCI->hasOneUse() && FCmpInst::isUnordered(FCI->getPredicate())) {
 2330       if (FCI->hasOneUse() && FCmpInst::isUnordered(FCI->getPredicate())) {

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

 1253       return new ICmpInst(I, cast<ICmpInst>(I)->getPredicate(),
 1257       return new FCmpInst(I, cast<FCmpInst>(I)->getPredicate(),

lib/Transforms/InstCombine/InstructionCombining.cpp

 1036         InV = ConstantExpr::getCompare(CI->getPredicate(), InC, C);
 1038         InV = Builder.CreateICmp(CI->getPredicate(), PN->getIncomingValue(i),
 1041         InV = Builder.CreateFCmp(CI->getPredicate(), PN->getIncomingValue(i),

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

 1565   ICmp->setPredicate(CmpInst::getInversePredicate(ICmp->getPredicate()));

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 2300     Value *S1 = IRB.CreateICmp(I.getPredicate(),
 2303     Value *S2 = IRB.CreateICmp(I.getPredicate(),
 2321       pre = I.getPredicate();

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

  272   OS << CmpInst::getPredicateName(CI->getPredicate()) << "_";

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

  208   if (ICI->getPredicate() != ICmpInst::ICMP_EQ)

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  318       LVI->getPredicateAt(Cmp->getPredicate(), Op0, C, Cmp);
  820     LVI->getPredicateAt(C->getPredicate(), Op0, Op1, At);

lib/Transforms/Scalar/EarlyCSE.cpp

  184     CmpInst::Predicate Pred = CI->getPredicate();
  296            LHSCmp->getSwappedPredicate() == RHSCmp->getPredicate();

lib/Transforms/Scalar/Float2Int.cpp

  139         if (mapFCmpPred(cast<CmpInst>(&I)->getPredicate()) !=
  475     CmpInst::Predicate P = mapFCmpPred(cast<CmpInst>(I)->getPredicate());

lib/Transforms/Scalar/GVN.cpp

  292     CmpInst::Predicate Predicate = C->getPredicate();
 1454     if (CmpI->getPredicate() == CmpInst::Predicate::ICMP_EQ ||
 1455         CmpI->getPredicate() == CmpInst::Predicate::FCMP_OEQ ||
 1456         (CmpI->getPredicate() == CmpInst::Predicate::FCMP_UEQ &&
 1879       if ((isKnownTrue && Cmp->getPredicate() == CmpInst::ICMP_EQ) ||
 1880           (isKnownFalse && Cmp->getPredicate() == CmpInst::ICMP_NE))
 1884       if ((isKnownTrue && Cmp->getPredicate() == CmpInst::FCMP_OEQ) ||
 1885           (isKnownFalse && Cmp->getPredicate() == CmpInst::FCMP_UNE)) {

lib/Transforms/Scalar/GVNSink.cpp

  401       CmpInst::Predicate Predicate = C->getPredicate();

lib/Transforms/Scalar/GuardWidening.cpp

  632       (IC->getPredicate() != ICmpInst::ICMP_ULT &&
  633        IC->getPredicate() != ICmpInst::ICMP_UGT))
  637   if (IC->getPredicate() == ICmpInst::ICMP_UGT)

lib/Transforms/Scalar/IndVarSimplify.cpp

  370   switch (Compare->getPredicate()) {
 2088   ICmpInst::Predicate Pred = Cond->getPredicate();

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

  283   ICmpInst::Predicate Pred = ICI->getPredicate();
  794   ICmpInst::Predicate Pred = ICI->getPredicate();

lib/Transforms/Scalar/JumpThreading.cpp

  773     CmpInst::Predicate Pred = Cmp->getPredicate();
 1155         LVI->getPredicateAt(CondCmp->getPredicate(), CondCmp->getOperand(0),
 2527         LVI->getPredicateOnEdge(CondCmp->getPredicate(), SI->getOperand(1),
 2530         LVI->getPredicateOnEdge(CondCmp->getPredicate(), SI->getOperand(2),

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1241   ICmpInst::Predicate Pred = Cond->getPredicate();
 1830         Builder.CreateICmp(PreCond->getPredicate(), Opnd0, Opnd1));

lib/Transforms/Scalar/LoopPredication.cpp

  364   auto Pred = ICI->getPredicate();

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 2249   if (Cond->getPredicate() != CmpInst::ICMP_EQ &&
 2250       Cond->getPredicate() != CmpInst::ICMP_NE)
 2337   if (Cond->getPredicate() == CmpInst::ICMP_EQ)

lib/Transforms/Scalar/LoopUnswitch.cpp

 1664       if (CI->getPredicate() == CmpInst::ICMP_EQ)

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

  258     Predicate = CmpI->getPredicate();

lib/Transforms/Scalar/MergeICmps.cpp

  334   if (CmpI->getPredicate() != ExpectedPredicate)

lib/Transforms/Scalar/NewGVN.cpp

 1141     CmpInst::Predicate Predicate = CI->getPredicate();
 1590       SwappedOps ? Cmp->getSwappedPredicate() : Cmp->getPredicate();
 1842   auto OurPredicate = CI->getPredicate();
 1909       auto BranchPredicate = BranchCond->getPredicate();

lib/Transforms/Scalar/SCCP.cpp

 1082   Constant *C = V1State.getCompare(I.getPredicate(), I.getType(), V2State);
 1240       if (PBranch->TrueEdge && Cmp->getPredicate() == CmpInst::ICMP_EQ) {
 1248       if (!PBranch->TrueEdge && Cmp->getPredicate() == CmpInst::ICMP_NE) {

lib/Transforms/Scalar/Scalarizer.cpp

  108     return Builder.CreateFCmp(FCI.getPredicate(), Op0, Op1, Name);
  121     return Builder.CreateICmp(ICI.getPredicate(), Op0, Op1, Name);

lib/Transforms/Utils/Evaluator.cpp

  405       InstResult = ConstantExpr::getCompare(CI->getPredicate(),

lib/Transforms/Utils/FlattenCFG.cpp

  259       CmpInst::Predicate Predicate = CI->getPredicate();

lib/Transforms/Utils/FunctionComparator.cpp

  571     return cmpNumbers(CI->getPredicate(), cast<CmpInst>(R)->getPredicate());
  571     return cmpNumbers(CI->getPredicate(), cast<CmpInst>(R)->getPredicate());

lib/Transforms/Utils/SimplifyCFG.cpp

  505     if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE)) {
  596         ICI->getPredicate(), C->getValue());
  738   BasicBlock *Succ = BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_NE);
  741   return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ);
  983     if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
 3634     if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
 3658   if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
 4666     return ConstantFoldCompareInstOperands(Cmp->getPredicate(), COps[0],
 5247   Constant *DefaultConst = ConstantExpr::getICmp(CmpInst->getPredicate(),
 5255     Constant *CaseConst = ConstantExpr::getICmp(CmpInst->getPredicate(),

lib/Transforms/Utils/SimplifyIndVar.cpp

  178   ICmpInst::Predicate Pred = ICmp->getPredicate();
  247   ICmpInst::Predicate Pred = ICmp->getPredicate();
  281     assert(ICmp->getPredicate() == OriginalPred && "Predicate changed?");
  588     ICmpInst::Predicate Pred = ICI->getPredicate();

lib/Transforms/Utils/SimplifyLibCalls.cpp

  853           B.CreateICmp(Old->getPredicate(), StrNCmp,

lib/Transforms/Vectorize/LoopVectorize.cpp

 3333             B.CreateICmp(CI->getPredicate(), ShrinkOperand(CI->getOperand(0)),
 4218         C = Builder.CreateFCmp(Cmp->getPredicate(), A, B);
 4220         C = Builder.CreateICmp(Cmp->getPredicate(), A, B);

lib/Transforms/Vectorize/SLPVectorizer.cpp

 2521       CmpInst::Predicate P0 = cast<CmpInst>(VL0)->getPredicate();
 2526         if ((Cmp->getPredicate() != P0 && Cmp->getPredicate() != SwapP0) ||
 2526         if ((Cmp->getPredicate() != P0 && Cmp->getPredicate() != SwapP0) ||
 2553           if (Cmp->getPredicate() != P0)
 3903       CmpInst::Predicate P0 = cast<CmpInst>(VL0)->getPredicate();

tools/lldb/source/Expression/IRInterpreter.cpp

  552         switch (icmp_inst->getPredicate()) {
 1090       CmpInst::Predicate predicate = icmp_inst->getPredicate();

tools/llvm-diff/DifferenceEngine.cpp

  255       if (cast<CmpInst>(L)->getPredicate()
  256             != cast<CmpInst>(R)->getPredicate()) {

tools/polly/lib/Analysis/ScopBuilder.cpp

  497     switch (ICond->getPredicate()) {
  521       ConsequenceCondSet = buildConditionSet(ICond->getPredicate(),