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/InstSimplifyFolder.h

@@ -22,6 +22,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/TargetFolder.h"
+#include "llvm/IR/CmpPredicate.h"
 #include "llvm/IR/IRBuilderFolder.h"
 #include "llvm/IR/Instruction.h"
 

llvm/include/llvm/Analysis/InstructionSimplify.h

@@ -44,6 +44,7 @@ class DataLayout;
 class DominatorTree;
 class Function;
 class Instruction;
+class CmpPredicate;
 class LoadInst;
 struct LoopStandardAnalysisResults;
 class Pass;
@@ -152,11 +153,11 @@ 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(CmpPredicate 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,
+Value *simplifyFCmpInst(CmpPredicate Predicate, Value *LHS, Value *RHS,
                         FastMathFlags FMF, const SimplifyQuery &Q);
 
 /// Given operands for a SelectInst, fold the result or return null.
@@ -200,7 +201,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(CmpPredicate 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

@@ -1245,8 +1245,7 @@ std::optional<bool> isImpliedCondition(const Value *LHS, const Value *RHS,
                                        const DataLayout &DL,
                                        bool LHSIsTrue = true,
                                        unsigned Depth = 0);
-std::optional<bool> isImpliedCondition(const Value *LHS,
-                                       CmpInst::Predicate RHSPred,
+std::optional<bool> isImpliedCondition(const Value *LHS, CmpPredicate RHSPred,
                                        const Value *RHSOp0, const Value *RHSOp1,
                                        const DataLayout &DL,
                                        bool LHSIsTrue = true,
@@ -1257,8 +1256,8 @@ 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,
-                                            const Value *LHS, const Value *RHS,
+std::optional<bool> isImpliedByDomCondition(CmpPredicate Pred, const Value *LHS,
+                                            const Value *RHS,
                                             const Instruction *ContextI,
                                             const DataLayout &DL);
 

llvm/include/llvm/IR/CmpPredicate.h

@@ -0,0 +1,56 @@
+//===- CmpPredicate.h - CmpInst Predicate with samesign information -------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// A CmpInst::Predicate with any samesign information (applicable to ICmpInst).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_CMPPREDICATE_H
+#define LLVM_IR_CMPPREDICATE_H
+
+#include "llvm/IR/InstrTypes.h"
+
+namespace llvm {
+/// An abstraction over a floating-point predicate, and a pack of an integer
+/// predicate with samesign information. Functions in ICmpInst construct and
+/// return this type in place of a Predicate. It is also implictly constructed
+/// with a Predicate, dropping samesign information.
+class CmpPredicate {
+  CmpInst::Predicate Pred;
+  bool HasSameSign;
+
+public:
+  CmpPredicate(CmpInst::Predicate Pred, bool HasSameSign = false)
+      : Pred(Pred), HasSameSign(HasSameSign) {
+    assert(!HasSameSign || CmpInst::isIntPredicate(Pred));
+  }
+
+  inline operator CmpInst::Predicate() const { return Pred; }
+
+  inline bool hasSameSign() const { return HasSameSign; }
+
+  static std::optional<CmpPredicate> getMatching(CmpPredicate A,
+                                                 CmpPredicate B) {
+    if (A.Pred == B.Pred)
+      return A.HasSameSign == B.HasSameSign ? A : CmpPredicate(A.Pred);
+    if (A.HasSameSign &&
+        A.Pred == CmpInst::getFlippedSignednessPredicate(B.Pred))
+      return B.Pred;
+    if (B.HasSameSign &&
+        B.Pred == CmpInst::getFlippedSignednessPredicate(A.Pred))
+      return A.Pred;
+    return {};
+  }
+
+  inline bool operator==(CmpInst::Predicate P) const { return Pred == P; }
+
+  inline bool operator==(CmpPredicate) const = delete;
+};
+} // namespace llvm
+
+#endif

llvm/include/llvm/IR/InstrTypes.h

@@ -728,6 +728,24 @@ class CmpInst : public Instruction {
           InsertPosition InsertBefore = nullptr,
           Instruction *FlagsSource = nullptr);
 
+  /// Return the signed version of the predicate: variant that operates on
+  /// Predicate; used by the corresponding function in ICmpInst, to operate with
+  /// CmpPredicate.
+  static Predicate getSignedPredicate(Predicate Pred);
+
+  /// Return the unsigned version of the predicate: variant that operates on
+  /// Predicate; used by the corresponding function in ICmpInst, to operate with
+  /// CmpPredicate.
+  static Predicate getUnsignedPredicate(Predicate Pred);
+
+  /// Return the unsigned version of the signed predicate pred or the signed
+  /// version of the signed predicate pred: variant that operates on Predicate;
+  /// used by the corresponding function in ICmpInst, to operate with
+  /// CmpPredicate.
+  static Predicate getFlippedSignednessPredicate(Predicate Pred);
+
+  friend class CmpPredicate;
+
 public:
   // allocate space for exactly two operands
   void *operator new(size_t S) { return User::operator new(S, AllocMarker); }

llvm/include/llvm/IR/Instructions.h

@@ -24,6 +24,7 @@
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/CFG.h"
+#include "llvm/IR/CmpPredicate.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GEPNoWrapFlags.h"
@@ -1203,38 +1204,78 @@ class ICmpInst: public CmpInst {
 #endif
   }
 
+  /// @returns the predicate along with samesign information.
+  CmpPredicate getCmpPredicate() const {
+    return {getPredicate(), hasSameSign()};
+  }
+
+  /// @returns the inverse predicate along with samesign information: static
+  /// variant.
+  static CmpPredicate getInverseCmpPredicate(CmpPredicate Pred) {
+    return {getInversePredicate(Pred), Pred.hasSameSign()};
+  }
+
+  /// @returns the inverse predicate along with samesign information.
+  CmpPredicate getInverseCmpPredicate() const {
+    return getInverseCmpPredicate(getCmpPredicate());
+  }
+
+  /// @returns the swapped predicate along with samesign information: static
+  /// variant.
+  static CmpPredicate getSwappedCmpPredicate(CmpPredicate Pred) {
+    return {getSwappedPredicate(Pred), Pred.hasSameSign()};
+  }
+
+  /// @returns the swapped predicate along with samesign information.
+  CmpPredicate getSwappedCmpPredicate() const {
+    return getSwappedPredicate(getCmpPredicate());
+  }
+
   /// 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());
+  /// Return the signed version of the predicate along with samesign
+  /// information.
+  CmpPredicate getSignedPredicate() const {
+    return getSignedPredicate(getCmpPredicate());
   }
 
-  /// Return the signed version of the predicate: static variant.
-  static Predicate getSignedPredicate(Predicate pred);
+  /// Return the signed version of the predicate along with samesign
+  /// information: static variant.
+  static CmpPredicate getSignedPredicate(CmpPredicate Pred) {
+    return {CmpInst::getSignedPredicate(Pred), Pred.hasSameSign()};
+  }
 
   /// 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());
+  /// Return the unsigned version of the predicate along with samesign
+  /// information.
+  CmpPredicate getUnsignedPredicate() const {
+    return getUnsignedPredicate(getCmpPredicate());
   }
 
-  /// Return the unsigned version of the predicate: static variant.
-  static Predicate getUnsignedPredicate(Predicate pred);
+  /// Return the unsigned version of the predicate along with samesign
+  /// information: static variant.
+  static CmpPredicate getUnsignedPredicate(CmpPredicate Pred) {
+    return {CmpInst::getUnsignedPredicate(Pred), Pred.hasSameSign()};
+  }
 
-  /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
+  /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->EQ
   /// @returns the unsigned version of the signed predicate pred or
-  ///          the signed version of the signed predicate pred.
-  static Predicate getFlippedSignednessPredicate(Predicate pred);
+  ///          the signed version of the signed predicate pred, along with
+  ///          samesign information.
+  /// Static variant.
+  static CmpPredicate getFlippedSignednessPredicate(CmpPredicate Pred) {
+    return {CmpInst::getFlippedSignednessPredicate(Pred), Pred.hasSameSign()};
+  }
 
-  /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
+  /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->EQ
   /// @returns the unsigned version of the signed predicate pred or
-  ///          the signed version of the signed predicate pred.
-  Predicate getFlippedSignednessPredicate() const {
-    return getFlippedSignednessPredicate(getPredicate());
+  ///          the signed version of the signed predicate pred, along with
+  ///          samesign information.
+  CmpPredicate getFlippedSignednessPredicate() const {
+    return getFlippedSignednessPredicate(getCmpPredicate());
   }
 
   void setSameSign(bool B = true) {

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(CmpPredicate Pred) {
     switch (Pred) {
     case CmpInst::ICMP_NE:
     case CmpInst::ICMP_ULE:
@@ -185,10 +185,9 @@ class LLVM_LIBRARY_VISIBILITY InstCombiner {
   }
 
   std::optional<std::pair<
-      CmpInst::Predicate,
-      Constant *>> static getFlippedStrictnessPredicateAndConstant(CmpInst::
-                                                                       Predicate
-                                                                           Pred,
+      CmpPredicate,
+      Constant *>> static getFlippedStrictnessPredicateAndConstant(CmpPredicate
+                                                                       Pred,
                                                                    Constant *C);
 
   static bool shouldAvoidAbsorbingNotIntoSelect(const SelectInst &SI) {