IR: introduce ICmpInst::PredicateSign

Introduce CmpInst::PredicateSign, an abstraction over a floating-point
predicate, and a pack of an integer predicate with samesign information,
in order to ease extending large portions of the codebase that take a
CmpInst::Predicate to respect the samesign flag.

We have chosen to demonstrate the utility of this new abstraction by
migrating ValueTracking, InstructionSimplify, and InstCombine from
CmpInst::Predicate to CmpInst::PredicateSign. There should be no
functional changes, as we don't perform any extra optimizations with
samesign in this patch.

The design approach taken by this patch allows for unaudited callers of
APIs that take a CmpInst::PredicateSign to silently drop the samesign
information; it does not pose a correctness issue, and allows us to
migrate the codebase piece-wise.

Author: artagnon

llvm/include/llvm/Analysis/InstructionSimplify.h

@@ -152,12 +152,12 @@ Value *simplifyOrInst(Value *LHS, Value *RHS, const SimplifyQuery &Q);
 Value *simplifyXorInst(Value *LHS, Value *RHS, const SimplifyQuery &Q);
 
 /// Given operands for an ICmpInst, fold the result or return null.
-Value *simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
+Value *simplifyICmpInst(CmpInst::PredicateSign Pred, Value *LHS, Value *RHS,
                         const SimplifyQuery &Q);
 
 /// Given operands for an FCmpInst, fold the result or return null.
-Value *simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
-                        FastMathFlags FMF, const SimplifyQuery &Q);
+Value *simplifyFCmpInst(CmpInst::PredicateSign Predicate, Value *LHS,
+                        Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q);
 
 /// Given operands for a SelectInst, fold the result or return null.
 Value *simplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
@@ -200,7 +200,7 @@ Value *simplifyShuffleVectorInst(Value *Op0, Value *Op1, ArrayRef<int> Mask,
 //=== 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(CmpInst::PredicateSign Predicate, Value *LHS, Value *RHS,
                        const SimplifyQuery &Q);
 
 /// Given operand for a UnaryOperator, fold the result or return null.

llvm/include/llvm/Analysis/ValueTracking.h

@@ -1246,7 +1246,7 @@ std::optional<bool> isImpliedCondition(const Value *LHS, const Value *RHS,
                                        bool LHSIsTrue = true,
                                        unsigned Depth = 0);
 std::optional<bool> isImpliedCondition(const Value *LHS,
-                                       CmpInst::Predicate RHSPred,
+                                       CmpInst::PredicateSign RHSPred,
                                        const Value *RHSOp0, const Value *RHSOp1,
                                        const DataLayout &DL,
                                        bool LHSIsTrue = true,
@@ -1257,7 +1257,7 @@ std::optional<bool> isImpliedCondition(const Value *LHS,
 std::optional<bool> isImpliedByDomCondition(const Value *Cond,
                                             const Instruction *ContextI,
                                             const DataLayout &DL);
-std::optional<bool> isImpliedByDomCondition(CmpInst::Predicate Pred,
+std::optional<bool> isImpliedByDomCondition(CmpInst::PredicateSign Pred,
                                             const Value *LHS, const Value *RHS,
                                             const Instruction *ContextI,
                                             const DataLayout &DL);

llvm/include/llvm/IR/InstrTypes.h

@@ -722,6 +722,31 @@ class CmpInst : public Instruction {
                               force_iteration_on_noniterable_enum);
   }
 
+  /// An abstraction over a floating-point predicate, and a pack of an integer
+  /// predicate with samesign information. The getPredicateSign() family of
+  /// functions in ICmpInst construct and return this type. It is also implictly
+  /// constructed with a Predicate, dropping samesign information.
+  class PredicateSign {
+    Predicate Pred;
+    std::optional<bool> HasSameSign;
+
+  public:
+    PredicateSign(Predicate Pred, bool HasSameSign)
+        : Pred(Pred), HasSameSign(HasSameSign) {}
+
+    PredicateSign(Predicate Pred) : Pred(Pred) {
+      if (isIntPredicate(Pred))
+        HasSameSign = false;
+    }
+
+    operator Predicate() { return Pred; }
+
+    bool hasSameSign() {
+      assert(isIntPredicate(Pred) && HasSameSign);
+      return *HasSameSign;
+    }
+  };
+
 protected:
   CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, Value *LHS,
           Value *RHS, const Twine &Name = "",

llvm/include/llvm/IR/Instructions.h

@@ -1203,6 +1203,18 @@ class ICmpInst: public CmpInst {
 #endif
   }
 
+  PredicateSign getPredicateSign() const {
+    return {getPredicate(), hasSameSign()};
+  }
+
+  PredicateSign getInversePredicateSign() const {
+    return {getInversePredicate(), hasSameSign()};
+  }
+
+  PredicateSign getSwappedPredicateSign() const {
+    return {getSwappedPredicate(), hasSameSign()};
+  }
+
   void setSameSign(bool B = true) {
     SubclassOptionalData = (SubclassOptionalData & ~SameSign) | (B * SameSign);
   }

llvm/include/llvm/Transforms/InstCombine/InstCombiner.h

@@ -157,7 +157,7 @@ class LLVM_LIBRARY_VISIBILITY InstCombiner {
   /// conditional branch or select to create a compare with a canonical
   /// (inverted) predicate which is then more likely to be matched with other
   /// values.
-  static bool isCanonicalPredicate(CmpInst::Predicate Pred) {
+  static bool isCanonicalPredicate(CmpInst::PredicateSign Pred) {
     switch (Pred) {
     case CmpInst::ICMP_NE:
     case CmpInst::ICMP_ULE:
@@ -185,11 +185,12 @@ class LLVM_LIBRARY_VISIBILITY InstCombiner {
   }
 
   std::optional<std::pair<
-      CmpInst::Predicate,
-      Constant *>> static getFlippedStrictnessPredicateAndConstant(CmpInst::
-                                                                       Predicate
-                                                                           Pred,
-                                                                   Constant *C);
+      CmpInst::PredicateSign,
+      Constant
+          *>> static getFlippedStrictnessPredicateAndConstant(CmpInst::
+                                                                  PredicateSign
+                                                                      Pred,
+                                                              Constant *C);
 
   static bool shouldAvoidAbsorbingNotIntoSelect(const SelectInst &SI) {
     // a ? b : false and a ? true : b are the canonical form of logical and/or.