PatternMatch, CmpPredicate: address review

Author: artagnon

llvm/include/llvm/IR/CmpPredicate.h

@@ -62,12 +62,11 @@ class CmpPredicate {
   bool operator==(CmpPredicate) const = delete;
   bool operator!=(CmpPredicate) const = delete;
 
-  /// TypeSwitch over the CmpInst and either do ICmpInst::getCmpPredicate() or
-  /// FCmpInst::getPredicate().
+  /// Do a ICmpInst::getCmpPredicate() or CmpInst::getPredicate(), as
+  /// appropriate.
   static CmpPredicate get(const CmpInst *Cmp);
 
-  /// Get the swapped predicate of a CmpPredicate, using
-  /// CmpInst::isIntPredicate().
+  /// Get the swapped predicate of a CmpPredicate.
   static CmpPredicate getSwapped(CmpPredicate P);
 
   /// Get the swapped predicate of a CmpInst.

llvm/include/llvm/IR/PatternMatch.h

@@ -695,7 +695,7 @@ struct icmp_pred_with_threshold {
 /// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
 /// to Threshold. For vectors, this includes constants with undefined elements.
 inline cst_pred_ty<icmp_pred_with_threshold>
-m_SpecificInt_ICMP(CmpPredicate Predicate, const APInt &Threshold) {
+m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold) {
   cst_pred_ty<icmp_pred_with_threshold> P;
   P.Pred = Predicate;
   P.Thr = &Threshold;

llvm/lib/IR/Instructions.cpp

@@ -16,7 +16,6 @@
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
@@ -3934,15 +3933,13 @@ std::optional<CmpPredicate> CmpPredicate::getMatching(CmpPredicate A,
 }
 
 CmpPredicate CmpPredicate::get(const CmpInst *Cmp) {
-  return TypeSwitch<const CmpInst *, CmpPredicate>(Cmp)
-      .Case<ICmpInst>([](auto *ICI) { return ICI->getCmpPredicate(); })
-      .Case<FCmpInst>([](auto *FCI) { return FCI->getPredicate(); });
+  if (auto *ICI = dyn_cast<ICmpInst>(Cmp))
+    return ICI->getCmpPredicate();
+  return Cmp->getPredicate();
 }
 
 CmpPredicate CmpPredicate::getSwapped(CmpPredicate P) {
-  return CmpInst::isIntPredicate(P)
-             ? ICmpInst::getSwappedCmpPredicate(P)
-             : CmpPredicate{CmpInst::getSwappedPredicate(P)};
+  return {CmpInst::getSwappedPredicate(P), P.hasSameSign()};
 }
 
 CmpPredicate CmpPredicate::getSwapped(const CmpInst *Cmp) {