[IR/GlobalISel] move compare predicates into lib/Support

[t.p.northover]

Summary

Hi,

I'd like to reuse the IR-level predicate scheme for GlobalISel. As far as I can tell there are 3 possible ways to do this:

• Use the CmpInst enums directly. This feels close to a layering violation. ISel has to know *something* about IR, but you'd hope to minimize that after the first translation.
• Copy/paste the definitions into include/CodeGen/GlobalISel somewhere. Long term this isn't viable, though it might be a reasonable short-term hack until we know GlobalISel works.
• Refactor the predicates out of lib/IR into lib/Support (or elsewhere).

I decided to try and avoid hacks so took the 3rd option, giving us this large diff. I think it's actually a reasonable change on its own and the interfaces are slightly nicer afterwards, though I wouldn't have called it worth the time without GlobalISel's wider intent.

One thing worth thinking about is whether a single Predicate is the best choice. Passes had been (somewhat haphazardly, but not completely without reason) using either CmpInst, ICmpInst or FCmpInst to refer to the enum values.

There's not really any loss of expressiveness with a single Predicate, since the names are still ICMP_*/FCMP_*, but I could alternatively split it into IPredicate and FPredicate which would allow IPredicate::EQ, FPredicate::OEQ and so on.

Opinions?

[t.p.northover]

Just noticed a couple of issues myself:

include/llvm/IR/Instructions.h

1133–1134

Just noticed these are redundant now. I'll remove them.

lib/IR/ConstantFold.cpp

1688

Sorry, these getKind calls are are unnecessary (from an earlier version of the Predicate class). I'll remove them too.

[t.p.northover]

Fixed issues I spotted after upload. Sorry about that!

[t.p.northover]

Ping?

[mehdi_amini]

I don't make sense of hosting these definitions in libSupport.

I think you are creating actually a dependency from GlobalISel to the IR as soon as you want a one-to-one mapping like that and reuse the list.
Just moving it in a separate library just for the purpose of not including llvm/IR/ seems like very artificial to me, and "breaks" the dependency on the surface.

[chandlerc]

In D23282#517014, @mehdi_amini wrote:

I don't make sense of hosting these definitions in libSupport.

I think you are creating actually a dependency from GlobalISel to the IR as soon as you want a one-to-one mapping like that and reuse the list.
Just moving it in a separate library just for the purpose of not including llvm/IR/ seems like very artificial to me, and "breaks" the dependency on the surface.

FWIW, I agree. If you are relying on a perfect 1:1 matching of the IR predicates to the MI predicates, I don't see much benefit in shifting the header to support. I see some small benefit, but it isn't clear to me that it is worth it...

[t.p.northover]

Ping?

[t.p.northover]

Sorry not ping, stale comment.

include/llvm/Analysis/ConstantFolding.h

 // DataLayout information. These functions cannot go in VMCore due to library
 // dependency issues.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_CONSTANTFOLDING_H
 #define LLVM_ANALYSIS_CONSTANTFOLDING_H
 
+#include "llvm/Support/Predicate.h"
+
 namespace llvm {
 class APInt;
 template <typename T> class ArrayRef;
 class Constant;
 class ConstantExpr;
 class ConstantVector;
 class DataLayout;
 class Function;
Constant *ConstantFoldInstOperands(Instruction *I, ArrayRef<Constant *> Ops,
                                    const DataLayout &DL,
                                    const TargetLibraryInfo *TLI = nullptr);
 
 /// ConstantFoldCompareInstOperands - Attempt to constant fold a compare
 /// instruction (icmp/fcmp) with the specified operands.  If it fails, it
 /// returns a constant expression of the specified operands.
 ///
 Constant *
-ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS,
-                                Constant *RHS, const DataLayout &DL,
+ConstantFoldCompareInstOperands(Predicate Pred, Constant *LHS, Constant *RHS,
+                                const DataLayout &DL,
                                 const TargetLibraryInfo *TLI = nullptr);
 
 /// \brief Attempt to constant fold a binary operation with the specified
 /// operands.  If it fails, it returns a constant expression of the specified
 /// operands.
 Constant *ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS,
                                        Constant *RHS, const DataLayout &DL);
 

include/llvm/Analysis/DependenceAnalysis.h

private:
     bool checkDstSubscript(const SCEV *Dst,
                            const Loop *LoopNest,
                            SmallBitVector &Loops);
 
     /// isKnownPredicate - Compare X and Y using the predicate Pred.
     /// Basically a wrapper for SCEV::isKnownPredicate,
     /// but tries harder, especially in the presence of sign and zero
     /// extensions and symbolics.
-    bool isKnownPredicate(ICmpInst::Predicate Pred,
-                          const SCEV *X,
-                          const SCEV *Y) const;
+    bool isKnownPredicate(Predicate Pred, const SCEV *X, const SCEV *Y) const;
 
     /// collectUpperBound - All subscripts are the same type (on my machine,
     /// an i64). The loop bound may be a smaller type. collectUpperBound
     /// find the bound, if available, and zero extends it to the Type T.
     /// (I zero extend since the bound should always be >= 0.)
     /// If no upper bound is available, return NULL.
     const SCEV *collectUpperBound(const Loop *l, Type *T) const;
 

include/llvm/Analysis/InstructionSimplify.h

 // contexts of a directly recursive call, for example).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
 #define LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
 
 #include "llvm/IR/User.h"
+#include "llvm/Support/Predicate.h"
 
 namespace llvm {
   template<typename T>
   class ArrayRef;
   class AssumptionCache;
   class DominatorTree;
   class Instruction;
   class DataLayout;
namespace llvm {
   /// Given operands for an Xor, fold the result or return null.
   Value *SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout &DL,
                          const TargetLibraryInfo *TLI = nullptr,
                          const DominatorTree *DT = nullptr,
                          AssumptionCache *AC = nullptr,
                          const Instruction *CxtI = nullptr);
 
   /// Given operands for an ICmpInst, fold the result or return null.
-  Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+  Value *SimplifyICmpInst(Predicate Pred, Value *LHS, Value *RHS,
                           const DataLayout &DL,
                           const TargetLibraryInfo *TLI = nullptr,
                           const DominatorTree *DT = nullptr,
                           AssumptionCache *AC = nullptr,
                           const Instruction *CxtI = nullptr);
 
   /// Given operands for an FCmpInst, fold the result or return null.
-  Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+  Value *SimplifyFCmpInst(Predicate Pred, Value *LHS, Value *RHS,
                           FastMathFlags FMF, const DataLayout &DL,
                           const TargetLibraryInfo *TLI = nullptr,
                           const DominatorTree *DT = nullptr,
                           AssumptionCache *AC = nullptr,
                           const Instruction *CxtI = nullptr);
 
   /// Given operands for a SelectInst, fold the result or return null.
   Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
Value *SimplifyCastInst(unsigned CastOpc, Value *Op, Type *Ty,
                           const DominatorTree *DT = nullptr,
                           AssumptionCache *AC = nullptr,
                           const Instruction *CxtI = nullptr);
 
   //=== Helper functions for higher up the class hierarchy.
 
 
   /// Given operands for a CmpInst, fold the result or return null.
-  Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+  Value *SimplifyCmpInst(Predicate Pred, Value *LHS, Value *RHS,
                          const DataLayout &DL,
                          const TargetLibraryInfo *TLI = nullptr,
                          const DominatorTree *DT = nullptr,
                          AssumptionCache *AC = nullptr,
                          const Instruction *CxtI = nullptr);
 
   /// Given operands for a BinaryOperator, fold the result or return null.
   Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,

include/llvm/Analysis/LazyValueInfo.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_LAZYVALUEINFO_H
 #define LLVM_ANALYSIS_LAZYVALUEINFO_H
 
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/Predicate.h"
 
 namespace llvm {
   class AssumptionCache;
   class Constant;
   class ConstantRange;
   class DataLayout;
   class DominatorTree;
   class Instruction;
enum Tristate {
     Unknown = -1, False = 0, True = 1
   };
 
   // Public query interface.
 
   /// Determine whether the specified value comparison with a constant is known
   /// to be true or false on the specified CFG edge.
   /// Pred is a CmpInst predicate.
-  Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
+  Tristate getPredicateOnEdge(Predicate Pred, Value *V, Constant *C,
                               BasicBlock *FromBB, BasicBlock *ToBB,
                               Instruction *CxtI = nullptr);
 
   /// Determine whether the specified value comparison with a constant is known
   /// to be true or false at the specified instruction
   /// (from an assume intrinsic). Pred is a CmpInst predicate.
-  Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C,
+  Tristate getPredicateAt(Predicate Pred, Value *V, Constant *C,
                           Instruction *CxtI);
 
   /// Determine whether the specified value is known to be a
   /// constant at the end of the specified block.  Return null if not.
   Constant *getConstant(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
 
   /// Return the ConstantRange constraint that is known to hold for the
   /// specified value at the end of the specified block. This may only be called

include/llvm/Analysis/ScalarEvolution.h

private:
     /// execute if its exit condition were a switch with a single exiting case
     /// to ExitingBB.
     ExitLimit
     computeExitLimitFromSingleExitSwitch(const Loop *L, SwitchInst *Switch,
                                BasicBlock *ExitingBB, bool IsSubExpr);
 
     /// Given an exit condition of 'icmp op load X, cst', try to see if we can
     /// compute the backedge-taken count.
-    ExitLimit computeLoadConstantCompareExitLimit(LoadInst *LI,
-                                                  Constant *RHS,
-                                                  const Loop *L,
-                                                  ICmpInst::Predicate p);
+    ExitLimit computeLoadConstantCompareExitLimit(LoadInst *LI, Constant *RHS,
+                                                  const Loop *L, Predicate p);
 
     /// Compute the exit limit of a loop that is controlled by a
     /// "(IV >> 1) != 0" type comparison.  We cannot compute the exact trip
     /// count in these cases (since SCEV has no way of expressing them), but we
     /// can still sometimes compute an upper bound.
     ///
     /// Return an ExitLimit for a loop whose backedge is guarded by `LHS Pred
     /// RHS`.
     ExitLimit computeShiftCompareExitLimit(Value *LHS, Value *RHS,
-                                           const Loop *L,
-                                           ICmpInst::Predicate Pred);
+                                           const Loop *L, Predicate Pred);
 
     /// If the loop is known to execute a constant number of times (the
     /// condition evolves only from constants), try to evaluate a few iterations
     /// of the loop until we get the exit condition gets a value of ExitWhen
     /// (true or false).  If we cannot evaluate the exit count of the loop,
     /// return CouldNotCompute.
     const SCEV *computeExitCountExhaustively(const Loop *L,
                                              Value *Cond,
private:
     /// Return a predecessor of BB (which may not be an immediate predecessor)
     /// which has exactly one successor from which BB is reachable, or null if
     /// no such block is found.
     std::pair<BasicBlock *, BasicBlock *>
     getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB);
 
     /// Test whether the condition described by Pred, LHS, and RHS is true
     /// whenever the given FoundCondValue value evaluates to true.
-    bool isImpliedCond(ICmpInst::Predicate Pred,
-                       const SCEV *LHS, const SCEV *RHS,
-                       Value *FoundCondValue,
-                       bool Inverse);
+    bool isImpliedCond(Predicate Pred, const SCEV *LHS, const SCEV *RHS,
+                       Value *FoundCondValue, bool Inverse);
 
     /// Test whether the condition described by Pred, LHS, and RHS is true
     /// whenever the condition described by FoundPred, FoundLHS, FoundRHS is
     /// true.
-    bool isImpliedCond(ICmpInst::Predicate Pred, const SCEV *LHS,
-                       const SCEV *RHS, ICmpInst::Predicate FoundPred,
-                       const SCEV *FoundLHS, const SCEV *FoundRHS);
+    bool isImpliedCond(Predicate Pred, const SCEV *LHS, const SCEV *RHS,
+                       Predicate FoundPred, const SCEV *FoundLHS,
+                       const SCEV *FoundRHS);
 
     /// Test whether the condition described by Pred, LHS, and RHS is true
     /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
     /// true.
-    bool isImpliedCondOperands(ICmpInst::Predicate Pred,
-                               const SCEV *LHS, const SCEV *RHS,
+    bool isImpliedCondOperands(Predicate Pred, const SCEV *LHS, const SCEV *RHS,
                                const SCEV *FoundLHS, const SCEV *FoundRHS);
 
     /// Test whether the condition described by Pred, LHS, and RHS is true
     /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
     /// true.
-    bool isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
-                                     const SCEV *LHS, const SCEV *RHS,
-                                     const SCEV *FoundLHS,
+    bool isImpliedCondOperandsHelper(Predicate Pred, const SCEV *LHS,
+                                     const SCEV *RHS, const SCEV *FoundLHS,
                                      const SCEV *FoundRHS);
 
     /// Test whether the condition described by Pred, LHS, and RHS is true
     /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
     /// true.  Utility function used by isImpliedCondOperands.  Tries to get
     /// cases like "X `sgt` 0 => X - 1 `sgt` -1".
-    bool isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
-                                        const SCEV *LHS, const SCEV *RHS,
-                                        const SCEV *FoundLHS,
+    bool isImpliedCondOperandsViaRanges(Predicate Pred, const SCEV *LHS,
+                                        const SCEV *RHS, const SCEV *FoundLHS,
                                         const SCEV *FoundRHS);
 
     /// Return true if the condition denoted by \p LHS \p Pred \p RHS is implied
     /// by a call to \c @llvm.experimental.guard in \p BB.
-    bool isImpliedViaGuard(BasicBlock *BB, ICmpInst::Predicate Pred,
-                           const SCEV *LHS, const SCEV *RHS);
+    bool isImpliedViaGuard(BasicBlock *BB, Predicate Pred, const SCEV *LHS,
+                           const SCEV *RHS);
 
     /// Test whether the condition described by Pred, LHS, and RHS is true
     /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
     /// true.
     ///
     /// This routine tries to rule out certain kinds of integer overflow, and
     /// then tries to reason about arithmetic properties of the predicates.
-    bool isImpliedCondOperandsViaNoOverflow(ICmpInst::Predicate Pred,
-                                            const SCEV *LHS, const SCEV *RHS,
+    bool isImpliedCondOperandsViaNoOverflow(Predicate Pred, const SCEV *LHS,
+                                            const SCEV *RHS,
                                             const SCEV *FoundLHS,
                                             const SCEV *FoundRHS);
 
     /// If we know that the specified Phi is in the header of its containing
     /// loop, we know the loop executes a constant number of times, and the PHI
     /// node is just a recurrence involving constants, fold it.
     Constant *getConstantEvolutionLoopExitValue(PHINode *PN, const APInt& BEs,
                                                 const Loop *L);
 
     /// Test if the given expression is known to satisfy the condition described
     /// by Pred and the known constant ranges of LHS and RHS.
     ///
-    bool isKnownPredicateViaConstantRanges(ICmpInst::Predicate Pred,
-                                           const SCEV *LHS, const SCEV *RHS);
+    bool isKnownPredicateViaConstantRanges(Predicate Pred, const SCEV *LHS,
+                                           const SCEV *RHS);
 
     /// Try to prove the condition described by "LHS Pred RHS" by ruling out
     /// integer overflow.
     ///
     /// For instance, this will return true for "A s< (A + C)<nsw>" if C is
     /// positive.
-    bool isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred,
-                                       const SCEV *LHS, const SCEV *RHS);
+    bool isKnownPredicateViaNoOverflow(Predicate Pred, const SCEV *LHS,
+                                       const SCEV *RHS);
 
     /// Try to split Pred LHS RHS into logical conjunctions (and's) and try to
     /// prove them individually.
-    bool isKnownPredicateViaSplitting(ICmpInst::Predicate Pred, const SCEV *LHS,
+    bool isKnownPredicateViaSplitting(Predicate Pred, const SCEV *LHS,
                                       const SCEV *RHS);
 
     /// Try to match the Expr as "(L + R)<Flags>".
     bool splitBinaryAdd(const SCEV *Expr, const SCEV *&L, const SCEV *&R,
                         SCEV::NoWrapFlags &Flags);
 
     /// Compute \p LHS - \p RHS and returns the result as an APInt if it is a
     /// constant, and None if it isn't.
private:
     ///
     template<typename ExtendOpTy>
     bool proveNoWrapByVaryingStart(const SCEV *Start, const SCEV *Step,
                                    const Loop *L);
 
     /// Try to prove NSW or NUW on \p AR relying on ConstantRange manipulation.
     SCEV::NoWrapFlags proveNoWrapViaConstantRanges(const SCEVAddRecExpr *AR);
 
-    bool isMonotonicPredicateImpl(const SCEVAddRecExpr *LHS,
-                                  ICmpInst::Predicate Pred, bool &Increasing);
+    bool isMonotonicPredicateImpl(const SCEVAddRecExpr *LHS, Predicate Pred,
+                                  bool &Increasing);
 
     /// Return true if, for all loop invariant X, the predicate "LHS `Pred` X"
     /// is monotonically increasing or decreasing.  In the former case set
     /// `Increasing` to true and in the latter case set `Increasing` to false.
     ///
     /// A predicate is said to be monotonically increasing if may go from being
     /// false to being true as the loop iterates, but never the other way
     /// around.  A predicate is said to be monotonically decreasing if may go
     /// from being true to being false as the loop iterates, but never the other
     /// way around.
-    bool isMonotonicPredicate(const SCEVAddRecExpr *LHS,
-                              ICmpInst::Predicate Pred, bool &Increasing);
+    bool isMonotonicPredicate(const SCEVAddRecExpr *LHS, Predicate Pred,
+                              bool &Increasing);
 
     /// Return SCEV no-wrap flags that can be proven based on reasoning about
     /// how poison produced from no-wrap flags on this value (e.g. a nuw add)
     /// would trigger undefined behavior on overflow.
     SCEV::NoWrapFlags getNoWrapFlagsFromUB(const Value *V);
 
     /// Return true if the SCEV corresponding to \p I is never poison.  Proving
     /// this is more complex than proving that just \p I is never poison, since
public:
     const SCEV *getSCEVAtScope(const SCEV *S, const Loop *L);
 
     /// This is a convenience function which does getSCEVAtScope(getSCEV(V), L).
     const SCEV *getSCEVAtScope(Value *V, const Loop *L);
 
     /// Test whether entry to the loop is protected by a conditional between LHS
     /// and RHS.  This is used to help avoid max expressions in loop trip
     /// counts, and to eliminate casts.
-    bool isLoopEntryGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
+    bool isLoopEntryGuardedByCond(const Loop *L, Predicate Pred,
                                   const SCEV *LHS, const SCEV *RHS);
 
     /// Test whether the backedge of the loop is protected by a conditional
     /// between LHS and RHS.  This is used to to eliminate casts.
-    bool isLoopBackedgeGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
+    bool isLoopBackedgeGuardedByCond(const Loop *L, Predicate Pred,
                                      const SCEV *LHS, const SCEV *RHS);
 
     /// Returns the maximum trip count of the loop if it is a single-exit
     /// loop and we can compute a small maximum for that loop.
     ///
     /// Implemented in terms of the \c getSmallConstantTripCount overload with
     /// the single exiting block passed to it. See that routine for details.
     unsigned getSmallConstantTripCount(Loop *L);
public:
 
     /// Test if the given expression is known to be non-zero.
     ///
     bool isKnownNonZero(const SCEV *S);
 
     /// Test if the given expression is known to satisfy the condition described
     /// by Pred, LHS, and RHS.
     ///
-    bool isKnownPredicate(ICmpInst::Predicate Pred,
-                          const SCEV *LHS, const SCEV *RHS);
+    bool isKnownPredicate(Predicate Pred, const SCEV *LHS, const SCEV *RHS);
 
     /// Return true if the result of the predicate LHS `Pred` RHS is loop
     /// invariant with respect to L.  Set InvariantPred, InvariantLHS and
     /// InvariantLHS so that InvariantLHS `InvariantPred` InvariantRHS is the
     /// loop invariant form of LHS `Pred` RHS.
-    bool isLoopInvariantPredicate(ICmpInst::Predicate Pred, const SCEV *LHS,
+    bool isLoopInvariantPredicate(Predicate Pred, const SCEV *LHS,
                                   const SCEV *RHS, const Loop *L,
-                                  ICmpInst::Predicate &InvariantPred,
+                                  Predicate &InvariantPred,
                                   const SCEV *&InvariantLHS,
                                   const SCEV *&InvariantRHS);
 
     /// Simplify LHS and RHS in a comparison with predicate Pred. Return true
     /// iff any changes were made. If the operands are provably equal or
     /// unequal, LHS and RHS are set to the same value and Pred is set to either
     /// ICMP_EQ or ICMP_NE.
     ///
-    bool SimplifyICmpOperands(ICmpInst::Predicate &Pred,
-                              const SCEV *&LHS,
-                              const SCEV *&RHS,
-                              unsigned Depth = 0);
+    bool SimplifyICmpOperands(Predicate &Pred, const SCEV *&LHS,
+                              const SCEV *&RHS, unsigned Depth = 0);
 
     /// Return the "disposition" of the given SCEV with respect to the given
     /// loop.
     LoopDisposition getLoopDisposition(const SCEV *S, const Loop *L);
 
     /// Return true if the value of the given SCEV is unchanging in the
     /// specified loop.
     bool isLoopInvariant(const SCEV *S, const Loop *L);

include/llvm/Analysis/TargetFolder.h

if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy));
   }
 
   //===--------------------------------------------------------------------===//
   // Compare Instructions
   //===--------------------------------------------------------------------===//
 
-  Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
-                       Constant *RHS) const {
+  Constant *CreateICmp(Predicate P, Constant *LHS, Constant *RHS) const {
     return Fold(ConstantExpr::getCompare(P, LHS, RHS));
   }
-  Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
-                       Constant *RHS) const {
+  Constant *CreateFCmp(Predicate P, Constant *LHS, Constant *RHS) const {
     return Fold(ConstantExpr::getCompare(P, LHS, RHS));
   }
 
   //===--------------------------------------------------------------------===//
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
   Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {

include/llvm/CodeGen/Analysis.h

 /// processed uses a memory 'm' constraint.
 bool hasInlineAsmMemConstraint(InlineAsm::ConstraintInfoVector &CInfos,
                                const TargetLowering &TLI);
 
 /// getFCmpCondCode - Return the ISD condition code corresponding to
 /// the given LLVM IR floating-point condition code.  This includes
 /// consideration of global floating-point math flags.
 ///
-ISD::CondCode getFCmpCondCode(FCmpInst::Predicate Pred);
+ISD::CondCode getFCmpCondCode(Predicate Pred);
 
 /// getFCmpCodeWithoutNaN - Given an ISD condition code comparing floats,
 /// return the equivalent code if we're allowed to assume that NaNs won't occur.
 ISD::CondCode getFCmpCodeWithoutNaN(ISD::CondCode CC);
 
 /// getICmpCondCode - Return the ISD condition code corresponding to
 /// the given LLVM IR integer condition code.
 ///
-ISD::CondCode getICmpCondCode(ICmpInst::Predicate Pred);
+ISD::CondCode getICmpCondCode(Predicate Pred);
 
 /// Test if the given instruction is in a position to be optimized
 /// with a tail-call. This roughly means that it's in a block with
 /// a return and there's nothing that needs to be scheduled
 /// between it and the return.
 ///
 /// This function only tests target-independent requirements.
 bool isInTailCallPosition(ImmutableCallSite CS, const TargetMachine &TM);

include/llvm/CodeGen/FastISel.h

protected:
   bool canFoldAddIntoGEP(const User *GEP, const Value *Add);
 
   /// \brief Test whether the given value has exactly one use.
   bool hasTrivialKill(const Value *V);
 
   /// \brief Create a machine mem operand from the given instruction.
   MachineMemOperand *createMachineMemOperandFor(const Instruction *I) const;
 
-  CmpInst::Predicate optimizeCmpPredicate(const CmpInst *CI) const;
+  Predicate optimizeCmpPredicate(const CmpInst *CI) const;
 
   bool lowerCallTo(const CallInst *CI, MCSymbol *Symbol, unsigned NumArgs);
   bool lowerCallTo(const CallInst *CI, const char *SymbolName,
                    unsigned NumArgs);
   bool lowerCallTo(CallLoweringInfo &CLI);
 
   bool isCommutativeIntrinsic(IntrinsicInst const *II) {
     switch (II->getIntrinsicID()) {

include/llvm/IR/ConstantFolder.h

public:
   Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
     return ConstantExpr::getTruncOrBitCast(C, DestTy);
   }
 
   //===--------------------------------------------------------------------===//
   // Compare Instructions
   //===--------------------------------------------------------------------===//
 
-  Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
-                       Constant *RHS) const {
+  Constant *CreateICmp(Predicate P, Constant *LHS, Constant *RHS) const {
     return ConstantExpr::getCompare(P, LHS, RHS);
   }
-  Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
-                       Constant *RHS) const {
+  Constant *CreateFCmp(Predicate P, Constant *LHS, Constant *RHS) const {
     return ConstantExpr::getCompare(P, LHS, RHS);
   }
 
   //===--------------------------------------------------------------------===//
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
   Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {

include/llvm/IR/ConstantRange.h

public:
   /// Produce the smallest range such that all values that may satisfy the given
   /// predicate with any value contained within Other is contained in the
   /// returned range.  Formally, this returns a superset of
   /// 'union over all y in Other . { x : icmp op x y is true }'.  If the exact
   /// answer is not representable as a ConstantRange, the return value will be a
   /// proper superset of the above.
   ///
   /// Example: Pred = ult and Other = i8 [2, 5) returns Result = [0, 4)
-  static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred,
+  static ConstantRange makeAllowedICmpRegion(Predicate Pred,
                                              const ConstantRange &Other);
 
   /// Produce the largest range such that all values in the returned range
   /// satisfy the given predicate with all values contained within Other.
   /// Formally, this returns a subset of
   /// 'intersection over all y in Other . { x : icmp op x y is true }'.  If the
   /// exact answer is not representable as a ConstantRange, the return value
   /// will be a proper subset of the above.
   ///
   /// Example: Pred = ult and Other = i8 [2, 5) returns [0, 2)
-  static ConstantRange makeSatisfyingICmpRegion(CmpInst::Predicate Pred,
+  static ConstantRange makeSatisfyingICmpRegion(Predicate Pred,
                                                 const ConstantRange &Other);
 
   /// Produce the exact range such that all values in the returned range satisfy
   /// the given predicate with any value contained within Other. Formally, this
   /// returns the exact answer when the superset of 'union over all y in Other
   /// is exactly same as the subset of intersection over all y in Other.
   /// { x : icmp op x y is true}'.
   ///
   /// Example: Pred = ult and Other = i8 3 returns [0, 3)
-  static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred,
-                                           const APInt &Other);
+  static ConstantRange makeExactICmpRegion(Predicate Pred, const APInt &Other);
 
   /// Return the largest range containing all X such that "X BinOpC Y" is
   /// guaranteed not to wrap (overflow) for all Y in Other.
   ///
   /// NB! The returned set does *not* contain **all** possible values of X for
   /// which "X BinOpC Y" does not wrap -- some viable values of X may be
   /// missing, so you cannot use this to contrain X's range.  E.g. in the last
   /// example, "(-2) + 1" is both nsw and nuw (so the "X" could be -2), but (-2)
public:
   ///  MGNR(Add, [i8 -1, 6), OBO::NoSignedWrap) == [INT_MIN+1, INT_MAX-4)
   static ConstantRange makeGuaranteedNoWrapRegion(Instruction::BinaryOps BinOp,
                                                   const ConstantRange &Other,
                                                   unsigned NoWrapKind);
 
   /// Set up \p Pred and \p RHS such that
   /// ConstantRange::makeExactICmpRegion(Pred, RHS) == *this.  Return true if
   /// successful.
-  bool getEquivalentICmp(CmpInst::Predicate &Pred, APInt &RHS) const;
+  bool getEquivalentICmp(Predicate &Pred, APInt &RHS) const;
 
   /// Return the lower value for this range.
   ///
   const APInt &getLower() const { return Lower; }
 
   /// Return the upper value for this range.
   ///
   const APInt &getUpper() const { return Upper; }

include/llvm/IR/Constants.h

 #define LLVM_IR_CONSTANTS_H
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/OperandTraits.h"
+#include "llvm/Support/Predicate.h"
 
 namespace llvm {
 
 class ArrayType;
 class IntegerType;
 class StructType;
 class PointerType;
 class VectorType;
public:
   ///
   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
   static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
                        unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr);
 
   /// \brief Return an ICmp or FCmp comparison operator constant expression.
   ///
   /// \param OnlyIfReduced see \a getWithOperands() docs.
-  static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2,
+  static Constant *getCompare(Predicate pred, Constant *C1, Constant *C2,
                               bool OnlyIfReduced = false);
 
   /// get* - Return some common constants without having to
   /// specify the full Instruction::OPCODE identifier.
   ///
-  static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS,
+  static Constant *getICmp(Predicate pred, Constant *LHS, Constant *RHS,
                            bool OnlyIfReduced = false);
-  static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS,
+  static Constant *getFCmp(Predicate pred, Constant *LHS, Constant *RHS,
                            bool OnlyIfReduced = false);
 
   /// Getelementptr form.  Value* is only accepted for convenience;
   /// all elements must be Constants.
   ///
   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
   static Constant *getGetElementPtr(Type *Ty, Constant *C,
                                     ArrayRef<Constant *> IdxList,
static Constant *getInsertValue(Constant *Agg, Constant *Val,
                                   ArrayRef<unsigned> Idxs,
                                   Type *OnlyIfReducedTy = nullptr);
 
   /// Return the opcode at the root of this constant expression
   unsigned getOpcode() const { return getSubclassDataFromValue(); }
 
   /// Return the ICMP or FCMP predicate value. Assert if this is not an ICMP or
   /// FCMP constant expression.
-  unsigned getPredicate() const;
+  Predicate getPredicate() const;
 
   /// Assert that this is an insertvalue or exactvalue
   /// expression and return the list of indices.
   ArrayRef<unsigned> getIndices() const;
 
   /// Return a string representation for an opcode.
   const char *getOpcodeName() const;
 

include/llvm/IR/IRBuilder.h

Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
     return Insert(CastInst::CreateFPCast(V, DestTy), Name);
   }
 
   //===--------------------------------------------------------------------===//
   // Instruction creation methods: Compare Instructions
   //===--------------------------------------------------------------------===//
 
   Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_EQ, LHS, RHS, Name);
   }
   Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_NE, LHS, RHS, Name);
   }
   Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_UGT, LHS, RHS, Name);
   }
   Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_UGE, LHS, RHS, Name);
   }
   Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_ULT, LHS, RHS, Name);
   }
   Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_ULE, LHS, RHS, Name);
   }
   Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_SGT, LHS, RHS, Name);
   }
   Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_SGE, LHS, RHS, Name);
   }
   Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_SLT, LHS, RHS, Name);
   }
   Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
+    return CreateICmp(Predicate::ICMP_SLE, LHS, RHS, Name);
   }
 
   Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_OGT, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_OGE, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_OLT, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_OLE, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_ONE, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_ORD, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_UNO, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_UGT, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_UGE, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_ULT, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_ULE, LHS, RHS, Name, FPMathTag);
   }
   Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
                        MDNode *FPMathTag = nullptr) {
-    return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
+    return CreateFCmp(Predicate::FCMP_UNE, LHS, RHS, Name, FPMathTag);
   }
 
-  Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
+  Value *CreateICmp(Predicate P, Value *LHS, Value *RHS,
                     const Twine &Name = "") {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
         return Insert(Folder.CreateICmp(P, LC, RC), Name);
     return Insert(new ICmpInst(P, LHS, RHS), Name);
   }
-  Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
-                    const Twine &Name = "", MDNode *FPMathTag = nullptr) {
+  Value *CreateFCmp(Predicate P, Value *LHS, Value *RHS, const Twine &Name = "",
+                    MDNode *FPMathTag = nullptr) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
         return Insert(Folder.CreateFCmp(P, LC, RC), Name);
     return Insert(AddFPMathAttributes(new FCmpInst(P, LHS, RHS),
                                       FPMathTag, FMF), Name);
   }
 
   //===--------------------------------------------------------------------===//

include/llvm/IR/InstrTypes.h

 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/OperandTraits.h"
+#include "llvm/Support/Predicate.h"
 
 namespace llvm {
 
 class LLVMContext;
 
 //===----------------------------------------------------------------------===//
 //                            TerminatorInst Class
 //===----------------------------------------------------------------------===//

 
 //===----------------------------------------------------------------------===//
 //                               CmpInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class is the base class for the comparison instructions.
 /// @brief Abstract base class of comparison instructions.
 class CmpInst : public Instruction {
-public:
-  /// This enumeration lists the possible predicates for CmpInst subclasses.
-  /// Values in the range 0-31 are reserved for FCmpInst, while values in the
-  /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
-  /// predicate values are not overlapping between the classes.
-  ///
-  /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
-  /// FCMP_* values. Changing the bit patterns requires a potential change to
-  /// those passes.
-  enum Predicate {
-    // Opcode              U L G E    Intuitive operation
-    FCMP_FALSE =  0,  ///< 0 0 0 0    Always false (always folded)
-    FCMP_OEQ   =  1,  ///< 0 0 0 1    True if ordered and equal
-    FCMP_OGT   =  2,  ///< 0 0 1 0    True if ordered and greater than
-    FCMP_OGE   =  3,  ///< 0 0 1 1    True if ordered and greater than or equal
-    FCMP_OLT   =  4,  ///< 0 1 0 0    True if ordered and less than
-    FCMP_OLE   =  5,  ///< 0 1 0 1    True if ordered and less than or equal
-    FCMP_ONE   =  6,  ///< 0 1 1 0    True if ordered and operands are unequal
-    FCMP_ORD   =  7,  ///< 0 1 1 1    True if ordered (no nans)
-    FCMP_UNO   =  8,  ///< 1 0 0 0    True if unordered: isnan(X) | isnan(Y)
-    FCMP_UEQ   =  9,  ///< 1 0 0 1    True if unordered or equal
-    FCMP_UGT   = 10,  ///< 1 0 1 0    True if unordered or greater than
-    FCMP_UGE   = 11,  ///< 1 0 1 1    True if unordered, greater than, or equal
-    FCMP_ULT   = 12,  ///< 1 1 0 0    True if unordered or less than
-    FCMP_ULE   = 13,  ///< 1 1 0 1    True if unordered, less than, or equal
-    FCMP_UNE   = 14,  ///< 1 1 1 0    True if unordered or not equal
-    FCMP_TRUE  = 15,  ///< 1 1 1 1    Always true (always folded)
-    FIRST_FCMP_PREDICATE = FCMP_FALSE,
-    LAST_FCMP_PREDICATE = FCMP_TRUE,
-    BAD_FCMP_PREDICATE = FCMP_TRUE + 1,
-    ICMP_EQ    = 32,  ///< equal
-    ICMP_NE    = 33,  ///< not equal
-    ICMP_UGT   = 34,  ///< unsigned greater than
-    ICMP_UGE   = 35,  ///< unsigned greater or equal
-    ICMP_ULT   = 36,  ///< unsigned less than
-    ICMP_ULE   = 37,  ///< unsigned less or equal
-    ICMP_SGT   = 38,  ///< signed greater than
-    ICMP_SGE   = 39,  ///< signed greater or equal
-    ICMP_SLT   = 40,  ///< signed less than
-    ICMP_SLE   = 41,  ///< signed less or equal
-    FIRST_ICMP_PREDICATE = ICMP_EQ,
-    LAST_ICMP_PREDICATE = ICMP_SLE,
-    BAD_ICMP_PREDICATE = ICMP_SLE + 1
-  };
-
 private:
   void *operator new(size_t, unsigned) = delete;
   CmpInst() = delete;
 
 protected:
   CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
           Value *LHS, Value *RHS, const Twine &Name = "",
           Instruction *InsertBefore = nullptr);
public:
   }
 
   /// @brief Return the predicate for this instruction.
   Predicate getPredicate() const {
     return Predicate(getSubclassDataFromInstruction());
   }
 
   /// @brief Set the predicate for this instruction to the specified value.
-  void setPredicate(Predicate P) { setInstructionSubclassData(P); }
-
-  static bool isFPPredicate(Predicate P) {
-    return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE;
+  void setPredicate(Predicate P) {
+    setInstructionSubclassData(static_cast<uint16_t>(P.getKind()));
   }
 
-  static bool isIntPredicate(Predicate P) {
-    return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE;
-  }
-
-  bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
-  bool isIntPredicate() const { return isIntPredicate(getPredicate()); }
+  bool isFPPredicate() const { return getPredicate().isFP(); }
+  bool isIntPredicate() const { return getPredicate().isInt(); }
 
   /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
   ///              OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
   /// @returns the inverse predicate for the instruction's current predicate.
   /// @brief Return the inverse of the instruction's predicate.
-  Predicate getInversePredicate() const {
-    return getInversePredicate(getPredicate());
-  }
-
-  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
-  ///              OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
-  /// @returns the inverse predicate for predicate provided in \p pred.
-  /// @brief Return the inverse of a given predicate
-  static Predicate getInversePredicate(Predicate pred);
+  Predicate getInversePredicate() const { return getPredicate().getInverse(); }
 
   /// For example, EQ->EQ, SLE->SGE, ULT->UGT,
   ///              OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
   /// @returns the predicate that would be the result of exchanging the two
   /// operands of the CmpInst instruction without changing the result
   /// produced.
   /// @brief Return the predicate as if the operands were swapped
-  Predicate getSwappedPredicate() const {
-    return getSwappedPredicate(getPredicate());
-  }
-
-  /// This is a static version that you can use without an instruction
-  /// available.
-  /// @brief Return the predicate as if the operands were swapped.
-  static Predicate getSwappedPredicate(Predicate pred);
+  Predicate getSwappedPredicate() const { return getPredicate().getSwapped(); }
 
   /// @brief Provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// This is just a convenience that dispatches to the subclasses.
   /// @brief Swap the operands and adjust predicate accordingly to retain
   /// the same comparison.
   void swapOperands();
 
-  /// This is just a convenience that dispatches to the subclasses.
   /// @brief Determine if this CmpInst is commutative.
-  bool isCommutative() const;
+  bool isCommutative() const { return getPredicate().isCommutative(); }
+
+  /// @returns true if the predicate is relational (i.e. not commutative).
+  bool isRelational() const { return getPredicate().isRelational(); }
 
   /// This is just a convenience that dispatches to the subclasses.
   /// @brief Determine if this is an equals/not equals predicate.
-  bool isEquality() const;
+  bool isEquality() const { return getPredicate().isEquality(); }
 
   /// @returns true if the comparison is signed, false otherwise.
   /// @brief Determine if this instruction is using a signed comparison.
-  bool isSigned() const {
-    return isSigned(getPredicate());
-  }
+  bool isSigned() const { return getPredicate().isSigned(); }
 
   /// @returns true if the comparison is unsigned, false otherwise.
   /// @brief Determine if this instruction is using an unsigned comparison.
-  bool isUnsigned() const {
-    return isUnsigned(getPredicate());
-  }
-
-  /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
-  /// @returns the signed version of the unsigned predicate pred.
-  /// @brief return the signed version of a predicate
-  static Predicate getSignedPredicate(Predicate pred);
+  bool isUnsigned() const { return getPredicate().isUnsigned(); }
 
   /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
   /// @returns the signed version of the predicate for this instruction (which
   /// has to be an unsigned predicate).
   /// @brief return the signed version of a predicate
-  Predicate getSignedPredicate() {
-    return getSignedPredicate(getPredicate());
+  Predicate getSignedPredicate() { return getPredicate().getSigned(); }
+
+  /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
+  /// @returns the predicate that would be the result if the operand were
+  /// regarded as unsigned.
+  /// \brief Return the unsigned version of the predicate
+  Predicate getUnsignedPredicate() const {
+    return getPredicate().getUnsigned();
   }
 
   /// This is just a convenience.
   /// @brief Determine if this is true when both operands are the same.
-  bool isTrueWhenEqual() const {
-    return isTrueWhenEqual(getPredicate());
-  }
+  bool isTrueWhenEqual() const { return getPredicate().isTrueWhenEqual(); }
 
   /// This is just a convenience.
   /// @brief Determine if this is false when both operands are the same.
-  bool isFalseWhenEqual() const {
-    return isFalseWhenEqual(getPredicate());
-  }
+  bool isFalseWhenEqual() const { return getPredicate().isFalseWhenEqual(); }
 
   /// @brief Determine if Pred1 implies Pred2 is true when two compares have
   /// matching operands.
   bool isImpliedTrueByMatchingCmp(Predicate Pred2) {
-    return isImpliedTrueByMatchingCmp(getPredicate(), Pred2);
+    return getPredicate().isImpliedTrueByMatchingCmp(Pred2);
   }
 
   /// @brief Determine if Pred1 implies Pred2 is false when two compares have
   /// matching operands.
   bool isImpliedFalseByMatchingCmp(Predicate Pred2) {
-    return isImpliedFalseByMatchingCmp(getPredicate(), Pred2);
+    return getPredicate().isImpliedFalseByMatchingCmp(Pred2);
   }
 
-  /// @returns true if the predicate is unsigned, false otherwise.
-  /// @brief Determine if the predicate is an unsigned operation.
-  static bool isUnsigned(Predicate predicate);
-
-  /// @returns true if the predicate is signed, false otherwise.
-  /// @brief Determine if the predicate is an signed operation.
-  static bool isSigned(Predicate predicate);
-
-  /// @brief Determine if the predicate is an ordered operation.
-  static bool isOrdered(Predicate predicate);
-
-  /// @brief Determine if the predicate is an unordered operation.
-  static bool isUnordered(Predicate predicate);
-
-  /// Determine if the predicate is true when comparing a value with itself.
-  static bool isTrueWhenEqual(Predicate predicate);
-
-  /// Determine if the predicate is false when comparing a value with itself.
-  static bool isFalseWhenEqual(Predicate predicate);
-
-  /// Determine if Pred1 implies Pred2 is true when two compares have matching
-  /// operands.
-  static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2);
-
-  /// Determine if Pred1 implies Pred2 is false when two compares have matching
-  /// operands.
-  static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2);
-
   /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::ICmp ||
            I->getOpcode() == Instruction::FCmp;
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }

include/llvm/IR/Instructions.h

 /// This instruction compares its operands according to the predicate given
 /// to the constructor. It only operates on integers or pointers. The operands
 /// must be identical types.
 /// Represent an integer comparison operator.
 class ICmpInst: public CmpInst {
   void anchor() override;
 
   void AssertOK() {
-    assert(getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE &&
-           getPredicate() <= CmpInst::LAST_ICMP_PREDICATE &&
-           "Invalid ICmp predicate value");
+    assert(getPredicate().isInt() && "Invalid ICmp predicate value");
     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
           "Both operands to ICmp instruction are not of the same type!");
     // Check that the operands are the right type
     assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
             getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&
            "Invalid operand types for ICmp instruction");
   }
 
ICmpInst(
     Value *RHS,     ///< The right-hand-side of the expression
     const Twine &NameStr = "" ///< Name of the instruction
   ) : CmpInst(makeCmpResultType(LHS->getType()),
               Instruction::ICmp, pred, LHS, RHS, NameStr) {
 #ifndef NDEBUG
   AssertOK();
 #endif
   }
 
-  /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
-  /// @returns the predicate that would be the result if the operand were
-  /// regarded as signed.
-  /// Return the signed version of the predicate
-  Predicate getSignedPredicate() const {
-    return getSignedPredicate(getPredicate());
-  }
-
-  /// This is a static version that you can use without an instruction.
-  /// Return the signed version of the predicate.
-  static Predicate getSignedPredicate(Predicate pred);
-
-  /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
-  /// @returns the predicate that would be the result if the operand were
-  /// regarded as unsigned.
-  /// Return the unsigned version of the predicate
-  Predicate getUnsignedPredicate() const {
-    return getUnsignedPredicate(getPredicate());
-  }
-
-  /// This is a static version that you can use without an instruction.
-  /// Return the unsigned version of the predicate.
-  static Predicate getUnsignedPredicate(Predicate pred);
-
-  /// Return true if this predicate is either EQ or NE.  This also
-  /// tests for commutativity.
-  static bool isEquality(Predicate P) {
-    return P == ICMP_EQ || P == ICMP_NE;
-  }
-
-  /// Return true if this predicate is either EQ or NE.  This also
-  /// tests for commutativity.
-  bool isEquality() const {
-    return isEquality(getPredicate());
-  }
-
-  /// @returns true if the predicate of this ICmpInst is commutative
-  /// Determine if this relation is commutative.
-  bool isCommutative() const { return isEquality(); }
-
-  /// Return true if the predicate is relational (not EQ or NE).
-  ///
-  bool isRelational() const {
-    return !isEquality();
-  }
-
-  /// Return true if the predicate is relational (not EQ or NE).
-  ///
-  static bool isRelational(Predicate P) {
-    return !isEquality(P);
-  }
-
   /// Initialize a set of values that all satisfy the predicate with C.
   /// Make a ConstantRange for a relation with a constant value.
   static ConstantRange makeConstantRange(Predicate pred, const APInt &C);
 
   /// Exchange the two operands to this instruction in such a way that it does
   /// not modify the semantics of the instruction. The predicate value may be
   /// changed to retain the same result if the predicate is order dependent
   /// (e.g. ult).
   /// Swap operands and adjust predicate.
FCmpInst(
     Instruction *InsertBefore, ///< Where to insert
     Predicate pred,  ///< The predicate to use for the comparison
     Value *LHS,      ///< The left-hand-side of the expression
     Value *RHS,      ///< The right-hand-side of the expression
     const Twine &NameStr = ""  ///< Name of the instruction
   ) : CmpInst(makeCmpResultType(LHS->getType()),
               Instruction::FCmp, pred, LHS, RHS, NameStr,
               InsertBefore) {
-    assert(pred <= FCmpInst::LAST_FCMP_PREDICATE &&
-           "Invalid FCmp predicate value");
+    assert(pred.isFP() && "Invalid FCmp predicate value");
     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
            "Both operands to FCmp instruction are not of the same type!");
     // Check that the operands are the right type
     assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
            "Invalid operand types for FCmp instruction");
   }
 
   /// Constructor with insert-at-end semantics.
   FCmpInst(
     BasicBlock &InsertAtEnd, ///< Block to insert into.
     Predicate pred,  ///< The predicate to use for the comparison
     Value *LHS,      ///< The left-hand-side of the expression
     Value *RHS,      ///< The right-hand-side of the expression
     const Twine &NameStr = ""  ///< Name of the instruction
   ) : CmpInst(makeCmpResultType(LHS->getType()),
               Instruction::FCmp, pred, LHS, RHS, NameStr,
               &InsertAtEnd) {
-    assert(pred <= FCmpInst::LAST_FCMP_PREDICATE &&
-           "Invalid FCmp predicate value");
+    assert(pred.isFP() && "Invalid FCmp predicate value");
     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
            "Both operands to FCmp instruction are not of the same type!");
     // Check that the operands are the right type
     assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
            "Invalid operand types for FCmp instruction");
   }
 
   /// Constructor with no-insertion semantics
   FCmpInst(
     Predicate pred, ///< The predicate to use for the comparison
     Value *LHS,     ///< The left-hand-side of the expression
     Value *RHS,     ///< The right-hand-side of the expression
     const Twine &NameStr = "" ///< Name of the instruction
   ) : CmpInst(makeCmpResultType(LHS->getType()),
               Instruction::FCmp, pred, LHS, RHS, NameStr) {
-    assert(pred <= FCmpInst::LAST_FCMP_PREDICATE &&
-           "Invalid FCmp predicate value");
+    assert(pred.isFP() && "Invalid FCmp predicate value");
     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
            "Both operands to FCmp instruction are not of the same type!");
     // Check that the operands are the right type
     assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
            "Invalid operand types for FCmp instruction");
   }
 
-  /// @returns true if the predicate of this instruction is EQ or NE.
-  /// Determine if this is an equality predicate.
-  static bool isEquality(Predicate Pred) {
-    return Pred == FCMP_OEQ || Pred == FCMP_ONE || Pred == FCMP_UEQ ||
-           Pred == FCMP_UNE;
-  }
-
-  /// @returns true if the predicate of this instruction is EQ or NE.
-  /// Determine if this is an equality predicate.
-  bool isEquality() const { return isEquality(getPredicate()); }
-
-  /// @returns true if the predicate of this instruction is commutative.
-  /// Determine if this is a commutative predicate.
-  bool isCommutative() const {
-    return isEquality() ||
-           getPredicate() == FCMP_FALSE ||
-           getPredicate() == FCMP_TRUE ||
-           getPredicate() == FCMP_ORD ||
-           getPredicate() == FCMP_UNO;
-  }
-
-  /// @returns true if the predicate is relational (not EQ or NE).
-  /// Determine if this a relational predicate.
-  bool isRelational() const { return !isEquality(); }
-
   /// Exchange the two operands to this instruction in such a way that it does
   /// not modify the semantics of the instruction. The predicate value may be
   /// changed to retain the same result if the predicate is order dependent
   /// (e.g. ult).
   /// Swap operands and adjust predicate.
   void swapOperands() {
     setPredicate(getSwappedPredicate());
     Op<0>().swap(Op<1>());

include/llvm/IR/NoFolder.h

public:
   Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
     return CastInst::CreateTruncOrBitCast(C, DestTy);
   }
 
   //===--------------------------------------------------------------------===//
   // Compare Instructions
   //===--------------------------------------------------------------------===//
 
-  Instruction *CreateICmp(CmpInst::Predicate P,
-                          Constant *LHS, Constant *RHS) const {
+  Instruction *CreateICmp(Predicate P, Constant *LHS, Constant *RHS) const {
     return new ICmpInst(P, LHS, RHS);
   }
-  Instruction *CreateFCmp(CmpInst::Predicate P,
-                          Constant *LHS, Constant *RHS) const {
+  Instruction *CreateFCmp(Predicate P, Constant *LHS, Constant *RHS) const {
     return new FCmpInst(P, LHS, RHS);
   }
 
   //===--------------------------------------------------------------------===//
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateSelect(Constant *C,

include/llvm/IR/PatternMatch.h

if (Class *I = dyn_cast<Class>(V))
         Predicate = I->getPredicate();
         return true;
       }
     return false;
   }
 };
 
 template <typename LHS, typename RHS>
-inline CmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate>
-m_Cmp(CmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
-  return CmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate>(Pred, L, R);
+inline CmpClass_match<LHS, RHS, CmpInst, Predicate>
+m_Cmp(Predicate &Pred, const LHS &L, const RHS &R) {
+  return CmpClass_match<LHS, RHS, CmpInst, Predicate>(Pred, L, R);
 }
 
 template <typename LHS, typename RHS>
-inline CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>
-m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
-  return CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>(Pred, L, R);
+inline CmpClass_match<LHS, RHS, ICmpInst, Predicate>
+m_ICmp(Predicate &Pred, const LHS &L, const RHS &R) {
+  return CmpClass_match<LHS, RHS, ICmpInst, Predicate>(Pred, L, R);
 }
 
 template <typename LHS, typename RHS>
-inline CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>
-m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
-  return CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>(Pred, L, R);
+inline CmpClass_match<LHS, RHS, FCmpInst, Predicate>
+m_FCmp(Predicate &Pred, const LHS &L, const RHS &R) {
+  return CmpClass_match<LHS, RHS, FCmpInst, Predicate>(Pred, L, R);
 }
 
 //===----------------------------------------------------------------------===//
 // Matchers for SelectInst classes
 //
 
 template <typename Cond_t, typename LHS_t, typename RHS_t>
 struct SelectClass_match {
template <typename OpTy> bool match(OpTy *V) {
     // it is the values returned by the select that are being compared.
     Value *TrueVal = SI->getTrueValue();
     Value *FalseVal = SI->getFalseValue();
     Value *LHS = Cmp->getOperand(0);
     Value *RHS = Cmp->getOperand(1);
     if ((TrueVal != LHS || FalseVal != RHS) &&
         (TrueVal != RHS || FalseVal != LHS))
       return false;
-    typename CmpInst_t::Predicate Pred =
+    Predicate Pred =
         LHS == TrueVal ? Cmp->getPredicate() : Cmp->getSwappedPredicate();
     // Does "(x pred y) ? x : y" represent the desired max/min operation?
     if (!Pred_t::match(Pred))
       return false;
     // It does!  Bind the operands.
     return L.match(LHS) && R.match(RHS);
   }
 };
 
 /// \brief Helper class for identifying signed max predicates.
 struct smax_pred_ty {
-  static bool match(ICmpInst::Predicate Pred) {
-    return Pred == CmpInst::ICMP_SGT || Pred == CmpInst::ICMP_SGE;
+  static bool match(Predicate Pred) {
+    return Pred.isOneOf(Predicate::ICMP_SGT, Predicate::ICMP_SGE);
   }
 };
 
 /// \brief Helper class for identifying signed min predicates.
 struct smin_pred_ty {
-  static bool match(ICmpInst::Predicate Pred) {
-    return Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SLE;
+  static bool match(Predicate Pred) {
+    return Pred.isOneOf(Predicate::ICMP_SLT, Predicate::ICMP_SLE);
   }
 };
 
 /// \brief Helper class for identifying unsigned max predicates.
 struct umax_pred_ty {
-  static bool match(ICmpInst::Predicate Pred) {
-    return Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_UGE;
+  static bool match(Predicate Pred) {
+    return Pred.isOneOf(Predicate::ICMP_UGT, Predicate::ICMP_UGE);
   }
 };
 
 /// \brief Helper class for identifying unsigned min predicates.
 struct umin_pred_ty {
-  static bool match(ICmpInst::Predicate Pred) {
-    return Pred == CmpInst::ICMP_ULT || Pred == CmpInst::ICMP_ULE;
+  static bool match(Predicate Pred) {
+    return Pred.isOneOf(Predicate::ICMP_ULT, Predicate::ICMP_ULE);
   }
 };
 
 /// \brief Helper class for identifying ordered max predicates.
 struct ofmax_pred_ty {
-  static bool match(FCmpInst::Predicate Pred) {
-    return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
+  static bool match(Predicate Pred) {
+    return Pred.isOneOf(Predicate::FCMP_OGT, Predicate::FCMP_OGE);
   }
 };
 
 /// \brief Helper class for identifying ordered min predicates.
 struct ofmin_pred_ty {
-  static bool match(FCmpInst::Predicate Pred) {
-    return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
+  static bool match(Predicate Pred) {
+    return Pred.isOneOf(Predicate::FCMP_OLT, Predicate::FCMP_OLE);
   }
 };
 
 /// \brief Helper class for identifying unordered max predicates.
 struct ufmax_pred_ty {
-  static bool match(FCmpInst::Predicate Pred) {
-    return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
+  static bool match(Predicate Pred) {
+    return Pred.isOneOf(Predicate::FCMP_UGT, Predicate::FCMP_UGE);
   }
 };
 
 /// \brief Helper class for identifying unordered min predicates.
 struct ufmin_pred_ty {
-  static bool match(FCmpInst::Predicate Pred) {
-    return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
+  static bool match(Predicate Pred) {
+    return Pred.isOneOf(Predicate::FCMP_ULT, Predicate::FCMP_ULE);
   }
 };
 
 template <typename LHS, typename RHS>
 inline MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty> m_SMax(const LHS &L,
                                                              const RHS &R) {
   return MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty>(L, R);
 }
struct UAddWithOverflow_match {
   RHS_t R;
   Sum_t S;
 
   UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
       : L(L), R(R), S(S) {}
 
   template <typename OpTy> bool match(OpTy *V) {
     Value *ICmpLHS, *ICmpRHS;
-    ICmpInst::Predicate Pred;
+    Predicate Pred;
     if (!m_ICmp(Pred, m_Value(ICmpLHS), m_Value(ICmpRHS)).match(V))
       return false;
 
     Value *AddLHS, *AddRHS;
     auto AddExpr = m_Add(m_Value(AddLHS), m_Value(AddRHS));
 
     // (a + b) u< a, (a + b) u< b
-    if (Pred == ICmpInst::ICMP_ULT)
+    if (Pred.isOneOf(Predicate::ICMP_ULT))
       if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
         return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
 
     // a >u (a + b), b >u (a + b)
-    if (Pred == ICmpInst::ICMP_UGT)
+    if (Pred.isOneOf(Predicate::ICMP_UGT))
       if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
         return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
 
     return false;
   }
 };
 
 /// \brief Match an icmp instruction checking for unsigned overflow on addition.

 }
 
 //===----------------------------------------------------------------------===//
 // Matchers for two-operands operators with the operators in either order
 //
 
 /// \brief Matches an ICmp with a predicate over LHS and RHS in either order.
 /// Does not swap the predicate.
-template<typename LHS, typename RHS>
-inline match_combine_or<CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>,
-                        CmpClass_match<RHS, LHS, ICmpInst, ICmpInst::Predicate>>
-m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
+template <typename LHS, typename RHS>
+inline match_combine_or<CmpClass_match<LHS, RHS, ICmpInst, Predicate>,
+                        CmpClass_match<RHS, LHS, ICmpInst, Predicate>>
+m_c_ICmp(Predicate &Pred, const LHS &L, const RHS &R) {
   return m_CombineOr(m_ICmp(Pred, L, R), m_ICmp(Pred, R, L));
 }
 
 /// \brief Matches an And with LHS and RHS in either order.
 template<typename LHS, typename RHS>
 inline match_combine_or<BinaryOp_match<LHS, RHS, Instruction::And>,
                         BinaryOp_match<RHS, LHS, Instruction::And>>
 m_c_And(const LHS &L, const RHS &R) {

include/llvm/Support/Predicate.h

+#ifndef LLVM_SUPPORT_PREDICATE
+#define LLVM_SUPPORT_PREDICATE
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace llvm {
+
+class Predicate {
+public:
+  /// This enumeration lists the possible predicates for CmpInst subclasses.
+  /// Values in the range 0-31 are reserved for FCmpInst, while values in the
+  /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
+  /// predicate values are not overlapping between the classes.
+  ///
+  /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
+  /// FCMP_* values. Changing the bit patterns requires a potential change to
+  /// those passes.
+  enum PredicateKind {
+    // Opcode              U L G E    Intuitive operation
+    FCMP_FALSE = 0, ///< 0 0 0 0    Always false (always folded)
+    FCMP_OEQ = 1,   ///< 0 0 0 1    True if ordered and equal
+    FCMP_OGT = 2,   ///< 0 0 1 0    True if ordered and greater than
+    FCMP_OGE = 3,   ///< 0 0 1 1    True if ordered and greater than or equal
+    FCMP_OLT = 4,   ///< 0 1 0 0    True if ordered and less than
+    FCMP_OLE = 5,   ///< 0 1 0 1    True if ordered and less than or equal
+    FCMP_ONE = 6,   ///< 0 1 1 0    True if ordered and operands are unequal
+    FCMP_ORD = 7,   ///< 0 1 1 1    True if ordered (no nans)
+    FCMP_UNO = 8,   ///< 1 0 0 0    True if unordered: isnan(X) | isnan(Y)
+    FCMP_UEQ = 9,   ///< 1 0 0 1    True if unordered or equal
+    FCMP_UGT = 10,  ///< 1 0 1 0    True if unordered or greater than
+    FCMP_UGE = 11,  ///< 1 0 1 1    True if unordered, greater than, or equal
+    FCMP_ULT = 12,  ///< 1 1 0 0    True if unordered or less than
+    FCMP_ULE = 13,  ///< 1 1 0 1    True if unordered, less than, or equal
+    FCMP_UNE = 14,  ///< 1 1 1 0    True if unordered or not equal
+    FCMP_TRUE = 15, ///< 1 1 1 1    Always true (always folded)
+    FIRST_FCMP_PREDICATE = FCMP_FALSE,
+    LAST_FCMP_PREDICATE = FCMP_TRUE,
+    BAD_FCMP_PREDICATE = FCMP_TRUE + 1,
+    ICMP_EQ = 32,  ///< equal
+    ICMP_NE = 33,  ///< not equal
+    ICMP_UGT = 34, ///< unsigned greater than
+    ICMP_UGE = 35, ///< unsigned greater or equal
+    ICMP_ULT = 36, ///< unsigned less than
+    ICMP_ULE = 37, ///< unsigned less or equal
+    ICMP_SGT = 38, ///< signed greater than
+    ICMP_SGE = 39, ///< signed greater or equal
+    ICMP_SLT = 40, ///< signed less than
+    ICMP_SLE = 41, ///< signed less or equal
+    FIRST_ICMP_PREDICATE = ICMP_EQ,
+    LAST_ICMP_PREDICATE = ICMP_SLE,
+    BAD_ICMP_PREDICATE = ICMP_SLE + 1
+  };
+
+  Predicate() : Pred(BAD_ICMP_PREDICATE) {}
+
+  Predicate(PredicateKind K) : Pred(K) {}
+
+  explicit Predicate(unsigned K) : Pred(static_cast<PredicateKind>(K)) {}
+
+  bool operator==(const Predicate &Other) const { return Pred == Other.Pred; }
+  bool operator!=(const Predicate &Other) const { return Pred != Other.Pred; }
+
+  PredicateKind getKind() const { return Pred; }
+
+  bool isFP() const {
+    return Pred >= FIRST_FCMP_PREDICATE && Pred <= LAST_FCMP_PREDICATE;
+  }
+
+  bool isInt() const {
+    return Pred >= FIRST_ICMP_PREDICATE && Pred <= LAST_ICMP_PREDICATE;
+  }
+
+  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
+  ///              OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
+  /// @returns the inverse predicate for predicate provided in \p pred.
+  /// @brief Return the inverse of a given predicate
+  Predicate getInverse() const;
+
+  /// For example, EQ->EQ, SLE->SGE, ULT->UGT,
+  ///              OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
+  /// @returns the predicate that would be the result of exchanging the two
+  /// operands of the CmpInst instruction without changing the result
+  /// produced.
+  /// @brief Return the predicate as if the operands were swapped
+  Predicate getSwapped() const;
+
+  /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
+  /// @returns the signed version of the unsigned predicate pred.
+  /// @brief return the signed version of a predicate
+  Predicate getSigned() const;
+
+  /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
+  /// @returns the signed version of the unsigned predicate pred.
+  /// @brief return the signed version of a predicate
+  Predicate getUnsigned() const;
+
+  /// @returns true if the predicate is unsigned, false otherwise.
+  /// @brief Determine if the predicate is an unsigned operation.
+  bool isUnsigned() const;
+
+  /// @returns true if the predicate is signed, false otherwise.
+  /// @brief Determine if the predicate is an signed operation.
+  bool isSigned() const;
+
+  /// @brief Determine if the predicate is an ordered operation.
+  bool isOrdered() const;
+
+  /// @brief Determine if the predicate is an unordered operation.
+  bool isUnordered() const;
+
+  /// Determine if the predicate is true when comparing a value with itself.
+  bool isTrueWhenEqual() const;
+
+  /// Determine if the predicate is false when comparing a value with itself.
+  bool isFalseWhenEqual() const;
+
+  /// Determine if the predicate is testing for equality. FIXME: floats????
+  bool isEquality() const;
+
+  /// Determine if the predicate is commutative (equality, true, false, ord or
+  /// uno).
+  bool isCommutative() const;
+
+  /// Return true if the predicate is relational (not EQ or NE).
+  bool isRelational() const;
+
+  /// Determine if Pred1 implies Pred2 is true when two compares have matching
+  /// operands.
+  bool isImpliedTrueByMatchingCmp(Predicate Pred2) const;
+
+  /// Determine if Pred1 implies Pred2 is false when two compares have matching
+  /// operands.
+  bool isImpliedFalseByMatchingCmp(Predicate Pred2) const;
+
+  StringRef getName() const;
+
+  bool isOneOf() const { return false; }
+
+  template <typename... Kinds>
+  bool isOneOf(PredicateKind Kind, Kinds... Others) {
+    return (Pred == Kind) || isOneOf(Others...);
+  }
+
+private:
+  PredicateKind Pred;
+};
+}
+#endif

include/llvm/Transforms/Scalar/GVN.h

class ValueTable {
     DenseMap<Expression, uint32_t> expressionNumbering;
     AliasAnalysis *AA;
     MemoryDependenceResults *MD;
     DominatorTree *DT;
 
     uint32_t nextValueNumber;
 
     Expression createExpr(Instruction *I);
-    Expression createCmpExpr(unsigned Opcode, CmpInst::Predicate Predicate,
-                             Value *LHS, Value *RHS);
+    Expression createCmpExpr(unsigned Opcode, Predicate Predicate, Value *LHS,
+                             Value *RHS);
     Expression createExtractvalueExpr(ExtractValueInst *EI);
     uint32_t lookupOrAddCall(CallInst *C);
 
   public:
     ValueTable();
     ValueTable(const ValueTable &Arg);
     ValueTable(ValueTable &&Arg);
     ~ValueTable();
 
     uint32_t lookupOrAdd(Value *V);
     uint32_t lookup(Value *V) const;
-    uint32_t lookupOrAddCmp(unsigned Opcode, CmpInst::Predicate Pred,
-                            Value *LHS, Value *RHS);
+    uint32_t lookupOrAddCmp(unsigned Opcode, Predicate Pred, Value *LHS,
+                            Value *RHS);
     bool exists(Value *V) const;
     void add(Value *V, uint32_t num);
     void clear();
     void erase(Value *v);
     void setAliasAnalysis(AliasAnalysis *A) { AA = A; }
     AliasAnalysis *getAliasAnalysis() const { return AA; }
     void setMemDep(MemoryDependenceResults *M) { MD = M; }
     void setDomTree(DominatorTree *D) { DT = D; }

include/llvm/Transforms/Utils/CmpInstAnalysis.h

namespace llvm {
   /// This is the complement of getICmpCode, which turns an opcode and two
   /// operands into either a constant true or false, or the predicate for a new
   /// ICmp instruction. 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 for which is output
   /// in NewICmpPred.
   Value *getICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS,
-                      CmpInst::Predicate &NewICmpPred);
+                      Predicate &NewICmpPred);
 
   /// Return true if both predicates match sign or if at least one of them is an
   /// equality comparison (which is signless).
-  bool PredicatesFoldable(CmpInst::Predicate p1, CmpInst::Predicate p2);
+  bool PredicatesFoldable(Predicate p1, Predicate p2);
 
   /// Decompose an icmp into the form ((X & Y) pred Z) if possible. The returned
   /// predicate is either == or !=. Returns false if decomposition fails.
-  bool decomposeBitTestICmp(const ICmpInst *I, CmpInst::Predicate &Pred,
-                            Value *&X, Value *&Y, Value *&Z);
+  bool decomposeBitTestICmp(const ICmpInst *I, Predicate &Pred, Value *&X,
+                            Value *&Y, Value *&Z);
 
 } // end namespace llvm
 
 #endif

lib/Analysis/BranchProbabilityInfo.cpp

bool BranchProbabilityInfo::calcPointerHeuristics(const BasicBlock *BB) {
 
   assert(CI->getOperand(1)->getType()->isPointerTy());
 
   // p != 0   ->   isProb = true
   // p == 0   ->   isProb = false
   // p != q   ->   isProb = true
   // p == q   ->   isProb = false;
   unsigned TakenIdx = 0, NonTakenIdx = 1;
-  bool isProb = CI->getPredicate() == ICmpInst::ICMP_NE;
+  bool isProb = CI->getPredicate() == Predicate::ICMP_NE;
   if (!isProb)
     std::swap(TakenIdx, NonTakenIdx);
 
   BranchProbability TakenProb(PH_TAKEN_WEIGHT,
                               PH_TAKEN_WEIGHT + PH_NONTAKEN_WEIGHT);
   setEdgeProbability(BB, TakenIdx, TakenProb);
   setEdgeProbability(BB, NonTakenIdx, TakenProb.getCompl());
   return true;
bool BranchProbabilityInfo::calcZeroHeuristics(const BasicBlock *BB) {
   if (Instruction *LHS = dyn_cast<Instruction>(CI->getOperand(0)))
     if (LHS->getOpcode() == Instruction::And)
       if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(LHS->getOperand(1)))
         if (AndRHS->getUniqueInteger().isPowerOf2())
           return false;
 
   bool isProb;
   if (CV->isZero()) {
-    switch (CI->getPredicate()) {
-    case CmpInst::ICMP_EQ:
+    switch (CI->getPredicate().getKind()) {
+    case Predicate::ICMP_EQ:
       // X == 0   ->  Unlikely
       isProb = false;
       break;
-    case CmpInst::ICMP_NE:
+    case Predicate::ICMP_NE:
       // X != 0   ->  Likely
       isProb = true;
       break;
-    case CmpInst::ICMP_SLT:
+    case Predicate::ICMP_SLT:
       // X < 0   ->  Unlikely
       isProb = false;
       break;
-    case CmpInst::ICMP_SGT:
+    case Predicate::ICMP_SGT:
       // X > 0   ->  Likely
       isProb = true;
       break;
     default:
       return false;
     }
-  } else if (CV->isOne() && CI->getPredicate() == CmpInst::ICMP_SLT) {
+  } else if (CV->isOne() && CI->getPredicate() == Predicate::ICMP_SLT) {
     // InstCombine canonicalizes X <= 0 into X < 1.
     // X <= 0   ->  Unlikely
     isProb = false;
   } else if (CV->isAllOnesValue()) {
-    switch (CI->getPredicate()) {
-    case CmpInst::ICMP_EQ:
+    switch (CI->getPredicate().getKind()) {
+    case Predicate::ICMP_EQ:
       // X == -1  ->  Unlikely
       isProb = false;
       break;
-    case CmpInst::ICMP_NE:
+    case Predicate::ICMP_NE:
       // X != -1  ->  Likely
       isProb = true;
       break;
-    case CmpInst::ICMP_SGT:
+    case Predicate::ICMP_SGT:
       // InstCombine canonicalizes X >= 0 into X > -1.
       // X >= 0   ->  Likely
       isProb = true;
       break;
     default:
       return false;
     }
   } else {
bool BranchProbabilityInfo::calcFloatingPointHeuristics(const BasicBlock *BB) {
   if (!FCmp)
     return false;
 
   bool isProb;
   if (FCmp->isEquality()) {
     // f1 == f2 -> Unlikely
     // f1 != f2 -> Likely
     isProb = !FCmp->isTrueWhenEqual();
-  } else if (FCmp->getPredicate() == FCmpInst::FCMP_ORD) {
+  } else if (FCmp->getPredicate() == Predicate::FCMP_ORD) {
     // !isnan -> Likely
     isProb = true;
-  } else if (FCmp->getPredicate() == FCmpInst::FCMP_UNO) {
+  } else if (FCmp->getPredicate() == Predicate::FCMP_UNO) {
     // isnan -> Unlikely
     isProb = false;
   } else {
     return false;
   }
 
   unsigned TakenIdx = 0, NonTakenIdx = 1;
 

lib/Analysis/ConstantFolding.cpp

 
 Constant *llvm::ConstantFoldInstOperands(Instruction *I,
                                          ArrayRef<Constant *> Ops,
                                          const DataLayout &DL,
                                          const TargetLibraryInfo *TLI) {
   return ConstantFoldInstOperandsImpl(I, I->getOpcode(), Ops, DL, TLI);
 }
 
-Constant *llvm::ConstantFoldCompareInstOperands(unsigned Predicate,
-                                                Constant *Ops0, Constant *Ops1,
+Constant *llvm::ConstantFoldCompareInstOperands(Predicate Pred, Constant *Ops0,
+                                                Constant *Ops1,
                                                 const DataLayout &DL,
                                                 const TargetLibraryInfo *TLI) {
   // fold: icmp (inttoptr x), null         -> icmp x, 0
   // fold: icmp (ptrtoint x), 0            -> icmp x, null
   // fold: icmp (inttoptr x), (inttoptr y) -> icmp trunc/zext x, trunc/zext y
   // fold: icmp (ptrtoint x), (ptrtoint y) -> icmp x, y
   //
   // FIXME: The following comment is out of data and the DataLayout is here now.
   // ConstantExpr::getCompare cannot do this, because it doesn't have DL
   // around to know if bit truncation is happening.
   if (auto *CE0 = dyn_cast<ConstantExpr>(Ops0)) {
     if (Ops1->isNullValue()) {
       if (CE0->getOpcode() == Instruction::IntToPtr) {
         Type *IntPtrTy = DL.getIntPtrType(CE0->getType());
         // Convert the integer value to the right size to ensure we get the
         // proper extension or truncation.
         Constant *C = ConstantExpr::getIntegerCast(CE0->getOperand(0),
                                                    IntPtrTy, false);
         Constant *Null = Constant::getNullValue(C->getType());
-        return ConstantFoldCompareInstOperands(Predicate, C, Null, DL, TLI);
+        return ConstantFoldCompareInstOperands(Pred, C, Null, DL, TLI);
       }
 
       // Only do this transformation if the int is intptrty in size, otherwise
       // there is a truncation or extension that we aren't modeling.
       if (CE0->getOpcode() == Instruction::PtrToInt) {
         Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType());
         if (CE0->getType() == IntPtrTy) {
           Constant *C = CE0->getOperand(0);
           Constant *Null = Constant::getNullValue(C->getType());
-          return ConstantFoldCompareInstOperands(Predicate, C, Null, DL, TLI);
+          return ConstantFoldCompareInstOperands(Pred, C, Null, DL, TLI);
         }
       }
     }
 
     if (auto *CE1 = dyn_cast<ConstantExpr>(Ops1)) {
       if (CE0->getOpcode() == CE1->getOpcode()) {
         if (CE0->getOpcode() == Instruction::IntToPtr) {
           Type *IntPtrTy = DL.getIntPtrType(CE0->getType());
 
           // Convert the integer value to the right size to ensure we get the
           // proper extension or truncation.
           Constant *C0 = ConstantExpr::getIntegerCast(CE0->getOperand(0),
                                                       IntPtrTy, false);
           Constant *C1 = ConstantExpr::getIntegerCast(CE1->getOperand(0),
                                                       IntPtrTy, false);
-          return ConstantFoldCompareInstOperands(Predicate, C0, C1, DL, TLI);
+          return ConstantFoldCompareInstOperands(Pred, C0, C1, DL, TLI);
         }
 
         // Only do this transformation if the int is intptrty in size, otherwise
         // there is a truncation or extension that we aren't modeling.
         if (CE0->getOpcode() == Instruction::PtrToInt) {
           Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType());
           if (CE0->getType() == IntPtrTy &&
               CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()) {
-            return ConstantFoldCompareInstOperands(
-                Predicate, CE0->getOperand(0), CE1->getOperand(0), DL, TLI);
+            return ConstantFoldCompareInstOperands(Pred, CE0->getOperand(0),
+                                                   CE1->getOperand(0), DL, TLI);
           }
         }
       }
     }
 
     // icmp eq (or x, y), 0 -> (icmp eq x, 0) & (icmp eq y, 0)
     // icmp ne (or x, y), 0 -> (icmp ne x, 0) | (icmp ne y, 0)
-    if ((Predicate == ICmpInst::ICMP_EQ || Predicate == ICmpInst::ICMP_NE) &&
+    if ((Pred == Predicate::ICMP_EQ || Pred == Predicate::ICMP_NE) &&
         CE0->getOpcode() == Instruction::Or && Ops1->isNullValue()) {
-      Constant *LHS = ConstantFoldCompareInstOperands(
-          Predicate, CE0->getOperand(0), Ops1, DL, TLI);
-      Constant *RHS = ConstantFoldCompareInstOperands(
-          Predicate, CE0->getOperand(1), Ops1, DL, TLI);
+      Constant *LHS = ConstantFoldCompareInstOperands(Pred, CE0->getOperand(0),
+                                                      Ops1, DL, TLI);
+      Constant *RHS = ConstantFoldCompareInstOperands(Pred, CE0->getOperand(1),
+                                                      Ops1, DL, TLI);
       unsigned OpC =
-        Predicate == ICmpInst::ICMP_EQ ? Instruction::And : Instruction::Or;
+          Pred == Predicate::ICMP_EQ ? Instruction::And : Instruction::Or;
       return ConstantFoldBinaryOpOperands(OpC, LHS, RHS, DL);
     }
   }
 
-  return ConstantExpr::getCompare(Predicate, Ops0, Ops1);
+  return ConstantExpr::getCompare(Pred, Ops0, Ops1);
 }
 
 Constant *llvm::ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS,
                                              Constant *RHS,
                                              const DataLayout &DL) {
   assert(Instruction::isBinaryOp(Opcode));
   if (isa<ConstantExpr>(LHS) || isa<ConstantExpr>(RHS))
     if (Constant *C = SymbolicallyEvaluateBinop(Opcode, LHS, RHS, DL))

lib/Analysis/DependenceAnalysis.cpp

if (X->isEmpty())
     return false;
   if (Y->isEmpty()) {
     X->setEmpty();
     return true;
   }
 
   if (X->isDistance() && Y->isDistance()) {
     DEBUG(dbgs() << "\t    intersect 2 distances\n");
-    if (isKnownPredicate(CmpInst::ICMP_EQ, X->getD(), Y->getD()))
+    if (isKnownPredicate(Predicate::ICMP_EQ, X->getD(), Y->getD()))
       return false;
-    if (isKnownPredicate(CmpInst::ICMP_NE, X->getD(), Y->getD())) {
+    if (isKnownPredicate(Predicate::ICMP_NE, X->getD(), Y->getD())) {
       X->setEmpty();
       ++DeltaSuccesses;
       return true;
     }
     // Hmmm, interesting situation.
     // I guess if either is constant, keep it and ignore the other.
     if (isa<SCEVConstant>(Y->getD())) {
       *X = *Y;
bool DependenceInfo::intersectConstraints(Constraint *X, const Constraint *Y) {
   // the result of an intersection.
   assert(!(X->isPoint() && Y->isPoint()) &&
          "We shouldn't ever see X->isPoint() && Y->isPoint()");
 
   if (X->isLine() && Y->isLine()) {
     DEBUG(dbgs() << "\t    intersect 2 lines\n");
     const SCEV *Prod1 = SE->getMulExpr(X->getA(), Y->getB());
     const SCEV *Prod2 = SE->getMulExpr(X->getB(), Y->getA());
-    if (isKnownPredicate(CmpInst::ICMP_EQ, Prod1, Prod2)) {
+    if (isKnownPredicate(Predicate::ICMP_EQ, Prod1, Prod2)) {
       // slopes are equal, so lines are parallel
       DEBUG(dbgs() << "\t\tsame slope\n");
       Prod1 = SE->getMulExpr(X->getC(), Y->getB());
       Prod2 = SE->getMulExpr(X->getB(), Y->getC());
-      if (isKnownPredicate(CmpInst::ICMP_EQ, Prod1, Prod2))
+      if (isKnownPredicate(Predicate::ICMP_EQ, Prod1, Prod2))
         return false;
-      if (isKnownPredicate(CmpInst::ICMP_NE, Prod1, Prod2)) {
+      if (isKnownPredicate(Predicate::ICMP_NE, Prod1, Prod2)) {
         X->setEmpty();
         ++DeltaSuccesses;
         return true;
       }
       return false;
     }
-    if (isKnownPredicate(CmpInst::ICMP_NE, Prod1, Prod2)) {
+    if (isKnownPredicate(Predicate::ICMP_NE, Prod1, Prod2)) {
       // slopes differ, so lines intersect
       DEBUG(dbgs() << "\t\tdifferent slopes\n");
       const SCEV *C1B2 = SE->getMulExpr(X->getC(), Y->getB());
       const SCEV *C1A2 = SE->getMulExpr(X->getC(), Y->getA());
       const SCEV *C2B1 = SE->getMulExpr(Y->getC(), X->getB());
       const SCEV *C2A1 = SE->getMulExpr(Y->getC(), X->getA());
       const SCEV *A1B2 = SE->getMulExpr(X->getA(), Y->getB());
       const SCEV *A2B1 = SE->getMulExpr(Y->getA(), X->getB());
bool DependenceInfo::intersectConstraints(Constraint *X, const Constraint *Y) {
   // if (X->isLine() && Y->isPoint()) This case can't occur.
   assert(!(X->isLine() && Y->isPoint()) && "This case should never occur");
 
   if (X->isPoint() && Y->isLine()) {
     DEBUG(dbgs() << "\t    intersect Point and Line\n");
     const SCEV *A1X1 = SE->getMulExpr(Y->getA(), X->getX());
     const SCEV *B1Y1 = SE->getMulExpr(Y->getB(), X->getY());
     const SCEV *Sum = SE->getAddExpr(A1X1, B1Y1);
-    if (isKnownPredicate(CmpInst::ICMP_EQ, Sum, Y->getC()))
+    if (isKnownPredicate(Predicate::ICMP_EQ, Sum, Y->getC()))
       return false;
-    if (isKnownPredicate(CmpInst::ICMP_NE, Sum, Y->getC())) {
+    if (isKnownPredicate(Predicate::ICMP_NE, Sum, Y->getC())) {
       X->setEmpty();
       ++DeltaSuccesses;
       return true;
     }
     return false;
   }
 
   llvm_unreachable("shouldn't reach the end of Constraint intersection");

 // If both X and Y have been identically sign or zero extended,
 // it strips off the (confusing) extensions before invoking
 // SCEV::isKnownPredicate. Perhaps, someday, the ScalarEvolution package
 // will be similarly updated.
 //
 // If SCEV::isKnownPredicate can't prove the predicate,
 // we try simple subtraction, which seems to help in some cases
 // involving symbolics.
-bool DependenceInfo::isKnownPredicate(ICmpInst::Predicate Pred, const SCEV *X,
+bool DependenceInfo::isKnownPredicate(Predicate Pred, const SCEV *X,
                                       const SCEV *Y) const {
-  if (Pred == CmpInst::ICMP_EQ ||
-      Pred == CmpInst::ICMP_NE) {
+  if (Pred == Predicate::ICMP_EQ || Pred == Predicate::ICMP_NE) {
     if ((isa<SCEVSignExtendExpr>(X) &&
          isa<SCEVSignExtendExpr>(Y)) ||
         (isa<SCEVZeroExtendExpr>(X) &&
          isa<SCEVZeroExtendExpr>(Y))) {
       const SCEVCastExpr *CX = cast<SCEVCastExpr>(X);
       const SCEVCastExpr *CY = cast<SCEVCastExpr>(Y);
       const SCEV *Xop = CX->getOperand();
       const SCEV *Yop = CY->getOperand();
       if (Xop->getType() == Yop->getType()) {
         X = Xop;
         Y = Yop;
       }
     }
   }
   if (SE->isKnownPredicate(Pred, X, Y))
     return true;
   // If SE->isKnownPredicate can't prove the condition,
   // we try the brute-force approach of subtracting
   // and testing the difference.
   // By testing with SE->isKnownPredicate first, we avoid
   // the possibility of overflow when the arguments are constants.
   const SCEV *Delta = SE->getMinusSCEV(X, Y);
-  switch (Pred) {
-  case CmpInst::ICMP_EQ:
+  switch (Pred.getKind()) {
+  case Predicate::ICMP_EQ:
     return Delta->isZero();
-  case CmpInst::ICMP_NE:
+  case Predicate::ICMP_NE:
     return SE->isKnownNonZero(Delta);
-  case CmpInst::ICMP_SGE:
+  case Predicate::ICMP_SGE:
     return SE->isKnownNonNegative(Delta);
-  case CmpInst::ICMP_SLE:
+  case Predicate::ICMP_SLE:
     return SE->isKnownNonPositive(Delta);
-  case CmpInst::ICMP_SGT:
+  case Predicate::ICMP_SGT:
     return SE->isKnownPositive(Delta);
-  case CmpInst::ICMP_SLT:
+  case Predicate::ICMP_SLT:
     return SE->isKnownNegative(Delta);
   default:
     llvm_unreachable("unexpected predicate in isKnownPredicate");
   }
 }
 
 
 // All subscripts are all the same type.

 // 3) the values might be equal, so we have to assume a dependence.
 //
 // Return true if dependence disproved.
 bool DependenceInfo::testZIV(const SCEV *Src, const SCEV *Dst,
                              FullDependence &Result) const {
   DEBUG(dbgs() << "    src = " << *Src << "\n");
   DEBUG(dbgs() << "    dst = " << *Dst << "\n");
   ++ZIVapplications;
-  if (isKnownPredicate(CmpInst::ICMP_EQ, Src, Dst)) {
+  if (isKnownPredicate(Predicate::ICMP_EQ, Src, Dst)) {
     DEBUG(dbgs() << "    provably dependent\n");
     return false; // provably dependent
   }
-  if (isKnownPredicate(CmpInst::ICMP_NE, Src, Dst)) {
+  if (isKnownPredicate(Predicate::ICMP_NE, Src, Dst)) {
     DEBUG(dbgs() << "    provably independent\n");
     ++ZIVindependence;
     return true; // provably independent
   }
   DEBUG(dbgs() << "    possibly dependent\n");
   Result.Consistent = false;
   return false; // possibly dependent
 }
bool DependenceInfo::strongSIVtest(const SCEV *Coeff, const SCEV *SrcConst,
   if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
     DEBUG(dbgs() << "\t    UpperBound = " << *UpperBound);
     DEBUG(dbgs() << ", " << *UpperBound->getType() << "\n");
     const SCEV *AbsDelta =
       SE->isKnownNonNegative(Delta) ? Delta : SE->getNegativeSCEV(Delta);
     const SCEV *AbsCoeff =
       SE->isKnownNonNegative(Coeff) ? Coeff : SE->getNegativeSCEV(Coeff);
     const SCEV *Product = SE->getMulExpr(UpperBound, AbsCoeff);
-    if (isKnownPredicate(CmpInst::ICMP_SGT, AbsDelta, Product)) {
+    if (isKnownPredicate(Predicate::ICMP_SGT, AbsDelta, Product)) {
       // Distance greater than trip count - no dependence
       ++StrongSIVindependence;
       ++StrongSIVsuccesses;
       return true;
     }
   }
 
   // Can we compute distance?
bool DependenceInfo::weakCrossingSIVtest(
   // We're certain that Delta > 0 and ConstCoeff > 0.
   // Check Delta/(2*ConstCoeff) against upper loop bound
   if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
     DEBUG(dbgs() << "\t    UpperBound = " << *UpperBound << "\n");
     const SCEV *ConstantTwo = SE->getConstant(UpperBound->getType(), 2);
     const SCEV *ML = SE->getMulExpr(SE->getMulExpr(ConstCoeff, UpperBound),
                                     ConstantTwo);
     DEBUG(dbgs() << "\t    ML = " << *ML << "\n");
-    if (isKnownPredicate(CmpInst::ICMP_SGT, Delta, ML)) {
+    if (isKnownPredicate(Predicate::ICMP_SGT, Delta, ML)) {
       // Delta too big, no dependence
       ++WeakCrossingSIVindependence;
       ++WeakCrossingSIVsuccesses;
       return true;
     }
-    if (isKnownPredicate(CmpInst::ICMP_EQ, Delta, ML)) {
+    if (isKnownPredicate(Predicate::ICMP_EQ, Delta, ML)) {
       // i = i' = UB
       Result.DV[Level].Direction &= unsigned(~Dependence::DVEntry::LT);
       Result.DV[Level].Direction &= unsigned(~Dependence::DVEntry::GT);
       ++WeakCrossingSIVsuccesses;
       if (!Result.DV[Level].Direction) {
         ++WeakCrossingSIVindependence;
         return true;
       }
bool DependenceInfo::weakZeroSrcSIVtest(const SCEV *DstCoeff,
   ++WeakZeroSIVapplications;
   assert(0 < Level && Level <= MaxLevels && "Level out of range");
   Level--;
   Result.Consistent = false;
   const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
   NewConstraint.setLine(SE->getZero(Delta->getType()), DstCoeff, Delta,
                         CurLoop);
   DEBUG(dbgs() << "\t    Delta = " << *Delta << "\n");
-  if (isKnownPredicate(CmpInst::ICMP_EQ, SrcConst, DstConst)) {
+  if (isKnownPredicate(Predicate::ICMP_EQ, SrcConst, DstConst)) {
     if (Level < CommonLevels) {
       Result.DV[Level].Direction &= Dependence::DVEntry::LE;
       Result.DV[Level].PeelFirst = true;
       ++WeakZeroSIVsuccesses;
     }
     return false; // dependences caused by first iteration
   }
   const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(DstCoeff);
   if (!ConstCoeff)
     return false;
   const SCEV *AbsCoeff =
     SE->isKnownNegative(ConstCoeff) ?
     SE->getNegativeSCEV(ConstCoeff) : ConstCoeff;
   const SCEV *NewDelta =
     SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
 
   // check that Delta/SrcCoeff < iteration count
   // really check NewDelta < count*AbsCoeff
   if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
     DEBUG(dbgs() << "\t    UpperBound = " << *UpperBound << "\n");
     const SCEV *Product = SE->getMulExpr(AbsCoeff, UpperBound);
-    if (isKnownPredicate(CmpInst::ICMP_SGT, NewDelta, Product)) {
+    if (isKnownPredicate(Predicate::ICMP_SGT, NewDelta, Product)) {
       ++WeakZeroSIVindependence;
       ++WeakZeroSIVsuccesses;
       return true;
     }
-    if (isKnownPredicate(CmpInst::ICMP_EQ, NewDelta, Product)) {
+    if (isKnownPredicate(Predicate::ICMP_EQ, NewDelta, Product)) {
       // dependences caused by last iteration
       if (Level < CommonLevels) {
         Result.DV[Level].Direction &= Dependence::DVEntry::GE;
         Result.DV[Level].PeelLast = true;
         ++WeakZeroSIVsuccesses;
       }
       return false;
     }
bool DependenceInfo::weakZeroDstSIVtest(const SCEV *SrcCoeff,
   ++WeakZeroSIVapplications;
   assert(0 < Level && Level <= SrcLevels && "Level out of range");
   Level--;
   Result.Consistent = false;
   const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
   NewConstraint.setLine(SrcCoeff, SE->getZero(Delta->getType()), Delta,
                         CurLoop);
   DEBUG(dbgs() << "\t    Delta = " << *Delta << "\n");
-  if (isKnownPredicate(CmpInst::ICMP_EQ, DstConst, SrcConst)) {
+  if (isKnownPredicate(Predicate::ICMP_EQ, DstConst, SrcConst)) {
     if (Level < CommonLevels) {
       Result.DV[Level].Direction &= Dependence::DVEntry::LE;
       Result.DV[Level].PeelFirst = true;
       ++WeakZeroSIVsuccesses;
     }
     return false; // dependences caused by first iteration
   }
   const SCEVConstant *ConstCoeff = dyn_cast<SCEVConstant>(SrcCoeff);
   if (!ConstCoeff)
     return false;
   const SCEV *AbsCoeff =
     SE->isKnownNegative(ConstCoeff) ?
     SE->getNegativeSCEV(ConstCoeff) : ConstCoeff;
   const SCEV *NewDelta =
     SE->isKnownNegative(ConstCoeff) ? SE->getNegativeSCEV(Delta) : Delta;
 
   // check that Delta/SrcCoeff < iteration count
   // really check NewDelta < count*AbsCoeff
   if (const SCEV *UpperBound = collectUpperBound(CurLoop, Delta->getType())) {
     DEBUG(dbgs() << "\t    UpperBound = " << *UpperBound << "\n");
     const SCEV *Product = SE->getMulExpr(AbsCoeff, UpperBound);
-    if (isKnownPredicate(CmpInst::ICMP_SGT, NewDelta, Product)) {
+    if (isKnownPredicate(Predicate::ICMP_SGT, NewDelta, Product)) {
       ++WeakZeroSIVindependence;
       ++WeakZeroSIVsuccesses;
       return true;
     }
-    if (isKnownPredicate(CmpInst::ICMP_EQ, NewDelta, Product)) {
+    if (isKnownPredicate(Predicate::ICMP_EQ, NewDelta, Product)) {
       // dependences caused by last iteration
       if (Level < CommonLevels) {
         Result.DV[Level].Direction &= Dependence::DVEntry::GE;
         Result.DV[Level].PeelLast = true;
         ++WeakZeroSIVsuccesses;
       }
       return false;
     }
bool DependenceInfo::symbolicRDIVtest(const SCEV *A1, const SCEV *A2,
   DEBUG(dbgs() << "\t    C1 - C2 = " << *C1_C2 << "\n");
   if (SE->isKnownNonNegative(A1)) {
     if (SE->isKnownNonNegative(A2)) {
       // A1 >= 0 && A2 >= 0
       if (N1) {
         // make sure that c2 - c1 <= a1*N1
         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
         DEBUG(dbgs() << "\t    A1*N1 = " << *A1N1 << "\n");
-        if (isKnownPredicate(CmpInst::ICMP_SGT, C2_C1, A1N1)) {
+        if (isKnownPredicate(Predicate::ICMP_SGT, C2_C1, A1N1)) {
           ++SymbolicRDIVindependence;
           return true;
         }
       }
       if (N2) {
         // make sure that -a2*N2 <= c2 - c1, or a2*N2 >= c1 - c2
         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
         DEBUG(dbgs() << "\t    A2*N2 = " << *A2N2 << "\n");
-        if (isKnownPredicate(CmpInst::ICMP_SLT, A2N2, C1_C2)) {
+        if (isKnownPredicate(Predicate::ICMP_SLT, A2N2, C1_C2)) {
           ++SymbolicRDIVindependence;
           return true;
         }
       }
     }
     else if (SE->isKnownNonPositive(A2)) {
       // a1 >= 0 && a2 <= 0
       if (N1 && N2) {
         // make sure that c2 - c1 <= a1*N1 - a2*N2
         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
         const SCEV *A1N1_A2N2 = SE->getMinusSCEV(A1N1, A2N2);
         DEBUG(dbgs() << "\t    A1*N1 - A2*N2 = " << *A1N1_A2N2 << "\n");
-        if (isKnownPredicate(CmpInst::ICMP_SGT, C2_C1, A1N1_A2N2)) {
+        if (isKnownPredicate(Predicate::ICMP_SGT, C2_C1, A1N1_A2N2)) {
           ++SymbolicRDIVindependence;
           return true;
         }
       }
       // make sure that 0 <= c2 - c1
       if (SE->isKnownNegative(C2_C1)) {
         ++SymbolicRDIVindependence;
         return true;
       }
     }
   }
   else if (SE->isKnownNonPositive(A1)) {
     if (SE->isKnownNonNegative(A2)) {
       // a1 <= 0 && a2 >= 0
       if (N1 && N2) {
         // make sure that a1*N1 - a2*N2 <= c2 - c1
         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
         const SCEV *A1N1_A2N2 = SE->getMinusSCEV(A1N1, A2N2);
         DEBUG(dbgs() << "\t    A1*N1 - A2*N2 = " << *A1N1_A2N2 << "\n");
-        if (isKnownPredicate(CmpInst::ICMP_SGT, A1N1_A2N2, C2_C1)) {
+        if (isKnownPredicate(Predicate::ICMP_SGT, A1N1_A2N2, C2_C1)) {
           ++SymbolicRDIVindependence;
           return true;
         }
       }
       // make sure that c2 - c1 <= 0
       if (SE->isKnownPositive(C2_C1)) {
         ++SymbolicRDIVindependence;
         return true;
       }
     }
     else if (SE->isKnownNonPositive(A2)) {
       // a1 <= 0 && a2 <= 0
       if (N1) {
         // make sure that a1*N1 <= c2 - c1
         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
         DEBUG(dbgs() << "\t    A1*N1 = " << *A1N1 << "\n");
-        if (isKnownPredicate(CmpInst::ICMP_SGT, A1N1, C2_C1)) {
+        if (isKnownPredicate(Predicate::ICMP_SGT, A1N1, C2_C1)) {
           ++SymbolicRDIVindependence;
           return true;
         }
       }
       if (N2) {
         // make sure that c2 - c1 <= -a2*N2, or c1 - c2 >= a2*N2
         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
         DEBUG(dbgs() << "\t    A2*N2 = " << *A2N2 << "\n");
-        if (isKnownPredicate(CmpInst::ICMP_SLT, C1_C2, A2N2)) {
+        if (isKnownPredicate(Predicate::ICMP_SLT, C1_C2, A2N2)) {
           ++SymbolicRDIVindependence;
           return true;
         }
       }
     }
   }
   return false;
 }

 }
 
 
 // Returns true iff the current bounds are plausible.
 bool DependenceInfo::testBounds(unsigned char DirKind, unsigned Level,
                                 BoundInfo *Bound, const SCEV *Delta) const {
   Bound[Level].Direction = DirKind;
   if (const SCEV *LowerBound = getLowerBound(Bound))
-    if (isKnownPredicate(CmpInst::ICMP_SGT, LowerBound, Delta))
+    if (isKnownPredicate(Predicate::ICMP_SGT, LowerBound, Delta))
       return false;
   if (const SCEV *UpperBound = getUpperBound(Bound))
-    if (isKnownPredicate(CmpInst::ICMP_SGT, Delta, UpperBound))
+    if (isKnownPredicate(Predicate::ICMP_SGT, Delta, UpperBound))
       return false;
   return true;
 }
 
 
 // Computes the upper and lower bounds for level K
 // using the * direction. Records them in Bound.
 // Wolfe gives the equations
Bound[K].Lower[Dependence::DVEntry::ALL] =
       SE->getMulExpr(SE->getMinusSCEV(A[K].NegPart, B[K].PosPart),
                      Bound[K].Iterations);
     Bound[K].Upper[Dependence::DVEntry::ALL] =
       SE->getMulExpr(SE->getMinusSCEV(A[K].PosPart, B[K].NegPart),
                      Bound[K].Iterations);
   }
   else {
     // If the difference is 0, we won't need to know the number of iterations.
-    if (isKnownPredicate(CmpInst::ICMP_EQ, A[K].NegPart, B[K].PosPart))
+    if (isKnownPredicate(Predicate::ICMP_EQ, A[K].NegPart, B[K].PosPart))
       Bound[K].Lower[Dependence::DVEntry::ALL] =
           SE->getZero(A[K].Coeff->getType());
-    if (isKnownPredicate(CmpInst::ICMP_EQ, A[K].PosPart, B[K].NegPart))
+    if (isKnownPredicate(Predicate::ICMP_EQ, A[K].PosPart, B[K].NegPart))
       Bound[K].Upper[Dependence::DVEntry::ALL] =
           SE->getZero(A[K].Coeff->getType());
   }
 }
 
 
 // Computes the upper and lower bounds for level K
 // using the = direction. Records them in Bound.
else if (B->isZero()) {
     APInt Charlie = Cconst->getAPInt();
     APInt CdivA = Charlie.sdiv(Alpha);
     assert(Charlie.srem(Alpha) == 0 && "C should be evenly divisible by A");
     const SCEV *A_K = findCoefficient(Src, CurLoop);
     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
     Src = zeroCoefficient(Src, CurLoop);
     if (!findCoefficient(Dst, CurLoop)->isZero())
       Consistent = false;
-  }
-  else if (isKnownPredicate(CmpInst::ICMP_EQ, A, B)) {
+  } else if (isKnownPredicate(Predicate::ICMP_EQ, A, B)) {
     const SCEVConstant *Aconst = dyn_cast<SCEVConstant>(A);
     const SCEVConstant *Cconst = dyn_cast<SCEVConstant>(C);
     if (!Aconst || !Cconst) return false;
     APInt Alpha = Aconst->getAPInt();
     APInt Charlie = Cconst->getAPInt();
     APInt CdivA = Charlie.sdiv(Alpha);
     assert(Charlie.srem(Alpha) == 0 && "C should be evenly divisible by A");
     const SCEV *A_K = findCoefficient(Src, CurLoop);
else if (CurConstraint.isLine()) {
     Level.Scalar = false;
     Level.Distance = nullptr;
     // direction should be accurate
   }
   else if (CurConstraint.isPoint()) {
     Level.Scalar = false;
     Level.Distance = nullptr;
     unsigned NewDirection = Dependence::DVEntry::NONE;
-    if (!isKnownPredicate(CmpInst::ICMP_NE,
-                          CurConstraint.getY(),
+    if (!isKnownPredicate(Predicate::ICMP_NE, CurConstraint.getY(),
                           CurConstraint.getX()))
       // if X may be = Y
       NewDirection |= Dependence::DVEntry::EQ;
-    if (!isKnownPredicate(CmpInst::ICMP_SLE,
-                          CurConstraint.getY(),
+    if (!isKnownPredicate(Predicate::ICMP_SLE, CurConstraint.getY(),
                           CurConstraint.getX()))
       // if Y may be > X
       NewDirection |= Dependence::DVEntry::LT;
-    if (!isKnownPredicate(CmpInst::ICMP_SGE,
-                          CurConstraint.getY(),
+    if (!isKnownPredicate(Predicate::ICMP_SGE, CurConstraint.getY(),
                           CurConstraint.getX()))
       // if Y may be < X
       NewDirection |= Dependence::DVEntry::GT;
     Level.Direction &= NewDirection;
   }
   else
     llvm_unreachable("constraint has unexpected kind");
 }

lib/Analysis/InlineCost.cpp

if (RHSBase && LHSBase == RHSBase) {
       }
     }
   }
 
   // If the comparison is an equality comparison with null, we can simplify it
   // if we know the value (argument) can't be null
   if (I.isEquality() && isa<ConstantPointerNull>(I.getOperand(1)) &&
       isKnownNonNullInCallee(I.getOperand(0))) {
-    bool IsNotEqual = I.getPredicate() == CmpInst::ICMP_NE;
+    bool IsNotEqual = I.getPredicate() == Predicate::ICMP_NE;
     SimplifiedValues[&I] = IsNotEqual ? ConstantInt::getTrue(I.getType())
                                       : ConstantInt::getFalse(I.getType());
     return true;
   }
   // Finally check for SROA candidates in comparisons.
   Value *SROAArg;
   DenseMap<Value *, int>::iterator CostIt;
   if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt)) {

lib/Analysis/InstructionSimplify.cpp

 };
 } // end anonymous namespace
 
 static Value *SimplifyAndInst(Value *, Value *, const Query &, unsigned);
 static Value *SimplifyBinOp(unsigned, Value *, Value *, const Query &,
                             unsigned);
 static Value *SimplifyFPBinOp(unsigned, Value *, Value *, const FastMathFlags &,
                               const Query &, unsigned);
-static Value *SimplifyCmpInst(unsigned, Value *, Value *, const Query &,
+static Value *SimplifyCmpInst(Predicate, Value *, Value *, const Query &,
                               unsigned);
 static Value *SimplifyOrInst(Value *, Value *, const Query &, unsigned);
 static Value *SimplifyXorInst(Value *, Value *, const Query &, unsigned);
 static Value *SimplifyCastInst(unsigned, Value *, Type *,
                                const Query &, unsigned);
 
 /// For a boolean type, or a vector of boolean type, return false, or
 /// a vector with every element false, as appropriate for the type.
 static Constant *getFalse(Type *Ty) {
   assert(Ty->getScalarType()->isIntegerTy(1) &&
          "Expected i1 type or a vector of i1!");
   return Constant::getNullValue(Ty);
 }
 
 /// For a boolean type, or a vector of boolean type, return true, or
 /// a vector with every element true, as appropriate for the type.
 static Constant *getTrue(Type *Ty) {
   assert(Ty->getScalarType()->isIntegerTy(1) &&
          "Expected i1 type or a vector of i1!");
   return Constant::getAllOnesValue(Ty);
 }
 
 /// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"?
-static bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS,
-                          Value *RHS) {
+static bool isSameCompare(Value *V, Predicate Pred, Value *LHS, Value *RHS) {
   CmpInst *Cmp = dyn_cast<CmpInst>(V);
   if (!Cmp)
     return false;
-  CmpInst::Predicate CPred = Cmp->getPredicate();
+  Predicate CPred = Cmp->getPredicate();
   Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1);
   if (CPred == Pred && CLHS == LHS && CRHS == RHS)
     return true;
-  return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS &&
-    CRHS == LHS;
+  return CPred == Pred.getSwapped() && CLHS == RHS && CRHS == LHS;
 }
 
 /// Does the given value dominate the specified phi node?
 static bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) {
   Instruction *I = dyn_cast<Instruction>(V);
   if (!I)
     // Arguments and constants dominate all instructions.
     return true;
static Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS,
   }
 
   return nullptr;
 }
 
 /// In the case of a comparison with a select instruction, try to simplify the
 /// comparison by seeing whether both branches of the select result in the same
 /// value. Returns the common value if so, otherwise returns null.
-static Value *ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS,
-                                  Value *RHS, const Query &Q,
-                                  unsigned MaxRecurse) {
+static Value *ThreadCmpOverSelect(Predicate Pred, Value *LHS, Value *RHS,
+                                  const Query &Q, unsigned MaxRecurse) {
   // Recursion is always used, so bail out at once if we already hit the limit.
   if (!MaxRecurse--)
     return nullptr;
 
   // Make sure the select is on the LHS.
   if (!isa<SelectInst>(LHS)) {
     std::swap(LHS, RHS);
-    Pred = CmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
   }
   assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!");
   SelectInst *SI = cast<SelectInst>(LHS);
   Value *Cond = SI->getCondition();
   Value *TV = SI->getTrueValue();
   Value *FV = SI->getFalseValue();
 
   // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it.
static Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS,
 
   return CommonValue;
 }
 
 /// In the case of a comparison with a PHI instruction, try to simplify the
 /// comparison by seeing whether comparing with all of the incoming phi values
 /// yields the same result every time. If so returns the common result,
 /// otherwise returns null.
-static Value *ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
+static Value *ThreadCmpOverPHI(Predicate Pred, Value *LHS, Value *RHS,
                                const Query &Q, unsigned MaxRecurse) {
   // Recursion is always used, so bail out at once if we already hit the limit.
   if (!MaxRecurse--)
     return nullptr;
 
   // Make sure the phi is on the LHS.
   if (!isa<PHINode>(LHS)) {
     std::swap(LHS, RHS);
-    Pred = CmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
   }
   assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!");
   PHINode *PI = cast<PHINode>(LHS);
 
   // Bail out if RHS and the phi may be mutually interdependent due to a loop.
   if (!ValueDominatesPHI(RHS, PI, Q.DT))
     return nullptr;
 
Value *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
   return ::SimplifyAShrInst(Op0, Op1, isExact, Query(DL, TLI, DT, AC, CxtI),
                             RecursionLimit);
 }
 
 static Value *simplifyUnsignedRangeCheck(ICmpInst *ZeroICmp,
                                          ICmpInst *UnsignedICmp, bool IsAnd) {
   Value *X, *Y;
 
-  ICmpInst::Predicate EqPred;
+  Predicate EqPred;
   if (!match(ZeroICmp, m_ICmp(EqPred, m_Value(Y), m_Zero())) ||
-      !ICmpInst::isEquality(EqPred))
+      !EqPred.isEquality())
     return nullptr;
 
-  ICmpInst::Predicate UnsignedPred;
+  Predicate UnsignedPred;
   if (match(UnsignedICmp, m_ICmp(UnsignedPred, m_Value(X), m_Specific(Y))) &&
-      ICmpInst::isUnsigned(UnsignedPred))
+      UnsignedPred.isUnsigned())
     ;
   else if (match(UnsignedICmp,
                  m_ICmp(UnsignedPred, m_Value(Y), m_Specific(X))) &&
-           ICmpInst::isUnsigned(UnsignedPred))
-    UnsignedPred = ICmpInst::getSwappedPredicate(UnsignedPred);
+           UnsignedPred.isUnsigned())
+    UnsignedPred = UnsignedPred.getSwapped();
   else
     return nullptr;
 
   // X < Y && Y != 0  -->  X < Y
   // X < Y || Y != 0  -->  Y != 0
-  if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_NE)
+  if (UnsignedPred == Predicate::ICMP_ULT && EqPred == Predicate::ICMP_NE)
     return IsAnd ? UnsignedICmp : ZeroICmp;
 
   // X >= Y || Y != 0  -->  true
   // X >= Y || Y == 0  -->  X >= Y
-  if (UnsignedPred == ICmpInst::ICMP_UGE && !IsAnd) {
-    if (EqPred == ICmpInst::ICMP_NE)
+  if (UnsignedPred == Predicate::ICMP_UGE && !IsAnd) {
+    if (EqPred == Predicate::ICMP_NE)
       return getTrue(UnsignedICmp->getType());
     return UnsignedICmp;
   }
 
   // X < Y && Y == 0  -->  false
-  if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_EQ &&
+  if (UnsignedPred == Predicate::ICMP_ULT && EqPred == Predicate::ICMP_EQ &&
       IsAnd)
     return getFalse(UnsignedICmp->getType());
 
   return nullptr;
 }
 
 static Value *SimplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1) {
   Type *ITy = Op0->getType();
-  ICmpInst::Predicate Pred0, Pred1;
+  Predicate Pred0, Pred1;
   ConstantInt *CI1, *CI2;
   Value *V;
 
   if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/true))
     return X;
 
   // Look for this pattern: (icmp V, C0) & (icmp V, C1)).
   const APInt *C0, *C1;
static Value *SimplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1) {
   bool isNSW = AddInst->hasNoSignedWrap();
   bool isNUW = AddInst->hasNoUnsignedWrap();
 
   const APInt &CI1V = CI1->getValue();
   const APInt &CI2V = CI2->getValue();
   const APInt Delta = CI2V - CI1V;
   if (CI1V.isStrictlyPositive()) {
     if (Delta == 2) {
-      if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_SGT)
+      if (Pred0 == Predicate::ICMP_ULT && Pred1 == Predicate::ICMP_SGT)
         return getFalse(ITy);
-      if (Pred0 == ICmpInst::ICMP_SLT && Pred1 == ICmpInst::ICMP_SGT && isNSW)
+      if (Pred0 == Predicate::ICMP_SLT && Pred1 == Predicate::ICMP_SGT && isNSW)
         return getFalse(ITy);
     }
     if (Delta == 1) {
-      if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_SGT)
+      if (Pred0 == Predicate::ICMP_ULE && Pred1 == Predicate::ICMP_SGT)
         return getFalse(ITy);
-      if (Pred0 == ICmpInst::ICMP_SLE && Pred1 == ICmpInst::ICMP_SGT && isNSW)
+      if (Pred0 == Predicate::ICMP_SLE && Pred1 == Predicate::ICMP_SGT && isNSW)
         return getFalse(ITy);
     }
   }
   if (CI1V.getBoolValue() && isNUW) {
     if (Delta == 2)
-      if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_UGT)
+      if (Pred0 == Predicate::ICMP_ULT && Pred1 == Predicate::ICMP_UGT)
         return getFalse(ITy);
     if (Delta == 1)
-      if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_UGT)
+      if (Pred0 == Predicate::ICMP_ULE && Pred1 == Predicate::ICMP_UGT)
         return getFalse(ITy);
   }
 
   return nullptr;
 }
 
 /// Given operands for an And, see if we can fold the result.
 /// If not, this returns null.
Value *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const DataLayout &DL,
                              const Instruction *CxtI) {
   return ::SimplifyAndInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
                            RecursionLimit);
 }
 
 /// Simplify (or (icmp ...) (icmp ...)) to true when we can tell that the union
 /// contains all possible values.
 static Value *SimplifyOrOfICmps(ICmpInst *Op0, ICmpInst *Op1) {
-  ICmpInst::Predicate Pred0, Pred1;
+  Predicate Pred0, Pred1;
   ConstantInt *CI1, *CI2;
   Value *V;
 
   if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/false))
     return X;
 
   if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_ConstantInt(CI1)),
                          m_ConstantInt(CI2))))
    return nullptr;
 
   if (!match(Op1, m_ICmp(Pred1, m_Specific(V), m_Specific(CI1))))
     return nullptr;
 
   Type *ITy = Op0->getType();
 
   auto *AddInst = cast<BinaryOperator>(Op0->getOperand(0));
   bool isNSW = AddInst->hasNoSignedWrap();
   bool isNUW = AddInst->hasNoUnsignedWrap();
 
   const APInt &CI1V = CI1->getValue();
   const APInt &CI2V = CI2->getValue();
   const APInt Delta = CI2V - CI1V;
   if (CI1V.isStrictlyPositive()) {
     if (Delta == 2) {
-      if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_SLE)
+      if (Pred0 == Predicate::ICMP_UGE && Pred1 == Predicate::ICMP_SLE)
         return getTrue(ITy);
-      if (Pred0 == ICmpInst::ICMP_SGE && Pred1 == ICmpInst::ICMP_SLE && isNSW)
+      if (Pred0 == Predicate::ICMP_SGE && Pred1 == Predicate::ICMP_SLE && isNSW)
         return getTrue(ITy);
     }
     if (Delta == 1) {
-      if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_SLE)
+      if (Pred0 == Predicate::ICMP_UGT && Pred1 == Predicate::ICMP_SLE)
         return getTrue(ITy);
-      if (Pred0 == ICmpInst::ICMP_SGT && Pred1 == ICmpInst::ICMP_SLE && isNSW)
+      if (Pred0 == Predicate::ICMP_SGT && Pred1 == Predicate::ICMP_SLE && isNSW)
         return getTrue(ITy);
     }
   }
   if (CI1V.getBoolValue() && isNUW) {
     if (Delta == 2)
-      if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_ULE)
+      if (Pred0 == Predicate::ICMP_UGE && Pred1 == Predicate::ICMP_ULE)
         return getTrue(ITy);
     if (Delta == 1)
-      if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_ULE)
+      if (Pred0 == Predicate::ICMP_UGT && Pred1 == Predicate::ICMP_ULE)
         return getTrue(ITy);
   }
 
   return nullptr;
 }
 
 /// Given operands for an Or, see if we can fold the result.
 /// If not, this returns null.

 
 static Type *GetCompareTy(Value *Op) {
   return CmpInst::makeCmpResultType(Op->getType());
 }
 
 /// Rummage around inside V looking for something equivalent to the comparison
 /// "LHS Pred RHS". Return such a value if found, otherwise return null.
 /// Helper function for analyzing max/min idioms.
-static Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred,
-                                         Value *LHS, Value *RHS) {
+static Value *ExtractEquivalentCondition(Value *V, Predicate Pred, Value *LHS,
+                                         Value *RHS) {
   SelectInst *SI = dyn_cast<SelectInst>(V);
   if (!SI)
     return nullptr;
   CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition());
   if (!Cmp)
     return nullptr;
   Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1);
   if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS)
     return Cmp;
-  if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) &&
-      LHS == CmpRHS && RHS == CmpLHS)
+  if (Pred == Cmp->getPredicate().getSwapped() && LHS == CmpRHS &&
+      RHS == CmpLHS)
     return Cmp;
   return nullptr;
 }
 
 // A significant optimization not implemented here is assuming that alloca
 // addresses are not equal to incoming argument values. They don't *alias*,
 // as we say, but that doesn't mean they aren't equal, so we take a
 // conservative approach.

 //
 // C11's version is more restrictive, however there's no reason why an argument
 // couldn't be a one-past-the-end value for a stack object in the caller and be
 // equal to the beginning of a stack object in the callee.
 //
 // If the C and C++ standards are ever made sufficiently restrictive in this
 // area, it may be possible to update LLVM's semantics accordingly and reinstate
 // this optimization.
-static Constant *
-computePointerICmp(const DataLayout &DL, const TargetLibraryInfo *TLI,
-                   const DominatorTree *DT, CmpInst::Predicate Pred,
-                   const Instruction *CxtI, Value *LHS, Value *RHS) {
+static Constant *computePointerICmp(const DataLayout &DL,
+                                    const TargetLibraryInfo *TLI,
+                                    const DominatorTree *DT, Predicate Pred,
+                                    const Instruction *CxtI, Value *LHS,
+                                    Value *RHS) {
   // First, skip past any trivial no-ops.
   LHS = LHS->stripPointerCasts();
   RHS = RHS->stripPointerCasts();
 
   // A non-null pointer is not equal to a null pointer.
   if (llvm::isKnownNonNull(LHS) && isa<ConstantPointerNull>(RHS) &&
-      (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE))
-    return ConstantInt::get(GetCompareTy(LHS),
-                            !CmpInst::isTrueWhenEqual(Pred));
+      (Pred == Predicate::ICMP_EQ || Pred == Predicate::ICMP_NE))
+    return ConstantInt::get(GetCompareTy(LHS), !Pred.isTrueWhenEqual());
 
   // We can only fold certain predicates on pointer comparisons.
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default:
     return nullptr;
 
     // Equality comaprisons are easy to fold.
-  case CmpInst::ICMP_EQ:
-  case CmpInst::ICMP_NE:
+  case Predicate::ICMP_EQ:
+  case Predicate::ICMP_NE:
     break;
 
     // We can only handle unsigned relational comparisons because 'inbounds' on
     // a GEP only protects against unsigned wrapping.
-  case CmpInst::ICMP_UGT:
-  case CmpInst::ICMP_UGE:
-  case CmpInst::ICMP_ULT:
-  case CmpInst::ICMP_ULE:
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_UGE:
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_ULE:
     // However, we have to switch them to their signed variants to handle
     // negative indices from the base pointer.
-    Pred = ICmpInst::getSignedPredicate(Pred);
+    Pred = Pred.getSigned();
     break;
   }
 
   // Strip off any constant offsets so that we can reason about them.
   // It's tempting to use getUnderlyingObject or even just stripInBoundsOffsets
   // here and compare base addresses like AliasAnalysis does, however there are
   // numerous hazards. AliasAnalysis and its utilities rely on special rules
   // governing loads and stores which don't apply to icmps. Also, AliasAnalysis
   // doesn't need to guarantee pointer inequality when it says NoAlias.
   Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS);
   Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS);
 
   // If LHS and RHS are related via constant offsets to the same base
   // value, we can replace it with an icmp which just compares the offsets.
   if (LHS == RHS)
     return ConstantExpr::getICmp(Pred, LHSOffset, RHSOffset);
 
   // Various optimizations for (in)equality comparisons.
-  if (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE) {
+  if (Pred == Predicate::ICMP_EQ || Pred == Predicate::ICMP_NE) {
     // Different non-empty allocations that exist at the same time have
     // different addresses (if the program can tell). Global variables always
     // exist, so they always exist during the lifetime of each other and all
     // allocas. Two different allocas usually have different addresses...
     //
     // However, if there's an @llvm.stackrestore dynamically in between two
     // allocas, they may have the same address. It's tempting to reduce the
     // scope of the problem by only looking at *static* allocas here. That would
if (isa<AllocaInst>(LHS) &&
           getObjectSize(LHS, LHSSize, DL, TLI) &&
           getObjectSize(RHS, RHSSize, DL, TLI)) {
         const APInt &LHSOffsetValue = LHSOffsetCI->getValue();
         const APInt &RHSOffsetValue = RHSOffsetCI->getValue();
         if (!LHSOffsetValue.isNegative() &&
             !RHSOffsetValue.isNegative() &&
             LHSOffsetValue.ult(LHSSize) &&
             RHSOffsetValue.ult(RHSSize)) {
-          return ConstantInt::get(GetCompareTy(LHS),
-                                  !CmpInst::isTrueWhenEqual(Pred));
+          return ConstantInt::get(GetCompareTy(LHS), !Pred.isTrueWhenEqual());
         }
       }
 
       // Repeat the above check but this time without depending on DataLayout
       // or being able to compute a precise size.
       if (!cast<PointerType>(LHS->getType())->isEmptyTy() &&
           !cast<PointerType>(RHS->getType())->isEmptyTy() &&
           LHSOffset->isNullValue() &&
           RHSOffset->isNullValue())
-        return ConstantInt::get(GetCompareTy(LHS),
-                                !CmpInst::isTrueWhenEqual(Pred));
+        return ConstantInt::get(GetCompareTy(LHS), !Pred.isTrueWhenEqual());
     }
 
     // Even if an non-inbounds GEP occurs along the path we can still optimize
     // equality comparisons concerning the result. We avoid walking the whole
     // chain again by starting where the last calls to
     // stripAndComputeConstantOffsets left off and accumulate the offsets.
     Constant *LHSNoBound = stripAndComputeConstantOffsets(DL, LHS, true);
     Constant *RHSNoBound = stripAndComputeConstantOffsets(DL, RHS, true);
auto IsAllocDisjoint = [](SmallVectorImpl<Value *> &Objects) {
         if (const Argument *A = dyn_cast<Argument>(V))
           return A->hasByValAttr();
         return false;
       });
     };
 
     if ((IsNAC(LHSUObjs) && IsAllocDisjoint(RHSUObjs)) ||
         (IsNAC(RHSUObjs) && IsAllocDisjoint(LHSUObjs)))
-        return ConstantInt::get(GetCompareTy(LHS),
-                                !CmpInst::isTrueWhenEqual(Pred));
+      return ConstantInt::get(GetCompareTy(LHS), !Pred.isTrueWhenEqual());
 
     // Fold comparisons for non-escaping pointer even if the allocation call
     // cannot be elided. We cannot fold malloc comparison to null. Also, the
     // dynamic allocation call could be either of the operands.
     Value *MI = nullptr;
     if (isAllocLikeFn(LHS, TLI) && llvm::isKnownNonNullAt(RHS, CxtI, DT))
       MI = LHS;
     else if (isAllocLikeFn(RHS, TLI) && llvm::isKnownNonNullAt(LHS, CxtI, DT))
       MI = RHS;
     // FIXME: We should also fold the compare when the pointer escapes, but the
     // compare dominates the pointer escape
     if (MI && !PointerMayBeCaptured(MI, true, true))
-      return ConstantInt::get(GetCompareTy(LHS),
-                              CmpInst::isFalseWhenEqual(Pred));
+      return ConstantInt::get(GetCompareTy(LHS), Pred.isFalseWhenEqual());
   }
 
   // Otherwise, fail.
   return nullptr;
 }
 
 /// Given operands for an ICmpInst, see if we can fold the result.
 /// If not, this returns null.
-static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+static Value *SimplifyICmpInst(Predicate Pred, Value *LHS, Value *RHS,
                                const Query &Q, unsigned MaxRecurse) {
-  CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate;
-  assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!");
+  assert(Pred.isInt() && "Not an integer compare!");
 
   if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
     if (Constant *CRHS = dyn_cast<Constant>(RHS))
       return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI);
 
     // If we have a constant, make sure it is on the RHS.
     std::swap(LHS, RHS);
-    Pred = CmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
   }
 
   Type *ITy = GetCompareTy(LHS); // The return type.
   Type *OpTy = LHS->getType();   // The operand type.
 
   // icmp X, X -> true/false
   // X icmp undef -> true/false.  For example, icmp ugt %X, undef -> false
   // because X could be 0.
   if (LHS == RHS || isa<UndefValue>(RHS))
-    return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred));
+    return ConstantInt::get(ITy, Pred.isTrueWhenEqual());
 
   // Special case logic when the operands have i1 type.
   if (OpTy->getScalarType()->isIntegerTy(1)) {
-    switch (Pred) {
+    switch (Pred.getKind()) {
     default: break;
-    case ICmpInst::ICMP_EQ:
+    case Predicate::ICMP_EQ:
       // X == 1 -> X
       if (match(RHS, m_One()))
         return LHS;
       break;
-    case ICmpInst::ICMP_NE:
+    case Predicate::ICMP_NE:
       // X != 0 -> X
       if (match(RHS, m_Zero()))
         return LHS;
       break;
-    case ICmpInst::ICMP_UGT:
+    case Predicate::ICMP_UGT:
       // X >u 0 -> X
       if (match(RHS, m_Zero()))
         return LHS;
       break;
-    case ICmpInst::ICMP_UGE: {
+    case Predicate::ICMP_UGE: {
       // X >=u 1 -> X
       if (match(RHS, m_One()))
         return LHS;
       if (isImpliedCondition(RHS, LHS, Q.DL).getValueOr(false))
         return getTrue(ITy);
       break;
     }
-    case ICmpInst::ICMP_SGE: {
+    case Predicate::ICMP_SGE: {
       /// For signed comparison, the values for an i1 are 0 and -1
       /// respectively. This maps into a truth table of:
       /// LHS | RHS | LHS >=s RHS   | LHS implies RHS
       ///  0  |  0  |  1 (0 >= 0)   |  1
       ///  0  |  1  |  1 (0 >= -1)  |  1
       ///  1  |  0  |  0 (-1 >= 0)  |  0
       ///  1  |  1  |  1 (-1 >= -1) |  1
       if (isImpliedCondition(LHS, RHS, Q.DL).getValueOr(false))
         return getTrue(ITy);
       break;
     }
-    case ICmpInst::ICMP_SLT:
+    case Predicate::ICMP_SLT:
       // X <s 0 -> X
       if (match(RHS, m_Zero()))
         return LHS;
       break;
-    case ICmpInst::ICMP_SLE:
+    case Predicate::ICMP_SLE:
       // X <=s -1 -> X
       if (match(RHS, m_One()))
         return LHS;
       break;
-    case ICmpInst::ICMP_ULE: {
+    case Predicate::ICMP_ULE: {
       if (isImpliedCondition(LHS, RHS, Q.DL).getValueOr(false))
         return getTrue(ITy);
       break;
     }
     }
   }
 
   // If we are comparing with zero then try hard since this is a common case.
   if (match(RHS, m_Zero())) {
     bool LHSKnownNonNegative, LHSKnownNegative;
-    switch (Pred) {
+    switch (Pred.getKind()) {
     default: llvm_unreachable("Unknown ICmp predicate!");
-    case ICmpInst::ICMP_ULT:
+    case Predicate::ICMP_ULT:
       return getFalse(ITy);
-    case ICmpInst::ICMP_UGE:
+    case Predicate::ICMP_UGE:
       return getTrue(ITy);
-    case ICmpInst::ICMP_EQ:
-    case ICmpInst::ICMP_ULE:
+    case Predicate::ICMP_EQ:
+    case Predicate::ICMP_ULE:
       if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
         return getFalse(ITy);
       break;
-    case ICmpInst::ICMP_NE:
-    case ICmpInst::ICMP_UGT:
+    case Predicate::ICMP_NE:
+    case Predicate::ICMP_UGT:
       if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
         return getTrue(ITy);
       break;
-    case ICmpInst::ICMP_SLT:
+    case Predicate::ICMP_SLT:
       ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
                      Q.CxtI, Q.DT);
       if (LHSKnownNegative)
         return getTrue(ITy);
       if (LHSKnownNonNegative)
         return getFalse(ITy);
       break;
-    case ICmpInst::ICMP_SLE:
+    case Predicate::ICMP_SLE:
       ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
                      Q.CxtI, Q.DT);
       if (LHSKnownNegative)
         return getTrue(ITy);
       if (LHSKnownNonNegative &&
           isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
         return getFalse(ITy);
       break;
-    case ICmpInst::ICMP_SGE:
+    case Predicate::ICMP_SGE:
       ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
                      Q.CxtI, Q.DT);
       if (LHSKnownNegative)
         return getFalse(ITy);
       if (LHSKnownNonNegative)
         return getTrue(ITy);
       break;
-    case ICmpInst::ICMP_SGT:
+    case Predicate::ICMP_SGT:
       ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
                      Q.CxtI, Q.DT);
       if (LHSKnownNegative)
         return getFalse(ITy);
       if (LHSKnownNonNegative &&
           isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
         return getTrue(ITy);
       break;
if (RHS_Instr->getMetadata(LLVMContext::MD_range) &&
           *RHS_Instr->getMetadata(LLVMContext::MD_range));
       auto LHS_CR = getConstantRangeFromMetadata(
           *LHS_Instr->getMetadata(LLVMContext::MD_range));
 
       auto Satisfied_CR = ConstantRange::makeSatisfyingICmpRegion(Pred, RHS_CR);
       if (Satisfied_CR.contains(LHS_CR))
         return ConstantInt::getTrue(RHS->getContext());
 
-      auto InversedSatisfied_CR = ConstantRange::makeSatisfyingICmpRegion(
-                CmpInst::getInversePredicate(Pred), RHS_CR);
+      auto InversedSatisfied_CR =
+          ConstantRange::makeSatisfyingICmpRegion(Pred.getInverse(), RHS_CR);
       if (InversedSatisfied_CR.contains(LHS_CR))
         return ConstantInt::getFalse(RHS->getContext());
     }
   }
 
   // Compare of cast, for example (zext X) != 0 -> X != 0
   if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) {
     Instruction *LI = cast<CastInst>(LHS);
if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) {
     }
 
     if (isa<ZExtInst>(LHS)) {
       // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the
       // same type.
       if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) {
         if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
           // Compare X and Y.  Note that signed predicates become unsigned.
-          if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred),
-                                          SrcOp, RI->getOperand(0), Q,
-                                          MaxRecurse-1))
+          if (Value *V = SimplifyICmpInst(Pred.getUnsigned(), SrcOp,
+                                          RI->getOperand(0), Q, MaxRecurse - 1))
             return V;
       }
       // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended
       // too.  If not, then try to deduce the result of the comparison.
       else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
         // Compute the constant that would happen if we truncated to SrcTy then
         // reextended to DstTy.
         Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy);
         Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy);
 
         // If the re-extended constant didn't change then this is effectively
         // also a case of comparing two zero-extended values.
         if (RExt == CI && MaxRecurse)
-          if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred),
-                                        SrcOp, Trunc, Q, MaxRecurse-1))
+          if (Value *V = SimplifyICmpInst(Pred.getUnsigned(), SrcOp, Trunc, Q,
+                                          MaxRecurse - 1))
             return V;
 
         // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit
         // there.  Use this to work out the result of the comparison.
         if (RExt != CI) {
-          switch (Pred) {
+          switch (Pred.getKind()) {
           default: llvm_unreachable("Unknown ICmp predicate!");
           // LHS <u RHS.
-          case ICmpInst::ICMP_EQ:
-          case ICmpInst::ICMP_UGT:
-          case ICmpInst::ICMP_UGE:
+          case Predicate::ICMP_EQ:
+          case Predicate::ICMP_UGT:
+          case Predicate::ICMP_UGE:
             return ConstantInt::getFalse(CI->getContext());
 
-          case ICmpInst::ICMP_NE:
-          case ICmpInst::ICMP_ULT:
-          case ICmpInst::ICMP_ULE:
+          case Predicate::ICMP_NE:
+          case Predicate::ICMP_ULT:
+          case Predicate::ICMP_ULE:
             return ConstantInt::getTrue(CI->getContext());
 
           // LHS is non-negative.  If RHS is negative then LHS >s LHS.  If RHS
           // is non-negative then LHS <s RHS.
-          case ICmpInst::ICMP_SGT:
-          case ICmpInst::ICMP_SGE:
+          case Predicate::ICMP_SGT:
+          case Predicate::ICMP_SGE:
             return CI->getValue().isNegative() ?
               ConstantInt::getTrue(CI->getContext()) :
               ConstantInt::getFalse(CI->getContext());
 
-          case ICmpInst::ICMP_SLT:
-          case ICmpInst::ICMP_SLE:
+          case Predicate::ICMP_SLT:
+          case Predicate::ICMP_SLE:
             return CI->getValue().isNegative() ?
               ConstantInt::getFalse(CI->getContext()) :
               ConstantInt::getTrue(CI->getContext());
           }
         }
       }
     }
 
if (isa<SExtInst>(LHS)) {
         // also a case of comparing two sign-extended values.
         if (RExt == CI && MaxRecurse)
           if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, Q, MaxRecurse-1))
             return V;
 
         // Otherwise the upper bits of LHS are all equal, while RHS has varying
         // bits there.  Use this to work out the result of the comparison.
         if (RExt != CI) {
-          switch (Pred) {
+          switch (Pred.getKind()) {
           default: llvm_unreachable("Unknown ICmp predicate!");
-          case ICmpInst::ICMP_EQ:
+          case Predicate::ICMP_EQ:
             return ConstantInt::getFalse(CI->getContext());
-          case ICmpInst::ICMP_NE:
+          case Predicate::ICMP_NE:
             return ConstantInt::getTrue(CI->getContext());
 
           // If RHS is non-negative then LHS <s RHS.  If RHS is negative then
           // LHS >s RHS.
-          case ICmpInst::ICMP_SGT:
-          case ICmpInst::ICMP_SGE:
+          case Predicate::ICMP_SGT:
+          case Predicate::ICMP_SGE:
             return CI->getValue().isNegative() ?
               ConstantInt::getTrue(CI->getContext()) :
               ConstantInt::getFalse(CI->getContext());
-          case ICmpInst::ICMP_SLT:
-          case ICmpInst::ICMP_SLE:
+          case Predicate::ICMP_SLT:
+          case Predicate::ICMP_SLE:
             return CI->getValue().isNegative() ?
               ConstantInt::getFalse(CI->getContext()) :
               ConstantInt::getTrue(CI->getContext());
 
           // If LHS is non-negative then LHS <u RHS.  If LHS is negative then
           // LHS >u RHS.
-          case ICmpInst::ICMP_UGT:
-          case ICmpInst::ICMP_UGE:
+          case Predicate::ICMP_UGT:
+          case Predicate::ICMP_UGE:
             // Comparison is true iff the LHS <s 0.
             if (MaxRecurse)
-              if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp,
-                                              Constant::getNullValue(SrcTy),
-                                              Q, MaxRecurse-1))
+              if (Value *V = SimplifyICmpInst(Predicate::ICMP_SLT, SrcOp,
+                                              Constant::getNullValue(SrcTy), Q,
+                                              MaxRecurse - 1))
                 return V;
             break;
-          case ICmpInst::ICMP_ULT:
-          case ICmpInst::ICMP_ULE:
+          case Predicate::ICMP_ULT:
+          case Predicate::ICMP_ULE:
             // Comparison is true iff the LHS >=s 0.
             if (MaxRecurse)
-              if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp,
-                                              Constant::getNullValue(SrcTy),
-                                              Q, MaxRecurse-1))
+              if (Value *V = SimplifyICmpInst(Predicate::ICMP_SGE, SrcOp,
+                                              Constant::getNullValue(SrcTy), Q,
+                                              MaxRecurse - 1))
                 return V;
             break;
           }
         }
       }
     }
   }
 
   // icmp eq|ne X, Y -> false|true if X != Y
-  if ((Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE) &&
+  if ((Pred == Predicate::ICMP_EQ || Pred == Predicate::ICMP_NE) &&
       isKnownNonEqual(LHS, RHS, Q.DL, Q.AC, Q.CxtI, Q.DT)) {
     LLVMContext &Ctx = LHS->getType()->getContext();
-    return Pred == ICmpInst::ICMP_NE ?
-      ConstantInt::getTrue(Ctx) : ConstantInt::getFalse(Ctx);
+    return Pred == Predicate::ICMP_NE ? ConstantInt::getTrue(Ctx)
+                                      : ConstantInt::getFalse(Ctx);
   }
 
   // Special logic for binary operators.
   BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS);
   BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS);
   if (MaxRecurse && (LBO || RBO)) {
     // Analyze the case when either LHS or RHS is an add instruction.
     Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr;
     // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null).
     bool NoLHSWrapProblem = false, NoRHSWrapProblem = false;
     if (LBO && LBO->getOpcode() == Instruction::Add) {
       A = LBO->getOperand(0); B = LBO->getOperand(1);
-      NoLHSWrapProblem = ICmpInst::isEquality(Pred) ||
-        (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) ||
-        (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap());
+      NoLHSWrapProblem = Pred.isEquality() ||
+                         (Pred.isUnsigned() && LBO->hasNoUnsignedWrap()) ||
+                         (Pred.isSigned() && LBO->hasNoSignedWrap());
     }
     if (RBO && RBO->getOpcode() == Instruction::Add) {
       C = RBO->getOperand(0); D = RBO->getOperand(1);
-      NoRHSWrapProblem = ICmpInst::isEquality(Pred) ||
-        (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) ||
-        (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap());
+      NoRHSWrapProblem = Pred.isEquality() ||
+                         (Pred.isUnsigned() && RBO->hasNoUnsignedWrap()) ||
+                         (Pred.isSigned() && RBO->hasNoSignedWrap());
     }
 
     // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow.
     if ((A == RHS || B == RHS) && NoLHSWrapProblem)
       if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A,
                                       Constant::getNullValue(RHS->getType()),
                                       Q, MaxRecurse-1))
         return V;
if (A && C && (A == C || A == D || B == C || B == D) &&
         return V;
     }
   }
 
   {
     Value *Y = nullptr;
     // icmp pred (or X, Y), X
     if (LBO && match(LBO, m_c_Or(m_Value(Y), m_Specific(RHS)))) {
-      if (Pred == ICmpInst::ICMP_ULT)
+      if (Pred == Predicate::ICMP_ULT)
         return getFalse(ITy);
-      if (Pred == ICmpInst::ICMP_UGE)
+      if (Pred == Predicate::ICMP_UGE)
         return getTrue(ITy);
 
-      if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SGE) {
+      if (Pred == Predicate::ICMP_SLT || Pred == Predicate::ICMP_SGE) {
         bool RHSKnownNonNegative, RHSKnownNegative;
         bool YKnownNonNegative, YKnownNegative;
         ComputeSignBit(RHS, RHSKnownNonNegative, RHSKnownNegative, Q.DL, 0,
                        Q.AC, Q.CxtI, Q.DT);
         ComputeSignBit(Y, YKnownNonNegative, YKnownNegative, Q.DL, 0, Q.AC,
                        Q.CxtI, Q.DT);
         if (RHSKnownNonNegative && YKnownNegative)
-          return Pred == ICmpInst::ICMP_SLT ? getTrue(ITy) : getFalse(ITy);
+          return Pred == Predicate::ICMP_SLT ? getTrue(ITy) : getFalse(ITy);
         if (RHSKnownNegative || YKnownNonNegative)
-          return Pred == ICmpInst::ICMP_SLT ? getFalse(ITy) : getTrue(ITy);
+          return Pred == Predicate::ICMP_SLT ? getFalse(ITy) : getTrue(ITy);
       }
     }
     // icmp pred X, (or X, Y)
     if (RBO && match(RBO, m_c_Or(m_Value(Y), m_Specific(LHS)))) {
-      if (Pred == ICmpInst::ICMP_ULE)
+      if (Pred == Predicate::ICMP_ULE)
         return getTrue(ITy);
-      if (Pred == ICmpInst::ICMP_UGT)
+      if (Pred == Predicate::ICMP_UGT)
         return getFalse(ITy);
 
-      if (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SLE) {
+      if (Pred == Predicate::ICMP_SGT || Pred == Predicate::ICMP_SLE) {
         bool LHSKnownNonNegative, LHSKnownNegative;
         bool YKnownNonNegative, YKnownNegative;
         ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0,
                        Q.AC, Q.CxtI, Q.DT);
         ComputeSignBit(Y, YKnownNonNegative, YKnownNegative, Q.DL, 0, Q.AC,
                        Q.CxtI, Q.DT);
         if (LHSKnownNonNegative && YKnownNegative)
-          return Pred == ICmpInst::ICMP_SGT ? getTrue(ITy) : getFalse(ITy);
+          return Pred == Predicate::ICMP_SGT ? getTrue(ITy) : getFalse(ITy);
         if (LHSKnownNegative || YKnownNonNegative)
-          return Pred == ICmpInst::ICMP_SGT ? getFalse(ITy) : getTrue(ITy);
+          return Pred == Predicate::ICMP_SGT ? getFalse(ITy) : getTrue(ITy);
       }
     }
   }
 
   // icmp pred (and X, Y), X
   if (LBO && match(LBO, m_CombineOr(m_And(m_Value(), m_Specific(RHS)),
                                     m_And(m_Specific(RHS), m_Value())))) {
-    if (Pred == ICmpInst::ICMP_UGT)
+    if (Pred == Predicate::ICMP_UGT)
       return getFalse(ITy);
-    if (Pred == ICmpInst::ICMP_ULE)
+    if (Pred == Predicate::ICMP_ULE)
       return getTrue(ITy);
   }
   // icmp pred X, (and X, Y)
   if (RBO && match(RBO, m_CombineOr(m_And(m_Value(), m_Specific(LHS)),
                                     m_And(m_Specific(LHS), m_Value())))) {
-    if (Pred == ICmpInst::ICMP_UGE)
+    if (Pred == Predicate::ICMP_UGE)
       return getTrue(ITy);
-    if (Pred == ICmpInst::ICMP_ULT)
+    if (Pred == Predicate::ICMP_ULT)
       return getFalse(ITy);
   }
 
   // 0 - (zext X) pred C
-  if (!CmpInst::isUnsigned(Pred) && match(LHS, m_Neg(m_ZExt(m_Value())))) {
+  if (!Pred.isUnsigned() && match(LHS, m_Neg(m_ZExt(m_Value())))) {
     if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) {
       if (RHSC->getValue().isStrictlyPositive()) {
-        if (Pred == ICmpInst::ICMP_SLT)
+        if (Pred == Predicate::ICMP_SLT)
           return ConstantInt::getTrue(RHSC->getContext());
-        if (Pred == ICmpInst::ICMP_SGE)
+        if (Pred == Predicate::ICMP_SGE)
           return ConstantInt::getFalse(RHSC->getContext());
-        if (Pred == ICmpInst::ICMP_EQ)
+        if (Pred == Predicate::ICMP_EQ)
           return ConstantInt::getFalse(RHSC->getContext());
-        if (Pred == ICmpInst::ICMP_NE)
+        if (Pred == Predicate::ICMP_NE)
           return ConstantInt::getTrue(RHSC->getContext());
       }
       if (RHSC->getValue().isNonNegative()) {
-        if (Pred == ICmpInst::ICMP_SLE)
+        if (Pred == Predicate::ICMP_SLE)
           return ConstantInt::getTrue(RHSC->getContext());
-        if (Pred == ICmpInst::ICMP_SGT)
+        if (Pred == Predicate::ICMP_SGT)
           return ConstantInt::getFalse(RHSC->getContext());
       }
     }
   }
 
   // icmp pred (urem X, Y), Y
   if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) {
     bool KnownNonNegative, KnownNegative;
-    switch (Pred) {
+    switch (Pred.getKind()) {
     default:
       break;
-    case ICmpInst::ICMP_SGT:
-    case ICmpInst::ICMP_SGE:
+    case Predicate::ICMP_SGT:
+    case Predicate::ICMP_SGE:
       ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
                      Q.CxtI, Q.DT);
       if (!KnownNonNegative)
         break;
       // fall-through
-    case ICmpInst::ICMP_EQ:
-    case ICmpInst::ICMP_UGT:
-    case ICmpInst::ICMP_UGE:
+    case Predicate::ICMP_EQ:
+    case Predicate::ICMP_UGT:
+    case Predicate::ICMP_UGE:
       return getFalse(ITy);
-    case ICmpInst::ICMP_SLT:
-    case ICmpInst::ICMP_SLE:
+    case Predicate::ICMP_SLT:
+    case Predicate::ICMP_SLE:
       ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
                      Q.CxtI, Q.DT);
       if (!KnownNonNegative)
         break;
       // fall-through
-    case ICmpInst::ICMP_NE:
-    case ICmpInst::ICMP_ULT:
-    case ICmpInst::ICMP_ULE:
+    case Predicate::ICMP_NE:
+    case Predicate::ICMP_ULT:
+    case Predicate::ICMP_ULE:
       return getTrue(ITy);
     }
   }
 
   // icmp pred X, (urem Y, X)
   if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) {
     bool KnownNonNegative, KnownNegative;
-    switch (Pred) {
+    switch (Pred.getKind()) {
     default:
       break;
-    case ICmpInst::ICMP_SGT:
-    case ICmpInst::ICMP_SGE:
+    case Predicate::ICMP_SGT:
+    case Predicate::ICMP_SGE:
       ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
                      Q.CxtI, Q.DT);
       if (!KnownNonNegative)
         break;
       // fall-through
-    case ICmpInst::ICMP_NE:
-    case ICmpInst::ICMP_UGT:
-    case ICmpInst::ICMP_UGE:
+    case Predicate::ICMP_NE:
+    case Predicate::ICMP_UGT:
+    case Predicate::ICMP_UGE:
       return getTrue(ITy);
-    case ICmpInst::ICMP_SLT:
-    case ICmpInst::ICMP_SLE:
+    case Predicate::ICMP_SLT:
+    case Predicate::ICMP_SLE:
       ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
                      Q.CxtI, Q.DT);
       if (!KnownNonNegative)
         break;
       // fall-through
-    case ICmpInst::ICMP_EQ:
-    case ICmpInst::ICMP_ULT:
-    case ICmpInst::ICMP_ULE:
+    case Predicate::ICMP_EQ:
+    case Predicate::ICMP_ULT:
+    case Predicate::ICMP_ULE:
       return getFalse(ITy);
     }
   }
 
   // x >> y <=u x
   // x udiv y <=u x.
   if (LBO && (match(LBO, m_LShr(m_Specific(RHS), m_Value())) ||
               match(LBO, m_UDiv(m_Specific(RHS), m_Value())))) {
     // icmp pred (X op Y), X
-    if (Pred == ICmpInst::ICMP_UGT)
+    if (Pred == Predicate::ICMP_UGT)
       return getFalse(ITy);
-    if (Pred == ICmpInst::ICMP_ULE)
+    if (Pred == Predicate::ICMP_ULE)
       return getTrue(ITy);
   }
 
   // handle:
   //   CI2 << X == CI
   //   CI2 << X != CI
   //
   //   where CI2 is a power of 2 and CI isn't
   if (auto *CI = dyn_cast<ConstantInt>(RHS)) {
     const APInt *CI2Val, *CIVal = &CI->getValue();
     if (LBO && match(LBO, m_Shl(m_APInt(CI2Val), m_Value())) &&
         CI2Val->isPowerOf2()) {
       if (!CIVal->isPowerOf2()) {
         // CI2 << X can equal zero in some circumstances,
         // this simplification is unsafe if CI is zero.
         //
         // We know it is safe if:
         // - The shift is nsw, we can't shift out the one bit.
         // - The shift is nuw, we can't shift out the one bit.
         // - CI2 is one
         // - CI isn't zero
         if (LBO->hasNoSignedWrap() || LBO->hasNoUnsignedWrap() ||
             *CI2Val == 1 || !CI->isZero()) {
-          if (Pred == ICmpInst::ICMP_EQ)
+          if (Pred == Predicate::ICMP_EQ)
             return ConstantInt::getFalse(RHS->getContext());
-          if (Pred == ICmpInst::ICMP_NE)
+          if (Pred == Predicate::ICMP_NE)
             return ConstantInt::getTrue(RHS->getContext());
         }
       }
       if (CIVal->isSignBit() && *CI2Val == 1) {
-        if (Pred == ICmpInst::ICMP_UGT)
+        if (Pred == Predicate::ICMP_UGT)
           return ConstantInt::getFalse(RHS->getContext());
-        if (Pred == ICmpInst::ICMP_ULE)
+        if (Pred == Predicate::ICMP_ULE)
           return ConstantInt::getTrue(RHS->getContext());
       }
     }
   }
 
   if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() &&
       LBO->getOperand(1) == RBO->getOperand(1)) {
     switch (LBO->getOpcode()) {
     default: break;
     case Instruction::UDiv:
     case Instruction::LShr:
-      if (ICmpInst::isSigned(Pred))
+      if (Pred.isSigned())
         break;
       // fall-through
     case Instruction::SDiv:
     case Instruction::AShr:
       if (!LBO->isExact() || !RBO->isExact())
         break;
       if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0),
                                       RBO->getOperand(0), Q, MaxRecurse-1))
         return V;
       break;
     case Instruction::Shl: {
       bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap();
       bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap();
       if (!NUW && !NSW)
         break;
-      if (!NSW && ICmpInst::isSigned(Pred))
+      if (!NSW && Pred.isSigned())
         break;
       if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0),
                                       RBO->getOperand(0), Q, MaxRecurse-1))
         return V;
       break;
     }
     }
   }
 
   // Simplify comparisons involving max/min.
   Value *A, *B;
-  CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE;
-  CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B".
+  Predicate P = Predicate::BAD_ICMP_PREDICATE;
+  Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B".
 
   // Signed variants on "max(a,b)>=a -> true".
   if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) {
     if (A != RHS) std::swap(A, B); // smax(A, B) pred A.
-    EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B".
+    EqP = Predicate::ICMP_SGE;     // "A == smax(A, B)" iff "A sge B".
     // We analyze this as smax(A, B) pred A.
     P = Pred;
   } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) &&
              (A == LHS || B == LHS)) {
     if (A != LHS) std::swap(A, B); // A pred smax(A, B).
-    EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B".
+    EqP = Predicate::ICMP_SGE;     // "A == smax(A, B)" iff "A sge B".
     // We analyze this as smax(A, B) swapped-pred A.
-    P = CmpInst::getSwappedPredicate(Pred);
+    P = Pred.getSwapped();
   } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) &&
              (A == RHS || B == RHS)) {
     if (A != RHS) std::swap(A, B); // smin(A, B) pred A.
-    EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B".
+    EqP = Predicate::ICMP_SLE;     // "A == smin(A, B)" iff "A sle B".
     // We analyze this as smax(-A, -B) swapped-pred -A.
     // Note that we do not need to actually form -A or -B thanks to EqP.
-    P = CmpInst::getSwappedPredicate(Pred);
+    P = Pred.getSwapped();
   } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) &&
              (A == LHS || B == LHS)) {
     if (A != LHS) std::swap(A, B); // A pred smin(A, B).
-    EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B".
+    EqP = Predicate::ICMP_SLE;     // "A == smin(A, B)" iff "A sle B".
     // We analyze this as smax(-A, -B) pred -A.
     // Note that we do not need to actually form -A or -B thanks to EqP.
     P = Pred;
   }
-  if (P != CmpInst::BAD_ICMP_PREDICATE) {
+  if (P != Predicate::BAD_ICMP_PREDICATE) {
     // Cases correspond to "max(A, B) p A".
-    switch (P) {
+    switch (P.getKind()) {
     default:
       break;
-    case CmpInst::ICMP_EQ:
-    case CmpInst::ICMP_SLE:
+    case Predicate::ICMP_EQ:
+    case Predicate::ICMP_SLE:
       // Equivalent to "A EqP B".  This may be the same as the condition tested
       // in the max/min; if so, we can just return that.
       if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B))
         return V;
       if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B))
         return V;
       // Otherwise, see if "A EqP B" simplifies.
       if (MaxRecurse)
         if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1))
           return V;
       break;
-    case CmpInst::ICMP_NE:
-    case CmpInst::ICMP_SGT: {
-      CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP);
+    case Predicate::ICMP_NE:
+    case Predicate::ICMP_SGT: {
+      Predicate InvEqP = EqP.getInverse();
       // Equivalent to "A InvEqP B".  This may be the same as the condition
       // tested in the max/min; if so, we can just return that.
       if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B))
         return V;
       if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B))
         return V;
       // Otherwise, see if "A InvEqP B" simplifies.
       if (MaxRecurse)
         if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1))
           return V;
       break;
     }
-    case CmpInst::ICMP_SGE:
+    case Predicate::ICMP_SGE:
       // Always true.
       return getTrue(ITy);
-    case CmpInst::ICMP_SLT:
+    case Predicate::ICMP_SLT:
       // Always false.
       return getFalse(ITy);
     }
   }
 
   // Unsigned variants on "max(a,b)>=a -> true".
-  P = CmpInst::BAD_ICMP_PREDICATE;
+  P = Predicate::BAD_ICMP_PREDICATE;
   if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) {
     if (A != RHS) std::swap(A, B); // umax(A, B) pred A.
-    EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B".
+    EqP = Predicate::ICMP_UGE;     // "A == umax(A, B)" iff "A uge B".
     // We analyze this as umax(A, B) pred A.
     P = Pred;
   } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) &&
              (A == LHS || B == LHS)) {
     if (A != LHS) std::swap(A, B); // A pred umax(A, B).
-    EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B".
+    EqP = Predicate::ICMP_UGE;     // "A == umax(A, B)" iff "A uge B".
     // We analyze this as umax(A, B) swapped-pred A.
-    P = CmpInst::getSwappedPredicate(Pred);
+    P = Pred.getSwapped();
   } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) &&
              (A == RHS || B == RHS)) {
     if (A != RHS) std::swap(A, B); // umin(A, B) pred A.
-    EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B".
+    EqP = Predicate::ICMP_ULE;     // "A == umin(A, B)" iff "A ule B".
     // We analyze this as umax(-A, -B) swapped-pred -A.
     // Note that we do not need to actually form -A or -B thanks to EqP.
-    P = CmpInst::getSwappedPredicate(Pred);
+    P = Pred.getSwapped();
   } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) &&
              (A == LHS || B == LHS)) {
     if (A != LHS) std::swap(A, B); // A pred umin(A, B).
-    EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B".
+    EqP = Predicate::ICMP_ULE;     // "A == umin(A, B)" iff "A ule B".
     // We analyze this as umax(-A, -B) pred -A.
     // Note that we do not need to actually form -A or -B thanks to EqP.
     P = Pred;
   }
-  if (P != CmpInst::BAD_ICMP_PREDICATE) {
+  if (P != Predicate::BAD_ICMP_PREDICATE) {
     // Cases correspond to "max(A, B) p A".
-    switch (P) {
+    switch (P.getKind()) {
     default:
       break;
-    case CmpInst::ICMP_EQ:
-    case CmpInst::ICMP_ULE:
+    case Predicate::ICMP_EQ:
+    case Predicate::ICMP_ULE:
       // Equivalent to "A EqP B".  This may be the same as the condition tested
       // in the max/min; if so, we can just return that.
       if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B))
         return V;
       if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B))
         return V;
       // Otherwise, see if "A EqP B" simplifies.
       if (MaxRecurse)
         if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1))
           return V;
       break;
-    case CmpInst::ICMP_NE:
-    case CmpInst::ICMP_UGT: {
-      CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP);
+    case Predicate::ICMP_NE:
+    case Predicate::ICMP_UGT: {
+      Predicate InvEqP = EqP.getInverse();
       // Equivalent to "A InvEqP B".  This may be the same as the condition
       // tested in the max/min; if so, we can just return that.
       if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B))
         return V;
       if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B))
         return V;
       // Otherwise, see if "A InvEqP B" simplifies.
       if (MaxRecurse)
         if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1))
           return V;
       break;
     }
-    case CmpInst::ICMP_UGE:
+    case Predicate::ICMP_UGE:
       // Always true.
       return getTrue(ITy);
-    case CmpInst::ICMP_ULT:
+    case Predicate::ICMP_ULT:
       // Always false.
       return getFalse(ITy);
     }
   }
 
   // Variants on "max(x,y) >= min(x,z)".
   Value *C, *D;
   if (match(LHS, m_SMax(m_Value(A), m_Value(B))) &&
       match(RHS, m_SMin(m_Value(C), m_Value(D))) &&
       (A == C || A == D || B == C || B == D)) {
     // max(x, ?) pred min(x, ?).
-    if (Pred == CmpInst::ICMP_SGE)
+    if (Pred == Predicate::ICMP_SGE)
       // Always true.
       return getTrue(ITy);
-    if (Pred == CmpInst::ICMP_SLT)
+    if (Pred == Predicate::ICMP_SLT)
       // Always false.
       return getFalse(ITy);
   } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) &&
              match(RHS, m_SMax(m_Value(C), m_Value(D))) &&
              (A == C || A == D || B == C || B == D)) {
     // min(x, ?) pred max(x, ?).
-    if (Pred == CmpInst::ICMP_SLE)
+    if (Pred == Predicate::ICMP_SLE)
       // Always true.
       return getTrue(ITy);
-    if (Pred == CmpInst::ICMP_SGT)
+    if (Pred == Predicate::ICMP_SGT)
       // Always false.
       return getFalse(ITy);
   } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) &&
              match(RHS, m_UMin(m_Value(C), m_Value(D))) &&
              (A == C || A == D || B == C || B == D)) {
     // max(x, ?) pred min(x, ?).
-    if (Pred == CmpInst::ICMP_UGE)
+    if (Pred == Predicate::ICMP_UGE)
       // Always true.
       return getTrue(ITy);
-    if (Pred == CmpInst::ICMP_ULT)
+    if (Pred == Predicate::ICMP_ULT)
       // Always false.
       return getFalse(ITy);
   } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) &&
              match(RHS, m_UMax(m_Value(C), m_Value(D))) &&
              (A == C || A == D || B == C || B == D)) {
     // min(x, ?) pred max(x, ?).
-    if (Pred == CmpInst::ICMP_ULE)
+    if (Pred == Predicate::ICMP_ULE)
       // Always true.
       return getTrue(ITy);
-    if (Pred == CmpInst::ICMP_UGT)
+    if (Pred == Predicate::ICMP_UGT)
       // Always false.
       return getFalse(ITy);
   }
 
   // Simplify comparisons of related pointers using a powerful, recursive
   // GEP-walk when we have target data available..
   if (LHS->getType()->isPointerTy())
     if (auto *C = computePointerICmp(Q.DL, Q.TLI, Q.DT, Pred, Q.CxtI, LHS, RHS))
       return C;
   if (auto *CLHS = dyn_cast<PtrToIntOperator>(LHS))
     if (auto *CRHS = dyn_cast<PtrToIntOperator>(RHS))
       if (Q.DL.getTypeSizeInBits(CLHS->getPointerOperandType()) ==
               Q.DL.getTypeSizeInBits(CLHS->getType()) &&
           Q.DL.getTypeSizeInBits(CRHS->getPointerOperandType()) ==
               Q.DL.getTypeSizeInBits(CRHS->getType()))
         if (auto *C = computePointerICmp(Q.DL, Q.TLI, Q.DT, Pred, Q.CxtI,
                                          CLHS->getPointerOperand(),
                                          CRHS->getPointerOperand()))
           return C;
 
   if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) {
     if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) {
       if (GLHS->getPointerOperand() == GRHS->getPointerOperand() &&
           GLHS->hasAllConstantIndices() && GRHS->hasAllConstantIndices() &&
-          (ICmpInst::isEquality(Pred) ||
-           (GLHS->isInBounds() && GRHS->isInBounds() &&
-            Pred == ICmpInst::getSignedPredicate(Pred)))) {
+          (Pred.isEquality() || (GLHS->isInBounds() && GRHS->isInBounds() &&
+                                 Pred == Pred.getSigned()))) {
         // The bases are equal and the indices are constant.  Build a constant
         // expression GEP with the same indices and a null base pointer to see
         // what constant folding can make out of it.
         Constant *Null = Constant::getNullValue(GLHS->getPointerOperandType());
         SmallVector<Value *, 4> IndicesLHS(GLHS->idx_begin(), GLHS->idx_end());
         Constant *NewLHS = ConstantExpr::getGetElementPtr(
             GLHS->getSourceElementType(), Null, IndicesLHS);
 
         SmallVector<Value *, 4> IndicesRHS(GRHS->idx_begin(), GRHS->idx_end());
         Constant *NewRHS = ConstantExpr::getGetElementPtr(
             GLHS->getSourceElementType(), Null, IndicesRHS);
         return ConstantExpr::getICmp(Pred, NewLHS, NewRHS);
       }
     }
   }
 
   // If a bit is known to be zero for A and known to be one for B,
   // then A and B cannot be equal.
-  if (ICmpInst::isEquality(Pred)) {
+  if (Pred.isEquality()) {
     const APInt *RHSVal;
     if (match(RHS, m_APInt(RHSVal))) {
       unsigned BitWidth = RHSVal->getBitWidth();
       APInt LHSKnownZero(BitWidth, 0);
       APInt LHSKnownOne(BitWidth, 0);
       computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, Q.DL, /*Depth=*/0, Q.AC,
                        Q.CxtI, Q.DT);
       if (((LHSKnownZero & *RHSVal) != 0) || ((LHSKnownOne & ~(*RHSVal)) != 0))
-        return Pred == ICmpInst::ICMP_EQ ? ConstantInt::getFalse(ITy)
+        return Pred == Predicate::ICMP_EQ ? ConstantInt::getFalse(ITy)
                                           : ConstantInt::getTrue(ITy);
     }
   }
 
   // If the comparison is with the result of a select instruction, check whether
   // comparing with either branch of the select always yields the same value.
   if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
     if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse))
       return V;
 
   // If the comparison is with the result of a phi instruction, check whether
   // doing the compare with each incoming phi value yields a common result.
   if (isa<PHINode>(LHS) || isa<PHINode>(RHS))
     if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse))
       return V;
 
   return nullptr;
 }
 
-Value *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+Value *llvm::SimplifyICmpInst(Predicate Pred, Value *LHS, Value *RHS,
                               const DataLayout &DL,
                               const TargetLibraryInfo *TLI,
                               const DominatorTree *DT, AssumptionCache *AC,
                               const Instruction *CxtI) {
-  return ::SimplifyICmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
+  return ::SimplifyICmpInst(Pred, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
                             RecursionLimit);
 }
 
 /// Given operands for an FCmpInst, see if we can fold the result.
 /// If not, this returns null.
-static Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+static Value *SimplifyFCmpInst(Predicate Pred, Value *LHS, Value *RHS,
                                FastMathFlags FMF, const Query &Q,
                                unsigned MaxRecurse) {
-  CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate;
-  assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!");
+  assert(Pred.isFP() && "Not an FP compare!");
 
   if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
     if (Constant *CRHS = dyn_cast<Constant>(RHS))
       return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI);
 
     // If we have a constant, make sure it is on the RHS.
     std::swap(LHS, RHS);
-    Pred = CmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
   }
 
   // Fold trivial predicates.
-  if (Pred == FCmpInst::FCMP_FALSE)
+  if (Pred == Predicate::FCMP_FALSE)
     return ConstantInt::get(GetCompareTy(LHS), 0);
-  if (Pred == FCmpInst::FCMP_TRUE)
+  if (Pred == Predicate::FCMP_TRUE)
     return ConstantInt::get(GetCompareTy(LHS), 1);
 
   // UNO/ORD predicates can be trivially folded if NaNs are ignored.
   if (FMF.noNaNs()) {
-    if (Pred == FCmpInst::FCMP_UNO)
+    if (Pred == Predicate::FCMP_UNO)
       return ConstantInt::get(GetCompareTy(LHS), 0);
-    if (Pred == FCmpInst::FCMP_ORD)
+    if (Pred == Predicate::FCMP_ORD)
       return ConstantInt::get(GetCompareTy(LHS), 1);
   }
 
   // fcmp pred x, undef  and  fcmp pred undef, x
   // fold to true if unordered, false if ordered
   if (isa<UndefValue>(LHS) || isa<UndefValue>(RHS)) {
     // Choosing NaN for the undef will always make unordered comparison succeed
     // and ordered comparison fail.
-    return ConstantInt::get(GetCompareTy(LHS), CmpInst::isUnordered(Pred));
+    return ConstantInt::get(GetCompareTy(LHS), Pred.isUnordered());
   }
 
   // fcmp x,x -> true/false.  Not all compares are foldable.
   if (LHS == RHS) {
-    if (CmpInst::isTrueWhenEqual(Pred))
+    if (Pred.isTrueWhenEqual())
       return ConstantInt::get(GetCompareTy(LHS), 1);
-    if (CmpInst::isFalseWhenEqual(Pred))
+    if (Pred.isFalseWhenEqual())
       return ConstantInt::get(GetCompareTy(LHS), 0);
   }
 
   // Handle fcmp with constant RHS
   const ConstantFP *CFP = nullptr;
   if (const auto *RHSC = dyn_cast<Constant>(RHS)) {
     if (RHS->getType()->isVectorTy())
       CFP = dyn_cast_or_null<ConstantFP>(RHSC->getSplatValue());
     else
       CFP = dyn_cast<ConstantFP>(RHSC);
   }
   if (CFP) {
     // If the constant is a nan, see if we can fold the comparison based on it.
     if (CFP->getValueAPF().isNaN()) {
-      if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo"
+      if (Pred.isOrdered()) // True "if ordered and foo"
         return ConstantInt::getFalse(CFP->getContext());
-      assert(FCmpInst::isUnordered(Pred) &&
+      assert(Pred.isUnordered() &&
              "Comparison must be either ordered or unordered!");
       // True if unordered.
       return ConstantInt::get(GetCompareTy(LHS), 1);
     }
     // Check whether the constant is an infinity.
     if (CFP->getValueAPF().isInfinity()) {
       if (CFP->getValueAPF().isNegative()) {
-        switch (Pred) {
-        case FCmpInst::FCMP_OLT:
+        switch (Pred.getKind()) {
+        case Predicate::FCMP_OLT:
           // No value is ordered and less than negative infinity.
           return ConstantInt::get(GetCompareTy(LHS), 0);
-        case FCmpInst::FCMP_UGE:
+        case Predicate::FCMP_UGE:
           // All values are unordered with or at least negative infinity.
           return ConstantInt::get(GetCompareTy(LHS), 1);
         default:
           break;
         }
       } else {
-        switch (Pred) {
-        case FCmpInst::FCMP_OGT:
+        switch (Pred.getKind()) {
+        case Predicate::FCMP_OGT:
           // No value is ordered and greater than infinity.
           return ConstantInt::get(GetCompareTy(LHS), 0);
-        case FCmpInst::FCMP_ULE:
+        case Predicate::FCMP_ULE:
           // All values are unordered with and at most infinity.
           return ConstantInt::get(GetCompareTy(LHS), 1);
         default:
           break;
         }
       }
     }
     if (CFP->getValueAPF().isZero()) {
-      switch (Pred) {
-      case FCmpInst::FCMP_UGE:
+      switch (Pred.getKind()) {
+      case Predicate::FCMP_UGE:
         if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
           return ConstantInt::get(GetCompareTy(LHS), 1);
         break;
-      case FCmpInst::FCMP_OLT:
+      case Predicate::FCMP_OLT:
         // X < 0
         if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
           return ConstantInt::get(GetCompareTy(LHS), 0);
         break;
       default:
         break;
       }
     }
static Value *SimplifyFCmpInst(Predicate Pred, Value *LHS, Value *RHS,
   // doing the compare with each incoming phi value yields a common result.
   if (isa<PHINode>(LHS) || isa<PHINode>(RHS))
     if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse))
       return V;
 
   return nullptr;
 }
 
-Value *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+Value *llvm::SimplifyFCmpInst(Predicate Pred, Value *LHS, Value *RHS,
                               FastMathFlags FMF, const DataLayout &DL,
                               const TargetLibraryInfo *TLI,
                               const DominatorTree *DT, AssumptionCache *AC,
                               const Instruction *CxtI) {
-  return ::SimplifyFCmpInst(Predicate, LHS, RHS, FMF,
-                            Query(DL, TLI, DT, AC, CxtI), RecursionLimit);
+  return ::SimplifyFCmpInst(Pred, LHS, RHS, FMF, Query(DL, TLI, DT, AC, CxtI),
+                            RecursionLimit);
 }
 
 /// See if V simplifies when its operand Op is replaced with RepOp.
 static const Value *SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
                                            const Query &Q,
                                            unsigned MaxRecurse) {
   // Trivial replacement.
   if (V == Op)
static Value *simplifySelectWithFakeICmpEq(Value *CmpLHS, Value *TrueVal,
   return nullptr;
 }
 
 /// Try to simplify a select instruction when its condition operand is an
 /// integer comparison.
 static Value *simplifySelectWithICmpCond(Value *CondVal, Value *TrueVal,
                                          Value *FalseVal, const Query &Q,
                                          unsigned MaxRecurse) {
-  ICmpInst::Predicate Pred;
+  Predicate Pred;
   Value *CmpLHS, *CmpRHS;
   if (!match(CondVal, m_ICmp(Pred, m_Value(CmpLHS), m_Value(CmpRHS))))
     return nullptr;
 
   // FIXME: This code is nearly duplicated in InstCombine. Using/refactoring
   // decomposeBitTestICmp() might help.
-  if (ICmpInst::isEquality(Pred) && match(CmpRHS, m_Zero())) {
+  if (Pred.isEquality() && match(CmpRHS, m_Zero())) {
     Value *X;
     const APInt *Y;
     if (match(CmpLHS, m_And(m_Value(X), m_APInt(Y))))
       if (Value *V = simplifySelectBitTest(TrueVal, FalseVal, X, Y,
-                                           Pred == ICmpInst::ICMP_EQ))
+                                           Pred == Predicate::ICMP_EQ))
         return V;
-  } else if (Pred == ICmpInst::ICMP_SLT && match(CmpRHS, m_Zero())) {
+  } else if (Pred == Predicate::ICMP_SLT && match(CmpRHS, m_Zero())) {
     // Comparing signed-less-than 0 checks if the sign bit is set.
     if (Value *V = simplifySelectWithFakeICmpEq(CmpLHS, TrueVal, FalseVal,
                                                 false))
       return V;
-  } else if (Pred == ICmpInst::ICMP_SGT && match(CmpRHS, m_AllOnes())) {
+  } else if (Pred == Predicate::ICMP_SGT && match(CmpRHS, m_AllOnes())) {
     // Comparing signed-greater-than -1 checks if the sign bit is not set.
     if (Value *V = simplifySelectWithFakeICmpEq(CmpLHS, TrueVal, FalseVal,
                                                 true))
       return V;
   }
 
   if (CondVal->hasOneUse()) {
     const APInt *C;
     if (match(CmpRHS, m_APInt(C))) {
       // X < MIN ? T : F  -->  F
-      if (Pred == ICmpInst::ICMP_SLT && C->isMinSignedValue())
+      if (Pred == Predicate::ICMP_SLT && C->isMinSignedValue())
         return FalseVal;
       // X < MIN ? T : F  -->  F
-      if (Pred == ICmpInst::ICMP_ULT && C->isMinValue())
+      if (Pred == Predicate::ICMP_ULT && C->isMinValue())
         return FalseVal;
       // X > MAX ? T : F  -->  F
-      if (Pred == ICmpInst::ICMP_SGT && C->isMaxSignedValue())
+      if (Pred == Predicate::ICMP_SGT && C->isMaxSignedValue())
         return FalseVal;
       // X > MAX ? T : F  -->  F
-      if (Pred == ICmpInst::ICMP_UGT && C->isMaxValue())
+      if (Pred == Predicate::ICMP_UGT && C->isMaxValue())
         return FalseVal;
     }
   }
 
   // If we have an equality comparison, then we know the value in one of the
   // arms of the select. See if substituting this value into the arm and
   // simplifying the result yields the same value as the other arm.
-  if (Pred == ICmpInst::ICMP_EQ) {
+  if (Pred == Predicate::ICMP_EQ) {
     if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, Q, MaxRecurse) ==
             TrueVal ||
         SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, Q, MaxRecurse) ==
             TrueVal)
       return FalseVal;
     if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, Q, MaxRecurse) ==
             FalseVal ||
         SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, Q, MaxRecurse) ==
             FalseVal)
       return FalseVal;
-  } else if (Pred == ICmpInst::ICMP_NE) {
+  } else if (Pred == Predicate::ICMP_NE) {
     if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, Q, MaxRecurse) ==
             FalseVal ||
         SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, Q, MaxRecurse) ==
             FalseVal)
       return TrueVal;
     if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, Q, MaxRecurse) ==
             TrueVal ||
         SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, Q, MaxRecurse) ==
Value *llvm::SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                              const TargetLibraryInfo *TLI,
                              const DominatorTree *DT, AssumptionCache *AC,
                              const Instruction *CxtI) {
   return ::SimplifyFPBinOp(Opcode, LHS, RHS, FMF, Query(DL, TLI, DT, AC, CxtI),
                            RecursionLimit);
 }
 
 /// Given operands for a CmpInst, see if we can fold the result.
-static Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+static Value *SimplifyCmpInst(Predicate Pred, Value *LHS, Value *RHS,
                               const Query &Q, unsigned MaxRecurse) {
-  if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate))
-    return SimplifyICmpInst(Predicate, LHS, RHS, Q, MaxRecurse);
-  return SimplifyFCmpInst(Predicate, LHS, RHS, FastMathFlags(), Q, MaxRecurse);
+  if (Pred.isInt())
+    return SimplifyICmpInst(Pred, LHS, RHS, Q, MaxRecurse);
+  return SimplifyFCmpInst(Pred, LHS, RHS, FastMathFlags(), Q, MaxRecurse);
 }
 
-Value *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+Value *llvm::SimplifyCmpInst(Predicate Pred, Value *LHS, Value *RHS,
                              const DataLayout &DL, const TargetLibraryInfo *TLI,
                              const DominatorTree *DT, AssumptionCache *AC,
                              const Instruction *CxtI) {
-  return ::SimplifyCmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
+  return ::SimplifyCmpInst(Pred, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
                            RecursionLimit);
 }
 
 static bool IsIdempotent(Intrinsic::ID ID) {
   switch (ID) {
   default: return false;
 
   // Unary idempotent: f(f(x)) = f(x)

lib/Analysis/LazyValueInfo.cpp

if (isConstant()) {
       if (RHS.isNotConstant()) {
         if (Val == RHS.Val)
           return markOverdefined();
 
         // Unless we can prove that the two Constants are different, we must
         // move to overdefined.
         if (ConstantInt *Res =
                 dyn_cast<ConstantInt>(ConstantFoldCompareInstOperands(
-                    CmpInst::ICMP_NE, getConstant(), RHS.getNotConstant(), DL)))
+                    Predicate::ICMP_NE, getConstant(), RHS.getNotConstant(),
+                    DL)))
           if (Res->isOne())
             return markNotConstant(RHS.getNotConstant());
 
         return markOverdefined();
       }
 
       return markOverdefined();
     }
 
     if (isNotConstant()) {
       if (RHS.isConstant()) {
         if (Val == RHS.Val)
           return markOverdefined();
 
         // Unless we can prove that the two Constants are different, we must
         // move to overdefined.
         if (ConstantInt *Res =
                 dyn_cast<ConstantInt>(ConstantFoldCompareInstOperands(
-                    CmpInst::ICMP_NE, getNotConstant(), RHS.getConstant(), DL)))
+                    Predicate::ICMP_NE, getNotConstant(), RHS.getConstant(),
+                    DL)))
           if (Res->isOne())
             return false;
 
         return markOverdefined();
       }
 
       if (RHS.isNotConstant()) {
         if (Val == RHS.Val)
bool LazyValueInfoCache::solveBlockValueSelect(LVILatticeVal &BBLV,
   //   %24 = constantrange<0, 17>
   //   %39 = icmp eq i32 %24, 0
   //   %40 = add i32 %24, -1
   //   %siv.next = select i1 %39, i32 16, i32 %40
   //   %siv.next = constantrange<0, 17> not <-1, 17>
   // In general, this can handle any clamp idiom which tests the edge
   // condition via an equality or inequality.
   if (auto *ICI = dyn_cast<ICmpInst>(Cond)) {
-    ICmpInst::Predicate Pred = ICI->getPredicate();
+    Predicate Pred = ICI->getPredicate();
     Value *A = ICI->getOperand(0);
     if (ConstantInt *CIBase = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
       auto addConstants = [](ConstantInt *A, ConstantInt *B) {
         assert(A->getType() == B->getType());
         return ConstantInt::get(A->getType(), A->getValue() + B->getValue());
       };
       // See if either input is A + C2, subject to the constraint from the
       // condition that A != C when that input is used.  We can assume that
       // that input doesn't include C + C2.
       ConstantInt *CIAdded;
-      switch (Pred) {
+      switch (Pred.getKind()) {
       default: break;
-      case ICmpInst::ICMP_EQ:
+      case Predicate::ICMP_EQ:
         if (match(SI->getFalseValue(), m_Add(m_Specific(A),
                                              m_ConstantInt(CIAdded)))) {
           auto ResNot = addConstants(CIBase, CIAdded);
           FalseVal = intersect(FalseVal,
                                LVILatticeVal::getNot(ResNot));
         }
         break;
-      case ICmpInst::ICMP_NE:
+      case Predicate::ICMP_NE:
         if (match(SI->getTrueValue(), m_Add(m_Specific(A),
                                             m_ConstantInt(CIAdded)))) {
           auto ResNot = addConstants(CIBase, CIAdded);
           TrueVal = intersect(TrueVal,
                               LVILatticeVal::getNot(ResNot));
         }
         break;
       };
bool getValueFromCondition(Value *Val, Value *Cond, LVILatticeVal &Result,
 
   // For now we only support ICmpInst conditions
   ICmpInst *ICI = dyn_cast<ICmpInst>(Cond);
   if (!ICI)
     return false;
 
   Value *LHS = ICI->getOperand(0);
   Value *RHS = ICI->getOperand(1);
-  CmpInst::Predicate Predicate = ICI->getPredicate();
+  Predicate Pred = ICI->getPredicate();
 
   if (isa<Constant>(RHS)) {
     if (ICI->isEquality() && LHS == Val) {
       // We know that V has the RHS constant if this is a true SETEQ or
       // false SETNE.
-      if (isTrueDest == (Predicate == ICmpInst::ICMP_EQ))
+      if (isTrueDest == (Pred == Predicate::ICMP_EQ))
         Result = LVILatticeVal::get(cast<Constant>(RHS));
       else
         Result = LVILatticeVal::getNot(cast<Constant>(RHS));
       return true;
     }
 
     // Recognize the range checking idiom that InstCombine produces.
     // (X+C1) u< C2 --> [-C1, C2-C1)
     ConstantInt *Offset = nullptr;
-    if (Predicate == ICmpInst::ICMP_ULT)
+    if (Pred == Predicate::ICMP_ULT)
       match(LHS, m_Add(m_Specific(Val), m_ConstantInt(Offset)));
 
     ConstantInt *CI = dyn_cast<ConstantInt>(RHS);
     if (CI && (LHS == Val || Offset)) {
       // Calculate the range of values that are allowed by the comparison
       ConstantRange CmpRange(CI->getValue());
 
       // If we're interested in the false dest, invert the condition
-      CmpInst::Predicate Pred =
-          isTrueDest ? Predicate : CmpInst::getInversePredicate(Predicate);
+      Pred = isTrueDest ? Pred : Pred.getInverse();
       ConstantRange TrueValues =
           ConstantRange::makeAllowedICmpRegion(Pred, CmpRange);
 
       if (Offset) // Apply the offset from above.
         TrueValues = TrueValues.subtract(Offset->getValue());
 
       Result = LVILatticeVal::getRange(std::move(TrueValues));
       return true;
Constant *LazyValueInfo::getConstantOnEdge(Value *V, BasicBlock *FromBB,
   if (Result.isConstantRange()) {
     ConstantRange CR = Result.getConstantRange();
     if (const APInt *SingleVal = CR.getSingleElement())
       return ConstantInt::get(V->getContext(), *SingleVal);
   }
   return nullptr;
 }
 
-static LazyValueInfo::Tristate getPredicateResult(unsigned Pred, Constant *C,
+static LazyValueInfo::Tristate getPredicateResult(Predicate Pred, Constant *C,
                                                   LVILatticeVal &Result,
                                                   const DataLayout &DL,
                                                   TargetLibraryInfo *TLI) {
 
   // If we know the value is a constant, evaluate the conditional.
   Constant *Res = nullptr;
   if (Result.isConstant()) {
     Res = ConstantFoldCompareInstOperands(Pred, Result.getConstant(), C, DL,
                                           TLI);
     if (ConstantInt *ResCI = dyn_cast<ConstantInt>(Res))
       return ResCI->isZero() ? LazyValueInfo::False : LazyValueInfo::True;
     return LazyValueInfo::Unknown;
   }
 
   if (Result.isConstantRange()) {
     ConstantInt *CI = dyn_cast<ConstantInt>(C);
     if (!CI) return LazyValueInfo::Unknown;
 
     ConstantRange CR = Result.getConstantRange();
-    if (Pred == ICmpInst::ICMP_EQ) {
+    if (Pred == Predicate::ICMP_EQ) {
       if (!CR.contains(CI->getValue()))
         return LazyValueInfo::False;
 
       if (CR.isSingleElement() && CR.contains(CI->getValue()))
         return LazyValueInfo::True;
-    } else if (Pred == ICmpInst::ICMP_NE) {
+    } else if (Pred == Predicate::ICMP_NE) {
       if (!CR.contains(CI->getValue()))
         return LazyValueInfo::True;
 
       if (CR.isSingleElement() && CR.contains(CI->getValue()))
         return LazyValueInfo::False;
     }
 
     // Handle more complex predicates.
     ConstantRange TrueValues =
-        ICmpInst::makeConstantRange((ICmpInst::Predicate)Pred, CI->getValue());
+        ICmpInst::makeConstantRange(Pred, CI->getValue());
     if (TrueValues.contains(CR))
       return LazyValueInfo::True;
     if (TrueValues.inverse().contains(CR))
       return LazyValueInfo::False;
     return LazyValueInfo::Unknown;
   }
 
   if (Result.isNotConstant()) {
     // If this is an equality comparison, we can try to fold it knowing that
     // "V != C1".
-    if (Pred == ICmpInst::ICMP_EQ) {
+    if (Pred == Predicate::ICMP_EQ) {
       // !C1 == C -> false iff C1 == C.
-      Res = ConstantFoldCompareInstOperands(ICmpInst::ICMP_NE,
-                                            Result.getNotConstant(), C, DL,
-                                            TLI);
+      Res = ConstantFoldCompareInstOperands(
+          Predicate::ICMP_NE, Result.getNotConstant(), C, DL, TLI);
       if (Res->isNullValue())
         return LazyValueInfo::False;
-    } else if (Pred == ICmpInst::ICMP_NE) {
+    } else if (Pred == Predicate::ICMP_NE) {
       // !C1 != C -> true iff C1 == C.
-      Res = ConstantFoldCompareInstOperands(ICmpInst::ICMP_NE,
-                                            Result.getNotConstant(), C, DL,
-                                            TLI);
+      Res = ConstantFoldCompareInstOperands(
+          Predicate::ICMP_NE, Result.getNotConstant(), C, DL, TLI);
       if (Res->isNullValue())
         return LazyValueInfo::True;
     }
     return LazyValueInfo::Unknown;
   }
 
   return LazyValueInfo::Unknown;
 }
 
 /// Determine whether the specified value comparison with a constant is known to
 /// be true or false on the specified CFG edge. Pred is a CmpInst predicate.
-LazyValueInfo::Tristate
-LazyValueInfo::getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
-                                  BasicBlock *FromBB, BasicBlock *ToBB,
+LazyValueInfo::Tristate LazyValueInfo::getPredicateOnEdge(Predicate Pred,
+                                                          Value *V, Constant *C,
+                                                          BasicBlock *FromBB,
+                                                          BasicBlock *ToBB,
                                                           Instruction *CxtI) {
   const DataLayout &DL = FromBB->getModule()->getDataLayout();
   LVILatticeVal Result =
       getCache(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
 
   return getPredicateResult(Pred, C, Result, DL, TLI);
 }
 
-LazyValueInfo::Tristate
-LazyValueInfo::getPredicateAt(unsigned Pred, Value *V, Constant *C,
+LazyValueInfo::Tristate LazyValueInfo::getPredicateAt(Predicate Pred, Value *V,
+                                                      Constant *C,
                                                       Instruction *CxtI) {
   const DataLayout &DL = CxtI->getModule()->getDataLayout();
   LVILatticeVal Result = getCache(PImpl, AC, &DL, DT).getValueAt(V, CxtI);
   Tristate Ret = getPredicateResult(Pred, C, Result, DL, TLI);
   if (Ret != Unknown)
     return Ret;
 
   // Note: The following bit of code is somewhat distinct from the rest of LVI;
   // LVI as a whole tries to compute a lattice value which is conservatively

lib/Analysis/ScalarEvolution.cpp

const SCEV *ScalarEvolution::getTruncateExpr(const SCEV *Op,
   UniqueSCEVs.InsertNode(S, IP);
   return S;
 }
 
 // Get the limit of a recurrence such that incrementing by Step cannot cause
 // signed overflow as long as the value of the recurrence within the
 // loop does not exceed this limit before incrementing.
 static const SCEV *getSignedOverflowLimitForStep(const SCEV *Step,
-                                                 ICmpInst::Predicate *Pred,
+                                                 Predicate *Pred,
                                                  ScalarEvolution *SE) {
   unsigned BitWidth = SE->getTypeSizeInBits(Step->getType());
   if (SE->isKnownPositive(Step)) {
-    *Pred = ICmpInst::ICMP_SLT;
+    *Pred = Predicate::ICMP_SLT;
     return SE->getConstant(APInt::getSignedMinValue(BitWidth) -
                            SE->getSignedRange(Step).getSignedMax());
   }
   if (SE->isKnownNegative(Step)) {
-    *Pred = ICmpInst::ICMP_SGT;
+    *Pred = Predicate::ICMP_SGT;
     return SE->getConstant(APInt::getSignedMaxValue(BitWidth) -
                            SE->getSignedRange(Step).getSignedMin());
   }
   return nullptr;
 }
 
 // Get the limit of a recurrence such that incrementing by Step cannot cause
 // unsigned overflow as long as the value of the recurrence within the loop does
 // not exceed this limit before incrementing.
 static const SCEV *getUnsignedOverflowLimitForStep(const SCEV *Step,
-                                                   ICmpInst::Predicate *Pred,
+                                                   Predicate *Pred,
                                                    ScalarEvolution *SE) {
   unsigned BitWidth = SE->getTypeSizeInBits(Step->getType());
-  *Pred = ICmpInst::ICMP_ULT;
+  *Pred = Predicate::ICMP_ULT;
 
   return SE->getConstant(APInt::getMinValue(BitWidth) -
                          SE->getUnsignedRange(Step).getUnsignedMax());
 }
 
 namespace {
 
 struct ExtendOpTraitsBase {
   typedef const SCEV *(ScalarEvolution::*GetExtendExprTy)(const SCEV *, Type *);
 };
 
 // Used to make code generic over signed and unsigned overflow.
 template <typename ExtendOp> struct ExtendOpTraits {
   // Members present:
   //
   // static const SCEV::NoWrapFlags WrapType;
   //
   // static const ExtendOpTraitsBase::GetExtendExprTy GetExtendExpr;
   //
   // static const SCEV *getOverflowLimitForStep(const SCEV *Step,
-  //                                           ICmpInst::Predicate *Pred,
+  //                                           Predicate *Pred,
   //                                           ScalarEvolution *SE);
 };
 
 template <>
 struct ExtendOpTraits<SCEVSignExtendExpr> : public ExtendOpTraitsBase {
   static const SCEV::NoWrapFlags WrapType = SCEV::FlagNSW;
 
   static const GetExtendExprTy GetExtendExpr;
 
-  static const SCEV *getOverflowLimitForStep(const SCEV *Step,
-                                             ICmpInst::Predicate *Pred,
+  static const SCEV *getOverflowLimitForStep(const SCEV *Step, Predicate *Pred,
                                              ScalarEvolution *SE) {
     return getSignedOverflowLimitForStep(Step, Pred, SE);
   }
 };
 
 const ExtendOpTraitsBase::GetExtendExprTy ExtendOpTraits<
     SCEVSignExtendExpr>::GetExtendExpr = &ScalarEvolution::getSignExtendExpr;
 
 template <>
 struct ExtendOpTraits<SCEVZeroExtendExpr> : public ExtendOpTraitsBase {
   static const SCEV::NoWrapFlags WrapType = SCEV::FlagNUW;
 
   static const GetExtendExprTy GetExtendExpr;
 
-  static const SCEV *getOverflowLimitForStep(const SCEV *Step,
-                                             ICmpInst::Predicate *Pred,
+  static const SCEV *getOverflowLimitForStep(const SCEV *Step, Predicate *Pred,
                                              ScalarEvolution *SE) {
     return getUnsignedOverflowLimitForStep(Step, Pred, SE);
   }
 };
 
 const ExtendOpTraitsBase::GetExtendExprTy ExtendOpTraits<
     SCEVZeroExtendExpr>::GetExtendExpr = &ScalarEvolution::getZeroExtendExpr;
 }
if (PreAR && AR->getNoWrapFlags(WrapType)) {
       // or FlagNUW) and that `PreStart` + `Step` is `WrapType` too, then
       // `PreAR` == {`PreStart`,+,`Step`} is also `WrapType`.  Cache this fact.
       const_cast<SCEVAddRecExpr *>(PreAR)->setNoWrapFlags(WrapType);
     }
     return PreStart;
   }
 
   // 3. Loop precondition.
-  ICmpInst::Predicate Pred;
+  Predicate Pred;
   const SCEV *OverflowLimit =
       ExtendOpTraits<ExtendOpTy>::getOverflowLimitForStep(Step, &Pred, SE);
 
   if (OverflowLimit &&
       SE->isLoopEntryGuardedByCond(L, Pred, PreStart, OverflowLimit))
     return PreStart;
 
   return nullptr;
for (unsigned Delta : {-2, -1, 1, 2}) {
     void *IP = nullptr;
     const auto *PreAR =
       static_cast<SCEVAddRecExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
 
     // Give up if we don't already have the add recurrence we need because
     // actually constructing an add recurrence is relatively expensive.
     if (PreAR && PreAR->getNoWrapFlags(WrapType)) {  // proves (2)
       const SCEV *DeltaS = getConstant(StartC->getType(), Delta);
-      ICmpInst::Predicate Pred = ICmpInst::BAD_ICMP_PREDICATE;
+      Predicate Pred = Predicate::BAD_ICMP_PREDICATE;
       const SCEV *Limit = ExtendOpTraits<ExtendOpTy>::getOverflowLimitForStep(
           DeltaS, &Pred, this);
       if (Limit && isKnownPredicate(Pred, PreAR, Limit))  // proves (1)
         return true;
     }
   }
 
   return false;
if (AR->isAffine()) {
         // If the backedge is guarded by a comparison with the pre-inc
         // value the addrec is safe. Also, if the entry is guarded by
         // a comparison with the start value and the backedge is
         // guarded by a comparison with the post-inc value, the addrec
         // is safe.
         if (isKnownPositive(Step)) {
           const SCEV *N = getConstant(APInt::getMinValue(BitWidth) -
                                       getUnsignedRange(Step).getUnsignedMax());
-          if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT, AR, N) ||
-              (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_ULT, Start, N) &&
-               isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT,
+          if (isLoopBackedgeGuardedByCond(L, Predicate::ICMP_ULT, AR, N) ||
+              (isLoopEntryGuardedByCond(L, Predicate::ICMP_ULT, Start, N) &&
+               isLoopBackedgeGuardedByCond(L, Predicate::ICMP_ULT,
                                            AR->getPostIncExpr(*this), N))) {
             // Cache knowledge of AR NUW, which is propagated to this
             // AddRec.
             const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
             // Return the expression with the addrec on the outside.
             return getAddRecExpr(
                 getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
                 getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
           }
         } else if (isKnownNegative(Step)) {
           const SCEV *N = getConstant(APInt::getMaxValue(BitWidth) -
                                       getSignedRange(Step).getSignedMin());
-          if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT, AR, N) ||
-              (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_UGT, Start, N) &&
-               isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT,
+          if (isLoopBackedgeGuardedByCond(L, Predicate::ICMP_UGT, AR, N) ||
+              (isLoopEntryGuardedByCond(L, Predicate::ICMP_UGT, Start, N) &&
+               isLoopBackedgeGuardedByCond(L, Predicate::ICMP_UGT,
                                            AR->getPostIncExpr(*this), N))) {
             // Cache knowledge of AR NW, which is propagated to this
             // AddRec.  Negative step causes unsigned wrap, but it
             // still can't self-wrap.
             const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
             // Return the expression with the addrec on the outside.
             return getAddRecExpr(
                 getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
if (AR->isAffine()) {
 
       if (!isa<SCEVCouldNotCompute>(MaxBECount) || HasGuards ||
           !AC.assumptions().empty()) {
         // If the backedge is guarded by a comparison with the pre-inc
         // value the addrec is safe. Also, if the entry is guarded by
         // a comparison with the start value and the backedge is
         // guarded by a comparison with the post-inc value, the addrec
         // is safe.
-        ICmpInst::Predicate Pred;
+        Predicate Pred;
         const SCEV *OverflowLimit =
             getSignedOverflowLimitForStep(Step, &Pred, this);
         if (OverflowLimit &&
             (isLoopBackedgeGuardedByCond(L, Pred, AR, OverflowLimit) ||
              (isLoopEntryGuardedByCond(L, Pred, Start, OverflowLimit) &&
               isLoopBackedgeGuardedByCond(L, Pred, AR->getPostIncExpr(*this),
                                           OverflowLimit)))) {
           // Cache knowledge of AR NSW, then propagate NSW to the wide AddRec.
#endif
   }
 
   // Okay, check to see if the same value occurs in the operand list twice.  If
   // so, delete one.  Since we sorted the list, these values are required to
   // be adjacent.
   for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
     //  X smax Y smax Y  -->  X smax Y
     //  X smax Y         -->  X, if X is always greater than Y
-    if (Ops[i] == Ops[i+1] ||
-        isKnownPredicate(ICmpInst::ICMP_SGE, Ops[i], Ops[i+1])) {
+    if (Ops[i] == Ops[i + 1] ||
+        isKnownPredicate(Predicate::ICMP_SGE, Ops[i], Ops[i + 1])) {
       Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
       --i; --e;
-    } else if (isKnownPredicate(ICmpInst::ICMP_SLE, Ops[i], Ops[i+1])) {
+    } else if (isKnownPredicate(Predicate::ICMP_SLE, Ops[i], Ops[i + 1])) {
       Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
       --i; --e;
     }
 
   if (Ops.size() == 1) return Ops[0];
 
   assert(!Ops.empty() && "Reduced smax down to nothing!");
 
#endif
   }
 
   // Okay, check to see if the same value occurs in the operand list twice.  If
   // so, delete one.  Since we sorted the list, these values are required to
   // be adjacent.
   for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
     //  X umax Y umax Y  -->  X umax Y
     //  X umax Y         -->  X, if X is always greater than Y
-    if (Ops[i] == Ops[i+1] ||
-        isKnownPredicate(ICmpInst::ICMP_UGE, Ops[i], Ops[i+1])) {
+    if (Ops[i] == Ops[i + 1] ||
+        isKnownPredicate(Predicate::ICMP_UGE, Ops[i], Ops[i + 1])) {
       Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
       --i; --e;
-    } else if (isKnownPredicate(ICmpInst::ICMP_ULE, Ops[i], Ops[i+1])) {
+    } else if (isKnownPredicate(Predicate::ICMP_ULE, Ops[i], Ops[i + 1])) {
       Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
       --i; --e;
     }
 
   if (Ops.size() == 1) return Ops[0];
 
   assert(!Ops.empty() && "Reduced umax down to nothing!");
 
const SCEV *ScalarEvolution::createNodeForSelectOrPHI(Instruction *I,
   // Try to match some simple smax or umax patterns.
   auto *ICI = dyn_cast<ICmpInst>(Cond);
   if (!ICI)
     return getUnknown(I);
 
   Value *LHS = ICI->getOperand(0);
   Value *RHS = ICI->getOperand(1);
 
-  switch (ICI->getPredicate()) {
-  case ICmpInst::ICMP_SLT:
-  case ICmpInst::ICMP_SLE:
+  switch (ICI->getPredicate().getKind()) {
+  case Predicate::ICMP_SLT:
+  case Predicate::ICMP_SLE:
     std::swap(LHS, RHS);
   // fall through
-  case ICmpInst::ICMP_SGT:
-  case ICmpInst::ICMP_SGE:
+  case Predicate::ICMP_SGT:
+  case Predicate::ICMP_SGE:
     // a >s b ? a+x : b+x  ->  smax(a, b)+x
     // a >s b ? b+x : a+x  ->  smin(a, b)+x
     if (getTypeSizeInBits(LHS->getType()) <= getTypeSizeInBits(I->getType())) {
       const SCEV *LS = getNoopOrSignExtend(getSCEV(LHS), I->getType());
       const SCEV *RS = getNoopOrSignExtend(getSCEV(RHS), I->getType());
       const SCEV *LA = getSCEV(TrueVal);
       const SCEV *RA = getSCEV(FalseVal);
       const SCEV *LDiff = getMinusSCEV(LA, LS);
       const SCEV *RDiff = getMinusSCEV(RA, RS);
       if (LDiff == RDiff)
         return getAddExpr(getSMaxExpr(LS, RS), LDiff);
       LDiff = getMinusSCEV(LA, RS);
       RDiff = getMinusSCEV(RA, LS);
       if (LDiff == RDiff)
         return getAddExpr(getSMinExpr(LS, RS), LDiff);
     }
     break;
-  case ICmpInst::ICMP_ULT:
-  case ICmpInst::ICMP_ULE:
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_ULE:
     std::swap(LHS, RHS);
   // fall through
-  case ICmpInst::ICMP_UGT:
-  case ICmpInst::ICMP_UGE:
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_UGE:
     // a >u b ? a+x : b+x  ->  umax(a, b)+x
     // a >u b ? b+x : a+x  ->  umin(a, b)+x
     if (getTypeSizeInBits(LHS->getType()) <= getTypeSizeInBits(I->getType())) {
       const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), I->getType());
       const SCEV *RS = getNoopOrZeroExtend(getSCEV(RHS), I->getType());
       const SCEV *LA = getSCEV(TrueVal);
       const SCEV *RA = getSCEV(FalseVal);
       const SCEV *LDiff = getMinusSCEV(LA, LS);
       const SCEV *RDiff = getMinusSCEV(RA, RS);
       if (LDiff == RDiff)
         return getAddExpr(getUMaxExpr(LS, RS), LDiff);
       LDiff = getMinusSCEV(LA, RS);
       RDiff = getMinusSCEV(RA, LS);
       if (LDiff == RDiff)
         return getAddExpr(getUMinExpr(LS, RS), LDiff);
     }
     break;
-  case ICmpInst::ICMP_NE:
+  case Predicate::ICMP_NE:
     // n != 0 ? n+x : 1+x  ->  umax(n, 1)+x
     if (getTypeSizeInBits(LHS->getType()) <= getTypeSizeInBits(I->getType()) &&
         isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
       const SCEV *One = getOne(I->getType());
       const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), I->getType());
       const SCEV *LA = getSCEV(TrueVal);
       const SCEV *RA = getSCEV(FalseVal);
       const SCEV *LDiff = getMinusSCEV(LA, LS);
       const SCEV *RDiff = getMinusSCEV(RA, One);
       if (LDiff == RDiff)
         return getAddExpr(getUMaxExpr(One, LS), LDiff);
     }
     break;
-  case ICmpInst::ICMP_EQ:
+  case Predicate::ICMP_EQ:
     // n == 0 ? 1+x : n+x  ->  umax(n, 1)+x
     if (getTypeSizeInBits(LHS->getType()) <= getTypeSizeInBits(I->getType()) &&
         isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
       const SCEV *One = getOne(I->getType());
       const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), I->getType());
       const SCEV *LA = getSCEV(TrueVal);
       const SCEV *RA = getSCEV(FalseVal);
       const SCEV *LDiff = getMinusSCEV(LA, One);

 ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
                                           ICmpInst *ExitCond,
                                           BasicBlock *TBB,
                                           BasicBlock *FBB,
                                           bool ControlsExit,
                                           bool AllowPredicates) {
 
   // If the condition was exit on true, convert the condition to exit on false
-  ICmpInst::Predicate Cond;
+  Predicate Cond;
   if (!L->contains(FBB))
     Cond = ExitCond->getPredicate();
   else
     Cond = ExitCond->getInversePredicate();
 
   // Handle common loops like: for (X = "string"; *X; ++X)
   if (LoadInst *LI = dyn_cast<LoadInst>(ExitCond->getOperand(0)))
     if (Constant *RHS = dyn_cast<Constant>(ExitCond->getOperand(1))) {
ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
   LHS = getSCEVAtScope(LHS, L);
   RHS = getSCEVAtScope(RHS, L);
 
   // At this point, we would like to compute how many iterations of the
   // loop the predicate will return true for these inputs.
   if (isLoopInvariant(LHS, L) && !isLoopInvariant(RHS, L)) {
     // If there is a loop-invariant, force it into the RHS.
     std::swap(LHS, RHS);
-    Cond = ICmpInst::getSwappedPredicate(Cond);
+    Cond = Cond.getSwapped();
   }
 
   // Simplify the operands before analyzing them.
   (void)SimplifyICmpOperands(Cond, LHS, RHS);
 
   // If we have a comparison of a chrec against a constant, try to use value
   // ranges to answer this query.
   if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS))
     if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(LHS))
       if (AddRec->getLoop() == L) {
         // Form the constant range.
         ConstantRange CompRange(
             ICmpInst::makeConstantRange(Cond, RHSC->getAPInt()));
 
         const SCEV *Ret = AddRec->getNumIterationsInRange(CompRange, *this);
         if (!isa<SCEVCouldNotCompute>(Ret)) return Ret;
       }
 
-  switch (Cond) {
-  case ICmpInst::ICMP_NE: {                     // while (X != Y)
+  switch (Cond.getKind()) {
+  case Predicate::ICMP_NE: { // while (X != Y)
     // Convert to: while (X-Y != 0)
     ExitLimit EL = howFarToZero(getMinusSCEV(LHS, RHS), L, ControlsExit,
                                 AllowPredicates);
     if (EL.hasAnyInfo()) return EL;
     break;
   }
-  case ICmpInst::ICMP_EQ: {                     // while (X == Y)
+  case Predicate::ICMP_EQ: { // while (X == Y)
     // Convert to: while (X-Y == 0)
     ExitLimit EL = howFarToNonZero(getMinusSCEV(LHS, RHS), L);
     if (EL.hasAnyInfo()) return EL;
     break;
   }
-  case ICmpInst::ICMP_SLT:
-  case ICmpInst::ICMP_ULT: {                    // while (X < Y)
-    bool IsSigned = Cond == ICmpInst::ICMP_SLT;
+  case Predicate::ICMP_SLT:
+  case Predicate::ICMP_ULT: { // while (X < Y)
+    bool IsSigned = Cond == Predicate::ICMP_SLT;
     ExitLimit EL = howManyLessThans(LHS, RHS, L, IsSigned, ControlsExit,
                                     AllowPredicates);
     if (EL.hasAnyInfo()) return EL;
     break;
   }
-  case ICmpInst::ICMP_SGT:
-  case ICmpInst::ICMP_UGT: {                    // while (X > Y)
-    bool IsSigned = Cond == ICmpInst::ICMP_SGT;
+  case Predicate::ICMP_SGT:
+  case Predicate::ICMP_UGT: { // while (X > Y)
+    bool IsSigned = Cond == Predicate::ICMP_SGT;
     ExitLimit EL =
         howManyGreaterThans(LHS, RHS, L, IsSigned, ControlsExit,
                             AllowPredicates);
     if (EL.hasAnyInfo()) return EL;
     break;
   }
   default:
     break;
EvaluateConstantChrecAtConstant(const SCEVAddRecExpr *AddRec, ConstantInt *C,
   const SCEV *Val = AddRec->evaluateAtIteration(InVal, SE);
   assert(isa<SCEVConstant>(Val) &&
          "Evaluation of SCEV at constant didn't fold correctly?");
   return cast<SCEVConstant>(Val)->getValue();
 }
 
 /// Given an exit condition of 'icmp op load X, cst', try to see if we can
 /// compute the backedge execution count.
-ScalarEvolution::ExitLimit
-ScalarEvolution::computeLoadConstantCompareExitLimit(
-  LoadInst *LI,
-  Constant *RHS,
-  const Loop *L,
-  ICmpInst::Predicate predicate) {
+ScalarEvolution::ExitLimit ScalarEvolution::computeLoadConstantCompareExitLimit(
+    LoadInst *LI, Constant *RHS, const Loop *L, Predicate predicate) {
 
   if (LI->isVolatile()) return getCouldNotCompute();
 
   // Check to see if the loaded pointer is a getelementptr of a global.
   // TODO: Use SCEV instead of manually grubbing with GEPs.
   GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(LI->getOperand(0));
   if (!GEP) return getCouldNotCompute();
 
for (unsigned IterationNum = 0; IterationNum != MaxSteps; ++IterationNum) {
     if (cast<ConstantInt>(Result)->getValue().isMinValue()) {
       ++NumArrayLenItCounts;
       return getConstant(ItCst);   // Found terminating iteration!
     }
   }
   return getCouldNotCompute();
 }
 
-ScalarEvolution::ExitLimit ScalarEvolution::computeShiftCompareExitLimit(
-    Value *LHS, Value *RHSV, const Loop *L, ICmpInst::Predicate Pred) {
+ScalarEvolution::ExitLimit
+ScalarEvolution::computeShiftCompareExitLimit(Value *LHS, Value *RHSV,
+                                              const Loop *L, Predicate Pred) {
   ConstantInt *RHS = dyn_cast<ConstantInt>(RHSV);
   if (!RHS)
     return getCouldNotCompute();
 
   const BasicBlock *Latch = L->getLoopLatch();
   if (!Latch)
     return getCouldNotCompute();
 
ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
   // If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of
   // the quadratic equation to solve it.
   if (AddRec->isQuadratic() && AddRec->getType()->isIntegerTy()) {
     if (auto Roots = SolveQuadraticEquation(AddRec, *this)) {
       const SCEVConstant *R1 = Roots->first;
       const SCEVConstant *R2 = Roots->second;
       // Pick the smallest positive root value.
       if (ConstantInt *CB = dyn_cast<ConstantInt>(ConstantExpr::getICmp(
-              CmpInst::ICMP_ULT, R1->getValue(), R2->getValue()))) {
+              Predicate::ICMP_ULT, R1->getValue(), R2->getValue()))) {
         if (!CB->getZExtValue())
           std::swap(R1, R2); // R1 is the minimum root now.
 
         // We can only use this value if the chrec ends up with an exact zero
         // value at this index.  When solving for "X*X != 5", for example, we
         // should not accept a root of 2.
         const SCEV *Val = AddRec->evaluateAtIteration(R1, *this);
         if (Val->isZero())
if (const SCEVUnknown *BU = dyn_cast<SCEVUnknown>(B))
         if (const Instruction *BI = dyn_cast<Instruction>(BU->getValue()))
           if (ComputesEqualValues(AI, BI))
             return true;
 
   // Otherwise assume they may have a different value.
   return false;
 }
 
-bool ScalarEvolution::SimplifyICmpOperands(ICmpInst::Predicate &Pred,
-                                           const SCEV *&LHS, const SCEV *&RHS,
-                                           unsigned Depth) {
+bool ScalarEvolution::SimplifyICmpOperands(Predicate &Pred, const SCEV *&LHS,
+                                           const SCEV *&RHS, unsigned Depth) {
   bool Changed = false;
 
   // If we hit the max recursion limit bail out.
   if (Depth >= 3)
     return false;
 
   // Canonicalize a constant to the right side.
   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
     // Check for both operands constant.
     if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
       if (ConstantExpr::getICmp(Pred,
                                 LHSC->getValue(),
                                 RHSC->getValue())->isNullValue())
         goto trivially_false;
       else
         goto trivially_true;
     }
     // Otherwise swap the operands to put the constant on the right.
     std::swap(LHS, RHS);
-    Pred = ICmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
     Changed = true;
   }
 
   // If we're comparing an addrec with a value which is loop-invariant in the
   // addrec's loop, put the addrec on the left. Also make a dominance check,
   // as both operands could be addrecs loop-invariant in each other's loop.
   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(RHS)) {
     const Loop *L = AR->getLoop();
     if (isLoopInvariant(LHS, L) && properlyDominates(LHS, L->getHeader())) {
       std::swap(LHS, RHS);
-      Pred = ICmpInst::getSwappedPredicate(Pred);
+      Pred = Pred.getSwapped();
       Changed = true;
     }
   }
 
   // If there's a constant operand, canonicalize comparisons with boundary
   // cases, and canonicalize *-or-equal comparisons to regular comparisons.
   if (const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS)) {
     const APInt &RA = RC->getAPInt();
-    switch (Pred) {
-    default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
-    case ICmpInst::ICMP_EQ:
-    case ICmpInst::ICMP_NE:
+    switch (Pred.getKind()) {
+    default:
+      llvm_unreachable("Unexpected Predicate value!");
+    case Predicate::ICMP_EQ:
+    case Predicate::ICMP_NE:
       // Fold ((-1) * %a) + %b == 0 (equivalent to %b-%a == 0) into %a == %b.
       if (!RA)
         if (const SCEVAddExpr *AE = dyn_cast<SCEVAddExpr>(LHS))
           if (const SCEVMulExpr *ME = dyn_cast<SCEVMulExpr>(AE->getOperand(0)))
             if (AE->getNumOperands() == 2 && ME->getNumOperands() == 2 &&
                 ME->getOperand(0)->isAllOnesValue()) {
               RHS = AE->getOperand(1);
               LHS = ME->getOperand(1);
               Changed = true;
             }
       break;
-    case ICmpInst::ICMP_UGE:
+    case Predicate::ICMP_UGE:
       if ((RA - 1).isMinValue()) {
-        Pred = ICmpInst::ICMP_NE;
+        Pred = Predicate::ICMP_NE;
         RHS = getConstant(RA - 1);
         Changed = true;
         break;
       }
       if (RA.isMaxValue()) {
-        Pred = ICmpInst::ICMP_EQ;
+        Pred = Predicate::ICMP_EQ;
         Changed = true;
         break;
       }
       if (RA.isMinValue()) goto trivially_true;
 
-      Pred = ICmpInst::ICMP_UGT;
+      Pred = Predicate::ICMP_UGT;
       RHS = getConstant(RA - 1);
       Changed = true;
       break;
-    case ICmpInst::ICMP_ULE:
+    case Predicate::ICMP_ULE:
       if ((RA + 1).isMaxValue()) {
-        Pred = ICmpInst::ICMP_NE;
+        Pred = Predicate::ICMP_NE;
         RHS = getConstant(RA + 1);
         Changed = true;
         break;
       }
       if (RA.isMinValue()) {
-        Pred = ICmpInst::ICMP_EQ;
+        Pred = Predicate::ICMP_EQ;
         Changed = true;
         break;
       }
       if (RA.isMaxValue()) goto trivially_true;
 
-      Pred = ICmpInst::ICMP_ULT;
+      Pred = Predicate::ICMP_ULT;
       RHS = getConstant(RA + 1);
       Changed = true;
       break;
-    case ICmpInst::ICMP_SGE:
+    case Predicate::ICMP_SGE:
       if ((RA - 1).isMinSignedValue()) {
-        Pred = ICmpInst::ICMP_NE;
+        Pred = Predicate::ICMP_NE;
         RHS = getConstant(RA - 1);
         Changed = true;
         break;
       }
       if (RA.isMaxSignedValue()) {
-        Pred = ICmpInst::ICMP_EQ;
+        Pred = Predicate::ICMP_EQ;
         Changed = true;
         break;
       }
       if (RA.isMinSignedValue()) goto trivially_true;
 
-      Pred = ICmpInst::ICMP_SGT;
+      Pred = Predicate::ICMP_SGT;
       RHS = getConstant(RA - 1);
       Changed = true;
       break;
-    case ICmpInst::ICMP_SLE:
+    case Predicate::ICMP_SLE:
       if ((RA + 1).isMaxSignedValue()) {
-        Pred = ICmpInst::ICMP_NE;
+        Pred = Predicate::ICMP_NE;
         RHS = getConstant(RA + 1);
         Changed = true;
         break;
       }
       if (RA.isMinSignedValue()) {
-        Pred = ICmpInst::ICMP_EQ;
+        Pred = Predicate::ICMP_EQ;
         Changed = true;
         break;
       }
       if (RA.isMaxSignedValue()) goto trivially_true;
 
-      Pred = ICmpInst::ICMP_SLT;
+      Pred = Predicate::ICMP_SLT;
       RHS = getConstant(RA + 1);
       Changed = true;
       break;
-    case ICmpInst::ICMP_UGT:
+    case Predicate::ICMP_UGT:
       if (RA.isMinValue()) {
-        Pred = ICmpInst::ICMP_NE;
+        Pred = Predicate::ICMP_NE;
         Changed = true;
         break;
       }
       if ((RA + 1).isMaxValue()) {
-        Pred = ICmpInst::ICMP_EQ;
+        Pred = Predicate::ICMP_EQ;
         RHS = getConstant(RA + 1);
         Changed = true;
         break;
       }
       if (RA.isMaxValue()) goto trivially_false;
       break;
-    case ICmpInst::ICMP_ULT:
+    case Predicate::ICMP_ULT:
       if (RA.isMaxValue()) {
-        Pred = ICmpInst::ICMP_NE;
+        Pred = Predicate::ICMP_NE;
         Changed = true;
         break;
       }
       if ((RA - 1).isMinValue()) {
-        Pred = ICmpInst::ICMP_EQ;
+        Pred = Predicate::ICMP_EQ;
         RHS = getConstant(RA - 1);
         Changed = true;
         break;
       }
       if (RA.isMinValue()) goto trivially_false;
       break;
-    case ICmpInst::ICMP_SGT:
+    case Predicate::ICMP_SGT:
       if (RA.isMinSignedValue()) {
-        Pred = ICmpInst::ICMP_NE;
+        Pred = Predicate::ICMP_NE;
         Changed = true;
         break;
       }
       if ((RA + 1).isMaxSignedValue()) {
-        Pred = ICmpInst::ICMP_EQ;
+        Pred = Predicate::ICMP_EQ;
         RHS = getConstant(RA + 1);
         Changed = true;
         break;
       }
       if (RA.isMaxSignedValue()) goto trivially_false;
       break;
-    case ICmpInst::ICMP_SLT:
+    case Predicate::ICMP_SLT:
       if (RA.isMaxSignedValue()) {
-        Pred = ICmpInst::ICMP_NE;
+        Pred = Predicate::ICMP_NE;
         Changed = true;
         break;
       }
       if ((RA - 1).isMinSignedValue()) {
-       Pred = ICmpInst::ICMP_EQ;
+        Pred = Predicate::ICMP_EQ;
         RHS = getConstant(RA - 1);
         Changed = true;
        break;
       }
       if (RA.isMinSignedValue()) goto trivially_false;
       break;
     }
   }
 
   // Check for obvious equality.
   if (HasSameValue(LHS, RHS)) {
-    if (ICmpInst::isTrueWhenEqual(Pred))
+    if (Pred.isTrueWhenEqual())
       goto trivially_true;
-    if (ICmpInst::isFalseWhenEqual(Pred))
+    if (Pred.isFalseWhenEqual())
       goto trivially_false;
   }
 
   // If possible, canonicalize GE/LE comparisons to GT/LT comparisons, by
   // adding or subtracting 1 from one of the operands.
-  switch (Pred) {
-  case ICmpInst::ICMP_SLE:
+  switch (Pred.getKind()) {
+  case Predicate::ICMP_SLE:
     if (!getSignedRange(RHS).getSignedMax().isMaxSignedValue()) {
       RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
                        SCEV::FlagNSW);
-      Pred = ICmpInst::ICMP_SLT;
+      Pred = Predicate::ICMP_SLT;
       Changed = true;
     } else if (!getSignedRange(LHS).getSignedMin().isMinSignedValue()) {
       LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS,
                        SCEV::FlagNSW);
-      Pred = ICmpInst::ICMP_SLT;
+      Pred = Predicate::ICMP_SLT;
       Changed = true;
     }
     break;
-  case ICmpInst::ICMP_SGE:
+  case Predicate::ICMP_SGE:
     if (!getSignedRange(RHS).getSignedMin().isMinSignedValue()) {
       RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS,
                        SCEV::FlagNSW);
-      Pred = ICmpInst::ICMP_SGT;
+      Pred = Predicate::ICMP_SGT;
       Changed = true;
     } else if (!getSignedRange(LHS).getSignedMax().isMaxSignedValue()) {
       LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
                        SCEV::FlagNSW);
-      Pred = ICmpInst::ICMP_SGT;
+      Pred = Predicate::ICMP_SGT;
       Changed = true;
     }
     break;
-  case ICmpInst::ICMP_ULE:
+  case Predicate::ICMP_ULE:
     if (!getUnsignedRange(RHS).getUnsignedMax().isMaxValue()) {
       RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
                        SCEV::FlagNUW);
-      Pred = ICmpInst::ICMP_ULT;
+      Pred = Predicate::ICMP_ULT;
       Changed = true;
     } else if (!getUnsignedRange(LHS).getUnsignedMin().isMinValue()) {
       LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS);
-      Pred = ICmpInst::ICMP_ULT;
+      Pred = Predicate::ICMP_ULT;
       Changed = true;
     }
     break;
-  case ICmpInst::ICMP_UGE:
+  case Predicate::ICMP_UGE:
     if (!getUnsignedRange(RHS).getUnsignedMin().isMinValue()) {
       RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS);
-      Pred = ICmpInst::ICMP_UGT;
+      Pred = Predicate::ICMP_UGT;
       Changed = true;
     } else if (!getUnsignedRange(LHS).getUnsignedMax().isMaxValue()) {
       LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
                        SCEV::FlagNUW);
-      Pred = ICmpInst::ICMP_UGT;
+      Pred = Predicate::ICMP_UGT;
       Changed = true;
     }
     break;
   default:
     break;
   }
 
   // TODO: More simplifications are possible here.
 
   // Recursively simplify until we either hit a recursion limit or nothing
   // changes.
   if (Changed)
     return SimplifyICmpOperands(Pred, LHS, RHS, Depth+1);
 
   return Changed;
 
 trivially_true:
   // Return 0 == 0.
   LHS = RHS = getConstant(ConstantInt::getFalse(getContext()));
-  Pred = ICmpInst::ICMP_EQ;
+  Pred = Predicate::ICMP_EQ;
   return true;
 
 trivially_false:
   // Return 0 != 0.
   LHS = RHS = getConstant(ConstantInt::getFalse(getContext()));
-  Pred = ICmpInst::ICMP_NE;
+  Pred = Predicate::ICMP_NE;
   return true;
 }
 
 bool ScalarEvolution::isKnownNegative(const SCEV *S) {
   return getSignedRange(S).getSignedMax().isNegative();
 }
 
 bool ScalarEvolution::isKnownPositive(const SCEV *S) {
   return getSignedRange(S).getSignedMin().isStrictlyPositive();
 }
 
 bool ScalarEvolution::isKnownNonNegative(const SCEV *S) {
   return !getSignedRange(S).getSignedMin().isNegative();
 }
 
 bool ScalarEvolution::isKnownNonPositive(const SCEV *S) {
   return !getSignedRange(S).getSignedMax().isStrictlyPositive();
 }
 
 bool ScalarEvolution::isKnownNonZero(const SCEV *S) {
   return isKnownNegative(S) || isKnownPositive(S);
 }
 
-bool ScalarEvolution::isKnownPredicate(ICmpInst::Predicate Pred,
-                                       const SCEV *LHS, const SCEV *RHS) {
+bool ScalarEvolution::isKnownPredicate(Predicate Pred, const SCEV *LHS,
+                                       const SCEV *RHS) {
   // Canonicalize the inputs first.
   (void)SimplifyICmpOperands(Pred, LHS, RHS);
 
   // If LHS or RHS is an addrec, check to see if the condition is true in
   // every iteration of the loop.
   // If LHS and RHS are both addrec, both conditions must be true in
   // every iteration of the loop.
   const SCEVAddRecExpr *LAR = dyn_cast<SCEVAddRecExpr>(LHS);
bool ScalarEvolution::isKnownPredicate(Predicate Pred, const SCEV *LHS,
   if (isKnownPredicateViaSplitting(Pred, LHS, RHS))
     return true;
 
   // Otherwise see what can be done with known constant ranges.
   return isKnownPredicateViaConstantRanges(Pred, LHS, RHS);
 }
 
 bool ScalarEvolution::isMonotonicPredicate(const SCEVAddRecExpr *LHS,
-                                           ICmpInst::Predicate Pred,
-                                           bool &Increasing) {
+                                           Predicate Pred, bool &Increasing) {
   bool Result = isMonotonicPredicateImpl(LHS, Pred, Increasing);
 
 #ifndef NDEBUG
   // Verify an invariant: inverting the predicate should turn a monotonically
   // increasing change to a monotonically decreasing one, and vice versa.
   bool IncreasingSwapped;
-  bool ResultSwapped = isMonotonicPredicateImpl(
-      LHS, ICmpInst::getSwappedPredicate(Pred), IncreasingSwapped);
+  bool ResultSwapped =
+      isMonotonicPredicateImpl(LHS, Pred.getSwapped(), IncreasingSwapped);
 
   assert(Result == ResultSwapped && "should be able to analyze both!");
   if (ResultSwapped)
     assert(Increasing == !IncreasingSwapped &&
            "monotonicity should flip as we flip the predicate");
 #endif
 
   return Result;
 }
 
 bool ScalarEvolution::isMonotonicPredicateImpl(const SCEVAddRecExpr *LHS,
-                                               ICmpInst::Predicate Pred,
+                                               Predicate Pred,
                                                bool &Increasing) {
 
   // A zero step value for LHS means the induction variable is essentially a
   // loop invariant value. We don't really depend on the predicate actually
   // flipping from false to true (for increasing predicates, and the other way
   // around for decreasing predicates), all we care about is that *if* the
   // predicate changes then it only changes from false to true.
   //
   // A zero step value in itself is not very useful, but there may be places
   // where SCEV can prove X >= 0 but not prove X > 0, so it is helpful to be
   // as general as possible.
 
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default:
     return false; // Conservative answer
 
-  case ICmpInst::ICMP_UGT:
-  case ICmpInst::ICMP_UGE:
-  case ICmpInst::ICMP_ULT:
-  case ICmpInst::ICMP_ULE:
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_UGE:
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_ULE:
     if (!LHS->hasNoUnsignedWrap())
       return false;
 
-    Increasing = Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE;
+    Increasing = Pred == Predicate::ICMP_UGT || Pred == Predicate::ICMP_UGE;
     return true;
 
-  case ICmpInst::ICMP_SGT:
-  case ICmpInst::ICMP_SGE:
-  case ICmpInst::ICMP_SLT:
-  case ICmpInst::ICMP_SLE: {
+  case Predicate::ICMP_SGT:
+  case Predicate::ICMP_SGE:
+  case Predicate::ICMP_SLT:
+  case Predicate::ICMP_SLE: {
     if (!LHS->hasNoSignedWrap())
       return false;
 
     const SCEV *Step = LHS->getStepRecurrence(*this);
 
     if (isKnownNonNegative(Step)) {
-      Increasing = Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE;
+      Increasing = Pred == Predicate::ICMP_SGT || Pred == Predicate::ICMP_SGE;
       return true;
     }
 
     if (isKnownNonPositive(Step)) {
-      Increasing = Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE;
+      Increasing = Pred == Predicate::ICMP_SLT || Pred == Predicate::ICMP_SLE;
       return true;
     }
 
     return false;
   }
 
   }
 
   llvm_unreachable("switch has default clause!");
 }
 
-bool ScalarEvolution::isLoopInvariantPredicate(
-    ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS, const Loop *L,
-    ICmpInst::Predicate &InvariantPred, const SCEV *&InvariantLHS,
+bool ScalarEvolution::isLoopInvariantPredicate(Predicate Pred, const SCEV *LHS,
+                                               const SCEV *RHS, const Loop *L,
+                                               Predicate &InvariantPred,
+                                               const SCEV *&InvariantLHS,
                                                const SCEV *&InvariantRHS) {
 
   // If there is a loop-invariant, force it into the RHS, otherwise bail out.
   if (!isLoopInvariant(RHS, L)) {
     if (!isLoopInvariant(LHS, L))
       return false;
 
     std::swap(LHS, RHS);
-    Pred = ICmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
   }
 
   const SCEVAddRecExpr *ArLHS = dyn_cast<SCEVAddRecExpr>(LHS);
   if (!ArLHS || ArLHS->getLoop() != L)
     return false;
 
   bool Increasing;
   if (!isMonotonicPredicate(ArLHS, Pred, Increasing))
bool ScalarEvolution::isLoopInvariantPredicate(Predicate Pred, const SCEV *LHS,
   //
   // For both the above possibilities, we can replace the loop varying
   // predicate with its value on the first iteration of the loop (which is
   // loop invariant).
   //
   // A similar reasoning applies for a monotonically decreasing predicate, by
   // replacing true with false and false with true in the above two bullets.
 
-  auto P = Increasing ? Pred : ICmpInst::getInversePredicate(Pred);
+  auto P = Increasing ? Pred : Pred.getInverse();
 
   if (!isLoopBackedgeGuardedByCond(L, P, LHS, RHS))
     return false;
 
   InvariantPred = Pred;
   InvariantLHS = ArLHS->getStart();
   InvariantRHS = RHS;
   return true;
 }
 
-bool ScalarEvolution::isKnownPredicateViaConstantRanges(
-    ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS) {
+bool ScalarEvolution::isKnownPredicateViaConstantRanges(Predicate Pred,
+                                                        const SCEV *LHS,
+                                                        const SCEV *RHS) {
   if (HasSameValue(LHS, RHS))
-    return ICmpInst::isTrueWhenEqual(Pred);
+    return Pred.isTrueWhenEqual();
 
   // This code is split out from isKnownPredicate because it is called from
   // within isLoopEntryGuardedByCond.
 
   auto CheckRanges =
       [&](const ConstantRange &RangeLHS, const ConstantRange &RangeRHS) {
     return ConstantRange::makeSatisfyingICmpRegion(Pred, RangeRHS)
         .contains(RangeLHS);
   };
 
   // The check at the top of the function catches the case where the values are
   // known to be equal.
-  if (Pred == CmpInst::ICMP_EQ)
+  if (Pred == Predicate::ICMP_EQ)
     return false;
 
-  if (Pred == CmpInst::ICMP_NE)
+  if (Pred == Predicate::ICMP_NE)
     return CheckRanges(getSignedRange(LHS), getSignedRange(RHS)) ||
            CheckRanges(getUnsignedRange(LHS), getUnsignedRange(RHS)) ||
            isKnownNonZero(getMinusSCEV(LHS, RHS));
 
-  if (CmpInst::isSigned(Pred))
+  if (Pred.isSigned())
     return CheckRanges(getSignedRange(LHS), getSignedRange(RHS));
 
   return CheckRanges(getUnsignedRange(LHS), getUnsignedRange(RHS));
 }
 
-bool ScalarEvolution::isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred,
+bool ScalarEvolution::isKnownPredicateViaNoOverflow(Predicate Pred,
                                                     const SCEV *LHS,
                                                     const SCEV *RHS) {
 
   // Match Result to (X + Y)<ExpectedFlags> where Y is a constant integer.
   // Return Y via OutY.
   auto MatchBinaryAddToConst =
       [this](const SCEV *Result, const SCEV *X, APInt &OutY,
              SCEV::NoWrapFlags ExpectedFlags) {
     const SCEV *NonConstOp, *ConstOp;
     SCEV::NoWrapFlags FlagsPresent;
 
     if (!splitBinaryAdd(Result, ConstOp, NonConstOp, FlagsPresent) ||
         !isa<SCEVConstant>(ConstOp) || NonConstOp != X)
       return false;
 
     OutY = cast<SCEVConstant>(ConstOp)->getAPInt();
     return (FlagsPresent & ExpectedFlags) == ExpectedFlags;
   };
 
   APInt C;
 
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default:
     break;
 
-  case ICmpInst::ICMP_SGE:
+  case Predicate::ICMP_SGE:
     std::swap(LHS, RHS);
-  case ICmpInst::ICMP_SLE:
+  case Predicate::ICMP_SLE:
     // X s<= (X + C)<nsw> if C >= 0
     if (MatchBinaryAddToConst(RHS, LHS, C, SCEV::FlagNSW) && C.isNonNegative())
       return true;
 
     // (X + C)<nsw> s<= X if C <= 0
     if (MatchBinaryAddToConst(LHS, RHS, C, SCEV::FlagNSW) &&
         !C.isStrictlyPositive())
       return true;
     break;
 
-  case ICmpInst::ICMP_SGT:
+  case Predicate::ICMP_SGT:
     std::swap(LHS, RHS);
-  case ICmpInst::ICMP_SLT:
+  case Predicate::ICMP_SLT:
     // X s< (X + C)<nsw> if C > 0
     if (MatchBinaryAddToConst(RHS, LHS, C, SCEV::FlagNSW) &&
         C.isStrictlyPositive())
       return true;
 
     // (X + C)<nsw> s< X if C < 0
     if (MatchBinaryAddToConst(LHS, RHS, C, SCEV::FlagNSW) && C.isNegative())
       return true;
     break;
   }
 
   return false;
 }
 
-bool ScalarEvolution::isKnownPredicateViaSplitting(ICmpInst::Predicate Pred,
+bool ScalarEvolution::isKnownPredicateViaSplitting(Predicate Pred,
                                                    const SCEV *LHS,
                                                    const SCEV *RHS) {
-  if (Pred != ICmpInst::ICMP_ULT || ProvingSplitPredicate)
+  if (Pred != Predicate::ICMP_ULT || ProvingSplitPredicate)
     return false;
 
   // Allowing arbitrary number of activations of isKnownPredicateViaSplitting on
   // the stack can result in exponential time complexity.
   SaveAndRestore<bool> Restore(ProvingSplitPredicate, true);
 
   // If L >= 0 then I `ult` L <=> I >= 0 && I `slt` L
   //
   // To prove L >= 0 we use isKnownNonNegative whereas to prove I >= 0 we use
   // isKnownPredicate.  isKnownPredicate is more powerful, but also more
   // expensive; and using isKnownNonNegative(RHS) is sufficient for most of the
   // interesting cases seen in practice.  We can consider "upgrading" L >= 0 to
   // use isKnownPredicate later if needed.
   return isKnownNonNegative(RHS) &&
-         isKnownPredicate(CmpInst::ICMP_SGE, LHS, getZero(LHS->getType())) &&
-         isKnownPredicate(CmpInst::ICMP_SLT, LHS, RHS);
+         isKnownPredicate(Predicate::ICMP_SGE, LHS, getZero(LHS->getType())) &&
+         isKnownPredicate(Predicate::ICMP_SLT, LHS, RHS);
 }
 
-bool ScalarEvolution::isImpliedViaGuard(BasicBlock *BB,
-                                        ICmpInst::Predicate Pred,
+bool ScalarEvolution::isImpliedViaGuard(BasicBlock *BB, Predicate Pred,
                                         const SCEV *LHS, const SCEV *RHS) {
   // No need to even try if we know the module has no guards.
   if (!HasGuards)
     return false;
 
   return any_of(*BB, [&](Instruction &I) {
     using namespace llvm::PatternMatch;
 
     Value *Condition;
     return match(&I, m_Intrinsic<Intrinsic::experimental_guard>(
                          m_Value(Condition))) &&
            isImpliedCond(Pred, LHS, RHS, Condition, false);
   });
 }
 
 /// isLoopBackedgeGuardedByCond - Test whether the backedge of the loop is
 /// protected by a conditional between LHS and RHS.  This is used to
 /// to eliminate casts.
-bool
-ScalarEvolution::isLoopBackedgeGuardedByCond(const Loop *L,
-                                             ICmpInst::Predicate Pred,
-                                             const SCEV *LHS, const SCEV *RHS) {
+bool ScalarEvolution::isLoopBackedgeGuardedByCond(const Loop *L, Predicate Pred,
+                                                  const SCEV *LHS,
+                                                  const SCEV *RHS) {
   // Interpret a null as meaning no loop, where there is obviously no guard
   // (interprocedural conditions notwithstanding).
   if (!L) return true;
 
   if (isKnownPredicateViaConstantRanges(Pred, LHS, RHS))
     return true;
 
   BasicBlock *Latch = L->getLoopLatch();
bool ScalarEvolution::isLoopBackedgeGuardedByCond(const Loop *L, Predicate Pred,
   if (LatchBECount != getCouldNotCompute()) {
     // We know that Latch branches back to the loop header exactly
     // LatchBECount times.  This means the backdege condition at Latch is
     // equivalent to  "{0,+,1} u< LatchBECount".
     Type *Ty = LatchBECount->getType();
     auto NoWrapFlags = SCEV::NoWrapFlags(SCEV::FlagNUW | SCEV::FlagNW);
     const SCEV *LoopCounter =
       getAddRecExpr(getZero(Ty), getOne(Ty), L, NoWrapFlags);
-    if (isImpliedCond(Pred, LHS, RHS, ICmpInst::ICMP_ULT, LoopCounter,
+    if (isImpliedCond(Pred, LHS, RHS, Predicate::ICMP_ULT, LoopCounter,
                       LatchBECount))
       return true;
   }
 
   // Check conditions due to any @llvm.assume intrinsics.
   for (auto &AssumeVH : AC.assumptions()) {
     if (!AssumeVH)
       continue;
if (DominatingEdge.isSingleEdge()) {
                         BB != ContinuePredicate->getSuccessor(0)))
         return true;
     }
   }
 
   return false;
 }
 
-bool
-ScalarEvolution::isLoopEntryGuardedByCond(const Loop *L,
-                                          ICmpInst::Predicate Pred,
-                                          const SCEV *LHS, const SCEV *RHS) {
+bool ScalarEvolution::isLoopEntryGuardedByCond(const Loop *L, Predicate Pred,
+                                               const SCEV *LHS,
+                                               const SCEV *RHS) {
   // Interpret a null as meaning no loop, where there is obviously no guard
   // (interprocedural conditions notwithstanding).
   if (!L) return false;
 
   if (isKnownPredicateViaConstantRanges(Pred, LHS, RHS))
     return true;
 
   // Starting at the loop predecessor, climb up the predecessor chain, as long
struct MarkPendingLoopPredicate {
   }
   ~MarkPendingLoopPredicate() {
     if (!Pending)
       LoopPreds.erase(Cond);
   }
 };
 } // end anonymous namespace
 
-bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred,
-                                    const SCEV *LHS, const SCEV *RHS,
-                                    Value *FoundCondValue,
+bool ScalarEvolution::isImpliedCond(Predicate Pred, const SCEV *LHS,
+                                    const SCEV *RHS, Value *FoundCondValue,
                                     bool Inverse) {
   MarkPendingLoopPredicate Mark(FoundCondValue, PendingLoopPredicates);
   if (Mark.Pending)
     return false;
 
   // Recursively handle And and Or conditions.
   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(FoundCondValue)) {
     if (BO->getOpcode() == Instruction::And) {
       if (!Inverse)
         return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
                isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
     } else if (BO->getOpcode() == Instruction::Or) {
       if (Inverse)
         return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
                isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
     }
   }
 
   ICmpInst *ICI = dyn_cast<ICmpInst>(FoundCondValue);
   if (!ICI) return false;
 
   // Now that we found a conditional branch that dominates the loop or controls
   // the loop latch. Check to see if it is the comparison we are looking for.
-  ICmpInst::Predicate FoundPred;
+  Predicate FoundPred;
   if (Inverse)
     FoundPred = ICI->getInversePredicate();
   else
     FoundPred = ICI->getPredicate();
 
   const SCEV *FoundLHS = getSCEV(ICI->getOperand(0));
   const SCEV *FoundRHS = getSCEV(ICI->getOperand(1));
 
   return isImpliedCond(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS);
 }
 
-bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred, const SCEV *LHS,
-                                    const SCEV *RHS,
-                                    ICmpInst::Predicate FoundPred,
+bool ScalarEvolution::isImpliedCond(Predicate Pred, const SCEV *LHS,
+                                    const SCEV *RHS, Predicate FoundPred,
                                     const SCEV *FoundLHS,
                                     const SCEV *FoundRHS) {
   // Balance the types.
   if (getTypeSizeInBits(LHS->getType()) <
       getTypeSizeInBits(FoundLHS->getType())) {
-    if (CmpInst::isSigned(Pred)) {
+    if (Pred.isSigned()) {
       LHS = getSignExtendExpr(LHS, FoundLHS->getType());
       RHS = getSignExtendExpr(RHS, FoundLHS->getType());
     } else {
       LHS = getZeroExtendExpr(LHS, FoundLHS->getType());
       RHS = getZeroExtendExpr(RHS, FoundLHS->getType());
     }
   } else if (getTypeSizeInBits(LHS->getType()) >
       getTypeSizeInBits(FoundLHS->getType())) {
-    if (CmpInst::isSigned(FoundPred)) {
+    if (FoundPred.isSigned()) {
       FoundLHS = getSignExtendExpr(FoundLHS, LHS->getType());
       FoundRHS = getSignExtendExpr(FoundRHS, LHS->getType());
     } else {
       FoundLHS = getZeroExtendExpr(FoundLHS, LHS->getType());
       FoundRHS = getZeroExtendExpr(FoundRHS, LHS->getType());
     }
   }
 
   // Canonicalize the query to match the way instcombine will have
   // canonicalized the comparison.
   if (SimplifyICmpOperands(Pred, LHS, RHS))
     if (LHS == RHS)
-      return CmpInst::isTrueWhenEqual(Pred);
+      return Pred.isTrueWhenEqual();
   if (SimplifyICmpOperands(FoundPred, FoundLHS, FoundRHS))
     if (FoundLHS == FoundRHS)
-      return CmpInst::isFalseWhenEqual(FoundPred);
+      return FoundPred.isFalseWhenEqual();
 
   // Check to see if we can make the LHS or RHS match.
   if (LHS == FoundRHS || RHS == FoundLHS) {
     if (isa<SCEVConstant>(RHS)) {
       std::swap(FoundLHS, FoundRHS);
-      FoundPred = ICmpInst::getSwappedPredicate(FoundPred);
+      FoundPred = FoundPred.getSwapped();
     } else {
       std::swap(LHS, RHS);
-      Pred = ICmpInst::getSwappedPredicate(Pred);
+      Pred = Pred.getSwapped();
     }
   }
 
   // Check whether the found predicate is the same as the desired predicate.
   if (FoundPred == Pred)
     return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
 
   // Check whether swapping the found predicate makes it the same as the
   // desired predicate.
-  if (ICmpInst::getSwappedPredicate(FoundPred) == Pred) {
+  if (FoundPred.getSwapped() == Pred) {
     if (isa<SCEVConstant>(RHS))
       return isImpliedCondOperands(Pred, LHS, RHS, FoundRHS, FoundLHS);
     else
-      return isImpliedCondOperands(ICmpInst::getSwappedPredicate(Pred),
-                                   RHS, LHS, FoundLHS, FoundRHS);
+      return isImpliedCondOperands(Pred.getSwapped(), RHS, LHS, FoundLHS,
+                                   FoundRHS);
   }
 
   // Unsigned comparison is the same as signed comparison when both the operands
   // are non-negative.
-  if (CmpInst::isUnsigned(FoundPred) &&
-      CmpInst::getSignedPredicate(FoundPred) == Pred &&
+  if (FoundPred.isUnsigned() && FoundPred.getSigned() == Pred &&
       isKnownNonNegative(FoundLHS) && isKnownNonNegative(FoundRHS))
     return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
 
   // Check if we can make progress by sharpening ranges.
-  if (FoundPred == ICmpInst::ICMP_NE &&
+  if (FoundPred == Predicate::ICMP_NE &&
       (isa<SCEVConstant>(FoundLHS) || isa<SCEVConstant>(FoundRHS))) {
 
     const SCEVConstant *C = nullptr;
     const SCEV *V = nullptr;
 
     if (isa<SCEVConstant>(FoundLHS)) {
       C = cast<SCEVConstant>(FoundLHS);
       V = FoundRHS;
     } else {
       C = cast<SCEVConstant>(FoundRHS);
       V = FoundLHS;
     }
 
     // The guarding predicate tells us that C != V. If the known range
     // of V is [C, t), we can sharpen the range to [C + 1, t).  The
     // range we consider has to correspond to same signedness as the
     // predicate we're interested in folding.
 
-    APInt Min = ICmpInst::isSigned(Pred) ?
-        getSignedRange(V).getSignedMin() : getUnsignedRange(V).getUnsignedMin();
+    APInt Min = Pred.isSigned() ? getSignedRange(V).getSignedMin()
+                                : getUnsignedRange(V).getUnsignedMin();
 
     if (Min == C->getAPInt()) {
       // Given (V >= Min && V != Min) we conclude V >= (Min + 1).
       // This is true even if (Min + 1) wraps around -- in case of
       // wraparound, (Min + 1) < Min, so (V >= Min => V >= (Min + 1)).
 
       APInt SharperMin = Min + 1;
 
-      switch (Pred) {
-        case ICmpInst::ICMP_SGE:
-        case ICmpInst::ICMP_UGE:
-          // We know V `Pred` SharperMin.  If this implies LHS `Pred`
-          // RHS, we're done.
-          if (isImpliedCondOperands(Pred, LHS, RHS, V,
-                                    getConstant(SharperMin)))
-            return true;
+      switch (Pred.getKind()) {
+      case Predicate::ICMP_SGE:
+      case Predicate::ICMP_UGE:
+        if (isImpliedCondOperands(Pred, LHS, RHS, V, getConstant(SharperMin)))
 
-        case ICmpInst::ICMP_SGT:
-        case ICmpInst::ICMP_UGT:
-          // We know from the range information that (V `Pred` Min ||
-          // V == Min).  We know from the guarding condition that !(V
-          // == Min).  This gives us
-          //
-          //       V `Pred` Min || V == Min && !(V == Min)
-          //   =>  V `Pred` Min
-          //
-          // If V `Pred` Min implies LHS `Pred` RHS, we're done.
+      case Predicate::ICMP_SGT:
+      case Predicate::ICMP_UGT:
 
-          if (isImpliedCondOperands(Pred, LHS, RHS, V, getConstant(Min)))
-            return true;
 
-        default:
-          // No change
-          break;
       }
     }
   }
 
   // Check whether the actual condition is beyond sufficient.
-  if (FoundPred == ICmpInst::ICMP_EQ)
-    if (ICmpInst::isTrueWhenEqual(Pred))
+  if (FoundPred == Predicate::ICMP_EQ)
+    if (Pred.isTrueWhenEqual())
       if (isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS))
         return true;
-  if (Pred == ICmpInst::ICMP_NE)
-    if (!ICmpInst::isTrueWhenEqual(FoundPred))
+  if (Pred == Predicate::ICMP_NE)
+    if (!FoundPred.isTrueWhenEqual())
       if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS))
         return true;
 
   // Otherwise assume the worst.
   return false;
 }
 
 bool ScalarEvolution::splitBinaryAdd(const SCEV *Expr,
Optional<APInt> ScalarEvolution::computeConstantDifference(const SCEV *More,
   if (splitBinaryAdd(More, L, R, Flags))
     if (const auto *LC = dyn_cast<SCEVConstant>(L))
       if (R == Less)
         return LC->getAPInt();
 
   return None;
 }
 
-bool ScalarEvolution::isImpliedCondOperandsViaNoOverflow(
-    ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
-    const SCEV *FoundLHS, const SCEV *FoundRHS) {
-  if (Pred != CmpInst::ICMP_SLT && Pred != CmpInst::ICMP_ULT)
+bool ScalarEvolution::isImpliedCondOperandsViaNoOverflow(Predicate Pred,
+                                                         const SCEV *LHS,
+                                                         const SCEV *RHS,
+                                                         const SCEV *FoundLHS,
+                                                         const SCEV *FoundRHS) {
+  if (Pred != Predicate::ICMP_SLT && Pred != Predicate::ICMP_ULT)
     return false;
 
   const auto *AddRecLHS = dyn_cast<SCEVAddRecExpr>(LHS);
   if (!AddRecLHS)
     return false;
 
   const auto *AddRecFoundLHS = dyn_cast<SCEVAddRecExpr>(FoundLHS);
   if (!AddRecFoundLHS)
bool ScalarEvolution::isImpliedCondOperandsViaNoOverflow(Predicate Pred,
   if (!LDiff || !RDiff || *LDiff != *RDiff)
     return false;
 
   if (LDiff->isMinValue())
     return true;
 
   APInt FoundRHSLimit;
 
-  if (Pred == CmpInst::ICMP_ULT) {
+  if (Pred == Predicate::ICMP_ULT) {
     FoundRHSLimit = -(*RDiff);
   } else {
-    assert(Pred == CmpInst::ICMP_SLT && "Checked above!");
+    assert(Pred == Predicate::ICMP_SLT && "Checked above!");
     FoundRHSLimit = APInt::getSignedMinValue(getTypeSizeInBits(RHS->getType())) - *RDiff;
   }
 
   // Try to prove (1) or (2), as needed.
   return isLoopEntryGuardedByCond(L, Pred, FoundRHS,
                                   getConstant(FoundRHSLimit));
 }
 
-bool ScalarEvolution::isImpliedCondOperands(ICmpInst::Predicate Pred,
-                                            const SCEV *LHS, const SCEV *RHS,
+bool ScalarEvolution::isImpliedCondOperands(Predicate Pred, const SCEV *LHS,
+                                            const SCEV *RHS,
                                             const SCEV *FoundLHS,
                                             const SCEV *FoundRHS) {
   if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundLHS, FoundRHS))
     return true;
 
   if (isImpliedCondOperandsViaNoOverflow(Pred, LHS, RHS, FoundLHS, FoundRHS))
     return true;
 
static bool IsMinConsistingOf(ScalarEvolution &SE,
                               const SCEV *Candidate) {
   const SCEV *MaybeMaxExpr = MatchNotExpr(MaybeMinExpr);
   if (!MaybeMaxExpr)
     return false;
 
   return IsMaxConsistingOf<MaxExprType>(MaybeMaxExpr, SE.getNotSCEV(Candidate));
 }
 
-static bool IsKnownPredicateViaAddRecStart(ScalarEvolution &SE,
-                                           ICmpInst::Predicate Pred,
+static bool IsKnownPredicateViaAddRecStart(ScalarEvolution &SE, Predicate Pred,
                                            const SCEV *LHS, const SCEV *RHS) {
 
   // If both sides are affine addrecs for the same loop, with equal
   // steps, and we know the recurrences don't wrap, then we only
   // need to check the predicate on the starting values.
 
-  if (!ICmpInst::isRelational(Pred))
+  if (!Pred.isRelational())
     return false;
 
   const SCEVAddRecExpr *LAR = dyn_cast<SCEVAddRecExpr>(LHS);
   if (!LAR)
     return false;
   const SCEVAddRecExpr *RAR = dyn_cast<SCEVAddRecExpr>(RHS);
   if (!RAR)
     return false;
   if (LAR->getLoop() != RAR->getLoop())
     return false;
   if (!LAR->isAffine() || !RAR->isAffine())
     return false;
 
   if (LAR->getStepRecurrence(SE) != RAR->getStepRecurrence(SE))
     return false;
 
-  SCEV::NoWrapFlags NW = ICmpInst::isSigned(Pred) ?
-                         SCEV::FlagNSW : SCEV::FlagNUW;
+  SCEV::NoWrapFlags NW = Pred.isSigned() ? SCEV::FlagNSW : SCEV::FlagNUW;
   if (!LAR->getNoWrapFlags(NW) || !RAR->getNoWrapFlags(NW))
     return false;
 
   return SE.isKnownPredicate(Pred, LAR->getStart(), RAR->getStart());
 }
 
 /// Is LHS `Pred` RHS true on the virtue of LHS or RHS being a Min or Max
 /// expression?
-static bool IsKnownPredicateViaMinOrMax(ScalarEvolution &SE,
-                                        ICmpInst::Predicate Pred,
+static bool IsKnownPredicateViaMinOrMax(ScalarEvolution &SE, Predicate Pred,
                                         const SCEV *LHS, const SCEV *RHS) {
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default:
     return false;
 
-  case ICmpInst::ICMP_SGE:
+  case Predicate::ICMP_SGE:
     std::swap(LHS, RHS);
     // fall through
-  case ICmpInst::ICMP_SLE:
+  case Predicate::ICMP_SLE:
     return
       // min(A, ...) <= A
       IsMinConsistingOf<SCEVSMaxExpr>(SE, LHS, RHS) ||
       // A <= max(A, ...)
       IsMaxConsistingOf<SCEVSMaxExpr>(RHS, LHS);
 
-  case ICmpInst::ICMP_UGE:
+  case Predicate::ICMP_UGE:
     std::swap(LHS, RHS);
     // fall through
-  case ICmpInst::ICMP_ULE:
+  case Predicate::ICMP_ULE:
     return
       // min(A, ...) <= A
       IsMinConsistingOf<SCEVUMaxExpr>(SE, LHS, RHS) ||
       // A <= max(A, ...)
       IsMaxConsistingOf<SCEVUMaxExpr>(RHS, LHS);
   }
 
   llvm_unreachable("covered switch fell through?!");
 }
 
-bool
-ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
-                                             const SCEV *LHS, const SCEV *RHS,
+bool ScalarEvolution::isImpliedCondOperandsHelper(Predicate Pred,
+                                                  const SCEV *LHS,
+                                                  const SCEV *RHS,
                                                   const SCEV *FoundLHS,
                                                   const SCEV *FoundRHS) {
-  auto IsKnownPredicateFull =
-      [this](ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS) {
+  auto IsKnownPredicateFull = [this](Predicate Pred, const SCEV *LHS,
+                                     const SCEV *RHS) {
     return isKnownPredicateViaConstantRanges(Pred, LHS, RHS) ||
            IsKnownPredicateViaMinOrMax(*this, Pred, LHS, RHS) ||
            IsKnownPredicateViaAddRecStart(*this, Pred, LHS, RHS) ||
            isKnownPredicateViaNoOverflow(Pred, LHS, RHS);
   };
 
-  switch (Pred) {
-  default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
-  case ICmpInst::ICMP_EQ:
-  case ICmpInst::ICMP_NE:
+  switch (Pred.getKind()) {
+  default:
+    llvm_unreachable("Unexpected Predicate value!");
+  case Predicate::ICMP_EQ:
+  case Predicate::ICMP_NE:
     if (HasSameValue(LHS, FoundLHS) && HasSameValue(RHS, FoundRHS))
       return true;
     break;
-  case ICmpInst::ICMP_SLT:
-  case ICmpInst::ICMP_SLE:
-    if (IsKnownPredicateFull(ICmpInst::ICMP_SLE, LHS, FoundLHS) &&
-        IsKnownPredicateFull(ICmpInst::ICMP_SGE, RHS, FoundRHS))
+  case Predicate::ICMP_SLT:
+  case Predicate::ICMP_SLE:
+    if (IsKnownPredicateFull(Predicate::ICMP_SLE, LHS, FoundLHS) &&
+        IsKnownPredicateFull(Predicate::ICMP_SGE, RHS, FoundRHS))
       return true;
     break;
-  case ICmpInst::ICMP_SGT:
-  case ICmpInst::ICMP_SGE:
-    if (IsKnownPredicateFull(ICmpInst::ICMP_SGE, LHS, FoundLHS) &&
-        IsKnownPredicateFull(ICmpInst::ICMP_SLE, RHS, FoundRHS))
+  case Predicate::ICMP_SGT:
+  case Predicate::ICMP_SGE:
+    if (IsKnownPredicateFull(Predicate::ICMP_SGE, LHS, FoundLHS) &&
+        IsKnownPredicateFull(Predicate::ICMP_SLE, RHS, FoundRHS))
       return true;
     break;
-  case ICmpInst::ICMP_ULT:
-  case ICmpInst::ICMP_ULE:
-    if (IsKnownPredicateFull(ICmpInst::ICMP_ULE, LHS, FoundLHS) &&
-        IsKnownPredicateFull(ICmpInst::ICMP_UGE, RHS, FoundRHS))
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_ULE:
+    if (IsKnownPredicateFull(Predicate::ICMP_ULE, LHS, FoundLHS) &&
+        IsKnownPredicateFull(Predicate::ICMP_UGE, RHS, FoundRHS))
       return true;
     break;
-  case ICmpInst::ICMP_UGT:
-  case ICmpInst::ICMP_UGE:
-    if (IsKnownPredicateFull(ICmpInst::ICMP_UGE, LHS, FoundLHS) &&
-        IsKnownPredicateFull(ICmpInst::ICMP_ULE, RHS, FoundRHS))
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_UGE:
+    if (IsKnownPredicateFull(Predicate::ICMP_UGE, LHS, FoundLHS) &&
+        IsKnownPredicateFull(Predicate::ICMP_ULE, RHS, FoundRHS))
       return true;
     break;
   }
 
   return false;
 }
 
-bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
+bool ScalarEvolution::isImpliedCondOperandsViaRanges(Predicate Pred,
                                                      const SCEV *LHS,
                                                      const SCEV *RHS,
                                                      const SCEV *FoundLHS,
                                                      const SCEV *FoundRHS) {
   if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
     // The restriction on `FoundRHS` be lifted easily -- it exists only to
     // reduce the compile time impact of this optimization.
     return false;
ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
 
   // Avoid proven overflow cases: this will ensure that the backedge taken count
   // will not generate any unsigned overflow. Relaxed no-overflow conditions
   // exploit NoWrapFlags, allowing to optimize in presence of undefined
   // behaviors like the case of C language.
   if (!Stride->isOne() && doesIVOverflowOnLT(RHS, Stride, IsSigned, NoWrap))
     return getCouldNotCompute();
 
-  ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SLT
-                                      : ICmpInst::ICMP_ULT;
+  Predicate Cond = IsSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT;
   const SCEV *Start = IV->getStart();
   const SCEV *End = RHS;
   if (!isLoopEntryGuardedByCond(L, Cond, getMinusSCEV(Start, Stride), RHS))
     End = IsSigned ? getSMaxExpr(RHS, Start) : getUMaxExpr(RHS, Start);
 
   const SCEV *BECount = computeBECount(getMinusSCEV(End, Start), Stride, false);
 
   APInt MinStart = IsSigned ? getSignedRange(Start).getSignedMin()
ScalarEvolution::howManyGreaterThans(const SCEV *LHS, const SCEV *RHS,
 
   // Avoid proven overflow cases: this will ensure that the backedge taken count
   // will not generate any unsigned overflow. Relaxed no-overflow conditions
   // exploit NoWrapFlags, allowing to optimize in presence of undefined
   // behaviors like the case of C language.
   if (!Stride->isOne() && doesIVOverflowOnGT(RHS, Stride, IsSigned, NoWrap))
     return getCouldNotCompute();
 
-  ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SGT
-                                      : ICmpInst::ICMP_UGT;
+  Predicate Cond = IsSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
 
   const SCEV *Start = IV->getStart();
   const SCEV *End = RHS;
   if (!isLoopEntryGuardedByCond(L, Cond, getAddExpr(Start, Stride), RHS))
     End = IsSigned ? getSMinExpr(RHS, Start) : getUMinExpr(RHS, Start);
 
   const SCEV *BECount = computeBECount(getMinusSCEV(Start, End), Stride, false);
 
if (isAffine()) {
 
     // Next, solve the constructed addrec
     if (auto Roots =
             SolveQuadraticEquation(cast<SCEVAddRecExpr>(NewAddRec), SE)) {
       const SCEVConstant *R1 = Roots->first;
       const SCEVConstant *R2 = Roots->second;
       // Pick the smallest positive root value.
       if (ConstantInt *CB = dyn_cast<ConstantInt>(ConstantExpr::getICmp(
-              ICmpInst::ICMP_ULT, R1->getValue(), R2->getValue()))) {
+              Predicate::ICMP_ULT, R1->getValue(), R2->getValue()))) {
         if (!CB->getZExtValue())
           std::swap(R1, R2); // R1 is the minimum root now.
 
         // Make sure the root is not off by one.  The returned iteration should
         // not be in the range, but the previous one should be.  When solving
         // for "X*X < 5", for example, we should not return a root of 2.
         ConstantInt *R1Val =
             EvaluateConstantChrecAtConstant(this, R1->getValue(), SE);

lib/Analysis/ScalarEvolutionExpander.cpp

Value *SCEVExpander::findExistingExpansion(const SCEV *S,
                                            const Instruction *At, Loop *L) {
   using namespace llvm::PatternMatch;
 
   SmallVector<BasicBlock *, 4> ExitingBlocks;
   L->getExitingBlocks(ExitingBlocks);
 
   // Look for suitable value in simple conditions at the loop exits.
   for (BasicBlock *BB : ExitingBlocks) {
-    ICmpInst::Predicate Pred;
+    Predicate Pred;
     Instruction *LHS, *RHS;
     BasicBlock *TrueBB, *FalseBB;
 
     if (!match(BB->getTerminator(),
                m_Br(m_ICmp(Pred, m_Instruction(LHS), m_Instruction(RHS)),
                     TrueBB, FalseBB)))
       continue;
 
Value *SCEVExpander::generateOverflowCheck(const SCEVAddRecExpr *AR,
   Value *NegStepValue = expandCodeFor(SE.getNegativeSCEV(Step), Ty, Loc);
   Value *StartValue = expandCodeFor(Start, Ty, Loc);
 
   ConstantInt *Zero =
       ConstantInt::get(Loc->getContext(), APInt::getNullValue(DstBits));
 
   Builder.SetInsertPoint(Loc);
   // Compute |Step|
-  Value *StepCompare = Builder.CreateICmp(ICmpInst::ICMP_SLT, StepValue, Zero);
+  Value *StepCompare = Builder.CreateICmp(Predicate::ICMP_SLT, StepValue, Zero);
   Value *AbsStep = Builder.CreateSelect(StepCompare, NegStepValue, StepValue);
 
   // Get the backedge taken count and truncate or extended to the AR type.
   Value *TruncTripCount = Builder.CreateZExtOrTrunc(TripCountVal, Ty);
   auto *MulF = Intrinsic::getDeclaration(Loc->getModule(),
                                          Intrinsic::umul_with_overflow, Ty);
 
   // Compute |Step| * Backedge
   CallInst *Mul = Builder.CreateCall(MulF, {AbsStep, TruncTripCount}, "mul");
   Value *MulV = Builder.CreateExtractValue(Mul, 0, "mul.result");
   Value *OfMul = Builder.CreateExtractValue(Mul, 1, "mul.overflow");
 
   // Compute:
   //   Start + |Step| * Backedge < Start
   //   Start - |Step| * Backedge > Start
   Value *Add = Builder.CreateAdd(StartValue, MulV);
   Value *Sub = Builder.CreateSub(StartValue, MulV);
 
   Value *EndCompareGT = Builder.CreateICmp(
-      Signed ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT, Sub, StartValue);
+      Signed ? Predicate::ICMP_SGT : Predicate::ICMP_UGT, Sub, StartValue);
 
   Value *EndCompareLT = Builder.CreateICmp(
-      Signed ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT, Add, StartValue);
+      Signed ? Predicate::ICMP_SLT : Predicate::ICMP_ULT, Add, StartValue);
 
   // Select the answer based on the sign of Step.
   Value *EndCheck =
       Builder.CreateSelect(StepCompare, EndCompareGT, EndCompareLT);
 
   // If the backedge taken count type is larger than the AR type,
   // check that we don't drop any bits by truncating it. If we are
   // droping bits, then we have overflow (unless the step is zero).
   if (SE.getTypeSizeInBits(CountTy) > SE.getTypeSizeInBits(Ty)) {
     auto MaxVal = APInt::getMaxValue(DstBits).zext(SrcBits);
     auto *BackedgeCheck =
-        Builder.CreateICmp(ICmpInst::ICMP_UGT, TripCountVal,
+        Builder.CreateICmp(Predicate::ICMP_UGT, TripCountVal,
                            ConstantInt::get(Loc->getContext(), MaxVal));
     BackedgeCheck = Builder.CreateAnd(
-        BackedgeCheck, Builder.CreateICmp(ICmpInst::ICMP_NE, StepValue, Zero));
+        BackedgeCheck, Builder.CreateICmp(Predicate::ICMP_NE, StepValue, Zero));
 
     EndCheck = Builder.CreateOr(EndCheck, BackedgeCheck);
   }
 
   EndCheck = Builder.CreateOr(EndCheck, OfMul);
   return EndCheck;
 }
 

lib/Analysis/ValueTracking.cpp

for (auto &AssumeVH : Q.AC->assumptions()) {
     if (Depth == MaxDepth)
       continue;
 
     Value *A, *B;
     auto m_V = m_CombineOr(m_Specific(V),
                            m_CombineOr(m_PtrToInt(m_Specific(V)),
                            m_BitCast(m_Specific(V))));
 
-    CmpInst::Predicate Pred;
+    Predicate Pred;
     ConstantInt *C;
     // assume(v = a)
     if (match(Arg, m_c_ICmp(Pred, m_V, m_Value(A))) &&
-        Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
+        Pred == Predicate::ICMP_EQ &&
+        isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       KnownZero |= RHSKnownZero;
       KnownOne  |= RHSKnownOne;
     // assume(v & b = a)
     } else if (match(Arg,
                      m_c_ICmp(Pred, m_c_And(m_V, m_Value(B)), m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
       computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1, Query(Q, I));
 
       // For those bits in the mask that are known to be one, we can propagate
       // known bits from the RHS to V.
       KnownZero |= RHSKnownZero & MaskKnownOne;
       KnownOne  |= RHSKnownOne  & MaskKnownOne;
     // assume(~(v & b) = a)
     } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_And(m_V, m_Value(B))),
                                    m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
       computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1, Query(Q, I));
 
       // For those bits in the mask that are known to be one, we can propagate
       // inverted known bits from the RHS to V.
       KnownZero |= RHSKnownOne  & MaskKnownOne;
       KnownOne  |= RHSKnownZero & MaskKnownOne;
     // assume(v | b = a)
     } else if (match(Arg,
                      m_c_ICmp(Pred, m_c_Or(m_V, m_Value(B)), m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
       computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
 
       // For those bits in B that are known to be zero, we can propagate known
       // bits from the RHS to V.
       KnownZero |= RHSKnownZero & BKnownZero;
       KnownOne  |= RHSKnownOne  & BKnownZero;
     // assume(~(v | b) = a)
     } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Or(m_V, m_Value(B))),
                                    m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
       computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
 
       // For those bits in B that are known to be zero, we can propagate
       // inverted known bits from the RHS to V.
       KnownZero |= RHSKnownOne  & BKnownZero;
       KnownOne  |= RHSKnownZero & BKnownZero;
     // assume(v ^ b = a)
     } else if (match(Arg,
                      m_c_ICmp(Pred, m_c_Xor(m_V, m_Value(B)), m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
       computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
 
       // For those bits in B that are known to be zero, we can propagate known
       // bits from the RHS to V. For those bits in B that are known to be one,
       // we can propagate inverted known bits from the RHS to V.
       KnownZero |= RHSKnownZero & BKnownZero;
       KnownOne  |= RHSKnownOne  & BKnownZero;
       KnownZero |= RHSKnownOne  & BKnownOne;
       KnownOne  |= RHSKnownZero & BKnownOne;
     // assume(~(v ^ b) = a)
     } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Xor(m_V, m_Value(B))),
                                    m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
       computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
 
       // For those bits in B that are known to be zero, we can propagate
       // inverted known bits from the RHS to V. For those bits in B that are
       // known to be one, we can propagate known bits from the RHS to V.
       KnownZero |= RHSKnownOne  & BKnownZero;
       KnownOne  |= RHSKnownZero & BKnownZero;
       KnownZero |= RHSKnownZero & BKnownOne;
       KnownOne  |= RHSKnownOne  & BKnownOne;
     // assume(v << c = a)
     } else if (match(Arg, m_c_ICmp(Pred, m_Shl(m_V, m_ConstantInt(C)),
                                    m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       // For those bits in RHS that are known, we can propagate them to known
       // bits in V shifted to the right by C.
       KnownZero |= RHSKnownZero.lshr(C->getZExtValue());
       KnownOne  |= RHSKnownOne.lshr(C->getZExtValue());
     // assume(~(v << c) = a)
     } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_Shl(m_V, m_ConstantInt(C))),
                                    m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       // For those bits in RHS that are known, we can propagate them inverted
       // to known bits in V shifted to the right by C.
       KnownZero |= RHSKnownOne.lshr(C->getZExtValue());
       KnownOne  |= RHSKnownZero.lshr(C->getZExtValue());
     // assume(v >> c = a)
     } else if (match(Arg,
                      m_c_ICmp(Pred, m_CombineOr(m_LShr(m_V, m_ConstantInt(C)),
                                                 m_AShr(m_V, m_ConstantInt(C))),
                               m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       // For those bits in RHS that are known, we can propagate them to known
       // bits in V shifted to the right by C.
       KnownZero |= RHSKnownZero << C->getZExtValue();
       KnownOne  |= RHSKnownOne  << C->getZExtValue();
     // assume(~(v >> c) = a)
     } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_CombineOr(
                                              m_LShr(m_V, m_ConstantInt(C)),
                                              m_AShr(m_V, m_ConstantInt(C)))),
                                    m_Value(A))) &&
-               Pred == ICmpInst::ICMP_EQ &&
+               Pred == Predicate::ICMP_EQ &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
       // For those bits in RHS that are known, we can propagate them inverted
       // to known bits in V shifted to the right by C.
       KnownZero |= RHSKnownOne  << C->getZExtValue();
       KnownOne  |= RHSKnownZero << C->getZExtValue();
     // assume(v >=_s c) where c is non-negative
     } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
-               Pred == ICmpInst::ICMP_SGE &&
+               Pred == Predicate::ICMP_SGE &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
 
       if (RHSKnownZero.isNegative()) {
         // We know that the sign bit is zero.
         KnownZero |= APInt::getSignBit(BitWidth);
       }
     // assume(v >_s c) where c is at least -1.
     } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
-               Pred == ICmpInst::ICMP_SGT &&
+               Pred == Predicate::ICMP_SGT &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
 
       if (RHSKnownOne.isAllOnesValue() || RHSKnownZero.isNegative()) {
         // We know that the sign bit is zero.
         KnownZero |= APInt::getSignBit(BitWidth);
       }
     // assume(v <=_s c) where c is negative
     } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
-               Pred == ICmpInst::ICMP_SLE &&
+               Pred == Predicate::ICMP_SLE &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
 
       if (RHSKnownOne.isNegative()) {
         // We know that the sign bit is one.
         KnownOne |= APInt::getSignBit(BitWidth);
       }
     // assume(v <_s c) where c is non-positive
     } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
-               Pred == ICmpInst::ICMP_SLT &&
+               Pred == Predicate::ICMP_SLT &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
 
       if (RHSKnownZero.isAllOnesValue() || RHSKnownOne.isNegative()) {
         // We know that the sign bit is one.
         KnownOne |= APInt::getSignBit(BitWidth);
       }
     // assume(v <=_u c)
     } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
-               Pred == ICmpInst::ICMP_ULE &&
+               Pred == Predicate::ICMP_ULE &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
 
       // Whatever high bits in c are zero are known to be zero.
       KnownZero |=
         APInt::getHighBitsSet(BitWidth, RHSKnownZero.countLeadingOnes());
     // assume(v <_u c)
     } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
-               Pred == ICmpInst::ICMP_ULT &&
+               Pred == Predicate::ICMP_ULT &&
                isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
       APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
       computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
 
       // Whatever high bits in c are zero are known to be zero (if c is a power
       // of 2, then one more).
       if (isKnownToBeAPowerOfTwo(A, false, Depth + 1, Query(Q, I)))
         KnownZero |=
static bool isKnownNonNullFromDominatingCondition(const Value *V,
 
   unsigned NumUsesExplored = 0;
   for (auto *U : V->users()) {
     // Avoid massive lists
     if (NumUsesExplored >= DomConditionsMaxUses)
       break;
     NumUsesExplored++;
     // Consider only compare instructions uniquely controlling a branch
-    CmpInst::Predicate Pred;
+    Predicate Pred;
     if (!match(const_cast<User *>(U),
                m_c_ICmp(Pred, m_Specific(V), m_Zero())) ||
-        (Pred != ICmpInst::ICMP_EQ && Pred != ICmpInst::ICMP_NE))
+        (Pred != Predicate::ICMP_EQ && Pred != Predicate::ICMP_NE))
       continue;
 
     for (auto *CmpU : U->users()) {
       if (const BranchInst *BI = dyn_cast<BranchInst>(CmpU)) {
         assert(BI->isConditional() && "uses a comparison!");
 
         BasicBlock *NonNullSuccessor =
-            BI->getSuccessor(Pred == ICmpInst::ICMP_EQ ? 1 : 0);
+            BI->getSuccessor(Pred == Predicate::ICMP_EQ ? 1 : 0);
         BasicBlockEdge Edge(BI->getParent(), NonNullSuccessor);
         if (Edge.isSingleEdge() && DT->dominates(Edge, CtxI->getParent()))
           return true;
-      } else if (Pred == ICmpInst::ICMP_NE &&
+      } else if (Pred == Predicate::ICMP_NE &&
                  match(CmpU, m_Intrinsic<Intrinsic::experimental_guard>()) &&
                  DT->dominates(cast<Instruction>(CmpU), CtxI)) {
         return true;
       }
     }
   }
 
   return false;

 }
 
 static bool isKnownNonZero(Value *V) {
   if (auto *C = dyn_cast<ConstantFP>(V))
     return !C->isZero();
   return false;
 }
 
-static SelectPatternResult matchSelectPattern(CmpInst::Predicate Pred,
-                                              FastMathFlags FMF,
+static SelectPatternResult matchSelectPattern(Predicate Pred, FastMathFlags FMF,
                                               Value *CmpLHS, Value *CmpRHS,
                                               Value *TrueVal, Value *FalseVal,
                                               Value *&LHS, Value *&RHS) {
   LHS = CmpLHS;
   RHS = CmpRHS;
 
   // If the predicate is an "or-equal"  (FP) predicate, then signed zeroes may
   // return inconsistent results between implementations.
   //   (0.0 <= -0.0) ? 0.0 : -0.0 // Returns 0.0
   //   minNum(0.0, -0.0)          // May return -0.0 or 0.0 (IEEE 754-2008 5.3.1)
   // Therefore we behave conservatively and only proceed if at least one of the
   // operands is known to not be zero, or if we don't care about signed zeroes.
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default: break;
-  case CmpInst::FCMP_OGE: case CmpInst::FCMP_OLE:
-  case CmpInst::FCMP_UGE: case CmpInst::FCMP_ULE:
+  case Predicate::FCMP_OGE:
+  case Predicate::FCMP_OLE:
+  case Predicate::FCMP_UGE:
+  case Predicate::FCMP_ULE:
     if (!FMF.noSignedZeros() && !isKnownNonZero(CmpLHS) &&
         !isKnownNonZero(CmpRHS))
       return {SPF_UNKNOWN, SPNB_NA, false};
   }
 
   SelectPatternNaNBehavior NaNBehavior = SPNB_NA;
   bool Ordered = false;
 
   // When given one NaN and one non-NaN input:
   //   - maxnum/minnum (C99 fmaxf()/fminf()) return the non-NaN input.
   //   - A simple C99 (a < b ? a : b) construction will return 'b' (as the
   //     ordered comparison fails), which could be NaN or non-NaN.
   // so here we discover exactly what NaN behavior is required/accepted.
-  if (CmpInst::isFPPredicate(Pred)) {
+  if (Pred.isFP()) {
     bool LHSSafe = isKnownNonNaN(CmpLHS, FMF);
     bool RHSSafe = isKnownNonNaN(CmpRHS, FMF);
 
     if (LHSSafe && RHSSafe) {
       // Both operands are known non-NaN.
       NaNBehavior = SPNB_RETURNS_ANY;
-    } else if (CmpInst::isOrdered(Pred)) {
+    } else if (Pred.isOrdered()) {
       // An ordered comparison will return false when given a NaN, so it
       // returns the RHS.
       Ordered = true;
       if (LHSSafe)
         // LHS is non-NaN, so if RHS is NaN then NaN will be returned.
         NaNBehavior = SPNB_RETURNS_NAN;
       else if (RHSSafe)
         NaNBehavior = SPNB_RETURNS_OTHER;
if (LHSSafe && RHSSafe) {
       else
         // Completely unsafe.
         return {SPF_UNKNOWN, SPNB_NA, false};
     }
   }
 
   if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
     std::swap(CmpLHS, CmpRHS);
-    Pred = CmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
     if (NaNBehavior == SPNB_RETURNS_NAN)
       NaNBehavior = SPNB_RETURNS_OTHER;
     else if (NaNBehavior == SPNB_RETURNS_OTHER)
       NaNBehavior = SPNB_RETURNS_NAN;
     Ordered = !Ordered;
   }
 
   // ([if]cmp X, Y) ? X : Y
   if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
-    switch (Pred) {
+    switch (Pred.getKind()) {
     default: return {SPF_UNKNOWN, SPNB_NA, false}; // Equality.
-    case ICmpInst::ICMP_UGT:
-    case ICmpInst::ICMP_UGE: return {SPF_UMAX, SPNB_NA, false};
-    case ICmpInst::ICMP_SGT:
-    case ICmpInst::ICMP_SGE: return {SPF_SMAX, SPNB_NA, false};
-    case ICmpInst::ICMP_ULT:
-    case ICmpInst::ICMP_ULE: return {SPF_UMIN, SPNB_NA, false};
-    case ICmpInst::ICMP_SLT:
-    case ICmpInst::ICMP_SLE: return {SPF_SMIN, SPNB_NA, false};
-    case FCmpInst::FCMP_UGT:
-    case FCmpInst::FCMP_UGE:
-    case FCmpInst::FCMP_OGT:
-    case FCmpInst::FCMP_OGE: return {SPF_FMAXNUM, NaNBehavior, Ordered};
-    case FCmpInst::FCMP_ULT:
-    case FCmpInst::FCMP_ULE:
-    case FCmpInst::FCMP_OLT:
-    case FCmpInst::FCMP_OLE: return {SPF_FMINNUM, NaNBehavior, Ordered};
+    case Predicate::ICMP_UGT:
+    case Predicate::ICMP_UGE:
+      return {SPF_UMAX, SPNB_NA, false};
+    case Predicate::ICMP_SGT:
+    case Predicate::ICMP_SGE:
+      return {SPF_SMAX, SPNB_NA, false};
+    case Predicate::ICMP_ULT:
+    case Predicate::ICMP_ULE:
+      return {SPF_UMIN, SPNB_NA, false};
+    case Predicate::ICMP_SLT:
+    case Predicate::ICMP_SLE:
+      return {SPF_SMIN, SPNB_NA, false};
+    case Predicate::FCMP_UGT:
+    case Predicate::FCMP_UGE:
+    case Predicate::FCMP_OGT:
+    case Predicate::FCMP_OGE:
+      return {SPF_FMAXNUM, NaNBehavior, Ordered};
+    case Predicate::FCMP_ULT:
+    case Predicate::FCMP_ULE:
+    case Predicate::FCMP_OLT:
+    case Predicate::FCMP_OLE:
+      return {SPF_FMINNUM, NaNBehavior, Ordered};
     }
   }
 
   if (ConstantInt *C1 = dyn_cast<ConstantInt>(CmpRHS)) {
     if ((CmpLHS == TrueVal && match(FalseVal, m_Neg(m_Specific(CmpLHS)))) ||
         (CmpLHS == FalseVal && match(TrueVal, m_Neg(m_Specific(CmpLHS))))) {
 
       // ABS(X) ==> (X >s 0) ? X : -X and (X >s -1) ? X : -X
       // NABS(X) ==> (X >s 0) ? -X : X and (X >s -1) ? -X : X
-      if (Pred == ICmpInst::ICMP_SGT && (C1->isZero() || C1->isMinusOne())) {
+      if (Pred == Predicate::ICMP_SGT && (C1->isZero() || C1->isMinusOne())) {
         return {(CmpLHS == TrueVal) ? SPF_ABS : SPF_NABS, SPNB_NA, false};
       }
 
       // ABS(X) ==> (X <s 0) ? -X : X and (X <s 1) ? -X : X
       // NABS(X) ==> (X <s 0) ? X : -X and (X <s 1) ? X : -X
-      if (Pred == ICmpInst::ICMP_SLT && (C1->isZero() || C1->isOne())) {
+      if (Pred == Predicate::ICMP_SLT && (C1->isZero() || C1->isOne())) {
         return {(CmpLHS == FalseVal) ? SPF_ABS : SPF_NABS, SPNB_NA, false};
       }
     }
 
     // Y >s C ? ~Y : ~C == ~Y <s ~C ? ~Y : ~C = SMIN(~Y, ~C)
     if (const auto *C2 = dyn_cast<ConstantInt>(FalseVal)) {
-      if (Pred == ICmpInst::ICMP_SGT && C1->getType() == C2->getType() &&
+      if (Pred == Predicate::ICMP_SGT && C1->getType() == C2->getType() &&
           ~C1->getValue() == C2->getValue() &&
           (match(TrueVal, m_Not(m_Specific(CmpLHS))) ||
            match(CmpLHS, m_Not(m_Specific(TrueVal))))) {
         LHS = TrueVal;
         RHS = FalseVal;
         return {SPF_SMIN, SPNB_NA, false};
       }
     }

 SelectPatternResult llvm::matchSelectPattern(Value *V, Value *&LHS, Value *&RHS,
                                              Instruction::CastOps *CastOp) {
   SelectInst *SI = dyn_cast<SelectInst>(V);
   if (!SI) return {SPF_UNKNOWN, SPNB_NA, false};
 
   CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
   if (!CmpI) return {SPF_UNKNOWN, SPNB_NA, false};
 
-  CmpInst::Predicate Pred = CmpI->getPredicate();
+  Predicate Pred = CmpI->getPredicate();
   Value *CmpLHS = CmpI->getOperand(0);
   Value *CmpRHS = CmpI->getOperand(1);
   Value *TrueVal = SI->getTrueValue();
   Value *FalseVal = SI->getFalseValue();
   FastMathFlags FMF;
   if (isa<FPMathOperator>(CmpI))
     FMF = CmpI->getFastMathFlags();
 
for (unsigned i = 1; i < NumRanges; ++i) {
     // contained in any of the original N ranges.
     CR = CR.unionWith(ConstantRange(Low->getValue(), High->getValue()));
   }
 
   return CR;
 }
 
 /// Return true if "icmp Pred LHS RHS" is always true.
-static bool isTruePredicate(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
+static bool isTruePredicate(Predicate Pred, Value *LHS, Value *RHS,
                             const DataLayout &DL, unsigned Depth,
                             AssumptionCache *AC, const Instruction *CxtI,
                             const DominatorTree *DT) {
   assert(!LHS->getType()->isVectorTy() && "TODO: extend to handle vectors!");
-  if (ICmpInst::isTrueWhenEqual(Pred) && LHS == RHS)
+  if (Pred.isTrueWhenEqual() && LHS == RHS)
     return true;
 
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default:
     return false;
 
-  case CmpInst::ICMP_SLE: {
+  case Predicate::ICMP_SLE: {
     const APInt *C;
 
     // LHS s<= LHS +_{nsw} C   if C >= 0
     if (match(RHS, m_NSWAdd(m_Specific(LHS), m_APInt(C))))
       return !C->isNegative();
     return false;
   }
 
-  case CmpInst::ICMP_ULE: {
+  case Predicate::ICMP_ULE: {
     const APInt *C;
 
     // LHS u<= LHS +_{nuw} C   for any C
     if (match(RHS, m_NUWAdd(m_Specific(LHS), m_APInt(C))))
       return true;
 
     // Match A to (X +_{nuw} CA) and B to (X +_{nuw} CB)
     auto MatchNUWAddsToSameValue = [&](Value *A, Value *B, Value *&X,
case Predicate::ICMP_ULE: {
 
     return false;
   }
   }
 }
 
 /// Return true if "icmp Pred BLHS BRHS" is true whenever "icmp Pred
 /// ALHS ARHS" is true.  Otherwise, return None.
-static Optional<bool>
-isImpliedCondOperands(CmpInst::Predicate Pred, Value *ALHS, Value *ARHS,
-                      Value *BLHS, Value *BRHS, const DataLayout &DL,
+static Optional<bool> isImpliedCondOperands(Predicate Pred, Value *ALHS,
+                                            Value *ARHS, Value *BLHS,
+                                            Value *BRHS, const DataLayout &DL,
                                             unsigned Depth, AssumptionCache *AC,
-                      const Instruction *CxtI, const DominatorTree *DT) {
-  switch (Pred) {
+                                            const Instruction *CxtI,
+                                            const DominatorTree *DT) {
+  switch (Pred.getKind()) {
   default:
     return None;
 
-  case CmpInst::ICMP_SLT:
-  case CmpInst::ICMP_SLE:
-    if (isTruePredicate(CmpInst::ICMP_SLE, BLHS, ALHS, DL, Depth, AC, CxtI,
+  case Predicate::ICMP_SLT:
+  case Predicate::ICMP_SLE:
+    if (isTruePredicate(Predicate::ICMP_SLE, BLHS, ALHS, DL, Depth, AC, CxtI,
                         DT) &&
-        isTruePredicate(CmpInst::ICMP_SLE, ARHS, BRHS, DL, Depth, AC, CxtI, DT))
+        isTruePredicate(Predicate::ICMP_SLE, ARHS, BRHS, DL, Depth, AC, CxtI,
+                        DT))
       return true;
     return None;
 
-  case CmpInst::ICMP_ULT:
-  case CmpInst::ICMP_ULE:
-    if (isTruePredicate(CmpInst::ICMP_ULE, BLHS, ALHS, DL, Depth, AC, CxtI,
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_ULE:
+    if (isTruePredicate(Predicate::ICMP_ULE, BLHS, ALHS, DL, Depth, AC, CxtI,
                         DT) &&
-        isTruePredicate(CmpInst::ICMP_ULE, ARHS, BRHS, DL, Depth, AC, CxtI, DT))
+        isTruePredicate(Predicate::ICMP_ULE, ARHS, BRHS, DL, Depth, AC, CxtI,
+                        DT))
       return true;
     return None;
   }
 }
 
 /// Return true if the operands of the two compares match.  IsSwappedOps is true
 /// when the operands match, but are swapped.
 static bool isMatchingOps(Value *ALHS, Value *ARHS, Value *BLHS, Value *BRHS,
                           bool &IsSwappedOps) {
 
   bool IsMatchingOps = (ALHS == BLHS && ARHS == BRHS);
   IsSwappedOps = (ALHS == BRHS && ARHS == BLHS);
   return IsMatchingOps || IsSwappedOps;
 }
 
 /// Return true if "icmp1 APred ALHS ARHS" implies "icmp2 BPred BLHS BRHS" is
 /// true.  Return false if "icmp1 APred ALHS ARHS" implies "icmp2 BPred BLHS
 /// BRHS" is false.  Otherwise, return None if we can't infer anything.
-static Optional<bool> isImpliedCondMatchingOperands(CmpInst::Predicate APred,
+static Optional<bool> isImpliedCondMatchingOperands(Predicate APred,
                                                     Value *ALHS, Value *ARHS,
-                                                    CmpInst::Predicate BPred,
+                                                    Predicate BPred,
                                                     Value *BLHS, Value *BRHS,
                                                     bool IsSwappedOps) {
   // Canonicalize the operands so they're matching.
   if (IsSwappedOps) {
     std::swap(BLHS, BRHS);
-    BPred = ICmpInst::getSwappedPredicate(BPred);
+    BPred = BPred.getSwapped();
   }
-  if (CmpInst::isImpliedTrueByMatchingCmp(APred, BPred))
+  if (APred.isImpliedTrueByMatchingCmp(BPred))
     return true;
-  if (CmpInst::isImpliedFalseByMatchingCmp(APred, BPred))
+  if (APred.isImpliedFalseByMatchingCmp(BPred))
     return false;
 
   return None;
 }
 
 /// Return true if "icmp1 APred ALHS C1" implies "icmp2 BPred BLHS C2" is
 /// true.  Return false if "icmp1 APred ALHS C1" implies "icmp2 BPred BLHS
 /// C2" is false.  Otherwise, return None if we can't infer anything.
 static Optional<bool>
-isImpliedCondMatchingImmOperands(CmpInst::Predicate APred, Value *ALHS,
-                                 ConstantInt *C1, CmpInst::Predicate BPred,
-                                 Value *BLHS, ConstantInt *C2) {
+isImpliedCondMatchingImmOperands(Predicate APred, Value *ALHS, ConstantInt *C1,
+                                 Predicate BPred, Value *BLHS,
+                                 ConstantInt *C2) {
   assert(ALHS == BLHS && "LHS operands must match.");
   ConstantRange DomCR =
       ConstantRange::makeExactICmpRegion(APred, C1->getValue());
   ConstantRange CR =
       ConstantRange::makeAllowedICmpRegion(BPred, C2->getValue());
   ConstantRange Intersection = DomCR.intersectWith(CR);
   ConstantRange Difference = DomCR.difference(CR);
   if (Intersection.isEmptySet())
Optional<bool> llvm::isImpliedCondition(Value *LHS, Value *RHS,
   if (!InvertAPred && LHS == RHS)
     return true;
 
   if (OpTy->isVectorTy())
     // TODO: extending the code below to handle vectors
     return None;
   assert(OpTy->isIntegerTy(1) && "implied by above");
 
-  ICmpInst::Predicate APred, BPred;
+  Predicate APred, BPred;
   Value *ALHS, *ARHS;
   Value *BLHS, *BRHS;
 
   if (!match(LHS, m_ICmp(APred, m_Value(ALHS), m_Value(ARHS))) ||
       !match(RHS, m_ICmp(BPred, m_Value(BLHS), m_Value(BRHS))))
     return None;
 
   if (InvertAPred)
-    APred = CmpInst::getInversePredicate(APred);
+    APred = APred.getInverse();
 
   // Can we infer anything when the two compares have matching operands?
   bool IsSwappedOps;
   if (isMatchingOps(ALHS, ARHS, BLHS, BRHS, IsSwappedOps)) {
     if (Optional<bool> Implication = isImpliedCondMatchingOperands(
             APred, ALHS, ARHS, BPred, BLHS, BRHS, IsSwappedOps))
       return Implication;
     // No amount of additional analysis will infer the second condition, so

lib/AsmParser/LLParser.cpp

if (ParseCmpPredicate(PredVal, Opc) ||
         ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
         ParseGlobalTypeAndValue(Val1) ||
         ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
       return true;
 
     if (Val0->getType() != Val1->getType())
       return Error(ID.Loc, "compare operands must have the same type");
 
-    CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
+    Predicate Pred{PredVal};
 
     if (Opc == Instruction::FCmp) {
       if (!Val0->getType()->isFPOrFPVectorTy())
         return Error(ID.Loc, "fcmp requires floating point operands");
       ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
     } else {
       assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
       if (!Val0->getType()->isIntOrIntVectorTy() &&
int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
   }
 }
 
 /// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind.
 bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) {
   if (Opc == Instruction::FCmp) {
     switch (Lex.getKind()) {
     default: return TokError("expected fcmp predicate (e.g. 'oeq')");
-    case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
-    case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
-    case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
-    case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
-    case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
-    case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
-    case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
-    case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
-    case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
-    case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
-    case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
-    case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
-    case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
-    case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
-    case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
-    case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
+    case lltok::kw_oeq:
+      P = Predicate::FCMP_OEQ;
+      break;
+    case lltok::kw_one:
+      P = Predicate::FCMP_ONE;
+      break;
+    case lltok::kw_olt:
+      P = Predicate::FCMP_OLT;
+      break;
+    case lltok::kw_ogt:
+      P = Predicate::FCMP_OGT;
+      break;
+    case lltok::kw_ole:
+      P = Predicate::FCMP_OLE;
+      break;
+    case lltok::kw_oge:
+      P = Predicate::FCMP_OGE;
+      break;
+    case lltok::kw_ord:
+      P = Predicate::FCMP_ORD;
+      break;
+    case lltok::kw_uno:
+      P = Predicate::FCMP_UNO;
+      break;
+    case lltok::kw_ueq:
+      P = Predicate::FCMP_UEQ;
+      break;
+    case lltok::kw_une:
+      P = Predicate::FCMP_UNE;
+      break;
+    case lltok::kw_ult:
+      P = Predicate::FCMP_ULT;
+      break;
+    case lltok::kw_ugt:
+      P = Predicate::FCMP_UGT;
+      break;
+    case lltok::kw_ule:
+      P = Predicate::FCMP_ULE;
+      break;
+    case lltok::kw_uge:
+      P = Predicate::FCMP_UGE;
+      break;
+    case lltok::kw_true:
+      P = Predicate::FCMP_TRUE;
+      break;
+    case lltok::kw_false:
+      P = Predicate::FCMP_FALSE;
+      break;
     }
   } else {
     switch (Lex.getKind()) {
     default: return TokError("expected icmp predicate (e.g. 'eq')");
-    case lltok::kw_eq:  P = CmpInst::ICMP_EQ; break;
-    case lltok::kw_ne:  P = CmpInst::ICMP_NE; break;
-    case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
-    case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
-    case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
-    case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
-    case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
-    case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
-    case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
-    case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
+    case lltok::kw_eq:
+      P = Predicate::ICMP_EQ;
+      break;
+    case lltok::kw_ne:
+      P = Predicate::ICMP_NE;
+      break;
+    case lltok::kw_slt:
+      P = Predicate::ICMP_SLT;
+      break;
+    case lltok::kw_sgt:
+      P = Predicate::ICMP_SGT;
+      break;
+    case lltok::kw_sle:
+      P = Predicate::ICMP_SLE;
+      break;
+    case lltok::kw_sge:
+      P = Predicate::ICMP_SGE;
+      break;
+    case lltok::kw_ult:
+      P = Predicate::ICMP_ULT;
+      break;
+    case lltok::kw_ugt:
+      P = Predicate::ICMP_UGT;
+      break;
+    case lltok::kw_ule:
+      P = Predicate::ICMP_ULE;
+      break;
+    case lltok::kw_uge:
+      P = Predicate::ICMP_UGE;
+      break;
     }
   }
   Lex.Lex();
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Terminator Instructions.
if (ParseCmpPredicate(Pred, Opc) ||
       ParseTypeAndValue(LHS, Loc, PFS) ||
       ParseToken(lltok::comma, "expected ',' after compare value") ||
       ParseValue(LHS->getType(), RHS, PFS))
     return true;
 
   if (Opc == Instruction::FCmp) {
     if (!LHS->getType()->isFPOrFPVectorTy())
       return Error(Loc, "fcmp requires floating point operands");
-    Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS);
+    Inst = new FCmpInst(Predicate{Pred}, LHS, RHS);
   } else {
     assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
     if (!LHS->getType()->isIntOrIntVectorTy() &&
         !LHS->getType()->getScalarType()->isPointerTy())
       return Error(Loc, "icmp requires integer operands");
-    Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS);
+    Inst = new ICmpInst(Predicate{Pred}, LHS, RHS);
   }
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Other Instructions.
 //===----------------------------------------------------------------------===//
 

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::CST_CODE_CE_CMP: {     // CE_CMP: [opty, opval, opval, pred]
         return error("Invalid record");
       Type *OpTy = getTypeByID(Record[0]);
       if (!OpTy)
         return error("Invalid record");
       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
       Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
 
       if (OpTy->isFPOrFPVectorTy())
-        V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
+        V = ConstantExpr::getFCmp(static_cast<Predicate>(Record[3]), Op0, Op1);
       else
-        V = ConstantExpr::getICmp(Record[3], Op0, Op1);
+        V = ConstantExpr::getICmp(static_cast<Predicate>(Record[3]), Op0, Op1);
       break;
     }
     // This maintains backward compatibility, pre-asm dialect keywords.
     // FIXME: Remove with the 4.0 release.
     case bitc::CST_CODE_INLINEASM_OLD: {
       if (Record.size() < 2)
         return error("Invalid record");
       std::string AsmStr, ConstrStr;
case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
       // FCmp/ICmp returning bool or vector of bool
 
       unsigned OpNum = 0;
       Value *LHS, *RHS;
       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
           popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS))
         return error("Invalid record");
 
-      unsigned PredVal = Record[OpNum];
+      Predicate PredVal = static_cast<Predicate>(Record[OpNum]);
       bool IsFP = LHS->getType()->isFPOrFPVectorTy();
       FastMathFlags FMF;
       if (IsFP && Record.size() > OpNum+1)
         FMF = getDecodedFastMathFlags(Record[++OpNum]);
 
       if (OpNum+1 != Record.size())
         return error("Invalid record");
 
       if (LHS->getType()->isFPOrFPVectorTy())
-        I = new FCmpInst((FCmpInst::Predicate)PredVal, LHS, RHS);
+        I = new FCmpInst(PredVal, LHS, RHS);
       else
-        I = new ICmpInst((ICmpInst::Predicate)PredVal, LHS, RHS);
+        I = new ICmpInst(PredVal, LHS, RHS);
 
       if (FMF.any())
         I->setFastMathFlags(FMF);
       InstructionList.push_back(I);
       break;
     }
 
     case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]

lib/Bitcode/Writer/BitcodeWriter.cpp

if (C->isNullValue()) {
         Record.push_back(VE.getValueID(C->getOperand(2)));
         break;
       case Instruction::ICmp:
       case Instruction::FCmp:
         Code = bitc::CST_CODE_CE_CMP;
         Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
         Record.push_back(VE.getValueID(C->getOperand(0)));
         Record.push_back(VE.getValueID(C->getOperand(1)));
-        Record.push_back(CE->getPredicate());
+        Record.push_back(CE->getPredicate().getKind());
         break;
       }
     } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
       Code = bitc::CST_CODE_BLOCKADDRESS;
       Record.push_back(VE.getTypeID(BA->getFunction()->getType()));
       Record.push_back(VE.getValueID(BA->getFunction()));
       Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock()));
     } else {
case Instruction::ShuffleVector:
     pushValue(I.getOperand(2), InstID, Vals);
     break;
   case Instruction::ICmp:
   case Instruction::FCmp: {
     // compare returning Int1Ty or vector of Int1Ty
     Code = bitc::FUNC_CODE_INST_CMP2;
     pushValueAndType(I.getOperand(0), InstID, Vals);
     pushValue(I.getOperand(1), InstID, Vals);
-    Vals.push_back(cast<CmpInst>(I).getPredicate());
+    Vals.push_back(cast<CmpInst>(I).getPredicate().getKind());
     uint64_t Flags = getOptimizationFlags(&I);
     if (Flags != 0)
       Vals.push_back(Flags);
     break;
   }
 
   case Instruction::Ret:
     {

lib/CodeGen/Analysis.cpp

llvm::hasInlineAsmMemConstraint(InlineAsm::ConstraintInfoVector &CInfos,
 
   return false;
 }
 
 /// getFCmpCondCode - Return the ISD condition code corresponding to
 /// the given LLVM IR floating-point condition code.  This includes
 /// consideration of global floating-point math flags.
 ///
-ISD::CondCode llvm::getFCmpCondCode(FCmpInst::Predicate Pred) {
-  switch (Pred) {
-  case FCmpInst::FCMP_FALSE: return ISD::SETFALSE;
-  case FCmpInst::FCMP_OEQ:   return ISD::SETOEQ;
-  case FCmpInst::FCMP_OGT:   return ISD::SETOGT;
-  case FCmpInst::FCMP_OGE:   return ISD::SETOGE;
-  case FCmpInst::FCMP_OLT:   return ISD::SETOLT;
-  case FCmpInst::FCMP_OLE:   return ISD::SETOLE;
-  case FCmpInst::FCMP_ONE:   return ISD::SETONE;
-  case FCmpInst::FCMP_ORD:   return ISD::SETO;
-  case FCmpInst::FCMP_UNO:   return ISD::SETUO;
-  case FCmpInst::FCMP_UEQ:   return ISD::SETUEQ;
-  case FCmpInst::FCMP_UGT:   return ISD::SETUGT;
-  case FCmpInst::FCMP_UGE:   return ISD::SETUGE;
-  case FCmpInst::FCMP_ULT:   return ISD::SETULT;
-  case FCmpInst::FCMP_ULE:   return ISD::SETULE;
-  case FCmpInst::FCMP_UNE:   return ISD::SETUNE;
-  case FCmpInst::FCMP_TRUE:  return ISD::SETTRUE;
+ISD::CondCode llvm::getFCmpCondCode(Predicate Pred) {
+  switch (Pred.getKind()) {
+  case Predicate::FCMP_FALSE:
+    return ISD::SETFALSE;
+  case Predicate::FCMP_OEQ:
+    return ISD::SETOEQ;
+  case Predicate::FCMP_OGT:
+    return ISD::SETOGT;
+  case Predicate::FCMP_OGE:
+    return ISD::SETOGE;
+  case Predicate::FCMP_OLT:
+    return ISD::SETOLT;
+  case Predicate::FCMP_OLE:
+    return ISD::SETOLE;
+  case Predicate::FCMP_ONE:
+    return ISD::SETONE;
+  case Predicate::FCMP_ORD:
+    return ISD::SETO;
+  case Predicate::FCMP_UNO:
+    return ISD::SETUO;
+  case Predicate::FCMP_UEQ:
+    return ISD::SETUEQ;
+  case Predicate::FCMP_UGT:
+    return ISD::SETUGT;
+  case Predicate::FCMP_UGE:
+    return ISD::SETUGE;
+  case Predicate::FCMP_ULT:
+    return ISD::SETULT;
+  case Predicate::FCMP_ULE:
+    return ISD::SETULE;
+  case Predicate::FCMP_UNE:
+    return ISD::SETUNE;
+  case Predicate::FCMP_TRUE:
+    return ISD::SETTRUE;
   default: llvm_unreachable("Invalid FCmp predicate opcode!");
   }
 }
 
 ISD::CondCode llvm::getFCmpCodeWithoutNaN(ISD::CondCode CC) {
   switch (CC) {
     case ISD::SETOEQ: case ISD::SETUEQ: return ISD::SETEQ;
     case ISD::SETONE: case ISD::SETUNE: return ISD::SETNE;
     case ISD::SETOLT: case ISD::SETULT: return ISD::SETLT;
     case ISD::SETOLE: case ISD::SETULE: return ISD::SETLE;
     case ISD::SETOGT: case ISD::SETUGT: return ISD::SETGT;
     case ISD::SETOGE: case ISD::SETUGE: return ISD::SETGE;
     default: return CC;
   }
 }
 
 /// getICmpCondCode - Return the ISD condition code corresponding to
 /// the given LLVM IR integer condition code.
 ///
-ISD::CondCode llvm::getICmpCondCode(ICmpInst::Predicate Pred) {
-  switch (Pred) {
-  case ICmpInst::ICMP_EQ:  return ISD::SETEQ;
-  case ICmpInst::ICMP_NE:  return ISD::SETNE;
-  case ICmpInst::ICMP_SLE: return ISD::SETLE;
-  case ICmpInst::ICMP_ULE: return ISD::SETULE;
-  case ICmpInst::ICMP_SGE: return ISD::SETGE;
-  case ICmpInst::ICMP_UGE: return ISD::SETUGE;
-  case ICmpInst::ICMP_SLT: return ISD::SETLT;
-  case ICmpInst::ICMP_ULT: return ISD::SETULT;
-  case ICmpInst::ICMP_SGT: return ISD::SETGT;
-  case ICmpInst::ICMP_UGT: return ISD::SETUGT;
+ISD::CondCode llvm::getICmpCondCode(Predicate Pred) {
+  switch (Pred.getKind()) {
+  case Predicate::ICMP_EQ:
+    return ISD::SETEQ;
+  case Predicate::ICMP_NE:
+    return ISD::SETNE;
+  case Predicate::ICMP_SLE:
+    return ISD::SETLE;
+  case Predicate::ICMP_ULE:
+    return ISD::SETULE;
+  case Predicate::ICMP_SGE:
+    return ISD::SETGE;
+  case Predicate::ICMP_UGE:
+    return ISD::SETUGE;
+  case Predicate::ICMP_SLT:
+    return ISD::SETLT;
+  case Predicate::ICMP_ULT:
+    return ISD::SETULT;
+  case Predicate::ICMP_SGT:
+    return ISD::SETGT;
+  case Predicate::ICMP_UGT:
+    return ISD::SETUGT;
   default:
     llvm_unreachable("Invalid ICmp predicate opcode!");
   }
 }
 
 static bool isNoopBitcast(Type *T1, Type *T2,
                           const TargetLoweringBase& TLI) {
   return T1 == T2 || (T1->isPointerTy() && T2->isPointerTy()) ||

lib/CodeGen/CodeGenPrepare.cpp

if (Idx > 0) {
       Phi = Builder.CreatePHI(VecType, 2, "res.phi.else");
       Phi->addIncoming(VResult, CondBlock);
       Phi->addIncoming(PrevPhi, PrevIfBlock);
       PrevPhi = Phi;
       VResult = Phi;
     }
 
     Value *Predicate = Builder.CreateExtractElement(Mask, Builder.getInt32(Idx));
-    Value *Cmp = Builder.CreateICmp(ICmpInst::ICMP_EQ, Predicate,
+    Value *Cmp = Builder.CreateICmp(Predicate::ICMP_EQ, Predicate,
                                     ConstantInt::get(Predicate->getType(), 1));
 
     // Create "cond" block
     //
     //  %EltAddr = getelementptr i32* %1, i32 0
     //  %Elt = load i32* %EltAddr
     //  VResult = insertelement <16 x i32> VResult, i32 %Elt, i32 Idx
     //
for (unsigned Idx = 0; Idx < VectorWidth; ++Idx) {
 
     // Fill the "else" block, created in the previous iteration
     //
     //  %mask_1 = extractelement <16 x i1> %mask, i32 Idx
     //  %to_store = icmp eq i1 %mask_1, true
     //  br i1 %to_store, label %cond.store, label %else
     //
     Value *Predicate = Builder.CreateExtractElement(Mask, Builder.getInt32(Idx));
-    Value *Cmp = Builder.CreateICmp(ICmpInst::ICMP_EQ, Predicate,
+    Value *Cmp = Builder.CreateICmp(Predicate::ICMP_EQ, Predicate,
                                     ConstantInt::get(Predicate->getType(), 1));
 
     // Create "cond" block
     //
     //  %OneElt = extractelement <16 x i32> %Src, i32 Idx
     //  %EltAddr = getelementptr i32* %1, i32 0
     //  %store i32 %OneElt, i32* %EltAddr
     //
if (Idx > 0) {
       Phi->addIncoming(PrevPhi, PrevIfBlock);
       PrevPhi = Phi;
       VResult = Phi;
     }
 
     Value *Predicate = Builder.CreateExtractElement(Mask,
                                                     Builder.getInt32(Idx),
                                                     "Mask" + Twine(Idx));
-    Value *Cmp = Builder.CreateICmp(ICmpInst::ICMP_EQ, Predicate,
+    Value *Cmp = Builder.CreateICmp(Predicate::ICMP_EQ, Predicate,
                                     ConstantInt::get(Predicate->getType(), 1),
                                     "ToLoad" + Twine(Idx));
 
     // Create "cond" block
     //
     //  %EltAddr = getelementptr i32* %1, i32 0
     //  %Elt = load i32* %EltAddr
     //  VResult = insertelement <16 x i32> VResult, i32 %Elt, i32 Idx
for (unsigned Idx = 0; Idx < VectorWidth; ++Idx) {
     //
     //  % Mask1 = extractelement <16 x i1> % Mask, i32 Idx
     //  % ToStore = icmp eq i1 % Mask1, true
     //  br i1 % ToStore, label %cond.store, label %else
     //
     Value *Predicate = Builder.CreateExtractElement(Mask,
                                                     Builder.getInt32(Idx),
                                                     "Mask" + Twine(Idx));
-    Value *Cmp =
-       Builder.CreateICmp(ICmpInst::ICMP_EQ, Predicate,
+    Value *Cmp = Builder.CreateICmp(Predicate::ICMP_EQ, Predicate,
                                     ConstantInt::get(Predicate->getType(), 1),
                                     "ToStore" + Twine(Idx));
 
     // Create "cond" block
     //
     //  % Elt1 = extractelement <16 x i32> %Src, i32 1
     //  % Ptr1 = extractelement <16 x i32*> %Ptrs, i32 1
     //  %store i32 % Elt1, i32* % Ptr1
     //
     BasicBlock *CondBlock = IfBlock->splitBasicBlock(InsertPt, "cond.store");

lib/CodeGen/SelectionDAG/FastISel.cpp

if (IsNonTemporal)
     Flags |= MachineMemOperand::MONonTemporal;
   if (IsInvariant)
     Flags |= MachineMemOperand::MOInvariant;
 
   return FuncInfo.MF->getMachineMemOperand(MachinePointerInfo(Ptr), Flags, Size,
                                            Alignment, AAInfo, Ranges);
 }
 
-CmpInst::Predicate FastISel::optimizeCmpPredicate(const CmpInst *CI) const {
+Predicate FastISel::optimizeCmpPredicate(const CmpInst *CI) const {
   // If both operands are the same, then try to optimize or fold the cmp.
-  CmpInst::Predicate Predicate = CI->getPredicate();
+  Predicate Pred = CI->getPredicate();
   if (CI->getOperand(0) != CI->getOperand(1))
-    return Predicate;
+    return Pred;
 
-  switch (Predicate) {
+  switch (Pred.getKind()) {
   default: llvm_unreachable("Invalid predicate!");
-  case CmpInst::FCMP_FALSE: Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::FCMP_OEQ:   Predicate = CmpInst::FCMP_ORD;   break;
-  case CmpInst::FCMP_OGT:   Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::FCMP_OGE:   Predicate = CmpInst::FCMP_ORD;   break;
-  case CmpInst::FCMP_OLT:   Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::FCMP_OLE:   Predicate = CmpInst::FCMP_ORD;   break;
-  case CmpInst::FCMP_ONE:   Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::FCMP_ORD:   Predicate = CmpInst::FCMP_ORD;   break;
-  case CmpInst::FCMP_UNO:   Predicate = CmpInst::FCMP_UNO;   break;
-  case CmpInst::FCMP_UEQ:   Predicate = CmpInst::FCMP_TRUE;  break;
-  case CmpInst::FCMP_UGT:   Predicate = CmpInst::FCMP_UNO;   break;
-  case CmpInst::FCMP_UGE:   Predicate = CmpInst::FCMP_TRUE;  break;
-  case CmpInst::FCMP_ULT:   Predicate = CmpInst::FCMP_UNO;   break;
-  case CmpInst::FCMP_ULE:   Predicate = CmpInst::FCMP_TRUE;  break;
-  case CmpInst::FCMP_UNE:   Predicate = CmpInst::FCMP_UNO;   break;
-  case CmpInst::FCMP_TRUE:  Predicate = CmpInst::FCMP_TRUE;  break;
-
-  case CmpInst::ICMP_EQ:    Predicate = CmpInst::FCMP_TRUE;  break;
-  case CmpInst::ICMP_NE:    Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::ICMP_UGT:   Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::ICMP_UGE:   Predicate = CmpInst::FCMP_TRUE;  break;
-  case CmpInst::ICMP_ULT:   Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::ICMP_ULE:   Predicate = CmpInst::FCMP_TRUE;  break;
-  case CmpInst::ICMP_SGT:   Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::ICMP_SGE:   Predicate = CmpInst::FCMP_TRUE;  break;
-  case CmpInst::ICMP_SLT:   Predicate = CmpInst::FCMP_FALSE; break;
-  case CmpInst::ICMP_SLE:   Predicate = CmpInst::FCMP_TRUE;  break;
+  case Predicate::FCMP_FALSE:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::FCMP_OEQ:
+    Pred = Predicate::FCMP_ORD;
+    break;
+  case Predicate::FCMP_OGT:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::FCMP_OGE:
+    Pred = Predicate::FCMP_ORD;
+    break;
+  case Predicate::FCMP_OLT:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::FCMP_OLE:
+    Pred = Predicate::FCMP_ORD;
+    break;
+  case Predicate::FCMP_ONE:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::FCMP_ORD:
+    Pred = Predicate::FCMP_ORD;
+    break;
+  case Predicate::FCMP_UNO:
+    Pred = Predicate::FCMP_UNO;
+    break;
+  case Predicate::FCMP_UEQ:
+    Pred = Predicate::FCMP_TRUE;
+    break;
+  case Predicate::FCMP_UGT:
+    Pred = Predicate::FCMP_UNO;
+    break;
+  case Predicate::FCMP_UGE:
+    Pred = Predicate::FCMP_TRUE;
+    break;
+  case Predicate::FCMP_ULT:
+    Pred = Predicate::FCMP_UNO;
+    break;
+  case Predicate::FCMP_ULE:
+    Pred = Predicate::FCMP_TRUE;
+    break;
+  case Predicate::FCMP_UNE:
+    Pred = Predicate::FCMP_UNO;
+    break;
+  case Predicate::FCMP_TRUE:
+    Pred = Predicate::FCMP_TRUE;
+    break;
+
+  case Predicate::ICMP_EQ:
+    Pred = Predicate::FCMP_TRUE;
+    break;
+  case Predicate::ICMP_NE:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::ICMP_UGT:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::ICMP_UGE:
+    Pred = Predicate::FCMP_TRUE;
+    break;
+  case Predicate::ICMP_ULT:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::ICMP_ULE:
+    Pred = Predicate::FCMP_TRUE;
+    break;
+  case Predicate::ICMP_SGT:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::ICMP_SGE:
+    Pred = Predicate::FCMP_TRUE;
+    break;
+  case Predicate::ICMP_SLT:
+    Pred = Predicate::FCMP_FALSE;
+    break;
+  case Predicate::ICMP_SLE:
+    Pred = Predicate::FCMP_TRUE;
+    break;
   }
 
-  return Predicate;
+  return Pred;
 }

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitSDiv(const User &I) {
   SDNodeFlags Flags;
   Flags.setExact(isa<PossiblyExactOperator>(&I) &&
                  cast<PossiblyExactOperator>(&I)->isExact());
   setValue(&I, DAG.getNode(ISD::SDIV, getCurSDLoc(), Op1.getValueType(), Op1,
                            Op2, &Flags));
 }
 
 void SelectionDAGBuilder::visitICmp(const User &I) {
-  ICmpInst::Predicate predicate = ICmpInst::BAD_ICMP_PREDICATE;
+  Predicate Pred = Predicate::BAD_ICMP_PREDICATE;
   if (const ICmpInst *IC = dyn_cast<ICmpInst>(&I))
-    predicate = IC->getPredicate();
+    Pred = IC->getPredicate();
   else if (const ConstantExpr *IC = dyn_cast<ConstantExpr>(&I))
-    predicate = ICmpInst::Predicate(IC->getPredicate());
+    Pred = IC->getPredicate();
   SDValue Op1 = getValue(I.getOperand(0));
   SDValue Op2 = getValue(I.getOperand(1));
-  ISD::CondCode Opcode = getICmpCondCode(predicate);
+  ISD::CondCode Opcode = getICmpCondCode(Pred);
 
   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
                                                         I.getType());
   setValue(&I, DAG.getSetCC(getCurSDLoc(), DestVT, Op1, Op2, Opcode));
 }
 
 void SelectionDAGBuilder::visitFCmp(const User &I) {
-  FCmpInst::Predicate predicate = FCmpInst::BAD_FCMP_PREDICATE;
+  Predicate Pred = Predicate::BAD_FCMP_PREDICATE;
   if (const FCmpInst *FC = dyn_cast<FCmpInst>(&I))
-    predicate = FC->getPredicate();
+    Pred = FC->getPredicate();
   else if (const ConstantExpr *FC = dyn_cast<ConstantExpr>(&I))
-    predicate = FCmpInst::Predicate(FC->getPredicate());
+    Pred = FC->getPredicate();
   SDValue Op1 = getValue(I.getOperand(0));
   SDValue Op2 = getValue(I.getOperand(1));
-  ISD::CondCode Condition = getFCmpCondCode(predicate);
+  ISD::CondCode Condition = getFCmpCondCode(Pred);
 
   // FIXME: Fcmp instructions have fast-math-flags in IR, so we should use them.
   // FIXME: We should propagate the fast-math-flags to the DAG node itself for
   // further optimization, but currently FMF is only applicable to binary nodes.
   if (TM.Options.NoNaNsFPMath)
     Condition = getFCmpCodeWithoutNaN(Condition);
   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
                                                         I.getType());

lib/ExecutionEngine/Interpreter/Execution.cpp

 }
 
 void Interpreter::visitICmpInst(ICmpInst &I) {
   ExecutionContext &SF = ECStack.back();
   Type *Ty    = I.getOperand(0)->getType();
   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
   GenericValue R;   // Result
-  
-  switch (I.getPredicate()) {
-  case ICmpInst::ICMP_EQ:  R = executeICMP_EQ(Src1,  Src2, Ty); break;
-  case ICmpInst::ICMP_NE:  R = executeICMP_NE(Src1,  Src2, Ty); break;
-  case ICmpInst::ICMP_ULT: R = executeICMP_ULT(Src1, Src2, Ty); break;
-  case ICmpInst::ICMP_SLT: R = executeICMP_SLT(Src1, Src2, Ty); break;
-  case ICmpInst::ICMP_UGT: R = executeICMP_UGT(Src1, Src2, Ty); break;
-  case ICmpInst::ICMP_SGT: R = executeICMP_SGT(Src1, Src2, Ty); break;
-  case ICmpInst::ICMP_ULE: R = executeICMP_ULE(Src1, Src2, Ty); break;
-  case ICmpInst::ICMP_SLE: R = executeICMP_SLE(Src1, Src2, Ty); break;
-  case ICmpInst::ICMP_UGE: R = executeICMP_UGE(Src1, Src2, Ty); break;
-  case ICmpInst::ICMP_SGE: R = executeICMP_SGE(Src1, Src2, Ty); break;
+  switch (I.getPredicate().getKind()) {
+  case Predicate::ICMP_EQ:
+    R = executeICMP_EQ(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_NE:
+    R = executeICMP_NE(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_ULT:
+    R = executeICMP_ULT(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_SLT:
+    R = executeICMP_SLT(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_UGT:
+    R = executeICMP_UGT(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_SGT:
+    R = executeICMP_SGT(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_ULE:
+    R = executeICMP_ULE(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_SLE:
+    R = executeICMP_SLE(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_UGE:
+    R = executeICMP_UGE(Src1, Src2, Ty);
+    break;
+  case Predicate::ICMP_SGE:
+    R = executeICMP_SGE(Src1, Src2, Ty);
+    break;
   default:
     dbgs() << "Don't know how to handle this ICmp predicate!\n-->" << I;
     llvm_unreachable(nullptr);
   }
  
   SetValue(&I, R, SF);
 }
 

 }
 
 void Interpreter::visitFCmpInst(FCmpInst &I) {
   ExecutionContext &SF = ECStack.back();
   Type *Ty    = I.getOperand(0)->getType();
   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
   GenericValue R;   // Result
-  
-  switch (I.getPredicate()) {
+  switch (I.getPredicate().getKind()) {
   default:
     dbgs() << "Don't know how to handle this FCmp predicate!\n-->" << I;
     llvm_unreachable(nullptr);
   break;
-  case FCmpInst::FCMP_FALSE: R = executeFCMP_BOOL(Src1, Src2, Ty, false); 
+  case Predicate::FCMP_FALSE:
+    R = executeFCMP_BOOL(Src1, Src2, Ty, false);
+    break;
+  case Predicate::FCMP_TRUE:
+    R = executeFCMP_BOOL(Src1, Src2, Ty, true);
+    break;
+  case Predicate::FCMP_ORD:
+    R = executeFCMP_ORD(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_UNO:
+    R = executeFCMP_UNO(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_UEQ:
+    R = executeFCMP_UEQ(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_OEQ:
+    R = executeFCMP_OEQ(Src1, Src2, Ty);
     break;
-  case FCmpInst::FCMP_TRUE:  R = executeFCMP_BOOL(Src1, Src2, Ty, true); 
+  case Predicate::FCMP_UNE:
+    R = executeFCMP_UNE(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_ONE:
+    R = executeFCMP_ONE(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_ULT:
+    R = executeFCMP_ULT(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_OLT:
+    R = executeFCMP_OLT(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_UGT:
+    R = executeFCMP_UGT(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_OGT:
+    R = executeFCMP_OGT(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_ULE:
+    R = executeFCMP_ULE(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_OLE:
+    R = executeFCMP_OLE(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_UGE:
+    R = executeFCMP_UGE(Src1, Src2, Ty);
+    break;
+  case Predicate::FCMP_OGE:
+    R = executeFCMP_OGE(Src1, Src2, Ty);
     break;
-  case FCmpInst::FCMP_ORD:   R = executeFCMP_ORD(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_UNO:   R = executeFCMP_UNO(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_UEQ:   R = executeFCMP_UEQ(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_OEQ:   R = executeFCMP_OEQ(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_UNE:   R = executeFCMP_UNE(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_ONE:   R = executeFCMP_ONE(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_ULT:   R = executeFCMP_ULT(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_OLT:   R = executeFCMP_OLT(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_UGT:   R = executeFCMP_UGT(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_OGT:   R = executeFCMP_OGT(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_ULE:   R = executeFCMP_ULE(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_OLE:   R = executeFCMP_OLE(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_UGE:   R = executeFCMP_UGE(Src1, Src2, Ty); break;
-  case FCmpInst::FCMP_OGE:   R = executeFCMP_OGE(Src1, Src2, Ty); break;
   }
  
   SetValue(&I, R, SF);
 }
 
-static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1, 
+static GenericValue executeCmpInst(Predicate predicate, GenericValue Src1,
                                    GenericValue Src2, Type *Ty) {
   GenericValue Result;
-  switch (predicate) {
-  case ICmpInst::ICMP_EQ:    return executeICMP_EQ(Src1, Src2, Ty);
-  case ICmpInst::ICMP_NE:    return executeICMP_NE(Src1, Src2, Ty);
-  case ICmpInst::ICMP_UGT:   return executeICMP_UGT(Src1, Src2, Ty);
-  case ICmpInst::ICMP_SGT:   return executeICMP_SGT(Src1, Src2, Ty);
-  case ICmpInst::ICMP_ULT:   return executeICMP_ULT(Src1, Src2, Ty);
-  case ICmpInst::ICMP_SLT:   return executeICMP_SLT(Src1, Src2, Ty);
-  case ICmpInst::ICMP_UGE:   return executeICMP_UGE(Src1, Src2, Ty);
-  case ICmpInst::ICMP_SGE:   return executeICMP_SGE(Src1, Src2, Ty);
-  case ICmpInst::ICMP_ULE:   return executeICMP_ULE(Src1, Src2, Ty);
-  case ICmpInst::ICMP_SLE:   return executeICMP_SLE(Src1, Src2, Ty);
-  case FCmpInst::FCMP_ORD:   return executeFCMP_ORD(Src1, Src2, Ty);
-  case FCmpInst::FCMP_UNO:   return executeFCMP_UNO(Src1, Src2, Ty);
-  case FCmpInst::FCMP_OEQ:   return executeFCMP_OEQ(Src1, Src2, Ty);
-  case FCmpInst::FCMP_UEQ:   return executeFCMP_UEQ(Src1, Src2, Ty);
-  case FCmpInst::FCMP_ONE:   return executeFCMP_ONE(Src1, Src2, Ty);
-  case FCmpInst::FCMP_UNE:   return executeFCMP_UNE(Src1, Src2, Ty);
-  case FCmpInst::FCMP_OLT:   return executeFCMP_OLT(Src1, Src2, Ty);
-  case FCmpInst::FCMP_ULT:   return executeFCMP_ULT(Src1, Src2, Ty);
-  case FCmpInst::FCMP_OGT:   return executeFCMP_OGT(Src1, Src2, Ty);
-  case FCmpInst::FCMP_UGT:   return executeFCMP_UGT(Src1, Src2, Ty);
-  case FCmpInst::FCMP_OLE:   return executeFCMP_OLE(Src1, Src2, Ty);
-  case FCmpInst::FCMP_ULE:   return executeFCMP_ULE(Src1, Src2, Ty);
-  case FCmpInst::FCMP_OGE:   return executeFCMP_OGE(Src1, Src2, Ty);
-  case FCmpInst::FCMP_UGE:   return executeFCMP_UGE(Src1, Src2, Ty);
-  case FCmpInst::FCMP_FALSE: return executeFCMP_BOOL(Src1, Src2, Ty, false);
-  case FCmpInst::FCMP_TRUE:  return executeFCMP_BOOL(Src1, Src2, Ty, true);
+  switch (predicate.getKind()) {
+  case Predicate::ICMP_EQ:
+    return executeICMP_EQ(Src1, Src2, Ty);
+  case Predicate::ICMP_NE:
+    return executeICMP_NE(Src1, Src2, Ty);
+  case Predicate::ICMP_UGT:
+    return executeICMP_UGT(Src1, Src2, Ty);
+  case Predicate::ICMP_SGT:
+    return executeICMP_SGT(Src1, Src2, Ty);
+  case Predicate::ICMP_ULT:
+    return executeICMP_ULT(Src1, Src2, Ty);
+  case Predicate::ICMP_SLT:
+    return executeICMP_SLT(Src1, Src2, Ty);
+  case Predicate::ICMP_UGE:
+    return executeICMP_UGE(Src1, Src2, Ty);
+  case Predicate::ICMP_SGE:
+    return executeICMP_SGE(Src1, Src2, Ty);
+  case Predicate::ICMP_ULE:
+    return executeICMP_ULE(Src1, Src2, Ty);
+  case Predicate::ICMP_SLE:
+    return executeICMP_SLE(Src1, Src2, Ty);
+  case Predicate::FCMP_ORD:
+    return executeFCMP_ORD(Src1, Src2, Ty);
+  case Predicate::FCMP_UNO:
+    return executeFCMP_UNO(Src1, Src2, Ty);
+  case Predicate::FCMP_OEQ:
+    return executeFCMP_OEQ(Src1, Src2, Ty);
+  case Predicate::FCMP_UEQ:
+    return executeFCMP_UEQ(Src1, Src2, Ty);
+  case Predicate::FCMP_ONE:
+    return executeFCMP_ONE(Src1, Src2, Ty);
+  case Predicate::FCMP_UNE:
+    return executeFCMP_UNE(Src1, Src2, Ty);
+  case Predicate::FCMP_OLT:
+    return executeFCMP_OLT(Src1, Src2, Ty);
+  case Predicate::FCMP_ULT:
+    return executeFCMP_ULT(Src1, Src2, Ty);
+  case Predicate::FCMP_OGT:
+    return executeFCMP_OGT(Src1, Src2, Ty);
+  case Predicate::FCMP_UGT:
+    return executeFCMP_UGT(Src1, Src2, Ty);
+  case Predicate::FCMP_OLE:
+    return executeFCMP_OLE(Src1, Src2, Ty);
+  case Predicate::FCMP_ULE:
+    return executeFCMP_ULE(Src1, Src2, Ty);
+  case Predicate::FCMP_OGE:
+    return executeFCMP_OGE(Src1, Src2, Ty);
+  case Predicate::FCMP_UGE:
+    return executeFCMP_UGE(Src1, Src2, Ty);
+  case Predicate::FCMP_FALSE:
+    return executeFCMP_BOOL(Src1, Src2, Ty, false);
+  case Predicate::FCMP_TRUE:
+    return executeFCMP_BOOL(Src1, Src2, Ty, true);
   default:
     dbgs() << "Unhandled Cmp predicate\n";
     llvm_unreachable(nullptr);
   }
 }
 
 void Interpreter::visitBinaryOperator(BinaryOperator &I) {
   ExecutionContext &SF = ECStack.back();

lib/IR/AsmWriter.cpp

static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
                                    SlotTracker *Machine,
                                    const Module *Context);
 
 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
                                    TypePrinting *TypePrinter,
                                    SlotTracker *Machine, const Module *Context,
                                    bool FromValue = false);
 
-static const char *getPredicateText(unsigned predicate) {
-  const char * pred = "unknown";
-  switch (predicate) {
-  case FCmpInst::FCMP_FALSE: pred = "false"; break;
-  case FCmpInst::FCMP_OEQ:   pred = "oeq"; break;
-  case FCmpInst::FCMP_OGT:   pred = "ogt"; break;
-  case FCmpInst::FCMP_OGE:   pred = "oge"; break;
-  case FCmpInst::FCMP_OLT:   pred = "olt"; break;
-  case FCmpInst::FCMP_OLE:   pred = "ole"; break;
-  case FCmpInst::FCMP_ONE:   pred = "one"; break;
-  case FCmpInst::FCMP_ORD:   pred = "ord"; break;
-  case FCmpInst::FCMP_UNO:   pred = "uno"; break;
-  case FCmpInst::FCMP_UEQ:   pred = "ueq"; break;
-  case FCmpInst::FCMP_UGT:   pred = "ugt"; break;
-  case FCmpInst::FCMP_UGE:   pred = "uge"; break;
-  case FCmpInst::FCMP_ULT:   pred = "ult"; break;
-  case FCmpInst::FCMP_ULE:   pred = "ule"; break;
-  case FCmpInst::FCMP_UNE:   pred = "une"; break;
-  case FCmpInst::FCMP_TRUE:  pred = "true"; break;
-  case ICmpInst::ICMP_EQ:    pred = "eq"; break;
-  case ICmpInst::ICMP_NE:    pred = "ne"; break;
-  case ICmpInst::ICMP_SGT:   pred = "sgt"; break;
-  case ICmpInst::ICMP_SGE:   pred = "sge"; break;
-  case ICmpInst::ICMP_SLT:   pred = "slt"; break;
-  case ICmpInst::ICMP_SLE:   pred = "sle"; break;
-  case ICmpInst::ICMP_UGT:   pred = "ugt"; break;
-  case ICmpInst::ICMP_UGE:   pred = "uge"; break;
-  case ICmpInst::ICMP_ULT:   pred = "ult"; break;
-  case ICmpInst::ICMP_ULE:   pred = "ule"; break;
-  }
-  return pred;
-}
-
 static void writeAtomicRMWOperation(raw_ostream &Out,
                                     AtomicRMWInst::BinOp Op) {
   switch (Op) {
   default: Out << " <unknown operation " << Op << ">"; break;
   case AtomicRMWInst::Xchg: Out << " xchg"; break;
   case AtomicRMWInst::Add:  Out << " add"; break;
   case AtomicRMWInst::Sub:  Out << " sub"; break;
   case AtomicRMWInst::And:  Out << " and"; break;
if (isa<UndefValue>(CV)) {
     Out << "undef";
     return;
   }
 
   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
     Out << CE->getOpcodeName();
     WriteOptimizationInfo(Out, CE);
     if (CE->isCompare())
-      Out << ' ' << getPredicateText(CE->getPredicate());
+      Out << ' ' << CE->getPredicate().getName();
     Out << " (";
 
     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
       TypePrinter.print(GEP->getSourceElementType(), Out);
       Out << ", ";
     }
 
     for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isVolatile()) ||
       (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
     Out << " volatile";
 
   // Print out optimization information.
   WriteOptimizationInfo(Out, &I);
 
   // Print out the compare instruction predicates
   if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
-    Out << ' ' << getPredicateText(CI->getPredicate());
+    Out << ' ' << CI->getPredicate().getName();
 
   // Print out the atomicrmw operation
   if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
     writeAtomicRMWOperation(Out, RMWI->getOperation());
 
   // Print out the type of the operands...
   const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
 

lib/IR/AutoUpgrade.cpp

static Value *UpgradeMaskedLoad(IRBuilder<> &Builder,
 
   // Convert the mask from an integer type to a vector of i1.
   unsigned NumElts = Passthru->getType()->getVectorNumElements();
   Mask = getX86MaskVec(Builder, Mask, NumElts);
   return Builder.CreateMaskedLoad(Ptr, Align, Mask, Passthru);
 }
 
 static Value *upgradeIntMinMax(IRBuilder<> &Builder, CallInst &CI,
-                               ICmpInst::Predicate Pred) {
+                               Predicate Pred) {
   Value *Op0 = CI.getArgOperand(0);
   Value *Op1 = CI.getArgOperand(1);
   Value *Cmp = Builder.CreateICmp(Pred, Op0, Op1);
   return Builder.CreateSelect(Cmp, Op0, Op1);
 }
 
 static Value *upgradeMaskedCompare(IRBuilder<> &Builder, CallInst &CI,
-                                   ICmpInst::Predicate Pred) {
+                                   Predicate Pred) {
   Value *Op0 = CI.getArgOperand(0);
   unsigned NumElts = Op0->getType()->getVectorNumElements();
   Value *Cmp = Builder.CreateICmp(Pred, Op0, CI.getArgOperand(1));
 
   Value *Mask = CI.getArgOperand(2);
   const auto *C = dyn_cast<Constant>(Mask);
   if (!C || !C->isAllOnesValue())
     Cmp = Builder.CreateAnd(Cmp, getX86MaskVec(Builder, Mask, NumElts));
if (IsX86 && (Name.startswith("sse2.pcmpeq.") ||
                                  "pcmpeq");
       Rep = Builder.CreateSExt(Rep, CI->getType(), "");
     } else if (IsX86 && (Name.startswith("sse2.pcmpgt.") ||
                          Name.startswith("avx2.pcmpgt."))) {
       Rep = Builder.CreateICmpSGT(CI->getArgOperand(0), CI->getArgOperand(1),
                                   "pcmpgt");
       Rep = Builder.CreateSExt(Rep, CI->getType(), "");
     } else if (IsX86 && Name.startswith("avx512.mask.pcmpeq.")) {
-      Rep = upgradeMaskedCompare(Builder, *CI, ICmpInst::ICMP_EQ);
+      Rep = upgradeMaskedCompare(Builder, *CI, Predicate::ICMP_EQ);
     } else if (IsX86 && Name.startswith("avx512.mask.pcmpgt.")) {
-      Rep = upgradeMaskedCompare(Builder, *CI, ICmpInst::ICMP_SGT);
+      Rep = upgradeMaskedCompare(Builder, *CI, Predicate::ICMP_SGT);
     } else if (IsX86 && (Name == "sse41.pmaxsb" ||
                          Name == "sse2.pmaxs.w" ||
                          Name == "sse41.pmaxsd" ||
                          Name.startswith("avx2.pmaxs"))) {
-      Rep = upgradeIntMinMax(Builder, *CI, ICmpInst::ICMP_SGT);
+      Rep = upgradeIntMinMax(Builder, *CI, Predicate::ICMP_SGT);
     } else if (IsX86 && (Name == "sse2.pmaxu.b" ||
                          Name == "sse41.pmaxuw" ||
                          Name == "sse41.pmaxud" ||
                          Name.startswith("avx2.pmaxu"))) {
-      Rep = upgradeIntMinMax(Builder, *CI, ICmpInst::ICMP_UGT);
+      Rep = upgradeIntMinMax(Builder, *CI, Predicate::ICMP_UGT);
     } else if (IsX86 && (Name == "sse41.pminsb" ||
                          Name == "sse2.pmins.w" ||
                          Name == "sse41.pminsd" ||
                          Name.startswith("avx2.pmins"))) {
-      Rep = upgradeIntMinMax(Builder, *CI, ICmpInst::ICMP_SLT);
+      Rep = upgradeIntMinMax(Builder, *CI, Predicate::ICMP_SLT);
     } else if (IsX86 && (Name == "sse2.pminu.b" ||
                          Name == "sse41.pminuw" ||
                          Name == "sse41.pminud" ||
                          Name.startswith("avx2.pminu"))) {
-      Rep = upgradeIntMinMax(Builder, *CI, ICmpInst::ICMP_ULT);
+      Rep = upgradeIntMinMax(Builder, *CI, Predicate::ICMP_ULT);
     } else if (IsX86 && (Name == "sse2.cvtdq2pd" ||
                          Name == "sse2.cvtps2pd" ||
                          Name == "avx.cvtdq2.pd.256" ||
                          Name == "avx.cvt.ps2.pd.256")) {
       // Lossless i32/float to double conversion.
       // Extract the bottom elements if necessary and convert to double vector.
       Value *Src = CI->getArgOperand(0);
       VectorType *SrcTy = cast<VectorType>(Src->getType());

lib/IR/ConstantFold.h

 // These operators may return a null object if they don't know how to perform
 // the specified operation on the specified constant types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_IR_CONSTANTFOLD_H
 #define LLVM_LIB_IR_CONSTANTFOLD_H
 
+#include "llvm/Support/Predicate.h"
+
 namespace llvm {
 template <typename T> class ArrayRef;
   class Value;
   class Constant;
   class Type;
 
   // Constant fold various types of instruction...
   Constant *ConstantFoldCastInstruction(
template <typename T> class ArrayRef;
   Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2,
                                                  Constant *Mask);
   Constant *ConstantFoldExtractValueInstruction(Constant *Agg,
                                                 ArrayRef<unsigned> Idxs);
   Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val,
                                                ArrayRef<unsigned> Idxs);
   Constant *ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1,
                                           Constant *V2);
-  Constant *ConstantFoldCompareInstruction(unsigned short predicate,
-                                           Constant *C1, Constant *C2);
+  Constant *ConstantFoldCompareInstruction(Predicate Pred, Constant *C1,
+                                           Constant *C2);
   Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool inBounds,
                                       ArrayRef<Constant *> Idxs);
   Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool inBounds,
                                       ArrayRef<Value *> Idxs);
 } // End llvm namespace
 
 #endif

lib/IR/ConstantFold.cpp

case Instruction::Xor:
 
       if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
         switch (CE1->getOpcode()) {
         default: break;
         case Instruction::ICmp:
         case Instruction::FCmp:
           // cmp pred ^ true -> cmp !pred
           assert(CI2->equalsInt(1));
-          CmpInst::Predicate pred = (CmpInst::Predicate)CE1->getPredicate();
-          pred = CmpInst::getInversePredicate(pred);
-          return ConstantExpr::getCompare(pred, CE1->getOperand(0),
+          Predicate Pred = CE1->getPredicate();
+          Pred = Pred.getInverse();
+          return ConstantExpr::getCompare(Pred, CE1->getOperand(0),
                                           CE1->getOperand(1));
         }
       }
       break;
     case Instruction::AShr:
       // ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2
       if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1))
         if (CE1->getOpcode() == Instruction::ZExt)  // Top bits known zero.

 /// If we can determine that the two constants have a particular relation to
 /// each other, we should return the corresponding FCmpInst predicate,
 /// otherwise return FCmpInst::BAD_FCMP_PREDICATE. This is used below in
 /// ConstantFoldCompareInstruction.
 ///
 /// To simplify this code we canonicalize the relation so that the first
 /// operand is always the most "complex" of the two.  We consider ConstantFP
 /// to be the simplest, and ConstantExprs to be the most complex.
-static FCmpInst::Predicate evaluateFCmpRelation(Constant *V1, Constant *V2) {
+static Predicate evaluateFCmpRelation(Constant *V1, Constant *V2) {
   assert(V1->getType() == V2->getType() &&
          "Cannot compare values of different types!");
 
   // Handle degenerate case quickly
-  if (V1 == V2) return FCmpInst::FCMP_OEQ;
+  if (V1 == V2)
+    return Predicate::FCMP_OEQ;
 
   if (!isa<ConstantExpr>(V1)) {
     if (!isa<ConstantExpr>(V2)) {
       // Simple case, use the standard constant folder.
       ConstantInt *R = nullptr;
       R = dyn_cast<ConstantInt>(
-                      ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, V1, V2));
+          ConstantExpr::getFCmp(Predicate::FCMP_OEQ, V1, V2));
       if (R && !R->isZero())
-        return FCmpInst::FCMP_OEQ;
+        return Predicate::FCMP_OEQ;
       R = dyn_cast<ConstantInt>(
-                      ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, V1, V2));
+          ConstantExpr::getFCmp(Predicate::FCMP_OLT, V1, V2));
       if (R && !R->isZero())
-        return FCmpInst::FCMP_OLT;
+        return Predicate::FCMP_OLT;
       R = dyn_cast<ConstantInt>(
-                      ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, V1, V2));
+          ConstantExpr::getFCmp(Predicate::FCMP_OGT, V1, V2));
       if (R && !R->isZero())
-        return FCmpInst::FCMP_OGT;
+        return Predicate::FCMP_OGT;
 
       // Nothing more we can do
-      return FCmpInst::BAD_FCMP_PREDICATE;
+      return Predicate::BAD_FCMP_PREDICATE;
     }
 
     // If the first operand is simple and second is ConstantExpr, swap operands.
-    FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(V2, V1);
-    if (SwappedRelation != FCmpInst::BAD_FCMP_PREDICATE)
-      return FCmpInst::getSwappedPredicate(SwappedRelation);
+    Predicate SwappedRelation = evaluateFCmpRelation(V2, V1);
+    if (SwappedRelation != Predicate::BAD_FCMP_PREDICATE)
+      return SwappedRelation.getSwapped();
   } else {
     // Ok, the LHS is known to be a constantexpr.  The RHS can be any of a
     // constantexpr or a simple constant.
     ConstantExpr *CE1 = cast<ConstantExpr>(V1);
     switch (CE1->getOpcode()) {
     case Instruction::FPTrunc:
     case Instruction::FPExt:
     case Instruction::UIToFP:
     case Instruction::SIToFP:
       // We might be able to do something with these but we don't right now.
       break;
     default:
       break;
     }
   }
   // There are MANY other foldings that we could perform here.  They will
   // probably be added on demand, as they seem needed.
-  return FCmpInst::BAD_FCMP_PREDICATE;
+  return Predicate::BAD_FCMP_PREDICATE;
 }
 
-static ICmpInst::Predicate areGlobalsPotentiallyEqual(const GlobalValue *GV1,
-                                                      const GlobalValue *GV2) {
+static Predicate areGlobalsPotentiallyEqual(const GlobalValue *GV1,
   auto isGlobalUnsafeForEquality = [](const GlobalValue *GV) {
     if (GV->hasExternalWeakLinkage() || GV->hasWeakAnyLinkage())
       return true;
     if (const auto *GVar = dyn_cast<GlobalVariable>(GV)) {
       Type *Ty = GVar->getValueType();
       // A global with opaque type might end up being zero sized.
       if (!Ty->isSized())
         return true;
       // A global with an empty type might lie at the address of any other
       // global.
       if (Ty->isEmptyTy())
         return true;
     }
     return false;
   };
   // Don't try to decide equality of aliases.
   if (!isa<GlobalAlias>(GV1) && !isa<GlobalAlias>(GV2))
     if (!isGlobalUnsafeForEquality(GV1) && !isGlobalUnsafeForEquality(GV2))
-      return ICmpInst::ICMP_NE;
-  return ICmpInst::BAD_ICMP_PREDICATE;
+      return Predicate::ICMP_NE;
+  return Predicate::BAD_ICMP_PREDICATE;
 }
 
 /// This function determines if there is anything we can decide about the two
 /// constants provided. This doesn't need to handle simple things like integer
 /// comparisons, but should instead handle ConstantExprs and GlobalValues.
 /// If we can determine that the two constants have a particular relation to
 /// each other, we should return the corresponding ICmp predicate, otherwise
-/// return ICmpInst::BAD_ICMP_PREDICATE.
+/// return Predicate::BAD_ICMP_PREDICATE.
 ///
 /// To simplify this code we canonicalize the relation so that the first
 /// operand is always the most "complex" of the two.  We consider simple
 /// constants (like ConstantInt) to be the simplest, followed by
 /// GlobalValues, followed by ConstantExpr's (the most complex).
 ///
-static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2,
-                                                bool isSigned) {
+static Predicate evaluateICmpRelation(Constant *V1, Constant *V2,
   assert(V1->getType() == V2->getType() &&
          "Cannot compare different types of values!");
-  if (V1 == V2) return ICmpInst::ICMP_EQ;
+  if (V1 == V2)
+    return Predicate::ICMP_EQ;
 
   if (!isa<ConstantExpr>(V1) && !isa<GlobalValue>(V1) &&
       !isa<BlockAddress>(V1)) {
     if (!isa<GlobalValue>(V2) && !isa<ConstantExpr>(V2) &&
         !isa<BlockAddress>(V2)) {
       // We distilled this down to a simple case, use the standard constant
       // folder.
       ConstantInt *R = nullptr;
-      ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
+      Predicate pred = Predicate::ICMP_EQ;
       R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
       if (R && !R->isZero())
         return pred;
-      pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
+      pred = isSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT;
       R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
       if (R && !R->isZero())
         return pred;
-      pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
+      pred = isSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
       R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
       if (R && !R->isZero())
         return pred;
 
       // If we couldn't figure it out, bail.
-      return ICmpInst::BAD_ICMP_PREDICATE;
+      return Predicate::BAD_ICMP_PREDICATE;
     }
 
     // If the first operand is simple, swap operands.
-    ICmpInst::Predicate SwappedRelation =
-      evaluateICmpRelation(V2, V1, isSigned);
-    if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
-      return ICmpInst::getSwappedPredicate(SwappedRelation);
+    Predicate SwappedRelation = evaluateICmpRelation(V2, V1, isSigned);
+    if (SwappedRelation != Predicate::BAD_ICMP_PREDICATE)
+      return SwappedRelation.getSwapped();
 
   } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V1)) {
     if (isa<ConstantExpr>(V2)) {  // Swap as necessary.
-      ICmpInst::Predicate SwappedRelation =
-        evaluateICmpRelation(V2, V1, isSigned);
-      if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
-        return ICmpInst::getSwappedPredicate(SwappedRelation);
-      return ICmpInst::BAD_ICMP_PREDICATE;
+      Predicate SwappedRelation = evaluateICmpRelation(V2, V1, isSigned);
+      if (SwappedRelation != Predicate::BAD_ICMP_PREDICATE)
+        return SwappedRelation.getSwapped();
+      return Predicate::BAD_ICMP_PREDICATE;
     }
 
     // Now we know that the RHS is a GlobalValue, BlockAddress or simple
     // constant (which, since the types must match, means that it's a
     // ConstantPointerNull).
     if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
       return areGlobalsPotentiallyEqual(GV, GV2);
     } else if (isa<BlockAddress>(V2)) {
-      return ICmpInst::ICMP_NE; // Globals never equal labels.
+      return Predicate::ICMP_NE; // Globals never equal labels.
     } else {
       assert(isa<ConstantPointerNull>(V2) && "Canonicalization guarantee!");
       // GlobalVals can never be null unless they have external weak linkage.
       // We don't try to evaluate aliases here.
       if (!GV->hasExternalWeakLinkage() && !isa<GlobalAlias>(GV))
-        return ICmpInst::ICMP_NE;
+        return Predicate::ICMP_NE;
     }
   } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(V1)) {
     if (isa<ConstantExpr>(V2)) {  // Swap as necessary.
-      ICmpInst::Predicate SwappedRelation =
-        evaluateICmpRelation(V2, V1, isSigned);
-      if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
-        return ICmpInst::getSwappedPredicate(SwappedRelation);
-      return ICmpInst::BAD_ICMP_PREDICATE;
+      Predicate SwappedRelation = evaluateICmpRelation(V2, V1, isSigned);
+      if (SwappedRelation != Predicate::BAD_ICMP_PREDICATE)
+        return SwappedRelation.getSwapped();
+      return Predicate::BAD_ICMP_PREDICATE;
     }
 
     // Now we know that the RHS is a GlobalValue, BlockAddress or simple
     // constant (which, since the types must match, means that it is a
     // ConstantPointerNull).
     if (const BlockAddress *BA2 = dyn_cast<BlockAddress>(V2)) {
       // Block address in another function can't equal this one, but block
       // addresses in the current function might be the same if blocks are
       // empty.
       if (BA2->getFunction() != BA->getFunction())
-        return ICmpInst::ICMP_NE;
+        return Predicate::ICMP_NE;
     } else {
       // Block addresses aren't null, don't equal the address of globals.
       assert((isa<ConstantPointerNull>(V2) || isa<GlobalValue>(V2)) &&
              "Canonicalization guarantee!");
-      return ICmpInst::ICMP_NE;
+      return Predicate::ICMP_NE;
     }
   } else {
     // Ok, the LHS is known to be a constantexpr.  The RHS can be any of a
     // constantexpr, a global, block address, or a simple constant.
     ConstantExpr *CE1 = cast<ConstantExpr>(V1);
     Constant *CE1Op0 = CE1->getOperand(0);
 
     switch (CE1->getOpcode()) {
case Instruction::GetElementPtr: {
       // pointer type.  Check the various cases.
       if (isa<ConstantPointerNull>(V2)) {
         // If we are comparing a GEP to a null pointer, check to see if the base
         // of the GEP equals the null pointer.
         if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
           if (GV->hasExternalWeakLinkage())
             // Weak linkage GVals could be zero or not. We're comparing that
             // to null pointer so its greater-or-equal
-            return isSigned ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE;
+            return isSigned ? Predicate::ICMP_SGE : Predicate::ICMP_UGE;
           else
             // If its not weak linkage, the GVal must have a non-zero address
             // so the result is greater-than
-            return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
+            return isSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
         } else if (isa<ConstantPointerNull>(CE1Op0)) {
           // If we are indexing from a null pointer, check to see if we have any
           // non-zero indices.
           for (unsigned i = 1, e = CE1->getNumOperands(); i != e; ++i)
             if (!CE1->getOperand(i)->isNullValue())
               // Offsetting from null, must not be equal.
-              return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
+              return isSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
           // Only zero indexes from null, must still be zero.
-          return ICmpInst::ICMP_EQ;
+          return Predicate::ICMP_EQ;
         }
         // Otherwise, we can't really say if the first operand is null or not.
       } else if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
         if (isa<ConstantPointerNull>(CE1Op0)) {
           if (GV2->hasExternalWeakLinkage())
             // Weak linkage GVals could be zero or not. We're comparing it to
             // a null pointer, so its less-or-equal
-            return isSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE;
+            return isSigned ? Predicate::ICMP_SLE : Predicate::ICMP_ULE;
           else
             // If its not weak linkage, the GVal must have a non-zero address
             // so the result is less-than
-            return isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
+            return isSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT;
         } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
           if (GV == GV2) {
             // If this is a getelementptr of the same global, then it must be
             // different.  Because the types must match, the getelementptr could
             // only have at most one index, and because we fold getelementptr's
             // with a single zero index, it must be nonzero.
             assert(CE1->getNumOperands() == 2 &&
                    !CE1->getOperand(1)->isNullValue() &&
                    "Surprising getelementptr!");
-            return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
+            return isSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
           } else {
             if (CE1GEP->hasAllZeroIndices())
               return areGlobalsPotentiallyEqual(GV, GV2);
-            return ICmpInst::BAD_ICMP_PREDICATE;
+            return Predicate::BAD_ICMP_PREDICATE;
           }
         }
       } else {
         ConstantExpr *CE2 = cast<ConstantExpr>(V2);
         Constant *CE2Op0 = CE2->getOperand(0);
 
         // There are MANY other foldings that we could perform here.  They will
         // probably be added on demand, as they seem needed.
         switch (CE2->getOpcode()) {
         default: break;
         case Instruction::GetElementPtr:
           // By far the most common case to handle is when the base pointers are
           // obviously to the same global.
           if (isa<GlobalValue>(CE1Op0) && isa<GlobalValue>(CE2Op0)) {
             // Don't know relative ordering, but check for inequality.
             if (CE1Op0 != CE2Op0) {
               GEPOperator *CE2GEP = cast<GEPOperator>(CE2);
               if (CE1GEP->hasAllZeroIndices() && CE2GEP->hasAllZeroIndices())
                 return areGlobalsPotentiallyEqual(cast<GlobalValue>(CE1Op0),
                                                   cast<GlobalValue>(CE2Op0));
-              return ICmpInst::BAD_ICMP_PREDICATE;
+              return Predicate::BAD_ICMP_PREDICATE;
             }
             // Ok, we know that both getelementptr instructions are based on the
             // same global.  From this, we can precisely determine the relative
             // ordering of the resultant pointers.
             unsigned i = 1;
 
             // The logic below assumes that the result of the comparison
             // can be determined by finding the first index that differs.
             // This doesn't work if there is over-indexing in any
             // subsequent indices, so check for that case first.
             if (!CE1->isGEPWithNoNotionalOverIndexing() ||
                 !CE2->isGEPWithNoNotionalOverIndexing())
-               return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
+              return Predicate::BAD_ICMP_PREDICATE; // Might be equal.
 
             // Compare all of the operands the GEP's have in common.
             gep_type_iterator GTI = gep_type_begin(CE1);
             for (;i != CE1->getNumOperands() && i != CE2->getNumOperands();
                  ++i, ++GTI)
               switch (IdxCompare(CE1->getOperand(i),
                                  CE2->getOperand(i), GTI.getIndexedType())) {
-              case -1: return isSigned ? ICmpInst::ICMP_SLT:ICmpInst::ICMP_ULT;
-              case 1:  return isSigned ? ICmpInst::ICMP_SGT:ICmpInst::ICMP_UGT;
-              case -2: return ICmpInst::BAD_ICMP_PREDICATE;
+              case -1:
+                return isSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT;
+              case 1:
+                return isSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
+              case -2:
+                return Predicate::BAD_ICMP_PREDICATE;
               }
 
             // Ok, we ran out of things they have in common.  If any leftovers
             // are non-zero then we have a difference, otherwise we are equal.
             for (; i < CE1->getNumOperands(); ++i)
               if (!CE1->getOperand(i)->isNullValue()) {
                 if (isa<ConstantInt>(CE1->getOperand(i)))
-                  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
+                  return isSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
                 else
-                  return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
+                  return Predicate::BAD_ICMP_PREDICATE; // Might be equal.
               }
 
             for (; i < CE2->getNumOperands(); ++i)
               if (!CE2->getOperand(i)->isNullValue()) {
                 if (isa<ConstantInt>(CE2->getOperand(i)))
-                  return isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
+                  return isSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT;
                 else
-                  return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
+                  return Predicate::BAD_ICMP_PREDICATE; // Might be equal.
               }
-            return ICmpInst::ICMP_EQ;
+            return Predicate::ICMP_EQ;
           }
         }
       }
     }
     default:
       break;
     }
   }
 
-  return ICmpInst::BAD_ICMP_PREDICATE;
+  return Predicate::BAD_ICMP_PREDICATE;
 }
 
-Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
-                                               Constant *C1, Constant *C2) {
+Constant *llvm::ConstantFoldCompareInstruction(Predicate Pred, Constant *C1,
+                                               Constant *C2) {
   Type *ResultTy;
   if (VectorType *VT = dyn_cast<VectorType>(C1->getType()))
     ResultTy = VectorType::get(Type::getInt1Ty(C1->getContext()),
                                VT->getNumElements());
   else
     ResultTy = Type::getInt1Ty(C1->getContext());
 
   // Fold FCMP_FALSE/FCMP_TRUE unconditionally.
-  if (pred == FCmpInst::FCMP_FALSE)
+  if (Pred == Predicate::FCMP_FALSE)
     return Constant::getNullValue(ResultTy);
 
-  if (pred == FCmpInst::FCMP_TRUE)
+  if (Pred == Predicate::FCMP_TRUE)
     return Constant::getAllOnesValue(ResultTy);
 
   // Handle some degenerate cases first
   if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
-    CmpInst::Predicate Predicate = CmpInst::Predicate(pred);
-    bool isIntegerPredicate = ICmpInst::isIntPredicate(Predicate);
+    bool isIntegerPredicate = Pred.isInt();
     // For EQ and NE, we can always pick a value for the undef to make the
     // predicate pass or fail, so we can return undef.
     // Also, if both operands are undef, we can return undef for int comparison.
-    if (ICmpInst::isEquality(Predicate) || (isIntegerPredicate && C1 == C2))
+    if (isIntegerPredicate && (Pred.isEquality() || C1 == C2))
       return UndefValue::get(ResultTy);
 
     // Otherwise, for integer compare, pick the same value as the non-undef
     // operand, and fold it to true or false.
     if (isIntegerPredicate)
-      return ConstantInt::get(ResultTy, CmpInst::isTrueWhenEqual(Predicate));
+      return ConstantInt::get(ResultTy, Pred.isTrueWhenEqual());
 
     // Choosing NaN for the undef will always make unordered comparison succeed
     // and ordered comparison fails.
-    return ConstantInt::get(ResultTy, CmpInst::isUnordered(Predicate));
+    return ConstantInt::get(ResultTy, Pred.isUnordered());
   }
 
   // icmp eq/ne(null,GV) -> false/true
   if (C1->isNullValue()) {
     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C2))
       // Don't try to evaluate aliases.  External weak GV can be null.
       if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
-        if (pred == ICmpInst::ICMP_EQ)
+        if (Pred == Predicate::ICMP_EQ)
           return ConstantInt::getFalse(C1->getContext());
-        else if (pred == ICmpInst::ICMP_NE)
+        else if (Pred == Predicate::ICMP_NE)
           return ConstantInt::getTrue(C1->getContext());
       }
   // icmp eq/ne(GV,null) -> false/true
   } else if (C2->isNullValue()) {
     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C1))
       // Don't try to evaluate aliases.  External weak GV can be null.
       if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
-        if (pred == ICmpInst::ICMP_EQ)
+        if (Pred == Predicate::ICMP_EQ)
           return ConstantInt::getFalse(C1->getContext());
-        else if (pred == ICmpInst::ICMP_NE)
+        else if (Pred == Predicate::ICMP_NE)
           return ConstantInt::getTrue(C1->getContext());
       }
   }
 
   // If the comparison is a comparison between two i1's, simplify it.
   if (C1->getType()->isIntegerTy(1)) {
-    switch(pred) {
-    case ICmpInst::ICMP_EQ:
+    switch (Pred.getKind()) {
+    case Predicate::ICMP_EQ:
       if (isa<ConstantInt>(C2))
         return ConstantExpr::getXor(C1, ConstantExpr::getNot(C2));
       return ConstantExpr::getXor(ConstantExpr::getNot(C1), C2);
-    case ICmpInst::ICMP_NE:
+    case Predicate::ICMP_NE:
       return ConstantExpr::getXor(C1, C2);
     default:
       break;
     }
   }
 
   if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
     const APInt &V1 = cast<ConstantInt>(C1)->getValue();
     const APInt &V2 = cast<ConstantInt>(C2)->getValue();
-    switch (pred) {
+    switch (Pred.getKind()) {
     default: llvm_unreachable("Invalid ICmp Predicate");
-    case ICmpInst::ICMP_EQ:  return ConstantInt::get(ResultTy, V1 == V2);
-    case ICmpInst::ICMP_NE:  return ConstantInt::get(ResultTy, V1 != V2);
-    case ICmpInst::ICMP_SLT: return ConstantInt::get(ResultTy, V1.slt(V2));
-    case ICmpInst::ICMP_SGT: return ConstantInt::get(ResultTy, V1.sgt(V2));
-    case ICmpInst::ICMP_SLE: return ConstantInt::get(ResultTy, V1.sle(V2));
-    case ICmpInst::ICMP_SGE: return ConstantInt::get(ResultTy, V1.sge(V2));
-    case ICmpInst::ICMP_ULT: return ConstantInt::get(ResultTy, V1.ult(V2));
-    case ICmpInst::ICMP_UGT: return ConstantInt::get(ResultTy, V1.ugt(V2));
-    case ICmpInst::ICMP_ULE: return ConstantInt::get(ResultTy, V1.ule(V2));
-    case ICmpInst::ICMP_UGE: return ConstantInt::get(ResultTy, V1.uge(V2));
+    case Predicate::ICMP_EQ:
+      return ConstantInt::get(ResultTy, V1 == V2);
+    case Predicate::ICMP_NE:
+      return ConstantInt::get(ResultTy, V1 != V2);
+    case Predicate::ICMP_SLT:
+      return ConstantInt::get(ResultTy, V1.slt(V2));
+    case Predicate::ICMP_SGT:
+      return ConstantInt::get(ResultTy, V1.sgt(V2));
+    case Predicate::ICMP_SLE:
+      return ConstantInt::get(ResultTy, V1.sle(V2));
+    case Predicate::ICMP_SGE:
+      return ConstantInt::get(ResultTy, V1.sge(V2));
+    case Predicate::ICMP_ULT:
+      return ConstantInt::get(ResultTy, V1.ult(V2));
+    case Predicate::ICMP_UGT:
+      return ConstantInt::get(ResultTy, V1.ugt(V2));
+    case Predicate::ICMP_ULE:
+      return ConstantInt::get(ResultTy, V1.ule(V2));
+    case Predicate::ICMP_UGE:
+      return ConstantInt::get(ResultTy, V1.uge(V2));
     }
   } else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
     const APFloat &C1V = cast<ConstantFP>(C1)->getValueAPF();
     const APFloat &C2V = cast<ConstantFP>(C2)->getValueAPF();
     APFloat::cmpResult R = C1V.compare(C2V);
-    switch (pred) {
+    switch (Pred.getKind()) {
     default: llvm_unreachable("Invalid FCmp Predicate");
-    case FCmpInst::FCMP_FALSE: return Constant::getNullValue(ResultTy);
-    case FCmpInst::FCMP_TRUE:  return Constant::getAllOnesValue(ResultTy);
-    case FCmpInst::FCMP_UNO:
+    case Predicate::FCMP_FALSE:
+      return Constant::getNullValue(ResultTy);
+    case Predicate::FCMP_TRUE:
+      return Constant::getAllOnesValue(ResultTy);
+    case Predicate::FCMP_UNO:
       return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered);
-    case FCmpInst::FCMP_ORD:
+    case Predicate::FCMP_ORD:
       return ConstantInt::get(ResultTy, R!=APFloat::cmpUnordered);
-    case FCmpInst::FCMP_UEQ:
+    case Predicate::FCMP_UEQ:
       return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
                                         R==APFloat::cmpEqual);
-    case FCmpInst::FCMP_OEQ:
+    case Predicate::FCMP_OEQ:
       return ConstantInt::get(ResultTy, R==APFloat::cmpEqual);
-    case FCmpInst::FCMP_UNE:
+    case Predicate::FCMP_UNE:
       return ConstantInt::get(ResultTy, R!=APFloat::cmpEqual);
-    case FCmpInst::FCMP_ONE:
+    case Predicate::FCMP_ONE:
       return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
                                         R==APFloat::cmpGreaterThan);
-    case FCmpInst::FCMP_ULT:
+    case Predicate::FCMP_ULT:
       return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
                                         R==APFloat::cmpLessThan);
-    case FCmpInst::FCMP_OLT:
+    case Predicate::FCMP_OLT:
       return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan);
-    case FCmpInst::FCMP_UGT:
+    case Predicate::FCMP_UGT:
       return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
                                         R==APFloat::cmpGreaterThan);
-    case FCmpInst::FCMP_OGT:
+    case Predicate::FCMP_OGT:
       return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan);
-    case FCmpInst::FCMP_ULE:
+    case Predicate::FCMP_ULE:
       return ConstantInt::get(ResultTy, R!=APFloat::cmpGreaterThan);
-    case FCmpInst::FCMP_OLE:
+    case Predicate::FCMP_OLE:
       return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
                                         R==APFloat::cmpEqual);
-    case FCmpInst::FCMP_UGE:
+    case Predicate::FCMP_UGE:
       return ConstantInt::get(ResultTy, R!=APFloat::cmpLessThan);
-    case FCmpInst::FCMP_OGE:
+    case Predicate::FCMP_OGE:
       return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan ||
                                         R==APFloat::cmpEqual);
     }
   } else if (C1->getType()->isVectorTy()) {
     // If we can constant fold the comparison of each element, constant fold
     // the whole vector comparison.
     SmallVector<Constant*, 4> ResElts;
     Type *Ty = IntegerType::get(C1->getContext(), 32);
     // Compare the elements, producing an i1 result or constant expr.
     for (unsigned i = 0, e = C1->getType()->getVectorNumElements(); i != e;++i){
       Constant *C1E =
         ConstantExpr::getExtractElement(C1, ConstantInt::get(Ty, i));
       Constant *C2E =
         ConstantExpr::getExtractElement(C2, ConstantInt::get(Ty, i));
 
-      ResElts.push_back(ConstantExpr::getCompare(pred, C1E, C2E));
+      ResElts.push_back(ConstantExpr::getCompare(Pred, C1E, C2E));
     }
 
     return ConstantVector::get(ResElts);
   }
 
   if (C1->getType()->isFloatingPointTy() &&
       // Only call evaluateFCmpRelation if we have a constant expr to avoid
       // infinite recursive loop
       (isa<ConstantExpr>(C1) || isa<ConstantExpr>(C2))) {
     int Result = -1;  // -1 = unknown, 0 = known false, 1 = known true.
-    switch (evaluateFCmpRelation(C1, C2)) {
+    switch (evaluateFCmpRelation(C1, C2).getKind()) {
     default: llvm_unreachable("Unknown relation!");
-    case FCmpInst::FCMP_UNO:
-    case FCmpInst::FCMP_ORD:
-    case FCmpInst::FCMP_UEQ:
-    case FCmpInst::FCMP_UNE:
-    case FCmpInst::FCMP_ULT:
-    case FCmpInst::FCMP_UGT:
-    case FCmpInst::FCMP_ULE:
-    case FCmpInst::FCMP_UGE:
-    case FCmpInst::FCMP_TRUE:
-    case FCmpInst::FCMP_FALSE:
-    case FCmpInst::BAD_FCMP_PREDICATE:
+    case Predicate::FCMP_UNO:
+    case Predicate::FCMP_ORD:
+    case Predicate::FCMP_UEQ:
+    case Predicate::FCMP_UNE:
+    case Predicate::FCMP_ULT:
+    case Predicate::FCMP_UGT:
+    case Predicate::FCMP_ULE:
+    case Predicate::FCMP_UGE:
+    case Predicate::FCMP_TRUE:
+    case Predicate::FCMP_FALSE:
+    case Predicate::BAD_FCMP_PREDICATE:
       break; // Couldn't determine anything about these constants.
-    case FCmpInst::FCMP_OEQ: // We know that C1 == C2
-      Result = (pred == FCmpInst::FCMP_UEQ || pred == FCmpInst::FCMP_OEQ ||
-                pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE ||
-                pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
-      break;
-    case FCmpInst::FCMP_OLT: // We know that C1 < C2
-      Result = (pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
-                pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT ||
-                pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE);
-      break;
-    case FCmpInst::FCMP_OGT: // We know that C1 > C2
-      Result = (pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
-                pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT ||
-                pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
+    case Predicate::FCMP_OEQ: // We know that C1 == C2
+      Result = Pred.isOneOf(Predicate::FCMP_UEQ, Predicate::FCMP_OEQ,
+                            Predicate::FCMP_ULE, Predicate::FCMP_OLE,
+                            Predicate::FCMP_UGE, Predicate::FCMP_OGE);
+      break;
+    case Predicate::FCMP_OLT: // We know that C1 < C2
+      Result = Pred.isOneOf(Predicate::FCMP_UNE, Predicate::FCMP_ONE,
+                            Predicate::FCMP_ULT, Predicate::FCMP_OLT,
+                            Predicate::FCMP_ULE, Predicate::FCMP_OLE);
+      break;
+    case Predicate::FCMP_OGT: // We know that C1 > C2
+      Result = Pred.isOneOf(Predicate::FCMP_UNE, Predicate::FCMP_ONE,
+                            Predicate::FCMP_UGT, Predicate::FCMP_OGT,
+                            Predicate::FCMP_UGE, Predicate::FCMP_OGE);
       break;
-    case FCmpInst::FCMP_OLE: // We know that C1 <= C2
+    case Predicate::FCMP_OLE: // We know that C1 <= C2
       // We can only partially decide this relation.
-      if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
+      if (Pred.isOneOf(Predicate::FCMP_UGT, Predicate::FCMP_OGT))
         Result = 0;
-      else if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
+      else if (Pred.isOneOf(Predicate::FCMP_ULT, Predicate::FCMP_OLT))
         Result = 1;
       break;
-    case FCmpInst::FCMP_OGE: // We known that C1 >= C2
+    case Predicate::FCMP_OGE: // We known that C1 >= C2
       // We can only partially decide this relation.
-      if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
+      if (Pred.isOneOf(Predicate::FCMP_ULT, Predicate::FCMP_OLT))
         Result = 0;
-      else if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
+      else if (Pred.isOneOf(Predicate::FCMP_UGT, Predicate::FCMP_OGT))
         Result = 1;
       break;
-    case FCmpInst::FCMP_ONE: // We know that C1 != C2
+    case Predicate::FCMP_ONE: // We know that C1 != C2
       // We can only partially decide this relation.
-      if (pred == FCmpInst::FCMP_OEQ || pred == FCmpInst::FCMP_UEQ)
+      if (Pred.isOneOf(Predicate::FCMP_OEQ, Predicate::FCMP_UEQ))
         Result = 0;
-      else if (pred == FCmpInst::FCMP_ONE || pred == FCmpInst::FCMP_UNE)
+      else if (Pred.isOneOf(Predicate::FCMP_ONE, Predicate::FCMP_UNE))
         Result = 1;
       break;
     }
 
     // If we evaluated the result, return it now.
     if (Result != -1)
       return ConstantInt::get(ResultTy, Result);
 
   } else {
     // Evaluate the relation between the two constants, per the predicate.
     int Result = -1;  // -1 = unknown, 0 = known false, 1 = known true.
-    switch (evaluateICmpRelation(C1, C2,
-                                 CmpInst::isSigned((CmpInst::Predicate)pred))) {
+    switch (evaluateICmpRelation(C1, C2, Pred.isSigned()).getKind()) {
     default: llvm_unreachable("Unknown relational!");
-    case ICmpInst::BAD_ICMP_PREDICATE:
+    case Predicate::BAD_ICMP_PREDICATE:
       break;  // Couldn't determine anything about these constants.
-    case ICmpInst::ICMP_EQ:   // We know the constants are equal!
+    case Predicate::ICMP_EQ: // We know the constants are equal!
       // If we know the constants are equal, we can decide the result of this
       // computation precisely.
-      Result = ICmpInst::isTrueWhenEqual((ICmpInst::Predicate)pred);
+      Result = Pred.isTrueWhenEqual();
       break;
-    case ICmpInst::ICMP_ULT:
-      switch (pred) {
-      case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_ULE:
+    case Predicate::ICMP_ULT:
+      switch (Pred.getKind()) {
+      default:
+        llvm_unreachable("unexpected predicate kind");
+      case Predicate::ICMP_ULT:
+      case Predicate::ICMP_NE:
+      case Predicate::ICMP_ULE:
         Result = 1; break;
-      case ICmpInst::ICMP_UGT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_UGE:
+      case Predicate::ICMP_UGT:
+      case Predicate::ICMP_EQ:
+      case Predicate::ICMP_UGE:
         Result = 0; break;
       }
       break;
-    case ICmpInst::ICMP_SLT:
-      switch (pred) {
-      case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_SLE:
+    case Predicate::ICMP_SLT:
+      switch (Pred.getKind()) {
+      default:
+        llvm_unreachable("unexpected predicate kind");
+      case Predicate::ICMP_SLT:
+      case Predicate::ICMP_NE:
+      case Predicate::ICMP_SLE:
         Result = 1; break;
-      case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_SGE:
+      case Predicate::ICMP_SGT:
+      case Predicate::ICMP_EQ:
+      case Predicate::ICMP_SGE:
         Result = 0; break;
       }
       break;
-    case ICmpInst::ICMP_UGT:
-      switch (pred) {
-      case ICmpInst::ICMP_UGT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_UGE:
+    case Predicate::ICMP_UGT:
+      switch (Pred.getKind()) {
+      default:
+        llvm_unreachable("unexpected predicate kind");
+      case Predicate::ICMP_UGT:
+      case Predicate::ICMP_NE:
+      case Predicate::ICMP_UGE:
         Result = 1; break;
-      case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_ULE:
+      case Predicate::ICMP_ULT:
+      case Predicate::ICMP_EQ:
+      case Predicate::ICMP_ULE:
         Result = 0; break;
       }
       break;
-    case ICmpInst::ICMP_SGT:
-      switch (pred) {
-      case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_SGE:
+    case Predicate::ICMP_SGT:
+      switch (Pred.getKind()) {
+      default:
+        llvm_unreachable("unexpected predicate kind");
+      case Predicate::ICMP_SGT:
+      case Predicate::ICMP_NE:
+      case Predicate::ICMP_SGE:
         Result = 1; break;
-      case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_SLE:
+      case Predicate::ICMP_SLT:
+      case Predicate::ICMP_EQ:
+      case Predicate::ICMP_SLE:
         Result = 0; break;
       }
       break;
-    case ICmpInst::ICMP_ULE:
-      if (pred == ICmpInst::ICMP_UGT) Result = 0;
-      if (pred == ICmpInst::ICMP_ULT || pred == ICmpInst::ICMP_ULE) Result = 1;
-      break;
-    case ICmpInst::ICMP_SLE:
-      if (pred == ICmpInst::ICMP_SGT) Result = 0;
-      if (pred == ICmpInst::ICMP_SLT || pred == ICmpInst::ICMP_SLE) Result = 1;
-      break;
-    case ICmpInst::ICMP_UGE:
-      if (pred == ICmpInst::ICMP_ULT) Result = 0;
-      if (pred == ICmpInst::ICMP_UGT || pred == ICmpInst::ICMP_UGE) Result = 1;
-      break;
-    case ICmpInst::ICMP_SGE:
-      if (pred == ICmpInst::ICMP_SLT) Result = 0;
-      if (pred == ICmpInst::ICMP_SGT || pred == ICmpInst::ICMP_SGE) Result = 1;
-      break;
-    case ICmpInst::ICMP_NE:
-      if (pred == ICmpInst::ICMP_EQ) Result = 0;
-      if (pred == ICmpInst::ICMP_NE) Result = 1;
+    case Predicate::ICMP_ULE:
+      if (Pred == Predicate::ICMP_UGT)
+        Result = 0;
+      if (Pred.isOneOf(Predicate::ICMP_ULT, Predicate::ICMP_ULE))
+        Result = 1;
+      break;
+    case Predicate::ICMP_SLE:
+      if (Pred == Predicate::ICMP_SGT)
+        Result = 0;
+      if (Pred.isOneOf(Predicate::ICMP_SLT, Predicate::ICMP_SLE))
+        Result = 1;
+      break;
+    case Predicate::ICMP_UGE:
+      if (Pred == Predicate::ICMP_ULT)
+        Result = 0;
+      if (Pred.isOneOf(Predicate::ICMP_UGT, Predicate::ICMP_UGE))
+        Result = 1;
+      break;
+    case Predicate::ICMP_SGE:
+      if (Pred == Predicate::ICMP_SLT)
+        Result = 0;
+      if (Pred.isOneOf(Predicate::ICMP_SGT, Predicate::ICMP_SGE))
+        Result = 1;
+      break;
+    case Predicate::ICMP_NE:
+      if (Pred == Predicate::ICMP_EQ)
+        Result = 0;
+      if (Pred == Predicate::ICMP_NE)
+        Result = 1;
       break;
     }
 
     // If we evaluated the result, return it now.
     if (Result != -1)
       return ConstantInt::get(ResultTy, Result);
 
     // If the right hand side is a bitcast, try using its inverse to simplify
     // it by moving it to the left hand side.  We can't do this if it would turn
     // a vector compare into a scalar compare or visa versa.
     if (ConstantExpr *CE2 = dyn_cast<ConstantExpr>(C2)) {
       Constant *CE2Op0 = CE2->getOperand(0);
       if (CE2->getOpcode() == Instruction::BitCast &&
           CE2->getType()->isVectorTy() == CE2Op0->getType()->isVectorTy()) {
         Constant *Inverse = ConstantExpr::getBitCast(C1, CE2Op0->getType());
-        return ConstantExpr::getICmp(pred, Inverse, CE2Op0);
+        return ConstantExpr::getICmp(Pred, Inverse, CE2Op0);
       }
     }
 
     // If the left hand side is an extension, try eliminating it.
     if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
-      if ((CE1->getOpcode() == Instruction::SExt &&
-           ICmpInst::isSigned((ICmpInst::Predicate)pred)) ||
-          (CE1->getOpcode() == Instruction::ZExt &&
-           !ICmpInst::isSigned((ICmpInst::Predicate)pred))){
+      if ((CE1->getOpcode() == Instruction::SExt && Pred.isSigned()) ||
+          (CE1->getOpcode() == Instruction::ZExt && !Pred.isSigned())) {
         Constant *CE1Op0 = CE1->getOperand(0);
         Constant *CE1Inverse = ConstantExpr::getTrunc(CE1, CE1Op0->getType());
         if (CE1Inverse == CE1Op0) {
           // Check whether we can safely truncate the right hand side.
           Constant *C2Inverse = ConstantExpr::getTrunc(C2, CE1Op0->getType());
           if (ConstantExpr::getCast(CE1->getOpcode(), C2Inverse,
                                     C2->getType()) == C2)
-            return ConstantExpr::getICmp(pred, CE1Inverse, C2Inverse);
+            return ConstantExpr::getICmp(Pred, CE1Inverse, C2Inverse);
         }
       }
     }
 
     if ((!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) ||
         (C1->isNullValue() && !C2->isNullValue())) {
       // If C2 is a constant expr and C1 isn't, flip them around and fold the
       // other way if possible.
       // Also, if C1 is null and C2 isn't, flip them around.
-      pred = ICmpInst::getSwappedPredicate((ICmpInst::Predicate)pred);
-      return ConstantExpr::getICmp(pred, C2, C1);
+      return ConstantExpr::getICmp(Pred.getSwapped(), C2, C1);
     }
   }
   return nullptr;
 }
 
 /// Test whether the given sequence of *normalized* indices is "inbounds".
 template<typename IndexTy>
 static bool isInBoundsIndices(ArrayRef<IndexTy> Idxs) {

lib/IR/ConstantRange.cpp

 ConstantRange::ConstantRange(APIntMoveTy L, APIntMoveTy U)
     : Lower(std::move(L)), Upper(std::move(U)) {
   assert(Lower.getBitWidth() == Upper.getBitWidth() &&
          "ConstantRange with unequal bit widths");
   assert((Lower != Upper || (Lower.isMaxValue() || Lower.isMinValue())) &&
          "Lower == Upper, but they aren't min or max value!");
 }
 
-ConstantRange ConstantRange::makeAllowedICmpRegion(CmpInst::Predicate Pred,
+ConstantRange ConstantRange::makeAllowedICmpRegion(Predicate Pred,
                                                    const ConstantRange &CR) {
   if (CR.isEmptySet())
     return CR;
 
   uint32_t W = CR.getBitWidth();
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default:
     llvm_unreachable("Invalid ICmp predicate to makeAllowedICmpRegion()");
-  case CmpInst::ICMP_EQ:
+  case Predicate::ICMP_EQ:
     return CR;
-  case CmpInst::ICMP_NE:
+  case Predicate::ICMP_NE:
     if (CR.isSingleElement())
       return ConstantRange(CR.getUpper(), CR.getLower());
     return ConstantRange(W);
-  case CmpInst::ICMP_ULT: {
+  case Predicate::ICMP_ULT: {
     APInt UMax(CR.getUnsignedMax());
     if (UMax.isMinValue())
       return ConstantRange(W, /* empty */ false);
     return ConstantRange(APInt::getMinValue(W), UMax);
   }
-  case CmpInst::ICMP_SLT: {
+  case Predicate::ICMP_SLT: {
     APInt SMax(CR.getSignedMax());
     if (SMax.isMinSignedValue())
       return ConstantRange(W, /* empty */ false);
     return ConstantRange(APInt::getSignedMinValue(W), SMax);
   }
-  case CmpInst::ICMP_ULE: {
+  case Predicate::ICMP_ULE: {
     APInt UMax(CR.getUnsignedMax());
     if (UMax.isMaxValue())
       return ConstantRange(W);
     return ConstantRange(APInt::getMinValue(W), UMax + 1);
   }
-  case CmpInst::ICMP_SLE: {
+  case Predicate::ICMP_SLE: {
     APInt SMax(CR.getSignedMax());
     if (SMax.isMaxSignedValue())
       return ConstantRange(W);
     return ConstantRange(APInt::getSignedMinValue(W), SMax + 1);
   }
-  case CmpInst::ICMP_UGT: {
+  case Predicate::ICMP_UGT: {
     APInt UMin(CR.getUnsignedMin());
     if (UMin.isMaxValue())
       return ConstantRange(W, /* empty */ false);
     return ConstantRange(UMin + 1, APInt::getNullValue(W));
   }
-  case CmpInst::ICMP_SGT: {
+  case Predicate::ICMP_SGT: {
     APInt SMin(CR.getSignedMin());
     if (SMin.isMaxSignedValue())
       return ConstantRange(W, /* empty */ false);
     return ConstantRange(SMin + 1, APInt::getSignedMinValue(W));
   }
-  case CmpInst::ICMP_UGE: {
+  case Predicate::ICMP_UGE: {
     APInt UMin(CR.getUnsignedMin());
     if (UMin.isMinValue())
       return ConstantRange(W);
     return ConstantRange(UMin, APInt::getNullValue(W));
   }
-  case CmpInst::ICMP_SGE: {
+  case Predicate::ICMP_SGE: {
     APInt SMin(CR.getSignedMin());
     if (SMin.isMinSignedValue())
       return ConstantRange(W);
     return ConstantRange(SMin, APInt::getSignedMinValue(W));
   }
   }
 }
 
-ConstantRange ConstantRange::makeSatisfyingICmpRegion(CmpInst::Predicate Pred,
+ConstantRange ConstantRange::makeSatisfyingICmpRegion(Predicate Pred,
                                                       const ConstantRange &CR) {
   // Follows from De-Morgan's laws:
   //
   // ~(~A union ~B) == A intersect B.
   //
-  return makeAllowedICmpRegion(CmpInst::getInversePredicate(Pred), CR)
-      .inverse();
+  return makeAllowedICmpRegion(Pred.getInverse(), CR).inverse();
 }
 
-ConstantRange ConstantRange::makeExactICmpRegion(CmpInst::Predicate Pred,
+ConstantRange ConstantRange::makeExactICmpRegion(Predicate Pred,
                                                  const APInt &C) {
   // Computes the exact range that is equal to both the constant ranges returned
   // by makeAllowedICmpRegion and makeSatisfyingICmpRegion. This is always true
   // when RHS is a singleton such as an APInt and so the assert is valid.
   // However for non-singleton RHS, for example ult [2,5) makeAllowedICmpRegion
   // returns [0,4) but makeSatisfyICmpRegion returns [0,2).
   //
   assert(makeAllowedICmpRegion(Pred, C) == makeSatisfyingICmpRegion(Pred, C));
   return makeAllowedICmpRegion(Pred, C);
 }
 
-bool ConstantRange::getEquivalentICmp(CmpInst::Predicate &Pred,
-                                      APInt &RHS) const {
+bool ConstantRange::getEquivalentICmp(Predicate &Pred, APInt &RHS) const {
   bool Success = false;
 
   if (isFullSet() || isEmptySet()) {
-    Pred = isEmptySet() ? CmpInst::ICMP_ULT : CmpInst::ICMP_UGE;
+    Pred = isEmptySet() ? Predicate::ICMP_ULT : Predicate::ICMP_UGE;
     RHS = APInt(getBitWidth(), 0);
     Success = true;
   } else if (getLower().isMinSignedValue() || getLower().isMinValue()) {
-    Pred =
-        getLower().isMinSignedValue() ? CmpInst::ICMP_SLT : CmpInst::ICMP_ULT;
+    Pred = getLower().isMinSignedValue() ? Predicate::ICMP_SLT
+                                         : Predicate::ICMP_ULT;
     RHS = getUpper();
     Success = true;
   } else if (getUpper().isMinSignedValue() || getUpper().isMinValue()) {
-    Pred =
-        getUpper().isMinSignedValue() ? CmpInst::ICMP_SGE : CmpInst::ICMP_UGE;
+    Pred = getUpper().isMinSignedValue() ? Predicate::ICMP_SGE
+                                         : Predicate::ICMP_UGE;
     RHS = getLower();
     Success = true;
   }
 
   assert((!Success || ConstantRange::makeExactICmpRegion(Pred, RHS) == *this) &&
          "Bad result!");
 
   return Success;

lib/IR/Constants.cpp

 ArrayRef<unsigned> ConstantExpr::getIndices() const {
   if (const ExtractValueConstantExpr *EVCE =
         dyn_cast<ExtractValueConstantExpr>(this))
     return EVCE->Indices;
 
   return cast<InsertValueConstantExpr>(this)->Indices;
 }
 
-unsigned ConstantExpr::getPredicate() const {
+Predicate ConstantExpr::getPredicate() const {
   return cast<CompareConstantExpr>(this)->predicate;
 }
 
 Constant *
 ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const {
   assert(Op->getType() == getOperand(OpNo)->getType() &&
          "Replacing operand with value of different type!");
   if (getOperand(OpNo) == Op)
Constant *GEPIdx[] = {
     FieldNo
   };
   Constant *GEP = getGetElementPtr(
       Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
   return getPtrToInt(GEP,
                      Type::getInt64Ty(Ty->getContext()));
 }
 
-Constant *ConstantExpr::getCompare(unsigned short Predicate, Constant *C1,
-                                   Constant *C2, bool OnlyIfReduced) {
+Constant *ConstantExpr::getCompare(Predicate Pred, Constant *C1, Constant *C2,
+                                   bool OnlyIfReduced) {
   assert(C1->getType() == C2->getType() && "Op types should be identical!");
 
-  switch (Predicate) {
+  switch (Pred.getKind()) {
   default: llvm_unreachable("Invalid CmpInst predicate");
-  case CmpInst::FCMP_FALSE: case CmpInst::FCMP_OEQ: case CmpInst::FCMP_OGT:
-  case CmpInst::FCMP_OGE:   case CmpInst::FCMP_OLT: case CmpInst::FCMP_OLE:
-  case CmpInst::FCMP_ONE:   case CmpInst::FCMP_ORD: case CmpInst::FCMP_UNO:
-  case CmpInst::FCMP_UEQ:   case CmpInst::FCMP_UGT: case CmpInst::FCMP_UGE:
-  case CmpInst::FCMP_ULT:   case CmpInst::FCMP_ULE: case CmpInst::FCMP_UNE:
-  case CmpInst::FCMP_TRUE:
-    return getFCmp(Predicate, C1, C2, OnlyIfReduced);
-
-  case CmpInst::ICMP_EQ:  case CmpInst::ICMP_NE:  case CmpInst::ICMP_UGT:
-  case CmpInst::ICMP_UGE: case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE:
-  case CmpInst::ICMP_SGT: case CmpInst::ICMP_SGE: case CmpInst::ICMP_SLT:
-  case CmpInst::ICMP_SLE:
-    return getICmp(Predicate, C1, C2, OnlyIfReduced);
+  case Predicate::FCMP_FALSE:
+  case Predicate::FCMP_OEQ:
+  case Predicate::FCMP_OGT:
+  case Predicate::FCMP_OGE:
+  case Predicate::FCMP_OLT:
+  case Predicate::FCMP_OLE:
+  case Predicate::FCMP_ONE:
+  case Predicate::FCMP_ORD:
+  case Predicate::FCMP_UNO:
+  case Predicate::FCMP_UEQ:
+  case Predicate::FCMP_UGT:
+  case Predicate::FCMP_UGE:
+  case Predicate::FCMP_ULT:
+  case Predicate::FCMP_ULE:
+  case Predicate::FCMP_UNE:
+  case Predicate::FCMP_TRUE:
+    return getFCmp(Pred, C1, C2, OnlyIfReduced);
+
+  case Predicate::ICMP_EQ:
+  case Predicate::ICMP_NE:
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_UGE:
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_ULE:
+  case Predicate::ICMP_SGT:
+  case Predicate::ICMP_SGE:
+  case Predicate::ICMP_SLT:
+  case Predicate::ICMP_SLE:
+    return getICmp(Pred, C1, C2, OnlyIfReduced);
   }
 }
 
 Constant *ConstantExpr::getSelect(Constant *C, Constant *V1, Constant *V2,
                                   Type *OnlyIfReducedTy) {
   assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
 
   if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C,
   const ConstantExprKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
                                 InBounds ? GEPOperator::IsInBounds : 0, None,
                                 Ty);
 
   LLVMContextImpl *pImpl = C->getContext().pImpl;
   return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
 }
 
-Constant *ConstantExpr::getICmp(unsigned short pred, Constant *LHS,
-                                Constant *RHS, bool OnlyIfReduced) {
+Constant *ConstantExpr::getICmp(Predicate Pred, Constant *LHS, Constant *RHS,
+                                bool OnlyIfReduced) {
   assert(LHS->getType() == RHS->getType());
-  assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE && 
-         pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate");
+  assert(Pred.isInt() && "Invalid ICmp Predicate");
 
-  if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
+  if (Constant *FC = ConstantFoldCompareInstruction(Pred, LHS, RHS))
     return FC;          // Fold a few common cases...
 
   if (OnlyIfReduced)
     return nullptr;
 
   // Look up the constant in the table first to ensure uniqueness
   Constant *ArgVec[] = { LHS, RHS };
   // Get the key type with both the opcode and predicate
-  const ConstantExprKeyType Key(Instruction::ICmp, ArgVec, pred);
+  const ConstantExprKeyType Key(Instruction::ICmp, ArgVec,
+                                static_cast<unsigned short>(Pred.getKind()));
 
   Type *ResultTy = Type::getInt1Ty(LHS->getContext());
   if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
     ResultTy = VectorType::get(ResultTy, VT->getNumElements());
 
   LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
   return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
 }
 
-Constant *ConstantExpr::getFCmp(unsigned short pred, Constant *LHS,
-                                Constant *RHS, bool OnlyIfReduced) {
+Constant *ConstantExpr::getFCmp(Predicate Pred, Constant *LHS, Constant *RHS,
+                                bool OnlyIfReduced) {
   assert(LHS->getType() == RHS->getType());
-  assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate");
+  assert(Pred.isFP() && "Invalid FCmp Predicate");
 
-  if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
+  if (Constant *FC = ConstantFoldCompareInstruction(Pred, LHS, RHS))
     return FC;          // Fold a few common cases...
 
   if (OnlyIfReduced)
     return nullptr;
 
   // Look up the constant in the table first to ensure uniqueness
   Constant *ArgVec[] = { LHS, RHS };
   // Get the key type with both the opcode and predicate
-  const ConstantExprKeyType Key(Instruction::FCmp, ArgVec, pred);
+  const ConstantExprKeyType Key(Instruction::FCmp, ArgVec,
+                                static_cast<unsigned short>(Pred.getKind()));
 
   Type *ResultTy = Type::getInt1Ty(LHS->getContext());
   if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
     ResultTy = VectorType::get(ResultTy, VT->getNumElements());
 
   LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
   return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
 }
case Instruction::GetElementPtr: {
     if (GO->isInBounds())
       return GetElementPtrInst::CreateInBounds(GO->getSourceElementType(),
                                                Ops[0], Ops.slice(1));
     return GetElementPtrInst::Create(GO->getSourceElementType(), Ops[0],
                                      Ops.slice(1));
   }
   case Instruction::ICmp:
   case Instruction::FCmp:
-    return CmpInst::Create((Instruction::OtherOps)getOpcode(),
-                           (CmpInst::Predicate)getPredicate(), Ops[0], Ops[1]);
+    return CmpInst::Create((Instruction::OtherOps)getOpcode(), getPredicate(),
+                           Ops[0], Ops[1]);
 
   default:
     assert(getNumOperands() == 2 && "Must be binary operator?");
     BinaryOperator *BO =
       BinaryOperator::Create((Instruction::BinaryOps)getOpcode(),
                              Ops[0], Ops[1]);
     if (isa<OverflowingBinaryOperator>(BO)) {
       BO->setHasNoUnsignedWrap(SubclassOptionalData &

lib/IR/ConstantsContext.h

 class CompareConstantExpr : public ConstantExpr {
   void anchor() override;
   void *operator new(size_t, unsigned) = delete;
 public:
   // allocate space for exactly two operands
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
-  unsigned short predicate;
+  Predicate predicate;
   CompareConstantExpr(Type *ty, Instruction::OtherOps opc,
                       unsigned short pred,  Constant* LHS, Constant* RHS)
     : ConstantExpr(ty, opc, &Op<0>(), 2), predicate(pred) {
     Op<0>() = LHS;
     Op<1>() = RHS;
   }
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
ConstantExprKeyType(unsigned Opcode, ArrayRef<Constant *> Ops,
                       ArrayRef<unsigned> Indexes = None,
                       Type *ExplicitTy = nullptr)
       : Opcode(Opcode), SubclassOptionalData(SubclassOptionalData),
         SubclassData(SubclassData), Ops(Ops), Indexes(Indexes),
         ExplicitTy(ExplicitTy) {}
   ConstantExprKeyType(ArrayRef<Constant *> Operands, const ConstantExpr *CE)
       : Opcode(CE->getOpcode()),
         SubclassOptionalData(CE->getRawSubclassOptionalData()),
-        SubclassData(CE->isCompare() ? CE->getPredicate() : 0), Ops(Operands),
+        SubclassData(CE->isCompare()
+                         ? static_cast<int>(CE->getPredicate().getKind())
+                         : 0),
+        Ops(Operands),
         Indexes(CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()) {}
   ConstantExprKeyType(const ConstantExpr *CE,
                       SmallVectorImpl<Constant *> &Storage)
       : Opcode(CE->getOpcode()),
         SubclassOptionalData(CE->getRawSubclassOptionalData()),
-        SubclassData(CE->isCompare() ? CE->getPredicate() : 0),
+        SubclassData(CE->isCompare()
+                         ? static_cast<int>(CE->getPredicate().getKind())
+                         : 0),
         Indexes(CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()) {
     assert(Storage.empty() && "Expected empty storage");
     for (unsigned I = 0, E = CE->getNumOperands(); I != E; ++I)
       Storage.push_back(CE->getOperand(I));
     Ops = Storage;
   }
 
   bool operator==(const ConstantExprKeyType &X) const {
     return Opcode == X.Opcode && SubclassData == X.SubclassData &&
            SubclassOptionalData == X.SubclassOptionalData && Ops == X.Ops &&
            Indexes == X.Indexes;
   }
 
   bool operator==(const ConstantExpr *CE) const {
     if (Opcode != CE->getOpcode())
       return false;
     if (SubclassOptionalData != CE->getRawSubclassOptionalData())
       return false;
     if (Ops.size() != CE->getNumOperands())
       return false;
-    if (SubclassData != (CE->isCompare() ? CE->getPredicate() : 0))
+    if (SubclassData !=
+        (CE->isCompare() ? static_cast<int>(CE->getPredicate().getKind()) : 0))
       return false;
     for (unsigned I = 0, E = Ops.size(); I != E; ++I)
       if (Ops[I] != CE->getOperand(I))
         return false;
     if (Indexes != (CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()))
       return false;
     return true;
   }

lib/IR/Core.cpp

return wrap(ConstantExpr::getOr(unwrap<Constant>(LHSConstant),
                                   unwrap<Constant>(RHSConstant)));
 }
 
 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
   return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant),
                                    unwrap<Constant>(RHSConstant)));
 }
 
-LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
-                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getICmp(Predicate,
+LLVMValueRef LLVMConstICmp(LLVMIntPredicate Pred, LLVMValueRef LHSConstant,
+                           LLVMValueRef RHSConstant) {
+  return wrap(ConstantExpr::getICmp(static_cast<Predicate>(Pred),
                                     unwrap<Constant>(LHSConstant),
                                     unwrap<Constant>(RHSConstant)));
 }
 
-LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
-                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getFCmp(Predicate,
+LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Pred, LLVMValueRef LHSConstant,
+                           LLVMValueRef RHSConstant) {
+  return wrap(ConstantExpr::getFCmp(static_cast<Predicate>(Pred),
                                     unwrap<Constant>(LHSConstant),
                                     unwrap<Constant>(RHSConstant)));
 }
 
 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
   return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant),
                                    unwrap<Constant>(RHSConstant)));
 }

 }
 
 void LLVMInstructionEraseFromParent(LLVMValueRef Inst) {
   unwrap<Instruction>(Inst)->eraseFromParent();
 }
 
 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst) {
   if (ICmpInst *I = dyn_cast<ICmpInst>(unwrap(Inst)))
-    return (LLVMIntPredicate)I->getPredicate();
+    return (LLVMIntPredicate)I->getPredicate().getKind();
   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))
     if (CE->getOpcode() == Instruction::ICmp)
-      return (LLVMIntPredicate)CE->getPredicate();
+      return (LLVMIntPredicate)CE->getPredicate().getKind();
   return (LLVMIntPredicate)0;
 }
 
 LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst) {
   if (FCmpInst *I = dyn_cast<FCmpInst>(unwrap(Inst)))
-    return (LLVMRealPredicate)I->getPredicate();
+    return (LLVMRealPredicate)I->getPredicate().getKind();
   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))
     if (CE->getOpcode() == Instruction::FCmp)
-      return (LLVMRealPredicate)CE->getPredicate();
+      return (LLVMRealPredicate)CE->getPredicate().getKind();
   return (LLVMRealPredicate)0;
 }
 
 LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst) {
   if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
     return map_to_llvmopcode(C->getOpcode());
   return (LLVMOpcode)0;
 }
LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val,
   return wrap(unwrap(B)->CreateFPCast(unwrap(Val), unwrap(DestTy), Name));
 }
 
 /*--.. Comparisons .........................................................--*/
 
 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op,
                            LLVMValueRef LHS, LLVMValueRef RHS,
                            const char *Name) {
-  return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op),
-                                    unwrap(LHS), unwrap(RHS), Name));
+  return wrap(unwrap(B)->CreateICmp(static_cast<Predicate>(Op), unwrap(LHS),
+                                    unwrap(RHS), Name));
 }
 
 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op,
                            LLVMValueRef LHS, LLVMValueRef RHS,
                            const char *Name) {
-  return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op),
-                                    unwrap(LHS), unwrap(RHS), Name));
+  return wrap(unwrap(B)->CreateFCmp(static_cast<Predicate>(Op), unwrap(LHS),
+                                    unwrap(RHS), Name));
 }
 
 /*--.. Miscellaneous instructions ..........................................--*/
 
 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
   return wrap(unwrap(B)->CreatePHI(unwrap(Ty), 0, Name));
 }
 

lib/IR/Instructions.cpp

 }
 
 //===----------------------------------------------------------------------===//
 //                               CmpInst Classes
 //===----------------------------------------------------------------------===//
 
 void CmpInst::anchor() {}
 
-CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
-                 Value *RHS, const Twine &Name, Instruction *InsertBefore)
-  : Instruction(ty, op,
-                OperandTraits<CmpInst>::op_begin(this),
-                OperandTraits<CmpInst>::operands(this),
-                InsertBefore) {
-    Op<0>() = LHS;
-    Op<1>() = RHS;
-  setPredicate((Predicate)predicate);
+CmpInst::CmpInst(Type *ty, OtherOps op, Predicate Pred, Value *LHS, Value *RHS,
+                 const Twine &Name, Instruction *InsertBefore)
+    : Instruction(ty, op, OperandTraits<CmpInst>::op_begin(this),
+                  OperandTraits<CmpInst>::operands(this), InsertBefore) {
+  setPredicate(Pred);
   setName(Name);
 }
 
-CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
-                 Value *RHS, const Twine &Name, BasicBlock *InsertAtEnd)
-  : Instruction(ty, op,
-                OperandTraits<CmpInst>::op_begin(this),
-                OperandTraits<CmpInst>::operands(this),
-                InsertAtEnd) {
+CmpInst::CmpInst(Type *ty, OtherOps op, Predicate Pred, Value *LHS, Value *RHS,
+                 const Twine &Name, BasicBlock *InsertAtEnd)
+    : Instruction(ty, op, OperandTraits<CmpInst>::op_begin(this),
+                  OperandTraits<CmpInst>::operands(this), InsertAtEnd) {
   Op<0>() = LHS;
   Op<1>() = RHS;
-  setPredicate((Predicate)predicate);
+  setPredicate(Pred);
   setName(Name);
 }
 
-CmpInst *
-CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2,
+CmpInst *CmpInst::Create(OtherOps Op, Predicate Pred, Value *S1, Value *S2,
                          const Twine &Name, Instruction *InsertBefore) {
   if (Op == Instruction::ICmp) {
     if (InsertBefore)
-      return new ICmpInst(InsertBefore, CmpInst::Predicate(predicate),
-                          S1, S2, Name);
+      return new ICmpInst(InsertBefore, Pred, S1, S2, Name);
     else
-      return new ICmpInst(CmpInst::Predicate(predicate),
-                          S1, S2, Name);
+      return new ICmpInst(Pred, S1, S2, Name);
   }
   
   if (InsertBefore)
-    return new FCmpInst(InsertBefore, CmpInst::Predicate(predicate),
-                        S1, S2, Name);
+    return new FCmpInst(InsertBefore, Pred, S1, S2, Name);
   else
-    return new FCmpInst(CmpInst::Predicate(predicate),
-                        S1, S2, Name);
+    return new FCmpInst(Pred, S1, S2, Name);
 }
 
-CmpInst *
-CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2,
+CmpInst *CmpInst::Create(OtherOps Op, Predicate Pred, Value *S1, Value *S2,
                          const Twine &Name, BasicBlock *InsertAtEnd) {
   if (Op == Instruction::ICmp) {
-    return new ICmpInst(*InsertAtEnd, CmpInst::Predicate(predicate),
-                        S1, S2, Name);
+    return new ICmpInst(*InsertAtEnd, Pred, S1, S2, Name);
   }
-  return new FCmpInst(*InsertAtEnd, CmpInst::Predicate(predicate),
-                      S1, S2, Name);
+  return new FCmpInst(*InsertAtEnd, Pred, S1, S2, Name);
 }
 
 void CmpInst::swapOperands() {
   if (ICmpInst *IC = dyn_cast<ICmpInst>(this))
     IC->swapOperands();
   else
     cast<FCmpInst>(this)->swapOperands();
 }
 
-bool CmpInst::isCommutative() const {
-  if (const ICmpInst *IC = dyn_cast<ICmpInst>(this))
-    return IC->isCommutative();
-  return cast<FCmpInst>(this)->isCommutative();
-}
-
-bool CmpInst::isEquality() const {
-  if (const ICmpInst *IC = dyn_cast<ICmpInst>(this))
-    return IC->isEquality();
-  return cast<FCmpInst>(this)->isEquality();
-}
-
-
-CmpInst::Predicate CmpInst::getInversePredicate(Predicate pred) {
-  switch (pred) {
-    default: llvm_unreachable("Unknown cmp predicate!");
-    case ICMP_EQ: return ICMP_NE;
-    case ICMP_NE: return ICMP_EQ;
-    case ICMP_UGT: return ICMP_ULE;
-    case ICMP_ULT: return ICMP_UGE;
-    case ICMP_UGE: return ICMP_ULT;
-    case ICMP_ULE: return ICMP_UGT;
-    case ICMP_SGT: return ICMP_SLE;
-    case ICMP_SLT: return ICMP_SGE;
-    case ICMP_SGE: return ICMP_SLT;
-    case ICMP_SLE: return ICMP_SGT;
-
-    case FCMP_OEQ: return FCMP_UNE;
-    case FCMP_ONE: return FCMP_UEQ;
-    case FCMP_OGT: return FCMP_ULE;
-    case FCMP_OLT: return FCMP_UGE;
-    case FCMP_OGE: return FCMP_ULT;
-    case FCMP_OLE: return FCMP_UGT;
-    case FCMP_UEQ: return FCMP_ONE;
-    case FCMP_UNE: return FCMP_OEQ;
-    case FCMP_UGT: return FCMP_OLE;
-    case FCMP_ULT: return FCMP_OGE;
-    case FCMP_UGE: return FCMP_OLT;
-    case FCMP_ULE: return FCMP_OGT;
-    case FCMP_ORD: return FCMP_UNO;
-    case FCMP_UNO: return FCMP_ORD;
-    case FCMP_TRUE: return FCMP_FALSE;
-    case FCMP_FALSE: return FCMP_TRUE;
-  }
-}
-
 void ICmpInst::anchor() {}
 
-ICmpInst::Predicate ICmpInst::getSignedPredicate(Predicate pred) {
-  switch (pred) {
-    default: llvm_unreachable("Unknown icmp predicate!");
-    case ICMP_EQ: case ICMP_NE: 
-    case ICMP_SGT: case ICMP_SLT: case ICMP_SGE: case ICMP_SLE: 
-       return pred;
-    case ICMP_UGT: return ICMP_SGT;
-    case ICMP_ULT: return ICMP_SLT;
-    case ICMP_UGE: return ICMP_SGE;
-    case ICMP_ULE: return ICMP_SLE;
-  }
-}
-
-ICmpInst::Predicate ICmpInst::getUnsignedPredicate(Predicate pred) {
-  switch (pred) {
-    default: llvm_unreachable("Unknown icmp predicate!");
-    case ICMP_EQ: case ICMP_NE: 
-    case ICMP_UGT: case ICMP_ULT: case ICMP_UGE: case ICMP_ULE: 
-       return pred;
-    case ICMP_SGT: return ICMP_UGT;
-    case ICMP_SLT: return ICMP_ULT;
-    case ICMP_SGE: return ICMP_UGE;
-    case ICMP_SLE: return ICMP_ULE;
-  }
-}
 
 /// Initialize a set of values that all satisfy the condition with C.
 ///
-ConstantRange 
-ICmpInst::makeConstantRange(Predicate pred, const APInt &C) {
+ConstantRange ICmpInst::makeConstantRange(Predicate Pred, const APInt &C) {
   APInt Lower(C);
   APInt Upper(C);
   uint32_t BitWidth = C.getBitWidth();
-  switch (pred) {
+  switch (Pred.getKind()) {
   default: llvm_unreachable("Invalid ICmp opcode to ConstantRange ctor!");
-  case ICmpInst::ICMP_EQ: ++Upper; break;
-  case ICmpInst::ICMP_NE: ++Lower; break;
-  case ICmpInst::ICMP_ULT:
+  case Predicate::ICMP_EQ:
+    ++Upper;
+    break;
+  case Predicate::ICMP_NE:
+    ++Lower;
+    break;
+  case Predicate::ICMP_ULT:
     Lower = APInt::getMinValue(BitWidth);
     // Check for an empty-set condition.
     if (Lower == Upper)
       return ConstantRange(BitWidth, /*isFullSet=*/false);
     break;
-  case ICmpInst::ICMP_SLT:
+  case Predicate::ICMP_SLT:
     Lower = APInt::getSignedMinValue(BitWidth);
     // Check for an empty-set condition.
     if (Lower == Upper)
       return ConstantRange(BitWidth, /*isFullSet=*/false);
     break;
-  case ICmpInst::ICMP_UGT: 
+  case Predicate::ICMP_UGT:
     ++Lower; Upper = APInt::getMinValue(BitWidth);        // Min = Next(Max)
     // Check for an empty-set condition.
     if (Lower == Upper)
       return ConstantRange(BitWidth, /*isFullSet=*/false);
     break;
-  case ICmpInst::ICMP_SGT:
+  case Predicate::ICMP_SGT:
     ++Lower; Upper = APInt::getSignedMinValue(BitWidth);  // Min = Next(Max)
     // Check for an empty-set condition.
     if (Lower == Upper)
       return ConstantRange(BitWidth, /*isFullSet=*/false);
     break;
-  case ICmpInst::ICMP_ULE: 
+  case Predicate::ICMP_ULE:
     Lower = APInt::getMinValue(BitWidth); ++Upper; 
     // Check for a full-set condition.
     if (Lower == Upper)
       return ConstantRange(BitWidth, /*isFullSet=*/true);
     break;
-  case ICmpInst::ICMP_SLE: 
+  case Predicate::ICMP_SLE:
     Lower = APInt::getSignedMinValue(BitWidth); ++Upper; 
     // Check for a full-set condition.
     if (Lower == Upper)
       return ConstantRange(BitWidth, /*isFullSet=*/true);
     break;
-  case ICmpInst::ICMP_UGE:
+  case Predicate::ICMP_UGE:
     Upper = APInt::getMinValue(BitWidth);        // Min = Next(Max)
     // Check for a full-set condition.
     if (Lower == Upper)
       return ConstantRange(BitWidth, /*isFullSet=*/true);
     break;
-  case ICmpInst::ICMP_SGE:
+  case Predicate::ICMP_SGE:
     Upper = APInt::getSignedMinValue(BitWidth);  // Min = Next(Max)
     // Check for a full-set condition.
     if (Lower == Upper)
       return ConstantRange(BitWidth, /*isFullSet=*/true);
     break;
   }
   return ConstantRange(Lower, Upper);
 }
 
-CmpInst::Predicate CmpInst::getSwappedPredicate(Predicate pred) {
-  switch (pred) {
-    default: llvm_unreachable("Unknown cmp predicate!");
-    case ICMP_EQ: case ICMP_NE:
-      return pred;
-    case ICMP_SGT: return ICMP_SLT;
-    case ICMP_SLT: return ICMP_SGT;
-    case ICMP_SGE: return ICMP_SLE;
-    case ICMP_SLE: return ICMP_SGE;
-    case ICMP_UGT: return ICMP_ULT;
-    case ICMP_ULT: return ICMP_UGT;
-    case ICMP_UGE: return ICMP_ULE;
-    case ICMP_ULE: return ICMP_UGE;
-  
-    case FCMP_FALSE: case FCMP_TRUE:
-    case FCMP_OEQ: case FCMP_ONE:
-    case FCMP_UEQ: case FCMP_UNE:
-    case FCMP_ORD: case FCMP_UNO:
-      return pred;
-    case FCMP_OGT: return FCMP_OLT;
-    case FCMP_OLT: return FCMP_OGT;
-    case FCMP_OGE: return FCMP_OLE;
-    case FCMP_OLE: return FCMP_OGE;
-    case FCMP_UGT: return FCMP_ULT;
-    case FCMP_ULT: return FCMP_UGT;
-    case FCMP_UGE: return FCMP_ULE;
-    case FCMP_ULE: return FCMP_UGE;
-  }
-}
-
-CmpInst::Predicate CmpInst::getSignedPredicate(Predicate pred) {
-  assert(CmpInst::isUnsigned(pred) && "Call only with signed predicates!");
-
-  switch (pred) {
-  default:
-    llvm_unreachable("Unknown predicate!");
-  case CmpInst::ICMP_ULT:
-    return CmpInst::ICMP_SLT;
-  case CmpInst::ICMP_ULE:
-    return CmpInst::ICMP_SLE;
-  case CmpInst::ICMP_UGT:
-    return CmpInst::ICMP_SGT;
-  case CmpInst::ICMP_UGE:
-    return CmpInst::ICMP_SGE;
-  }
-}
-
-bool CmpInst::isUnsigned(Predicate predicate) {
-  switch (predicate) {
-    default: return false;
-    case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_ULE: case ICmpInst::ICMP_UGT: 
-    case ICmpInst::ICMP_UGE: return true;
-  }
-}
-
-bool CmpInst::isSigned(Predicate predicate) {
-  switch (predicate) {
-    default: return false;
-    case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_SLE: case ICmpInst::ICMP_SGT: 
-    case ICmpInst::ICMP_SGE: return true;
-  }
-}
-
-bool CmpInst::isOrdered(Predicate predicate) {
-  switch (predicate) {
-    default: return false;
-    case FCmpInst::FCMP_OEQ: case FCmpInst::FCMP_ONE: case FCmpInst::FCMP_OGT: 
-    case FCmpInst::FCMP_OLT: case FCmpInst::FCMP_OGE: case FCmpInst::FCMP_OLE: 
-    case FCmpInst::FCMP_ORD: return true;
-  }
-}
-      
-bool CmpInst::isUnordered(Predicate predicate) {
-  switch (predicate) {
-    default: return false;
-    case FCmpInst::FCMP_UEQ: case FCmpInst::FCMP_UNE: case FCmpInst::FCMP_UGT: 
-    case FCmpInst::FCMP_ULT: case FCmpInst::FCMP_UGE: case FCmpInst::FCMP_ULE: 
-    case FCmpInst::FCMP_UNO: return true;
-  }
-}
-
-bool CmpInst::isTrueWhenEqual(Predicate predicate) {
-  switch(predicate) {
-    default: return false;
-    case ICMP_EQ:   case ICMP_UGE: case ICMP_ULE: case ICMP_SGE: case ICMP_SLE:
-    case FCMP_TRUE: case FCMP_UEQ: case FCMP_UGE: case FCMP_ULE: return true;
-  }
-}
-
-bool CmpInst::isFalseWhenEqual(Predicate predicate) {
-  switch(predicate) {
-  case ICMP_NE:    case ICMP_UGT: case ICMP_ULT: case ICMP_SGT: case ICMP_SLT:
-  case FCMP_FALSE: case FCMP_ONE: case FCMP_OGT: case FCMP_OLT: return true;
-  default: return false;
-  }
-}
-
-bool CmpInst::isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2) {
-  // If the predicates match, then we know the first condition implies the
-  // second is true.
-  if (Pred1 == Pred2)
-    return true;
-
-  switch (Pred1) {
-  default:
-    break;
-  case ICMP_EQ:
-    // A == B implies A >=u B, A <=u B, A >=s B, and A <=s B are true.
-    return Pred2 == ICMP_UGE || Pred2 == ICMP_ULE || Pred2 == ICMP_SGE ||
-           Pred2 == ICMP_SLE;
-  case ICMP_UGT: // A >u B implies A != B and A >=u B are true.
-    return Pred2 == ICMP_NE || Pred2 == ICMP_UGE;
-  case ICMP_ULT: // A <u B implies A != B and A <=u B are true.
-    return Pred2 == ICMP_NE || Pred2 == ICMP_ULE;
-  case ICMP_SGT: // A >s B implies A != B and A >=s B are true.
-    return Pred2 == ICMP_NE || Pred2 == ICMP_SGE;
-  case ICMP_SLT: // A <s B implies A != B and A <=s B are true.
-    return Pred2 == ICMP_NE || Pred2 == ICMP_SLE;
-  }
-  return false;
-}
-
-bool CmpInst::isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2) {
-  return isImpliedTrueByMatchingCmp(Pred1, getInversePredicate(Pred2));
-}
-
 //===----------------------------------------------------------------------===//
 //                        SwitchInst Implementation
 //===----------------------------------------------------------------------===//
 
 void SwitchInst::init(Value *Value, BasicBlock *Default, unsigned NumReserved) {
   assert(Value && Default && NumReserved);
   ReservedSpace = NumReserved;
   setNumHungOffUseOperands(2);

lib/IR/Verifier.cpp

void Verifier::visitICmpInst(ICmpInst &IC) {
   Type *Op0Ty = IC.getOperand(0)->getType();
   Type *Op1Ty = IC.getOperand(1)->getType();
   Assert(Op0Ty == Op1Ty,
          "Both operands to ICmp instruction are not of the same type!", &IC);
   // Check that the operands are the right type
   Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->getScalarType()->isPointerTy(),
          "Invalid operand types for ICmp instruction", &IC);
   // Check that the predicate is valid.
-  Assert(IC.getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE &&
-             IC.getPredicate() <= CmpInst::LAST_ICMP_PREDICATE,
-         "Invalid predicate in ICmp instruction!", &IC);
+  Assert(IC.getPredicate().isInt(), "Invalid predicate in ICmp instruction!",
+         &IC);
 
   visitInstruction(IC);
 }
 
 void Verifier::visitFCmpInst(FCmpInst &FC) {
   // Check that the operands are the same type
   Type *Op0Ty = FC.getOperand(0)->getType();
   Type *Op1Ty = FC.getOperand(1)->getType();
   Assert(Op0Ty == Op1Ty,
          "Both operands to FCmp instruction are not of the same type!", &FC);
   // Check that the operands are the right type
   Assert(Op0Ty->isFPOrFPVectorTy(),
          "Invalid operand types for FCmp instruction", &FC);
   // Check that the predicate is valid.
-  Assert(FC.getPredicate() >= CmpInst::FIRST_FCMP_PREDICATE &&
-             FC.getPredicate() <= CmpInst::LAST_FCMP_PREDICATE,
-         "Invalid predicate in FCmp instruction!", &FC);
+  Assert(FC.getPredicate().isFP(), "Invalid predicate in FCmp instruction!",
+         &FC);
 
   visitInstruction(FC);
 }
 
 void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
   Assert(
       ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)),
       "Invalid extractelement operands!", &EI);

lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   LockFileManager.cpp
   ManagedStatic.cpp
   MathExtras.cpp
   MemoryBuffer.cpp
   MemoryObject.cpp
   MD5.cpp
   Options.cpp
   PluginLoader.cpp
+  Predicate.cpp
   PrettyStackTrace.cpp
   RandomNumberGenerator.cpp
   Regex.cpp
   ScaledNumber.cpp
   ScopedPrinter.cpp
   SHA1.cpp
   SmallPtrSet.cpp
   SmallVector.cpp

lib/Support/Predicate.cpp

+#include "llvm/Support/Predicate.h"
+
+using namespace llvm;
+
+Predicate Predicate::getInverse() const {
+  switch (Pred) {
+  default:
+    llvm_unreachable("Unknown cmp predicate!");
+  case ICMP_EQ:
+    return ICMP_NE;
+  case ICMP_NE:
+    return ICMP_EQ;
+  case ICMP_UGT:
+    return ICMP_ULE;
+  case ICMP_ULT:
+    return ICMP_UGE;
+  case ICMP_UGE:
+    return ICMP_ULT;
+  case ICMP_ULE:
+    return ICMP_UGT;
+  case ICMP_SGT:
+    return ICMP_SLE;
+  case ICMP_SLT:
+    return ICMP_SGE;
+  case ICMP_SGE:
+    return ICMP_SLT;
+  case ICMP_SLE:
+    return ICMP_SGT;
+
+  case FCMP_OEQ:
+    return FCMP_UNE;
+  case FCMP_ONE:
+    return FCMP_UEQ;
+  case FCMP_OGT:
+    return FCMP_ULE;
+  case FCMP_OLT:
+    return FCMP_UGE;
+  case FCMP_OGE:
+    return FCMP_ULT;
+  case FCMP_OLE:
+    return FCMP_UGT;
+  case FCMP_UEQ:
+    return FCMP_ONE;
+  case FCMP_UNE:
+    return FCMP_OEQ;
+  case FCMP_UGT:
+    return FCMP_OLE;
+  case FCMP_ULT:
+    return FCMP_OGE;
+  case FCMP_UGE:
+    return FCMP_OLT;
+  case FCMP_ULE:
+    return FCMP_OGT;
+  case FCMP_ORD:
+    return FCMP_UNO;
+  case FCMP_UNO:
+    return FCMP_ORD;
+  case FCMP_TRUE:
+    return FCMP_FALSE;
+  case FCMP_FALSE:
+    return FCMP_TRUE;
+  }
+}
+
+Predicate Predicate::getSigned() const {
+  switch (Pred) {
+  default:
+    llvm_unreachable("Unknown icmp predicate!");
+  case ICMP_EQ:
+  case ICMP_NE:
+  case ICMP_SGT:
+  case ICMP_SLT:
+  case ICMP_SGE:
+  case ICMP_SLE:
+    return Pred;
+  case ICMP_UGT:
+    return ICMP_SGT;
+  case ICMP_ULT:
+    return ICMP_SLT;
+  case ICMP_UGE:
+    return ICMP_SGE;
+  case ICMP_ULE:
+    return ICMP_SLE;
+  }
+}
+
+Predicate Predicate::getUnsigned() const {
+  switch (Pred) {
+  default:
+    llvm_unreachable("Unknown icmp predicate!");
+  case ICMP_EQ:
+  case ICMP_NE:
+  case ICMP_UGT:
+  case ICMP_ULT:
+  case ICMP_UGE:
+  case ICMP_ULE:
+    return Pred;
+  case ICMP_SGT:
+    return ICMP_UGT;
+  case ICMP_SLT:
+    return ICMP_ULT;
+  case ICMP_SGE:
+    return ICMP_UGE;
+  case ICMP_SLE:
+    return ICMP_ULE;
+  }
+}
+
+Predicate Predicate::getSwapped() const {
+  switch (Pred) {
+  default:
+    llvm_unreachable("Unknown cmp predicate!");
+  case ICMP_EQ:
+  case ICMP_NE:
+    return Pred;
+  case ICMP_SGT:
+    return ICMP_SLT;
+  case ICMP_SLT:
+    return ICMP_SGT;
+  case ICMP_SGE:
+    return ICMP_SLE;
+  case ICMP_SLE:
+    return ICMP_SGE;
+  case ICMP_UGT:
+    return ICMP_ULT;
+  case ICMP_ULT:
+    return ICMP_UGT;
+  case ICMP_UGE:
+    return ICMP_ULE;
+  case ICMP_ULE:
+    return ICMP_UGE;
+
+  case FCMP_FALSE:
+  case FCMP_TRUE:
+  case FCMP_OEQ:
+  case FCMP_ONE:
+  case FCMP_UEQ:
+  case FCMP_UNE:
+  case FCMP_ORD:
+  case FCMP_UNO:
+    return Pred;
+  case FCMP_OGT:
+    return FCMP_OLT;
+  case FCMP_OLT:
+    return FCMP_OGT;
+  case FCMP_OGE:
+    return FCMP_OLE;
+  case FCMP_OLE:
+    return FCMP_OGE;
+  case FCMP_UGT:
+    return FCMP_ULT;
+  case FCMP_ULT:
+    return FCMP_UGT;
+  case FCMP_UGE:
+    return FCMP_ULE;
+  case FCMP_ULE:
+    return FCMP_UGE;
+  }
+}
+
+bool Predicate::isUnsigned() const {
+  switch (Pred) {
+  default:
+    return false;
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_ULE:
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_UGE:
+    return true;
+  }
+}
+
+bool Predicate::isSigned() const {
+  switch (Pred) {
+  default:
+    return false;
+  case Predicate::ICMP_SLT:
+  case Predicate::ICMP_SLE:
+  case Predicate::ICMP_SGT:
+  case Predicate::ICMP_SGE:
+    return true;
+  }
+}
+
+bool Predicate::isOrdered() const {
+  switch (Pred) {
+  default:
+    return false;
+  case Predicate::FCMP_OEQ:
+  case Predicate::FCMP_ONE:
+  case Predicate::FCMP_OGT:
+  case Predicate::FCMP_OLT:
+  case Predicate::FCMP_OGE:
+  case Predicate::FCMP_OLE:
+  case Predicate::FCMP_ORD:
+    return true;
+  }
+}
+
+bool Predicate::isUnordered() const {
+  switch (Pred) {
+  default:
+    return false;
+  case Predicate::FCMP_UEQ:
+  case Predicate::FCMP_UNE:
+  case Predicate::FCMP_UGT:
+  case Predicate::FCMP_ULT:
+  case Predicate::FCMP_UGE:
+  case Predicate::FCMP_ULE:
+  case Predicate::FCMP_UNO:
+    return true;
+  }
+}
+
+bool Predicate::isTrueWhenEqual() const {
+  switch (Pred) {
+  default:
+    return false;
+  case ICMP_EQ:
+  case ICMP_UGE:
+  case ICMP_ULE:
+  case ICMP_SGE:
+  case ICMP_SLE:
+  case FCMP_TRUE:
+  case FCMP_UEQ:
+  case FCMP_UGE:
+  case FCMP_ULE:
+    return true;
+  }
+}
+
+bool Predicate::isFalseWhenEqual() const {
+  switch (Pred) {
+  case ICMP_NE:
+  case ICMP_UGT:
+  case ICMP_ULT:
+  case ICMP_SGT:
+  case ICMP_SLT:
+  case FCMP_FALSE:
+  case FCMP_ONE:
+  case FCMP_OGT:
+  case FCMP_OLT:
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool Predicate::isEquality() const {
+  return Pred == ICMP_EQ || Pred == ICMP_NE || Pred == FCMP_OEQ ||
+         Pred == FCMP_ONE || Pred == FCMP_UEQ || Pred == FCMP_UNE;
+}
+
+bool Predicate::isCommutative() const {
+  return isEquality() || Pred == FCMP_TRUE || Pred == FCMP_FALSE ||
+         Pred == FCMP_ORD || Pred == FCMP_UNO;
+}
+
+bool Predicate::isRelational() const { return !isCommutative(); }
+
+bool Predicate::isImpliedTrueByMatchingCmp(Predicate Pred2) const {
+  // If the predicates match, then we know the first condition implies the
+  // second is true.
+  if (Pred == Pred2.Pred)
+    return true;
+
+  switch (Pred) {
+  default:
+    break;
+  case ICMP_EQ:
+    // A == B implies A >=u B, A <=u B, A >=s B, and A <=s B are true.
+    return Pred2.Pred == ICMP_UGE || Pred2.Pred == ICMP_ULE ||
+           Pred2.Pred == ICMP_SGE || Pred2.Pred == ICMP_SLE;
+  case ICMP_UGT: // A >u B implies A != B and A >=u B are true.
+    return Pred2.Pred == ICMP_NE || Pred2.Pred == ICMP_UGE;
+  case ICMP_ULT: // A <u B implies A != B and A <=u B are true.
+    return Pred2.Pred == ICMP_NE || Pred2.Pred == ICMP_ULE;
+  case ICMP_SGT: // A >s B implies A != B and A >=s B are true.
+    return Pred2.Pred == ICMP_NE || Pred2.Pred == ICMP_SGE;
+  case ICMP_SLT: // A <s B implies A != B and A <=s B are true.
+    return Pred2.Pred == ICMP_NE || Pred2.Pred == ICMP_SLE;
+  }
+  return false;
+}
+
+bool Predicate::isImpliedFalseByMatchingCmp(Predicate Pred2) const {
+  return isImpliedTrueByMatchingCmp(Pred2.getInverse());
+}
+
+StringRef Predicate::getName() const {
+  const char *Name;
+  switch (Pred) {
+  default:
+    Name = "unknown";
+  case FCMP_FALSE:
+    Name = "false";
+    break;
+  case FCMP_OEQ:
+    Name = "oeq";
+    break;
+  case FCMP_OGT:
+    Name = "ogt";
+    break;
+  case FCMP_OGE:
+    Name = "oge";
+    break;
+  case FCMP_OLT:
+    Name = "olt";
+    break;
+  case FCMP_OLE:
+    Name = "ole";
+    break;
+  case FCMP_ONE:
+    Name = "one";
+    break;
+  case FCMP_ORD:
+    Name = "ord";
+    break;
+  case FCMP_UNO:
+    Name = "uno";
+    break;
+  case FCMP_UEQ:
+    Name = "ueq";
+    break;
+  case FCMP_UGT:
+    Name = "ugt";
+    break;
+  case FCMP_UGE:
+    Name = "uge";
+    break;
+  case FCMP_ULT:
+    Name = "ult";
+    break;
+  case FCMP_ULE:
+    Name = "ule";
+    break;
+  case FCMP_UNE:
+    Name = "une";
+    break;
+  case FCMP_TRUE:
+    Name = "true";
+    break;
+  case ICMP_EQ:
+    Name = "eq";
+    break;
+  case ICMP_NE:
+    Name = "ne";
+    break;
+  case ICMP_SGT:
+    Name = "sgt";
+    break;
+  case ICMP_SGE:
+    Name = "sge";
+    break;
+  case ICMP_SLT:
+    Name = "slt";
+    break;
+  case ICMP_SLE:
+    Name = "sle";
+    break;
+  case ICMP_UGT:
+    Name = "ugt";
+    break;
+  case ICMP_UGE:
+    Name = "uge";
+    break;
+  case ICMP_ULT:
+    Name = "ult";
+    break;
+  case ICMP_ULE:
+    Name = "ule";
+    break;
+  }
+  return Name;
+}

lib/Target/AArch64/AArch64FastISel.cpp

bool AArch64FastISel::selectStore(const Instruction *I) {
   if (!computeAddress(PtrV, Addr, Op0->getType()))
     return false;
 
   if (!emitStore(VT, SrcReg, Addr, createMachineMemOperandFor(I)))
     return false;
   return true;
 }
 
-static AArch64CC::CondCode getCompareCC(CmpInst::Predicate Pred) {
-  switch (Pred) {
-  case CmpInst::FCMP_ONE:
-  case CmpInst::FCMP_UEQ:
+static AArch64CC::CondCode getCompareCC(Predicate Pred) {
+  switch (Pred.getKind()) {
+  case Predicate::FCMP_ONE:
+  case Predicate::FCMP_UEQ:
   default:
     // AL is our "false" for now. The other two need more compares.
     return AArch64CC::AL;
-  case CmpInst::ICMP_EQ:
-  case CmpInst::FCMP_OEQ:
+  case Predicate::ICMP_EQ:
+  case Predicate::FCMP_OEQ:
     return AArch64CC::EQ;
-  case CmpInst::ICMP_SGT:
-  case CmpInst::FCMP_OGT:
+  case Predicate::ICMP_SGT:
+  case Predicate::FCMP_OGT:
     return AArch64CC::GT;
-  case CmpInst::ICMP_SGE:
-  case CmpInst::FCMP_OGE:
+  case Predicate::ICMP_SGE:
+  case Predicate::FCMP_OGE:
     return AArch64CC::GE;
-  case CmpInst::ICMP_UGT:
-  case CmpInst::FCMP_UGT:
+  case Predicate::ICMP_UGT:
+  case Predicate::FCMP_UGT:
     return AArch64CC::HI;
-  case CmpInst::FCMP_OLT:
+  case Predicate::FCMP_OLT:
     return AArch64CC::MI;
-  case CmpInst::ICMP_ULE:
-  case CmpInst::FCMP_OLE:
+  case Predicate::ICMP_ULE:
+  case Predicate::FCMP_OLE:
     return AArch64CC::LS;
-  case CmpInst::FCMP_ORD:
+  case Predicate::FCMP_ORD:
     return AArch64CC::VC;
-  case CmpInst::FCMP_UNO:
+  case Predicate::FCMP_UNO:
     return AArch64CC::VS;
-  case CmpInst::FCMP_UGE:
+  case Predicate::FCMP_UGE:
     return AArch64CC::PL;
-  case CmpInst::ICMP_SLT:
-  case CmpInst::FCMP_ULT:
+  case Predicate::ICMP_SLT:
+  case Predicate::FCMP_ULT:
     return AArch64CC::LT;
-  case CmpInst::ICMP_SLE:
-  case CmpInst::FCMP_ULE:
+  case Predicate::ICMP_SLE:
+  case Predicate::FCMP_ULE:
     return AArch64CC::LE;
-  case CmpInst::FCMP_UNE:
-  case CmpInst::ICMP_NE:
+  case Predicate::FCMP_UNE:
+  case Predicate::ICMP_NE:
     return AArch64CC::NE;
-  case CmpInst::ICMP_UGE:
+  case Predicate::ICMP_UGE:
     return AArch64CC::HS;
-  case CmpInst::ICMP_ULT:
+  case Predicate::ICMP_ULT:
     return AArch64CC::LO;
   }
 }
 
 /// \brief Try to emit a combined compare-and-branch instruction.
 bool AArch64FastISel::emitCompareAndBranch(const BranchInst *BI) {
   assert(isa<CmpInst>(BI->getCondition()) && "Expected cmp instruction");
   const CmpInst *CI = cast<CmpInst>(BI->getCondition());
-  CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);
+  Predicate Pred = optimizeCmpPredicate(CI);
 
   const Value *LHS = CI->getOperand(0);
   const Value *RHS = CI->getOperand(1);
 
   MVT VT;
   if (!isTypeSupported(LHS->getType(), VT))
     return false;
 
   unsigned BW = VT.getSizeInBits();
   if (BW > 64)
     return false;
 
   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 
   // Try to take advantage of fallthrough opportunities.
   if (FuncInfo.MBB->isLayoutSuccessor(TBB)) {
     std::swap(TBB, FBB);
-    Predicate = CmpInst::getInversePredicate(Predicate);
+    Pred = Pred.getInverse();
   }
 
   int TestBit = -1;
   bool IsCmpNE;
-  switch (Predicate) {
+  switch (Pred.getKind()) {
   default:
     return false;
-  case CmpInst::ICMP_EQ:
-  case CmpInst::ICMP_NE:
+  case Predicate::ICMP_EQ:
+  case Predicate::ICMP_NE:
     if (isa<Constant>(LHS) && cast<Constant>(LHS)->isNullValue())
       std::swap(LHS, RHS);
 
     if (!isa<Constant>(RHS) || !cast<Constant>(RHS)->isNullValue())
       return false;
 
     if (const auto *AI = dyn_cast<BinaryOperator>(LHS))
       if (AI->getOpcode() == Instruction::And && isValueAvailable(AI)) {
if (const auto *AI = dyn_cast<BinaryOperator>(LHS))
             TestBit = C->getValue().logBase2();
             LHS = AndLHS;
           }
       }
 
     if (VT == MVT::i1)
       TestBit = 0;
 
-    IsCmpNE = Predicate == CmpInst::ICMP_NE;
+    IsCmpNE = Pred == Predicate::ICMP_NE;
     break;
-  case CmpInst::ICMP_SLT:
-  case CmpInst::ICMP_SGE:
+  case Predicate::ICMP_SLT:
+  case Predicate::ICMP_SGE:
     if (!isa<Constant>(RHS) || !cast<Constant>(RHS)->isNullValue())
       return false;
 
     TestBit = BW - 1;
-    IsCmpNE = Predicate == CmpInst::ICMP_SLT;
+    IsCmpNE = Pred == Predicate::ICMP_SLT;
     break;
-  case CmpInst::ICMP_SGT:
-  case CmpInst::ICMP_SLE:
+  case Predicate::ICMP_SGT:
+  case Predicate::ICMP_SLE:
     if (!isa<ConstantInt>(RHS))
       return false;
 
     if (cast<ConstantInt>(RHS)->getValue() != APInt(BW, -1, true))
       return false;
 
     TestBit = BW - 1;
-    IsCmpNE = Predicate == CmpInst::ICMP_SLE;
+    IsCmpNE = Pred == Predicate::ICMP_SLE;
     break;
   } // end switch
 
   static const unsigned OpcTable[2][2][2] = {
     { {AArch64::CBZW,  AArch64::CBZX },
       {AArch64::CBNZW, AArch64::CBNZX} },
     { {AArch64::TBZW,  AArch64::TBZX },
       {AArch64::TBNZW, AArch64::TBNZX} }
bool AArch64FastISel::selectBranch(const Instruction *I) {
   }
 
   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 
   if (const CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition())) {
     if (CI->hasOneUse() && isValueAvailable(CI)) {
       // Try to optimize or fold the cmp.
-      CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);
-      switch (Predicate) {
+      Predicate Pred = optimizeCmpPredicate(CI);
+      switch (Pred.getKind()) {
       default:
         break;
-      case CmpInst::FCMP_FALSE:
+      case Predicate::FCMP_FALSE:
         fastEmitBranch(FBB, DbgLoc);
         return true;
-      case CmpInst::FCMP_TRUE:
+      case Predicate::FCMP_TRUE:
         fastEmitBranch(TBB, DbgLoc);
         return true;
       }
 
       // Try to emit a combined compare-and-branch first.
       if (emitCompareAndBranch(BI))
         return true;
 
       // Try to take advantage of fallthrough opportunities.
       if (FuncInfo.MBB->isLayoutSuccessor(TBB)) {
         std::swap(TBB, FBB);
-        Predicate = CmpInst::getInversePredicate(Predicate);
+        Pred = Pred.getInverse();
       }
 
       // Emit the cmp.
       if (!emitCmp(CI->getOperand(0), CI->getOperand(1), CI->isUnsigned()))
         return false;
 
       // FCMP_UEQ and FCMP_ONE cannot be checked with a single branch
       // instruction.
-      AArch64CC::CondCode CC = getCompareCC(Predicate);
+      AArch64CC::CondCode CC = getCompareCC(Pred);
       AArch64CC::CondCode ExtraCC = AArch64CC::AL;
-      switch (Predicate) {
+      switch (Pred.getKind()) {
       default:
         break;
-      case CmpInst::FCMP_UEQ:
+      case Predicate::FCMP_UEQ:
         ExtraCC = AArch64CC::EQ;
         CC = AArch64CC::VS;
         break;
-      case CmpInst::FCMP_ONE:
+      case Predicate::FCMP_ONE:
         ExtraCC = AArch64CC::MI;
         CC = AArch64CC::GT;
         break;
       }
       assert((CC != AArch64CC::AL) && "Unexpected condition code.");
 
       // Emit the extra branch for FCMP_UEQ and FCMP_ONE.
       if (ExtraCC != AArch64CC::AL) {

 bool AArch64FastISel::selectCmp(const Instruction *I) {
   const CmpInst *CI = cast<CmpInst>(I);
 
   // Vectors of i1 are weird: bail out.
   if (CI->getType()->isVectorTy())
     return false;
 
   // Try to optimize or fold the cmp.
-  CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);
+  Predicate Pred = optimizeCmpPredicate(CI);
   unsigned ResultReg = 0;
-  switch (Predicate) {
+  switch (Pred.getKind()) {
   default:
     break;
-  case CmpInst::FCMP_FALSE:
+  case Predicate::FCMP_FALSE:
     ResultReg = createResultReg(&AArch64::GPR32RegClass);
     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
             TII.get(TargetOpcode::COPY), ResultReg)
         .addReg(AArch64::WZR, getKillRegState(true));
     break;
-  case CmpInst::FCMP_TRUE:
+  case Predicate::FCMP_TRUE:
     ResultReg = fastEmit_i(MVT::i32, MVT::i32, ISD::Constant, 1);
     break;
   }
 
   if (ResultReg) {
     updateValueMap(I, ResultReg);
     return true;
   }
 
   // Emit the cmp.
   if (!emitCmp(CI->getOperand(0), CI->getOperand(1), CI->isUnsigned()))
     return false;
 
   ResultReg = createResultReg(&AArch64::GPR32RegClass);
 
   // FCMP_UEQ and FCMP_ONE cannot be checked with a single instruction. These
   // condition codes are inverted, because they are used by CSINC.
   static unsigned CondCodeTable[2][2] = {
     { AArch64CC::NE, AArch64CC::VC },
     { AArch64CC::PL, AArch64CC::LE }
   };
   unsigned *CondCodes = nullptr;
-  switch (Predicate) {
+  switch (Pred.getKind()) {
   default:
     break;
-  case CmpInst::FCMP_UEQ:
+  case Predicate::FCMP_UEQ:
     CondCodes = &CondCodeTable[0][0];
     break;
-  case CmpInst::FCMP_ONE:
+  case Predicate::FCMP_ONE:
     CondCodes = &CondCodeTable[1][0];
     break;
   }
 
   if (CondCodes) {
     unsigned TmpReg1 = createResultReg(&AArch64::GPR32RegClass);
     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::CSINCWr),
             TmpReg1)
         .addReg(AArch64::WZR, getKillRegState(true))
         .addReg(AArch64::WZR, getKillRegState(true))
         .addImm(CondCodes[0]);
     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::CSINCWr),
             ResultReg)
         .addReg(TmpReg1, getKillRegState(true))
         .addReg(AArch64::WZR, getKillRegState(true))
         .addImm(CondCodes[1]);
 
     updateValueMap(I, ResultReg);
     return true;
   }
 
   // Now set a register based on the comparison.
-  AArch64CC::CondCode CC = getCompareCC(Predicate);
+  AArch64CC::CondCode CC = getCompareCC(Pred);
   assert((CC != AArch64CC::AL) && "Unexpected condition code.");
   AArch64CC::CondCode invertedCC = getInvertedCondCode(CC);
   BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AArch64::CSINCWr),
           ResultReg)
       .addReg(AArch64::WZR, getKillRegState(true))
       .addReg(AArch64::WZR, getKillRegState(true))
       .addImm(invertedCC);
 
if (foldXALUIntrinsic(CC, I, Cond)) {
     // Fake request the condition to force emission of the XALU intrinsic.
     unsigned CondReg = getRegForValue(Cond);
     if (!CondReg)
       return false;
   } else if (isa<CmpInst>(Cond) && cast<CmpInst>(Cond)->hasOneUse() &&
              isValueAvailable(Cond)) {
     const auto *Cmp = cast<CmpInst>(Cond);
     // Try to optimize or fold the cmp.
-    CmpInst::Predicate Predicate = optimizeCmpPredicate(Cmp);
+    Predicate Pred = optimizeCmpPredicate(Cmp);
     const Value *FoldSelect = nullptr;
-    switch (Predicate) {
+    switch (Pred.getKind()) {
     default:
       break;
-    case CmpInst::FCMP_FALSE:
+    case Predicate::FCMP_FALSE:
       FoldSelect = SI->getFalseValue();
       break;
-    case CmpInst::FCMP_TRUE:
+    case Predicate::FCMP_TRUE:
       FoldSelect = SI->getTrueValue();
       break;
     }
 
     if (FoldSelect) {
       unsigned SrcReg = getRegForValue(FoldSelect);
       if (!SrcReg)
         return false;
       unsigned UseReg = lookUpRegForValue(SI);
       if (UseReg)
         MRI.clearKillFlags(UseReg);
 
       updateValueMap(I, SrcReg);
       return true;
     }
 
     // Emit the cmp.
     if (!emitCmp(Cmp->getOperand(0), Cmp->getOperand(1), Cmp->isUnsigned()))
       return false;
 
     // FCMP_UEQ and FCMP_ONE cannot be checked with a single select instruction.
-    CC = getCompareCC(Predicate);
-    switch (Predicate) {
+    CC = getCompareCC(Pred);
+    switch (Pred.getKind()) {
     default:
       break;
-    case CmpInst::FCMP_UEQ:
+    case Predicate::FCMP_UEQ:
       ExtraCC = AArch64CC::EQ;
       CC = AArch64CC::VS;
       break;
-    case CmpInst::FCMP_ONE:
+    case Predicate::FCMP_ONE:
       ExtraCC = AArch64CC::MI;
       CC = AArch64CC::GT;
       break;
     }
     assert((CC != AArch64CC::AL) && "Unexpected condition code.");
   } else {
     unsigned CondReg = getRegForValue(Cond);
     if (!CondReg)

lib/Target/AMDGPU/SIISelLowering.cpp

case Intrinsic::amdgcn_div_scale: {
 
     SDValue Src0 = Param->isAllOnesValue() ? Numerator : Denominator;
 
     return DAG.getNode(AMDGPUISD::DIV_SCALE, DL, Op->getVTList(), Src0,
                        Denominator, Numerator);
   }
   case Intrinsic::amdgcn_icmp: {
     const auto *CD = dyn_cast<ConstantSDNode>(Op.getOperand(3));
-    int CondCode = CD->getSExtValue();
+    Predicate IcInput(CD->getSExtValue());
 
-    if (CondCode < ICmpInst::Predicate::FIRST_ICMP_PREDICATE ||
-         CondCode >= ICmpInst::Predicate::BAD_ICMP_PREDICATE)
+    if (!IcInput.isInt())
       return DAG.getUNDEF(VT);
 
-    ICmpInst::Predicate IcInput =
-     static_cast<ICmpInst::Predicate>(CondCode);
     ISD::CondCode CCOpcode = getICmpCondCode(IcInput);
     return DAG.getNode(AMDGPUISD::SETCC, DL, VT, Op.getOperand(1),
                        Op.getOperand(2), DAG.getCondCode(CCOpcode));
   }
   case Intrinsic::amdgcn_fcmp: {
     const auto *CD = dyn_cast<ConstantSDNode>(Op.getOperand(3));
-    int CondCode = CD->getSExtValue();
+    Predicate IcInput(CD->getSExtValue());
 
-    if (CondCode <= FCmpInst::Predicate::FCMP_FALSE ||
-         CondCode >= FCmpInst::Predicate::FCMP_TRUE)
+    if (!IcInput.isFP())
       return DAG.getUNDEF(VT);
 
-    FCmpInst::Predicate IcInput =
-     static_cast<FCmpInst::Predicate>(CondCode);
     ISD::CondCode CCOpcode = getFCmpCondCode(IcInput);
     return DAG.getNode(AMDGPUISD::SETCC, DL, VT, Op.getOperand(1),
                        Op.getOperand(2), DAG.getCondCode(CCOpcode));
   }
   case Intrinsic::amdgcn_fmul_legacy:
     return DAG.getNode(AMDGPUISD::FMUL_LEGACY, DL, VT,
                        Op.getOperand(1), Op.getOperand(2));
   case Intrinsic::amdgcn_sffbh:

lib/Target/ARM/ARMFastISel.cpp

bool ARMFastISel::SelectStore(const Instruction *I) {
   if (!ARMComputeAddress(I->getOperand(1), Addr))
     return false;
 
   if (!ARMEmitStore(VT, SrcReg, Addr, cast<StoreInst>(I)->getAlignment()))
     return false;
   return true;
 }
 
-static ARMCC::CondCodes getComparePred(CmpInst::Predicate Pred) {
-  switch (Pred) {
-    // Needs two compares...
-    case CmpInst::FCMP_ONE:
-    case CmpInst::FCMP_UEQ:
-    default:
-      // AL is our "false" for now. The other two need more compares.
-      return ARMCC::AL;
-    case CmpInst::ICMP_EQ:
-    case CmpInst::FCMP_OEQ:
-      return ARMCC::EQ;
-    case CmpInst::ICMP_SGT:
-    case CmpInst::FCMP_OGT:
-      return ARMCC::GT;
-    case CmpInst::ICMP_SGE:
-    case CmpInst::FCMP_OGE:
-      return ARMCC::GE;
-    case CmpInst::ICMP_UGT:
-    case CmpInst::FCMP_UGT:
-      return ARMCC::HI;
-    case CmpInst::FCMP_OLT:
-      return ARMCC::MI;
-    case CmpInst::ICMP_ULE:
-    case CmpInst::FCMP_OLE:
-      return ARMCC::LS;
-    case CmpInst::FCMP_ORD:
-      return ARMCC::VC;
-    case CmpInst::FCMP_UNO:
-      return ARMCC::VS;
-    case CmpInst::FCMP_UGE:
-      return ARMCC::PL;
-    case CmpInst::ICMP_SLT:
-    case CmpInst::FCMP_ULT:
-      return ARMCC::LT;
-    case CmpInst::ICMP_SLE:
-    case CmpInst::FCMP_ULE:
-      return ARMCC::LE;
-    case CmpInst::FCMP_UNE:
-    case CmpInst::ICMP_NE:
-      return ARMCC::NE;
-    case CmpInst::ICMP_UGE:
-      return ARMCC::HS;
-    case CmpInst::ICMP_ULT:
-      return ARMCC::LO;
+static ARMCC::CondCodes getComparePred(Predicate Pred) {
+  switch (Pred.getKind()) {
+  case Predicate::FCMP_ONE:
+  case Predicate::FCMP_UEQ:
+  case Predicate::ICMP_EQ:
+  case Predicate::FCMP_OEQ:
+  case Predicate::ICMP_SGT:
+  case Predicate::FCMP_OGT:
+  case Predicate::ICMP_SGE:
+  case Predicate::FCMP_OGE:
+  case Predicate::ICMP_UGT:
+  case Predicate::FCMP_UGT:
+  case Predicate::FCMP_OLT:
+  case Predicate::ICMP_ULE:
+  case Predicate::FCMP_OLE:
+  case Predicate::FCMP_ORD:
+  case Predicate::FCMP_UNO:
+  case Predicate::FCMP_UGE:
+  case Predicate::ICMP_SLT:
+  case Predicate::FCMP_ULT:
+  case Predicate::ICMP_SLE:
+  case Predicate::FCMP_ULE:
+  case Predicate::FCMP_UNE:
+  case Predicate::ICMP_NE:
+  case Predicate::ICMP_UGE:
+  case Predicate::ICMP_ULT:
   }
 }
 
 bool ARMFastISel::SelectBranch(const Instruction *I) {
   const BranchInst *BI = cast<BranchInst>(I);
   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 
   // Simple branch support.
 
   // If we can, avoid recomputing the compare - redoing it could lead to wonky
   // behavior.
   if (const CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition())) {
     if (CI->hasOneUse() && (CI->getParent() == I->getParent())) {
 
       // Get the compare predicate.
       // Try to take advantage of fallthrough opportunities.
-      CmpInst::Predicate Predicate = CI->getPredicate();
+      Predicate Pred = CI->getPredicate();
       if (FuncInfo.MBB->isLayoutSuccessor(TBB)) {
         std::swap(TBB, FBB);
-        Predicate = CmpInst::getInversePredicate(Predicate);
+        Pred = Pred.getInverse();
       }
 
-      ARMCC::CondCodes ARMPred = getComparePred(Predicate);
+      ARMCC::CondCodes ARMPred = getComparePred(Pred);
 
       // We may not handle every CC for now.
       if (ARMPred == ARMCC::AL) return false;
 
       // Emit the compare.
       if (!ARMEmitCmp(CI->getOperand(0), CI->getOperand(1), CI->isUnsigned()))
         return false;
 

lib/Target/Mips/MipsFastISel.cpp

bool MipsFastISel::emitCmp(unsigned ResultReg, const CmpInst *CI) {
   const Value *Left = CI->getOperand(0), *Right = CI->getOperand(1);
   bool IsUnsigned = CI->isUnsigned();
   unsigned LeftReg = getRegEnsuringSimpleIntegerWidening(Left, IsUnsigned);
   if (LeftReg == 0)
     return false;
   unsigned RightReg = getRegEnsuringSimpleIntegerWidening(Right, IsUnsigned);
   if (RightReg == 0)
     return false;
-  CmpInst::Predicate P = CI->getPredicate();
+  Predicate P = CI->getPredicate();
 
-  switch (P) {
+  switch (P.getKind()) {
   default:
     return false;
-  case CmpInst::ICMP_EQ: {
+  case Predicate::ICMP_EQ: {
     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
     emitInst(Mips::XOR, TempReg).addReg(LeftReg).addReg(RightReg);
     emitInst(Mips::SLTiu, ResultReg).addReg(TempReg).addImm(1);
     break;
   }
-  case CmpInst::ICMP_NE: {
+  case Predicate::ICMP_NE: {
     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
     emitInst(Mips::XOR, TempReg).addReg(LeftReg).addReg(RightReg);
     emitInst(Mips::SLTu, ResultReg).addReg(Mips::ZERO).addReg(TempReg);
     break;
   }
-  case CmpInst::ICMP_UGT: {
+  case Predicate::ICMP_UGT: {
     emitInst(Mips::SLTu, ResultReg).addReg(RightReg).addReg(LeftReg);
     break;
   }
-  case CmpInst::ICMP_ULT: {
+  case Predicate::ICMP_ULT: {
     emitInst(Mips::SLTu, ResultReg).addReg(LeftReg).addReg(RightReg);
     break;
   }
-  case CmpInst::ICMP_UGE: {
+  case Predicate::ICMP_UGE: {
     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
     emitInst(Mips::SLTu, TempReg).addReg(LeftReg).addReg(RightReg);
     emitInst(Mips::XORi, ResultReg).addReg(TempReg).addImm(1);
     break;
   }
-  case CmpInst::ICMP_ULE: {
+  case Predicate::ICMP_ULE: {
     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
     emitInst(Mips::SLTu, TempReg).addReg(RightReg).addReg(LeftReg);
     emitInst(Mips::XORi, ResultReg).addReg(TempReg).addImm(1);
     break;
   }
-  case CmpInst::ICMP_SGT: {
+  case Predicate::ICMP_SGT: {
     emitInst(Mips::SLT, ResultReg).addReg(RightReg).addReg(LeftReg);
     break;
   }
-  case CmpInst::ICMP_SLT: {
+  case Predicate::ICMP_SLT: {
     emitInst(Mips::SLT, ResultReg).addReg(LeftReg).addReg(RightReg);
     break;
   }
-  case CmpInst::ICMP_SGE: {
+  case Predicate::ICMP_SGE: {
     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
     emitInst(Mips::SLT, TempReg).addReg(LeftReg).addReg(RightReg);
     emitInst(Mips::XORi, ResultReg).addReg(TempReg).addImm(1);
     break;
   }
-  case CmpInst::ICMP_SLE: {
+  case Predicate::ICMP_SLE: {
     unsigned TempReg = createResultReg(&Mips::GPR32RegClass);
     emitInst(Mips::SLT, TempReg).addReg(RightReg).addReg(LeftReg);
     emitInst(Mips::XORi, ResultReg).addReg(TempReg).addImm(1);
     break;
   }
-  case CmpInst::FCMP_OEQ:
-  case CmpInst::FCMP_UNE:
-  case CmpInst::FCMP_OLT:
-  case CmpInst::FCMP_OLE:
-  case CmpInst::FCMP_OGT:
-  case CmpInst::FCMP_OGE: {
+  case Predicate::FCMP_OEQ:
+  case Predicate::FCMP_UNE:
+  case Predicate::FCMP_OLT:
+  case Predicate::FCMP_OLE:
+  case Predicate::FCMP_OGT:
+  case Predicate::FCMP_OGE: {
     if (UnsupportedFPMode)
       return false;
     bool IsFloat = Left->getType()->isFloatTy();
     bool IsDouble = Left->getType()->isDoubleTy();
     if (!IsFloat && !IsDouble)
       return false;
     unsigned Opc, CondMovOpc;
-    switch (P) {
-    case CmpInst::FCMP_OEQ:
+    switch (P.getKind()) {
+    case Predicate::FCMP_OEQ:
       Opc = IsFloat ? Mips::C_EQ_S : Mips::C_EQ_D32;
       CondMovOpc = Mips::MOVT_I;
       break;
-    case CmpInst::FCMP_UNE:
+    case Predicate::FCMP_UNE:
       Opc = IsFloat ? Mips::C_EQ_S : Mips::C_EQ_D32;
       CondMovOpc = Mips::MOVF_I;
       break;
-    case CmpInst::FCMP_OLT:
+    case Predicate::FCMP_OLT:
       Opc = IsFloat ? Mips::C_OLT_S : Mips::C_OLT_D32;
       CondMovOpc = Mips::MOVT_I;
       break;
-    case CmpInst::FCMP_OLE:
+    case Predicate::FCMP_OLE:
       Opc = IsFloat ? Mips::C_OLE_S : Mips::C_OLE_D32;
       CondMovOpc = Mips::MOVT_I;
       break;
-    case CmpInst::FCMP_OGT:
+    case Predicate::FCMP_OGT:
       Opc = IsFloat ? Mips::C_ULE_S : Mips::C_ULE_D32;
       CondMovOpc = Mips::MOVF_I;
       break;
-    case CmpInst::FCMP_OGE:
+    case Predicate::FCMP_OGE:
       Opc = IsFloat ? Mips::C_ULT_S : Mips::C_ULT_D32;
       CondMovOpc = Mips::MOVF_I;
       break;
     default:
       llvm_unreachable("Only switching of a subset of CCs.");
     }
     unsigned RegWithZero = createResultReg(&Mips::GPR32RegClass);
     unsigned RegWithOne = createResultReg(&Mips::GPR32RegClass);

lib/Target/NVPTX/NVPTXGenericToNVVM.cpp

Value *GenericToNVVM::remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
   }
 
   // If any of the operands has been modified, construct the instruction with
   // the converted operands.
   unsigned Opcode = C->getOpcode();
   switch (Opcode) {
   case Instruction::ICmp:
     // CompareConstantExpr (icmp)
-    return Builder.CreateICmp(CmpInst::Predicate(C->getPredicate()),
-                              NewOperands[0], NewOperands[1]);
+    return Builder.CreateICmp(Predicate(C->getPredicate()), NewOperands[0],
+                              NewOperands[1]);
   case Instruction::FCmp:
     // CompareConstantExpr (fcmp)
     llvm_unreachable("Address space conversion should have no effect "
                      "on float point CompareConstantExpr (fcmp)!");
   case Instruction::ExtractElement:
     // ExtractElementConstantExpr
     return Builder.CreateExtractElement(NewOperands[0], NewOperands[1]);
   case Instruction::InsertElement:

lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp

void convertMemMoveToLoop(Instruction *ConvertedInst, Value *SrcAddr,
   BasicBlock *OrigBB = ConvertedInst->getParent();
 
   // Create the a comparison of src and dst, based on which we jump to either
   // the forward-copy part of the function (if src >= dst) or the backwards-copy
   // part (if src < dst).
   // SplitBlockAndInsertIfThenElse conveniently creates the basic if-then-else
   // structure. Its block terminators (unconditional branches) are replaced by
   // the appropriate conditional branches when the loop is built.
-  ICmpInst *PtrCompare = new ICmpInst(ConvertedInst, ICmpInst::ICMP_ULT,
+  ICmpInst *PtrCompare = new ICmpInst(ConvertedInst, Predicate::ICMP_ULT,
                                       SrcAddr, DstAddr, "compare_src_dst");
   TerminatorInst *ThenTerm, *ElseTerm;
   SplitBlockAndInsertIfThenElse(PtrCompare, ConvertedInst, &ThenTerm,
                                 &ElseTerm);
 
   // Each part of the function consists of two blocks:
   //   copy_backwards:        used to skip the loop when n == 0
   //   copy_backwards_loop:   the actual backwards loop BB
   //   copy_forward:          used to skip the loop when n == 0
   //   copy_forward_loop:     the actual forward loop BB
   BasicBlock *CopyBackwardsBB = ThenTerm->getParent();
   CopyBackwardsBB->setName("copy_backwards");
   BasicBlock *CopyForwardBB = ElseTerm->getParent();
   CopyForwardBB->setName("copy_forward");
   BasicBlock *ExitBB = ConvertedInst->getParent();
   ExitBB->setName("memmove_done");
 
   // Initial comparison of n == 0 that lets us skip the loops altogether. Shared
   // between both backwards and forward copy clauses.
   ICmpInst *CompareN =
-      new ICmpInst(OrigBB->getTerminator(), ICmpInst::ICMP_EQ, CopyLen,
+      new ICmpInst(OrigBB->getTerminator(), Predicate::ICMP_EQ, CopyLen,
                    ConstantInt::get(TypeOfCopyLen, 0), "compare_n_to_0");
 
   // Copying backwards.
   BasicBlock *LoopBB =
       BasicBlock::Create(Context, "copy_backwards_loop", &F, CopyForwardBB);
   IRBuilder<> LoopBuilder(LoopBB);
   PHINode *LoopPhi = LoopBuilder.CreatePHI(TypeOfCopyLen, 0);
   Value *IndexPtr = LoopBuilder.CreateSub(

lib/Target/PowerPC/PPCFastISel.cpp

CCAssignFn *PPCFastISel::usePPC32CCs(unsigned Flag) {
   else if (Flag == 2)
     return CC_PPC32_SVR4_ByVal;
   else if (Flag == 3)
     return CC_PPC32_SVR4_VarArg;
   else
     return RetCC_PPC;
 }
 
-static Optional<PPC::Predicate> getComparePred(CmpInst::Predicate Pred) {
-  switch (Pred) {
-    // These are not representable with any single compare.
-    case CmpInst::FCMP_FALSE:
-    case CmpInst::FCMP_TRUE:
-    // Major concern about the following 6 cases is NaN result. The comparison
-    // result consists of 4 bits, indicating lt, eq, gt and un (unordered),
-    // only one of which will be set. The result is generated by fcmpu
-    // instruction. However, bc instruction only inspects one of the first 3
-    // bits, so when un is set, bc instruction may jump to to an undesired
-    // place.
-    //
-    // More specifically, if we expect an unordered comparison and un is set, we
-    // expect to always go to true branch; in such case UEQ, UGT and ULT still
-    // give false, which are undesired; but UNE, UGE, ULE happen to give true,
-    // since they are tested by inspecting !eq, !lt, !gt, respectively.
-    //
-    // Similarly, for ordered comparison, when un is set, we always expect the
-    // result to be false. In such case OGT, OLT and OEQ is good, since they are
-    // actually testing GT, LT, and EQ respectively, which are false. OGE, OLE
-    // and ONE are tested through !lt, !gt and !eq, and these are true.
-    case CmpInst::FCMP_UEQ:
-    case CmpInst::FCMP_UGT:
-    case CmpInst::FCMP_ULT:
-    case CmpInst::FCMP_OGE:
-    case CmpInst::FCMP_OLE:
-    case CmpInst::FCMP_ONE:
-    default:
-      return Optional<PPC::Predicate>();
+static Optional<PPC::Predicate> getComparePred(Predicate Pred) {
+  switch (Pred.getKind()) {
+  case Predicate::FCMP_FALSE:
+  case Predicate::FCMP_TRUE:
+  case Predicate::FCMP_UEQ:
+  case Predicate::FCMP_UGT:
+  case Predicate::FCMP_ULT:
+  case Predicate::FCMP_OGE:
+  case Predicate::FCMP_OLE:
+  case Predicate::FCMP_ONE:
 
-    case CmpInst::FCMP_OEQ:
-    case CmpInst::ICMP_EQ:
-      return PPC::PRED_EQ;
+  case Predicate::FCMP_OEQ:
+  case Predicate::ICMP_EQ:
 
-    case CmpInst::FCMP_OGT:
-    case CmpInst::ICMP_UGT:
-    case CmpInst::ICMP_SGT:
-      return PPC::PRED_GT;
+  case Predicate::FCMP_OGT:
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_SGT:
 
-    case CmpInst::FCMP_UGE:
-    case CmpInst::ICMP_UGE:
-    case CmpInst::ICMP_SGE:
-      return PPC::PRED_GE;
+  case Predicate::FCMP_UGE:
+  case Predicate::ICMP_UGE:
+  case Predicate::ICMP_SGE:
 
-    case CmpInst::FCMP_OLT:
-    case CmpInst::ICMP_ULT:
-    case CmpInst::ICMP_SLT:
-      return PPC::PRED_LT;
+  case Predicate::FCMP_OLT:
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_SLT:
 
-    case CmpInst::FCMP_ULE:
-    case CmpInst::ICMP_ULE:
-    case CmpInst::ICMP_SLE:
-      return PPC::PRED_LE;
+  case Predicate::FCMP_ULE:
+  case Predicate::ICMP_ULE:
+  case Predicate::ICMP_SLE:
 
-    case CmpInst::FCMP_UNE:
-    case CmpInst::ICMP_NE:
-      return PPC::PRED_NE;
+  case Predicate::FCMP_UNE:
+  case Predicate::ICMP_NE:
 
-    case CmpInst::FCMP_ORD:
-      return PPC::PRED_NU;
+  case Predicate::FCMP_ORD:
 
-    case CmpInst::FCMP_UNO:
-      return PPC::PRED_UN;
+  case Predicate::FCMP_UNO:
   }
 }
 
 // Determine whether the type Ty is simple enough to be handled by
 // fast-isel, and return its equivalent machine type in VT.
 // FIXME: Copied directly from ARM -- factor into base class?
 bool PPCFastISel::isTypeLegal(Type *Ty, MVT &VT) {
   EVT Evt = TLI.getValueType(DL, Ty, true);

lib/Target/SystemZ/SystemZTDC.cpp

void SystemZTDCPass::convertFCmp(CmpInst &I) {
   if (Const->isZero()) {
     // All comparisons with 0 can be converted.
     WhichConst = 0;
   } else if (Const->isInfinity()) {
     // Likewise for infinities.
     WhichConst = Const->isNegative() ? 2 : 1;
   } else if (Const->isExactlyValue(Smallest)) {
     // For Smallest, we cannot do EQ separately from GT.
-    if ((Pred & CmpInst::FCMP_OGE) != CmpInst::FCMP_OGE &&
-        (Pred & CmpInst::FCMP_OGE) != 0)
+    if ((Pred.getKind() & Predicate::FCMP_OGE) != Predicate::FCMP_OGE &&
+        (Pred.getKind() & Predicate::FCMP_OGE) != 0)
       return;
     WhichConst = 3;
   } else if (Const->isExactlyValue(NegSmallest)) {
     // Likewise for NegSmallest, we cannot do EQ separately from LT.
-    if ((Pred & CmpInst::FCMP_OLE) != CmpInst::FCMP_OLE &&
-        (Pred & CmpInst::FCMP_OLE) != 0)
+    if ((Pred.getKind() & Predicate::FCMP_OLE) != Predicate::FCMP_OLE &&
+        (Pred.getKind() & Predicate::FCMP_OLE) != 0)
       return;
     WhichConst = 4;
   } else {
     // Not one of our special constants.
     return;
   }
   // Partial masks to use for EQ, GT, LT, UN comparisons, respectively.
   static const int Masks[][4] = {
static const int Masks[][4] = {
        SystemZ::TDCMASK_SUBNORMAL_MINUS), // gt
       (SystemZ::TDCMASK_NORMAL_MINUS |
        SystemZ::TDCMASK_INFINITY_MINUS),  // lt (actually le)
       SystemZ::TDCMASK_NAN,               // un
     }
   };
   // Construct the mask as a combination of the partial masks.
   int Mask = 0;
-  if (Pred & CmpInst::FCMP_OEQ)
+  if (Pred.getKind() & Predicate::FCMP_OEQ)
     Mask |= Masks[WhichConst][0];
-  if (Pred & CmpInst::FCMP_OGT)
+  if (Pred.getKind() & Predicate::FCMP_OGT)
     Mask |= Masks[WhichConst][1];
-  if (Pred & CmpInst::FCMP_OLT)
+  if (Pred.getKind() & Predicate::FCMP_OLT)
     Mask |= Masks[WhichConst][2];
-  if (Pred & CmpInst::FCMP_UNO)
+  if (Pred.getKind() & Predicate::FCMP_UNO)
     Mask |= Masks[WhichConst][3];
   // A lone fcmp is unworthy of tdc conversion on its own, but may become
   // worthy if combined with fabs.
   bool Worthy = false;
   if (CallInst *CI = dyn_cast<CallInst>(Op0)) {
     Function *F = CI->getCalledFunction();
     if (F && F->getIntrinsicID() == Intrinsic::fabs) {
       // Fold with fabs - adjust the mask appropriately.
void SystemZTDCPass::convertICmp(CmpInst &I) {
   if (auto *Cast = dyn_cast<BitCastInst>(Op0)) {
     // Check for icmp+bitcast used for signbit.
     if (!Cast->getSrcTy()->isFloatTy() &&
         !Cast->getSrcTy()->isDoubleTy() &&
         !Cast->getSrcTy()->isFP128Ty())
       return;
     Value *V = Cast->getOperand(0);
     int Mask;
-    if (Pred == CmpInst::ICMP_SLT && Const->isZero()) {
+    if (Pred == Predicate::ICMP_SLT && Const->isZero()) {
       // icmp slt (bitcast X), 0 - set if sign bit true
       Mask = SystemZ::TDCMASK_MINUS;
-    } else if (Pred == CmpInst::ICMP_SGT && Const->isMinusOne()) {
+    } else if (Pred == Predicate::ICMP_SGT && Const->isMinusOne()) {
       // icmp sgt (bitcast X), -1 - set if sign bit false
       Mask = SystemZ::TDCMASK_PLUS;
     } else {
       // Not a sign bit check.
       return;
     }
     PossibleJunk.insert(Cast);
     converted(&I, V, Mask, true);
   } else if (auto *CI = dyn_cast<CallInst>(Op0)) {
     // Check if this is a pre-existing call of our tdc intrinsic.
     Function *F = CI->getCalledFunction();
     if (!F || F->getIntrinsicID() != Intrinsic::s390_tdc)
       return;
     if (!Const->isZero())
       return;
     Value *V = CI->getArgOperand(0);
     auto *MaskC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
     // Bail if the mask is not a constant.
     if (!MaskC)
       return;
     int Mask = MaskC->getZExtValue();
     Mask &= SystemZ::TDCMASK_ALL;
-    if (Pred == CmpInst::ICMP_NE) {
+    if (Pred == Predicate::ICMP_NE) {
       // icmp ne (call llvm.s390.tdc(...)), 0 -> simple TDC
-    } else if (Pred == CmpInst::ICMP_EQ) {
+    } else if (Pred == Predicate::ICMP_EQ) {
       // icmp eq (call llvm.s390.tdc(...)), 0 -> TDC with inverted mask
       Mask ^= SystemZ::TDCMASK_ALL;
     } else {
       // An unknown comparison - ignore.
       return;
     }
     PossibleJunk.insert(CI);
     converted(&I, V, Mask, false);
if (!I->user_empty()) {
       if (!Worthy)
         continue;
       // Call the intrinsic, compare result with 0.
       Value *TDCFunc = Intrinsic::getDeclaration(&M, Intrinsic::s390_tdc,
                                                  V->getType());
       IRBuilder<> IRB(I);
       Value *MaskVal = ConstantInt::get(Type::getInt64Ty(Ctx), Mask);
       Instruction *TDC = IRB.CreateCall(TDCFunc, {V, MaskVal});
-      Value *ICmp = IRB.CreateICmp(CmpInst::ICMP_NE, TDC, Zero32);
+      Value *ICmp = IRB.CreateICmp(Predicate::ICMP_NE, TDC, Zero32);
       I->replaceAllUsesWith(ICmp);
     }
     // If unused, or used and converted, remove it.
     I->eraseFromParent();
     MadeChange = true;
   }
 
   if (!MadeChange)

lib/Target/X86/X86FastISel.cpp

bool foldX86XALUIntrinsic(X86::CondCode &CC, const Instruction *I,
                             const Value *Cond);
 
   const MachineInstrBuilder &addFullAddress(const MachineInstrBuilder &MIB,
                                             X86AddressMode &AM);
 };
 
 } // end anonymous namespace.
 
-static std::pair<X86::CondCode, bool>
-getX86ConditionCode(CmpInst::Predicate Predicate) {
+static std::pair<X86::CondCode, bool> getX86ConditionCode(Predicate Predicate) {
   X86::CondCode CC = X86::COND_INVALID;
   bool NeedSwap = false;
-  switch (Predicate) {
+  switch (Predicate.getKind()) {
   default: break;
   // Floating-point Predicates
-  case CmpInst::FCMP_UEQ: CC = X86::COND_E;       break;
-  case CmpInst::FCMP_OLT: NeedSwap = true; // fall-through
-  case CmpInst::FCMP_OGT: CC = X86::COND_A;       break;
-  case CmpInst::FCMP_OLE: NeedSwap = true; // fall-through
-  case CmpInst::FCMP_OGE: CC = X86::COND_AE;      break;
-  case CmpInst::FCMP_UGT: NeedSwap = true; // fall-through
-  case CmpInst::FCMP_ULT: CC = X86::COND_B;       break;
-  case CmpInst::FCMP_UGE: NeedSwap = true; // fall-through
-  case CmpInst::FCMP_ULE: CC = X86::COND_BE;      break;
-  case CmpInst::FCMP_ONE: CC = X86::COND_NE;      break;
-  case CmpInst::FCMP_UNO: CC = X86::COND_P;       break;
-  case CmpInst::FCMP_ORD: CC = X86::COND_NP;      break;
-  case CmpInst::FCMP_OEQ: // fall-through
-  case CmpInst::FCMP_UNE: CC = X86::COND_INVALID; break;
+  case Predicate::FCMP_UEQ:
+    CC = X86::COND_E;
+    break;
+  case Predicate::FCMP_OLT:
+    NeedSwap = true; // fall-through
+  case Predicate::FCMP_OGT:
+    CC = X86::COND_A;
+    break;
+  case Predicate::FCMP_OLE:
+    NeedSwap = true; // fall-through
+  case Predicate::FCMP_OGE:
+    CC = X86::COND_AE;
+    break;
+  case Predicate::FCMP_UGT:
+    NeedSwap = true; // fall-through
+  case Predicate::FCMP_ULT:
+    CC = X86::COND_B;
+    break;
+  case Predicate::FCMP_UGE:
+    NeedSwap = true; // fall-through
+  case Predicate::FCMP_ULE:
+    CC = X86::COND_BE;
+    break;
+  case Predicate::FCMP_ONE:
+    CC = X86::COND_NE;
+    break;
+  case Predicate::FCMP_UNO:
+    CC = X86::COND_P;
+    break;
+  case Predicate::FCMP_ORD:
+    CC = X86::COND_NP;
+    break;
+  case Predicate::FCMP_OEQ: // fall-through
+  case Predicate::FCMP_UNE:
+    CC = X86::COND_INVALID;
+    break;
 
   // Integer Predicates
-  case CmpInst::ICMP_EQ:  CC = X86::COND_E;       break;
-  case CmpInst::ICMP_NE:  CC = X86::COND_NE;      break;
-  case CmpInst::ICMP_UGT: CC = X86::COND_A;       break;
-  case CmpInst::ICMP_UGE: CC = X86::COND_AE;      break;
-  case CmpInst::ICMP_ULT: CC = X86::COND_B;       break;
-  case CmpInst::ICMP_ULE: CC = X86::COND_BE;      break;
-  case CmpInst::ICMP_SGT: CC = X86::COND_G;       break;
-  case CmpInst::ICMP_SGE: CC = X86::COND_GE;      break;
-  case CmpInst::ICMP_SLT: CC = X86::COND_L;       break;
-  case CmpInst::ICMP_SLE: CC = X86::COND_LE;      break;
+  case Predicate::ICMP_EQ:
+    CC = X86::COND_E;
+    break;
+  case Predicate::ICMP_NE:
+    CC = X86::COND_NE;
+    break;
+  case Predicate::ICMP_UGT:
+    CC = X86::COND_A;
+    break;
+  case Predicate::ICMP_UGE:
+    CC = X86::COND_AE;
+    break;
+  case Predicate::ICMP_ULT:
+    CC = X86::COND_B;
+    break;
+  case Predicate::ICMP_ULE:
+    CC = X86::COND_BE;
+    break;
+  case Predicate::ICMP_SGT:
+    CC = X86::COND_G;
+    break;
+  case Predicate::ICMP_SGE:
+    CC = X86::COND_GE;
+    break;
+  case Predicate::ICMP_SLT:
+    CC = X86::COND_L;
+    break;
+  case Predicate::ICMP_SLE:
+    CC = X86::COND_LE;
+    break;
   }
 
   return std::make_pair(CC, NeedSwap);
 }
 
-static std::pair<unsigned, bool>
-getX86SSEConditionCode(CmpInst::Predicate Predicate) {
+static std::pair<unsigned, bool> getX86SSEConditionCode(Predicate Predicate) {
   unsigned CC;
   bool NeedSwap = false;
 
   // SSE Condition code mapping:
   //  0 - EQ
   //  1 - LT
   //  2 - LE
   //  3 - UNORD
   //  4 - NEQ
   //  5 - NLT
   //  6 - NLE
   //  7 - ORD
-  switch (Predicate) {
+  switch (Predicate.getKind()) {
   default: llvm_unreachable("Unexpected predicate");
-  case CmpInst::FCMP_OEQ: CC = 0;          break;
-  case CmpInst::FCMP_OGT: NeedSwap = true; // fall-through
-  case CmpInst::FCMP_OLT: CC = 1;          break;
-  case CmpInst::FCMP_OGE: NeedSwap = true; // fall-through
-  case CmpInst::FCMP_OLE: CC = 2;          break;
-  case CmpInst::FCMP_UNO: CC = 3;          break;
-  case CmpInst::FCMP_UNE: CC = 4;          break;
-  case CmpInst::FCMP_ULE: NeedSwap = true; // fall-through
-  case CmpInst::FCMP_UGE: CC = 5;          break;
-  case CmpInst::FCMP_ULT: NeedSwap = true; // fall-through
-  case CmpInst::FCMP_UGT: CC = 6;          break;
-  case CmpInst::FCMP_ORD: CC = 7;          break;
-  case CmpInst::FCMP_UEQ:
-  case CmpInst::FCMP_ONE: CC = 8;          break;
+  case Predicate::FCMP_OEQ:
+    CC = 0;
+    break;
+  case Predicate::FCMP_OGT:
+    NeedSwap = true; // fall-through
+  case Predicate::FCMP_OLT:
+    CC = 1;
+    break;
+  case Predicate::FCMP_OGE:
+    NeedSwap = true; // fall-through
+  case Predicate::FCMP_OLE:
+    CC = 2;
+    break;
+  case Predicate::FCMP_UNO:
+    CC = 3;
+    break;
+  case Predicate::FCMP_UNE:
+    CC = 4;
+    break;
+  case Predicate::FCMP_ULE:
+    NeedSwap = true; // fall-through
+  case Predicate::FCMP_UGE:
+    CC = 5;
+    break;
+  case Predicate::FCMP_ULT:
+    NeedSwap = true; // fall-through
+  case Predicate::FCMP_UGT:
+    CC = 6;
+    break;
+  case Predicate::FCMP_ORD:
+    CC = 7;
+    break;
+  case Predicate::FCMP_UEQ:
+  case Predicate::FCMP_ONE:
+    CC = 8;
+    break;
   }
 
   return std::make_pair(CC, NeedSwap);
 }
 
 /// \brief Adds a complex addressing mode to the given machine instr builder.
 /// Note, this will constrain the index register.  If its not possible to
 /// constrain the given index register, then a new one will be created.  The
bool X86FastISel::X86SelectCmp(const Instruction *I) {
   MVT VT;
   if (!isTypeLegal(I->getOperand(0)->getType(), VT))
     return false;
 
   if (I->getType()->isIntegerTy(1) && Subtarget->hasAVX512())
     return false;
 
   // Try to optimize or fold the cmp.
-  CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);
+  Predicate Predicate = optimizeCmpPredicate(CI);
   unsigned ResultReg = 0;
-  switch (Predicate) {
+  switch (Predicate.getKind()) {
   default: break;
-  case CmpInst::FCMP_FALSE: {
+  case Predicate::FCMP_FALSE: {
     ResultReg = createResultReg(&X86::GR32RegClass);
     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::MOV32r0),
             ResultReg);
     ResultReg = fastEmitInst_extractsubreg(MVT::i8, ResultReg, /*Kill=*/true,
                                            X86::sub_8bit);
     if (!ResultReg)
       return false;
     break;
   }
-  case CmpInst::FCMP_TRUE: {
+  case Predicate::FCMP_TRUE: {
     ResultReg = createResultReg(&X86::GR8RegClass);
     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::MOV8ri),
             ResultReg).addImm(1);
     break;
   }
   }
 
   if (ResultReg) {
     updateValueMap(I, ResultReg);
     return true;
   }
 
   const Value *LHS = CI->getOperand(0);
   const Value *RHS = CI->getOperand(1);
 
   // The optimizer might have replaced fcmp oeq %x, %x with fcmp ord %x, 0.0.
   // We don't have to materialize a zero constant for this case and can just use
   // %x again on the RHS.
-  if (Predicate == CmpInst::FCMP_ORD || Predicate == CmpInst::FCMP_UNO) {
+  if (Predicate == Predicate::FCMP_ORD || Predicate == Predicate::FCMP_UNO) {
     const auto *RHSC = dyn_cast<ConstantFP>(RHS);
     if (RHSC && RHSC->isNullValue())
       RHS = LHS;
   }
 
   // FCMP_OEQ and FCMP_UNE cannot be checked with a single instruction.
   static unsigned SETFOpcTable[2][3] = {
     { X86::SETEr,  X86::SETNPr, X86::AND8rr },
     { X86::SETNEr, X86::SETPr,  X86::OR8rr  }
   };
   unsigned *SETFOpc = nullptr;
-  switch (Predicate) {
+  switch (Predicate.getKind()) {
   default: break;
-  case CmpInst::FCMP_OEQ: SETFOpc = &SETFOpcTable[0][0]; break;
-  case CmpInst::FCMP_UNE: SETFOpc = &SETFOpcTable[1][0]; break;
+  case Predicate::FCMP_OEQ:
+    SETFOpc = &SETFOpcTable[0][0];
+    break;
+  case Predicate::FCMP_UNE:
+    SETFOpc = &SETFOpcTable[1][0];
+    break;
   }
 
   ResultReg = createResultReg(&X86::GR8RegClass);
   if (SETFOpc) {
     if (!X86FastEmitCompare(LHS, RHS, VT, I->getDebugLoc()))
       return false;
 
     unsigned FlagReg1 = createResultReg(&X86::GR8RegClass);
bool X86FastISel::X86SelectBranch(const Instruction *I) {
   // in the same block (values defined on other blocks may not have
   // initialized registers).
   X86::CondCode CC;
   if (const CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition())) {
     if (CI->hasOneUse() && CI->getParent() == I->getParent()) {
       EVT VT = TLI.getValueType(DL, CI->getOperand(0)->getType());
 
       // Try to optimize or fold the cmp.
-      CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);
-      switch (Predicate) {
+      Predicate Predicate = optimizeCmpPredicate(CI);
+      switch (Predicate.getKind()) {
       default: break;
-      case CmpInst::FCMP_FALSE: fastEmitBranch(FalseMBB, DbgLoc); return true;
-      case CmpInst::FCMP_TRUE:  fastEmitBranch(TrueMBB, DbgLoc); return true;
+      case Predicate::FCMP_FALSE:
+        fastEmitBranch(FalseMBB, DbgLoc);
+        return true;
+      case Predicate::FCMP_TRUE:
+        fastEmitBranch(TrueMBB, DbgLoc);
+        return true;
       }
 
       const Value *CmpLHS = CI->getOperand(0);
       const Value *CmpRHS = CI->getOperand(1);
 
       // The optimizer might have replaced fcmp oeq %x, %x with fcmp ord %x,
       // 0.0.
       // We don't have to materialize a zero constant for this case and can just
       // use %x again on the RHS.
-      if (Predicate == CmpInst::FCMP_ORD || Predicate == CmpInst::FCMP_UNO) {
+      if (Predicate == Predicate::FCMP_ORD ||
+          Predicate == Predicate::FCMP_UNO) {
         const auto *CmpRHSC = dyn_cast<ConstantFP>(CmpRHS);
         if (CmpRHSC && CmpRHSC->isNullValue())
           CmpRHS = CmpLHS;
       }
 
       // Try to take advantage of fallthrough opportunities.
       if (FuncInfo.MBB->isLayoutSuccessor(TrueMBB)) {
         std::swap(TrueMBB, FalseMBB);
-        Predicate = CmpInst::getInversePredicate(Predicate);
+        Predicate = Predicate.getInverse();
       }
 
       // FCMP_OEQ and FCMP_UNE cannot be expressed with a single flag/condition
       // code check. Instead two branch instructions are required to check all
       // the flags. First we change the predicate to a supported condition code,
       // which will be the first branch. Later one we will emit the second
       // branch.
       bool NeedExtraBranch = false;
-      switch (Predicate) {
+      switch (Predicate.getKind()) {
       default: break;
-      case CmpInst::FCMP_OEQ:
+      case Predicate::FCMP_OEQ:
         std::swap(TrueMBB, FalseMBB); // fall-through
-      case CmpInst::FCMP_UNE:
+      case Predicate::FCMP_UNE:
         NeedExtraBranch = true;
-        Predicate = CmpInst::FCMP_ONE;
+        Predicate = Predicate::FCMP_ONE;
         break;
       }
 
       bool SwapArgs;
       unsigned BranchOpc;
       std::tie(CC, SwapArgs) = getX86ConditionCode(Predicate);
       assert(CC <= X86::LAST_VALID_COND && "Unexpected condition code.");
 
bool X86FastISel::X86FastEmitCMoveSelect(MVT RetVT, const Instruction *I) {
   bool NeedTest = true;
   X86::CondCode CC = X86::COND_NE;
 
   // Optimize conditions coming from a compare if both instructions are in the
   // same basic block (values defined in other basic blocks may not have
   // initialized registers).
   const auto *CI = dyn_cast<CmpInst>(Cond);
   if (CI && (CI->getParent() == I->getParent())) {
-    CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);
+    Predicate Predicate = optimizeCmpPredicate(CI);
 
     // FCMP_OEQ and FCMP_UNE cannot be checked with a single instruction.
     static unsigned SETFOpcTable[2][3] = {
       { X86::SETNPr, X86::SETEr , X86::TEST8rr },
       { X86::SETPr,  X86::SETNEr, X86::OR8rr   }
     };
     unsigned *SETFOpc = nullptr;
-    switch (Predicate) {
+    switch (Predicate.getKind()) {
     default: break;
-    case CmpInst::FCMP_OEQ:
+    case Predicate::FCMP_OEQ:
       SETFOpc = &SETFOpcTable[0][0];
-      Predicate = CmpInst::ICMP_NE;
+      Predicate = Predicate::ICMP_NE;
       break;
-    case CmpInst::FCMP_UNE:
+    case Predicate::FCMP_UNE:
       SETFOpc = &SETFOpcTable[1][0];
-      Predicate = CmpInst::ICMP_NE;
+      Predicate = Predicate::ICMP_NE;
       break;
     }
 
     bool NeedSwap;
     std::tie(CC, NeedSwap) = getX86ConditionCode(Predicate);
     assert(CC <= X86::LAST_VALID_COND && "Unexpected condition code.");
 
     const Value *CmpLHS = CI->getOperand(0);
bool X86FastISel::X86FastEmitSSESelect(MVT RetVT, const Instruction *I) {
 
   if (I->getType() != CI->getOperand(0)->getType() ||
       !((Subtarget->hasSSE1() && RetVT == MVT::f32) ||
         (Subtarget->hasSSE2() && RetVT == MVT::f64)))
     return false;
 
   const Value *CmpLHS = CI->getOperand(0);
   const Value *CmpRHS = CI->getOperand(1);
-  CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);
+  Predicate Predicate = optimizeCmpPredicate(CI);
 
   // The optimizer might have replaced fcmp oeq %x, %x with fcmp ord %x, 0.0.
   // We don't have to materialize a zero constant for this case and can just use
   // %x again on the RHS.
-  if (Predicate == CmpInst::FCMP_ORD || Predicate == CmpInst::FCMP_UNO) {
+  if (Predicate == Predicate::FCMP_ORD || Predicate == Predicate::FCMP_UNO) {
     const auto *CmpRHSC = dyn_cast<ConstantFP>(CmpRHS);
     if (CmpRHSC && CmpRHSC->isNullValue())
       CmpRHS = CmpLHS;
   }
 
   unsigned CC;
   bool NeedSwap;
   std::tie(CC, NeedSwap) = getX86SSEConditionCode(Predicate);

 
 bool X86FastISel::X86SelectSelect(const Instruction *I) {
   MVT RetVT;
   if (!isTypeLegal(I->getType(), RetVT))
     return false;
 
   // Check if we can fold the select.
   if (const auto *CI = dyn_cast<CmpInst>(I->getOperand(0))) {
-    CmpInst::Predicate Predicate = optimizeCmpPredicate(CI);
+    Predicate Predicate = optimizeCmpPredicate(CI);
     const Value *Opnd = nullptr;
-    switch (Predicate) {
+    switch (Predicate.getKind()) {
     default:                              break;
-    case CmpInst::FCMP_FALSE: Opnd = I->getOperand(2); break;
-    case CmpInst::FCMP_TRUE:  Opnd = I->getOperand(1); break;
+    case Predicate::FCMP_FALSE:
+      Opnd = I->getOperand(2);
+      break;
+    case Predicate::FCMP_TRUE:
+      Opnd = I->getOperand(1);
+      break;
     }
     // No need for a select anymore - this is an unconditional move.
     if (Opnd) {
       unsigned OpReg = getRegForValue(Opnd);
       if (OpReg == 0)
         return false;
       bool OpIsKill = hasTrivialKill(Opnd);
       const TargetRegisterClass *RC = TLI.getRegClassFor(RetVT);

lib/Transforms/IPO/GlobalOpt.cpp

while (!LI->use_empty()) {
       }
 
       // Replace the cmp X, 0 with a use of the bool value.
       // Sink the load to where the compare was, if atomic rules allow us to.
       Value *LV = new LoadInst(InitBool, InitBool->getName()+".val", false, 0,
                                LI->getOrdering(), LI->getSynchScope(),
                                LI->isUnordered() ? (Instruction*)ICI : LI);
       InitBoolUsed = true;
-      switch (ICI->getPredicate()) {
+      switch (ICI->getPredicate().getKind()) {
       default: llvm_unreachable("Unknown ICmp Predicate!");
-      case ICmpInst::ICMP_ULT:
-      case ICmpInst::ICMP_SLT:   // X < null -> always false
+      case Predicate::ICMP_ULT:
+      case Predicate::ICMP_SLT: // X < null -> always false
         LV = ConstantInt::getFalse(GV->getContext());
         break;
-      case ICmpInst::ICMP_ULE:
-      case ICmpInst::ICMP_SLE:
-      case ICmpInst::ICMP_EQ:
+      case Predicate::ICMP_ULE:
+      case Predicate::ICMP_SLE:
+      case Predicate::ICMP_EQ:
         LV = BinaryOperator::CreateNot(LV, "notinit", ICI);
         break;
-      case ICmpInst::ICMP_NE:
-      case ICmpInst::ICMP_UGE:
-      case ICmpInst::ICMP_SGE:
-      case ICmpInst::ICMP_UGT:
-      case ICmpInst::ICMP_SGT:
+      case Predicate::ICMP_NE:
+      case Predicate::ICMP_UGE:
+      case Predicate::ICMP_SGE:
+      case Predicate::ICMP_UGT:
+      case Predicate::ICMP_SGT:
         break;  // no change.
       }
       ICI->replaceAllUsesWith(LV);
       ICI->eraseFromParent();
     }
     LI->eraseFromParent();
   }
 
static GlobalVariable *PerformHeapAllocSRoA(GlobalVariable *GV, CallInst *CI,
   //    F2 = malloc(field2)
   //    if (F0 == 0 || F1 == 0 || F2 == 0) {
   //      if (F0) { free(F0); F0 = 0; }
   //      if (F1) { free(F1); F1 = 0; }
   //      if (F2) { free(F2); F2 = 0; }
   //    }
   // The malloc can also fail if its argument is too large.
   Constant *ConstantZero = ConstantInt::get(CI->getArgOperand(0)->getType(), 0);
-  Value *RunningOr = new ICmpInst(CI, ICmpInst::ICMP_SLT, CI->getArgOperand(0),
+  Value *RunningOr = new ICmpInst(CI, Predicate::ICMP_SLT, CI->getArgOperand(0),
                                   ConstantZero, "isneg");
   for (unsigned i = 0, e = FieldMallocs.size(); i != e; ++i) {
-    Value *Cond = new ICmpInst(CI, ICmpInst::ICMP_EQ, FieldMallocs[i],
-                             Constant::getNullValue(FieldMallocs[i]->getType()),
-                               "isnull");
+    Value *Cond = new ICmpInst(
+        CI, Predicate::ICMP_EQ, FieldMallocs[i],
+        Constant::getNullValue(FieldMallocs[i]->getType()), "isnull");
     RunningOr = BinaryOperator::CreateOr(RunningOr, Cond, "tmp", CI);
   }
 
   // Split the basic block at the old malloc.
   BasicBlock *OrigBB = CI->getParent();
   BasicBlock *ContBB =
       OrigBB->splitBasicBlock(CI->getIterator(), "malloc_cont");
 
   // Create the block to check the first condition.  Put all these blocks at the
   // end of the function as they are unlikely to be executed.
   BasicBlock *NullPtrBlock = BasicBlock::Create(OrigBB->getContext(),
                                                 "malloc_ret_null",
                                                 OrigBB->getParent());
 
   // Remove the uncond branch from OrigBB to ContBB, turning it into a cond
   // branch on RunningOr.
   OrigBB->getTerminator()->eraseFromParent();
   BranchInst::Create(NullPtrBlock, ContBB, RunningOr, OrigBB);
 
   // Within the NullPtrBlock, we need to emit a comparison and branch for each
   // pointer, because some may be null while others are not.
   for (unsigned i = 0, e = FieldGlobals.size(); i != e; ++i) {
     Value *GVVal = new LoadInst(FieldGlobals[i], "tmp", NullPtrBlock);
-    Value *Cmp = new ICmpInst(*NullPtrBlock, ICmpInst::ICMP_NE, GVVal,
+    Value *Cmp = new ICmpInst(*NullPtrBlock, Predicate::ICMP_NE, GVVal,
                               Constant::getNullValue(GVVal->getType()));
     BasicBlock *FreeBlock = BasicBlock::Create(Cmp->getContext(), "free_it",
                                                OrigBB->getParent());
     BasicBlock *NextBlock = BasicBlock::Create(Cmp->getContext(), "next",
                                                OrigBB->getParent());
     Instruction *BI = BranchInst::Create(FreeBlock, NextBlock,
                                          Cmp, NullPtrBlock);
 

lib/Transforms/IPO/MergeFunctions.cpp

if (int Res =
             cmpNumbers(SI->getAlignment(), cast<StoreInst>(R)->getAlignment()))
       return Res;
     if (int Res =
             cmpOrderings(SI->getOrdering(), cast<StoreInst>(R)->getOrdering()))
       return Res;
     return cmpNumbers(SI->getSynchScope(), cast<StoreInst>(R)->getSynchScope());
   }
   if (const CmpInst *CI = dyn_cast<CmpInst>(L))
-    return cmpNumbers(CI->getPredicate(), cast<CmpInst>(R)->getPredicate());
+    return cmpNumbers(CI->getPredicate().getKind(),
+                      cast<CmpInst>(R)->getPredicate().getKind());
   if (const CallInst *CI = dyn_cast<CallInst>(L)) {
     if (int Res = cmpNumbers(CI->getCallingConv(),
                              cast<CallInst>(R)->getCallingConv()))
       return Res;
     if (int Res =
             cmpAttrs(CI->getAttributes(), cast<CallInst>(R)->getAttributes()))
       return Res;
     if (int Res = cmpOperandBundlesSchema(CI, R))

lib/Transforms/IPO/WholeProgramDevirt.cpp

auto tryUniqueRetValOptFor = [&](bool IsOne) {
     // checked for a uniform return value in tryUniformRetValOpt.
     assert(UniqueMember);
 
     // Replace each call with the comparison.
     for (auto &&Call : CallSites) {
       IRBuilder<> B(Call.CS.getInstruction());
       Value *OneAddr = B.CreateBitCast(UniqueMember->Bits->GV, Int8PtrTy);
       OneAddr = B.CreateConstGEP1_64(OneAddr, UniqueMember->Offset);
-      Value *Cmp = B.CreateICmp(IsOne ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE,
+      Value *Cmp = B.CreateICmp(IsOne ? Predicate::ICMP_EQ : Predicate::ICMP_NE,
                                 Call.VTable, OneAddr);
       Call.replaceAndErase(Cmp);
     }
     return true;
   };
 
   if (BitWidth == 1) {
     if (tryUniqueRetValOptFor(true))

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

static inline Value *dyn_castNotVal(Value *V) {
   // Constants can be considered to be not'ed values...
   if (ConstantInt *C = dyn_cast<ConstantInt>(V))
     return ConstantInt::get(C->getType(), ~C->getValue());
   return nullptr;
 }
 
 /// Similar to getICmpCode but for FCmpInst. This encodes a fcmp predicate into
 /// a four bit mask.
-static unsigned getFCmpCode(FCmpInst::Predicate CC) {
-  assert(FCmpInst::FCMP_FALSE <= CC && CC <= FCmpInst::FCMP_TRUE &&
-         "Unexpected FCmp predicate!");
-  // Take advantage of the bit pattern of FCmpInst::Predicate here.
+static unsigned getFCmpCode(Predicate CC) {
+  assert(CC.isFP() && "Unexpected FCmp predicate!");
+  // Take advantage of the bit pattern of Predicate here.
   //                                                 U L G E
-  static_assert(FCmpInst::FCMP_FALSE ==  0, "");  // 0 0 0 0
-  static_assert(FCmpInst::FCMP_OEQ   ==  1, "");  // 0 0 0 1
-  static_assert(FCmpInst::FCMP_OGT   ==  2, "");  // 0 0 1 0
-  static_assert(FCmpInst::FCMP_OGE   ==  3, "");  // 0 0 1 1
-  static_assert(FCmpInst::FCMP_OLT   ==  4, "");  // 0 1 0 0
-  static_assert(FCmpInst::FCMP_OLE   ==  5, "");  // 0 1 0 1
-  static_assert(FCmpInst::FCMP_ONE   ==  6, "");  // 0 1 1 0
-  static_assert(FCmpInst::FCMP_ORD   ==  7, "");  // 0 1 1 1
-  static_assert(FCmpInst::FCMP_UNO   ==  8, "");  // 1 0 0 0
-  static_assert(FCmpInst::FCMP_UEQ   ==  9, "");  // 1 0 0 1
-  static_assert(FCmpInst::FCMP_UGT   == 10, "");  // 1 0 1 0
-  static_assert(FCmpInst::FCMP_UGE   == 11, "");  // 1 0 1 1
-  static_assert(FCmpInst::FCMP_ULT   == 12, "");  // 1 1 0 0
-  static_assert(FCmpInst::FCMP_ULE   == 13, "");  // 1 1 0 1
-  static_assert(FCmpInst::FCMP_UNE   == 14, "");  // 1 1 1 0
-  static_assert(FCmpInst::FCMP_TRUE  == 15, "");  // 1 1 1 1
-  return CC;
+  static_assert(Predicate::FCMP_FALSE == 0, ""); // 0 0 0 0
+  static_assert(Predicate::FCMP_OEQ == 1, "");   // 0 0 0 1
+  static_assert(Predicate::FCMP_OGT == 2, "");   // 0 0 1 0
+  static_assert(Predicate::FCMP_OGE == 3, "");   // 0 0 1 1
+  static_assert(Predicate::FCMP_OLT == 4, "");   // 0 1 0 0
+  static_assert(Predicate::FCMP_OLE == 5, "");   // 0 1 0 1
+  static_assert(Predicate::FCMP_ONE == 6, "");   // 0 1 1 0
+  static_assert(Predicate::FCMP_ORD == 7, "");   // 0 1 1 1
+  static_assert(Predicate::FCMP_UNO == 8, "");   // 1 0 0 0
+  static_assert(Predicate::FCMP_UEQ == 9, "");   // 1 0 0 1
+  static_assert(Predicate::FCMP_UGT == 10, "");  // 1 0 1 0
+  static_assert(Predicate::FCMP_UGE == 11, "");  // 1 0 1 1
+  static_assert(Predicate::FCMP_ULT == 12, "");  // 1 1 0 0
+  static_assert(Predicate::FCMP_ULE == 13, "");  // 1 1 0 1
+  static_assert(Predicate::FCMP_UNE == 14, "");  // 1 1 1 0
+  static_assert(Predicate::FCMP_TRUE == 15, ""); // 1 1 1 1
+  return static_cast<unsigned>(CC.getKind());
 }
 
 /// This is the complement of getICmpCode, which turns an opcode and two
 /// operands into either a constant true or false, or a brand new ICmp
 /// instruction. The sign is passed in to determine which kind of predicate to
 /// use in the new icmp instruction.
 static Value *getNewICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS,
                               InstCombiner::BuilderTy *Builder) {
-  ICmpInst::Predicate NewPred;
+  Predicate NewPred;
   if (Value *NewConstant = getICmpValue(Sign, Code, LHS, RHS, NewPred))
     return NewConstant;
   return Builder->CreateICmp(NewPred, LHS, RHS);
 }
 
 /// This is the complement of getFCmpCode, which turns an opcode and two
 /// operands into either a FCmp instruction, or a true/false constant.
 static Value *getFCmpValue(unsigned Code, Value *LHS, Value *RHS,
                            InstCombiner::BuilderTy *Builder) {
-  const auto Pred = static_cast<FCmpInst::Predicate>(Code);
-  assert(FCmpInst::FCMP_FALSE <= Pred && Pred <= FCmpInst::FCMP_TRUE &&
-         "Unexpected FCmp predicate!");
-  if (Pred == FCmpInst::FCMP_FALSE)
+  const auto Pred = static_cast<Predicate>(Code);
+  assert(Pred.isFP() && "Unexpected FCmp predicate!");
+  if (Pred == Predicate::FCMP_FALSE)
     return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
-  if (Pred == FCmpInst::FCMP_TRUE)
+  if (Pred == Predicate::FCMP_TRUE)
     return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1);
   return Builder->CreateFCmp(Pred, LHS, RHS);
 }
 
 /// \brief Transform BITWISE_OP(BSWAP(A),BSWAP(B)) to BSWAP(BITWISE_OP(A, B))
 /// \param I Binary operator to transform.
 /// \return Pointer to node that must replace the original binary operator, or
 ///         null pointer if no transformation was made.

 
 /// Emit a computation of: (V >= Lo && V < Hi) if Inside is true, otherwise
 /// (V < Lo || V >= Hi).  In practice, we emit the more efficient
 /// (V-Lo) \<u Hi-Lo.  This method expects that Lo <= Hi. isSigned indicates
 /// whether to treat the V, Lo and HI as signed or not. IB is the location to
 /// insert new instructions.
 Value *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi,
                                      bool isSigned, bool Inside) {
-  assert(cast<ConstantInt>(ConstantExpr::getICmp((isSigned ?
-            ICmpInst::ICMP_SLE:ICmpInst::ICMP_ULE), Lo, Hi))->getZExtValue() &&
-         "Lo is not <= Hi in range emission code!");
+  assert(
+      cast<ConstantInt>(
+          ConstantExpr::getICmp(
+              (isSigned ? Predicate::ICMP_SLE : Predicate::ICMP_ULE), Lo, Hi))
+          ->getZExtValue() &&
 
   if (Inside) {
     if (Lo == Hi)  // Trivially false.
       return Builder->getFalse();
 
     // V >= Min && V < Hi --> V < Hi
     if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) {
-      ICmpInst::Predicate pred = (isSigned ?
-        ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT);
+      Predicate pred = (isSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT);
       return Builder->CreateICmp(pred, V, Hi);
     }
 
     // Emit V-Lo <u Hi-Lo
     Constant *NegLo = ConstantExpr::getNeg(Lo);
     Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off");
     Constant *UpperBound = ConstantExpr::getAdd(NegLo, Hi);
     return Builder->CreateICmpULT(Add, UpperBound);
   }
 
   if (Lo == Hi)  // Trivially true.
     return Builder->getTrue();
 
   // V < Min || V >= Hi -> V > Hi-1
   Hi = SubOne(cast<ConstantInt>(Hi));
   if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) {
-    ICmpInst::Predicate pred = (isSigned ?
-        ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT);
+    Predicate pred = (isSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT);
     return Builder->CreateICmp(pred, V, Hi);
   }
 
   // Emit V-Lo >u Hi-1-Lo
   // Note that Hi has already had one subtracted from it, above.
   ConstantInt *NegLo = cast<ConstantInt>(ConstantExpr::getNeg(Lo));
   Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off");
   Constant *LowerBound = ConstantExpr::getAdd(NegLo, Hi);
enum MaskedICmpType {
   FoldMskICmp_AMask_Mixed             =    64,
   FoldMskICmp_AMask_NotMixed          =   128,
   FoldMskICmp_BMask_Mixed             =   256,
   FoldMskICmp_BMask_NotMixed          =   512
 };
 
 /// Return the set of pattern classes (from MaskedICmpType)
 /// that (icmp SCC (A & B), C) satisfies.
-static unsigned getTypeOfMaskedICmp(Value* A, Value* B, Value* C,
-                                    ICmpInst::Predicate SCC)
-{
+static unsigned getTypeOfMaskedICmp(Value *A, Value *B, Value *C,
+                                    Predicate SCC) {
   ConstantInt *ACst = dyn_cast<ConstantInt>(A);
   ConstantInt *BCst = dyn_cast<ConstantInt>(B);
   ConstantInt *CCst = dyn_cast<ConstantInt>(C);
-  bool icmp_eq = (SCC == ICmpInst::ICMP_EQ);
+  bool icmp_eq = (SCC == Predicate::ICMP_EQ);
   bool icmp_abit = (ACst && !ACst->isZero() &&
                     ACst->getValue().isPowerOf2());
   bool icmp_bbit = (BCst && !BCst->isZero() &&
                     BCst->getValue().isPowerOf2());
   unsigned result = 0;
   if (CCst && CCst->isZero()) {
     // if C is zero, then both A and B qualify as mask
     result |= (icmp_eq ? (FoldMskICmp_Mask_AllZeroes |
NewMask |=
       >> 1;
 
   return NewMask;
 }
 
 /// Handle (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E)
 /// Return the set of pattern classes (from MaskedICmpType)
 /// that both LHS and RHS satisfy.
-static unsigned foldLogOpOfMaskedICmpsHelper(Value*& A,
-                                             Value*& B, Value*& C,
-                                             Value*& D, Value*& E,
+static unsigned foldLogOpOfMaskedICmpsHelper(Value *&A, Value *&B, Value *&C,
+                                             Value *&D, Value *&E,
                                              ICmpInst *LHS, ICmpInst *RHS,
-                                             ICmpInst::Predicate &LHSCC,
-                                             ICmpInst::Predicate &RHSCC) {
+                                             Predicate &LHSCC,
+                                             Predicate &RHSCC) {
   if (LHS->getOperand(0)->getType() != RHS->getOperand(0)->getType()) return 0;
   // vectors are not (yet?) supported
   if (LHS->getOperand(0)->getType()->isVectorTy()) return 0;
 
   // Here comes the tricky part:
   // LHS might be of the form L11 & L12 == X, X == L21 & L22,
   // and L11 & L12 == L21 & L22. The same goes for RHS.
   // Now we must find those components L** and R**, that are equal, so
if (!L2->getType()->isIntegerTy()) {
       L21 = L22 = nullptr;
     } else if (!match(L2, m_And(m_Value(L21), m_Value(L22)))) {
       L21 = L2;
       L22 = Constant::getAllOnesValue(L2->getType());
     }
   }
 
   // Bail if LHS was a icmp that can't be decomposed into an equality.
-  if (!ICmpInst::isEquality(LHSCC))
+  if (!LHSCC.isEquality())
     return 0;
 
   Value *R1 = RHS->getOperand(0);
   Value *R2 = RHS->getOperand(1);
   Value *R11,*R12;
   bool ok = false;
   if (decomposeBitTestICmp(RHS, RHSCC, R11, R12, R2)) {
     if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) {
if (decomposeBitTestICmp(RHS, RHSCC, R11, R12, R2)) {
     if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) {
       A = R11; D = R12; E = R2; ok = true;
     } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) {
       A = R12; D = R11; E = R2; ok = true;
     }
   }
 
   // Bail if RHS was a icmp that can't be decomposed into an equality.
-  if (!ICmpInst::isEquality(RHSCC))
+  if (!RHSCC.isEquality())
     return 0;
 
   // Look for ANDs on the right side of the RHS icmp.
   if (!ok && R2->getType()->isIntegerTy()) {
     if (!match(R2, m_And(m_Value(R11), m_Value(R12)))) {
       R11 = R2;
       R12 = Constant::getAllOnesValue(R2->getType());
     }
static unsigned foldLogOpOfMaskedICmpsHelper(Value *&A, Value *&B, Value *&C,
   return LeftType & RightType;
 }
 
 /// Try to fold (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E)
 /// into a single (icmp(A & X) ==/!= Y).
 static Value *foldLogOpOfMaskedICmps(ICmpInst *LHS, ICmpInst *RHS, bool IsAnd,
                                      llvm::InstCombiner::BuilderTy *Builder) {
   Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr, *E = nullptr;
-  ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate();
+  Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate();
   unsigned Mask = foldLogOpOfMaskedICmpsHelper(A, B, C, D, E, LHS, RHS,
                                                LHSCC, RHSCC);
   if (Mask == 0) return nullptr;
-  assert(ICmpInst::isEquality(LHSCC) && ICmpInst::isEquality(RHSCC) &&
+  assert(LHSCC.isEquality() && RHSCC.isEquality() &&
          "foldLogOpOfMaskedICmpsHelper must return an equality predicate.");
 
   // In full generality:
   //     (icmp (A & B) Op C) | (icmp (A & D) Op E)
   // ==  ![ (icmp (A & B) !Op C) & (icmp (A & D) !Op E) ]
   //
   // If the latter can be converted into (icmp (A & X) Op Y) then the former is
   // equivalent to (icmp (A & X) !Op Y).
   //
   // Therefore, we can pretend for the rest of this function that we're dealing
   // with the conjunction, provided we flip the sense of any comparisons (both
   // input and output).
 
   // In most cases we're going to produce an EQ for the "&&" case.
-  ICmpInst::Predicate NewCC = IsAnd ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE;
+  Predicate NewCC = IsAnd ? Predicate::ICMP_EQ : Predicate::ICMP_NE;
   if (!IsAnd) {
     // Convert the masking analysis into its equivalent with negated
     // comparisons.
     Mask = conjugateICmpMask(Mask);
   }
 
   if (Mask & FoldMskICmp_Mask_AllZeroes) {
     // (icmp eq (A & B), 0) & (icmp eq (A & D), 0)

 Value *InstCombiner::simplifyRangeCheck(ICmpInst *Cmp0, ICmpInst *Cmp1,
                                         bool Inverted) {
   // Check the lower range comparison, e.g. x >= 0
   // InstCombine already ensured that if there is a constant it's on the RHS.
   ConstantInt *RangeStart = dyn_cast<ConstantInt>(Cmp0->getOperand(1));
   if (!RangeStart)
     return nullptr;
 
-  ICmpInst::Predicate Pred0 = (Inverted ? Cmp0->getInversePredicate() :
-                               Cmp0->getPredicate());
+  Predicate Pred0 =
+      (Inverted ? Cmp0->getInversePredicate() : Cmp0->getPredicate());
 
   // Accept x > -1 or x >= 0 (after potentially inverting the predicate).
-  if (!((Pred0 == ICmpInst::ICMP_SGT && RangeStart->isMinusOne()) ||
-        (Pred0 == ICmpInst::ICMP_SGE && RangeStart->isZero())))
+  if (!((Pred0 == Predicate::ICMP_SGT && RangeStart->isMinusOne()) ||
+        (Pred0 == Predicate::ICMP_SGE && RangeStart->isZero())))
     return nullptr;
 
-  ICmpInst::Predicate Pred1 = (Inverted ? Cmp1->getInversePredicate() :
-                               Cmp1->getPredicate());
+  Predicate Pred1 =
+      (Inverted ? Cmp1->getInversePredicate() : Cmp1->getPredicate());
 
   Value *Input = Cmp0->getOperand(0);
   Value *RangeEnd;
   if (Cmp1->getOperand(0) == Input) {
     // For the upper range compare we have: icmp x, n
     RangeEnd = Cmp1->getOperand(1);
   } else if (Cmp1->getOperand(1) == Input) {
     // For the upper range compare we have: icmp n, x
     RangeEnd = Cmp1->getOperand(0);
-    Pred1 = ICmpInst::getSwappedPredicate(Pred1);
+    Pred1 = Pred1.getSwapped();
   } else {
     return nullptr;
   }
 
   // Check the upper range comparison, e.g. x < n
-  ICmpInst::Predicate NewPred;
-  switch (Pred1) {
-    case ICmpInst::ICMP_SLT: NewPred = ICmpInst::ICMP_ULT; break;
-    case ICmpInst::ICMP_SLE: NewPred = ICmpInst::ICMP_ULE; break;
-    default: return nullptr;
+  Predicate NewPred;
+  switch (Pred1.getKind()) {
+  case Predicate::ICMP_SLT:
+    NewPred = Predicate::ICMP_ULT;
+    break;
+  case Predicate::ICMP_SLE:
+    NewPred = Predicate::ICMP_ULE;
+    break;
+  default:
+    return nullptr;
   }
 
   // This simplification is only valid if the upper range is not negative.
   bool IsNegative, IsNotNegative;
   ComputeSignBit(RangeEnd, IsNotNegative, IsNegative, /*Depth=*/0, Cmp1);
   if (!IsNotNegative)
     return nullptr;
 
   if (Inverted)
-    NewPred = ICmpInst::getInversePredicate(NewPred);
+    NewPred = NewPred.getInverse();
 
   return Builder->CreateICmp(NewPred, Input, RangeEnd);
 }
 
 /// Fold (icmp)&(icmp) if possible.
 Value *InstCombiner::FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS) {
-  ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate();
+  Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate();
 
   // (icmp1 A, B) & (icmp2 A, B) --> (icmp3 A, B)
   if (PredicatesFoldable(LHSCC, RHSCC)) {
     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 *InstCombiner::FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS) {
   ConstantInt *LHSCst = dyn_cast<ConstantInt>(LHS->getOperand(1));
   ConstantInt *RHSCst = dyn_cast<ConstantInt>(RHS->getOperand(1));
   if (!LHSCst || !RHSCst) return nullptr;
 
   if (LHSCst == RHSCst && LHSCC == RHSCC) {
     // (icmp ult A, C) & (icmp ult B, C) --> (icmp ult (A|B), C)
     // where C is a power of 2 or
     // (icmp eq A, 0) & (icmp eq B, 0) --> (icmp eq (A|B), 0)
-    if ((LHSCC == ICmpInst::ICMP_ULT && LHSCst->getValue().isPowerOf2()) ||
-        (LHSCC == ICmpInst::ICMP_EQ && LHSCst->isZero())) {
+    if ((LHSCC == Predicate::ICMP_ULT && LHSCst->getValue().isPowerOf2()) ||
+        (LHSCC == Predicate::ICMP_EQ && LHSCst->isZero())) {
       Value *NewOr = Builder->CreateOr(Val, Val2);
       return Builder->CreateICmp(LHSCC, NewOr, LHSCst);
     }
   }
 
   // (trunc x) == C1 & (and x, CA) == C2 -> (and x, CA|CMAX) == C1|C2
   // where CMAX is the all ones value for the truncated type,
   // iff the lower bits of C2 and CA are zero.
-  if (LHSCC == ICmpInst::ICMP_EQ && LHSCC == RHSCC &&
-      LHS->hasOneUse() && RHS->hasOneUse()) {
+  if (LHSCC == Predicate::ICMP_EQ && LHSCC == RHSCC && LHS->hasOneUse() &&
+      RHS->hasOneUse()) {
     Value *V;
     ConstantInt *AndCst, *SmallCst = nullptr, *BigCst = nullptr;
 
     // (trunc x) == C1 & (and x, CA) == C2
     // (and x, CA) == C2 & (trunc x) == C1
     if (match(Val2, m_Trunc(m_Value(V))) &&
         match(Val, m_And(m_Specific(V), m_ConstantInt(AndCst)))) {
       SmallCst = RHSCst;
if (LHSCC == Predicate::ICMP_EQ && LHSCC == RHSCC && LHS->hasOneUse() &&
     }
   }
 
   // From here on, we only handle:
   //    (icmp1 A, C1) & (icmp2 A, C2) --> something simpler.
   if (Val != Val2) return nullptr;
 
   // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere.
-  if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE ||
-      RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE ||
-      LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE ||
-      RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE)
+  if (LHSCC.isOneOf(Predicate::ICMP_UGE, Predicate::ICMP_ULE,
+                    Predicate::ICMP_SGE, Predicate::ICMP_SLE) ||
+      RHSCC.isOneOf(Predicate::ICMP_UGE, Predicate::ICMP_ULE,
+                    Predicate::ICMP_SGE, Predicate::ICMP_SLE))
     return nullptr;
 
   // We can't fold (ugt x, C) & (sgt x, C2).
   if (!PredicatesFoldable(LHSCC, RHSCC))
     return nullptr;
 
   // Ensure that the larger constant is on the RHS.
   bool ShouldSwap;
-  if (CmpInst::isSigned(LHSCC) ||
-      (ICmpInst::isEquality(LHSCC) &&
-       CmpInst::isSigned(RHSCC)))
+  if (LHSCC.isSigned() || (LHSCC.isEquality() && RHSCC.isSigned()))
     ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue());
   else
     ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue());
 
   if (ShouldSwap) {
     std::swap(LHS, RHS);
     std::swap(LHSCst, RHSCst);
     std::swap(LHSCC, RHSCC);
   }
 
   // At this point, we know we have two icmp instructions
   // comparing a value against two constants and and'ing the result
   // together.  Because of the above check, we know that we only have
   // icmp eq, icmp ne, icmp [su]lt, and icmp [SU]gt here. We also know
   // (from the icmp folding check above), that the two constants
   // are not equal and that the larger constant is on the RHS
   assert(LHSCst != RHSCst && "Compares not folded above?");
 
-  switch (LHSCC) {
+  switch (LHSCC.getKind()) {
   default: llvm_unreachable("Unknown integer condition code!");
-  case ICmpInst::ICMP_EQ:
-    switch (RHSCC) {
+  case Predicate::ICMP_EQ:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_NE:         // (X == 13 & X != 15) -> X == 13
-    case ICmpInst::ICMP_ULT:        // (X == 13 & X <  15) -> X == 13
-    case ICmpInst::ICMP_SLT:        // (X == 13 & X <  15) -> X == 13
+    case Predicate::ICMP_NE:  // (X == 13 & X != 15) -> X == 13
+    case Predicate::ICMP_ULT: // (X == 13 & X <  15) -> X == 13
+    case Predicate::ICMP_SLT: // (X == 13 & X <  15) -> X == 13
       return LHS;
     }
-  case ICmpInst::ICMP_NE:
-    switch (RHSCC) {
+  case Predicate::ICMP_NE:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_ULT:
+    case Predicate::ICMP_ULT:
       if (LHSCst == SubOne(RHSCst)) // (X != 13 & X u< 14) -> X < 13
         return Builder->CreateICmpULT(Val, LHSCst);
       if (LHSCst->isNullValue())    // (X !=  0 & X u< 14) -> X-1 u< 13
         return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, false, true);
       break;                        // (X != 13 & X u< 15) -> no change
-    case ICmpInst::ICMP_SLT:
+    case Predicate::ICMP_SLT:
       if (LHSCst == SubOne(RHSCst)) // (X != 13 & X s< 14) -> X < 13
         return Builder->CreateICmpSLT(Val, LHSCst);
       break;                        // (X != 13 & X s< 15) -> no change
-    case ICmpInst::ICMP_EQ:         // (X != 13 & X == 15) -> X == 15
-    case ICmpInst::ICMP_UGT:        // (X != 13 & X u> 15) -> X u> 15
-    case ICmpInst::ICMP_SGT:        // (X != 13 & X s> 15) -> X s> 15
+    case Predicate::ICMP_EQ:        // (X != 13 & X == 15) -> X == 15
+    case Predicate::ICMP_UGT:       // (X != 13 & X u> 15) -> X u> 15
+    case Predicate::ICMP_SGT:       // (X != 13 & X s> 15) -> X s> 15
       return RHS;
-    case ICmpInst::ICMP_NE:
+    case Predicate::ICMP_NE:
       // Special case to get the ordering right when the values wrap around
       // zero.
       if (LHSCst->getValue() == 0 && RHSCst->getValue().isAllOnesValue())
         std::swap(LHSCst, RHSCst);
       if (LHSCst == SubOne(RHSCst)){// (X != 13 & X != 14) -> X-13 >u 1
         Constant *AddCST = ConstantExpr::getNeg(LHSCst);
         Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off");
         return Builder->CreateICmpUGT(Add, ConstantInt::get(Add->getType(), 1),
                                       Val->getName()+".cmp");
       }
       break;                        // (X != 13 & X != 15) -> no change
     }
     break;
-  case ICmpInst::ICMP_ULT:
-    switch (RHSCC) {
+  case Predicate::ICMP_ULT:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:         // (X u< 13 & X == 15) -> false
-    case ICmpInst::ICMP_UGT:        // (X u< 13 & X u> 15) -> false
+    case Predicate::ICMP_EQ:  // (X u< 13 & X == 15) -> false
+    case Predicate::ICMP_UGT: // (X u< 13 & X u> 15) -> false
       return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
-    case ICmpInst::ICMP_SGT:        // (X u< 13 & X s> 15) -> no change
+    case Predicate::ICMP_SGT: // (X u< 13 & X s> 15) -> no change
       break;
-    case ICmpInst::ICMP_NE:         // (X u< 13 & X != 15) -> X u< 13
-    case ICmpInst::ICMP_ULT:        // (X u< 13 & X u< 15) -> X u< 13
+    case Predicate::ICMP_NE:  // (X u< 13 & X != 15) -> X u< 13
+    case Predicate::ICMP_ULT: // (X u< 13 & X u< 15) -> X u< 13
       return LHS;
-    case ICmpInst::ICMP_SLT:        // (X u< 13 & X s< 15) -> no change
+    case Predicate::ICMP_SLT: // (X u< 13 & X s< 15) -> no change
       break;
     }
     break;
-  case ICmpInst::ICMP_SLT:
-    switch (RHSCC) {
+  case Predicate::ICMP_SLT:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_UGT:        // (X s< 13 & X u> 15) -> no change
+    case Predicate::ICMP_UGT: // (X s< 13 & X u> 15) -> no change
       break;
-    case ICmpInst::ICMP_NE:         // (X s< 13 & X != 15) -> X < 13
-    case ICmpInst::ICMP_SLT:        // (X s< 13 & X s< 15) -> X < 13
+    case Predicate::ICMP_NE:  // (X s< 13 & X != 15) -> X < 13
+    case Predicate::ICMP_SLT: // (X s< 13 & X s< 15) -> X < 13
       return LHS;
-    case ICmpInst::ICMP_ULT:        // (X s< 13 & X u< 15) -> no change
+    case Predicate::ICMP_ULT: // (X s< 13 & X u< 15) -> no change
       break;
     }
     break;
-  case ICmpInst::ICMP_UGT:
-    switch (RHSCC) {
+  case Predicate::ICMP_UGT:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:         // (X u> 13 & X == 15) -> X == 15
-    case ICmpInst::ICMP_UGT:        // (X u> 13 & X u> 15) -> X u> 15
+    case Predicate::ICMP_EQ:  // (X u> 13 & X == 15) -> X == 15
+    case Predicate::ICMP_UGT: // (X u> 13 & X u> 15) -> X u> 15
       return RHS;
-    case ICmpInst::ICMP_SGT:        // (X u> 13 & X s> 15) -> no change
+    case Predicate::ICMP_SGT: // (X u> 13 & X s> 15) -> no change
       break;
-    case ICmpInst::ICMP_NE:
+    case Predicate::ICMP_NE:
       if (RHSCst == AddOne(LHSCst)) // (X u> 13 & X != 14) -> X u> 14
         return Builder->CreateICmp(LHSCC, Val, RHSCst);
       break;                        // (X u> 13 & X != 15) -> no change
-    case ICmpInst::ICMP_ULT:        // (X u> 13 & X u< 15) -> (X-14) <u 1
+    case Predicate::ICMP_ULT:       // (X u> 13 & X u< 15) -> (X-14) <u 1
       return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, false, true);
-    case ICmpInst::ICMP_SLT:        // (X u> 13 & X s< 15) -> no change
+    case Predicate::ICMP_SLT: // (X u> 13 & X s< 15) -> no change
       break;
     }
     break;
-  case ICmpInst::ICMP_SGT:
-    switch (RHSCC) {
+  case Predicate::ICMP_SGT:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:         // (X s> 13 & X == 15) -> X == 15
-    case ICmpInst::ICMP_SGT:        // (X s> 13 & X s> 15) -> X s> 15
+    case Predicate::ICMP_EQ:  // (X s> 13 & X == 15) -> X == 15
+    case Predicate::ICMP_SGT: // (X s> 13 & X s> 15) -> X s> 15
       return RHS;
-    case ICmpInst::ICMP_UGT:        // (X s> 13 & X u> 15) -> no change
+    case Predicate::ICMP_UGT: // (X s> 13 & X u> 15) -> no change
       break;
-    case ICmpInst::ICMP_NE:
+    case Predicate::ICMP_NE:
       if (RHSCst == AddOne(LHSCst)) // (X s> 13 & X != 14) -> X s> 14
         return Builder->CreateICmp(LHSCC, Val, RHSCst);
       break;                        // (X s> 13 & X != 15) -> no change
-    case ICmpInst::ICMP_SLT:        // (X s> 13 & X s< 15) -> (X-14) s< 1
+    case Predicate::ICMP_SLT:       // (X s> 13 & X s< 15) -> (X-14) s< 1
       return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, true, true);
-    case ICmpInst::ICMP_ULT:        // (X s> 13 & X u< 15) -> no change
+    case Predicate::ICMP_ULT: // (X s> 13 & X u< 15) -> no change
       break;
     }
     break;
   }
 
   return nullptr;
 }
 
 /// Optimize (fcmp)&(fcmp).  NOTE: Unlike the rest of instcombine, this returns
 /// a Value which should already be inserted into the function.
 Value *InstCombiner::FoldAndOfFCmps(FCmpInst *LHS, FCmpInst *RHS) {
   Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1);
   Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1);
-  FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate();
+  Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate();
 
   if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) {
     // Swap RHS operands to match LHS.
-    Op1CC = FCmpInst::getSwappedPredicate(Op1CC);
+    Op1CC = Op1CC.getSwapped();
     std::swap(Op1LHS, Op1RHS);
   }
 
   // Simplify (fcmp cc0 x, y) & (fcmp cc1 x, y).
   // Suppose the relation between x and y is R, where R is one of
   // U(1000), L(0100), G(0010) or E(0001), and CC0 and CC1 are the bitmasks for
   // testing the desired relations.
   //
   // Since (R & CC0) and (R & CC1) are either R or 0, we actually have this:
   //    bool(R & CC0) && bool(R & CC1)
   //  = bool((R & CC0) & (R & CC1))
   //  = bool(R & (CC0 & CC1)) <= by re-association, commutation, and idempotency
   if (Op0LHS == Op1LHS && Op0RHS == Op1RHS)
     return getFCmpValue(getFCmpCode(Op0CC) & getFCmpCode(Op1CC), Op0LHS, Op0RHS,
                         Builder);
 
-  if (LHS->getPredicate() == FCmpInst::FCMP_ORD &&
-      RHS->getPredicate() == FCmpInst::FCMP_ORD) {
+  if (LHS->getPredicate() == Predicate::FCMP_ORD &&
+      RHS->getPredicate() == Predicate::FCMP_ORD) {
     if (LHS->getOperand(0)->getType() != RHS->getOperand(0)->getType())
       return nullptr;
 
     // (fcmp ord x, c) & (fcmp ord y, c)  -> (fcmp ord x, y)
     if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1)))
       if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) {
         // If either of the constants are nans, then the whole thing returns
         // false.
static Value *matchSelectFromAndOr(Value *A, Value *C, Value *B, Value *D,
   }
 
   return nullptr;
 }
 
 /// Fold (icmp)|(icmp) if possible.
 Value *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS,
                                    Instruction *CxtI) {
-  ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate();
+  Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate();
 
   // Fold (iszero(A & K1) | iszero(A & K2)) ->  (A & (K1 | K2)) != (K1 | K2)
   // if K1 and K2 are a one-bit mask.
   ConstantInt *LHSCst = dyn_cast<ConstantInt>(LHS->getOperand(1));
   ConstantInt *RHSCst = dyn_cast<ConstantInt>(RHS->getOperand(1));
 
-  if (LHS->getPredicate() == ICmpInst::ICMP_EQ && LHSCst && LHSCst->isZero() &&
-      RHS->getPredicate() == ICmpInst::ICMP_EQ && RHSCst && RHSCst->isZero()) {
+  if (LHS->getPredicate() == Predicate::ICMP_EQ && LHSCst && LHSCst->isZero() &&
+      RHS->getPredicate() == Predicate::ICMP_EQ && RHSCst && RHSCst->isZero()) {
 
     BinaryOperator *LAnd = dyn_cast<BinaryOperator>(LHS->getOperand(0));
     BinaryOperator *RAnd = dyn_cast<BinaryOperator>(RHS->getOperand(0));
     if (LAnd && RAnd && LAnd->hasOneUse() && RHS->hasOneUse() &&
         LAnd->getOpcode() == Instruction::And &&
         RAnd->getOpcode() == Instruction::And) {
 
       Value *Mask = nullptr;
if (LAnd && RAnd && LAnd->hasOneUse() && RHS->hasOneUse() &&
                                         CxtI, &DT) &&
                  isKnownToBeAPowerOfTwo(RAnd->getOperand(0), DL, false, 0, &AC,
                                         CxtI, &DT)) {
         Mask = Builder->CreateOr(LAnd->getOperand(0), RAnd->getOperand(0));
         Masked = Builder->CreateAnd(LAnd->getOperand(1), Mask);
       }
 
       if (Masked)
-        return Builder->CreateICmp(ICmpInst::ICMP_NE, Masked, Mask);
+        return Builder->CreateICmp(Predicate::ICMP_NE, Masked, Mask);
     }
   }
 
   // Fold (icmp ult/ule (A + C1), C3) | (icmp ult/ule (A + C2), C3)
   //                   -->  (icmp ult/ule ((A & ~(C1 ^ C2)) + max(C1, C2)), C3)
   // The original condition actually refers to the following two ranges:
   // [MAX_UINT-C1+1, MAX_UINT-C1+1+C3] and [MAX_UINT-C2+1, MAX_UINT-C2+1+C3]
   // We can fold these two ranges if:
   // 1) C1 and C2 is unsigned greater than C3.
   // 2) The two ranges are separated.
   // 3) C1 ^ C2 is one-bit mask.
   // 4) LowRange1 ^ LowRange2 and HighRange1 ^ HighRange2 are one-bit mask.
   // This implies all values in the two ranges differ by exactly one bit.
 
-  if ((LHSCC == ICmpInst::ICMP_ULT || LHSCC == ICmpInst::ICMP_ULE) &&
+  if ((LHSCC == Predicate::ICMP_ULT || LHSCC == Predicate::ICMP_ULE) &&
       LHSCC == RHSCC && LHSCst && RHSCst && LHS->hasOneUse() &&
       RHS->hasOneUse() && LHSCst->getType() == RHSCst->getType() &&
       LHSCst->getValue() == (RHSCst->getValue())) {
 
     Value *LAdd = LHS->getOperand(0);
     Value *RAdd = RHS->getOperand(0);
 
     Value *LAddOpnd, *RAddOpnd;
Value *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS,
   if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, false, Builder))
     return V;
 
   Value *Val = LHS->getOperand(0), *Val2 = RHS->getOperand(0);
   if (LHS->hasOneUse() || RHS->hasOneUse()) {
     // (icmp eq B, 0) | (icmp ult A, B) -> (icmp ule A, B-1)
     // (icmp eq B, 0) | (icmp ugt B, A) -> (icmp ule A, B-1)
     Value *A = nullptr, *B = nullptr;
-    if (LHSCC == ICmpInst::ICMP_EQ && LHSCst && LHSCst->isZero()) {
+    if (LHSCC == Predicate::ICMP_EQ && LHSCst && LHSCst->isZero()) {
       B = Val;
-      if (RHSCC == ICmpInst::ICMP_ULT && Val == RHS->getOperand(1))
+      if (RHSCC == Predicate::ICMP_ULT && Val == RHS->getOperand(1))
         A = Val2;
-      else if (RHSCC == ICmpInst::ICMP_UGT && Val == Val2)
+      else if (RHSCC == Predicate::ICMP_UGT && Val == Val2)
         A = RHS->getOperand(1);
     }
     // (icmp ult A, B) | (icmp eq B, 0) -> (icmp ule A, B-1)
     // (icmp ugt B, A) | (icmp eq B, 0) -> (icmp ule A, B-1)
-    else if (RHSCC == ICmpInst::ICMP_EQ && RHSCst && RHSCst->isZero()) {
+    else if (RHSCC == Predicate::ICMP_EQ && RHSCst && RHSCst->isZero()) {
       B = Val2;
-      if (LHSCC == ICmpInst::ICMP_ULT && Val2 == LHS->getOperand(1))
+      if (LHSCC == Predicate::ICMP_ULT && Val2 == LHS->getOperand(1))
         A = Val;
-      else if (LHSCC == ICmpInst::ICMP_UGT && Val2 == Val)
+      else if (LHSCC == Predicate::ICMP_UGT && Val2 == Val)
         A = LHS->getOperand(1);
     }
     if (A && B)
       return Builder->CreateICmp(
-          ICmpInst::ICMP_UGE,
+          Predicate::ICMP_UGE,
           Builder->CreateAdd(B, ConstantInt::getSigned(B->getType(), -1)), A);
   }
 
   // E.g. (icmp slt x, 0) | (icmp sgt x, n) --> icmp ugt x, n
   if (Value *V = simplifyRangeCheck(LHS, RHS, /*Inverted=*/true))
     return V;
 
   // E.g. (icmp sgt x, n) | (icmp slt x, 0) --> icmp ugt x, n
   if (Value *V = simplifyRangeCheck(RHS, LHS, /*Inverted=*/true))
     return V;
 
   // This only handles icmp of constants: (icmp1 A, C1) | (icmp2 B, C2).
   if (!LHSCst || !RHSCst) return nullptr;
 
   if (LHSCst == RHSCst && LHSCC == RHSCC) {
     // (icmp ne A, 0) | (icmp ne B, 0) --> (icmp ne (A|B), 0)
-    if (LHSCC == ICmpInst::ICMP_NE && LHSCst->isZero()) {
+    if (LHSCC == Predicate::ICMP_NE && LHSCst->isZero()) {
       Value *NewOr = Builder->CreateOr(Val, Val2);
       return Builder->CreateICmp(LHSCC, NewOr, LHSCst);
     }
   }
 
   // (icmp ult (X + CA), C1) | (icmp eq X, C2) -> (icmp ule (X + CA), C1)
   //   iff C2 + CA == C1.
-  if (LHSCC == ICmpInst::ICMP_ULT && RHSCC == ICmpInst::ICMP_EQ) {
+  if (LHSCC == Predicate::ICMP_ULT && RHSCC == Predicate::ICMP_EQ) {
     ConstantInt *AddCst;
     if (match(Val, m_Add(m_Specific(Val2), m_ConstantInt(AddCst))))
       if (RHSCst->getValue() + AddCst->getValue() == LHSCst->getValue())
         return Builder->CreateICmpULE(Val, LHSCst);
   }
 
   // From here on, we only handle:
   //    (icmp1 A, C1) | (icmp2 A, C2) --> something simpler.
   if (Val != Val2) return nullptr;
 
   // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere.
-  if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE ||
-      RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE ||
-      LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE ||
-      RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE)
+  if (LHSCC.isOneOf(Predicate::ICMP_UGE, Predicate::ICMP_ULE,
+                    Predicate::ICMP_SGE, Predicate::ICMP_SLE) ||
+      RHSCC.isOneOf(Predicate::ICMP_UGE, Predicate::ICMP_ULE,
+                    Predicate::ICMP_SGE, Predicate::ICMP_SLE))
     return nullptr;
 
   // We can't fold (ugt x, C) | (sgt x, C2).
   if (!PredicatesFoldable(LHSCC, RHSCC))
     return nullptr;
 
   // Ensure that the larger constant is on the RHS.
   bool ShouldSwap;
-  if (CmpInst::isSigned(LHSCC) ||
-      (ICmpInst::isEquality(LHSCC) &&
-       CmpInst::isSigned(RHSCC)))
+  if (LHSCC.isSigned() || (LHSCC.isEquality() && RHSCC.isSigned()))
     ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue());
   else
     ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue());
 
   if (ShouldSwap) {
     std::swap(LHS, RHS);
     std::swap(LHSCst, RHSCst);
     std::swap(LHSCC, RHSCC);
   }
 
   // At this point, we know we have two icmp instructions
   // comparing a value against two constants and or'ing the result
   // together.  Because of the above check, we know that we only have
   // ICMP_EQ, ICMP_NE, ICMP_LT, and ICMP_GT here. We also know (from the
   // icmp folding check above), that the two constants are not
   // equal.
   assert(LHSCst != RHSCst && "Compares not folded above?");
 
-  switch (LHSCC) {
+  switch (LHSCC.getKind()) {
   default: llvm_unreachable("Unknown integer condition code!");
-  case ICmpInst::ICMP_EQ:
-    switch (RHSCC) {
+  case Predicate::ICMP_EQ:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:
+    case Predicate::ICMP_EQ:
       if (LHS->getOperand(0) == RHS->getOperand(0)) {
         // if LHSCst and RHSCst differ only by one bit:
         // (A == C1 || A == C2) -> (A | (C1 ^ C2)) == C2
         assert(LHSCst->getValue().ule(LHSCst->getValue()));
 
         APInt Xor = LHSCst->getValue() ^ RHSCst->getValue();
         if (Xor.isPowerOf2()) {
           Value *Cst = Builder->getInt(Xor);
           Value *Or = Builder->CreateOr(LHS->getOperand(0), Cst);
-          return Builder->CreateICmp(ICmpInst::ICMP_EQ, Or, RHSCst);
+          return Builder->CreateICmp(Predicate::ICMP_EQ, Or, RHSCst);
         }
       }
 
       if (LHSCst == SubOne(RHSCst)) {
         // (X == 13 | X == 14) -> X-13 <u 2
         Constant *AddCST = ConstantExpr::getNeg(LHSCst);
         Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off");
         AddCST = ConstantExpr::getSub(AddOne(RHSCst), LHSCst);
         return Builder->CreateICmpULT(Add, AddCST);
       }
 
       break;                         // (X == 13 | X == 15) -> no change
-    case ICmpInst::ICMP_UGT:         // (X == 13 | X u> 14) -> no change
-    case ICmpInst::ICMP_SGT:         // (X == 13 | X s> 14) -> no change
+    case Predicate::ICMP_UGT:        // (X == 13 | X u> 14) -> no change
+    case Predicate::ICMP_SGT:        // (X == 13 | X s> 14) -> no change
       break;
-    case ICmpInst::ICMP_NE:          // (X == 13 | X != 15) -> X != 15
-    case ICmpInst::ICMP_ULT:         // (X == 13 | X u< 15) -> X u< 15
-    case ICmpInst::ICMP_SLT:         // (X == 13 | X s< 15) -> X s< 15
+    case Predicate::ICMP_NE:  // (X == 13 | X != 15) -> X != 15
+    case Predicate::ICMP_ULT: // (X == 13 | X u< 15) -> X u< 15
+    case Predicate::ICMP_SLT: // (X == 13 | X s< 15) -> X s< 15
       return RHS;
     }
     break;
-  case ICmpInst::ICMP_NE:
-    switch (RHSCC) {
+  case Predicate::ICMP_NE:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:          // (X != 13 | X == 15) -> X != 13
-    case ICmpInst::ICMP_UGT:         // (X != 13 | X u> 15) -> X != 13
-    case ICmpInst::ICMP_SGT:         // (X != 13 | X s> 15) -> X != 13
+    case Predicate::ICMP_EQ:  // (X != 13 | X == 15) -> X != 13
+    case Predicate::ICMP_UGT: // (X != 13 | X u> 15) -> X != 13
+    case Predicate::ICMP_SGT: // (X != 13 | X s> 15) -> X != 13
       return LHS;
-    case ICmpInst::ICMP_NE:          // (X != 13 | X != 15) -> true
-    case ICmpInst::ICMP_ULT:         // (X != 13 | X u< 15) -> true
-    case ICmpInst::ICMP_SLT:         // (X != 13 | X s< 15) -> true
+    case Predicate::ICMP_NE:  // (X != 13 | X != 15) -> true
+    case Predicate::ICMP_ULT: // (X != 13 | X u< 15) -> true
+    case Predicate::ICMP_SLT: // (X != 13 | X s< 15) -> true
       return Builder->getTrue();
     }
-  case ICmpInst::ICMP_ULT:
-    switch (RHSCC) {
+  case Predicate::ICMP_ULT:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:         // (X u< 13 | X == 14) -> no change
+    case Predicate::ICMP_EQ: // (X u< 13 | X == 14) -> no change
       break;
-    case ICmpInst::ICMP_UGT:        // (X u< 13 | X u> 15) -> (X-13) u> 2
+    case Predicate::ICMP_UGT: // (X u< 13 | X u> 15) -> (X-13) u> 2
       // If RHSCst is [us]MAXINT, it is always false.  Not handling
       // this can cause overflow.
       if (RHSCst->isMaxValue(false))
         return LHS;
       return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), false, false);
-    case ICmpInst::ICMP_SGT:        // (X u< 13 | X s> 15) -> no change
+    case Predicate::ICMP_SGT: // (X u< 13 | X s> 15) -> no change
       break;
-    case ICmpInst::ICMP_NE:         // (X u< 13 | X != 15) -> X != 15
-    case ICmpInst::ICMP_ULT:        // (X u< 13 | X u< 15) -> X u< 15
+    case Predicate::ICMP_NE:  // (X u< 13 | X != 15) -> X != 15
+    case Predicate::ICMP_ULT: // (X u< 13 | X u< 15) -> X u< 15
       return RHS;
-    case ICmpInst::ICMP_SLT:        // (X u< 13 | X s< 15) -> no change
+    case Predicate::ICMP_SLT: // (X u< 13 | X s< 15) -> no change
       break;
     }
     break;
-  case ICmpInst::ICMP_SLT:
-    switch (RHSCC) {
+  case Predicate::ICMP_SLT:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:         // (X s< 13 | X == 14) -> no change
+    case Predicate::ICMP_EQ: // (X s< 13 | X == 14) -> no change
       break;
-    case ICmpInst::ICMP_SGT:        // (X s< 13 | X s> 15) -> (X-13) s> 2
+    case Predicate::ICMP_SGT: // (X s< 13 | X s> 15) -> (X-13) s> 2
       // If RHSCst is [us]MAXINT, it is always false.  Not handling
       // this can cause overflow.
       if (RHSCst->isMaxValue(true))
         return LHS;
       return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), true, false);
-    case ICmpInst::ICMP_UGT:        // (X s< 13 | X u> 15) -> no change
+    case Predicate::ICMP_UGT: // (X s< 13 | X u> 15) -> no change
       break;
-    case ICmpInst::ICMP_NE:         // (X s< 13 | X != 15) -> X != 15
-    case ICmpInst::ICMP_SLT:        // (X s< 13 | X s< 15) -> X s< 15
+    case Predicate::ICMP_NE:  // (X s< 13 | X != 15) -> X != 15
+    case Predicate::ICMP_SLT: // (X s< 13 | X s< 15) -> X s< 15
       return RHS;
-    case ICmpInst::ICMP_ULT:        // (X s< 13 | X u< 15) -> no change
+    case Predicate::ICMP_ULT: // (X s< 13 | X u< 15) -> no change
       break;
     }
     break;
-  case ICmpInst::ICMP_UGT:
-    switch (RHSCC) {
+  case Predicate::ICMP_UGT:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:         // (X u> 13 | X == 15) -> X u> 13
-    case ICmpInst::ICMP_UGT:        // (X u> 13 | X u> 15) -> X u> 13
+    case Predicate::ICMP_EQ:  // (X u> 13 | X == 15) -> X u> 13
+    case Predicate::ICMP_UGT: // (X u> 13 | X u> 15) -> X u> 13
       return LHS;
-    case ICmpInst::ICMP_SGT:        // (X u> 13 | X s> 15) -> no change
+    case Predicate::ICMP_SGT: // (X u> 13 | X s> 15) -> no change
       break;
-    case ICmpInst::ICMP_NE:         // (X u> 13 | X != 15) -> true
-    case ICmpInst::ICMP_ULT:        // (X u> 13 | X u< 15) -> true
+    case Predicate::ICMP_NE:  // (X u> 13 | X != 15) -> true
+    case Predicate::ICMP_ULT: // (X u> 13 | X u< 15) -> true
       return Builder->getTrue();
-    case ICmpInst::ICMP_SLT:        // (X u> 13 | X s< 15) -> no change
+    case Predicate::ICMP_SLT: // (X u> 13 | X s< 15) -> no change
       break;
     }
     break;
-  case ICmpInst::ICMP_SGT:
-    switch (RHSCC) {
+  case Predicate::ICMP_SGT:
+    switch (RHSCC.getKind()) {
     default: llvm_unreachable("Unknown integer condition code!");
-    case ICmpInst::ICMP_EQ:         // (X s> 13 | X == 15) -> X > 13
-    case ICmpInst::ICMP_SGT:        // (X s> 13 | X s> 15) -> X > 13
+    case Predicate::ICMP_EQ:  // (X s> 13 | X == 15) -> X > 13
+    case Predicate::ICMP_SGT: // (X s> 13 | X s> 15) -> X > 13
       return LHS;
-    case ICmpInst::ICMP_UGT:        // (X s> 13 | X u> 15) -> no change
+    case Predicate::ICMP_UGT: // (X s> 13 | X u> 15) -> no change
       break;
-    case ICmpInst::ICMP_NE:         // (X s> 13 | X != 15) -> true
-    case ICmpInst::ICMP_SLT:        // (X s> 13 | X s< 15) -> true
+    case Predicate::ICMP_NE:  // (X s> 13 | X != 15) -> true
+    case Predicate::ICMP_SLT: // (X s> 13 | X s< 15) -> true
       return Builder->getTrue();
-    case ICmpInst::ICMP_ULT:        // (X s> 13 | X u< 15) -> no change
+    case Predicate::ICMP_ULT: // (X s> 13 | X u< 15) -> no change
       break;
     }
     break;
   }
   return nullptr;
 }
 
 /// Optimize (fcmp)|(fcmp).  NOTE: Unlike the rest of instcombine, this returns
 /// a Value which should already be inserted into the function.
 Value *InstCombiner::FoldOrOfFCmps(FCmpInst *LHS, FCmpInst *RHS) {
   Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1);
   Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1);
-  FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate();
+  Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate();
 
   if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) {
     // Swap RHS operands to match LHS.
-    Op1CC = FCmpInst::getSwappedPredicate(Op1CC);
+    Op1CC = Op1CC.getSwapped();
     std::swap(Op1LHS, Op1RHS);
   }
 
   // Simplify (fcmp cc0 x, y) | (fcmp cc1 x, y).
   // This is a similar transformation to the one in FoldAndOfFCmps.
   //
   // Since (R & CC0) and (R & CC1) are either R or 0, we actually have this:
   //    bool(R & CC0) || bool(R & CC1)
   //  = bool((R & CC0) | (R & CC1))
   //  = bool(R & (CC0 | CC1)) <= by reversed distribution (contribution? ;)
   if (Op0LHS == Op1LHS && Op0RHS == Op1RHS)
     return getFCmpValue(getFCmpCode(Op0CC) | getFCmpCode(Op1CC), Op0LHS, Op0RHS,
                         Builder);
 
-  if (LHS->getPredicate() == FCmpInst::FCMP_UNO &&
-      RHS->getPredicate() == FCmpInst::FCMP_UNO &&
+  if (LHS->getPredicate() == Predicate::FCMP_UNO &&
+      RHS->getPredicate() == Predicate::FCMP_UNO &&
       LHS->getOperand(0)->getType() == RHS->getOperand(0)->getType()) {
     if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1)))
       if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) {
         // If either of the constants are nans, then the whole thing returns
         // true.
         if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN())
           return Builder->getTrue();
 

lib/Transforms/InstCombine/InstCombineCalls.cpp

 
 /// Decode XOP integer vector comparison intrinsics.
 static Value *simplifyX86vpcom(const IntrinsicInst &II,
                                InstCombiner::BuilderTy &Builder,
                                bool IsSigned) {
   if (auto *CInt = dyn_cast<ConstantInt>(II.getArgOperand(2))) {
     uint64_t Imm = CInt->getZExtValue() & 0x7;
     VectorType *VecTy = cast<VectorType>(II.getType());
-    CmpInst::Predicate Pred = ICmpInst::BAD_ICMP_PREDICATE;
+    Predicate Pred = Predicate::BAD_ICMP_PREDICATE;
 
     switch (Imm) {
     case 0x0:
-      Pred = IsSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
+      Pred = IsSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT;
       break;
     case 0x1:
-      Pred = IsSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE;
+      Pred = IsSigned ? Predicate::ICMP_SLE : Predicate::ICMP_ULE;
       break;
     case 0x2:
-      Pred = IsSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
+      Pred = IsSigned ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
       break;
     case 0x3:
-      Pred = IsSigned ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE;
+      Pred = IsSigned ? Predicate::ICMP_SGE : Predicate::ICMP_UGE;
       break;
     case 0x4:
-      Pred = ICmpInst::ICMP_EQ; break;
+      Pred = Predicate::ICMP_EQ;
+      break;
     case 0x5:
-      Pred = ICmpInst::ICMP_NE; break;
+      Pred = Predicate::ICMP_NE;
+      break;
     case 0x6:
       return ConstantInt::getSigned(VecTy, 0); // FALSE
     case 0x7:
       return ConstantInt::getSigned(VecTy, -1); // TRUE
     }
 
     if (Value *Cmp = Builder.CreateICmp(Pred, II.getArgOperand(0),
                                         II.getArgOperand(1)))
if (match(IIOperand, m_Not(m_Or(m_Value(A), m_Value(B))))) {
       return eraseInstFromFunction(*II);
     }
 
     // assume( (load addr) != null ) -> add 'nonnull' metadata to load
     // (if assume is valid at the load)
     if (ICmpInst* ICmp = dyn_cast<ICmpInst>(IIOperand)) {
       Value *LHS = ICmp->getOperand(0);
       Value *RHS = ICmp->getOperand(1);
-      if (ICmpInst::ICMP_NE == ICmp->getPredicate() &&
-          isa<LoadInst>(LHS) &&
-          isa<Constant>(RHS) &&
-          RHS->getType()->isPointerTy() &&
-          cast<Constant>(RHS)->isNullValue()) {
+      if (Predicate::ICMP_NE == ICmp->getPredicate().getKind() &&
+          isa<LoadInst>(LHS) && isa<Constant>(RHS) &&
+          RHS->getType()->isPointerTy() && cast<Constant>(RHS)->isNullValue()) {
         LoadInst* LI = cast<LoadInst>(LHS);
         if (isValidAssumeForContext(II, LI, &DT)) {
           MDNode *MD = MDNode::get(II->getContext(), None);
           LI->setMetadata(LLVMContext::MD_nonnull, MD);
           return eraseInstFromFunction(*II);
         }
       }
       // TODO: apply nonnull return attributes to calls and invokes

lib/Transforms/InstCombine/InstCombineCasts.cpp

if ((DestTy->isVectorTy() || ShouldChangeType(SrcTy, DestTy)) &&
     return replaceInstUsesWith(CI, Res);
   }
 
   // Canonicalize trunc x to i1 -> (icmp ne (and x, 1), 0), likewise for vector.
   if (DestTy->getScalarSizeInBits() == 1) {
     Constant *One = ConstantInt::get(SrcTy, 1);
     Src = Builder->CreateAnd(Src, One);
     Value *Zero = Constant::getNullValue(Src->getType());
-    return new ICmpInst(ICmpInst::ICMP_NE, Src, Zero);
+    return new ICmpInst(Predicate::ICMP_NE, Src, Zero);
   }
 
   // Transform trunc(lshr (zext A), Cst) to eliminate one type conversion.
   Value *A = nullptr; ConstantInt *Cst = nullptr;
   if (Src->hasOneUse() &&
       match(Src, m_LShr(m_ZExt(m_Value(A)), m_ConstantInt(Cst)))) {
     // We have three types to worry about here, the type of A, the source of
     // the truncate (MidSize), and the destination of the truncate. We know that
Instruction *InstCombiner::transformZExtICmp(ICmpInst *ICI, ZExtInst &CI,
   // If we are just checking for a icmp eq of a single bit and zext'ing it
   // to an integer, then shift the bit to the appropriate place and then
   // cast to integer to avoid the comparison.
   if (ConstantInt *Op1C = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
     const APInt &Op1CV = Op1C->getValue();
 
     // zext (x <s  0) to i32 --> x>>u31      true if signbit set.
     // zext (x >s -1) to i32 --> (x>>u31)^1  true if signbit clear.
-    if ((ICI->getPredicate() == ICmpInst::ICMP_SLT && Op1CV == 0) ||
-        (ICI->getPredicate() == ICmpInst::ICMP_SGT && Op1CV.isAllOnesValue())) {
+    if ((ICI->getPredicate() == Predicate::ICMP_SLT && Op1CV == 0) ||
+        (ICI->getPredicate() == Predicate::ICMP_SGT &&
+         Op1CV.isAllOnesValue())) {
       if (!DoTransform) return ICI;
 
       Value *In = ICI->getOperand(0);
       Value *Sh = ConstantInt::get(In->getType(),
                                    In->getType()->getScalarSizeInBits() - 1);
       In = Builder->CreateLShr(In, Sh, In->getName() + ".lobit");
       if (In->getType() != CI.getType())
         In = Builder->CreateIntCast(In, CI.getType(), false/*ZExt*/);
 
-      if (ICI->getPredicate() == ICmpInst::ICMP_SGT) {
+      if (ICI->getPredicate() == Predicate::ICMP_SGT) {
         Constant *One = ConstantInt::get(In->getType(), 1);
         In = Builder->CreateXor(In, One, In->getName() + ".not");
       }
 
       return replaceInstUsesWith(CI, In);
     }
 
     // zext (X == 0) to i32 --> X^1      iff X has only the low bit set.
if ((Op1CV == 0 || Op1CV.isPowerOf2()) &&
       uint32_t BitWidth = Op1C->getType()->getBitWidth();
       APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
       computeKnownBits(ICI->getOperand(0), KnownZero, KnownOne, 0, &CI);
 
       APInt KnownZeroMask(~KnownZero);
       if (KnownZeroMask.isPowerOf2()) { // Exactly 1 possible 1?
         if (!DoTransform) return ICI;
 
-        bool isNE = ICI->getPredicate() == ICmpInst::ICMP_NE;
+        bool isNE = ICI->getPredicate() == Predicate::ICMP_NE;
         if (Op1CV != 0 && (Op1CV != KnownZeroMask)) {
           // (X&4) == 2 --> false
           // (X&4) != 2 --> true
           Constant *Res = ConstantInt::get(Type::getInt1Ty(CI.getContext()),
                                            isNE);
           Res = ConstantExpr::getZExt(Res, CI.getType());
           return replaceInstUsesWith(CI, Res);
         }
if (IntegerType *ITy = dyn_cast<IntegerType>(CI.getType())) {
           if (KnownOneLHS.uge(UnknownBit))
             Result = Builder->CreateAnd(Result,
                                         ConstantInt::get(ITy, UnknownBit));
 
           // Shift the bit we're testing down to the lsb.
           Result = Builder->CreateLShr(
                Result, ConstantInt::get(ITy, UnknownBit.countTrailingZeros()));
 
-          if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
+          if (ICI->getPredicate() == Predicate::ICMP_EQ)
             Result = Builder->CreateXor(Result, ConstantInt::get(ITy, 1));
           Result->takeName(ICI);
           return replaceInstUsesWith(CI, Result);
         }
       }
     }
   }
 
Instruction *InstCombiner::visitZExt(ZExtInst &CI) {
   }
 
   return nullptr;
 }
 
 /// Transform (sext icmp) to bitwise / integer operations to eliminate the icmp.
 Instruction *InstCombiner::transformSExtICmp(ICmpInst *ICI, Instruction &CI) {
   Value *Op0 = ICI->getOperand(0), *Op1 = ICI->getOperand(1);
-  ICmpInst::Predicate Pred = ICI->getPredicate();
+  Predicate Pred = ICI->getPredicate();
 
   // Don't bother if Op1 isn't of vector or integer type.
   if (!Op1->getType()->isIntOrIntVectorTy())
     return nullptr;
 
   if (Constant *Op1C = dyn_cast<Constant>(Op1)) {
     // (x <s  0) ? -1 : 0 -> ashr x, 31        -> all ones if negative
     // (x >s -1) ? -1 : 0 -> not (ashr x, 31)  -> all ones if positive
-    if ((Pred == ICmpInst::ICMP_SLT && Op1C->isNullValue()) ||
-        (Pred == ICmpInst::ICMP_SGT && Op1C->isAllOnesValue())) {
+    if ((Pred == Predicate::ICMP_SLT && Op1C->isNullValue()) ||
+        (Pred == Predicate::ICMP_SGT && Op1C->isAllOnesValue())) {
 
       Value *Sh = ConstantInt::get(Op0->getType(),
                                    Op0->getType()->getScalarSizeInBits()-1);
       Value *In = Builder->CreateAShr(Op0, Sh, Op0->getName()+".lobit");
       if (In->getType() != CI.getType())
         In = Builder->CreateIntCast(In, CI.getType(), true/*SExt*/);
 
-      if (Pred == ICmpInst::ICMP_SGT)
+      if (Pred == Predicate::ICMP_SGT)
         In = Builder->CreateNot(In, In->getName()+".not");
       return replaceInstUsesWith(CI, In);
     }
   }
 
   if (ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
     // If we know that only one bit of the LHS of the icmp can be set and we
     // have an equality comparison with zero or a power of 2, we can transform
     // the icmp and sext into bitwise/integer operations.
     if (ICI->hasOneUse() &&
         ICI->isEquality() && (Op1C->isZero() || Op1C->getValue().isPowerOf2())){
       unsigned BitWidth = Op1C->getType()->getBitWidth();
       APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
       computeKnownBits(Op0, KnownZero, KnownOne, 0, &CI);
 
       APInt KnownZeroMask(~KnownZero);
       if (KnownZeroMask.isPowerOf2()) {
         Value *In = ICI->getOperand(0);
 
         // If the icmp tests for a known zero bit we can constant fold it.
         if (!Op1C->isZero() && Op1C->getValue() != KnownZeroMask) {
-          Value *V = Pred == ICmpInst::ICMP_NE ?
-                       ConstantInt::getAllOnesValue(CI.getType()) :
-                       ConstantInt::getNullValue(CI.getType());
+          Value *V = Pred == Predicate::ICMP_NE
+                         ? ConstantInt::getAllOnesValue(CI.getType())
+                         : ConstantInt::getNullValue(CI.getType());
           return replaceInstUsesWith(CI, V);
         }
 
-        if (!Op1C->isZero() == (Pred == ICmpInst::ICMP_NE)) {
+        if (!Op1C->isZero() == (Pred == Predicate::ICMP_NE)) {
           // sext ((x & 2^n) == 0)   -> (x >> n) - 1
           // sext ((x & 2^n) != 2^n) -> (x >> n) - 1
           unsigned ShiftAmt = KnownZeroMask.countTrailingZeros();
           // Perform a right shift to place the desired bit in the LSB.
           if (ShiftAmt)
             In = Builder->CreateLShr(In,
                                      ConstantInt::get(In->getType(), ShiftAmt));
 

lib/Transforms/InstCombine/InstCombineCompares.cpp

for (auto *U : I.users())
     if (isa<BranchInst>(U))
       return isSignBit;
   return false;
 }
 
 /// Given an exploded icmp instruction, return true if the comparison only
 /// checks the sign bit. If it only checks the sign bit, set TrueIfSigned if the
 /// result of the comparison is true when the input value is signed.
-static bool isSignBitCheck(ICmpInst::Predicate Pred, ConstantInt *RHS,
+static bool isSignBitCheck(Predicate Pred, ConstantInt *RHS,
                            bool &TrueIfSigned) {
-  switch (Pred) {
-  case ICmpInst::ICMP_SLT:   // True if LHS s< 0
+  switch (Pred.getKind()) {
+  case Predicate::ICMP_SLT: // True if LHS s< 0
     TrueIfSigned = true;
     return RHS->isZero();
-  case ICmpInst::ICMP_SLE:   // True if LHS s<= RHS and RHS == -1
+  case Predicate::ICMP_SLE: // True if LHS s<= RHS and RHS == -1
     TrueIfSigned = true;
     return RHS->isAllOnesValue();
-  case ICmpInst::ICMP_SGT:   // True if LHS s> -1
+  case Predicate::ICMP_SGT: // True if LHS s> -1
     TrueIfSigned = false;
     return RHS->isAllOnesValue();
-  case ICmpInst::ICMP_UGT:
+  case Predicate::ICMP_UGT:
     // True if LHS u> RHS and RHS == high-bit-mask - 1
     TrueIfSigned = true;
     return RHS->isMaxValue(true);
-  case ICmpInst::ICMP_UGE:
+  case Predicate::ICMP_UGE:
     // True if LHS u>= RHS and RHS == high-bit-mask (2^7, 2^15, 2^31, etc)
     TrueIfSigned = true;
     return RHS->getValue().isSignBit();
   default:
     return false;
   }
 }
 
 /// Returns true if the exploded icmp can be expressed as a signed comparison
 /// to zero and updates the predicate accordingly.
 /// The signedness of the comparison is preserved.
-static bool isSignTest(ICmpInst::Predicate &Pred, const ConstantInt *RHS) {
-  if (!ICmpInst::isSigned(Pred))
+static bool isSignTest(Predicate &Pred, const ConstantInt *RHS) {
+  if (!Pred.isSigned())
     return false;
 
   if (RHS->isZero())
-    return ICmpInst::isRelational(Pred);
+    return Pred.isRelational();
 
   if (RHS->isOne()) {
-    if (Pred == ICmpInst::ICMP_SLT) {
-      Pred = ICmpInst::ICMP_SLE;
+    if (Pred == Predicate::ICMP_SLT) {
+      Pred = Predicate::ICMP_SLE;
       return true;
     }
   } else if (RHS->isAllOnesValue()) {
-    if (Pred == ICmpInst::ICMP_SGT) {
-      Pred = ICmpInst::ICMP_SGE;
+    if (Pred == Predicate::ICMP_SGT) {
+      Pred = Predicate::ICMP_SGE;
       return true;
     }
   }
 
   return false;
 }
 
 /// Given a signed integer type and a set of known zero and one bits, compute
if (SecondTrueElement != Overdefined) {
     // None true -> false.
     if (FirstTrueElement == Undefined)
       return replaceInstUsesWith(ICI, Builder->getFalse());
 
     Value *FirstTrueIdx = ConstantInt::get(Idx->getType(), FirstTrueElement);
 
     // True for one element -> 'i == 47'.
     if (SecondTrueElement == Undefined)
-      return new ICmpInst(ICmpInst::ICMP_EQ, Idx, FirstTrueIdx);
+      return new ICmpInst(Predicate::ICMP_EQ, Idx, FirstTrueIdx);
 
     // True for two elements -> 'i == 47 | i == 72'.
     Value *C1 = Builder->CreateICmpEQ(Idx, FirstTrueIdx);
     Value *SecondTrueIdx = ConstantInt::get(Idx->getType(), SecondTrueElement);
     Value *C2 = Builder->CreateICmpEQ(Idx, SecondTrueIdx);
     return BinaryOperator::CreateOr(C1, C2);
   }
 
   // If the comparison is only false for one or two elements, emit direct
   // comparisons.
   if (SecondFalseElement != Overdefined) {
     // None false -> true.
     if (FirstFalseElement == Undefined)
       return replaceInstUsesWith(ICI, Builder->getTrue());
 
     Value *FirstFalseIdx = ConstantInt::get(Idx->getType(), FirstFalseElement);
 
     // False for one element -> 'i != 47'.
     if (SecondFalseElement == Undefined)
-      return new ICmpInst(ICmpInst::ICMP_NE, Idx, FirstFalseIdx);
+      return new ICmpInst(Predicate::ICMP_NE, Idx, FirstFalseIdx);
 
     // False for two elements -> 'i != 47 & i != 72'.
     Value *C1 = Builder->CreateICmpNE(Idx, FirstFalseIdx);
     Value *SecondFalseIdx = ConstantInt::get(Idx->getType(),SecondFalseElement);
     Value *C2 = Builder->CreateICmpNE(Idx, SecondFalseIdx);
     return BinaryOperator::CreateAnd(C1, C2);
   }
 
   // If the comparison can be replaced with a range comparison for the elements
   // where it is true, emit the range check.
   if (TrueRangeEnd != Overdefined) {
     assert(TrueRangeEnd != FirstTrueElement && "Should emit single compare");
 
     // Generate (i-FirstTrue) <u (TrueRangeEnd-FirstTrue+1).
     if (FirstTrueElement) {
       Value *Offs = ConstantInt::get(Idx->getType(), -FirstTrueElement);
       Idx = Builder->CreateAdd(Idx, Offs);
     }
 
     Value *End = ConstantInt::get(Idx->getType(),
                                   TrueRangeEnd-FirstTrueElement+1);
-    return new ICmpInst(ICmpInst::ICMP_ULT, Idx, End);
+    return new ICmpInst(Predicate::ICMP_ULT, Idx, End);
   }
 
   // False range check.
   if (FalseRangeEnd != Overdefined) {
     assert(FalseRangeEnd != FirstFalseElement && "Should emit single compare");
     // Generate (i-FirstFalse) >u (FalseRangeEnd-FirstFalse).
     if (FirstFalseElement) {
       Value *Offs = ConstantInt::get(Idx->getType(), -FirstFalseElement);
       Idx = Builder->CreateAdd(Idx, Offs);
     }
 
     Value *End = ConstantInt::get(Idx->getType(),
                                   FalseRangeEnd-FirstFalseElement);
-    return new ICmpInst(ICmpInst::ICMP_UGT, Idx, End);
+    return new ICmpInst(Predicate::ICMP_UGT, Idx, End);
   }
 
   // If a magic bitvector captures the entire comparison state
   // of this load, replace it with computation that does:
   //   ((magic_cst >> i) & 1) != 0
   {
     Type *Ty = nullptr;
 
     // Look for an appropriate type:
     // - The type of Idx if the magic fits
     // - The smallest fitting legal type if we have a DataLayout
     // - Default to i32
     if (ArrayElementCount <= Idx->getType()->getIntegerBitWidth())
       Ty = Idx->getType();
     else
       Ty = DL.getSmallestLegalIntType(Init->getContext(), ArrayElementCount);
 
     if (Ty) {
       Value *V = Builder->CreateIntCast(Idx, Ty, false);
       V = Builder->CreateLShr(ConstantInt::get(Ty, MagicBitvector), V);
       V = Builder->CreateAnd(ConstantInt::get(Ty, 1), V);
-      return new ICmpInst(ICmpInst::ICMP_NE, V, ConstantInt::get(Ty, 0));
+      return new ICmpInst(Predicate::ICMP_NE, V, ConstantInt::get(Ty, 0));
     }
   }
 
   return nullptr;
 }
 
 /// Return a value that can be used to compare the *offset* implied by a GEP to
 /// zero. For example, if we have &A[i], we want to return 'i' for
getAsConstantIndexedAddress(Value *V, const DataLayout &DL) {
   }
   return {V, Index};
 }
 
 /// Converts (CMP GEPLHS, RHS) if this change would make RHS a constant.
 /// We can look through PHIs, GEPs and casts in order to determine a common base
 /// between GEPLHS and RHS.
 static Instruction *transformToIndexedCompare(GEPOperator *GEPLHS, Value *RHS,
-                                              ICmpInst::Predicate Cond,
+                                              Predicate Cond,
                                               const DataLayout &DL) {
   if (!GEPLHS->hasAllConstantIndices())
     return nullptr;
 
   Value *PtrBase, *Index;
   std::tie(PtrBase, Index) = getAsConstantIndexedAddress(GEPLHS, DL);
 
   // The set of nodes that will take part in this transformation.
static Instruction *transformToIndexedCompare(GEPOperator *GEPLHS, Value *RHS,
   // this as:
   //   OFFSET1 cmp OFFSET2
   Value *NewRHS = rewriteGEPAsOffset(RHS, PtrBase, DL, Nodes);
 
   // RewriteGEPAsOffset has replaced RHS and all of its uses with a re-written
   // GEP having PtrBase as the pointer base, and has returned in NewRHS the
   // offset. Since Index is the offset of LHS to the base pointer, we will now
   // compare the offsets instead of comparing the pointers.
-  return new ICmpInst(ICmpInst::getSignedPredicate(Cond), Index, NewRHS);
+  return new ICmpInst(Cond.getSigned(), Index, NewRHS);
 }
 
 /// Fold comparisons between a GEP instruction and something else. At this point
 /// we know that the GEP is on the LHS of the comparison.
 Instruction *InstCombiner::foldGEPICmp(GEPOperator *GEPLHS, Value *RHS,
-                                       ICmpInst::Predicate Cond,
-                                       Instruction &I) {
+                                       Predicate Cond, Instruction &I) {
   // Don't transform signed compares of GEPs into index compares. Even if the
   // GEP is inbounds, the final add of the base pointer can have signed overflow
   // and would change the result of the icmp.
   // e.g. "&foo[0] <s &foo[1]" can't be folded to "true" because "foo" could be
   // the maximum signed value for the pointer type.
-  if (ICmpInst::isSigned(Cond))
+  if (Cond.isSigned())
     return nullptr;
 
   // Look through bitcasts and addrspacecasts. We do not however want to remove
   // 0 GEPs.
   if (!isa<GetElementPtrInst>(RHS))
     RHS = RHS->stripPointerCasts();
 
   Value *PtrBase = GEPLHS->getOperand(0);
   if (PtrBase == RHS && GEPLHS->isInBounds()) {
     // ((gep Ptr, OFFSET) cmp Ptr)   ---> (OFFSET cmp 0).
     // This transformation (ignoring the base and scales) is valid because we
     // know pointers can't overflow since the gep is inbounds.  See if we can
     // output an optimized form.
     Value *Offset = EvaluateGEPOffsetExpression(GEPLHS, *this, DL);
 
     // If not, synthesize the offset the hard way.
     if (!Offset)
       Offset = EmitGEPOffset(GEPLHS);
-    return new ICmpInst(ICmpInst::getSignedPredicate(Cond), Offset,
+    return new ICmpInst(Cond.getSigned(), Offset,
                         Constant::getNullValue(Offset->getType()));
   } else if (GEPOperator *GEPRHS = dyn_cast<GEPOperator>(RHS)) {
     // If the base pointers are different, but the indices are the same, just
     // compare the base pointer.
     if (PtrBase != GEPRHS->getOperand(0)) {
       bool IndicesTheSame = GEPLHS->getNumOperands()==GEPRHS->getNumOperands();
       IndicesTheSame &= GEPLHS->getOperand(0)->getType() ==
                         GEPRHS->getOperand(0)->getType();
if (PtrBase != GEPRHS->getOperand(0)) {
         if (LHSIndexTy != RHSIndexTy) {
           if (LHSIndexTy->getPrimitiveSizeInBits() <
               RHSIndexTy->getPrimitiveSizeInBits()) {
             ROffset = Builder->CreateTrunc(ROffset, LHSIndexTy);
           } else
             LOffset = Builder->CreateTrunc(LOffset, RHSIndexTy);
         }
 
-        Value *Cmp = Builder->CreateICmp(ICmpInst::getSignedPredicate(Cond),
-                                         LOffset, ROffset);
+        Value *Cmp = Builder->CreateICmp(Cond.getSigned(), LOffset, ROffset);
         return replaceInstUsesWith(I, Cmp);
       }
 
       // Otherwise, the base pointers are different and the indices are
       // different. Try convert this to an indexed compare by looking through
       // PHIs/casts.
       return transformToIndexedCompare(GEPLHS, RHS, Cond, DL);
     }
 
     // If one of the GEPs has all zero indices, recurse.
     if (GEPLHS->hasAllZeroIndices())
-      return foldGEPICmp(GEPRHS, GEPLHS->getOperand(0),
-                         ICmpInst::getSwappedPredicate(Cond), I);
+      return foldGEPICmp(GEPRHS, GEPLHS->getOperand(0), Cond.getSwapped(), I);
 
     // If the other GEP has all zero indices, recurse.
     if (GEPRHS->hasAllZeroIndices())
       return foldGEPICmp(GEPLHS, GEPRHS->getOperand(0), Cond, I);
 
     bool GEPsInBounds = GEPLHS->isInBounds() && GEPRHS->isInBounds();
     if (GEPLHS->getNumOperands() == GEPRHS->getNumOperands()) {
       // If the GEPs only differ by one index, compare it.
if (GEPLHS->getNumOperands() == GEPRHS->getNumOperands()) {
           } else {
             if (NumDifferences++) break;
             DiffOperand = i;
           }
         }
 
       if (NumDifferences == 0)   // SAME GEP?
         return replaceInstUsesWith(I, // No comparison is needed here.
-                             Builder->getInt1(ICmpInst::isTrueWhenEqual(Cond)));
+                                   Builder->getInt1(Cond.isTrueWhenEqual()));
 
       else if (NumDifferences == 1 && GEPsInBounds) {
         Value *LHSV = GEPLHS->getOperand(DiffOperand);
         Value *RHSV = GEPRHS->getOperand(DiffOperand);
         // Make sure we do a signed comparison here.
-        return new ICmpInst(ICmpInst::getSignedPredicate(Cond), LHSV, RHSV);
+        return new ICmpInst(Cond.getSigned(), LHSV, RHSV);
       }
     }
 
     // Only lower this if the icmp is the only user of the GEP or if we expect
     // the result to fold to a constant!
     if (GEPsInBounds && (isa<ConstantExpr>(GEPLHS) || GEPLHS->hasOneUse()) &&
         (isa<ConstantExpr>(GEPRHS) || GEPRHS->hasOneUse())) {
       // ((gep Ptr, OFFSET1) cmp (gep Ptr, OFFSET2)  --->  (OFFSET1 cmp OFFSET2)
       Value *L = EmitGEPOffset(GEPLHS);
       Value *R = EmitGEPOffset(GEPRHS);
-      return new ICmpInst(ICmpInst::getSignedPredicate(Cond), L, R);
+      return new ICmpInst(Cond.getSigned(), L, R);
     }
   }
 
   // Try convert this to an indexed compare by looking through PHIs/casts as a
   // last resort.
   return transformToIndexedCompare(GEPLHS, RHS, Cond, DL);
 }
 
for (Use &U : V->uses()) {
       if (Worklist.size() >= MaxIter)
         return nullptr;
       Worklist.push_back(&U);
     }
   }
 
   Type *CmpTy = CmpInst::makeCmpResultType(Other->getType());
   return replaceInstUsesWith(
-      ICI,
-      ConstantInt::get(CmpTy, !CmpInst::isTrueWhenEqual(ICI.getPredicate())));
+      ICI, ConstantInt::get(CmpTy, !ICI.getPredicate().isTrueWhenEqual()));
 }
 
 /// Fold "icmp pred (X+CI), X".
-Instruction *InstCombiner::foldICmpAddOpConst(Instruction &ICI,
-                                              Value *X, ConstantInt *CI,
-                                              ICmpInst::Predicate Pred) {
+Instruction *InstCombiner::foldICmpAddOpConst(Instruction &ICI, Value *X,
+                                              ConstantInt *CI, Predicate Pred) {
   // From this point on, we know that (X+C <= X) --> (X+C < X) because C != 0,
   // so the values can never be equal.  Similarly for all other "or equals"
   // operators.
 
   // (X+1) <u X        --> X >u (MAXUINT-1)        --> X == 255
   // (X+2) <u X        --> X >u (MAXUINT-2)        --> X > 253
   // (X+MAXUINT) <u X  --> X >u (MAXUINT-MAXUINT)  --> X != 0
-  if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) {
+  if (Pred == Predicate::ICMP_ULT || Pred == Predicate::ICMP_ULE) {
     Value *R =
       ConstantExpr::getSub(ConstantInt::getAllOnesValue(CI->getType()), CI);
-    return new ICmpInst(ICmpInst::ICMP_UGT, X, R);
+    return new ICmpInst(Predicate::ICMP_UGT, X, R);
   }
 
   // (X+1) >u X        --> X <u (0-1)        --> X != 255
   // (X+2) >u X        --> X <u (0-2)        --> X <u 254
   // (X+MAXUINT) >u X  --> X <u (0-MAXUINT)  --> X <u 1  --> X == 0
-  if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE)
-    return new ICmpInst(ICmpInst::ICMP_ULT, X, ConstantExpr::getNeg(CI));
+  if (Pred == Predicate::ICMP_UGT || Pred == Predicate::ICMP_UGE)
+    return new ICmpInst(Predicate::ICMP_ULT, X, ConstantExpr::getNeg(CI));
 
   unsigned BitWidth = CI->getType()->getPrimitiveSizeInBits();
   ConstantInt *SMax = ConstantInt::get(X->getContext(),
                                        APInt::getSignedMaxValue(BitWidth));
 
   // (X+ 1) <s X       --> X >s (MAXSINT-1)          --> X == 127
   // (X+ 2) <s X       --> X >s (MAXSINT-2)          --> X >s 125
   // (X+MAXSINT) <s X  --> X >s (MAXSINT-MAXSINT)    --> X >s 0
   // (X+MINSINT) <s X  --> X >s (MAXSINT-MINSINT)    --> X >s -1
   // (X+ -2) <s X      --> X >s (MAXSINT- -2)        --> X >s 126
   // (X+ -1) <s X      --> X >s (MAXSINT- -1)        --> X != 127
-  if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE)
-    return new ICmpInst(ICmpInst::ICMP_SGT, X, ConstantExpr::getSub(SMax, CI));
+  if (Pred == Predicate::ICMP_SLT || Pred == Predicate::ICMP_SLE)
+    return new ICmpInst(Predicate::ICMP_SGT, X, ConstantExpr::getSub(SMax, CI));
 
   // (X+ 1) >s X       --> X <s (MAXSINT-(1-1))       --> X != 127
   // (X+ 2) >s X       --> X <s (MAXSINT-(2-1))       --> X <s 126
   // (X+MAXSINT) >s X  --> X <s (MAXSINT-(MAXSINT-1)) --> X <s 1
   // (X+MINSINT) >s X  --> X <s (MAXSINT-(MINSINT-1)) --> X <s -2
   // (X+ -2) >s X      --> X <s (MAXSINT-(-2-1))      --> X <s -126
   // (X+ -1) >s X      --> X <s (MAXSINT-(-1-1))      --> X == -128
 
-  assert(Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE);
+  assert(Pred == Predicate::ICMP_SGT || Pred == Predicate::ICMP_SGE);
   Constant *C = Builder->getInt(CI->getValue()-1);
-  return new ICmpInst(ICmpInst::ICMP_SLT, X, ConstantExpr::getSub(SMax, C));
+  return new ICmpInst(Predicate::ICMP_SLT, X, ConstantExpr::getSub(SMax, C));
 }
 
 /// Fold "icmp pred, ([su]div X, DivRHS), CmpRHS" where DivRHS and CmpRHS are
 /// both known to be integer constants.
 Instruction *InstCombiner::foldICmpDivConst(ICmpInst &ICI, BinaryOperator *DivI,
                                             ConstantInt *DivRHS) {
   ConstantInt *CmpRHS = cast<ConstantInt>(ICI.getOperand(1));
   const APInt &CmpRHSV = CmpRHS->getValue();
Instruction *InstCombiner::foldICmpDivConst(ICmpInst &ICI, BinaryOperator *DivI,
 
   // Determine if the product overflows by seeing if the product is
   // not equal to the divide. Make sure we do the same kind of divide
   // as in the LHS instruction that we're folding.
   bool ProdOV = (DivIsSigned ? ConstantExpr::getSDiv(Prod, DivRHS) :
                  ConstantExpr::getUDiv(Prod, DivRHS)) != CmpRHS;
 
   // Get the ICmp opcode
-  ICmpInst::Predicate Pred = ICI.getPredicate();
+  Predicate Pred = ICI.getPredicate();
 
   // If the division is known to be exact, then there is no remainder from the
   // divide, so the covered range size is unit, otherwise it is the divisor.
   ConstantInt *RangeSize = DivI->isExact() ? getOne(Prod) : DivRHS;
 
   // Figure out the interval that is being checked.  For example, a comparison
   // like "X /u 5 == 0" is really checking that X is in the interval [0, 5).
   // Compute this interval based on the constants involved and the signedness of
if (!DivIsSigned) {  // udiv
     } else {                       // (X / neg) op neg
       LoBound = Prod;       // e.g. X/-5 op -3  --> [15, 20)
       LoOverflow = HiOverflow = ProdOV;
       if (!HiOverflow)
         HiOverflow = SubWithOverflow(HiBound, Prod, RangeSize, true);
     }
 
     // Dividing by a negative swaps the condition.  LT <-> GT
-    Pred = ICmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
   }
 
   Value *X = DivI->getOperand(0);
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default: llvm_unreachable("Unhandled icmp opcode!");
-  case ICmpInst::ICMP_EQ:
+  case Predicate::ICMP_EQ:
     if (LoOverflow && HiOverflow)
       return replaceInstUsesWith(ICI, Builder->getFalse());
     if (HiOverflow)
-      return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SGE :
-                          ICmpInst::ICMP_UGE, X, LoBound);
+      return new ICmpInst(
+          DivIsSigned ? Predicate::ICMP_SGE : Predicate::ICMP_UGE, X, LoBound);
     if (LoOverflow)
-      return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SLT :
-                          ICmpInst::ICMP_ULT, X, HiBound);
+      return new ICmpInst(
+          DivIsSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT, X, HiBound);
     return replaceInstUsesWith(ICI, InsertRangeTest(X, LoBound, HiBound,
                                                     DivIsSigned, true));
-  case ICmpInst::ICMP_NE:
+  case Predicate::ICMP_NE:
     if (LoOverflow && HiOverflow)
       return replaceInstUsesWith(ICI, Builder->getTrue());
     if (HiOverflow)
-      return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SLT :
-                          ICmpInst::ICMP_ULT, X, LoBound);
+      return new ICmpInst(
+          DivIsSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT, X, LoBound);
     if (LoOverflow)
-      return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SGE :
-                          ICmpInst::ICMP_UGE, X, HiBound);
+      return new ICmpInst(
+          DivIsSigned ? Predicate::ICMP_SGE : Predicate::ICMP_UGE, X, HiBound);
     return replaceInstUsesWith(ICI, InsertRangeTest(X, LoBound, HiBound,
                                                     DivIsSigned, false));
-  case ICmpInst::ICMP_ULT:
-  case ICmpInst::ICMP_SLT:
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_SLT:
     if (LoOverflow == +1)   // Low bound is greater than input range.
       return replaceInstUsesWith(ICI, Builder->getTrue());
     if (LoOverflow == -1)   // Low bound is less than input range.
       return replaceInstUsesWith(ICI, Builder->getFalse());
     return new ICmpInst(Pred, X, LoBound);
-  case ICmpInst::ICMP_UGT:
-  case ICmpInst::ICMP_SGT:
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_SGT:
     if (HiOverflow == +1)       // High bound greater than input range.
       return replaceInstUsesWith(ICI, Builder->getFalse());
     if (HiOverflow == -1)       // High bound less than input range.
       return replaceInstUsesWith(ICI, Builder->getTrue());
-    if (Pred == ICmpInst::ICMP_UGT)
-      return new ICmpInst(ICmpInst::ICMP_UGE, X, HiBound);
-    return new ICmpInst(ICmpInst::ICMP_SGE, X, HiBound);
+    if (Pred == Predicate::ICMP_UGT)
+      return new ICmpInst(Predicate::ICMP_UGE, X, HiBound);
+    return new ICmpInst(Predicate::ICMP_SGE, X, HiBound);
   }
 }
 
 /// Handle "icmp(([al]shr X, cst1), cst2)".
 Instruction *InstCombiner::foldICmpShrConst(ICmpInst &ICI, BinaryOperator *Shr,
                                             ConstantInt *ShAmt) {
   const APInt &CmpRHSV = cast<ConstantInt>(ICI.getOperand(1))->getValue();
 
Instruction *InstCombiner::foldICmpShrConst(ICmpInst &ICI, BinaryOperator *Shr,
   APInt Comp = CmpRHSV << ShAmtVal;
   ConstantInt *ShiftedCmpRHS = Builder->getInt(Comp);
   if (Shr->getOpcode() == Instruction::LShr)
     Comp = Comp.lshr(ShAmtVal);
   else
     Comp = Comp.ashr(ShAmtVal);
 
   if (Comp != CmpRHSV) { // Comparing against a bit that we know is zero.
-    bool IsICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE;
+    bool IsICMP_NE = ICI.getPredicate() == Predicate::ICMP_NE;
     Constant *Cst = Builder->getInt1(IsICMP_NE);
     return replaceInstUsesWith(ICI, Cst);
   }
 
   // Otherwise, check to see if the bits shifted out are known to be zero.
   // If so, we can compare against the unshifted value:
   //  (X & 4) >> 1 == 2  --> (X & 4) == 4.
   if (Shr->hasOneUse() && Shr->isExact())

 /// (icmp eq/ne A, Log2(const2/const1)) ->
 /// (icmp eq/ne A, Log2(const2) - Log2(const1)).
 Instruction *InstCombiner::foldICmpCstShrConst(ICmpInst &I, Value *Op, Value *A,
                                              ConstantInt *CI1,
                                              ConstantInt *CI2) {
   assert(I.isEquality() && "Cannot fold icmp gt/lt");
 
   auto getConstant = [&I, this](bool IsTrue) {
-    if (I.getPredicate() == I.ICMP_NE)
+    if (I.getPredicate() == Predicate::ICMP_NE)
       IsTrue = !IsTrue;
     return replaceInstUsesWith(I, ConstantInt::get(I.getType(), IsTrue));
   };
 
-  auto getICmp = [&I](CmpInst::Predicate Pred, Value *LHS, Value *RHS) {
-    if (I.getPredicate() == I.ICMP_NE)
-      Pred = CmpInst::getInversePredicate(Pred);
+  auto getICmp = [&I](Predicate Pred, Value *LHS, Value *RHS) {
+    if (I.getPredicate() == Predicate::ICMP_NE)
+      Pred = Pred.getInverse();
     return new ICmpInst(Pred, LHS, RHS);
   };
 
   const APInt &AP1 = CI1->getValue();
   const APInt &AP2 = CI2->getValue();
 
   // Don't bother doing any work for cases which InstSimplify handles.
   if (AP2 == 0)
     return nullptr;
   bool IsAShr = isa<AShrOperator>(Op);
   if (IsAShr) {
     if (AP2.isAllOnesValue())
       return nullptr;
     if (AP2.isNegative() != AP1.isNegative())
       return nullptr;
     if (AP2.sgt(AP1))
       return nullptr;
   }
 
   if (!AP1)
     // 'A' must be large enough to shift out the highest set bit.
-    return getICmp(I.ICMP_UGT, A,
+    return getICmp(Predicate::ICMP_UGT, A,
                    ConstantInt::get(A->getType(), AP2.logBase2()));
 
   if (AP1 == AP2)
-    return getICmp(I.ICMP_EQ, A, ConstantInt::getNullValue(A->getType()));
+    return getICmp(Predicate::ICMP_EQ, A,
+                   ConstantInt::getNullValue(A->getType()));
 
   int Shift;
   if (IsAShr && AP1.isNegative())
     Shift = AP1.countLeadingOnes() - AP2.countLeadingOnes();
   else
     Shift = AP1.countLeadingZeros() - AP2.countLeadingZeros();
 
   if (Shift > 0) {
     if (IsAShr && AP1 == AP2.ashr(Shift)) {
       // There are multiple solutions if we are comparing against -1 and the LHS
       // of the ashr is not a power of two.
       if (AP1.isAllOnesValue() && !AP2.isPowerOf2())
-        return getICmp(I.ICMP_UGE, A, ConstantInt::get(A->getType(), Shift));
-      return getICmp(I.ICMP_EQ, A, ConstantInt::get(A->getType(), Shift));
+        return getICmp(Predicate::ICMP_UGE, A,
+                       ConstantInt::get(A->getType(), Shift));
+      return getICmp(Predicate::ICMP_EQ, A,
+                     ConstantInt::get(A->getType(), Shift));
     } else if (AP1 == AP2.lshr(Shift)) {
-      return getICmp(I.ICMP_EQ, A, ConstantInt::get(A->getType(), Shift));
+      return getICmp(Predicate::ICMP_EQ, A,
+                     ConstantInt::get(A->getType(), Shift));
     }
   }
   // Shifting const2 will never be equal to const1.
   return getConstant(false);
 }
 
 /// Handle "(icmp eq/ne (shl const2, A), const1)" ->
 /// (icmp eq/ne A, TrailingZeros(const1) - TrailingZeros(const2)).
 Instruction *InstCombiner::foldICmpCstShlConst(ICmpInst &I, Value *Op, Value *A,
                                                ConstantInt *CI1,
                                                ConstantInt *CI2) {
   assert(I.isEquality() && "Cannot fold icmp gt/lt");
 
   auto getConstant = [&I, this](bool IsTrue) {
-    if (I.getPredicate() == I.ICMP_NE)
+    if (I.getPredicate() == Predicate::ICMP_NE)
       IsTrue = !IsTrue;
     return replaceInstUsesWith(I, ConstantInt::get(I.getType(), IsTrue));
   };
 
-  auto getICmp = [&I](CmpInst::Predicate Pred, Value *LHS, Value *RHS) {
-    if (I.getPredicate() == I.ICMP_NE)
-      Pred = CmpInst::getInversePredicate(Pred);
+  auto getICmp = [&I](Predicate Pred, Value *LHS, Value *RHS) {
+    if (I.getPredicate() == Predicate::ICMP_NE)
+      Pred = Pred.getInverse();
     return new ICmpInst(Pred, LHS, RHS);
   };
 
   const APInt &AP1 = CI1->getValue();
   const APInt &AP2 = CI2->getValue();
 
   // Don't bother doing any work for cases which InstSimplify handles.
   if (AP2 == 0)
     return nullptr;
 
   unsigned AP2TrailingZeros = AP2.countTrailingZeros();
 
   if (!AP1 && AP2TrailingZeros != 0)
-    return getICmp(I.ICMP_UGE, A,
-                   ConstantInt::get(A->getType(), AP2.getBitWidth() - AP2TrailingZeros));
+    return getICmp(
+        Predicate::ICMP_UGE, A,
 
   if (AP1 == AP2)
-    return getICmp(I.ICMP_EQ, A, ConstantInt::getNullValue(A->getType()));
+    return getICmp(Predicate::ICMP_EQ, A,
+                   ConstantInt::getNullValue(A->getType()));
 
   // Get the distance between the lowest bits that are set.
   int Shift = AP1.countTrailingZeros() - AP2TrailingZeros;
 
   if (Shift > 0 && AP2.shl(Shift) == AP1)
-    return getICmp(I.ICMP_EQ, A, ConstantInt::get(A->getType(), Shift));
+    return getICmp(Predicate::ICMP_EQ, A,
+                   ConstantInt::get(A->getType(), Shift));
 
   // Shifting const2 will never be equal to const1.
   return getConstant(false);
 }
 
 /// Handle "icmp (instr, intcst)".
 Instruction *InstCombiner::foldICmpWithConstant(ICmpInst &ICI,
                                                 Instruction *LHSI,
                                                 ConstantInt *RHS) {
   const APInt &RHSV = RHS->getValue();
 
   switch (LHSI->getOpcode()) {
   case Instruction::Trunc:
     if (RHS->isOne() && RHSV.getBitWidth() > 1) {
       // icmp slt trunc(signum(V)) 1 --> icmp slt V, 1
       Value *V = nullptr;
-      if (ICI.getPredicate() == ICmpInst::ICMP_SLT &&
+      if (ICI.getPredicate() == Predicate::ICMP_SLT &&
           match(LHSI->getOperand(0), m_Signum(m_Value(V))))
-        return new ICmpInst(ICmpInst::ICMP_SLT, V,
+        return new ICmpInst(Predicate::ICMP_SLT, V,
                             ConstantInt::get(V->getType(), 1));
     }
     if (ICI.isEquality() && LHSI->hasOneUse()) {
       // Simplify icmp eq (trunc x to i8), 42 -> icmp eq x, 42|highbits if all
       // of the high bits truncated out of x are known.
       unsigned DstBits = LHSI->getType()->getPrimitiveSizeInBits(),
              SrcBits = LHSI->getOperand(0)->getType()->getPrimitiveSizeInBits();
       APInt KnownZero(SrcBits, 0), KnownOne(SrcBits, 0);
if (ICI.isEquality() && LHSI->hasOneUse()) {
       }
     }
     break;
 
   case Instruction::Xor:         // (icmp pred (xor X, XorCst), CI)
     if (ConstantInt *XorCst = dyn_cast<ConstantInt>(LHSI->getOperand(1))) {
       // If this is a comparison that tests the signbit (X < 0) or (x > -1),
       // fold the xor.
-      if ((ICI.getPredicate() == ICmpInst::ICMP_SLT && RHSV == 0) ||
-          (ICI.getPredicate() == ICmpInst::ICMP_SGT && RHSV.isAllOnesValue())) {
+      if ((ICI.getPredicate() == Predicate::ICMP_SLT && RHSV == 0) ||
+          (ICI.getPredicate() == Predicate::ICMP_SGT &&
+           RHSV.isAllOnesValue())) {
         Value *CompareVal = LHSI->getOperand(0);
 
         // If the sign bit of the XorCst is not set, there is no change to
         // the operation, just stop using the Xor.
         if (!XorCst->isNegative()) {
           ICI.setOperand(0, CompareVal);
           Worklist.Add(LHSI);
           return &ICI;
         }
 
         // Was the old condition true if the operand is positive?
-        bool isTrueIfPositive = ICI.getPredicate() == ICmpInst::ICMP_SGT;
+        bool isTrueIfPositive = ICI.getPredicate() == Predicate::ICMP_SGT;
 
         // If so, the new one isn't.
         isTrueIfPositive ^= true;
 
         if (isTrueIfPositive)
-          return new ICmpInst(ICmpInst::ICMP_SGT, CompareVal,
-                              SubOne(RHS));
+          return new ICmpInst(Predicate::ICMP_SGT, CompareVal, SubOne(RHS));
         else
-          return new ICmpInst(ICmpInst::ICMP_SLT, CompareVal,
-                              AddOne(RHS));
+          return new ICmpInst(Predicate::ICMP_SLT, CompareVal, AddOne(RHS));
       }
 
       if (LHSI->hasOneUse()) {
         // (icmp u/s (xor A SignBit), C) -> (icmp s/u A, (xor C SignBit))
         if (!ICI.isEquality() && XorCst->getValue().isSignBit()) {
           const APInt &SignBit = XorCst->getValue();
-          ICmpInst::Predicate Pred = ICI.isSigned()
-                                         ? ICI.getUnsignedPredicate()
+          Predicate Pred = ICI.isSigned() ? ICI.getUnsignedPredicate()
                                           : ICI.getSignedPredicate();
           return new ICmpInst(Pred, LHSI->getOperand(0),
                               Builder->getInt(RHSV ^ SignBit));
         }
 
         // (icmp u/s (xor A ~SignBit), C) -> (icmp s/u (xor C ~SignBit), A)
         if (!ICI.isEquality() && XorCst->isMaxValue(true)) {
           const APInt &NotSignBit = XorCst->getValue();
-          ICmpInst::Predicate Pred = ICI.isSigned()
-                                         ? ICI.getUnsignedPredicate()
+          Predicate Pred = ICI.isSigned() ? ICI.getUnsignedPredicate()
                                           : ICI.getSignedPredicate();
-          Pred = ICI.getSwappedPredicate(Pred);
+          Pred = Pred.getSwapped();
           return new ICmpInst(Pred, LHSI->getOperand(0),
                               Builder->getInt(RHSV ^ NotSignBit));
         }
       }
 
       // (icmp ugt (xor X, C), ~C) -> (icmp ult X, C)
       //   iff -C is a power of 2
-      if (ICI.getPredicate() == ICmpInst::ICMP_UGT &&
+      if (ICI.getPredicate() == Predicate::ICMP_UGT &&
           XorCst->getValue() == ~RHSV && (RHSV + 1).isPowerOf2())
-        return new ICmpInst(ICmpInst::ICMP_ULT, LHSI->getOperand(0), XorCst);
+        return new ICmpInst(Predicate::ICMP_ULT, LHSI->getOperand(0), XorCst);
 
       // (icmp ult (xor X, C), -C) -> (icmp uge X, C)
       //   iff -C is a power of 2
-      if (ICI.getPredicate() == ICmpInst::ICMP_ULT &&
+      if (ICI.getPredicate() == Predicate::ICMP_ULT &&
           XorCst->getValue() == -RHSV && RHSV.isPowerOf2())
-        return new ICmpInst(ICmpInst::ICMP_UGE, LHSI->getOperand(0), XorCst);
+        return new ICmpInst(Predicate::ICMP_UGE, LHSI->getOperand(0), XorCst);
     }
     break;
   case Instruction::And:         // (icmp pred (and X, AndCst), RHS)
     if (LHSI->hasOneUse() && isa<ConstantInt>(LHSI->getOperand(1)) &&
         LHSI->getOperand(0)->hasOneUse()) {
       ConstantInt *AndCst = cast<ConstantInt>(LHSI->getOperand(1));
 
       // If the LHS is an AND of a truncating cast, we can widen the
if (LHSI->hasOneUse() && isa<ConstantInt>(LHSI->getOperand(1)) &&
             NewCst = ConstantExpr::getShl(RHS, ShAmt);
 
           // Check to see if we are shifting out any of the bits being
           // compared.
           if (ConstantExpr::get(ShiftOpcode, NewCst, ShAmt) != RHS) {
             // If we shifted bits out, the fold is not going to work out.
             // As a special case, check to see if this means that the
             // result is always true or false now.
-            if (ICI.getPredicate() == ICmpInst::ICMP_EQ)
+            if (ICI.getPredicate() == Predicate::ICMP_EQ)
               return replaceInstUsesWith(ICI, Builder->getFalse());
-            if (ICI.getPredicate() == ICmpInst::ICMP_NE)
+            if (ICI.getPredicate() == Predicate::ICMP_NE)
               return replaceInstUsesWith(ICI, Builder->getTrue());
           } else {
             ICI.setOperand(1, NewCst);
             Constant *NewAndCst;
             if (ShiftOpcode == Instruction::Shl)
               NewAndCst = ConstantExpr::getLShr(AndCst, ShAmt);
             else
               NewAndCst = ConstantExpr::getShl(AndCst, ShAmt);
if (LHSI->hasOneUse() && isa<ConstantInt>(LHSI->getOperand(1)) &&
               }
             }
           }
         }
       }
 
       // Replace ((X & AndCst) > RHSV) with ((X & AndCst) != 0), if any
       // bit set in (X & AndCst) will produce a result greater than RHSV.
-      if (ICI.getPredicate() == ICmpInst::ICMP_UGT) {
+      if (ICI.getPredicate() == Predicate::ICMP_UGT) {
         unsigned NTZ = AndCst->getValue().countTrailingZeros();
         if ((NTZ < AndCst->getBitWidth()) &&
             APInt::getOneBitSet(AndCst->getBitWidth(), NTZ).ugt(RHSV))
-          return new ICmpInst(ICmpInst::ICMP_NE, LHSI,
+          return new ICmpInst(Predicate::ICMP_NE, LHSI,
                               Constant::getNullValue(RHS->getType()));
       }
     }
 
     // Try to optimize things like "A[i]&42 == 0" to index computations.
     if (LoadInst *LI = dyn_cast<LoadInst>(LHSI->getOperand(0))) {
       if (GetElementPtrInst *GEP =
           dyn_cast<GetElementPtrInst>(LI->getOperand(0)))
         if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0)))
           if (GV->isConstant() && GV->hasDefinitiveInitializer() &&
               !LI->isVolatile() && isa<ConstantInt>(LHSI->getOperand(1))) {
             ConstantInt *C = cast<ConstantInt>(LHSI->getOperand(1));
             if (Instruction *Res = foldCmpLoadFromIndexedGlobal(GEP, GV,ICI, C))
               return Res;
           }
     }
 
     // X & -C == -C -> X >  u ~C
     // X & -C != -C -> X <= u ~C
     //   iff C is a power of 2
     if (ICI.isEquality() && RHS == LHSI->getOperand(1) && (-RHSV).isPowerOf2())
-      return new ICmpInst(
-          ICI.getPredicate() == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_UGT
-                                                  : ICmpInst::ICMP_ULE,
+      return new ICmpInst(ICI.getPredicate() == Predicate::ICMP_EQ
+                              ? Predicate::ICMP_UGT
+                              : Predicate::ICMP_ULE,
                           LHSI->getOperand(0), SubOne(RHS));
 
     // (icmp eq (and %A, C), 0) -> (icmp sgt (trunc %A), -1)
     //   iff C is a power of 2
     if (ICI.isEquality() && LHSI->hasOneUse() && match(RHS, m_Zero())) {
       if (auto *CI = dyn_cast<ConstantInt>(LHSI->getOperand(1))) {
         const APInt &AI = CI->getValue();
         int32_t ExactLogBase2 = AI.exactLogBase2();
         if (ExactLogBase2 != -1 && DL.isLegalInteger(ExactLogBase2 + 1)) {
           Type *NTy = IntegerType::get(ICI.getContext(), ExactLogBase2 + 1);
           Value *Trunc = Builder->CreateTrunc(LHSI->getOperand(0), NTy);
-          return new ICmpInst(ICI.getPredicate() == ICmpInst::ICMP_EQ
-                                  ? ICmpInst::ICMP_SGE
-                                  : ICmpInst::ICMP_SLT,
+          return new ICmpInst(ICI.getPredicate() == Predicate::ICMP_EQ
+                                  ? Predicate::ICMP_SGE
+                                  : Predicate::ICMP_SLT,
                               Trunc, Constant::getNullValue(NTy));
         }
       }
     }
     break;
 
   case Instruction::Or: {
     if (RHS->isOne()) {
       // icmp slt signum(V) 1 --> icmp slt V, 1
       Value *V = nullptr;
-      if (ICI.getPredicate() == ICmpInst::ICMP_SLT &&
+      if (ICI.getPredicate() == Predicate::ICMP_SLT &&
           match(LHSI, m_Signum(m_Value(V))))
-        return new ICmpInst(ICmpInst::ICMP_SLT, V,
+        return new ICmpInst(Predicate::ICMP_SLT, V,
                             ConstantInt::get(V->getType(), 1));
     }
 
     if (!ICI.isEquality() || !RHS->isNullValue() || !LHSI->hasOneUse())
       break;
     Value *P, *Q;
     if (match(LHSI, m_Or(m_PtrToInt(m_Value(P)), m_PtrToInt(m_Value(Q))))) {
       // Simplify icmp eq (or (ptrtoint P), (ptrtoint Q)), 0
       // -> and (icmp eq P, null), (icmp eq Q, null).
       Value *ICIP = Builder->CreateICmp(ICI.getPredicate(), P,
                                         Constant::getNullValue(P->getType()));
       Value *ICIQ = Builder->CreateICmp(ICI.getPredicate(), Q,
                                         Constant::getNullValue(Q->getType()));
       Instruction *Op;
-      if (ICI.getPredicate() == ICmpInst::ICMP_EQ)
+      if (ICI.getPredicate() == Predicate::ICMP_EQ)
         Op = BinaryOperator::CreateAnd(ICIP, ICIQ);
       else
         Op = BinaryOperator::CreateOr(ICIP, ICIQ);
       return Op;
     }
     break;
   }
 
   case Instruction::Mul: {       // (icmp pred (mul X, Val), CI)
     ConstantInt *Val = dyn_cast<ConstantInt>(LHSI->getOperand(1));
     if (!Val) break;
 
     // If this is a signed comparison to 0 and the mul is sign preserving,
     // use the mul LHS operand instead.
-    ICmpInst::Predicate pred = ICI.getPredicate();
+    Predicate pred = ICI.getPredicate();
     if (isSignTest(pred, RHS) && !Val->isZero() &&
         cast<BinaryOperator>(LHSI)->hasNoSignedWrap())
-      return new ICmpInst(Val->isNegative() ?
-                          ICmpInst::getSwappedPredicate(pred) : pred,
+      return new ICmpInst(Val->isNegative() ? pred.getSwapped() : pred,
                           LHSI->getOperand(0),
                           Constant::getNullValue(RHS->getType()));
 
     break;
   }
 
   case Instruction::Shl: {       // (icmp pred (shl X, ShAmt), CI)
     uint32_t TypeBits = RHSV.getBitWidth();
     ConstantInt *ShAmt = dyn_cast<ConstantInt>(LHSI->getOperand(1));
     if (!ShAmt) {
       Value *X;
       // (1 << X) pred P2 -> X pred Log2(P2)
       if (match(LHSI, m_Shl(m_One(), m_Value(X)))) {
         bool RHSVIsPowerOf2 = RHSV.isPowerOf2();
-        ICmpInst::Predicate Pred = ICI.getPredicate();
+        Predicate Pred = ICI.getPredicate();
         if (ICI.isUnsigned()) {
           if (!RHSVIsPowerOf2) {
             // (1 << X) <  30 -> X <= 4
             // (1 << X) <= 30 -> X <= 4
             // (1 << X) >= 30 -> X >  4
             // (1 << X) >  30 -> X >  4
-            if (Pred == ICmpInst::ICMP_ULT)
-              Pred = ICmpInst::ICMP_ULE;
-            else if (Pred == ICmpInst::ICMP_UGE)
-              Pred = ICmpInst::ICMP_UGT;
+            if (Pred == Predicate::ICMP_ULT)
+              Pred = Predicate::ICMP_ULE;
+            else if (Pred == Predicate::ICMP_UGE)
+              Pred = Predicate::ICMP_UGT;
           }
           unsigned RHSLog2 = RHSV.logBase2();
 
           // (1 << X) >= 2147483648 -> X >= 31 -> X == 31
           // (1 << X) <  2147483648 -> X <  31 -> X != 31
           if (RHSLog2 == TypeBits-1) {
-            if (Pred == ICmpInst::ICMP_UGE)
-              Pred = ICmpInst::ICMP_EQ;
-            else if (Pred == ICmpInst::ICMP_ULT)
-              Pred = ICmpInst::ICMP_NE;
+            if (Pred == Predicate::ICMP_UGE)
+              Pred = Predicate::ICMP_EQ;
+            else if (Pred == Predicate::ICMP_ULT)
+              Pred = Predicate::ICMP_NE;
           }
 
           return new ICmpInst(Pred, X,
                               ConstantInt::get(RHS->getType(), RHSLog2));
         } else if (ICI.isSigned()) {
           if (RHSV.isAllOnesValue()) {
             // (1 << X) <= -1 -> X == 31
-            if (Pred == ICmpInst::ICMP_SLE)
-              return new ICmpInst(ICmpInst::ICMP_EQ, X,
-                                  ConstantInt::get(RHS->getType(), TypeBits-1));
+            if (Pred == Predicate::ICMP_SLE)
+              return new ICmpInst(
+                  Predicate::ICMP_EQ, X,
+                  ConstantInt::get(RHS->getType(), TypeBits - 1));
 
             // (1 << X) >  -1 -> X != 31
-            if (Pred == ICmpInst::ICMP_SGT)
-              return new ICmpInst(ICmpInst::ICMP_NE, X,
-                                  ConstantInt::get(RHS->getType(), TypeBits-1));
+            if (Pred == Predicate::ICMP_SGT)
+              return new ICmpInst(
+                  Predicate::ICMP_NE, X,
+                  ConstantInt::get(RHS->getType(), TypeBits - 1));
           } else if (!RHSV) {
             // (1 << X) <  0 -> X == 31
             // (1 << X) <= 0 -> X == 31
-            if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE)
-              return new ICmpInst(ICmpInst::ICMP_EQ, X,
-                                  ConstantInt::get(RHS->getType(), TypeBits-1));
+            if (Pred == Predicate::ICMP_SLT || Pred == Predicate::ICMP_SLE)
+              return new ICmpInst(
+                  Predicate::ICMP_EQ, X,
+                  ConstantInt::get(RHS->getType(), TypeBits - 1));
 
             // (1 << X) >= 0 -> X != 31
             // (1 << X) >  0 -> X != 31
-            if (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE)
-              return new ICmpInst(ICmpInst::ICMP_NE, X,
-                                  ConstantInt::get(RHS->getType(), TypeBits-1));
+            if (Pred == Predicate::ICMP_SGT || Pred == Predicate::ICMP_SGE)
+              return new ICmpInst(
+                  Predicate::ICMP_NE, X,
+                  ConstantInt::get(RHS->getType(), TypeBits - 1));
           }
         } else if (ICI.isEquality()) {
           if (RHSVIsPowerOf2)
             return new ICmpInst(
                 Pred, X, ConstantInt::get(RHS->getType(), RHSV.logBase2()));
         }
       }
       break;
     }
 
     // Check that the shift amount is in range.  If not, don't perform
     // undefined shifts.  When the shift is visited it will be
     // simplified.
     if (ShAmt->uge(TypeBits))
       break;
 
     if (ICI.isEquality()) {
       // If we are comparing against bits always shifted out, the
       // comparison cannot succeed.
       Constant *Comp =
         ConstantExpr::getShl(ConstantExpr::getLShr(RHS, ShAmt),
                                                                  ShAmt);
       if (Comp != RHS) {// Comparing against a bit that we know is zero.
-        bool IsICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE;
+        bool IsICMP_NE = ICI.getPredicate() == Predicate::ICMP_NE;
         Constant *Cst = Builder->getInt1(IsICMP_NE);
         return replaceInstUsesWith(ICI, Cst);
       }
 
       // If the shift is NUW, then it is just shifting out zeros, no need for an
       // AND.
       if (cast<BinaryOperator>(LHSI)->hasNoUnsignedWrap())
         return new ICmpInst(ICI.getPredicate(), LHSI->getOperand(0),
if (ICI.isEquality()) {
           Builder->CreateAnd(LHSI->getOperand(0),Mask, LHSI->getName()+".mask");
         return new ICmpInst(ICI.getPredicate(), And,
                             ConstantExpr::getLShr(RHS, ShAmt));
       }
     }
 
     // If this is a signed comparison to 0 and the shift is sign preserving,
     // use the shift LHS operand instead.
-    ICmpInst::Predicate pred = ICI.getPredicate();
+    Predicate pred = ICI.getPredicate();
     if (isSignTest(pred, RHS) &&
         cast<BinaryOperator>(LHSI)->hasNoSignedWrap())
       return new ICmpInst(pred,
                           LHSI->getOperand(0),
                           Constant::getNullValue(RHS->getType()));
 
     // Otherwise, if this is a comparison of the sign bit, simplify to and/test.
     bool TrueIfSigned = false;
     if (LHSI->hasOneUse() &&
         isSignBitCheck(ICI.getPredicate(), RHS, TrueIfSigned)) {
       // (X << 31) <s 0  --> (X&1) != 0
       Constant *Mask = ConstantInt::get(LHSI->getOperand(0)->getType(),
                                         APInt::getOneBitSet(TypeBits,
                                             TypeBits-ShAmt->getZExtValue()-1));
       Value *And =
         Builder->CreateAnd(LHSI->getOperand(0), Mask, LHSI->getName()+".mask");
-      return new ICmpInst(TrueIfSigned ? ICmpInst::ICMP_NE : ICmpInst::ICMP_EQ,
+      return new ICmpInst(TrueIfSigned ? Predicate::ICMP_NE
+                                       : Predicate::ICMP_EQ,
                           And, Constant::getNullValue(And->getType()));
     }
 
     // Transform (icmp pred iM (shl iM %v, N), CI)
     // -> (icmp pred i(M-N) (trunc %v iM to i(M-N)), (trunc (CI>>N))
     // Transform the shl to a trunc if (trunc (CI>>N)) has no loss and M-N.
     // This enables to get rid of the shift in favor of a trunc which can be
     // free on the target. It has the additional benefit of comparing to a
Instruction *InstCombiner::foldICmpWithConstant(ICmpInst &ICI,
 
   case Instruction::UDiv:
     if (ConstantInt *DivLHS = dyn_cast<ConstantInt>(LHSI->getOperand(0))) {
       Value *X = LHSI->getOperand(1);
       const APInt &C1 = RHS->getValue();
       const APInt &C2 = DivLHS->getValue();
       assert(C2 != 0 && "udiv 0, X should have been simplified already.");
       // (icmp ugt (udiv C2, X), C1) -> (icmp ule X, C2/(C1+1))
-      if (ICI.getPredicate() == ICmpInst::ICMP_UGT) {
+      if (ICI.getPredicate() == Predicate::ICMP_UGT) {
         assert(!C1.isMaxValue() &&
                "icmp ugt X, UINT_MAX should have been simplified already.");
-        return new ICmpInst(ICmpInst::ICMP_ULE, X,
+        return new ICmpInst(Predicate::ICMP_ULE, X,
                             ConstantInt::get(X->getType(), C2.udiv(C1 + 1)));
       }
       // (icmp ult (udiv C2, X), C1) -> (icmp ugt X, C2/C1)
-      if (ICI.getPredicate() == ICmpInst::ICMP_ULT) {
+      if (ICI.getPredicate() == Predicate::ICMP_ULT) {
         assert(C1 != 0 && "icmp ult X, 0 should have been simplified already.");
-        return new ICmpInst(ICmpInst::ICMP_UGT, X,
+        return new ICmpInst(Predicate::ICMP_UGT, X,
                             ConstantInt::get(X->getType(), C2.udiv(C1)));
       }
     }
   // fall-through
   case Instruction::SDiv:
     // Fold: icmp pred ([us]div X, C1), C2 -> range test
     // Fold this div into the comparison, producing a range check.
     // Determine, based on the divide type, what the range is being
Instruction *InstCombiner::foldICmpWithConstant(ICmpInst &ICI,
   case Instruction::Sub: {
     ConstantInt *LHSC = dyn_cast<ConstantInt>(LHSI->getOperand(0));
     if (!LHSC) break;
     const APInt &LHSV = LHSC->getValue();
 
     // C1-X <u C2 -> (X|(C2-1)) == C1
     //   iff C1 & (C2-1) == C2-1
     //       C2 is a power of 2
-    if (ICI.getPredicate() == ICmpInst::ICMP_ULT && LHSI->hasOneUse() &&
+    if (ICI.getPredicate() == Predicate::ICMP_ULT && LHSI->hasOneUse() &&
         RHSV.isPowerOf2() && (LHSV & (RHSV - 1)) == (RHSV - 1))
-      return new ICmpInst(ICmpInst::ICMP_EQ,
+      return new ICmpInst(Predicate::ICMP_EQ,
                           Builder->CreateOr(LHSI->getOperand(1), RHSV - 1),
                           LHSC);
 
     // C1-X >u C2 -> (X|C2) != C1
     //   iff C1 & C2 == C2
     //       C2+1 is a power of 2
-    if (ICI.getPredicate() == ICmpInst::ICMP_UGT && LHSI->hasOneUse() &&
+    if (ICI.getPredicate() == Predicate::ICMP_UGT && LHSI->hasOneUse() &&
         (RHSV + 1).isPowerOf2() && (LHSV & RHSV) == RHSV)
-      return new ICmpInst(ICmpInst::ICMP_NE,
+      return new ICmpInst(Predicate::ICMP_NE,
                           Builder->CreateOr(LHSI->getOperand(1), RHSV), LHSC);
     break;
   }
 
   case Instruction::Add:
     // Fold: icmp pred (add X, C1), C2
     if (!ICI.isEquality()) {
       ConstantInt *LHSC = dyn_cast<ConstantInt>(LHSI->getOperand(1));
       if (!LHSC) break;
       const APInt &LHSV = LHSC->getValue();
 
       ConstantRange CR = ICI.makeConstantRange(ICI.getPredicate(), RHSV)
                             .subtract(LHSV);
 
       if (ICI.isSigned()) {
         if (CR.getLower().isSignBit()) {
-          return new ICmpInst(ICmpInst::ICMP_SLT, LHSI->getOperand(0),
+          return new ICmpInst(Predicate::ICMP_SLT, LHSI->getOperand(0),
                               Builder->getInt(CR.getUpper()));
         } else if (CR.getUpper().isSignBit()) {
-          return new ICmpInst(ICmpInst::ICMP_SGE, LHSI->getOperand(0),
+          return new ICmpInst(Predicate::ICMP_SGE, LHSI->getOperand(0),
                               Builder->getInt(CR.getLower()));
         }
       } else {
         if (CR.getLower().isMinValue()) {
-          return new ICmpInst(ICmpInst::ICMP_ULT, LHSI->getOperand(0),
+          return new ICmpInst(Predicate::ICMP_ULT, LHSI->getOperand(0),
                               Builder->getInt(CR.getUpper()));
         } else if (CR.getUpper().isMinValue()) {
-          return new ICmpInst(ICmpInst::ICMP_UGE, LHSI->getOperand(0),
+          return new ICmpInst(Predicate::ICMP_UGE, LHSI->getOperand(0),
                               Builder->getInt(CR.getLower()));
         }
       }
 
       // X-C1 <u C2 -> (X & -C2) == C1
       //   iff C1 & (C2-1) == 0
       //       C2 is a power of 2
-      if (ICI.getPredicate() == ICmpInst::ICMP_ULT && LHSI->hasOneUse() &&
+      if (ICI.getPredicate() == Predicate::ICMP_ULT && LHSI->hasOneUse() &&
           RHSV.isPowerOf2() && (LHSV & (RHSV - 1)) == 0)
-        return new ICmpInst(ICmpInst::ICMP_EQ,
+        return new ICmpInst(Predicate::ICMP_EQ,
                             Builder->CreateAnd(LHSI->getOperand(0), -RHSV),
                             ConstantExpr::getNeg(LHSC));
 
       // X-C1 >u C2 -> (X & ~C2) != C1
       //   iff C1 & C2 == 0
       //       C2+1 is a power of 2
-      if (ICI.getPredicate() == ICmpInst::ICMP_UGT && LHSI->hasOneUse() &&
+      if (ICI.getPredicate() == Predicate::ICMP_UGT && LHSI->hasOneUse() &&
           (RHSV + 1).isPowerOf2() && (LHSV & RHSV) == 0)
-        return new ICmpInst(ICmpInst::ICMP_NE,
+        return new ICmpInst(Predicate::ICMP_NE,
                             Builder->CreateAnd(LHSI->getOperand(0), ~RHSV),
                             ConstantExpr::getNeg(LHSC));
     }
     break;
   }
 
   return nullptr;
 }
 
 /// Simplify icmp_eq and icmp_ne instructions with binary operator LHS and
 /// integer constant RHS.
 Instruction *InstCombiner::foldICmpEqualityWithConstant(ICmpInst &ICI) {
   BinaryOperator *BO;
   const APInt *RHSV;
   // FIXME: Some of these folds could work with arbitrary constants, but this
   // match is limited to scalars and vector splat constants.
   if (!ICI.isEquality() || !match(ICI.getOperand(0), m_BinOp(BO)) ||
       !match(ICI.getOperand(1), m_APInt(RHSV)))
     return nullptr;
 
   Constant *RHS = cast<Constant>(ICI.getOperand(1));
-  bool isICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE;
+  bool isICMP_NE = ICI.getPredicate() == Predicate::ICMP_NE;
   Value *BOp0 = BO->getOperand(0), *BOp1 = BO->getOperand(1);
 
   switch (BO->getOpcode()) {
   case Instruction::SRem:
     // If we have a signed (X % (2^c)) == 0, turn it into an unsigned one.
     if (*RHSV == 0 && BO->hasOneUse()) {
       const APInt *BOC;
       if (match(BOp1, m_APInt(BOC)) && BOC->sgt(1) && BOC->isPowerOf2()) {
case Instruction::Or: {
     }
     break;
   }
   case Instruction::And: {
     const APInt *BOC;
     if (match(BOp1, m_APInt(BOC))) {
       // If we have ((X & C) == C), turn it into ((X & C) != 0).
       if (RHSV == BOC && RHSV->isPowerOf2())
-        return new ICmpInst(isICMP_NE ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE,
+        return new ICmpInst(isICMP_NE ? Predicate::ICMP_EQ : Predicate::ICMP_NE,
                             BO, Constant::getNullValue(RHS->getType()));
 
       // Don't perform the following transforms if the AND has multiple uses
       if (!BO->hasOneUse())
         break;
 
       // Replace (and X, (1 << size(X)-1) != 0) with x s< 0
       if (BOC->isSignBit()) {
         Constant *Zero = Constant::getNullValue(BOp0->getType());
-        ICmpInst::Predicate Pred =
-            isICMP_NE ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_SGE;
+        Predicate Pred = isICMP_NE ? Predicate::ICMP_SLT : Predicate::ICMP_SGE;
         return new ICmpInst(Pred, BOp0, Zero);
       }
 
       // ((X & ~7) == 0) --> X < 8
       if (*RHSV == 0 && (~(*BOC) + 1).isPowerOf2()) {
         Constant *NegBOC = ConstantExpr::getNeg(cast<Constant>(BOp1));
-        ICmpInst::Predicate Pred =
-            isICMP_NE ? ICmpInst::ICMP_UGE : ICmpInst::ICMP_ULT;
+        Predicate Pred = isICMP_NE ? Predicate::ICMP_UGE : Predicate::ICMP_ULT;
         return new ICmpInst(Pred, BOp0, NegBOC);
       }
     }
     break;
   }
   case Instruction::Mul:
     if (*RHSV == 0 && BO->hasNoSignedWrap()) {
       const APInt *BOC;
       if (match(BOp1, m_APInt(BOC)) && *BOC != 0) {
         // The trivial case (mul X, 0) is handled by InstSimplify.
         // General case : (mul X, C) != 0 iff X != 0
         //                (mul X, C) == 0 iff X == 0
         return new ICmpInst(ICI.getPredicate(), BOp0,
                             Constant::getNullValue(RHS->getType()));
       }
     }
     break;
   case Instruction::UDiv:
     if (*RHSV == 0) {
       // (icmp eq/ne (udiv A, B), 0) -> (icmp ugt/ule i32 B, A)
-      ICmpInst::Predicate Pred =
-          isICMP_NE ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_UGT;
+      Predicate Pred = isICMP_NE ? Predicate::ICMP_ULE : Predicate::ICMP_UGT;
       return new ICmpInst(Pred, BOp1, BOp0);
     }
     break;
   default:
     break;
   }
   return nullptr;
 }
Instruction *InstCombiner::foldICmpWithCastAndCast(ICmpInst &ICmp) {
   // should have been folded away previously and not enter in here.
 
   // We're performing an unsigned comp with a sign extended value.
   // This is true if the input is >= 0. [aka >s -1]
   Constant *NegOne = Constant::getAllOnesValue(SrcTy);
   Value *Result = Builder->CreateICmpSGT(LHSCIOp, NegOne, ICmp.getName());
 
   // Finally, return the value computed.
-  if (ICmp.getPredicate() == ICmpInst::ICMP_ULT)
+  if (ICmp.getPredicate() == Predicate::ICMP_ULT)
     return replaceInstUsesWith(ICmp, Result);
 
-  assert(ICmp.getPredicate() == ICmpInst::ICMP_UGT && "ICmp should be folded!");
+  assert(ICmp.getPredicate() == Predicate::ICMP_UGT &&
+         "ICmp should be folded!");
   return BinaryOperator::CreateNot(Result);
 }
 
 /// The caller has matched a pattern of the form:
 ///   I = icmp ugt (add (add A, B), CI2), CI1
 /// If this is of the form:
 ///   sum = a + b
 ///   if (sum+128 >u 255)
for (User *U : MulVal->users()) {
         }
       } else {
         // Other uses prohibit this transformation.
         return nullptr;
       }
     }
 
   // Recognize patterns
-  switch (I.getPredicate()) {
-  case ICmpInst::ICMP_EQ:
-  case ICmpInst::ICMP_NE:
+  switch (I.getPredicate().getKind()) {
+  case Predicate::ICMP_EQ:
+  case Predicate::ICMP_NE:
     // Recognize pattern:
     //   mulval = mul(zext A, zext B)
     //   cmp eq/neq mulval, zext trunc mulval
     if (ZExtInst *Zext = dyn_cast<ZExtInst>(OtherVal))
       if (Zext->hasOneUse()) {
         Value *ZextArg = Zext->getOperand(0);
         if (TruncInst *Trunc = dyn_cast<TruncInst>(ZextArg))
           if (Trunc->getType()->getPrimitiveSizeInBits() == MulWidth)
if (match(OtherVal, m_And(m_Value(ValToMask), m_ConstantInt(CI)))) {
       if (CVal.isPowerOf2()) {
         unsigned MaskWidth = CVal.logBase2();
         if (MaskWidth == MulWidth)
           break; // Recognized
       }
     }
     return nullptr;
 
-  case ICmpInst::ICMP_UGT:
+  case Predicate::ICMP_UGT:
     // Recognize pattern:
     //   mulval = mul(zext A, zext B)
     //   cmp ugt mulval, max
     if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
       APInt MaxVal = APInt::getMaxValue(MulWidth);
       MaxVal = MaxVal.zext(CI->getBitWidth());
       if (MaxVal.eq(CI->getValue()))
         break; // Recognized
     }
     return nullptr;
 
-  case ICmpInst::ICMP_UGE:
+  case Predicate::ICMP_UGE:
     // Recognize pattern:
     //   mulval = mul(zext A, zext B)
     //   cmp uge mulval, max+1
     if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
       APInt MaxVal = APInt::getOneBitSet(CI->getBitWidth(), MulWidth);
       if (MaxVal.eq(CI->getValue()))
         break; // Recognized
     }
     return nullptr;
 
-  case ICmpInst::ICMP_ULE:
+  case Predicate::ICMP_ULE:
     // Recognize pattern:
     //   mulval = mul(zext A, zext B)
     //   cmp ule mulval, max
     if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
       APInt MaxVal = APInt::getMaxValue(MulWidth);
       MaxVal = MaxVal.zext(CI->getBitWidth());
       if (MaxVal.eq(CI->getValue()))
         break; // Recognized
     }
     return nullptr;
 
-  case ICmpInst::ICMP_ULT:
+  case Predicate::ICMP_ULT:
     // Recognize pattern:
     //   mulval = mul(zext A, zext B)
     //   cmp ule mulval, max + 1
     if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
       APInt MaxVal = APInt::getOneBitSet(CI->getBitWidth(), MulWidth);
       if (MaxVal.eq(CI->getValue()))
         break; // Recognized
     }
if (MulVal->hasNUsesOrMore(2)) {
     }
   }
   if (isa<Instruction>(OtherVal))
     IC.Worklist.Add(cast<Instruction>(OtherVal));
 
   // The original icmp gets replaced with the overflow value, maybe inverted
   // depending on predicate.
   bool Inverse = false;
-  switch (I.getPredicate()) {
-  case ICmpInst::ICMP_NE:
+  switch (I.getPredicate().getKind()) {
+  case Predicate::ICMP_NE:
     break;
-  case ICmpInst::ICMP_EQ:
+  case Predicate::ICMP_EQ:
     Inverse = true;
     break;
-  case ICmpInst::ICMP_UGT:
-  case ICmpInst::ICMP_UGE:
+  case Predicate::ICMP_UGT:
+  case Predicate::ICMP_UGE:
     if (I.getOperand(0) == MulVal)
       break;
     Inverse = true;
     break;
-  case ICmpInst::ICMP_ULT:
-  case ICmpInst::ICMP_ULE:
+  case Predicate::ICMP_ULT:
+  case Predicate::ICMP_ULE:
     if (I.getOperand(1) == MulVal)
       break;
     Inverse = true;
     break;
   default:
     llvm_unreachable("Unexpected predicate");
   }
   if (Inverse) {
static APInt DemandedBitsLHSMask(ICmpInst &I,
                                  unsigned BitWidth, bool isSignCheck) {
   if (isSignCheck)
     return APInt::getSignBit(BitWidth);
 
   ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand(1));
   if (!CI) return APInt::getAllOnesValue(BitWidth);
   const APInt &RHS = CI->getValue();
 
-  switch (I.getPredicate()) {
+  switch (I.getPredicate().getKind()) {
   // For a UGT comparison, we don't care about any bits that
   // correspond to the trailing ones of the comparand.  The value of these
   // bits doesn't impact the outcome of the comparison, because any value
   // greater than the RHS must differ in a bit higher than these due to carry.
-  case ICmpInst::ICMP_UGT: {
+  case Predicate::ICMP_UGT: {
     unsigned trailingOnes = RHS.countTrailingOnes();
     APInt lowBitsSet = APInt::getLowBitsSet(BitWidth, trailingOnes);
     return ~lowBitsSet;
   }
 
   // Similarly, for a ULT comparison, we don't care about the trailing zeros.
   // Any value less than the RHS must differ in a higher bit because of carries.
-  case ICmpInst::ICMP_ULT: {
+  case Predicate::ICMP_ULT: {
     unsigned trailingZeros = RHS.countTrailingZeros();
     APInt lowBitsSet = APInt::getLowBitsSet(BitWidth, trailingZeros);
     return ~lowBitsSet;
   }
 
   default:
     return APInt::getAllOnesValue(BitWidth);
   }

 /// major restriction since a NE compare should be 'normalized' to an equal
 /// compare, which usually happens in the combiner and test case
 /// select-cmp-br.ll
 /// checks for it.
 bool InstCombiner::replacedSelectWithOperand(SelectInst *SI,
                                              const ICmpInst *Icmp,
                                              const unsigned SIOpd) {
   assert((SIOpd == 1 || SIOpd == 2) && "Invalid select operand!");
-  if (isChainSelectCmpBranch(SI) && Icmp->getPredicate() == ICmpInst::ICMP_EQ) {
+  if (isChainSelectCmpBranch(SI) &&
+      Icmp->getPredicate() == Predicate::ICMP_EQ) {
     BasicBlock *Succ = SI->getParent()->getTerminator()->getSuccessor(1);
     // The check for the unique predecessor is not the best that can be
     // done. But it protects efficiently against cases like  when SI's
     // home block has two successors, Succ and Succ1, and Succ1 predecessor
     // of Succ. Then SI can't be replaced by SIOpd because the use that gets
     // replaced can be reached on either path. So the uniqueness check
     // guarantees that the path all uses of SI (outside SI's parent) are on
     // is disjoint from all other paths out of SI. But that information
     // is more expensive to compute, and the trade-off here is in favor
     // of compile-time.
     if (Succ->getUniquePredecessor() && dominatesAllUses(SI, Icmp, Succ)) {
       NumSel++;
       SI->replaceUsesOutsideBlock(SI->getOperand(SIOpd), SI->getParent());
       return true;
     }
   }
   return false;
 }
 
 /// If we have an icmp le or icmp ge instruction with a constant operand, turn
 /// it into the appropriate icmp lt or icmp gt instruction. This transform
 /// allows them to be folded in visitICmpInst.
 static ICmpInst *canonicalizeCmpWithConstant(ICmpInst &I) {
-  ICmpInst::Predicate Pred = I.getPredicate();
-  if (Pred != ICmpInst::ICMP_SLE && Pred != ICmpInst::ICMP_SGE &&
-      Pred != ICmpInst::ICMP_ULE && Pred != ICmpInst::ICMP_UGE)
+  Predicate Pred = I.getPredicate();
+  if (!Pred.isOneOf(Predicate::ICMP_SLE, Predicate::ICMP_SGE,
+                    Predicate::ICMP_ULE, Predicate::ICMP_UGE))
     return nullptr;
 
   Value *Op0 = I.getOperand(0);
   Value *Op1 = I.getOperand(1);
   auto *Op1C = dyn_cast<Constant>(Op1);
   if (!Op1C)
     return nullptr;
 
   // Check if the constant operand can be safely incremented/decremented without
   // overflowing/underflowing. For scalars, SimplifyICmpInst has already handled
   // the edge cases for us, so we just assert on them. For vectors, we must
   // handle the edge cases.
   Type *Op1Type = Op1->getType();
   bool IsSigned = I.isSigned();
-  bool IsLE = (Pred == ICmpInst::ICMP_SLE || Pred == ICmpInst::ICMP_ULE);
+  bool IsLE = (Pred == Predicate::ICMP_SLE || Pred == Predicate::ICMP_ULE);
   auto *CI = dyn_cast<ConstantInt>(Op1C);
   if (CI) {
     // A <= MAX -> TRUE ; A >= MIN -> TRUE
     assert(IsLE ? !CI->isMaxValue(IsSigned) : !CI->isMinValue(IsSigned));
   } else if (Op1Type->isVectorTy()) {
     // TODO? If the edge cases for vectors were guaranteed to be handled as they
     // are for scalar, we could remove the min/max checks. However, to do that,
     // we would have to use insertelement/shufflevector to replace edge values.
static ICmpInst *canonicalizeCmpWithConstant(ICmpInst &I) {
   } else {
     // ConstantExpr?
     return nullptr;
   }
 
   // Increment or decrement the constant and set the new comparison predicate:
   // ULE -> ULT ; UGE -> UGT ; SLE -> SLT ; SGE -> SGT
   Constant *OneOrNegOne = ConstantInt::get(Op1Type, IsLE ? 1 : -1, true);
-  CmpInst::Predicate NewPred = IsLE ? ICmpInst::ICMP_ULT: ICmpInst::ICMP_UGT;
-  NewPred = IsSigned ? ICmpInst::getSignedPredicate(NewPred) : NewPred;
+  Predicate NewPred = IsLE ? Predicate::ICMP_ULT : Predicate::ICMP_UGT;
+  NewPred = IsSigned ? NewPred.getSigned() : NewPred;
   return new ICmpInst(NewPred, Op0, ConstantExpr::getAdd(Op1C, OneOrNegOne));
 }
 
 Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
   bool Changed = false;
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
   unsigned Op0Cplxity = getComplexity(Op0);
   unsigned Op1Cplxity = getComplexity(Op1);
Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
   }
 
   if (Value *V =
           SimplifyICmpInst(I.getPredicate(), Op0, Op1, DL, &TLI, &DT, &AC, &I))
     return replaceInstUsesWith(I, V);
 
   // comparing -val or val with non-zero is the same as just comparing val
   // ie, abs(val) != 0 -> val != 0
-  if (I.getPredicate() == ICmpInst::ICMP_NE && match(Op1, m_Zero())) {
+  if (I.getPredicate() == Predicate::ICMP_NE && match(Op1, m_Zero())) {
     Value *Cond, *SelectTrue, *SelectFalse;
     if (match(Op0, m_Select(m_Value(Cond), m_Value(SelectTrue),
                             m_Value(SelectFalse)))) {
       if (Value *V = dyn_castNegVal(SelectTrue)) {
         if (V == SelectFalse)
           return CmpInst::Create(Instruction::ICmp, I.getPredicate(), V, Op1);
       }
       else if (Value *V = dyn_castNegVal(SelectFalse)) {
         if (V == SelectTrue)
           return CmpInst::Create(Instruction::ICmp, I.getPredicate(), V, Op1);
       }
     }
   }
 
   Type *Ty = Op0->getType();
 
   // icmp's with boolean values can always be turned into bitwise operations
   if (Ty->getScalarType()->isIntegerTy(1)) {
-    switch (I.getPredicate()) {
+    switch (I.getPredicate().getKind()) {
     default: llvm_unreachable("Invalid icmp instruction!");
-    case ICmpInst::ICMP_EQ: {                // icmp eq i1 A, B -> ~(A^B)
+    case Predicate::ICMP_EQ: { // icmp eq i1 A, B -> ~(A^B)
       Value *Xor = Builder->CreateXor(Op0, Op1, I.getName() + "tmp");
       return BinaryOperator::CreateNot(Xor);
     }
-    case ICmpInst::ICMP_NE:                  // icmp ne i1 A, B -> A^B
+    case Predicate::ICMP_NE: // icmp ne i1 A, B -> A^B
       return BinaryOperator::CreateXor(Op0, Op1);
 
-    case ICmpInst::ICMP_UGT:
+    case Predicate::ICMP_UGT:
       std::swap(Op0, Op1);                   // Change icmp ugt -> icmp ult
       // FALL THROUGH
-    case ICmpInst::ICMP_ULT:{                // icmp ult i1 A, B -> ~A & B
+    case Predicate::ICMP_ULT: { // icmp ult i1 A, B -> ~A & B
       Value *Not = Builder->CreateNot(Op0, I.getName() + "tmp");
       return BinaryOperator::CreateAnd(Not, Op1);
     }
-    case ICmpInst::ICMP_SGT:
+    case Predicate::ICMP_SGT:
       std::swap(Op0, Op1);                   // Change icmp sgt -> icmp slt
       // FALL THROUGH
-    case ICmpInst::ICMP_SLT: {               // icmp slt i1 A, B -> A & ~B
+    case Predicate::ICMP_SLT: { // icmp slt i1 A, B -> A & ~B
       Value *Not = Builder->CreateNot(Op1, I.getName() + "tmp");
       return BinaryOperator::CreateAnd(Not, Op0);
     }
-    case ICmpInst::ICMP_UGE:
+    case Predicate::ICMP_UGE:
       std::swap(Op0, Op1);                   // Change icmp uge -> icmp ule
       // FALL THROUGH
-    case ICmpInst::ICMP_ULE: {               // icmp ule i1 A, B -> ~A | B
+    case Predicate::ICMP_ULE: { // icmp ule i1 A, B -> ~A | B
       Value *Not = Builder->CreateNot(Op0, I.getName() + "tmp");
       return BinaryOperator::CreateOr(Not, Op1);
     }
-    case ICmpInst::ICMP_SGE:
+    case Predicate::ICMP_SGE:
       std::swap(Op0, Op1);                   // Change icmp sge -> icmp sle
       // FALL THROUGH
-    case ICmpInst::ICMP_SLE: {               // icmp sle i1 A, B -> A | ~B
+    case Predicate::ICMP_SLE: { // icmp sle i1 A, B -> A | ~B
       Value *Not = Builder->CreateNot(Op1, I.getName() + "tmp");
       return BinaryOperator::CreateOr(Not, Op0);
     }
     }
   }
 
   if (ICmpInst *NewICmp = canonicalizeCmpWithConstant(I))
     return NewICmp;
if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
     // TODO: This could probably be generalized to handle other overflow-safe
     // operations if we worked out the formulas to compute the appropriate
     // magic constants.
     //
     // sum = a + b
     // if (sum+128 >u 255)  ...  -> llvm.sadd.with.overflow.i8
     {
     ConstantInt *CI2;    // I = icmp ugt (add (add A, B), CI2), CI
-    if (I.getPredicate() == ICmpInst::ICMP_UGT &&
+    if (I.getPredicate() == Predicate::ICMP_UGT &&
         match(Op0, m_Add(m_Add(m_Value(A), m_Value(B)), m_ConstantInt(CI2))))
       if (Instruction *Res = ProcessUGT_ADDCST_ADD(I, A, B, CI2, CI, *this))
         return Res;
     }
 
     // (icmp sgt smin(PosA, B) 0) -> (icmp sgt B 0)
-    if (CI->isZero() && I.getPredicate() == ICmpInst::ICMP_SGT)
+    if (CI->isZero() && I.getPredicate() == Predicate::ICMP_SGT)
       if (auto *SI = dyn_cast<SelectInst>(Op0)) {
         SelectPatternResult SPR = matchSelectPattern(SI, A, B);
         if (SPR.Flavor == SPF_SMIN) {
           if (isKnownPositive(A, DL))
             return new ICmpInst(I.getPredicate(), B, CI);
           if (isKnownPositive(B, DL))
             return new ICmpInst(I.getPredicate(), A, CI);
         }
       }
 
 
     // The following transforms are only 'worth it' if the only user of the
     // subtraction is the icmp.
     if (Op0->hasOneUse()) {
       // (icmp ne/eq (sub A B) 0) -> (icmp ne/eq A, B)
       if (I.isEquality() && CI->isZero() &&
           match(Op0, m_Sub(m_Value(A), m_Value(B))))
         return new ICmpInst(I.getPredicate(), A, B);
 
       // (icmp sgt (sub nsw A B), -1) -> (icmp sge A, B)
-      if (I.getPredicate() == ICmpInst::ICMP_SGT && CI->isAllOnesValue() &&
+      if (I.getPredicate() == Predicate::ICMP_SGT && CI->isAllOnesValue() &&
           match(Op0, m_NSWSub(m_Value(A), m_Value(B))))
-        return new ICmpInst(ICmpInst::ICMP_SGE, A, B);
+        return new ICmpInst(Predicate::ICMP_SGE, A, B);
 
       // (icmp sgt (sub nsw A B), 0) -> (icmp sgt A, B)
-      if (I.getPredicate() == ICmpInst::ICMP_SGT && CI->isZero() &&
+      if (I.getPredicate() == Predicate::ICMP_SGT && CI->isZero() &&
           match(Op0, m_NSWSub(m_Value(A), m_Value(B))))
-        return new ICmpInst(ICmpInst::ICMP_SGT, A, B);
+        return new ICmpInst(Predicate::ICMP_SGT, A, B);
 
       // (icmp slt (sub nsw A B), 0) -> (icmp slt A, B)
-      if (I.getPredicate() == ICmpInst::ICMP_SLT && CI->isZero() &&
+      if (I.getPredicate() == Predicate::ICMP_SLT && CI->isZero() &&
           match(Op0, m_NSWSub(m_Value(A), m_Value(B))))
-        return new ICmpInst(ICmpInst::ICMP_SLT, A, B);
+        return new ICmpInst(Predicate::ICMP_SLT, A, B);
 
       // (icmp slt (sub nsw A B), 1) -> (icmp sle A, B)
-      if (I.getPredicate() == ICmpInst::ICMP_SLT && CI->isOne() &&
+      if (I.getPredicate() == Predicate::ICMP_SLT && CI->isOne() &&
           match(Op0, m_NSWSub(m_Value(A), m_Value(B))))
-        return new ICmpInst(ICmpInst::ICMP_SLE, A, B);
+        return new ICmpInst(Predicate::ICMP_SLE, A, B);
     }
 
     if (I.isEquality()) {
       ConstantInt *CI2;
       if (match(Op0, m_AShr(m_ConstantInt(CI2), m_Value(A))) ||
           match(Op0, m_LShr(m_ConstantInt(CI2), m_Value(A)))) {
         // (icmp eq/ne (ashr/lshr const2, A), const1)
         if (Instruction *Inst = foldICmpCstShrConst(I, Op0, A, CI, CI2))
if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
     // bits, if it is a sign bit comparison, it only demands the sign bit.
     bool UnusedBit;
     isSignBit = isSignBitCheck(I.getPredicate(), CI, UnusedBit);
 
     // Canonicalize icmp instructions based on dominating conditions.
     BasicBlock *Parent = I.getParent();
     BasicBlock *Dom = Parent->getSinglePredecessor();
     auto *BI = Dom ? dyn_cast<BranchInst>(Dom->getTerminator()) : nullptr;
-    ICmpInst::Predicate Pred;
+    Predicate Pred;
     BasicBlock *TrueBB, *FalseBB;
     ConstantInt *CI2;
     if (BI && match(BI, m_Br(m_ICmp(Pred, m_Specific(Op0), m_ConstantInt(CI2)),
                              TrueBB, FalseBB)) &&
         TrueBB != FalseBB) {
       ConstantRange CR = ConstantRange::makeAllowedICmpRegion(I.getPredicate(),
                                                               CI->getValue());
       ConstantRange DominatingCR =
           (Parent == TrueBB)
               ? ConstantRange::makeExactICmpRegion(Pred, CI2->getValue())
-              : ConstantRange::makeExactICmpRegion(
-                    CmpInst::getInversePredicate(Pred), CI2->getValue());
+              : ConstantRange::makeExactICmpRegion(Pred.getInverse(),
+                                                   CI2->getValue());
       ConstantRange Intersection = DominatingCR.intersectWith(CR);
       ConstantRange Difference = DominatingCR.difference(CR);
       if (Intersection.isEmptySet())
         return replaceInstUsesWith(I, Builder->getFalse());
       if (Difference.isEmptySet())
         return replaceInstUsesWith(I, Builder->getTrue());
       // Canonicalizing a sign bit comparison that gets used in a branch,
       // pessimizes codegen by generating branch on zero instruction instead
       // of a test and branch. So we avoid canonicalizing in such situations
       // because test and branch instruction has better branch displacement
       // than compare and branch instruction.
       if (!isBranchOnSignBitCheck(I, isSignBit) && !I.isEquality()) {
         if (auto *AI = Intersection.getSingleElement())
-          return new ICmpInst(ICmpInst::ICMP_EQ, Op0, Builder->getInt(*AI));
+          return new ICmpInst(Predicate::ICMP_EQ, Op0, Builder->getInt(*AI));
         if (auto *AD = Difference.getSingleElement())
-          return new ICmpInst(ICmpInst::ICMP_NE, Op0, Builder->getInt(*AD));
+          return new ICmpInst(Predicate::ICMP_NE, Op0, Builder->getInt(*AD));
       }
     }
   }
 
   // See if we can fold the comparison based on range information we can get
   // by checking whether bits are known to be zero or one in the input.
   if (BitWidth != 0) {
     APInt Op0KnownZero(BitWidth, 0), Op0KnownOne(BitWidth, 0);
if (!isa<Constant>(Op0) && Op0Min == Op0Max)
       return new ICmpInst(I.getPredicate(),
                           ConstantInt::get(Op0->getType(), Op0Min), Op1);
     if (!isa<Constant>(Op1) && Op1Min == Op1Max)
       return new ICmpInst(I.getPredicate(), Op0,
                           ConstantInt::get(Op1->getType(), Op1Min));
 
     // Based on the range information we know about the LHS, see if we can
     // simplify this comparison.  For example, (x&4) < 8 is always true.
-    switch (I.getPredicate()) {
+    switch (I.getPredicate().getKind()) {
     default: llvm_unreachable("Unknown icmp opcode!");
-    case ICmpInst::ICMP_EQ: {
+    case Predicate::ICMP_EQ: {
       if (Op0Max.ult(Op1Min) || Op0Min.ugt(Op1Max))
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
 
       // If all bits are known zero except for one, then we know at most one
       // bit is set.   If the comparison is against zero, then this is a check
       // to see if *that* bit is set.
       APInt Op0KnownZeroInverted = ~Op0KnownZero;
       if (~Op1KnownZero == 0) {
         // If the LHS is an AND with the same constant, look through it.
         Value *LHS = nullptr;
         ConstantInt *LHSC = nullptr;
         if (!match(Op0, m_And(m_Value(LHS), m_ConstantInt(LHSC))) ||
             LHSC->getValue() != Op0KnownZeroInverted)
           LHS = Op0;
 
         // If the LHS is 1 << x, and we know the result is a power of 2 like 8,
         // then turn "((1 << x)&8) == 0" into "x != 3".
         // or turn "((1 << x)&7) == 0" into "x > 2".
         Value *X = nullptr;
         if (match(LHS, m_Shl(m_One(), m_Value(X)))) {
           APInt ValToCheck = Op0KnownZeroInverted;
           if (ValToCheck.isPowerOf2()) {
             unsigned CmpVal = ValToCheck.countTrailingZeros();
-            return new ICmpInst(ICmpInst::ICMP_NE, X,
+            return new ICmpInst(Predicate::ICMP_NE, X,
                                 ConstantInt::get(X->getType(), CmpVal));
           } else if ((++ValToCheck).isPowerOf2()) {
             unsigned CmpVal = ValToCheck.countTrailingZeros() - 1;
-            return new ICmpInst(ICmpInst::ICMP_UGT, X,
+            return new ICmpInst(Predicate::ICMP_UGT, X,
                                 ConstantInt::get(X->getType(), CmpVal));
           }
         }
 
         // If the LHS is 8 >>u x, and we know the result is a power of 2 like 1,
         // then turn "((8 >>u x)&1) == 0" into "x != 3".
         const APInt *CI;
         if (Op0KnownZeroInverted == 1 &&
             match(LHS, m_LShr(m_Power2(CI), m_Value(X))))
-          return new ICmpInst(ICmpInst::ICMP_NE, X,
-                              ConstantInt::get(X->getType(),
-                                               CI->countTrailingZeros()));
+          return new ICmpInst(
+              Predicate::ICMP_NE, X,
+              ConstantInt::get(X->getType(), CI->countTrailingZeros()));
       }
       break;
     }
-    case ICmpInst::ICMP_NE: {
+    case Predicate::ICMP_NE: {
       if (Op0Max.ult(Op1Min) || Op0Min.ugt(Op1Max))
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
 
       // If all bits are known zero except for one, then we know at most one
       // bit is set.   If the comparison is against zero, then this is a check
       // to see if *that* bit is set.
       APInt Op0KnownZeroInverted = ~Op0KnownZero;
       if (~Op1KnownZero == 0) {
         // If the LHS is an AND with the same constant, look through it.
         Value *LHS = nullptr;
         ConstantInt *LHSC = nullptr;
         if (!match(Op0, m_And(m_Value(LHS), m_ConstantInt(LHSC))) ||
             LHSC->getValue() != Op0KnownZeroInverted)
           LHS = Op0;
 
         // If the LHS is 1 << x, and we know the result is a power of 2 like 8,
         // then turn "((1 << x)&8) != 0" into "x == 3".
         // or turn "((1 << x)&7) != 0" into "x < 3".
         Value *X = nullptr;
         if (match(LHS, m_Shl(m_One(), m_Value(X)))) {
           APInt ValToCheck = Op0KnownZeroInverted;
           if (ValToCheck.isPowerOf2()) {
             unsigned CmpVal = ValToCheck.countTrailingZeros();
-            return new ICmpInst(ICmpInst::ICMP_EQ, X,
+            return new ICmpInst(Predicate::ICMP_EQ, X,
                                 ConstantInt::get(X->getType(), CmpVal));
           } else if ((++ValToCheck).isPowerOf2()) {
             unsigned CmpVal = ValToCheck.countTrailingZeros();
-            return new ICmpInst(ICmpInst::ICMP_ULT, X,
+            return new ICmpInst(Predicate::ICMP_ULT, X,
                                 ConstantInt::get(X->getType(), CmpVal));
           }
         }
 
         // If the LHS is 8 >>u x, and we know the result is a power of 2 like 1,
         // then turn "((8 >>u x)&1) != 0" into "x == 3".
         const APInt *CI;
         if (Op0KnownZeroInverted == 1 &&
             match(LHS, m_LShr(m_Power2(CI), m_Value(X))))
-          return new ICmpInst(ICmpInst::ICMP_EQ, X,
-                              ConstantInt::get(X->getType(),
-                                               CI->countTrailingZeros()));
+          return new ICmpInst(
+              Predicate::ICMP_EQ, X,
+              ConstantInt::get(X->getType(), CI->countTrailingZeros()));
       }
       break;
     }
-    case ICmpInst::ICMP_ULT:
+    case Predicate::ICMP_ULT:
       if (Op0Max.ult(Op1Min))          // A <u B -> true if max(A) < min(B)
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
       if (Op0Min.uge(Op1Max))          // A <u B -> false if min(A) >= max(B)
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
       if (Op1Min == Op0Max)            // A <u B -> A != B if max(A) == min(B)
-        return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
+        return new ICmpInst(Predicate::ICMP_NE, Op0, Op1);
       if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
         if (Op1Max == Op0Min+1)        // A <u C -> A == C-1 if min(A)+1 == C
-          return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
-                              Builder->getInt(CI->getValue()-1));
+          return new ICmpInst(Predicate::ICMP_EQ, Op0,
+                              Builder->getInt(CI->getValue() - 1));
 
         // (x <u 2147483648) -> (x >s -1)  -> true if sign bit clear
         if (CI->isMinValue(true))
-          return new ICmpInst(ICmpInst::ICMP_SGT, Op0,
+          return new ICmpInst(Predicate::ICMP_SGT, Op0,
                               Constant::getAllOnesValue(Op0->getType()));
       }
       break;
-    case ICmpInst::ICMP_UGT:
+    case Predicate::ICMP_UGT:
       if (Op0Min.ugt(Op1Max))          // A >u B -> true if min(A) > max(B)
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
       if (Op0Max.ule(Op1Min))          // A >u B -> false if max(A) <= max(B)
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
 
       if (Op1Max == Op0Min)            // A >u B -> A != B if min(A) == max(B)
-        return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
+        return new ICmpInst(Predicate::ICMP_NE, Op0, Op1);
       if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
         if (Op1Min == Op0Max-1)        // A >u C -> A == C+1 if max(a)-1 == C
-          return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
-                              Builder->getInt(CI->getValue()+1));
+          return new ICmpInst(Predicate::ICMP_EQ, Op0,
+                              Builder->getInt(CI->getValue() + 1));
 
         // (x >u 2147483647) -> (x <s 0)  -> true if sign bit set
         if (CI->isMaxValue(true))
-          return new ICmpInst(ICmpInst::ICMP_SLT, Op0,
+          return new ICmpInst(Predicate::ICMP_SLT, Op0,
                               Constant::getNullValue(Op0->getType()));
       }
       break;
-    case ICmpInst::ICMP_SLT:
+    case Predicate::ICMP_SLT:
       if (Op0Max.slt(Op1Min))          // A <s B -> true if max(A) < min(C)
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
       if (Op0Min.sge(Op1Max))          // A <s B -> false if min(A) >= max(C)
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
       if (Op1Min == Op0Max)            // A <s B -> A != B if max(A) == min(B)
-        return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
+        return new ICmpInst(Predicate::ICMP_NE, Op0, Op1);
       if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
         if (Op1Max == Op0Min+1)        // A <s C -> A == C-1 if min(A)+1 == C
-          return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
-                              Builder->getInt(CI->getValue()-1));
+          return new ICmpInst(Predicate::ICMP_EQ, Op0,
+                              Builder->getInt(CI->getValue() - 1));
       }
       break;
-    case ICmpInst::ICMP_SGT:
+    case Predicate::ICMP_SGT:
       if (Op0Min.sgt(Op1Max))          // A >s B -> true if min(A) > max(B)
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
       if (Op0Max.sle(Op1Min))          // A >s B -> false if max(A) <= min(B)
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
 
       if (Op1Max == Op0Min)            // A >s B -> A != B if min(A) == max(B)
-        return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1);
+        return new ICmpInst(Predicate::ICMP_NE, Op0, Op1);
       if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
         if (Op1Min == Op0Max-1)        // A >s C -> A == C+1 if max(A)-1 == C
-          return new ICmpInst(ICmpInst::ICMP_EQ, Op0,
-                              Builder->getInt(CI->getValue()+1));
+          return new ICmpInst(Predicate::ICMP_EQ, Op0,
+                              Builder->getInt(CI->getValue() + 1));
       }
       break;
-    case ICmpInst::ICMP_SGE:
+    case Predicate::ICMP_SGE:
       assert(!isa<ConstantInt>(Op1) && "ICMP_SGE with ConstantInt not folded!");
       if (Op0Min.sge(Op1Max))          // A >=s B -> true if min(A) >= max(B)
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
       if (Op0Max.slt(Op1Min))          // A >=s B -> false if max(A) < min(B)
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
       break;
-    case ICmpInst::ICMP_SLE:
+    case Predicate::ICMP_SLE:
       assert(!isa<ConstantInt>(Op1) && "ICMP_SLE with ConstantInt not folded!");
       if (Op0Max.sle(Op1Min))          // A <=s B -> true if max(A) <= min(B)
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
       if (Op0Min.sgt(Op1Max))          // A <=s B -> false if min(A) > max(B)
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
       break;
-    case ICmpInst::ICMP_UGE:
+    case Predicate::ICMP_UGE:
       assert(!isa<ConstantInt>(Op1) && "ICMP_UGE with ConstantInt not folded!");
       if (Op0Min.uge(Op1Max))          // A >=u B -> true if min(A) >= max(B)
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
       if (Op0Max.ult(Op1Min))          // A >=u B -> false if max(A) < min(B)
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
       break;
-    case ICmpInst::ICMP_ULE:
+    case Predicate::ICMP_ULE:
       assert(!isa<ConstantInt>(Op1) && "ICMP_ULE with ConstantInt not folded!");
       if (Op0Max.ule(Op1Min))          // A <=u B -> true if max(A) <= min(B)
         return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
       if (Op0Min.ugt(Op1Max))          // A <=u B -> false if min(A) > max(B)
         return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
       break;
     }
 
if (Instruction *LHSI = dyn_cast<Instruction>(Op0))
       }
   }
 
   // If we can optimize a 'icmp GEP, P' or 'icmp P, GEP', do so now.
   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op0))
     if (Instruction *NI = foldGEPICmp(GEP, Op1, I.getPredicate(), I))
       return NI;
   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op1))
-    if (Instruction *NI = foldGEPICmp(GEP, Op0,
-                           ICmpInst::getSwappedPredicate(I.getPredicate()), I))
+    if (Instruction *NI =
+            foldGEPICmp(GEP, Op0, I.getPredicate().getSwapped(), I))
       return NI;
 
   // Try to optimize equality comparisons against alloca-based pointers.
   if (Op0->getType()->isPointerTy() && I.isEquality()) {
     assert(Op1->getType()->isPointerTy() && "Comparing pointer with non-pointer?");
     if (auto *Alloca = dyn_cast<AllocaInst>(GetUnderlyingObject(Op0, DL)))
       if (Instruction *New = foldAllocaCmp(I, Alloca, Op1))
         return New;
if (isa<Constant>(Op1) || isa<CastInst>(Op1))
       if (Instruction *R = foldICmpWithCastAndCast(I))
         return R;
   }
 
   // Special logic for binary operators.
   BinaryOperator *BO0 = dyn_cast<BinaryOperator>(Op0);
   BinaryOperator *BO1 = dyn_cast<BinaryOperator>(Op1);
   if (BO0 || BO1) {
-    CmpInst::Predicate Pred = I.getPredicate();
+    Predicate Pred = I.getPredicate();
     bool NoOp0WrapProblem = false, NoOp1WrapProblem = false;
     if (BO0 && isa<OverflowingBinaryOperator>(BO0))
-      NoOp0WrapProblem = ICmpInst::isEquality(Pred) ||
-        (CmpInst::isUnsigned(Pred) && BO0->hasNoUnsignedWrap()) ||
-        (CmpInst::isSigned(Pred) && BO0->hasNoSignedWrap());
+      NoOp0WrapProblem = Pred.isEquality() ||
+                         (Pred.isUnsigned() && BO0->hasNoUnsignedWrap()) ||
+                         (Pred.isSigned() && BO0->hasNoSignedWrap());
     if (BO1 && isa<OverflowingBinaryOperator>(BO1))
-      NoOp1WrapProblem = ICmpInst::isEquality(Pred) ||
-        (CmpInst::isUnsigned(Pred) && BO1->hasNoUnsignedWrap()) ||
-        (CmpInst::isSigned(Pred) && BO1->hasNoSignedWrap());
+      NoOp1WrapProblem = Pred.isEquality() ||
+                         (Pred.isUnsigned() && BO1->hasNoUnsignedWrap()) ||
+                         (Pred.isSigned() && BO1->hasNoSignedWrap());
 
     // Analyze the case when either Op0 or Op1 is an add instruction.
     // Op0 = A + B (or A and B are null); Op1 = C + D (or C and D are null).
     Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr;
     if (BO0 && BO0->getOpcode() == Instruction::Add) {
       A = BO0->getOperand(0);
       B = BO0->getOperand(1);
     }
     if (BO1 && BO1->getOpcode() == Instruction::Add) {
       C = BO1->getOperand(0);
       D = BO1->getOperand(1);
     }
 
     // icmp (X+cst) < 0 --> X < -cst
-    if (NoOp0WrapProblem && ICmpInst::isSigned(Pred) && match(Op1, m_Zero()))
+    if (NoOp0WrapProblem && Pred.isSigned() && match(Op1, m_Zero()))
       if (ConstantInt *RHSC = dyn_cast_or_null<ConstantInt>(B))
         if (!RHSC->isMinValue(/*isSigned=*/true))
           return new ICmpInst(Pred, A, ConstantExpr::getNeg(RHSC));
 
     // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow.
     if ((A == Op1 || B == Op1) && NoOp0WrapProblem)
       return new ICmpInst(Pred, A == Op1 ? B : A,
                           Constant::getNullValue(Op1->getType()));
if (A && C && (A == C || A == D || B == C || B == D) &&
         // A + D == C + D  ->  A == C
         Y = A;
         Z = C;
       }
       return new ICmpInst(Pred, Y, Z);
     }
 
     // icmp slt (X + -1), Y -> icmp sle X, Y
-    if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SLT &&
+    if (A && NoOp0WrapProblem && Pred == Predicate::ICMP_SLT &&
         match(B, m_AllOnes()))
-      return new ICmpInst(CmpInst::ICMP_SLE, A, Op1);
+      return new ICmpInst(Predicate::ICMP_SLE, A, Op1);
 
     // icmp sge (X + -1), Y -> icmp sgt X, Y
-    if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SGE &&
+    if (A && NoOp0WrapProblem && Pred == Predicate::ICMP_SGE &&
         match(B, m_AllOnes()))
-      return new ICmpInst(CmpInst::ICMP_SGT, A, Op1);
+      return new ICmpInst(Predicate::ICMP_SGT, A, Op1);
 
     // icmp sle (X + 1), Y -> icmp slt X, Y
-    if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SLE &&
+    if (A && NoOp0WrapProblem && Pred == Predicate::ICMP_SLE &&
         match(B, m_One()))
-      return new ICmpInst(CmpInst::ICMP_SLT, A, Op1);
+      return new ICmpInst(Predicate::ICMP_SLT, A, Op1);
 
     // icmp sgt (X + 1), Y -> icmp sge X, Y
-    if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SGT &&
+    if (A && NoOp0WrapProblem && Pred == Predicate::ICMP_SGT &&
         match(B, m_One()))
-      return new ICmpInst(CmpInst::ICMP_SGE, A, Op1);
+      return new ICmpInst(Predicate::ICMP_SGE, A, Op1);
 
     // icmp sgt X, (Y + -1) -> icmp sge X, Y
-    if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_SGT &&
+    if (C && NoOp1WrapProblem && Pred == Predicate::ICMP_SGT &&
         match(D, m_AllOnes()))
-      return new ICmpInst(CmpInst::ICMP_SGE, Op0, C);
+      return new ICmpInst(Predicate::ICMP_SGE, Op0, C);
 
     // icmp sle X, (Y + -1) -> icmp slt X, Y
-    if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_SLE &&
+    if (C && NoOp1WrapProblem && Pred == Predicate::ICMP_SLE &&
         match(D, m_AllOnes()))
-      return new ICmpInst(CmpInst::ICMP_SLT, Op0, C);
+      return new ICmpInst(Predicate::ICMP_SLT, Op0, C);
 
     // icmp sge X, (Y + 1) -> icmp sgt X, Y
-    if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_SGE &&
+    if (C && NoOp1WrapProblem && Pred == Predicate::ICMP_SGE &&
         match(D, m_One()))
-      return new ICmpInst(CmpInst::ICMP_SGT, Op0, C);
+      return new ICmpInst(Predicate::ICMP_SGT, Op0, C);
 
     // icmp slt X, (Y + 1) -> icmp sle X, Y
-    if (C && NoOp1WrapProblem && Pred == CmpInst::ICMP_SLT &&
+    if (C && NoOp1WrapProblem && Pred == Predicate::ICMP_SLT &&
         match(D, m_One()))
-      return new ICmpInst(CmpInst::ICMP_SLE, Op0, C);
+      return new ICmpInst(Predicate::ICMP_SLE, Op0, C);
 
     // if C1 has greater magnitude than C2:
     //  icmp (X + C1), (Y + C2) -> icmp (X + C3), Y
     //  s.t. C3 = C1 - C2
     //
     // if C2 has greater magnitude than C1:
     //  icmp (X + C1), (Y + C2) -> icmp X, (Y + C3)
     //  s.t. C3 = C2 - C1
if (BO0 || BO1) {
 
     // icmp (X-Y), (X-Z) -> icmp Z, Y for equalities or if there is no overflow.
     if (A && C && A == C && NoOp0WrapProblem && NoOp1WrapProblem &&
         // Try not to increase register pressure.
         BO0->hasOneUse() && BO1->hasOneUse())
       return new ICmpInst(Pred, D, B);
 
     // icmp (0-X) < cst --> x > -cst
-    if (NoOp0WrapProblem && ICmpInst::isSigned(Pred)) {
+    if (NoOp0WrapProblem && Pred.isSigned()) {
       Value *X;
       if (match(BO0, m_Neg(m_Value(X))))
         if (ConstantInt *RHSC = dyn_cast<ConstantInt>(Op1))
           if (!RHSC->isMinValue(/*isSigned=*/true))
             return new ICmpInst(I.getSwappedPredicate(), X,
                                 ConstantExpr::getNeg(RHSC));
     }
 
     BinaryOperator *SRem = nullptr;
     // icmp (srem X, Y), Y
     if (BO0 && BO0->getOpcode() == Instruction::SRem &&
         Op1 == BO0->getOperand(1))
       SRem = BO0;
     // icmp Y, (srem X, Y)
     else if (BO1 && BO1->getOpcode() == Instruction::SRem &&
              Op0 == BO1->getOperand(1))
       SRem = BO1;
     if (SRem) {
       // We don't check hasOneUse to avoid increasing register pressure because
       // the value we use is the same value this instruction was already using.
-      switch (SRem == BO0 ? ICmpInst::getSwappedPredicate(Pred) : Pred) {
-        default: break;
-        case ICmpInst::ICMP_EQ:
-          return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
-        case ICmpInst::ICMP_NE:
-          return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
-        case ICmpInst::ICMP_SGT:
-        case ICmpInst::ICMP_SGE:
-          return new ICmpInst(ICmpInst::ICMP_SGT, SRem->getOperand(1),
-                              Constant::getAllOnesValue(SRem->getType()));
-        case ICmpInst::ICMP_SLT:
-        case ICmpInst::ICMP_SLE:
-          return new ICmpInst(ICmpInst::ICMP_SLT, SRem->getOperand(1),
-                              Constant::getNullValue(SRem->getType()));
+      switch ((SRem == BO0 ? Pred.getSwapped() : Pred).getKind()) {
+      default:
+        break;
+      case Predicate::ICMP_EQ:
+      case Predicate::ICMP_NE:
+      case Predicate::ICMP_SGT:
+      case Predicate::ICMP_SGE:
+        return new ICmpInst(Predicate::ICMP_SGT, SRem->getOperand(1),
+      case Predicate::ICMP_SLT:
+      case Predicate::ICMP_SLE:
+        return new ICmpInst(Predicate::ICMP_SLT, SRem->getOperand(1),
       }
     }
 
     if (BO0 && BO1 && BO0->getOpcode() == BO1->getOpcode() &&
         BO0->hasOneUse() && BO1->hasOneUse() &&
         BO0->getOperand(1) == BO1->getOperand(1)) {
       switch (BO0->getOpcode()) {
       default: break;
       case Instruction::Add:
       case Instruction::Sub:
       case Instruction::Xor:
         if (I.isEquality())    // a+x icmp eq/ne b+x --> a icmp b
           return new ICmpInst(I.getPredicate(), BO0->getOperand(0),
                               BO1->getOperand(0));
         // icmp u/s (a ^ signbit), (b ^ signbit) --> icmp s/u a, b
         if (ConstantInt *CI = dyn_cast<ConstantInt>(BO0->getOperand(1))) {
           if (CI->getValue().isSignBit()) {
-            ICmpInst::Predicate Pred = I.isSigned()
-                                           ? I.getUnsignedPredicate()
-                                           : I.getSignedPredicate();
+            Predicate Pred = I.isSigned() ? I.getUnsignedPredicate()
             return new ICmpInst(Pred, BO0->getOperand(0),
                                 BO1->getOperand(0));
           }
 
           if (BO0->getOpcode() == Instruction::Xor && CI->isMaxValue(true)) {
-            ICmpInst::Predicate Pred = I.isSigned()
-                                           ? I.getUnsignedPredicate()
-                                           : I.getSignedPredicate();
-            Pred = I.getSwappedPredicate(Pred);
+            Predicate Pred = I.isSigned() ? I.getUnsignedPredicate()
+            Pred = Pred.getSwapped();
             return new ICmpInst(Pred, BO0->getOperand(0),
                                 BO1->getOperand(0));
           }
         }
         break;
       case Instruction::Mul:
         if (!I.isEquality())
           break;
if (BO0 || BO1) {
     }
 
     if (BO0) {
       // Transform  A & (L - 1) `ult` L --> L != 0
       auto LSubOne = m_Add(m_Specific(Op1), m_AllOnes());
       auto BitwiseAnd =
           m_CombineOr(m_And(m_Value(), LSubOne), m_And(LSubOne, m_Value()));
 
-      if (match(BO0, BitwiseAnd) && I.getPredicate() == ICmpInst::ICMP_ULT) {
+      if (match(BO0, BitwiseAnd) && I.getPredicate() == Predicate::ICMP_ULT) {
         auto *Zero = Constant::getNullValue(BO0->getType());
-        return new ICmpInst(ICmpInst::ICMP_NE, Op1, Zero);
+        return new ICmpInst(Predicate::ICMP_NE, Op1, Zero);
       }
     }
   }
 
   { Value *A, *B;
     // Transform (A & ~B) == 0 --> (A & B) != 0
     // and       (A & ~B) != 0 --> (A & B) == 0
     // if A is a power of 2.
if (I.isEquality()) {
     // For lshr and ashr pairs.
     if ((match(Op0, m_OneUse(m_LShr(m_Value(A), m_ConstantInt(Cst1)))) &&
          match(Op1, m_OneUse(m_LShr(m_Value(B), m_Specific(Cst1))))) ||
         (match(Op0, m_OneUse(m_AShr(m_Value(A), m_ConstantInt(Cst1)))) &&
          match(Op1, m_OneUse(m_AShr(m_Value(B), m_Specific(Cst1)))))) {
       unsigned TypeBits = Cst1->getBitWidth();
       unsigned ShAmt = (unsigned)Cst1->getLimitedValue(TypeBits);
       if (ShAmt < TypeBits && ShAmt != 0) {
-        ICmpInst::Predicate Pred = I.getPredicate() == ICmpInst::ICMP_NE
-                                       ? ICmpInst::ICMP_UGE
-                                       : ICmpInst::ICMP_ULT;
+        Predicate Pred = I.getPredicate() == Predicate::ICMP_NE
+                             ? Predicate::ICMP_UGE
+                             : Predicate::ICMP_ULT;
         Value *Xor = Builder->CreateXor(A, B, I.getName() + ".unshifted");
         APInt CmpVal = APInt::getOneBitSet(TypeBits, ShAmt);
         return new ICmpInst(Pred, Xor, Builder->getInt(CmpVal));
       }
     }
 
     // (A << C) == (B << C) --> ((A^B) & (~0U >> C)) == 0
     if (match(Op0, m_OneUse(m_Shl(m_Value(A), m_ConstantInt(Cst1)))) &&

   // an i1 which indicates whether or not we successfully did the swap.
   //
   // Replace comparisons between the old value and the expected value with the
   // indicator that 'cmpxchg' returns.
   //
   // N.B.  This transform is only valid when the 'cmpxchg' is not permitted to
   // spuriously fail.  In those cases, the old value may equal the expected
   // value but it is possible for the swap to not occur.
-  if (I.getPredicate() == ICmpInst::ICMP_EQ)
+  if (I.getPredicate() == Predicate::ICMP_EQ)
     if (auto *EVI = dyn_cast<ExtractValueInst>(Op0))
       if (auto *ACXI = dyn_cast<AtomicCmpXchgInst>(EVI->getAggregateOperand()))
         if (EVI->getIndices()[0] == 0 && ACXI->getCompareOperand() == Op1 &&
             !ACXI->isWeak())
           return ExtractValueInst::Create(ACXI, 1);
 
   {
     Value *X; ConstantInt *Cst;
Instruction *InstCombiner::foldFCmpIntToFPConst(FCmpInst &I, Instruction *LHSI,
   int MantissaWidth = LHSI->getType()->getFPMantissaWidth();
   if (MantissaWidth == -1) return nullptr;  // Unknown.
 
   IntegerType *IntTy = cast<IntegerType>(LHSI->getOperand(0)->getType());
 
   bool LHSUnsigned = isa<UIToFPInst>(LHSI);
 
   if (I.isEquality()) {
-    FCmpInst::Predicate P = I.getPredicate();
+    Predicate P = I.getPredicate();
     bool IsExact = false;
     APSInt RHSCvt(IntTy->getBitWidth(), LHSUnsigned);
     RHS.convertToInteger(RHSCvt, APFloat::rmNearestTiesToEven, &IsExact);
 
     // If the floating point constant isn't an integer value, we know if we will
     // ever compare equal / not equal to it.
     if (!IsExact) {
       // TODO: Can never be -0.0 and other non-representable values
       APFloat RHSRoundInt(RHS);
       RHSRoundInt.roundToIntegral(APFloat::rmNearestTiesToEven);
       if (RHS.compare(RHSRoundInt) != APFloat::cmpEqual) {
-        if (P == FCmpInst::FCMP_OEQ || P == FCmpInst::FCMP_UEQ)
+        if (P == Predicate::FCMP_OEQ || P == Predicate::FCMP_UEQ)
           return replaceInstUsesWith(I, Builder->getFalse());
 
-        assert(P == FCmpInst::FCMP_ONE || P == FCmpInst::FCMP_UNE);
+        assert(P == Predicate::FCMP_ONE || P == Predicate::FCMP_UNE);
         return replaceInstUsesWith(I, Builder->getTrue());
       }
     }
 
     // TODO: If the constant is exactly representable, is it always OK to do
     // equality compares as integer?
   }
 
if ((int)InputSize > MantissaWidth) {
     }
   }
 
   // Otherwise, we can potentially simplify the comparison.  We know that it
   // will always come through as an integer value and we know the constant is
   // not a NAN (it would have been previously simplified).
   assert(!RHS.isNaN() && "NaN comparison not already folded!");
 
-  ICmpInst::Predicate Pred;
-  switch (I.getPredicate()) {
+  Predicate Pred;
+  switch (I.getPredicate().getKind()) {
   default: llvm_unreachable("Unexpected predicate!");
-  case FCmpInst::FCMP_UEQ:
-  case FCmpInst::FCMP_OEQ:
-    Pred = ICmpInst::ICMP_EQ;
-    break;
-  case FCmpInst::FCMP_UGT:
-  case FCmpInst::FCMP_OGT:
-    Pred = LHSUnsigned ? ICmpInst::ICMP_UGT : ICmpInst::ICMP_SGT;
-    break;
-  case FCmpInst::FCMP_UGE:
-  case FCmpInst::FCMP_OGE:
-    Pred = LHSUnsigned ? ICmpInst::ICMP_UGE : ICmpInst::ICMP_SGE;
-    break;
-  case FCmpInst::FCMP_ULT:
-  case FCmpInst::FCMP_OLT:
-    Pred = LHSUnsigned ? ICmpInst::ICMP_ULT : ICmpInst::ICMP_SLT;
-    break;
-  case FCmpInst::FCMP_ULE:
-  case FCmpInst::FCMP_OLE:
-    Pred = LHSUnsigned ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_SLE;
-    break;
-  case FCmpInst::FCMP_UNE:
-  case FCmpInst::FCMP_ONE:
-    Pred = ICmpInst::ICMP_NE;
+  case Predicate::FCMP_UEQ:
+  case Predicate::FCMP_OEQ:
+    Pred = Predicate::ICMP_EQ;
+    break;
+  case Predicate::FCMP_UGT:
+  case Predicate::FCMP_OGT:
+    Pred = LHSUnsigned ? Predicate::ICMP_UGT : Predicate::ICMP_SGT;
+    break;
+  case Predicate::FCMP_UGE:
+  case Predicate::FCMP_OGE:
+    Pred = LHSUnsigned ? Predicate::ICMP_UGE : Predicate::ICMP_SGE;
+    break;
+  case Predicate::FCMP_ULT:
+  case Predicate::FCMP_OLT:
+    Pred = LHSUnsigned ? Predicate::ICMP_ULT : Predicate::ICMP_SLT;
+    break;
+  case Predicate::FCMP_ULE:
+  case Predicate::FCMP_OLE:
+    Pred = LHSUnsigned ? Predicate::ICMP_ULE : Predicate::ICMP_SLE;
+    break;
+  case Predicate::FCMP_UNE:
+  case Predicate::FCMP_ONE:
+    Pred = Predicate::ICMP_NE;
     break;
-  case FCmpInst::FCMP_ORD:
+  case Predicate::FCMP_ORD:
     return replaceInstUsesWith(I, Builder->getTrue());
-  case FCmpInst::FCMP_UNO:
+  case Predicate::FCMP_UNO:
     return replaceInstUsesWith(I, Builder->getFalse());
   }
 
   // Now we know that the APFloat is a normal number, zero or inf.
 
   // See if the FP constant is too large for the integer.  For example,
   // comparing an i8 to 300.0.
   unsigned IntWidth = IntTy->getScalarSizeInBits();
 
   if (!LHSUnsigned) {
     // If the RHS value is > SignedMax, fold the comparison.  This handles +INF
     // and large values.
     APFloat SMax(RHS.getSemantics());
     SMax.convertFromAPInt(APInt::getSignedMaxValue(IntWidth), true,
                           APFloat::rmNearestTiesToEven);
     if (SMax.compare(RHS) == APFloat::cmpLessThan) {  // smax < 13123.0
-      if (Pred == ICmpInst::ICMP_NE  || Pred == ICmpInst::ICMP_SLT ||
-          Pred == ICmpInst::ICMP_SLE)
+      if (Pred.isOneOf(Predicate::ICMP_NE, Predicate::ICMP_SLT,
+                       Predicate::ICMP_SLE))
         return replaceInstUsesWith(I, Builder->getTrue());
       return replaceInstUsesWith(I, Builder->getFalse());
     }
   } else {
     // If the RHS value is > UnsignedMax, fold the comparison. This handles
     // +INF and large values.
     APFloat UMax(RHS.getSemantics());
     UMax.convertFromAPInt(APInt::getMaxValue(IntWidth), false,
                           APFloat::rmNearestTiesToEven);
     if (UMax.compare(RHS) == APFloat::cmpLessThan) {  // umax < 13123.0
-      if (Pred == ICmpInst::ICMP_NE  || Pred == ICmpInst::ICMP_ULT ||
-          Pred == ICmpInst::ICMP_ULE)
+      if (Pred.isOneOf(Predicate::ICMP_NE, Predicate::ICMP_ULT,
+                       Predicate::ICMP_ULE))
         return replaceInstUsesWith(I, Builder->getTrue());
       return replaceInstUsesWith(I, Builder->getFalse());
     }
   }
 
   if (!LHSUnsigned) {
     // See if the RHS value is < SignedMin.
     APFloat SMin(RHS.getSemantics());
     SMin.convertFromAPInt(APInt::getSignedMinValue(IntWidth), true,
                           APFloat::rmNearestTiesToEven);
     if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // smin > 12312.0
-      if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SGT ||
-          Pred == ICmpInst::ICMP_SGE)
+      if (Pred.isOneOf(Predicate::ICMP_NE, Predicate::ICMP_SGT,
+                       Predicate::ICMP_SGE))
         return replaceInstUsesWith(I, Builder->getTrue());
       return replaceInstUsesWith(I, Builder->getFalse());
     }
   } else {
     // See if the RHS value is < UnsignedMin.
     APFloat SMin(RHS.getSemantics());
     SMin.convertFromAPInt(APInt::getMinValue(IntWidth), true,
                           APFloat::rmNearestTiesToEven);
     if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // umin > 12312.0
-      if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_UGT ||
-          Pred == ICmpInst::ICMP_UGE)
+      if (Pred.isOneOf(Predicate::ICMP_NE, Predicate::ICMP_UGT,
+                       Predicate::ICMP_UGE))
         return replaceInstUsesWith(I, Builder->getTrue());
       return replaceInstUsesWith(I, Builder->getFalse());
     }
   }
 
   // Okay, now we know that the FP constant fits in the range [SMIN, SMAX] or
   // [0, UMAX], but it may still be fractional.  See if it is fractional by
   // casting the FP value to the integer value and back, checking for equality.
   // Don't do this for zero, because -0.0 is not fractional.
   Constant *RHSInt = LHSUnsigned
     ? ConstantExpr::getFPToUI(RHSC, IntTy)
     : ConstantExpr::getFPToSI(RHSC, IntTy);
   if (!RHS.isZero()) {
     bool Equal = LHSUnsigned
       ? ConstantExpr::getUIToFP(RHSInt, RHSC->getType()) == RHSC
       : ConstantExpr::getSIToFP(RHSInt, RHSC->getType()) == RHSC;
     if (!Equal) {
       // If we had a comparison against a fractional value, we have to adjust
       // the compare predicate and sometimes the value.  RHSC is rounded towards
       // zero at this point.
-      switch (Pred) {
+      switch (Pred.getKind()) {
       default: llvm_unreachable("Unexpected integer comparison!");
-      case ICmpInst::ICMP_NE:  // (float)int != 4.4   --> true
+      case Predicate::ICMP_NE: // (float)int != 4.4   --> true
         return replaceInstUsesWith(I, Builder->getTrue());
-      case ICmpInst::ICMP_EQ:  // (float)int == 4.4   --> false
+      case Predicate::ICMP_EQ: // (float)int == 4.4   --> false
         return replaceInstUsesWith(I, Builder->getFalse());
-      case ICmpInst::ICMP_ULE:
+      case Predicate::ICMP_ULE:
         // (float)int <= 4.4   --> int <= 4
         // (float)int <= -4.4  --> false
         if (RHS.isNegative())
           return replaceInstUsesWith(I, Builder->getFalse());
         break;
-      case ICmpInst::ICMP_SLE:
+      case Predicate::ICMP_SLE:
         // (float)int <= 4.4   --> int <= 4
         // (float)int <= -4.4  --> int < -4
         if (RHS.isNegative())
-          Pred = ICmpInst::ICMP_SLT;
+          Pred = Predicate::ICMP_SLT;
         break;
-      case ICmpInst::ICMP_ULT:
+      case Predicate::ICMP_ULT:
         // (float)int < -4.4   --> false
         // (float)int < 4.4    --> int <= 4
         if (RHS.isNegative())
           return replaceInstUsesWith(I, Builder->getFalse());
-        Pred = ICmpInst::ICMP_ULE;
+        Pred = Predicate::ICMP_ULE;
         break;
-      case ICmpInst::ICMP_SLT:
+      case Predicate::ICMP_SLT:
         // (float)int < -4.4   --> int < -4
         // (float)int < 4.4    --> int <= 4
         if (!RHS.isNegative())
-          Pred = ICmpInst::ICMP_SLE;
+          Pred = Predicate::ICMP_SLE;
         break;
-      case ICmpInst::ICMP_UGT:
+      case Predicate::ICMP_UGT:
         // (float)int > 4.4    --> int > 4
         // (float)int > -4.4   --> true
         if (RHS.isNegative())
           return replaceInstUsesWith(I, Builder->getTrue());
         break;
-      case ICmpInst::ICMP_SGT:
+      case Predicate::ICMP_SGT:
         // (float)int > 4.4    --> int > 4
         // (float)int > -4.4   --> int >= -4
         if (RHS.isNegative())
-          Pred = ICmpInst::ICMP_SGE;
+          Pred = Predicate::ICMP_SGE;
         break;
-      case ICmpInst::ICMP_UGE:
+      case Predicate::ICMP_UGE:
         // (float)int >= -4.4   --> true
         // (float)int >= 4.4    --> int > 4
         if (RHS.isNegative())
           return replaceInstUsesWith(I, Builder->getTrue());
-        Pred = ICmpInst::ICMP_UGT;
+        Pred = Predicate::ICMP_UGT;
         break;
-      case ICmpInst::ICMP_SGE:
+      case Predicate::ICMP_SGE:
         // (float)int >= -4.4   --> int >= -4
         // (float)int >= 4.4    --> int > 4
         if (!RHS.isNegative())
-          Pred = ICmpInst::ICMP_SGT;
+          Pred = Predicate::ICMP_SGT;
         break;
       }
     }
   }
 
   // Lower this FP comparison into an appropriate integer version of the
   // comparison.
   return new ICmpInst(Pred, LHSI->getOperand(0), RHSInt);
Instruction *InstCombiner::visitFCmpInst(FCmpInst &I) {
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
 
   if (Value *V = SimplifyFCmpInst(I.getPredicate(), Op0, Op1,
                                   I.getFastMathFlags(), DL, &TLI, &DT, &AC, &I))
     return replaceInstUsesWith(I, V);
 
   // Simplify 'fcmp pred X, X'
   if (Op0 == Op1) {
-    switch (I.getPredicate()) {
+    switch (I.getPredicate().getKind()) {
     default: llvm_unreachable("Unknown predicate!");
-    case FCmpInst::FCMP_UNO:    // True if unordered: isnan(X) | isnan(Y)
-    case FCmpInst::FCMP_ULT:    // True if unordered or less than
-    case FCmpInst::FCMP_UGT:    // True if unordered or greater than
-    case FCmpInst::FCMP_UNE:    // True if unordered or not equal
+    case Predicate::FCMP_UNO: // True if unordered: isnan(X) | isnan(Y)
+    case Predicate::FCMP_ULT: // True if unordered or less than
+    case Predicate::FCMP_UGT: // True if unordered or greater than
+    case Predicate::FCMP_UNE: // True if unordered or not equal
       // Canonicalize these to be 'fcmp uno %X, 0.0'.
-      I.setPredicate(FCmpInst::FCMP_UNO);
+      I.setPredicate(Predicate::FCMP_UNO);
       I.setOperand(1, Constant::getNullValue(Op0->getType()));
       return &I;
 
-    case FCmpInst::FCMP_ORD:    // True if ordered (no nans)
-    case FCmpInst::FCMP_OEQ:    // True if ordered and equal
-    case FCmpInst::FCMP_OGE:    // True if ordered and greater than or equal
-    case FCmpInst::FCMP_OLE:    // True if ordered and less than or equal
+    case Predicate::FCMP_ORD: // True if ordered (no nans)
+    case Predicate::FCMP_OEQ: // True if ordered and equal
+    case Predicate::FCMP_OGE: // True if ordered and greater than or equal
+    case Predicate::FCMP_OLE: // True if ordered and less than or equal
       // Canonicalize these to be 'fcmp ord %X, 0.0'.
-      I.setPredicate(FCmpInst::FCMP_ORD);
+      I.setPredicate(Predicate::FCMP_ORD);
       I.setOperand(1, Constant::getNullValue(Op0->getType()));
       return &I;
     }
   }
 
   // Test if the FCmpInst instruction is used exclusively by a select as
   // part of a minimum or maximum operation. If so, refrain from doing
   // any other folding. This helps out other analyses which understand
if (Instruction *LHSI = dyn_cast<Instruction>(Op0))
           break;
 
         CallInst *CI = cast<CallInst>(LHSI);
         Intrinsic::ID IID = getIntrinsicForCallSite(CI, &TLI);
         if (IID != Intrinsic::fabs)
           break;
 
         // Various optimization for fabs compared with zero.
-        switch (I.getPredicate()) {
+        switch (I.getPredicate().getKind()) {
         default:
           break;
         // fabs(x) < 0 --> false
-        case FCmpInst::FCMP_OLT:
+        case Predicate::FCMP_OLT:
           llvm_unreachable("handled by SimplifyFCmpInst");
         // fabs(x) > 0 --> x != 0
-        case FCmpInst::FCMP_OGT:
-          return new FCmpInst(FCmpInst::FCMP_ONE, CI->getArgOperand(0), RHSC);
+        case Predicate::FCMP_OGT:
+          return new FCmpInst(Predicate::FCMP_ONE, CI->getArgOperand(0), RHSC);
         // fabs(x) <= 0 --> x == 0
-        case FCmpInst::FCMP_OLE:
-          return new FCmpInst(FCmpInst::FCMP_OEQ, CI->getArgOperand(0), RHSC);
+        case Predicate::FCMP_OLE:
+          return new FCmpInst(Predicate::FCMP_OEQ, CI->getArgOperand(0), RHSC);
         // fabs(x) >= 0 --> !isnan(x)
-        case FCmpInst::FCMP_OGE:
-          return new FCmpInst(FCmpInst::FCMP_ORD, CI->getArgOperand(0), RHSC);
+        case Predicate::FCMP_OGE:
+          return new FCmpInst(Predicate::FCMP_ORD, CI->getArgOperand(0), RHSC);
         // fabs(x) == 0 --> x == 0
         // fabs(x) != 0 --> x != 0
-        case FCmpInst::FCMP_OEQ:
-        case FCmpInst::FCMP_UEQ:
-        case FCmpInst::FCMP_ONE:
-        case FCmpInst::FCMP_UNE:
+        case Predicate::FCMP_OEQ:
+        case Predicate::FCMP_UEQ:
+        case Predicate::FCMP_ONE:
+        case Predicate::FCMP_UNE:
           return new FCmpInst(I.getPredicate(), CI->getArgOperand(0), RHSC);
         }
       }
       }
   }
 
   // fcmp pred (fneg x), (fneg y) -> fcmp swap(pred) x, y
   Value *X, *Y;

lib/Transforms/InstCombine/InstCombineInternal.h

private:
   /// \brief Try to rotate an operation below a PHI node, using PHI nodes for
   /// its operands.
   Instruction *FoldPHIArgOpIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgBinOpIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgGEPIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgLoadIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgZextsIntoPHI(PHINode &PN);
 
-  Instruction *foldGEPICmp(GEPOperator *GEPLHS, Value *RHS,
-                           ICmpInst::Predicate Cond, Instruction &I);
+  Instruction *foldGEPICmp(GEPOperator *GEPLHS, Value *RHS, Predicate Cond,
+                           Instruction &I);
   Instruction *foldAllocaCmp(ICmpInst &ICI, AllocaInst *Alloca, Value *Other);
   Instruction *foldCmpLoadFromIndexedGlobal(GetElementPtrInst *GEP,
                                             GlobalVariable *GV, CmpInst &ICI,
                                             ConstantInt *AndCst = nullptr);
   Instruction *foldFCmpIntToFPConst(FCmpInst &I, Instruction *LHSI,
                                     Constant *RHSC);
   Instruction *foldICmpDivConst(ICmpInst &ICI, BinaryOperator *DivI,
                                 ConstantInt *DivRHS);
   Instruction *foldICmpShrConst(ICmpInst &ICI, BinaryOperator *DivI,
                                 ConstantInt *DivRHS);
   Instruction *foldICmpCstShrConst(ICmpInst &I, Value *Op, Value *A,
                                    ConstantInt *CI1, ConstantInt *CI2);
   Instruction *foldICmpCstShlConst(ICmpInst &I, Value *Op, Value *A,
                                    ConstantInt *CI1, ConstantInt *CI2);
   Instruction *foldICmpAddOpConst(Instruction &ICI, Value *X, ConstantInt *CI,
-                                  ICmpInst::Predicate Pred);
+                                  Predicate Pred);
   Instruction *foldICmpWithCastAndCast(ICmpInst &ICI);
   Instruction *foldICmpWithConstant(ICmpInst &ICI, Instruction *LHS,
                                     ConstantInt *RHS);
   Instruction *foldICmpEqualityWithConstant(ICmpInst &ICI);
   Instruction *foldICmpIntrinsicWithConstant(ICmpInst &ICI);
 
   Instruction *OptAndOp(Instruction *Op, ConstantInt *OpRHS,
                         ConstantInt *AndRHS, BinaryOperator &TheAnd);

lib/Transforms/InstCombine/InstCombineSelect.cpp

case SPF_UMIN:
     return SPF_UMAX;
   case SPF_SMAX:
     return SPF_SMIN;
   case SPF_UMAX:
     return SPF_UMIN;
   }
 }
 
-static CmpInst::Predicate getCmpPredicateForMinMax(SelectPatternFlavor SPF,
-                                                   bool Ordered=false) {
+static Predicate getCmpPredicateForMinMax(SelectPatternFlavor SPF,
+                                          bool Ordered = false) {
   switch (SPF) {
   default:
     llvm_unreachable("unhandled!");
 
   case SPF_SMIN:
-    return ICmpInst::ICMP_SLT;
+    return Predicate::ICMP_SLT;
   case SPF_UMIN:
-    return ICmpInst::ICMP_ULT;
+    return Predicate::ICMP_ULT;
   case SPF_SMAX:
-    return ICmpInst::ICMP_SGT;
+    return Predicate::ICMP_SGT;
   case SPF_UMAX:
-    return ICmpInst::ICMP_UGT;
+    return Predicate::ICMP_UGT;
   case SPF_FMINNUM:
-    return Ordered ? FCmpInst::FCMP_OLT : FCmpInst::FCMP_ULT;
+    return Ordered ? Predicate::FCMP_OLT : Predicate::FCMP_ULT;
   case SPF_FMAXNUM:
-    return Ordered ? FCmpInst::FCMP_OGT : FCmpInst::FCMP_UGT;
+    return Ordered ? Predicate::FCMP_OGT : Predicate::FCMP_UGT;
   }
 }
 
 static Value *generateMinMaxSelectPattern(InstCombiner::BuilderTy *Builder,
                                           SelectPatternFlavor SPF, Value *A,
                                           Value *B) {
-  CmpInst::Predicate Pred = getCmpPredicateForMinMax(SPF);
-  assert(CmpInst::isIntPredicate(Pred));
+  Predicate Pred = getCmpPredicateForMinMax(SPF);
+  assert(Pred.isInt());
   return Builder->CreateSelect(Builder->CreateICmp(Pred, A, B), A, B);
 }
 
 /// We want to turn code that looks like this:
 ///   %C = or %A, %B
 ///   %D = select %cond, %C, %A
 /// into:
 ///   %C = select %cond, %B, 0
if (C2Log > C1Log) {
     V = Builder->CreateZExtOrTrunc(V, Y->getType());
     V = Builder->CreateShl(V, C2Log - C1Log);
   } else if (C1Log > C2Log) {
     V = Builder->CreateLShr(V, C1Log - C2Log);
     V = Builder->CreateZExtOrTrunc(V, Y->getType());
   } else
     V = Builder->CreateZExtOrTrunc(V, Y->getType());
 
-  ICmpInst::Predicate Pred = IC->getPredicate();
-  if ((Pred == ICmpInst::ICMP_NE && OrOnFalseVal) ||
-      (Pred == ICmpInst::ICMP_EQ && OrOnTrueVal))
+  Predicate Pred = IC->getPredicate();
+  if ((Pred == Predicate::ICMP_NE && OrOnFalseVal) ||
+      (Pred == Predicate::ICMP_EQ && OrOnTrueVal))
     V = Builder->CreateXor(V, *C2);
 
   return Builder->CreateOr(V, Y);
 }
 
 /// Attempt to fold a cttz/ctlz followed by a icmp plus select into a single
 /// call to cttz/ctlz with flag 'is_zero_undef' cleared.
 ///
 /// For example, we can fold the following code sequence:
 /// \code
 ///   %0 = tail call i32 @llvm.cttz.i32(i32 %x, i1 true)
 ///   %1 = icmp ne i32 %x, 0
 ///   %2 = select i1 %1, i32 %0, i32 32
 /// \code
 ///
 /// into:
 ///   %0 = tail call i32 @llvm.cttz.i32(i32 %x, i1 false)
 static Value *foldSelectCttzCtlz(ICmpInst *ICI, Value *TrueVal, Value *FalseVal,
                                   InstCombiner::BuilderTy *Builder) {
-  ICmpInst::Predicate Pred = ICI->getPredicate();
+  Predicate Pred = ICI->getPredicate();
   Value *CmpLHS = ICI->getOperand(0);
   Value *CmpRHS = ICI->getOperand(1);
 
   // Check if the condition value compares a value for equality against zero.
   if (!ICI->isEquality() || !match(CmpRHS, m_Zero()))
     return nullptr;
 
   Value *Count = FalseVal;
   Value *ValueOnZero = TrueVal;
-  if (Pred == ICmpInst::ICMP_NE)
+  if (Pred == Predicate::ICMP_NE)
     std::swap(Count, ValueOnZero);
 
   // Skip zero extend/truncate.
   Value *V = nullptr;
   if (match(Count, m_ZExt(m_Value(V))) ||
       match(Count, m_Trunc(m_Value(V))))
     Count = V;
 
static Value *foldSelectCttzCtlz(ICmpInst *ICI, Value *TrueVal, Value *FalseVal,
 
   return nullptr;
 }
 
 /// Visit a SelectInst that has an ICmpInst as its first operand.
 Instruction *InstCombiner::visitSelectInstWithICmp(SelectInst &SI,
                                                    ICmpInst *ICI) {
   bool Changed = false;
-  ICmpInst::Predicate Pred = ICI->getPredicate();
+  Predicate Pred = ICI->getPredicate();
   Value *CmpLHS = ICI->getOperand(0);
   Value *CmpRHS = ICI->getOperand(1);
   Value *TrueVal = SI.getTrueValue();
   Value *FalseVal = SI.getFalseValue();
 
   // Check cases where the comparison is with a constant that
   // can be adjusted to fit the min/max idiom. We may move or edit ICI
   // here, so make sure the select is the only user.
   if (ICI->hasOneUse())
     if (ConstantInt *CI = dyn_cast<ConstantInt>(CmpRHS)) {
-      switch (Pred) {
+      switch (Pred.getKind()) {
       default: break;
-      case ICmpInst::ICMP_ULT:
-      case ICmpInst::ICMP_SLT:
-      case ICmpInst::ICMP_UGT:
-      case ICmpInst::ICMP_SGT: {
+      case Predicate::ICMP_ULT:
+      case Predicate::ICMP_SLT:
+      case Predicate::ICMP_UGT:
+      case Predicate::ICMP_SGT: {
         // These transformations only work for selects over integers.
         IntegerType *SelectTy = dyn_cast<IntegerType>(SI.getType());
         if (!SelectTy)
           break;
 
         Constant *AdjustedRHS;
-        if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_SGT)
+        if (Pred == Predicate::ICMP_UGT || Pred == Predicate::ICMP_SGT)
           AdjustedRHS = ConstantInt::get(CI->getContext(), CI->getValue() + 1);
-        else // (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_SLT)
+        else // (Pred == Predicate::ICMP_ULT || Pred == Predicate::ICMP_SLT)
           AdjustedRHS = ConstantInt::get(CI->getContext(), CI->getValue() - 1);
 
         // X > C ? X : C+1  -->  X < C+1 ? C+1 : X
         // X < C ? X : C-1  -->  X > C-1 ? C-1 : X
         if ((CmpLHS == TrueVal && AdjustedRHS == FalseVal) ||
             (CmpLHS == FalseVal && AdjustedRHS == TrueVal))
           ; // Nothing to do here. Values match without any sign/zero extension.
 
if (ConstantInt *CI = dyn_cast<ConstantInt>(CmpRHS)) {
               AdjustedRHS = zextRHS;
             } else
               break;
           } else
             break;
         } else
           break;
 
-        Pred = ICmpInst::getSwappedPredicate(Pred);
+        Pred = Pred.getSwapped();
         CmpRHS = AdjustedRHS;
         std::swap(FalseVal, TrueVal);
         ICI->setPredicate(Pred);
         ICI->setOperand(0, CmpLHS);
         ICI->setOperand(1, CmpRHS);
         SI.setOperand(1, TrueVal);
         SI.setOperand(2, FalseVal);
 
Instruction *InstCombiner::visitSelectInstWithICmp(SelectInst &SI,
   // and       (X <s  0) ? C2 : C1 --> ((X >>s 31) & (C2 - C1)) + C1
   // FIXME: Type and constness constraints could be lifted, but we have to
   //        watch code size carefully. We should consider xor instead of
   //        sub/add when we decide to do that.
   if (IntegerType *Ty = dyn_cast<IntegerType>(CmpLHS->getType())) {
     if (TrueVal->getType() == Ty) {
       if (ConstantInt *Cmp = dyn_cast<ConstantInt>(CmpRHS)) {
         ConstantInt *C1 = nullptr, *C2 = nullptr;
-        if (Pred == ICmpInst::ICMP_SGT && Cmp->isAllOnesValue()) {
+        if (Pred == Predicate::ICMP_SGT && Cmp->isAllOnesValue()) {
           C1 = dyn_cast<ConstantInt>(TrueVal);
           C2 = dyn_cast<ConstantInt>(FalseVal);
-        } else if (Pred == ICmpInst::ICMP_SLT && Cmp->isNullValue()) {
+        } else if (Pred == Predicate::ICMP_SLT && Cmp->isNullValue()) {
           C1 = dyn_cast<ConstantInt>(FalseVal);
           C2 = dyn_cast<ConstantInt>(TrueVal);
         }
         if (C1 && C2) {
           // This shift results in either -1 or 0.
           Value *AShr = Builder->CreateAShr(CmpLHS, Ty->getBitWidth()-1);
 
           // Check if we can express the operation with a single or.
           if (C2->isAllOnesValue())
             return replaceInstUsesWith(SI, Builder->CreateOr(AShr, C1));
 
           Value *And = Builder->CreateAnd(AShr, C2->getValue()-C1->getValue());
           return replaceInstUsesWith(SI, Builder->CreateAdd(And, C1));
         }
       }
     }
   }
 
   // NOTE: if we wanted to, this is where to detect integer MIN/MAX
 
   if (CmpRHS != CmpLHS && isa<Constant>(CmpRHS)) {
-    if (CmpLHS == TrueVal && Pred == ICmpInst::ICMP_EQ) {
+    if (CmpLHS == TrueVal && Pred == Predicate::ICMP_EQ) {
       // Transform (X == C) ? X : Y -> (X == C) ? C : Y
       SI.setOperand(1, CmpRHS);
       Changed = true;
-    } else if (CmpLHS == FalseVal && Pred == ICmpInst::ICMP_NE) {
+    } else if (CmpLHS == FalseVal && Pred == Predicate::ICMP_NE) {
       // Transform (X != C) ? Y : X -> (X != C) ? Y : C
       SI.setOperand(2, CmpRHS);
       Changed = true;
     }
   }
 
   // FIXME: This code is nearly duplicated in InstSimplify. Using/refactoring
   // decomposeBitTestICmp() might help.
   {
     unsigned BitWidth =
         DL.getTypeSizeInBits(TrueVal->getType()->getScalarType());
     APInt MinSignedValue = APInt::getSignBit(BitWidth);
     Value *X;
     const APInt *Y, *C;
     bool TrueWhenUnset;
     bool IsBitTest = false;
-    if (ICmpInst::isEquality(Pred) &&
-        match(CmpLHS, m_And(m_Value(X), m_Power2(Y))) &&
+    if (Pred.isEquality() && match(CmpLHS, m_And(m_Value(X), m_Power2(Y))) &&
         match(CmpRHS, m_Zero())) {
       IsBitTest = true;
-      TrueWhenUnset = Pred == ICmpInst::ICMP_EQ;
-    } else if (Pred == ICmpInst::ICMP_SLT && match(CmpRHS, m_Zero())) {
+      TrueWhenUnset = Pred == Predicate::ICMP_EQ;
+    } else if (Pred == Predicate::ICMP_SLT && match(CmpRHS, m_Zero())) {
       X = CmpLHS;
       Y = &MinSignedValue;
       IsBitTest = true;
       TrueWhenUnset = false;
-    } else if (Pred == ICmpInst::ICMP_SGT && match(CmpRHS, m_AllOnes())) {
+    } else if (Pred == Predicate::ICMP_SGT && match(CmpRHS, m_AllOnes())) {
       X = CmpLHS;
       Y = &MinSignedValue;
       IsBitTest = true;
       TrueWhenUnset = true;
     }
     if (IsBitTest) {
       Value *V = nullptr;
       // (X & Y) == 0 ? X : X ^ Y  --> X & ~Y
static Value *foldSelectICmpAnd(const SelectInst &SI, ConstantInt *TrueVal,
   if (ValZeros > AndZeros)
     V = Builder->CreateShl(V, ValZeros - AndZeros);
   else if (ValZeros < AndZeros)
     V = Builder->CreateLShr(V, AndZeros - ValZeros);
 
   // Okay, now we know that everything is set up, we just don't know whether we
   // have a icmp_ne or icmp_eq and whether the true or false val is the zero.
   bool ShouldNotVal = !TrueVal->isZero();
-  ShouldNotVal ^= IC->getPredicate() == ICmpInst::ICMP_NE;
+  ShouldNotVal ^= IC->getPredicate() == Predicate::ICMP_NE;
   if (ShouldNotVal)
     V = Builder->CreateXor(V, ValC);
 
   // Apply an offset if needed.
   if (Offset)
     V = Builder->CreateAdd(V, Offset);
   return V;
 }
if (ConstantInt *TrueValC = dyn_cast<ConstantInt>(TrueVal))
     if (ConstantInt *FalseValC = dyn_cast<ConstantInt>(FalseVal))
       if (Value *V = foldSelectICmpAnd(SI, TrueValC, FalseValC, Builder))
         return replaceInstUsesWith(SI, V);
 
   // See if we are selecting two values based on a comparison of the two values.
   if (FCmpInst *FCI = dyn_cast<FCmpInst>(CondVal)) {
     if (FCI->getOperand(0) == TrueVal && FCI->getOperand(1) == FalseVal) {
       // Transform (X == Y) ? X : Y  -> Y
-      if (FCI->getPredicate() == FCmpInst::FCMP_OEQ) {
+      if (FCI->getPredicate() == Predicate::FCMP_OEQ) {
         // This is not safe in general for floating point:
         // consider X== -0, Y== +0.
         // It becomes safe if either operand is a nonzero constant.
         ConstantFP *CFPt, *CFPf;
         if (((CFPt = dyn_cast<ConstantFP>(TrueVal)) &&
               !CFPt->getValueAPF().isZero()) ||
             ((CFPf = dyn_cast<ConstantFP>(FalseVal)) &&
              !CFPf->getValueAPF().isZero()))
         return replaceInstUsesWith(SI, FalseVal);
       }
       // Transform (X une Y) ? X : Y  -> X
-      if (FCI->getPredicate() == FCmpInst::FCMP_UNE) {
+      if (FCI->getPredicate() == Predicate::FCMP_UNE) {
         // This is not safe in general for floating point:
         // consider X== -0, Y== +0.
         // It becomes safe if either operand is a nonzero constant.
         ConstantFP *CFPt, *CFPf;
         if (((CFPt = dyn_cast<ConstantFP>(TrueVal)) &&
               !CFPt->getValueAPF().isZero()) ||
             ((CFPf = dyn_cast<ConstantFP>(FalseVal)) &&
              !CFPf->getValueAPF().isZero()))
         return replaceInstUsesWith(SI, TrueVal);
       }
 
       // Canonicalize to use ordered comparisons by swapping the select
       // operands.
       //
       // e.g.
       // (X ugt Y) ? X : Y -> (X ole Y) ? Y : X
-      if (FCI->hasOneUse() && FCmpInst::isUnordered(FCI->getPredicate())) {
-        FCmpInst::Predicate InvPred = FCI->getInversePredicate();
+      if (FCI->hasOneUse() && FCI->getPredicate().isUnordered()) {
+        Predicate InvPred = FCI->getInversePredicate();
         IRBuilder<>::FastMathFlagGuard FMFG(*Builder);
         Builder->setFastMathFlags(FCI->getFastMathFlags());
         Value *NewCond = Builder->CreateFCmp(InvPred, TrueVal, FalseVal,
                                              FCI->getName() + ".inv");
 
         return SelectInst::Create(NewCond, FalseVal, TrueVal,
                                   SI.getName() + ".p");
       }
 
       // NOTE: if we wanted to, this is where to detect MIN/MAX
     } else if (FCI->getOperand(0) == FalseVal && FCI->getOperand(1) == TrueVal){
       // Transform (X == Y) ? Y : X  -> X
-      if (FCI->getPredicate() == FCmpInst::FCMP_OEQ) {
+      if (FCI->getPredicate() == Predicate::FCMP_OEQ) {
         // This is not safe in general for floating point:
         // consider X== -0, Y== +0.
         // It becomes safe if either operand is a nonzero constant.
         ConstantFP *CFPt, *CFPf;
         if (((CFPt = dyn_cast<ConstantFP>(TrueVal)) &&
               !CFPt->getValueAPF().isZero()) ||
             ((CFPf = dyn_cast<ConstantFP>(FalseVal)) &&
              !CFPf->getValueAPF().isZero()))
           return replaceInstUsesWith(SI, FalseVal);
       }
       // Transform (X une Y) ? Y : X  -> Y
-      if (FCI->getPredicate() == FCmpInst::FCMP_UNE) {
+      if (FCI->getPredicate() == Predicate::FCMP_UNE) {
         // This is not safe in general for floating point:
         // consider X== -0, Y== +0.
         // It becomes safe if either operand is a nonzero constant.
         ConstantFP *CFPt, *CFPf;
         if (((CFPt = dyn_cast<ConstantFP>(TrueVal)) &&
               !CFPt->getValueAPF().isZero()) ||
             ((CFPf = dyn_cast<ConstantFP>(FalseVal)) &&
              !CFPf->getValueAPF().isZero()))
           return replaceInstUsesWith(SI, TrueVal);
       }
 
       // Canonicalize to use ordered comparisons by swapping the select
       // operands.
       //
       // e.g.
       // (X ugt Y) ? X : Y -> (X ole Y) ? X : Y
-      if (FCI->hasOneUse() && FCmpInst::isUnordered(FCI->getPredicate())) {
-        FCmpInst::Predicate InvPred = FCI->getInversePredicate();
+      if (FCI->hasOneUse() && FCI->getPredicate().isUnordered()) {
+        Predicate InvPred = FCI->getInversePredicate();
         IRBuilder<>::FastMathFlagGuard FMFG(*Builder);
         Builder->setFastMathFlags(FCI->getFastMathFlags());
         Value *NewCond = Builder->CreateFCmp(InvPred, FalseVal, TrueVal,
                                              FCI->getName() + ".inv");
 
         return SelectInst::Create(NewCond, FalseVal, TrueVal,
                                   SI.getName() + ".p");
       }
if (SelType->isIntOrIntVectorTy() || SelType->isFPOrFPVectorTy()) {
     Instruction::CastOps CastOp;
     SelectPatternResult SPR = matchSelectPattern(&SI, LHS, RHS, &CastOp);
     auto SPF = SPR.Flavor;
 
     if (SelectPatternResult::isMinOrMax(SPF)) {
       // Canonicalize so that type casts are outside select patterns.
       if (LHS->getType()->getPrimitiveSizeInBits() !=
           SelType->getPrimitiveSizeInBits()) {
-        CmpInst::Predicate Pred = getCmpPredicateForMinMax(SPF, SPR.Ordered);
+        Predicate Pred = getCmpPredicateForMinMax(SPF, SPR.Ordered);
 
         Value *Cmp;
-        if (CmpInst::isIntPredicate(Pred)) {
+        if (Pred.isInt()) {
           Cmp = Builder->CreateICmp(Pred, LHS, RHS);
         } else {
           IRBuilder<>::FastMathFlagGuard FMFG(*Builder);
           auto FMF = cast<FPMathOperator>(SI.getCondition())->getFastMathFlags();
           Builder->setFastMathFlags(FMF);
           Cmp = Builder->CreateFCmp(Pred, LHS, RHS);
         }
 

lib/Transforms/InstCombine/InstructionCombining.cpp

if (FreeInstrBB->size() != 2)
     return nullptr;
   BasicBlock *SuccBB;
   if (!match(FreeInstrBB->getTerminator(), m_UnconditionalBr(SuccBB)))
     return nullptr;
 
   // Validate the rest of constraint #1 by matching on the pred branch.
   TerminatorInst *TI = PredBB->getTerminator();
   BasicBlock *TrueBB, *FalseBB;
-  ICmpInst::Predicate Pred;
+  Predicate Pred;
   if (!match(TI, m_Br(m_ICmp(Pred, m_Specific(Op), m_Zero()), TrueBB, FalseBB)))
     return nullptr;
-  if (Pred != ICmpInst::ICMP_EQ && Pred != ICmpInst::ICMP_NE)
+  if (!Pred.isOneOf(Predicate::ICMP_EQ, Predicate::ICMP_NE))
     return nullptr;
 
   // Validate constraint #3: Ensure the null case just falls through.
-  if (SuccBB != (Pred == ICmpInst::ICMP_EQ ? TrueBB : FalseBB))
+  if (SuccBB != (Pred == Predicate::ICMP_EQ ? TrueBB : FalseBB))
     return nullptr;
-  assert(FreeInstrBB == (Pred == ICmpInst::ICMP_EQ ? FalseBB : TrueBB) &&
+  assert(FreeInstrBB == (Pred == Predicate::ICMP_EQ ? FalseBB : TrueBB) &&
          "Broken CFG: missing edge from predecessor to successor");
 
   FI.moveBefore(TI);
   return &FI;
 }
 
 
 Instruction *InstCombiner::visitFree(CallInst &FI) {
Instruction *InstCombiner::visitBranchInst(BranchInst &BI) {
   if (BI.isConditional() &&
       BI.getSuccessor(0) == BI.getSuccessor(1) &&
       !isa<UndefValue>(BI.getCondition())) {
     BI.setCondition(UndefValue::get(BI.getCondition()->getType()));
     return &BI;
   }
 
   // Canonicalize fcmp_one -> fcmp_oeq
-  FCmpInst::Predicate FPred; Value *Y;
+  Predicate FPred;
+  Value *Y;
   if (match(&BI, m_Br(m_FCmp(FPred, m_Value(X), m_Value(Y)),
                              TrueDest, FalseDest)) &&
       BI.getCondition()->hasOneUse())
-    if (FPred == FCmpInst::FCMP_ONE || FPred == FCmpInst::FCMP_OLE ||
-        FPred == FCmpInst::FCMP_OGE) {
+    if (FPred.isOneOf(Predicate::FCMP_ONE, Predicate::FCMP_OLE,
+                      Predicate::FCMP_OGE)) {
       FCmpInst *Cond = cast<FCmpInst>(BI.getCondition());
-      Cond->setPredicate(FCmpInst::getInversePredicate(FPred));
+      Cond->setPredicate(FPred.getInverse());
 
       // Swap Destinations and condition.
       BI.swapSuccessors();
       Worklist.Add(Cond);
       return &BI;
     }
 
   // Canonicalize icmp_ne -> icmp_eq
-  ICmpInst::Predicate IPred;
+  Predicate IPred;
   if (match(&BI, m_Br(m_ICmp(IPred, m_Value(X), m_Value(Y)),
                       TrueDest, FalseDest)) &&
       BI.getCondition()->hasOneUse())
-    if (IPred == ICmpInst::ICMP_NE  || IPred == ICmpInst::ICMP_ULE ||
-        IPred == ICmpInst::ICMP_SLE || IPred == ICmpInst::ICMP_UGE ||
-        IPred == ICmpInst::ICMP_SGE) {
+    if (IPred.isOneOf(Predicate::ICMP_NE, Predicate::ICMP_ULE,
+                      Predicate::ICMP_SLE, Predicate::ICMP_UGE,
+                      Predicate::ICMP_SGE)) {
       ICmpInst *Cond = cast<ICmpInst>(BI.getCondition());
-      Cond->setPredicate(ICmpInst::getInversePredicate(IPred));
+      Cond->setPredicate(IPred.getInverse());
       // Swap Destinations and condition.
       BI.swapSuccessors();
       Worklist.Add(Cond);
       return &BI;
     }
 
   return nullptr;
 }
if (II->hasOneUse()) {
           return BinaryOperator::CreateAdd(LHS, RHS);
         }
 
         // If the normal result of the add is dead, and the RHS is a constant,
         // we can transform this into a range comparison.
         // overflow = uadd a, -4  -->  overflow = icmp ugt a, 3
         if (II->getIntrinsicID() == Intrinsic::uadd_with_overflow)
           if (ConstantInt *CI = dyn_cast<ConstantInt>(II->getArgOperand(1)))
-            return new ICmpInst(ICmpInst::ICMP_UGT, II->getArgOperand(0),
+            return new ICmpInst(Predicate::ICMP_UGT, II->getArgOperand(0),
                                 ConstantExpr::getNot(CI));
         break;
       case Intrinsic::usub_with_overflow:
       case Intrinsic::ssub_with_overflow:
         if (*EV.idx_begin() == 0) {  // Normal result.
           Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1);
           replaceInstUsesWith(*II, UndefValue::get(II->getType()));
           eraseInstFromFunction(*II);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

#endif
 
   /// \brief Instrument signed relational comparisons.
   ///
   /// Handle sign bit tests: x<0, x>=0, x<=-1, x>-1 by propagating the highest
   /// bit of the shadow. Everything else is delegated to handleShadowOr().
   void handleSignedRelationalComparison(ICmpInst &I) {
     Constant *constOp;
     Value *op = nullptr;
-    CmpInst::Predicate pre;
+    Predicate pre;
     if ((constOp = dyn_cast<Constant>(I.getOperand(1)))) {
       op = I.getOperand(0);
       pre = I.getPredicate();
     } else if ((constOp = dyn_cast<Constant>(I.getOperand(0)))) {
       op = I.getOperand(1);
       pre = I.getSwappedPredicate();
     } else {
       handleShadowOr(I);
       return;
     }
 
     if ((constOp->isNullValue() &&
-         (pre == CmpInst::ICMP_SLT || pre == CmpInst::ICMP_SGE)) ||
+         pre.isOneOf(Predicate::ICMP_SLT, Predicate::ICMP_SGE)) ||
         (constOp->isAllOnesValue() &&
-         (pre == CmpInst::ICMP_SGT || pre == CmpInst::ICMP_SLE))) {
+         pre.isOneOf(Predicate::ICMP_SGT, Predicate::ICMP_SLE))) {
       IRBuilder<> IRB(&I);
       Value *Shadow = IRB.CreateICmpSLT(getShadow(op), getCleanShadow(op),
                                         "_msprop_icmp_s");
       setShadow(&I, Shadow);
       setOrigin(&I, getOrigin(op));
     } else {
       handleShadowOr(I);
     }

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

if (ICmpInst *ICMP = dyn_cast<ICmpInst>(I)) {
       Value *A0 = ICMP->getOperand(0);
       Value *A1 = ICMP->getOperand(1);
       if (!A0->getType()->isIntegerTy())
         continue;
       uint64_t TypeSize = DL->getTypeStoreSizeInBits(A0->getType());
       // __sanitizer_cov_trace_cmp((type_size << 32) | predicate, A0, A1);
       IRB.CreateCall(
           SanCovTraceCmpFunction,
-          {ConstantInt::get(Int64Ty, (TypeSize << 32) | ICMP->getPredicate()),
+          {ConstantInt::get(Int64Ty,
+                            (TypeSize << 32) | ICMP->getPredicate().getKind()),
            IRB.CreateIntCast(A0, Int64Ty, true),
            IRB.CreateIntCast(A1, Int64Ty, true)});
     }
   }
 }
 
 void SanitizerCoverageModule::SetNoSanitizeMetadata(Instruction *I) {
   I->setMetadata(I->getModule()->getMDKindID("nosanitize"),

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

bool AlignmentFromAssumptionsPass::extractAlignmentInfo(CallInst *I,
                                                         const SCEV *&OffSCEV) {
   // An alignment assume must be a statement about the least-significant
   // bits of the pointer being zero, possibly with some offset.
   ICmpInst *ICI = dyn_cast<ICmpInst>(I->getArgOperand(0));
   if (!ICI)
     return false;
 
   // This must be an expression of the form: x & m == 0.
-  if (ICI->getPredicate() != ICmpInst::ICMP_EQ)
+  if (ICI->getPredicate() != Predicate::ICMP_EQ)
     return false;
 
   // Swap things around so that the RHS is 0.
   Value *CmpLHS = ICI->getOperand(0);
   Value *CmpRHS = ICI->getOperand(1);
   const SCEV *CmpLHSSCEV = SE->getSCEV(CmpLHS);
   const SCEV *CmpRHSSCEV = SE->getSCEV(CmpRHS);
   if (CmpLHSSCEV->isZero())

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

if (!V) {
       // Look if the select has a constant but LVI tells us that the incoming
       // value can never be that constant. In that case replace the incoming
       // value with the other value of the select. This often allows us to
       // remove the select later.
       if (!V) {
         Constant *C = dyn_cast<Constant>(SI->getFalseValue());
         if (!C) continue;
 
-        if (LVI->getPredicateOnEdge(ICmpInst::ICMP_EQ, SI, C,
-              P->getIncomingBlock(i), BB, P) !=
-            LazyValueInfo::False)
+        if (LVI->getPredicateOnEdge(Predicate::ICMP_EQ, SI, C,
+                                    P->getIncomingBlock(i), BB,
+                                    P) != LazyValueInfo::False)
           continue;
         V = SI->getTrueValue();
       }
 
       DEBUG(dbgs() << "CVP: Threading PHI over " << *SI << '\n');
     }
 
     P->setIncomingValue(i, V);
for (SwitchInst::CaseIt CI = SI->case_end(), CE = SI->case_begin(); CI-- != CE;
        ) {
     ConstantInt *Case = CI.getCaseValue();
 
     // Check to see if the switch condition is equal to/not equal to the case
     // value on every incoming edge, equal/not equal being the same each time.
     LazyValueInfo::Tristate State = LazyValueInfo::Unknown;
     for (pred_iterator PI = PB; PI != PE; ++PI) {
       // Is the switch condition equal to the case value?
-      LazyValueInfo::Tristate Value = LVI->getPredicateOnEdge(CmpInst::ICMP_EQ,
-                                                              Cond, Case, *PI,
-                                                              BB, SI);
+      LazyValueInfo::Tristate Value =
+          LVI->getPredicateOnEdge(Predicate::ICMP_EQ, Cond, Case, *PI, BB, SI);
       // Give up on this case if nothing is known.
       if (Value == LazyValueInfo::Unknown) {
         State = LazyValueInfo::Unknown;
         break;
       }
 
       // If this was the first edge to be visited, record that all other edges
       // need to give the same result.
static bool processCallSite(CallSite CS, LazyValueInfo *LVI) {
   unsigned ArgNo = 0;
 
   for (Value *V : CS.args()) {
     PointerType *Type = dyn_cast<PointerType>(V->getType());
     // Try to mark pointer typed parameters as non-null.  We skip the
     // relatively expensive analysis for constants which are obviously either
     // null or non-null to start with.
     if (Type && !CS.paramHasAttr(ArgNo + 1, Attribute::NonNull) &&
-        !isa<Constant>(V) && 
-        LVI->getPredicateAt(ICmpInst::ICMP_EQ, V,
+        !isa<Constant>(V) &&
+        LVI->getPredicateAt(Predicate::ICMP_EQ, V,
                             ConstantPointerNull::get(Type),
                             CS.getInstruction()) == LazyValueInfo::False)
       Indices.push_back(ArgNo + 1);
     ArgNo++;
   }
 
   assert(ArgNo == CS.arg_size() && "sanity check");
 
if (I && I->getParent() == SDI->getParent())
       return true;
   }
   return false;
 }
 
 static bool hasPositiveOperands(BinaryOperator *SDI, LazyValueInfo *LVI) {
   Constant *Zero = ConstantInt::get(SDI->getType(), 0);
   for (Value *O : SDI->operands()) {
-    auto Result = LVI->getPredicateAt(ICmpInst::ICMP_SGE, O, Zero, SDI);
+    auto Result = LVI->getPredicateAt(Predicate::ICMP_SGE, O, Zero, SDI);
     if (Result != LazyValueInfo::True)
       return false;
   }
   return true;
 }
 
 static bool processSRem(BinaryOperator *SDI, LazyValueInfo *LVI) {
   if (SDI->getType()->isVectorTy() || hasLocalDefs(SDI) ||

lib/Transforms/Scalar/EarlyCSE.cpp

if (BinOp->isCommutative() && BinOp->getOperand(0) > BinOp->getOperand(1))
       std::swap(LHS, RHS);
 
     return hash_combine(BinOp->getOpcode(), LHS, RHS);
   }
 
   if (CmpInst *CI = dyn_cast<CmpInst>(Inst)) {
     Value *LHS = CI->getOperand(0);
     Value *RHS = CI->getOperand(1);
-    CmpInst::Predicate Pred = CI->getPredicate();
+    Predicate Pred = CI->getPredicate();
     if (Inst->getOperand(0) > Inst->getOperand(1)) {
       std::swap(LHS, RHS);
-      Pred = CI->getSwappedPredicate();
+      Pred = Pred.getSwapped();
     }
-    return hash_combine(Inst->getOpcode(), Pred, LHS, RHS);
+    return hash_combine(Inst->getOpcode(), Pred.getKind(), LHS, RHS);
   }
 
   if (CastInst *CI = dyn_cast<CastInst>(Inst))
     return hash_combine(CI->getOpcode(), CI->getType(), CI->getOperand(0));
 
   if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Inst))
     return hash_combine(EVI->getOpcode(), EVI->getOperand(0),
                         hash_combine_range(EVI->idx_begin(), EVI->idx_end()));

lib/Transforms/Scalar/Float2Int.cpp

namespace {
   };
 }
 
 char Float2IntLegacyPass::ID = 0;
 INITIALIZE_PASS(Float2IntLegacyPass, "float2int", "Float to int", false, false)
 
 // Given a FCmp predicate, return a matching ICmp predicate if one
 // exists, otherwise return BAD_ICMP_PREDICATE.
-static CmpInst::Predicate mapFCmpPred(CmpInst::Predicate P) {
-  switch (P) {
-  case CmpInst::FCMP_OEQ:
-  case CmpInst::FCMP_UEQ:
-    return CmpInst::ICMP_EQ;
-  case CmpInst::FCMP_OGT:
-  case CmpInst::FCMP_UGT:
-    return CmpInst::ICMP_SGT;
-  case CmpInst::FCMP_OGE:
-  case CmpInst::FCMP_UGE:
-    return CmpInst::ICMP_SGE;
-  case CmpInst::FCMP_OLT:
-  case CmpInst::FCMP_ULT:
-    return CmpInst::ICMP_SLT;
-  case CmpInst::FCMP_OLE:
-  case CmpInst::FCMP_ULE:
-    return CmpInst::ICMP_SLE;
-  case CmpInst::FCMP_ONE:
-  case CmpInst::FCMP_UNE:
-    return CmpInst::ICMP_NE;
+static Predicate mapFCmpPred(Predicate P) {
+  switch (P.getKind()) {
+  case Predicate::FCMP_OEQ:
+  case Predicate::FCMP_UEQ:
+    return Predicate::ICMP_EQ;
+  case Predicate::FCMP_OGT:
+  case Predicate::FCMP_UGT:
+    return Predicate::ICMP_SGT;
+  case Predicate::FCMP_OGE:
+  case Predicate::FCMP_UGE:
+    return Predicate::ICMP_SGE;
+  case Predicate::FCMP_OLT:
+  case Predicate::FCMP_ULT:
+    return Predicate::ICMP_SLT;
+  case Predicate::FCMP_OLE:
+  case Predicate::FCMP_ULE:
+    return Predicate::ICMP_SLE;
+  case Predicate::FCMP_ONE:
+  case Predicate::FCMP_UNE:
+    return Predicate::ICMP_NE;
   default:
-    return CmpInst::BAD_ICMP_PREDICATE;
+    return Predicate::BAD_ICMP_PREDICATE;
   }
 }
 
 // Given a floating point binary operator, return the matching
 // integer version.
 static Instruction::BinaryOps mapBinOpcode(unsigned Opcode) {
   switch (Opcode) {
   default: llvm_unreachable("Unhandled opcode!");
for (auto &I : instructions(F)) {
     switch (I.getOpcode()) {
     default: break;
     case Instruction::FPToUI:
     case Instruction::FPToSI:
       Roots.insert(&I);
       break;
     case Instruction::FCmp:
       if (mapFCmpPred(cast<CmpInst>(&I)->getPredicate()) !=
-          CmpInst::BAD_ICMP_PREDICATE)
+          Predicate::BAD_ICMP_PREDICATE)
         Roots.insert(&I);
       break;
     }
   }
 }
 
 // Helper - mark I as having been traversed, having range R.
 ConstantRange Float2IntPass::seen(Instruction *I, ConstantRange R) {
case Instruction::FPToUI:
     NewV = IRB.CreateZExtOrTrunc(NewOperands[0], I->getType());
     break;
 
   case Instruction::FPToSI:
     NewV = IRB.CreateSExtOrTrunc(NewOperands[0], I->getType());
     break;
 
   case Instruction::FCmp: {
-    CmpInst::Predicate P = mapFCmpPred(cast<CmpInst>(I)->getPredicate());
-    assert(P != CmpInst::BAD_ICMP_PREDICATE && "Unhandled predicate!");
+    Predicate P = mapFCmpPred(cast<CmpInst>(I)->getPredicate());
+    assert(P != Predicate::BAD_ICMP_PREDICATE && "Unhandled predicate!");
     NewV = IRB.CreateICmp(P, NewOperands[0], NewOperands[1], I->getName());
     break;
   }
 
   case Instruction::UIToFP:
     NewV = IRB.CreateZExtOrTrunc(NewOperands[0], ToTy);
     break;
 

lib/Transforms/Scalar/GVN.cpp

if (I->isCommutative()) {
     // efficient to sort by hand rather than using, say, std::sort.
     assert(I->getNumOperands() == 2 && "Unsupported commutative instruction!");
     if (e.varargs[0] > e.varargs[1])
       std::swap(e.varargs[0], e.varargs[1]);
   }
 
   if (CmpInst *C = dyn_cast<CmpInst>(I)) {
     // Sort the operand value numbers so x<y and y>x get the same value number.
-    CmpInst::Predicate Predicate = C->getPredicate();
+    Predicate Pred = C->getPredicate();
     if (e.varargs[0] > e.varargs[1]) {
       std::swap(e.varargs[0], e.varargs[1]);
-      Predicate = CmpInst::getSwappedPredicate(Predicate);
+      Pred = Pred.getSwapped();
     }
-    e.opcode = (C->getOpcode() << 8) | Predicate;
+    e.opcode = (C->getOpcode() << 8) | Pred.getKind();
   } else if (InsertValueInst *E = dyn_cast<InsertValueInst>(I)) {
     for (InsertValueInst::idx_iterator II = E->idx_begin(), IE = E->idx_end();
          II != IE; ++II)
       e.varargs.push_back(*II);
   }
 
   return e;
 }
 
-GVN::Expression GVN::ValueTable::createCmpExpr(unsigned Opcode,
-                                               CmpInst::Predicate Predicate,
+GVN::Expression GVN::ValueTable::createCmpExpr(unsigned Opcode, Predicate Pred,
                                                Value *LHS, Value *RHS) {
   assert((Opcode == Instruction::ICmp || Opcode == Instruction::FCmp) &&
          "Not a comparison!");
   Expression e;
   e.type = CmpInst::makeCmpResultType(LHS->getType());
   e.varargs.push_back(lookupOrAdd(LHS));
   e.varargs.push_back(lookupOrAdd(RHS));
 
   // Sort the operand value numbers so x<y and y>x get the same value number.
   if (e.varargs[0] > e.varargs[1]) {
     std::swap(e.varargs[0], e.varargs[1]);
-    Predicate = CmpInst::getSwappedPredicate(Predicate);
+    Pred = Pred.getSwapped();
   }
-  e.opcode = (Opcode << 8) | Predicate;
+  e.opcode = (Opcode << 8) | Pred.getKind();
   return e;
 }
 
 GVN::Expression GVN::ValueTable::createExtractvalueExpr(ExtractValueInst *EI) {
   assert(EI && "Not an ExtractValueInst?");
   Expression e;
   e.type = EI->getType();
   e.opcode = 0;
uint32_t GVN::ValueTable::lookup(Value *V) const {
   assert(VI != valueNumbering.end() && "Value not numbered?");
   return VI->second;
 }
 
 /// Returns the value number of the given comparison,
 /// assigning it a new number if it did not have one before.  Useful when
 /// we deduced the result of a comparison, but don't immediately have an
 /// instruction realizing that comparison to hand.
-uint32_t GVN::ValueTable::lookupOrAddCmp(unsigned Opcode,
-                                         CmpInst::Predicate Predicate,
+uint32_t GVN::ValueTable::lookupOrAddCmp(unsigned Opcode, Predicate Predicate,
                                          Value *LHS, Value *RHS) {
   Expression exp = createCmpExpr(Opcode, Predicate, LHS, RHS);
   uint32_t& e = expressionNumbering[exp];
   if (!e) e = nextValueNumber++;
   return e;
 }
 
 /// Remove all entries from the ValueTable.
bool GVN::processAssumeIntrinsic(IntrinsicInst *IntrinsicI) {
   // br i1 %cmp, label %bb1, label %bb2 ; will change %cmp to true
   ReplaceWithConstMap[V] = True;
 
   // If one of *cmp *eq operand is const, adding it to map will cover this:
   // %cmp = fcmp oeq float 3.000000e+00, %0 ; const on lhs could happen
   // call void @llvm.assume(i1 %cmp)
   // ret float %0 ; will change it to ret float 3.000000e+00
   if (auto *CmpI = dyn_cast<CmpInst>(V)) {
-    if (CmpI->getPredicate() == CmpInst::Predicate::ICMP_EQ ||
-        CmpI->getPredicate() == CmpInst::Predicate::FCMP_OEQ ||
-        (CmpI->getPredicate() == CmpInst::Predicate::FCMP_UEQ &&
+    if (CmpI->getPredicate() == Predicate::ICMP_EQ ||
+        CmpI->getPredicate() == Predicate::FCMP_OEQ ||
+        (CmpI->getPredicate() == Predicate::FCMP_UEQ &&
          CmpI->getFastMathFlags().noNaNs())) {
       Value *CmpLHS = CmpI->getOperand(0);
       Value *CmpRHS = CmpI->getOperand(1);
       if (isa<Constant>(CmpLHS))
         std::swap(CmpLHS, CmpRHS);
       auto *RHSConst = dyn_cast<Constant>(CmpRHS);
 
       // If only one operand is constant.
while (!Worklist.empty()) {
     // If we are propagating an equality like "(A == B)" == "true" then also
     // propagate the equality A == B.  When propagating a comparison such as
     // "(A >= B)" == "true", replace all instances of "A < B" with "false".
     if (CmpInst *Cmp = dyn_cast<CmpInst>(LHS)) {
       Value *Op0 = Cmp->getOperand(0), *Op1 = Cmp->getOperand(1);
 
       // If "A == B" is known true, or "A != B" is known false, then replace
       // A with B everywhere in the scope.
-      if ((isKnownTrue && Cmp->getPredicate() == CmpInst::ICMP_EQ) ||
-          (isKnownFalse && Cmp->getPredicate() == CmpInst::ICMP_NE))
+      if ((isKnownTrue && Cmp->getPredicate() == Predicate::ICMP_EQ) ||
+          (isKnownFalse && Cmp->getPredicate() == Predicate::ICMP_NE))
         Worklist.push_back(std::make_pair(Op0, Op1));
 
       // Handle the floating point versions of equality comparisons too.
-      if ((isKnownTrue && Cmp->getPredicate() == CmpInst::FCMP_OEQ) ||
-          (isKnownFalse && Cmp->getPredicate() == CmpInst::FCMP_UNE)) {
+      if ((isKnownTrue && Cmp->getPredicate() == Predicate::FCMP_OEQ) ||
+          (isKnownFalse && Cmp->getPredicate() == Predicate::FCMP_UNE)) {
 
         // Floating point -0.0 and 0.0 compare equal, so we can only
         // propagate values if we know that we have a constant and that
         // its value is non-zero.
 
         // FIXME: We should do this optimization if 'no signed zeros' is
         // applicable via an instruction-level fast-math-flag or some other
         // indicator that relaxed FP semantics are being used.
 
         if (isa<ConstantFP>(Op1) && !cast<ConstantFP>(Op1)->isZero())
           Worklist.push_back(std::make_pair(Op0, Op1));
       }
 
       // If "A >= B" is known true, replace "A < B" with false everywhere.
-      CmpInst::Predicate NotPred = Cmp->getInversePredicate();
+      Predicate NotPred = Cmp->getInversePredicate();
       Constant *NotVal = ConstantInt::get(Cmp->getType(), isKnownFalse);
       // Since we don't have the instruction "A < B" immediately to hand, work
       // out the value number that it would have and use that to find an
       // appropriate instruction (if any).
       uint32_t NextNum = VN.getNextUnusedValueNumber();
       uint32_t Num = VN.lookupOrAddCmp(Cmp->getOpcode(), NotPred, Op0, Op1);
       // If the number we were assigned was brand new then there is no point in
       // looking for an instruction realizing it: there cannot be one!

lib/Transforms/Scalar/GuardWidening.cpp

 bool GuardWideningImpl::widenCondCommon(Value *Cond0, Value *Cond1,
                                         Instruction *InsertPt, Value *&Result) {
   using namespace llvm::PatternMatch;
 
   {
     // L >u C0 && L >u C1  ->  L >u max(C0, C1)
     ConstantInt *RHS0, *RHS1;
     Value *LHS;
-    ICmpInst::Predicate Pred0, Pred1;
+    Predicate Pred0, Pred1;
     if (match(Cond0, m_ICmp(Pred0, m_Value(LHS), m_ConstantInt(RHS0))) &&
         match(Cond1, m_ICmp(Pred1, m_Specific(LHS), m_ConstantInt(RHS1)))) {
 
       ConstantRange CR0 =
           ConstantRange::makeExactICmpRegion(Pred0, RHS0->getValue());
       ConstantRange CR1 =
           ConstantRange::makeExactICmpRegion(Pred1, RHS1->getValue());
 
       // SubsetIntersect is a subset of the actual mathematical intersection of
       // CR0 and CR1, while SupersetIntersect is a superset of the actual
       // mathematical intersection.  If these two ConstantRanges are equal, then
       // we know we were able to represent the actual mathematical intersection
       // of CR0 and CR1, and can use the same to generate an icmp instruction.
       //
       // Given what we're doing here and the semantics of guards, it would
       // actually be correct to just use SubsetIntersect, but that may be too
       // aggressive in cases we care about.
       auto SubsetIntersect = CR0.inverse().unionWith(CR1.inverse()).inverse();
       auto SupersetIntersect = CR0.intersectWith(CR1);
 
       APInt NewRHSAP;
-      CmpInst::Predicate Pred;
+      Predicate Pred;
       if (SubsetIntersect == SupersetIntersect &&
           SubsetIntersect.getEquivalentICmp(Pred, NewRHSAP)) {
         if (InsertPt) {
           ConstantInt *NewRHS = ConstantInt::get(Cond0->getContext(), NewRHSAP);
           Result = new ICmpInst(InsertPt, Pred, LHS, NewRHS, "wide.chk");
         }
         return true;
       }
using namespace llvm::PatternMatch;
     Value *AndLHS, *AndRHS;
     if (match(CheckCond, m_And(m_Value(AndLHS), m_Value(AndRHS))))
       return parseRangeChecks(AndLHS, Checks) &&
              parseRangeChecks(AndRHS, Checks);
   }
 
   auto *IC = dyn_cast<ICmpInst>(CheckCond);
   if (!IC || !IC->getOperand(0)->getType()->isIntegerTy() ||
-      (IC->getPredicate() != ICmpInst::ICMP_ULT &&
-       IC->getPredicate() != ICmpInst::ICMP_UGT))
+      (IC->getPredicate() != Predicate::ICMP_ULT &&
+       IC->getPredicate() != Predicate::ICMP_UGT))
     return false;
 
   Value *CmpLHS = IC->getOperand(0), *CmpRHS = IC->getOperand(1);
-  if (IC->getPredicate() == ICmpInst::ICMP_UGT)
+  if (IC->getPredicate() == Predicate::ICMP_UGT)
     std::swap(CmpLHS, CmpRHS);
 
   auto &DL = IC->getModule()->getDataLayout();
 
   GuardWideningImpl::RangeCheck Check(
       CmpLHS, cast<ConstantInt>(ConstantInt::getNullValue(CmpRHS->getType())),
       CmpRHS, IC);
 

lib/Transforms/Scalar/IndVarSimplify.cpp

void IndVarSimplify::handleFloatingPointIV(Loop *L, PHINode *PN) {
   // transform it.
   ConstantFP *ExitValueVal = dyn_cast<ConstantFP>(Compare->getOperand(1));
   int64_t ExitValue;
   if (ExitValueVal == nullptr ||
       !ConvertToSInt(ExitValueVal->getValueAPF(), ExitValue))
     return;
 
   // Find new predicate for integer comparison.
-  CmpInst::Predicate NewPred = CmpInst::BAD_ICMP_PREDICATE;
-  switch (Compare->getPredicate()) {
+  Predicate NewPred = Predicate::BAD_ICMP_PREDICATE;
+  switch (Compare->getPredicate().getKind()) {
   default: return;  // Unknown comparison.
-  case CmpInst::FCMP_OEQ:
-  case CmpInst::FCMP_UEQ: NewPred = CmpInst::ICMP_EQ; break;
-  case CmpInst::FCMP_ONE:
-  case CmpInst::FCMP_UNE: NewPred = CmpInst::ICMP_NE; break;
-  case CmpInst::FCMP_OGT:
-  case CmpInst::FCMP_UGT: NewPred = CmpInst::ICMP_SGT; break;
-  case CmpInst::FCMP_OGE:
-  case CmpInst::FCMP_UGE: NewPred = CmpInst::ICMP_SGE; break;
-  case CmpInst::FCMP_OLT:
-  case CmpInst::FCMP_ULT: NewPred = CmpInst::ICMP_SLT; break;
-  case CmpInst::FCMP_OLE:
-  case CmpInst::FCMP_ULE: NewPred = CmpInst::ICMP_SLE; break;
+  case Predicate::FCMP_OEQ:
+  case Predicate::FCMP_UEQ:
+    NewPred = Predicate::ICMP_EQ;
+    break;
+  case Predicate::FCMP_ONE:
+  case Predicate::FCMP_UNE:
+    NewPred = Predicate::ICMP_NE;
+    break;
+  case Predicate::FCMP_OGT:
+  case Predicate::FCMP_UGT:
+    NewPred = Predicate::ICMP_SGT;
+    break;
+  case Predicate::FCMP_OGE:
+  case Predicate::FCMP_UGE:
+    NewPred = Predicate::ICMP_SGE;
+    break;
+  case Predicate::FCMP_OLT:
+  case Predicate::FCMP_ULT:
+    NewPred = Predicate::ICMP_SLT;
+    break;
+  case Predicate::FCMP_OLE:
+  case Predicate::FCMP_ULE:
+    NewPred = Predicate::ICMP_SLE;
+    break;
   }
 
   // We convert the floating point induction variable to a signed i32 value if
   // we can.  This is only safe if the comparison will not overflow in a way
   // that won't be trapped by the integer equivalent operations.  Check for this
   // now.
   // TODO: We could use i64 if it is native and the range requires it.
 
if (IncValue > 0) {
     // If we have a positive stride, we require the init to be less than the
     // exit value.
     if (InitValue >= ExitValue)
       return;
 
     uint32_t Range = uint32_t(ExitValue-InitValue);
     // Check for infinite loop, either:
     // while (i <= Exit) or until (i > Exit)
-    if (NewPred == CmpInst::ICMP_SLE || NewPred == CmpInst::ICMP_SGT) {
+    if (NewPred == Predicate::ICMP_SLE || NewPred == Predicate::ICMP_SGT) {
       if (++Range == 0) return;  // Range overflows.
     }
 
     unsigned Leftover = Range % uint32_t(IncValue);
 
     // If this is an equality comparison, we require that the strided value
     // exactly land on the exit value, otherwise the IV condition will wrap
     // around and do things the fp IV wouldn't.
-    if ((NewPred == CmpInst::ICMP_EQ || NewPred == CmpInst::ICMP_NE) &&
+    if ((NewPred == Predicate::ICMP_EQ || NewPred == Predicate::ICMP_NE) &&
         Leftover != 0)
       return;
 
     // If the stride would wrap around the i32 before exiting, we can't
     // transform the IV.
     if (Leftover != 0 && int32_t(ExitValue+IncValue) < ExitValue)
       return;
 
   } else {
     // If we have a negative stride, we require the init to be greater than the
     // exit value.
     if (InitValue <= ExitValue)
       return;
 
     uint32_t Range = uint32_t(InitValue-ExitValue);
     // Check for infinite loop, either:
     // while (i >= Exit) or until (i < Exit)
-    if (NewPred == CmpInst::ICMP_SGE || NewPred == CmpInst::ICMP_SLT) {
+    if (NewPred == Predicate::ICMP_SGE || NewPred == Predicate::ICMP_SLT) {
       if (++Range == 0) return;  // Range overflows.
     }
 
     unsigned Leftover = Range % uint32_t(-IncValue);
 
     // If this is an equality comparison, we require that the strided value
     // exactly land on the exit value, otherwise the IV condition will wrap
     // around and do things the fp IV wouldn't.
-    if ((NewPred == CmpInst::ICMP_EQ || NewPred == CmpInst::ICMP_NE) &&
+    if ((NewPred == Predicate::ICMP_EQ || NewPred == Predicate::ICMP_NE) &&
         Leftover != 0)
       return;
 
     // If the stride would wrap around the i32 before exiting, we can't
     // transform the IV.
     if (Leftover != 0 && int32_t(ExitValue+IncValue) > ExitValue)
       return;
   }
Instruction *WidenIV::widenIVUse(NarrowIVDefUse DU, SCEVExpander &Rewriter) {
   return WideUse;
 }
 
 /// Add eligible users of NarrowDef to NarrowIVUsers.
 ///
 void WidenIV::pushNarrowIVUsers(Instruction *NarrowDef, Instruction *WideDef) {
   const SCEV *NarrowSCEV = SE->getSCEV(NarrowDef);
   bool NeverNegative =
-      SE->isKnownPredicate(ICmpInst::ICMP_SGE, NarrowSCEV,
+      SE->isKnownPredicate(Predicate::ICMP_SGE, NarrowSCEV,
                            SE->getConstant(NarrowSCEV->getType(), 0));
   for (User *U : NarrowDef->users()) {
     Instruction *NarrowUser = cast<Instruction>(U);
 
     // Handle data flow merges and bizarre phi cycles.
     if (!Widened.insert(NarrowUser).second)
       continue;
 

 /// current exit test is already sufficiently canonical.
 static bool needsLFTR(Loop *L, DominatorTree *DT) {
   // Do LFTR to simplify the exit condition to an ICMP.
   ICmpInst *Cond = getLoopTest(L);
   if (!Cond)
     return true;
 
   // Do LFTR to simplify the exit ICMP to EQ/NE
-  ICmpInst::Predicate Pred = Cond->getPredicate();
-  if (Pred != ICmpInst::ICMP_NE && Pred != ICmpInst::ICMP_EQ)
+  Predicate Pred = Cond->getPredicate();
+  if (Pred != Predicate::ICMP_NE && Pred != Predicate::ICMP_EQ)
     return true;
 
   // Look for a loop invariant RHS
   Value *LHS = Cond->getOperand(0);
   Value *RHS = Cond->getOperand(1);
   if (!isLoopInvariant(RHS, L, DT)) {
     if (!isLoopInvariant(LHS, L, DT))
       return true;
linearFunctionTestReplace(Loop *L,
 
   Value *ExitCnt = genLoopLimit(IndVar, IVCount, L, Rewriter, SE);
   assert(ExitCnt->getType()->isPointerTy() ==
              IndVar->getType()->isPointerTy() &&
          "genLoopLimit missed a cast");
 
   // Insert a new icmp_ne or icmp_eq instruction before the branch.
   BranchInst *BI = cast<BranchInst>(L->getExitingBlock()->getTerminator());
-  ICmpInst::Predicate P;
+  Predicate P;
   if (L->contains(BI->getSuccessor(0)))
-    P = ICmpInst::ICMP_NE;
+    P = Predicate::ICMP_NE;
   else
-    P = ICmpInst::ICMP_EQ;
+    P = Predicate::ICMP_EQ;
 
   DEBUG(dbgs() << "INDVARS: Rewriting loop exit condition to:\n"
                << "      LHS:" << *CmpIndVar << '\n'
-               << "       op:\t"
-               << (P == ICmpInst::ICMP_NE ? "!=" : "==") << "\n"
+               << "       op:\t" << (P == Predicate::ICMP_NE ? "!=" : "==")
+               << "\n"
                << "      RHS:\t" << *ExitCnt << "\n"
                << "  IVCount:\t" << *IVCount << "\n");
 
   IRBuilder<> Builder(BI);
 
   // LFTR can ignore IV overflow and truncate to the width of
   // BECount. This avoids materializing the add(zext(add)) expression.
   unsigned CmpIndVarSize = SE->getTypeSizeInBits(CmpIndVar->getType());

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

if (isa<SCEVCouldNotCompute>(S))
       return false;
 
     return SE.getLoopDisposition(S, L) == ScalarEvolution::LoopInvariant &&
            SE.isKnownNonNegative(S);
   };
 
   using namespace llvm::PatternMatch;
 
-  ICmpInst::Predicate Pred = ICI->getPredicate();
+  Predicate Pred = ICI->getPredicate();
   Value *LHS = ICI->getOperand(0);
   Value *RHS = ICI->getOperand(1);
 
-  switch (Pred) {
+  switch (Pred.getKind()) {
   default:
     return RANGE_CHECK_UNKNOWN;
 
-  case ICmpInst::ICMP_SLE:
+  case Predicate::ICMP_SLE:
     std::swap(LHS, RHS);
   // fallthrough
-  case ICmpInst::ICMP_SGE:
+  case Predicate::ICMP_SGE:
     if (match(RHS, m_ConstantInt<0>())) {
       Index = LHS;
       return RANGE_CHECK_LOWER;
     }
     return RANGE_CHECK_UNKNOWN;
 
-  case ICmpInst::ICMP_SLT:
+  case Predicate::ICMP_SLT:
     std::swap(LHS, RHS);
   // fallthrough
-  case ICmpInst::ICMP_SGT:
+  case Predicate::ICMP_SGT:
     if (match(RHS, m_ConstantInt<-1>())) {
       Index = LHS;
       return RANGE_CHECK_LOWER;
     }
 
     if (IsNonNegativeAndNotLoopVarying(LHS)) {
       Index = RHS;
       Length = LHS;
       return RANGE_CHECK_UPPER;
     }
     return RANGE_CHECK_UNKNOWN;
 
-  case ICmpInst::ICMP_ULT:
+  case Predicate::ICMP_ULT:
     std::swap(LHS, RHS);
   // fallthrough
-  case ICmpInst::ICMP_UGT:
+  case Predicate::ICMP_UGT:
     if (IsNonNegativeAndNotLoopVarying(LHS)) {
       Index = RHS;
       Length = LHS;
       return RANGE_CHECK_BOTH;
     }
     return RANGE_CHECK_UNKNOWN;
   }
 
LoopStructure::parseLoopStructure(ScalarEvolution &SE, BranchProbabilityInfo &BPI,
   }
 
   const SCEV *LatchCount = SE.getExitCount(&L, Latch);
   if (isa<SCEVCouldNotCompute>(LatchCount)) {
     FailureReason = "could not compute latch count";
     return None;
   }
 
-  ICmpInst::Predicate Pred = ICI->getPredicate();
+  Predicate Pred = ICI->getPredicate();
   Value *LeftValue = ICI->getOperand(0);
   const SCEV *LeftSCEV = SE.getSCEV(LeftValue);
   IntegerType *IndVarTy = cast<IntegerType>(LeftValue->getType());
 
   Value *RightValue = ICI->getOperand(1);
   const SCEV *RightSCEV = SE.getSCEV(RightValue);
 
   // We canonicalize `ICI` such that `LeftSCEV` is an add recurrence.
   if (!isa<SCEVAddRecExpr>(LeftSCEV)) {
     if (isa<SCEVAddRecExpr>(RightSCEV)) {
       std::swap(LeftSCEV, RightSCEV);
       std::swap(LeftValue, RightValue);
-      Pred = ICmpInst::getSwappedPredicate(Pred);
+      Pred = Pred.getSwapped();
     } else {
       FailureReason = "no add recurrences in the icmp";
       return None;
     }
   }
 
   auto HasNoSignedWrap = [&](const SCEVAddRecExpr *AR) {
     if (AR->getNoWrapFlags(SCEV::FlagNSW))
if (!IsInductionVar(IndVarNext, IsIncreasing)) {
     FailureReason = "LHS in icmp not induction variable";
     return None;
   }
 
   ConstantInt *One = ConstantInt::get(IndVarTy, 1);
   // TODO: generalize the predicates here to also match their unsigned variants.
   if (IsIncreasing) {
     bool FoundExpectedPred =
-        (Pred == ICmpInst::ICMP_SLT && LatchBrExitIdx == 1) ||
-        (Pred == ICmpInst::ICMP_SGT && LatchBrExitIdx == 0);
+        (Pred == Predicate::ICMP_SLT && LatchBrExitIdx == 1) ||
+        (Pred == Predicate::ICMP_SGT && LatchBrExitIdx == 0);
 
     if (!FoundExpectedPred) {
       FailureReason = "expected icmp slt semantically, found something else";
       return None;
     }
 
     if (LatchBrExitIdx == 0) {
       if (CanBeSMax(SE, RightSCEV)) {
         // TODO: this restriction is easily removable -- we just have to
         // remember that the icmp was an slt and not an sle.
         FailureReason = "limit may overflow when coercing sle to slt";
         return None;
       }
 
       IRBuilder<> B(Preheader->getTerminator());
       RightValue = B.CreateAdd(RightValue, One);
     }
 
   } else {
     bool FoundExpectedPred =
-        (Pred == ICmpInst::ICMP_SGT && LatchBrExitIdx == 1) ||
-        (Pred == ICmpInst::ICMP_SLT && LatchBrExitIdx == 0);
+        (Pred == Predicate::ICMP_SGT && LatchBrExitIdx == 1) ||
+        (Pred == Predicate::ICMP_SLT && LatchBrExitIdx == 0);
 
     if (!FoundExpectedPred) {
       FailureReason = "expected icmp sgt semantically, found something else";
       return None;
     }
 
     if (LatchBrExitIdx == 0) {
       if (CanBeSMin(SE, RightSCEV)) {
LoopConstrainer::calculateSubRanges() const {
 
   auto Clamp = [this, Smallest, Greatest](const SCEV *S) {
     return SE.getSMaxExpr(Smallest, SE.getSMinExpr(Greatest, S));
   };
 
   // In some cases we can prove that we don't need a pre or post loop
 
   bool ProvablyNoPreloop =
-      SE.isKnownPredicate(ICmpInst::ICMP_SLE, Range.getBegin(), Smallest);
+      SE.isKnownPredicate(Predicate::ICMP_SLE, Range.getBegin(), Smallest);
   if (!ProvablyNoPreloop)
     Result.LowLimit = Clamp(Range.getBegin());
 
   bool ProvablyNoPostLoop =
-      SE.isKnownPredicate(ICmpInst::ICMP_SLE, Greatest, Range.getEnd());
+      SE.isKnownPredicate(Predicate::ICMP_SLE, Greatest, Range.getEnd());
   if (!ProvablyNoPostLoop)
     Result.HighLimit = Clamp(Range.getEnd());
 
   return Result;
 }
 
 void LoopConstrainer::cloneLoop(LoopConstrainer::ClonedLoop &Result,
                                 const char *Tag) const {

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

static Value *matchCondition(BranchInst *BI, BasicBlock *LoopEntry) {
   ICmpInst *Cond = dyn_cast<ICmpInst>(BI->getCondition());
   if (!Cond)
     return nullptr;
 
   ConstantInt *CmpZero = dyn_cast<ConstantInt>(Cond->getOperand(1));
   if (!CmpZero || !CmpZero->isZero())
     return nullptr;
 
-  ICmpInst::Predicate Pred = Cond->getPredicate();
-  if ((Pred == ICmpInst::ICMP_NE && BI->getSuccessor(0) == LoopEntry) ||
-      (Pred == ICmpInst::ICMP_EQ && BI->getSuccessor(1) == LoopEntry))
+  Predicate Pred = Cond->getPredicate();
+  if ((Pred == Predicate::ICMP_NE && BI->getSuccessor(0) == LoopEntry) ||
+      (Pred == Predicate::ICMP_EQ && BI->getSuccessor(1) == LoopEntry))
     return Cond->getOperand(0);
 
   return nullptr;
 }
 
 /// Return true iff the idiom is detected in the loop.
 ///
 /// Additionally:
BasicBlock *Body = *(CurLoop->block_begin());
     Builder.SetInsertPoint(LbCond);
     Instruction *TcDec = cast<Instruction>(
         Builder.CreateSub(TcPhi, ConstantInt::get(Ty, 1),
                           "tcdec", false, true));
 
     TcPhi->addIncoming(TripCnt, PreHead);
     TcPhi->addIncoming(TcDec, Body);
 
-    CmpInst::Predicate Pred =
-        (LbBr->getSuccessor(0) == Body) ? CmpInst::ICMP_UGT : CmpInst::ICMP_SLE;
+    Predicate Pred = (LbBr->getSuccessor(0) == Body) ? Predicate::ICMP_UGT
+                                                     : Predicate::ICMP_SLE;
     LbCond->setPredicate(Pred);
     LbCond->setOperand(0, TcDec);
     LbCond->setOperand(1, ConstantInt::get(Ty, 0));
   }
 
   // Step 4: All the references to the original population counter outside
   //  the loop are replaced with the NewCount -- the value returned from
   //  __builtin_ctpop().
   CntInst->replaceUsesOutsideBlock(NewCount, Body);
 
   // step 5: Forget the "non-computable" trip-count SCEV associated with the
   //   loop. The loop would otherwise not be deleted even if it becomes empty.
   SE->forgetLoop(CurLoop);
 }

lib/Transforms/Scalar/LoopRerollPass.cpp

if (BranchInst *BI = dyn_cast<BranchInst>(Header->getTerminator())) {
              SE->getTypeSizeInBits(ICMinusPlus1SCEV->getType()))) {
           IRBuilder<> Builder(BI);
           Builder.SetCurrentDebugLocation(BI->getDebugLoc());
           NewIV = Builder.CreateSExt(NewIV, ICMinusPlus1SCEV->getType());
         }
         Value *ICMinusPlus1 = Expander.expandCodeFor(
             ICMinusPlus1SCEV, NewIV->getType(), InsertPtr);
 
-        Value *Cond =
-            new ICmpInst(BI, CmpInst::ICMP_EQ, NewIV, ICMinusPlus1, "exitcond");
+        Value *Cond = new ICmpInst(BI, Predicate::ICMP_EQ, NewIV, ICMinusPlus1,
+                                   "exitcond");
         BI->setCondition(Cond);
 
         if (BI->getSuccessor(1) != Header)
           BI->swapSuccessors();
       }
     }
   }
 }

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 /// can be quite costly, especially if it's inside of an outer loop.
 ///
 /// This function solves this problem by detecting this type of loop and
 /// rewriting their conditions from ICMP_NE back to ICMP_SLT, and deleting
 /// the instructions for the maximum computation.
 ///
 ICmpInst *LSRInstance::OptimizeMax(ICmpInst *Cond, IVStrideUse* &CondUse) {
   // Check that the loop matches the pattern we're looking for.
-  if (Cond->getPredicate() != CmpInst::ICMP_EQ &&
-      Cond->getPredicate() != CmpInst::ICMP_NE)
+  if (Cond->getPredicate() != Predicate::ICMP_EQ &&
+      Cond->getPredicate() != Predicate::ICMP_NE)
     return Cond;
 
   SelectInst *Sel = dyn_cast<SelectInst>(Cond->getOperand(1));
   if (!Sel || !Sel->hasOneUse()) return Cond;
 
   const SCEV *BackedgeTakenCount = SE.getBackedgeTakenCount(L);
   if (isa<SCEVCouldNotCompute>(BackedgeTakenCount))
     return Cond;
   const SCEV *One = SE.getConstant(BackedgeTakenCount->getType(), 1);
 
   // Add one to the backedge-taken count to get the trip count.
   const SCEV *IterationCount = SE.getAddExpr(One, BackedgeTakenCount);
   if (IterationCount != SE.getSCEV(Sel)) return Cond;
 
   // Check for a max calculation that matches the pattern. There's no check
   // for ICMP_ULE here because the comparison would be with zero, which
   // isn't interesting.
-  CmpInst::Predicate Pred = ICmpInst::BAD_ICMP_PREDICATE;
+  Predicate Pred = Predicate::BAD_ICMP_PREDICATE;
   const SCEVNAryExpr *Max = nullptr;
   if (const SCEVSMaxExpr *S = dyn_cast<SCEVSMaxExpr>(BackedgeTakenCount)) {
-    Pred = ICmpInst::ICMP_SLE;
+    Pred = Predicate::ICMP_SLE;
     Max = S;
   } else if (const SCEVSMaxExpr *S = dyn_cast<SCEVSMaxExpr>(IterationCount)) {
-    Pred = ICmpInst::ICMP_SLT;
+    Pred = Predicate::ICMP_SLT;
     Max = S;
   } else if (const SCEVUMaxExpr *U = dyn_cast<SCEVUMaxExpr>(IterationCount)) {
-    Pred = ICmpInst::ICMP_ULT;
+    Pred = Predicate::ICMP_ULT;
     Max = U;
   } else {
     // No match; bail.
     return Cond;
   }
 
   // To handle a max with more than two operands, this optimization would
   // require additional checking and setup.
   if (Max->getNumOperands() != 2)
     return Cond;
 
   const SCEV *MaxLHS = Max->getOperand(0);
   const SCEV *MaxRHS = Max->getOperand(1);
 
   // ScalarEvolution canonicalizes constants to the left. For < and >, look
   // for a comparison with 1. For <= and >=, a comparison with zero.
-  if (!MaxLHS ||
-      (ICmpInst::isTrueWhenEqual(Pred) ? !MaxLHS->isZero() : (MaxLHS != One)))
+  if (!MaxLHS || (Pred.isTrueWhenEqual() ? !MaxLHS->isZero() : (MaxLHS != One)))
     return Cond;
 
   // Check the relevant induction variable for conformance to
   // the pattern.
   const SCEV *IV = SE.getSCEV(Cond->getOperand(0));
   const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(IV);
   if (!AR || !AR->isAffine() ||
       AR->getStart() != One ||
       AR->getStepRecurrence(SE) != One)
     return Cond;
 
   assert(AR->getLoop() == L &&
          "Loop condition operand is an addrec in a different loop!");
 
   // Check the right operand of the select, and remember it, as it will
   // be used in the new comparison instruction.
   Value *NewRHS = nullptr;
-  if (ICmpInst::isTrueWhenEqual(Pred)) {
+  if (Pred.isTrueWhenEqual()) {
     // Look for n+1, and grab n.
     if (AddOperator *BO = dyn_cast<AddOperator>(Sel->getOperand(1)))
       if (ConstantInt *BO1 = dyn_cast<ConstantInt>(BO->getOperand(1)))
          if (BO1->isOne() && SE.getSCEV(BO->getOperand(0)) == MaxRHS)
            NewRHS = BO->getOperand(0);
     if (AddOperator *BO = dyn_cast<AddOperator>(Sel->getOperand(2)))
       if (ConstantInt *BO1 = dyn_cast<ConstantInt>(BO->getOperand(1)))
         if (BO1->isOne() && SE.getSCEV(BO->getOperand(0)) == MaxRHS)
           NewRHS = BO->getOperand(0);
     if (!NewRHS)
       return Cond;
   } else if (SE.getSCEV(Sel->getOperand(1)) == MaxRHS)
     NewRHS = Sel->getOperand(1);
   else if (SE.getSCEV(Sel->getOperand(2)) == MaxRHS)
     NewRHS = Sel->getOperand(2);
   else if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(MaxRHS))
     NewRHS = SU->getValue();
   else
     // Max doesn't match expected pattern.
     return Cond;
 
   // Determine the new comparison opcode. It may be signed or unsigned,
   // and the original comparison may be either equality or inequality.
-  if (Cond->getPredicate() == CmpInst::ICMP_EQ)
-    Pred = CmpInst::getInversePredicate(Pred);
+  if (Cond->getPredicate() == Predicate::ICMP_EQ)
+    Pred = Pred.getInverse();
 
   // Ok, everything looks ok to change the condition into an SLT or SGE and
   // delete the max calculation.
   ICmpInst *NewCond =
     new ICmpInst(Cond, Pred, Cond->getOperand(0), NewRHS, "scmp");
 
   // Delete the max calculation instructions.
   Cond->replaceAllUsesWith(NewCond);

lib/Transforms/Scalar/LoopUnswitch.cpp

void LoopUnswitch::EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
                                                   Instruction *InsertPt,
                                                   TerminatorInst *TI) {
   // Insert a conditional branch on LIC to the two preheaders.  The original
   // code is the true version and the new code is the false version.
   Value *BranchVal = LIC;
   bool Swapped = false;
   if (!isa<ConstantInt>(Val) ||
       Val->getType() != Type::getInt1Ty(LIC->getContext()))
-    BranchVal = new ICmpInst(InsertPt, ICmpInst::ICMP_EQ, LIC, Val);
+    BranchVal = new ICmpInst(InsertPt, Predicate::ICMP_EQ, LIC, Val);
   else if (Val != ConstantInt::getTrue(Val->getContext())) {
     // We want to enter the new loop when the condition is true.
     std::swap(TrueDest, FalseDest);
     Swapped = true;
   }
 
   // Insert the new branch.
   BranchInst *BI = BranchInst::Create(TrueDest, FalseDest, BranchVal, InsertPt);

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

static bool handleBranchExpect(BranchInst &BI) {
   //   br i1 %expval, label %if.then, label %if.end
 
   CallInst *CI;
 
   ICmpInst *CmpI = dyn_cast<ICmpInst>(BI.getCondition());
   if (!CmpI) {
     CI = dyn_cast<CallInst>(BI.getCondition());
   } else {
-    if (CmpI->getPredicate() != CmpInst::ICMP_NE)
+    if (CmpI->getPredicate() != Predicate::ICMP_NE)
       return false;
     CI = dyn_cast<CallInst>(CmpI->getOperand(0));
   }
 
   if (!CI)
     return false;
 
   Function *Fn = CI->getCalledFunction();

lib/Transforms/Utils/CmpInstAnalysis.cpp

 
 #include "llvm/Transforms/Utils/CmpInstAnalysis.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 
 using namespace llvm;
 
 unsigned llvm::getICmpCode(const ICmpInst *ICI, bool InvertPred) {
-  ICmpInst::Predicate Pred = InvertPred ? ICI->getInversePredicate()
-                                        : ICI->getPredicate();
-  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
-    case ICmpInst::ICMP_SLT: return 4;  // 100
-    case ICmpInst::ICMP_NE:  return 5;  // 101
-    case ICmpInst::ICMP_ULE: return 6;  // 110
-    case ICmpInst::ICMP_SLE: return 6;  // 110
-      // True -> 7
-    default:
-      llvm_unreachable("Invalid ICmp predicate!");
+  Predicate Pred =
+      InvertPred ? ICI->getInversePredicate() : ICI->getPredicate();
+  switch (Pred.getKind()) {
+  case Predicate::ICMP_UGT:
+    return 1; // 001
+  case Predicate::ICMP_SGT:
+    return 1; // 001
+  case Predicate::ICMP_EQ:
+    return 2; // 010
+  case Predicate::ICMP_UGE:
+    return 3; // 011
+  case Predicate::ICMP_SGE:
+    return 3; // 011
+  case Predicate::ICMP_ULT:
+    return 4; // 100
+  case Predicate::ICMP_SLT:
+    return 4; // 100
+  case Predicate::ICMP_NE:
+    return 5; // 101
+  case Predicate::ICMP_ULE:
+    return 6; // 110
+  case Predicate::ICMP_SLE:
+    return 6; // 110
   }
 }
 
 Value *llvm::getICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS,
-                          CmpInst::Predicate &NewICmpPred) {
+                          Predicate &NewICmpPred) {
   switch (Code) {
     default: llvm_unreachable("Illegal ICmp code!");
     case 0: // False.
       return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
-    case 1: NewICmpPred = Sign ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; break;
-    case 2: NewICmpPred = ICmpInst::ICMP_EQ; break;
-    case 3: NewICmpPred = Sign ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE; break;
-    case 4: NewICmpPred = Sign ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT; break;
-    case 5: NewICmpPred = ICmpInst::ICMP_NE; break;
-    case 6: NewICmpPred = Sign ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE; break;
+    case 1:
+      NewICmpPred = Sign ? Predicate::ICMP_SGT : Predicate::ICMP_UGT;
+      break;
+    case 2:
+      NewICmpPred = Predicate::ICMP_EQ;
+      break;
+    case 3:
+      NewICmpPred = Sign ? Predicate::ICMP_SGE : Predicate::ICMP_UGE;
+      break;
+    case 4:
+      NewICmpPred = Sign ? Predicate::ICMP_SLT : Predicate::ICMP_ULT;
+      break;
+    case 5:
+      NewICmpPred = Predicate::ICMP_NE;
+      break;
+    case 6:
+      NewICmpPred = Sign ? Predicate::ICMP_SLE : Predicate::ICMP_ULE;
+      break;
     case 7: // True.
       return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1);
   }
   return nullptr;
 }
 
-bool llvm::PredicatesFoldable(ICmpInst::Predicate p1, ICmpInst::Predicate p2) {
-  return (CmpInst::isSigned(p1) == CmpInst::isSigned(p2)) ||
-         (CmpInst::isSigned(p1) && ICmpInst::isEquality(p2)) ||
-         (CmpInst::isSigned(p2) && ICmpInst::isEquality(p1));
+bool llvm::PredicatesFoldable(Predicate p1, Predicate p2) {
+  return (p1.isSigned() == p2.isSigned()) ||
+         (p1.isSigned() && p2.isEquality()) ||
+         (p2.isSigned() && p1.isEquality());
 }
 
-bool llvm::decomposeBitTestICmp(const ICmpInst *I, CmpInst::Predicate &Pred,
-                                Value *&X, Value *&Y, Value *&Z) {
+bool llvm::decomposeBitTestICmp(const ICmpInst *I, Predicate &Pred, Value *&X,
+                                Value *&Y, Value *&Z) {
   ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1));
   if (!C)
     return false;
 
-  switch (I->getPredicate()) {
+  switch (I->getPredicate().getKind()) {
   default:
     return false;
-  case ICmpInst::ICMP_SLT:
+  case Predicate::ICMP_SLT:
     // X < 0 is equivalent to (X & SignBit) != 0.
     if (!C->isZero())
       return false;
     Y = ConstantInt::get(I->getContext(), APInt::getSignBit(C->getBitWidth()));
-    Pred = ICmpInst::ICMP_NE;
+    Pred = Predicate::ICMP_NE;
     break;
-  case ICmpInst::ICMP_SGT:
+  case Predicate::ICMP_SGT:
     // X > -1 is equivalent to (X & SignBit) == 0.
     if (!C->isAllOnesValue())
       return false;
     Y = ConstantInt::get(I->getContext(), APInt::getSignBit(C->getBitWidth()));
-    Pred = ICmpInst::ICMP_EQ;
+    Pred = Predicate::ICMP_EQ;
     break;
-  case ICmpInst::ICMP_ULT:
+  case Predicate::ICMP_ULT:
     // X <u 2^n is equivalent to (X & ~(2^n-1)) == 0.
     if (!C->getValue().isPowerOf2())
       return false;
     Y = ConstantInt::get(I->getContext(), -C->getValue());
-    Pred = ICmpInst::ICMP_EQ;
+    Pred = Predicate::ICMP_EQ;
     break;
-  case ICmpInst::ICMP_UGT:
+  case Predicate::ICMP_UGT:
     // X >u 2^n-1 is equivalent to (X & ~(2^n-1)) != 0.
     if (!(C->getValue() + 1).isPowerOf2())
       return false;
     Y = ConstantInt::get(I->getContext(), ~C->getValue());
-    Pred = ICmpInst::ICMP_NE;
+    Pred = Predicate::ICMP_NE;
     break;
   }
 
   X = I->getOperand(0);
   Z = ConstantInt::getNullValue(C->getType());
   return true;
 }

lib/Transforms/Utils/FlattenCFG.cpp

if (!PBI1 || !PBI1->isUnconditional() ||
     bool EverChanged = false;
     for (;CurrBlock != FirstCondBlock;
           CurrBlock = CurrBlock->getSinglePredecessor()) {
       BranchInst *BI = dyn_cast<BranchInst>(CurrBlock->getTerminator());
       CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition());
       if (!CI)
         continue;
 
-      CmpInst::Predicate Predicate = CI->getPredicate();
+      Predicate Pred = CI->getPredicate();
       // Canonicalize icmp_ne -> icmp_eq, fcmp_one -> fcmp_oeq
-      if ((Predicate == CmpInst::ICMP_NE) || (Predicate == CmpInst::FCMP_ONE)) {
-        CI->setPredicate(ICmpInst::getInversePredicate(Predicate));
+      if (Pred.isOneOf(Predicate::ICMP_NE, Predicate::FCMP_ONE)) {
+        CI->setPredicate(Pred.getInverse());
         BI->swapSuccessors();
         EverChanged = true;
       }
     }
     return EverChanged;
   }
 
   // PS1 must have a conditional branch.

lib/Transforms/Utils/LoopUtils.cpp

unsigned RecurrenceDescriptor::getRecurrenceBinOp(RecurrenceKind Kind) {
   default:
     llvm_unreachable("Unknown recurrence operation");
   }
 }
 
 Value *RecurrenceDescriptor::createMinMaxOp(IRBuilder<> &Builder,
                                             MinMaxRecurrenceKind RK,
                                             Value *Left, Value *Right) {
-  CmpInst::Predicate P = CmpInst::ICMP_NE;
+  Predicate P = Predicate::ICMP_NE;
   switch (RK) {
   default:
     llvm_unreachable("Unknown min/max recurrence kind");
   case MRK_UIntMin:
-    P = CmpInst::ICMP_ULT;
+    P = Predicate::ICMP_ULT;
     break;
   case MRK_UIntMax:
-    P = CmpInst::ICMP_UGT;
+    P = Predicate::ICMP_UGT;
     break;
   case MRK_SIntMin:
-    P = CmpInst::ICMP_SLT;
+    P = Predicate::ICMP_SLT;
     break;
   case MRK_SIntMax:
-    P = CmpInst::ICMP_SGT;
+    P = Predicate::ICMP_SGT;
     break;
   case MRK_FloatMin:
-    P = CmpInst::FCMP_OLT;
+    P = Predicate::FCMP_OLT;
     break;
   case MRK_FloatMax:
-    P = CmpInst::FCMP_OGT;
+    P = Predicate::FCMP_OGT;
     break;
   }
 
   // We only match FP sequences with unsafe algebra, so we can unconditionally
   // set it on any generated instructions.
   IRBuilder<>::FastMathFlagGuard FMFG(Builder);
   FastMathFlags FMF;
   FMF.setUnsafeAlgebra();

lib/Transforms/Utils/LowerSwitch.cpp

DEBUG(dbgs() << "LHS Bounds ==> ";
           dbgs() << "NONE\n";
         });
 
   // Create a new node that checks if the value is < pivot. Go to the
   // left branch if it is and right branch if not.
   Function* F = OrigBlock->getParent();
   BasicBlock* NewNode = BasicBlock::Create(Val->getContext(), "NodeBlock");
 
-  ICmpInst* Comp = new ICmpInst(ICmpInst::ICMP_SLT,
-                                Val, Pivot.Low, "Pivot");
+  ICmpInst *Comp = new ICmpInst(Predicate::ICMP_SLT, Val, Pivot.Low, "Pivot");
 
   BasicBlock *LBranch = switchConvert(LHS.begin(), LHS.end(), LowerBound,
                                       NewUpperBound, Val, NewNode, OrigBlock,
                                       Default, UnreachableRanges);
   BasicBlock *RBranch = switchConvert(RHS.begin(), RHS.end(), NewLowerBound,
                                       UpperBound, Val, NewNode, OrigBlock,
                                       Default, UnreachableRanges);
 
BasicBlock* LowerSwitch::newLeafBlock(CaseRange& Leaf, Value* Val,
   Function* F = OrigBlock->getParent();
   BasicBlock* NewLeaf = BasicBlock::Create(Val->getContext(), "LeafBlock");
   F->getBasicBlockList().insert(++OrigBlock->getIterator(), NewLeaf);
 
   // Emit comparison
   ICmpInst* Comp = nullptr;
   if (Leaf.Low == Leaf.High) {
     // Make the seteq instruction...
-    Comp = new ICmpInst(*NewLeaf, ICmpInst::ICMP_EQ, Val,
-                        Leaf.Low, "SwitchLeaf");
+    Comp =
+        new ICmpInst(*NewLeaf, Predicate::ICMP_EQ, Val, Leaf.Low, "SwitchLeaf");
   } else {
     // Make range comparison
     if (Leaf.Low->isMinValue(true /*isSigned*/)) {
       // Val >= Min && Val <= Hi --> Val <= Hi
-      Comp = new ICmpInst(*NewLeaf, ICmpInst::ICMP_SLE, Val, Leaf.High,
+      Comp = new ICmpInst(*NewLeaf, Predicate::ICMP_SLE, Val, Leaf.High,
                           "SwitchLeaf");
     } else if (Leaf.Low->isZero()) {
       // Val >= 0 && Val <= Hi --> Val <=u Hi
-      Comp = new ICmpInst(*NewLeaf, ICmpInst::ICMP_ULE, Val, Leaf.High,
-                          "SwitchLeaf");      
+      Comp = new ICmpInst(*NewLeaf, Predicate::ICMP_ULE, Val, Leaf.High,
+                          "SwitchLeaf");
     } else {
       // Emit V-Lo <=u Hi-Lo
       Constant* NegLo = ConstantExpr::getNeg(Leaf.Low);
       Instruction* Add = BinaryOperator::CreateAdd(Val, NegLo,
                                                    Val->getName()+".off",
                                                    NewLeaf);
       Constant *UpperBound = ConstantExpr::getAdd(NegLo, Leaf.High);
-      Comp = new ICmpInst(*NewLeaf, ICmpInst::ICMP_ULE, Add, UpperBound,
+      Comp = new ICmpInst(*NewLeaf, Predicate::ICMP_ULE, Add, UpperBound,
                           "SwitchLeaf");
     }
   }
 
   // Make the conditional branch...
   BasicBlock* Succ = Leaf.BB;
   BranchInst::Create(Succ, Default, Comp, NewLeaf);
 

lib/Transforms/Utils/SimplifyCFG.cpp

bool matchInstruction(Instruction *I, bool isEQ) {
     }
 
     Value *RHSVal;
     const APInt *RHSC;
 
     // Pattern match a special case
     // (x & ~2^z) == y --> x == y || x == y|2^z
     // This undoes a transformation done by instcombine to fuse 2 compares.
-    if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE)) {
+    if (ICI->getPredicate() ==
+        (isEQ ? Predicate::ICMP_EQ : Predicate::ICMP_NE)) {
 
       // It's a little bit hard to see why the following transformations are
       // correct. Here is a CVC3 program to verify them for 64-bit values:
 
       /*
          ONE  : BITVECTOR(64) = BVZEROEXTEND(0bin1, 63);
          x    : BITVECTOR(64);
          y    : BITVECTOR(64);
for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e;
          ++i)
       Cases.push_back(
           ValueEqualityComparisonCase(i.getCaseValue(), i.getCaseSuccessor()));
     return SI->getDefaultDest();
   }
 
   BranchInst *BI = cast<BranchInst>(TI);
   ICmpInst *ICI = cast<ICmpInst>(BI->getCondition());
-  BasicBlock *Succ = BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_NE);
+  BasicBlock *Succ =
+      BI->getSuccessor(ICI->getPredicate() == Predicate::ICMP_NE);
   Cases.push_back(ValueEqualityComparisonCase(
       GetConstantInt(ICI->getOperand(1), DL), Succ));
-  return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ);
+  return BI->getSuccessor(ICI->getPredicate() == Predicate::ICMP_EQ);
 }
 
 /// Given a vector of bb/value pairs, remove any entries
 /// in the list that match the specified block.
 static void
 EliminateBlockCases(BasicBlock *BB,
                     std::vector<ValueEqualityComparisonCase> &Cases) {
   Cases.erase(std::remove(Cases.begin(), Cases.end(), BB), Cases.end());
static void GetBranchWeights(TerminatorInst *TI,
   }
 
   // If TI is a conditional eq, the default case is the false case,
   // and the corresponding branch-weight data is at index 2. We swap the
   // default weight to be the first entry.
   if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
     assert(Weights.size() == 2);
     ICmpInst *ICI = cast<ICmpInst>(BI->getCondition());
-    if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
+    if (ICI->getPredicate() == Predicate::ICMP_EQ)
       std::swap(Weights.front(), Weights.back());
   }
 }
 
 /// Keep halving the weights until all can fit in uint32_t.
 static void FitWeights(MutableArrayRef<uint64_t> Weights) {
   uint64_t Max = *std::max_element(Weights.begin(), Weights.end());
   if (Max > UINT_MAX) {
if (SI->getDefaultDest() != BB) {
     return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
   }
 
   // Ok, the block is reachable from the default dest.  If the constant we're
   // comparing exists in one of the other edges, then we can constant fold ICI
   // and zap it.
   if (SI->findCaseValue(Cst) != SI->case_default()) {
     Value *V;
-    if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
+    if (ICI->getPredicate() == Predicate::ICMP_EQ)
       V = ConstantInt::getFalse(BB->getContext());
     else
       V = ConstantInt::getTrue(BB->getContext());
 
     ICI->replaceAllUsesWith(V);
     ICI->eraseFromParent();
     // BB is now empty, so it is likely to simplify away.
     return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
   }
 
   // The use of the icmp has to be in the 'end' block, by the only PHI node in
   // the block.
   BasicBlock *SuccBlock = BB->getTerminator()->getSuccessor(0);
   PHINode *PHIUse = dyn_cast<PHINode>(ICI->user_back());
   if (PHIUse == nullptr || PHIUse != &SuccBlock->front() ||
       isa<PHINode>(++BasicBlock::iterator(PHIUse)))
     return false;
 
   // If the icmp is a SETEQ, then the default dest gets false, the new edge gets
   // true in the PHI.
   Constant *DefaultCst = ConstantInt::getTrue(BB->getContext());
   Constant *NewCst = ConstantInt::getFalse(BB->getContext());
 
-  if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
+  if (ICI->getPredicate() == Predicate::ICMP_EQ)
     std::swap(DefaultCst, NewCst);
 
   // Replace ICI (which is used by the PHI for the default value) with true or
   // false depending on if it is EQ or NE.
   ICI->replaceAllUsesWith(DefaultCst);
   ICI->eraseFromParent();
 
   // Okay, the switch goes to this block on a default value.  Add an edge from

lib/Transforms/Utils/SimplifyIndVar.cpp

if (IVOperand->use_empty())
     DeadInsts.emplace_back(IVOperand);
   return IVSrc;
 }
 
 /// SimplifyIVUsers helper for eliminating useless
 /// comparisons against an induction variable.
 void SimplifyIndvar::eliminateIVComparison(ICmpInst *ICmp, Value *IVOperand) {
   unsigned IVOperIdx = 0;
-  ICmpInst::Predicate Pred = ICmp->getPredicate();
+  Predicate Pred = ICmp->getPredicate();
   if (IVOperand != ICmp->getOperand(0)) {
     // Swapped
     assert(IVOperand == ICmp->getOperand(1) && "Can't find IVOperand");
     IVOperIdx = 1;
-    Pred = ICmpInst::getSwappedPredicate(Pred);
+    Pred = Pred.getSwapped();
   }
 
   // Get the SCEVs for the ICmp operands.
   const SCEV *S = SE->getSCEV(ICmp->getOperand(IVOperIdx));
   const SCEV *X = SE->getSCEV(ICmp->getOperand(1 - IVOperIdx));
 
   // Simplify unnecessary loops away.
   const Loop *ICmpLoop = LI->getLoopFor(ICmp->getParent());
   S = SE->getSCEVAtScope(S, ICmpLoop);
   X = SE->getSCEVAtScope(X, ICmpLoop);
 
-  ICmpInst::Predicate InvariantPredicate;
+  Predicate InvariantPredicate;
   const SCEV *InvariantLHS, *InvariantRHS;
 
   // If the condition is always true or always false, replace it with
   // a constant value.
   if (SE->isKnownPredicate(Pred, S, X)) {
     ICmp->replaceAllUsesWith(ConstantInt::getTrue(ICmp->getContext()));
     DeadInsts.emplace_back(ICmp);
     DEBUG(dbgs() << "INDVARS: Eliminated comparison: " << *ICmp << '\n');
-  } else if (SE->isKnownPredicate(ICmpInst::getInversePredicate(Pred), S, X)) {
+  } else if (SE->isKnownPredicate(Pred.getInverse(), S, X)) {
     ICmp->replaceAllUsesWith(ConstantInt::getFalse(ICmp->getContext()));
     DeadInsts.emplace_back(ICmp);
     DEBUG(dbgs() << "INDVARS: Eliminated comparison: " << *ICmp << '\n');
   } else if (isa<PHINode>(IVOperand) &&
              SE->isLoopInvariantPredicate(Pred, S, X, L, InvariantPredicate,
                                           InvariantLHS, InvariantRHS)) {
 
     // Rewrite the comparison to a loop invariant comparison if it can be done
void SimplifyIndvar::eliminateIVRemainder(BinaryOperator *Rem,
 
   // Simplify unnecessary loops away.
   const Loop *ICmpLoop = LI->getLoopFor(Rem->getParent());
   S = SE->getSCEVAtScope(S, ICmpLoop);
   X = SE->getSCEVAtScope(X, ICmpLoop);
 
   // i % n  -->  i  if i is in [0,n).
   if ((!IsSigned || SE->isKnownNonNegative(S)) &&
-      SE->isKnownPredicate(IsSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT,
+      SE->isKnownPredicate(IsSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT,
                            S, X))
     Rem->replaceAllUsesWith(Rem->getOperand(0));
   else {
     // (i+1) % n  -->  (i+1)==n?0:(i+1)  if i is in [0,n).
     const SCEV *LessOne = SE->getMinusSCEV(S, SE->getOne(S->getType()));
     if (IsSigned && !SE->isKnownNonNegative(LessOne))
       return;
 
-    if (!SE->isKnownPredicate(IsSigned ?
-                              ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT,
-                              LessOne, X))
+    if (!SE->isKnownPredicate(
+            IsSigned ? Predicate::ICMP_SLT : Predicate::ICMP_ULT, LessOne, X))
       return;
 
-    ICmpInst *ICmp = new ICmpInst(Rem, ICmpInst::ICMP_EQ,
-                                  Rem->getOperand(0), Rem->getOperand(1));
+    ICmpInst *ICmp = new ICmpInst(Rem, Predicate::ICMP_EQ, Rem->getOperand(0),
+                                  Rem->getOperand(1));
     SelectInst *Sel =
       SelectInst::Create(ICmp,
                          ConstantInt::get(Rem->getType(), 0),
                          Rem->getOperand(0), "tmp", Rem);
     Rem->replaceAllUsesWith(Sel);
   }
 
   DEBUG(dbgs() << "INDVARS: Simplified rem: " << *Rem << '\n');

lib/Transforms/Utils/SimplifyLibCalls.cpp

if (!CharC && !Str.empty() && isOnlyUsedInZeroEqualityComparison(CI)) {
     // Now build the bit field.
     APInt Bitfield(Width, 0);
     for (char C : Str)
       Bitfield.setBit((unsigned char)C);
     Value *BitfieldC = B.getInt(Bitfield);
 
     // First check that the bit field access is within bounds.
     Value *C = B.CreateZExtOrTrunc(CI->getArgOperand(1), BitfieldC->getType());
-    Value *Bounds = B.CreateICmp(ICmpInst::ICMP_ULT, C, B.getIntN(Width, Width),
-                                 "memchr.bounds");
+    Value *Bounds = B.CreateICmp(Predicate::ICMP_ULT, C,
+                                 B.getIntN(Width, Width), "memchr.bounds");
 
     // Create code that checks if the given bit is set in the field.
     Value *Shl = B.CreateShl(B.getIntN(Width, 1ULL), C);
     Value *Bits = B.CreateIsNotNull(B.CreateAnd(Shl, BitfieldC), "memchr.bits");
 
     // Finally merge both checks and cast to pointer type. The inttoptr
     // implicitly zexts the i1 to intptr type.
     return B.CreateIntToPtr(B.CreateAnd(Bounds, Bits, "memchr"), CI->getType());

lib/Transforms/Vectorize/LoopVectorize.cpp

void InnerLoopVectorizer::scalarizeInstruction(Instruction *Instr,
   for (unsigned Part = 0; Part < UF; ++Part) {
     // For each scalar that we create:
     for (unsigned Width = 0; Width < VF; ++Width) {
 
       // Start if-block.
       Value *Cmp = nullptr;
       if (IfPredicateStore) {
         Cmp = Builder.CreateExtractElement(Cond[Part], Builder.getInt32(Width));
-        Cmp = Builder.CreateICmp(ICmpInst::ICMP_EQ, Cmp,
+        Cmp = Builder.CreateICmp(Predicate::ICMP_EQ, Cmp,
                                  ConstantInt::get(Cmp->getType(), 1));
       }
 
       Instruction *Cloned = Instr->clone();
       if (!IsVoidRetTy)
         Cloned->setName(Instr->getName() + ".cloned");
       // Replace the operands of the cloned instructions with extracted scalars.
       for (unsigned op = 0, e = Instr->getNumOperands(); op != e; ++op) {
for (BasicBlock *BB : LoopBypassBlocks)
       BCResumeVal->addIncoming(II.getStartValue(), BB);
     OrigPhi->setIncomingValue(BlockIdx, BCResumeVal);
   }
 
   // Add a check in the middle block to see if we have completed
   // all of the iterations in the first vector loop.
   // If (N - N%VF) == N, then we *don't* need to run the remainder.
   Value *CmpN =
-      CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ, Count,
+      CmpInst::Create(Instruction::ICmp, Predicate::ICMP_EQ, Count,
                       CountRoundDown, "cmp.n", MiddleBlock->getTerminator());
   ReplaceInstWithInst(MiddleBlock->getTerminator(),
                       BranchInst::Create(ExitBlock, ScalarPH, CmpN));
 
   // Get ready to start creating new instructions into the vectorized body.
   Builder.SetInsertPoint(&*VecBody->getFirstInsertionPt());
 
   // Save the state.
for (unsigned Part = 0; Part < UF; ++Part) {
     // For each scalar that we create:
 
     // Start an "if (pred) a[i] = ..." block.
     Value *Cmp = nullptr;
     if (IfPredicateStore) {
       if (Cond[Part]->getType()->isVectorTy())
         Cond[Part] =
             Builder.CreateExtractElement(Cond[Part], Builder.getInt32(0));
-      Cmp = Builder.CreateICmp(ICmpInst::ICMP_EQ, Cond[Part],
+      Cmp = Builder.CreateICmp(Predicate::ICMP_EQ, Cond[Part],
                                ConstantInt::get(Cond[Part]->getType(), 1));
     }
 
     Instruction *Cloned = Instr->clone();
     if (!IsVoidRetTy)
       Cloned->setName(Instr->getName() + ".cloned");
     // Replace the operands of the cloned instructions with extracted scalars.
     for (unsigned op = 0, e = Instr->getNumOperands(); op != e; ++op) {

lib/Transforms/Vectorize/SLPVectorizer.cpp

case Instruction::BitCast: {
 
         buildTree_rec(Operands, Depth+1);
       }
       return;
     }
     case Instruction::ICmp:
     case Instruction::FCmp: {
       // Check that all of the compares have the same predicate.
-      CmpInst::Predicate P0 = cast<CmpInst>(VL0)->getPredicate();
+      Predicate P0 = cast<CmpInst>(VL0)->getPredicate();
       Type *ComparedTy = cast<Instruction>(VL[0])->getOperand(0)->getType();
       for (unsigned i = 1, e = VL.size(); i < e; ++i) {
         CmpInst *Cmp = cast<CmpInst>(VL[i]);
         if (Cmp->getPredicate() != P0 ||
             Cmp->getOperand(0)->getType() != ComparedTy) {
           BS.cancelScheduling(VL);
           newTreeEntry(VL, false);
           DEBUG(dbgs() << "SLP: Gathering cmp with different predicate.\n");
case Instruction::ICmp: {
       setInsertPointAfterBundle(E->Scalars);
 
       Value *L = vectorizeTree(LHSV);
       Value *R = vectorizeTree(RHSV);
 
       if (Value *V = alreadyVectorized(E->Scalars))
         return V;
 
-      CmpInst::Predicate P0 = cast<CmpInst>(VL0)->getPredicate();
+      Predicate P0 = cast<CmpInst>(VL0)->getPredicate();
       Value *V;
       if (Opcode == Instruction::FCmp)
         V = Builder.CreateFCmp(P0, L, R);
       else
         V = Builder.CreateICmp(P0, L, R);
 
       E->VectorizedValue = V;
       ++NumVectorInstructions;

tools/bugpoint/Miscompilation.cpp

if (F->isDeclaration() && !F->use_empty() && &*F != resolverFunc &&
                                                     "entry", FuncWrapper);
           BasicBlock *DoCallBB = BasicBlock::Create(F->getContext(),
                                                     "usecache", FuncWrapper);
           BasicBlock *LookupBB = BasicBlock::Create(F->getContext(),
                                                     "lookupfp", FuncWrapper);
 
           // Check to see if we already looked up the value.
           Value *CachedVal = new LoadInst(Cache, "fpcache", EntryBB);
-          Value *IsNull = new ICmpInst(*EntryBB, ICmpInst::ICMP_EQ, CachedVal,
+          Value *IsNull = new ICmpInst(*EntryBB, Predicate::ICMP_EQ, CachedVal,
                                        NullPtr, "isNull");
           BranchInst::Create(LookupBB, DoCallBB, IsNull, EntryBB);
 
           // Resolve the call to function F via the JIT API:
           //
           // call resolver(GetElementPtr...)
           CallInst *Resolver =
             CallInst::Create(resolverFunc, ResolverArgs, "resolver", LookupBB);

tools/llvm-stress/llvm-stress.cpp

struct CmpModifier: public Modifier {
   void Act() override {
 
     Value *Val0 = getRandomVal();
     Value *Val1 = getRandomValue(Val0->getType());
 
     if (Val0->getType()->isPointerTy()) return;
     bool fp = Val0->getType()->getScalarType()->isFloatingPointTy();
 
-    int op;
+    unsigned op;
     if (fp) {
-      op = Ran->Rand() %
-      (CmpInst::LAST_FCMP_PREDICATE - CmpInst::FIRST_FCMP_PREDICATE) +
-       CmpInst::FIRST_FCMP_PREDICATE;
+      op = Ran->Rand() % (Predicate::LAST_FCMP_PREDICATE -
+                          Predicate::FIRST_FCMP_PREDICATE) +
+           Predicate::FIRST_FCMP_PREDICATE;
     } else {
-      op = Ran->Rand() %
-      (CmpInst::LAST_ICMP_PREDICATE - CmpInst::FIRST_ICMP_PREDICATE) +
-       CmpInst::FIRST_ICMP_PREDICATE;
+      op = Ran->Rand() % (Predicate::LAST_ICMP_PREDICATE -
+                          Predicate::FIRST_ICMP_PREDICATE) +
+           Predicate::FIRST_ICMP_PREDICATE;
     }
 
-    Value *V = CmpInst::Create(fp ? Instruction::FCmp : Instruction::ICmp,
-                               (CmpInst::Predicate)op, Val0, Val1, "Cmp",
-                               BB->getTerminator());
+    Value *V =
+        CmpInst::Create(fp ? Instruction::FCmp : Instruction::ICmp,
+                        Predicate{op}, Val0, Val1, "Cmp", BB->getTerminator());
     return PT->push_back(V);
   }
 };
 
 } // end anonymous namespace
 
 static void FillFunction(Function *F, Random &R) {
   // Create a legal entry block.

unittests/IR/ConstantRangeTest.cpp

EXPECT_EQ(Some.lshr(Some), ConstantRange(APInt(16, 0),
                                            APInt(16, (0xaaa >> 0xa) + 1)));
   EXPECT_EQ(Some.lshr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
   EXPECT_EQ(Wrap.lshr(Wrap), Full);
 }
 
 TEST(ConstantRange, MakeAllowedICmpRegion) {
   // PR8250
   ConstantRange SMax = ConstantRange(APInt::getSignedMaxValue(32));
-  EXPECT_TRUE(ConstantRange::makeAllowedICmpRegion(ICmpInst::ICMP_SGT, SMax)
+  EXPECT_TRUE(ConstantRange::makeAllowedICmpRegion(Predicate::ICMP_SGT, SMax)
                   .isEmptySet());
 }
 
 TEST(ConstantRange, MakeSatisfyingICmpRegion) {
   ConstantRange LowHalf(APInt(8, 0), APInt(8, 128));
   ConstantRange HighHalf(APInt(8, 128), APInt(8, 0));
   ConstantRange EmptySet(8, /* isFullSet = */ false);
 
-  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_NE, LowHalf),
-            HighHalf);
+  EXPECT_EQ(
+      ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_NE, LowHalf),
 
   EXPECT_EQ(
-      ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_NE, HighHalf),
+      ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_NE, HighHalf),
       LowHalf);
 
-  EXPECT_TRUE(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_EQ,
-                                                      HighHalf).isEmptySet());
+  EXPECT_TRUE(
+      ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_EQ, HighHalf)
+          .isEmptySet());
 
   ConstantRange UnsignedSample(APInt(8, 5), APInt(8, 200));
 
-  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_ULT,
+  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_ULT,
                                                     UnsignedSample),
             ConstantRange(APInt(8, 0), APInt(8, 5)));
 
-  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_ULE,
+  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_ULE,
                                                     UnsignedSample),
             ConstantRange(APInt(8, 0), APInt(8, 6)));
 
-  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_UGT,
+  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_UGT,
                                                     UnsignedSample),
             ConstantRange(APInt(8, 200), APInt(8, 0)));
 
-  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_UGE,
+  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_UGE,
                                                     UnsignedSample),
             ConstantRange(APInt(8, 199), APInt(8, 0)));
 
   ConstantRange SignedSample(APInt(8, -5), APInt(8, 5));
 
-  EXPECT_EQ(
-      ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SLT, SignedSample),
+  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_SLT,
+                                                    SignedSample),
             ConstantRange(APInt(8, -128), APInt(8, -5)));
 
-  EXPECT_EQ(
-      ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SLE, SignedSample),
+  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_SLE,
+                                                    SignedSample),
             ConstantRange(APInt(8, -128), APInt(8, -4)));
 
-  EXPECT_EQ(
-      ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SGT, SignedSample),
+  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_SGT,
+                                                    SignedSample),
             ConstantRange(APInt(8, 5), APInt(8, -128)));
 
-  EXPECT_EQ(
-      ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SGE, SignedSample),
+  EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(Predicate::ICMP_SGE,
+                                                    SignedSample),
             ConstantRange(APInt(8, 4), APInt(8, -128)));
 }
 
 TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
   const int IntMin4Bits = 8;
   const int IntMax4Bits = 7;
   typedef OverflowingBinaryOperator OBO;
 
   for (int Const : {0, -1, -2, 1, 2, IntMin4Bits, IntMax4Bits}) {
TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
   EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
                 Instruction::Add, MinusOneToOne,
                 OBO::NoUnsignedWrap | OBO::NoSignedWrap),
             ConstantRange(APInt(32, 0), APInt(32, 1)));
 }
 
 TEST(ConstantRange, GetEquivalentICmp) {
   APInt RHS;
-  CmpInst::Predicate Pred;
+  Predicate Pred;
 
   EXPECT_TRUE(ConstantRange(APInt::getMinValue(32), APInt(32, 100))
                   .getEquivalentICmp(Pred, RHS));
-  EXPECT_EQ(Pred, CmpInst::ICMP_ULT);
+  EXPECT_EQ(Pred, Predicate::ICMP_ULT);
   EXPECT_EQ(RHS, APInt(32, 100));
 
   EXPECT_TRUE(ConstantRange(APInt::getSignedMinValue(32), APInt(32, 100))
                   .getEquivalentICmp(Pred, RHS));
-  EXPECT_EQ(Pred, CmpInst::ICMP_SLT);
+  EXPECT_EQ(Pred, Predicate::ICMP_SLT);
   EXPECT_EQ(RHS, APInt(32, 100));
 
   EXPECT_TRUE(ConstantRange(APInt(32, 100), APInt::getMinValue(32))
                   .getEquivalentICmp(Pred, RHS));
-  EXPECT_EQ(Pred, CmpInst::ICMP_UGE);
+  EXPECT_EQ(Pred, Predicate::ICMP_UGE);
   EXPECT_EQ(RHS, APInt(32, 100));
 
   EXPECT_TRUE(ConstantRange(APInt(32, 100), APInt::getSignedMinValue(32))
                   .getEquivalentICmp(Pred, RHS));
-  EXPECT_EQ(Pred, CmpInst::ICMP_SGE);
+  EXPECT_EQ(Pred, Predicate::ICMP_SGE);
   EXPECT_EQ(RHS, APInt(32, 100));
 
   EXPECT_TRUE(
       ConstantRange(32, /*isFullSet=*/true).getEquivalentICmp(Pred, RHS));
-  EXPECT_EQ(Pred, CmpInst::ICMP_UGE);
+  EXPECT_EQ(Pred, Predicate::ICMP_UGE);
   EXPECT_EQ(RHS, APInt(32, 0));
 
   EXPECT_TRUE(
       ConstantRange(32, /*isFullSet=*/false).getEquivalentICmp(Pred, RHS));
-  EXPECT_EQ(Pred, CmpInst::ICMP_ULT);
+  EXPECT_EQ(Pred, Predicate::ICMP_ULT);
   EXPECT_EQ(RHS, APInt(32, 0));
 
   EXPECT_FALSE(ConstantRange(APInt(32, 100), APInt(32, 200))
                    .getEquivalentICmp(Pred, RHS));
 
   EXPECT_FALSE(ConstantRange(APInt::getSignedMinValue(32) - APInt(32, 100),
                              APInt::getSignedMinValue(32) + APInt(32, 100))
                    .getEquivalentICmp(Pred, RHS));
 
   EXPECT_FALSE(ConstantRange(APInt::getMinValue(32) - APInt(32, 100),
                              APInt::getMinValue(32) + APInt(32, 100))
                    .getEquivalentICmp(Pred, RHS));
 }
 
 }  // anonymous namespace

unittests/IR/ConstantsTest.cpp

CHECK(ConstantExpr::getFPTrunc(P2, FloatTy), "fptrunc double " P2STR
         " to float");
   CHECK(ConstantExpr::getFPExtend(P1, DoubleTy), "fpext float " P1STR
         " to double");
 
   CHECK(ConstantExpr::getExactUDiv(P0, P0), "udiv exact i32 " P0STR ", " P0STR);
 
   CHECK(ConstantExpr::getSelect(P3, P0, P4), "select i1 " P3STR ", i32 " P0STR
         ", i32 " P4STR);
-  CHECK(ConstantExpr::getICmp(CmpInst::ICMP_EQ, P0, P4), "icmp eq i32 " P0STR
-        ", " P4STR);
-  CHECK(ConstantExpr::getFCmp(CmpInst::FCMP_ULT, P1, P5), "fcmp ult float "
-        P1STR ", " P5STR);
+  CHECK(ConstantExpr::getICmp(Predicate::ICMP_EQ, P0, P4),
+        "icmp eq i32 " P0STR ", " P4STR);
+  CHECK(ConstantExpr::getFCmp(Predicate::FCMP_ULT, P1, P5),
+        "fcmp ult float " P1STR ", " P5STR);
 
   std::vector<Constant*> V;
   V.push_back(One);
   // FIXME: getGetElementPtr() actually creates an inbounds ConstantGEP,
   //        not a normal one!
   //CHECK(ConstantExpr::getGetElementPtr(Global, V, false),
   //      "getelementptr i32*, i32** @dummy, i32 1");
   CHECK(ConstantExpr::getInBoundsGetElementPtr(PointerType::getUnqual(Int32Ty),

unittests/IR/InstructionsTest.cpp

TEST(InstructionsTest, VectorGep) {
   std::vector<Constant*> ConstVa(2, Ci32a);
   std::vector<Constant*> ConstVb(2, Ci32b);
   Constant *C2xi32a = ConstantVector::get(ConstVa);
   Constant *C2xi32b = ConstantVector::get(ConstVb);
 
   CastInst *PtrVecA = new IntToPtrInst(C2xi32a, V2xi32PTy);
   CastInst *PtrVecB = new IntToPtrInst(C2xi32b, V2xi32PTy);
 
-  ICmpInst *ICmp0 = new ICmpInst(ICmpInst::ICMP_SGT, PtrVecA, PtrVecB);
-  ICmpInst *ICmp1 = new ICmpInst(ICmpInst::ICMP_ULT, PtrVecA, PtrVecB);
+  ICmpInst *ICmp0 = new ICmpInst(Predicate::ICMP_SGT, PtrVecA, PtrVecB);
+  ICmpInst *ICmp1 = new ICmpInst(Predicate::ICMP_ULT, PtrVecA, PtrVecB);
   EXPECT_NE(ICmp0, ICmp1); // suppress warning.
 
   BasicBlock* BB0 = BasicBlock::Create(C);
   // Test InsertAtEnd ICmpInst constructor.
-  ICmpInst *ICmp2 = new ICmpInst(*BB0, ICmpInst::ICMP_SGE, PtrVecA, PtrVecB);
+  ICmpInst *ICmp2 = new ICmpInst(*BB0, Predicate::ICMP_SGE, PtrVecA, PtrVecB);
   EXPECT_NE(ICmp0, ICmp2); // suppress warning.
 
   GetElementPtrInst *Gep0 = GetElementPtrInst::Create(I32Ty, PtrVecA, C2xi32a);
   GetElementPtrInst *Gep1 = GetElementPtrInst::Create(I32Ty, PtrVecA, C2xi32b);
   GetElementPtrInst *Gep2 = GetElementPtrInst::Create(I32Ty, PtrVecB, C2xi32a);
   GetElementPtrInst *Gep3 = GetElementPtrInst::Create(I32Ty, PtrVecB, C2xi32b);
 
   CastInst *BTC0 = new BitCastInst(Gep0, V2xi8PTy);