CmpInst: merge functions; address review

Author: artagnon

llvm/include/llvm/IR/InstrTypes.h

@@ -912,15 +912,11 @@ class CmpInst : public Instruction {
   /// Determine if this is an equals/not equals predicate.
   bool isEquality() const { return isEquality(getPredicate()); }
 
-  /// Determine if this is an equals predicate that is also an equivalence. This
-  /// is useful in GVN-like transformations, where we can replace RHS by LHS in
-  /// the true branch of the CmpInst.
-  bool isEqEquivalence() const;
-
-  /// Determine if this is a not-equals predicate that is also an equivalence.
-  /// This is useful in GVN-like transformations, where we can replace RHS by
-  /// LHS in the false branch of the CmpInst.
-  bool isNeEquivalence() const;
+  /// Determine if one operand of this compare can always be replaced by the
+  /// other operand, ignoring provenance considerations. If \p Invert is false,
+  /// check for equivalence with an equals predicate; otherwise, check for
+  /// equivalence with a not-equals predicate.
+  bool isEquivalence(bool Invert = false) const;
 
   /// Return true if the predicate is relational (not EQ or NE).
   static bool isRelational(Predicate P) { return !isEquality(P); }

llvm/lib/IR/Instructions.cpp

@@ -3487,34 +3487,24 @@ static bool hasNonZeroFPOperands(const CmpInst *Cmp) {
 // Floating-point equality is not an equivalence when comparing +0.0 with
 // -0.0, when comparing NaN with another value, or when flushing
 // denormals-to-zero.
-bool CmpInst::isEqEquivalence() const {
+bool CmpInst::isEquivalence(bool Invert) const {
   switch (getPredicate()) {
   case CmpInst::Predicate::ICMP_EQ:
-    return true;
+    return !Invert;
+  case CmpInst::Predicate::ICMP_NE:
+    return Invert;
   case CmpInst::Predicate::FCMP_UEQ:
     if (!hasNoNaNs())
       return false;
     [[fallthrough]];
   case CmpInst::Predicate::FCMP_OEQ:
-    return hasNonZeroFPOperands(this);
-  default:
-    return false;
-  }
-}
-
-// Floating-point equality is not an equivalence when comparing +0.0 with
-// -0.0, when comparing NaN with another value, or when flushing
-// denormals-to-zero.
-bool CmpInst::isNeEquivalence() const {
-  switch (getPredicate()) {
-  case CmpInst::Predicate::ICMP_NE:
-    return true;
+    return !Invert && hasNonZeroFPOperands(this);
   case CmpInst::Predicate::FCMP_ONE:
     if (!hasNoNaNs())
       return false;
     [[fallthrough]];
   case CmpInst::Predicate::FCMP_UNE:
-    return hasNonZeroFPOperands(this);
+    return Invert && hasNonZeroFPOperands(this);
   default:
     return false;
   }

llvm/lib/Transforms/Scalar/GVN.cpp

@@ -2090,7 +2090,7 @@ bool GVNPass::processAssumeIntrinsic(AssumeInst *IntrinsicI) {
   // call void @llvm.assume(i1 %cmp)
   // ret float %load ; will change it to ret float %0
   if (auto *CmpI = dyn_cast<CmpInst>(V)) {
-    if (CmpI->isEqEquivalence()) {
+    if (CmpI->isEquivalence()) {
       Value *CmpLHS = CmpI->getOperand(0);
       Value *CmpRHS = CmpI->getOperand(1);
       // Heuristically pick the better replacement -- the choice of heuristic
@@ -2514,8 +2514,8 @@ bool GVNPass::propagateEquality(Value *LHS, Value *RHS,
       // If "A == B" is known true, or "A != B" is known false, then replace
       // A with B everywhere in the scope.  For floating point operations, we
       // have to be careful since equality does not always imply equivalance.
-      if ((isKnownTrue && Cmp->isEqEquivalence()) ||
-          (isKnownFalse && Cmp->isNeEquivalence()))
+      if ((isKnownTrue && Cmp->isEquivalence()) ||
+          (isKnownFalse && Cmp->isEquivalence(/* Invert = */ true)))
         Worklist.push_back(std::make_pair(Op0, Op1));
 
       // If "A >= B" is known true, replace "A < B" with false everywhere.