Add a new matcher m_ICmpWithPred

[sanjoy]

Summary

This simplifies a later change

[reames]

LGTM

Refactoring some bit of code as part of the patch so that this isn't dead on submission would be a good idea. There should be lots of candidates.

include/llvm/IR/PatternMatch.h

738

Add a comment which clarifies the difference with the previous, it's not obvious.

Something along the lines of:

/ Matches an arbitrary ICmp and binds Pred
.. matcher 1
/ Matches an icmp w/ a specific predicate P
... matcher 2

include/llvm/IR/PatternMatch.h

if (Class *I = dyn_cast<Class>(V))
       if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
         Predicate = I->getPredicate();
         return true;
       }
     return false;
   }
 };
 
+template<typename LHS_t, typename RHS_t, typename Class, typename PredicateTy, PredicateTy P>
+struct CmpClassPred_match {
+  LHS_t L;
+  RHS_t R;
+
+  CmpClassPred_match(const LHS_t &LHS, const RHS_t &RHS)
+    : L(LHS), R(RHS) {}
+
+  template<typename OpTy>
+  bool match(OpTy *V) {
+    PredicateTy Pred;
+    CmpClass_match<LHS_t, RHS_t, Class, PredicateTy> Inner(Pred, L, R);
+    if (Inner.match(V))
+      return Pred == P;
+    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);
 }
 
 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);
 }
 
+template<ICmpInst::Predicate P, typename LHS, typename RHS>
+inline CmpClassPred_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, P>
+m_ICmpWithPred(const LHS &L, const RHS &R) {
+  return CmpClassPred_match<LHS, RHS,
+                            ICmpInst, ICmpInst::Predicate, P>(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);
 }
 
 //===----------------------------------------------------------------------===//
 // Matchers for SelectInst classes