[Analysis] Simplify the interface to llvm::getICmpCode. NFC

[craig.topper]

Summary

Instead of passing an InstCmpInt * and a bool just pass the predicate
from the caller.

I'm considering moving the similar FCmp functions from InstCombine
over here and this makes the interface consistent with what is used
for FCmp.

[RKSimon]

LGTM

llvm/include/llvm/Analysis/CmpInstAnalysis.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_CMPINSTANALYSIS_H
 #define LLVM_ANALYSIS_CMPINSTANALYSIS_H
 
 #include "llvm/IR/InstrTypes.h"
 
 namespace llvm {
-  class ICmpInst;
   class Type;
   class Value;
 
   /// Encode a icmp predicate into a three bit mask. These bits are carefully
   /// arranged to allow folding of expressions such as:
   ///
   ///      (A < B) | (A > B) --> (A != B)
   ///
namespace llvm {
   /// 001     1   A >  B
   /// 010     2   A == B
   /// 011     3   A >= B
   /// 100     4   A <  B
   /// 101     5   A != B
   /// 110     6   A <= B
   /// 111     7   Always true
   ///
-  unsigned getICmpCode(const ICmpInst *ICI, bool InvertPred = false);
+  unsigned getICmpCode(CmpInst::Predicate Pred);
 
   /// This is the complement of getICmpCode. It turns a predicate code into
   /// either a constant true or false or the predicate for a new ICmp.
   /// The sign is passed in to determine which kind of predicate to use in the
   /// new ICmp instruction.
   /// Non-NULL return value will be a true or false constant.
   /// NULL return means a new ICmp is needed. The predicate is output in Pred.
   Constant *getPredForICmpCode(unsigned Code, bool Sign, Type *OpTy,

llvm/lib/Analysis/CmpInstAnalysis.cpp

 
 #include "llvm/Analysis/CmpInstAnalysis.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/PatternMatch.h"
 
 using namespace llvm;
 
-unsigned llvm::getICmpCode(const ICmpInst *ICI, bool InvertPred) {
-  ICmpInst::Predicate Pred = InvertPred ? ICI->getInversePredicate()
-                                        : ICI->getPredicate();
+unsigned llvm::getICmpCode(CmpInst::Predicate Pred) {
   switch (Pred) {
       // False -> 0
     case ICmpInst::ICMP_UGT: return 1;  // 001
     case ICmpInst::ICMP_SGT: return 1;  // 001
     case ICmpInst::ICMP_EQ:  return 2;  // 010
     case ICmpInst::ICMP_UGE: return 3;  // 011
     case ICmpInst::ICMP_SGE: return 3;  // 011
     case ICmpInst::ICMP_ULT: return 4;  // 100

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

Value *InstCombinerImpl::foldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS,
   // (icmp1 A, B) & (icmp2 A, B) --> (icmp3 A, B)
   if (predicatesFoldable(PredL, PredR)) {
     if (LHS->getOperand(0) == RHS->getOperand(1) &&
         LHS->getOperand(1) == RHS->getOperand(0))
       LHS->swapOperands();
     if (LHS->getOperand(0) == RHS->getOperand(0) &&
         LHS->getOperand(1) == RHS->getOperand(1)) {
       Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1);
-      unsigned Code = getICmpCode(LHS) & getICmpCode(RHS);
+      unsigned Code =
+          getICmpCode(LHS->getPredicate()) & getICmpCode(RHS->getPredicate());
       bool IsSigned = LHS->isSigned() || RHS->isSigned();
       return getNewICmpValue(Code, IsSigned, Op0, Op1, Builder);
     }
   }
 
   // handle (roughly):  (icmp eq (A & B), C) & (icmp eq (A & D), E)
   if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, true, Builder))
     return V;
if ((PredL == ICmpInst::ICMP_ULT || PredL == ICmpInst::ICMP_ULE) &&
     }
   }
 
   // (icmp1 A, B) | (icmp2 A, B) --> (icmp3 A, B)
   if (predicatesFoldable(PredL, PredR)) {
     if (LHS0 == RHS1 && LHS1 == RHS0)
       LHS->swapOperands();
     if (LHS0 == RHS0 && LHS1 == RHS1) {
-      unsigned Code = getICmpCode(LHS) | getICmpCode(RHS);
+      unsigned Code =
+          getICmpCode(LHS->getPredicate()) | getICmpCode(RHS->getPredicate());
       bool IsSigned = LHS->isSigned() || RHS->isSigned();
       return getNewICmpValue(Code, IsSigned, LHS0, LHS1, Builder);
     }
   }
 
   // handle (roughly):
   // (icmp ne (A & B), C) | (icmp ne (A & D), E)
   if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, false, Builder))
Value *InstCombinerImpl::foldXorOfICmps(ICmpInst *LHS, ICmpInst *RHS,
   if (predicatesFoldable(LHS->getPredicate(), RHS->getPredicate())) {
     if (LHS->getOperand(0) == RHS->getOperand(1) &&
         LHS->getOperand(1) == RHS->getOperand(0))
       LHS->swapOperands();
     if (LHS->getOperand(0) == RHS->getOperand(0) &&
         LHS->getOperand(1) == RHS->getOperand(1)) {
       // (icmp1 A, B) ^ (icmp2 A, B) --> (icmp3 A, B)
       Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1);
-      unsigned Code = getICmpCode(LHS) ^ getICmpCode(RHS);
+      unsigned Code =
+          getICmpCode(LHS->getPredicate()) ^ getICmpCode(RHS->getPredicate());
       bool IsSigned = LHS->isSigned() || RHS->isSigned();
       return getNewICmpValue(Code, IsSigned, Op0, Op1, Builder);
     }
   }
 
   // TODO: This can be generalized to compares of non-signbits using
   // decomposeBitTestICmp(). It could be enhanced more by using (something like)
   // foldLogOpOfMaskedICmps().