[llvm] [ADT] Factor PatternMatch m_Combine(And|Or), m_Isa (NFC) (PR #190753)

Ramkumar Ramachandra via llvm-commits llvm-commits at lists.llvm.org
Thu Apr 9 03:06:20 PDT 2026


https://github.com/artagnon updated https://github.com/llvm/llvm-project/pull/190753

>From e5e933c5adca1c5c395a51a4b5c1e3245829ed24 Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <artagnon at tenstorrent.com>
Date: Tue, 7 Apr 2026 09:39:55 +0100
Subject: [PATCH 1/2] [VPlan] Generalize m_Combine(And|Or) to variadic (NFC)

---
 .../Transforms/Vectorize/VPlanPatternMatch.h  | 49 ++++++++-----------
 1 file changed, 20 insertions(+), 29 deletions(-)

diff --git a/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h b/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
index 2ce012c5a9f10..e2f2899210425 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
@@ -232,38 +232,36 @@ inline match_poison m_Poison() { return match_poison(); }
 inline bind_const_int m_ConstantInt(uint64_t &C) { return C; }
 
 /// Matching combinators
-template <typename LTy, typename RTy> struct match_combine_or {
-  LTy L;
-  RTy R;
+template <typename... Ty> struct match_combine_or {
+  std::tuple<Ty...> Ps;
 
-  match_combine_or(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
+  match_combine_or(const Ty &...Ps) : Ps(Ps...) {}
 
   template <typename ITy> bool match(ITy *V) const {
-    return L.match(V) || R.match(V);
+    return std::apply([V](auto &&...Ps) { return (Ps.match(V) || ...); }, Ps);
   }
 };
 
-template <typename LTy, typename RTy> struct match_combine_and {
-  LTy L;
-  RTy R;
+template <typename... Ty> struct match_combine_and {
+  std::tuple<Ty...> Ps;
 
-  match_combine_and(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
+  match_combine_and(const Ty &...Ps) : Ps(Ps...) {}
 
   template <typename ITy> bool match(ITy *V) const {
-    return L.match(V) && R.match(V);
+    return std::apply([V](auto &&...Ps) { return (Ps.match(V) && ...); }, Ps);
   }
 };
 
-/// Combine two pattern matchers matching L || R
-template <typename LTy, typename RTy>
-inline match_combine_or<LTy, RTy> m_CombineOr(const LTy &L, const RTy &R) {
-  return match_combine_or<LTy, RTy>(L, R);
+/// Combine two pattern matchers matching any of Ps patterns.
+template <typename... Ty>
+inline match_combine_or<Ty...> m_CombineOr(const Ty &...Ps) {
+  return {Ps...};
 }
 
-/// Combine two pattern matchers matching L && R
-template <typename LTy, typename RTy>
-inline match_combine_and<LTy, RTy> m_CombineAnd(const LTy &L, const RTy &R) {
-  return match_combine_and<LTy, RTy>(L, R);
+/// Combine two pattern matchers matching all of Ps patterns.
+template <typename... Ty>
+inline match_combine_and<Ty...> m_CombineAnd(const Ty &...Ps) {
+  return {Ps...};
 }
 
 /// Match a VPValue, capturing it if we match.
@@ -619,13 +617,8 @@ m_ZExtOrSelf(const Op0_t &Op0) {
   return m_CombineOr(m_ZExt(Op0), Op0);
 }
 
-template <typename Op0_t>
-inline match_combine_or<
-    match_combine_or<AllRecipe_match<Instruction::ZExt, Op0_t>,
-                     AllRecipe_match<Instruction::Trunc, Op0_t>>,
-    Op0_t>
-m_ZExtOrTruncOrSelf(const Op0_t &Op0) {
-  return m_CombineOr(m_CombineOr(m_ZExt(Op0), m_Trunc(Op0)), Op0);
+template <typename Op0_t> inline auto m_ZExtOrTruncOrSelf(const Op0_t &Op0) {
+  return m_CombineOr(m_ZExt(Op0), m_Trunc(Op0), Op0);
 }
 
 template <unsigned Opcode, typename Op0_t, typename Op1_t>
@@ -821,10 +814,8 @@ inline auto m_GetElementPtr(const Op0_t &Op0, const Op1_t &Op1) {
       Recipe_match<std::tuple<Op0_t, Op1_t>, Instruction::GetElementPtr,
                    /*Commutative*/ false, VPReplicateRecipe, VPWidenGEPRecipe>(
           Op0, Op1),
-      m_CombineOr(
-          VPInstruction_match<VPInstruction::PtrAdd, Op0_t, Op1_t>(Op0, Op1),
-          VPInstruction_match<VPInstruction::WidePtrAdd, Op0_t, Op1_t>(Op0,
-                                                                       Op1)));
+      VPInstruction_match<VPInstruction::PtrAdd, Op0_t, Op1_t>(Op0, Op1),
+      VPInstruction_match<VPInstruction::WidePtrAdd, Op0_t, Op1_t>(Op0, Op1));
 }
 
 template <typename Op0_t, typename Op1_t, typename Op2_t>

>From 6b629eaf44840ba8bb76608d1287882df57f5bdb Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <artagnon at tenstorrent.com>
Date: Thu, 9 Apr 2026 10:37:07 +0100
Subject: [PATCH 2/2] [ADT] Factor PatternMatch m_Combine(And|Or), m_Isa

Introduce a new PatternMatchHelpers with a variant of m_Combine(And|Or)
and m_Isa to share across the IR PatternMatch,
ScalarEvolutionPatternMatch, and VPlanPatternMatch. m_Combine(And|Or)
has been generalized to be variadic.
---
 llvm/include/llvm/ADT/PatternMatchHelpers.h   |  69 +++++++++++
 .../Analysis/ScalarEvolutionPatternMatch.h    |  25 ++--
 llvm/include/llvm/IR/PatternMatch.h           | 116 ++++--------------
 .../Transforms/InstCombine/InstCombiner.h     |   8 +-
 .../Transforms/Vectorize/VPlanPatternMatch.h  |  53 +-------
 5 files changed, 107 insertions(+), 164 deletions(-)
 create mode 100644 llvm/include/llvm/ADT/PatternMatchHelpers.h

diff --git a/llvm/include/llvm/ADT/PatternMatchHelpers.h b/llvm/include/llvm/ADT/PatternMatchHelpers.h
new file mode 100644
index 0000000000000..b21edd34b194b
--- /dev/null
+++ b/llvm/include/llvm/ADT/PatternMatchHelpers.h
@@ -0,0 +1,69 @@
+//===- PatternMatchHelpers.h - Helpers for PatternMatch -------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides helpers that are used across the IR PatternMatch,
+// ScalarEvolutionPatternMatch, and VPlanPatternMatch.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_PATTERNMATCHHELPERS_H
+#define LLVM_ADT_PATTERNMATCHHELPERS_H
+
+#include "llvm/Support/Casting.h"
+#include <tuple>
+
+namespace llvm::PatternMatchHelpers {
+/// Matching or combinator.
+template <typename... Ty> struct match_combine_or { // NOLINT
+  std::tuple<Ty...> Ps;
+  match_combine_or(const Ty &...Ps) : Ps(Ps...) {}
+  template <typename ITy> bool match(ITy *V) const {
+    return std::apply([V](auto &&...Ps) { return (Ps.match(V) || ...); }, Ps);
+  }
+};
+
+/// Matching and combinator.
+template <typename... Ty> struct match_combine_and { // NOLINT
+  std::tuple<Ty...> Ps;
+  match_combine_and(const Ty &...Ps) : Ps(Ps...) {}
+  template <typename ITy> bool match(ITy *V) const {
+    return std::apply([V](auto &&...Ps) { return (Ps.match(V) && ...); }, Ps);
+  }
+};
+
+/// Combine two pattern matchers matching any of Ps patterns.
+template <typename... Ty>
+inline match_combine_or<Ty...> m_CombineOr(const Ty &...Ps) { // NOLINT
+  return {Ps...};
+}
+
+/// Combine two pattern matchers matching all of Ps patterns.
+template <typename... Ty>
+inline match_combine_and<Ty...> m_CombineAnd(const Ty &...Ps) { // NOLINT
+  return {Ps...};
+}
+
+/// A match-wrapper around isa.
+template <typename... To> struct match_isa { // NOLINT
+  template <typename ArgTy> bool match(const ArgTy *V) const {
+    return isa<To...>(V);
+  }
+};
+
+template <typename... To> inline match_isa<To...> m_Isa() { // NOLINT
+  return match_isa<To...>();
+}
+
+/// A variant of m_Isa that also matches SubPattern.
+template <typename... To, typename SubPattern>
+inline auto m_Isa(const SubPattern &P) { // NOLINT
+  return m_CombineAnd(m_Isa<To...>(), P);
+}
+} // namespace llvm::PatternMatchHelpers
+
+#endif
diff --git a/llvm/include/llvm/Analysis/ScalarEvolutionPatternMatch.h b/llvm/include/llvm/Analysis/ScalarEvolutionPatternMatch.h
index 7b045e150c76b..7db4401d3cd0e 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolutionPatternMatch.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolutionPatternMatch.h
@@ -13,9 +13,12 @@
 #ifndef LLVM_ANALYSIS_SCALAREVOLUTIONPATTERNMATCH_H
 #define LLVM_ANALYSIS_SCALAREVOLUTIONPATTERNMATCH_H
 
+#include "llvm/ADT/PatternMatchHelpers.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 
+using namespace llvm::PatternMatchHelpers;
+
 namespace llvm {
 namespace SCEVPatternMatch {
 
@@ -62,17 +65,9 @@ inline cst_pred_ty<is_all_ones> m_scev_AllOnes() {
   return cst_pred_ty<is_all_ones>();
 }
 
-template <typename Class> struct class_match {
-  template <typename ITy> bool match(ITy *V) const { return isa<Class>(V); }
-};
-
-inline class_match<const SCEV> m_SCEV() { return class_match<const SCEV>(); }
-inline class_match<const SCEVConstant> m_SCEVConstant() {
-  return class_match<const SCEVConstant>();
-}
-inline class_match<const SCEVVScale> m_SCEVVScale() {
-  return class_match<const SCEVVScale>();
-}
+inline auto m_SCEV() { return m_Isa<const SCEV>(); }
+inline auto m_SCEVConstant() { return m_Isa<const SCEVConstant>(); }
+inline auto m_SCEVVScale() { return m_Isa<const SCEVVScale>(); }
 
 template <typename Class> struct bind_ty {
   Class *&VR;
@@ -368,7 +363,7 @@ inline SCEVURem_match<Op0_t, Op1_t> m_scev_URem(Op0_t LHS, Op1_t RHS,
   return SCEVURem_match<Op0_t, Op1_t>(LHS, RHS, SE);
 }
 
-inline class_match<const Loop> m_Loop() { return class_match<const Loop>(); }
+inline auto m_Loop() { return m_Isa<const Loop>(); }
 
 /// Match an affine SCEVAddRecExpr.
 template <typename Op0_t, typename Op1_t, typename Loop_t>
@@ -398,10 +393,10 @@ inline specificloop_ty m_SpecificLoop(const Loop *L) { return L; }
 inline bind_ty<const Loop> m_Loop(const Loop *&L) { return L; }
 
 template <typename Op0_t, typename Op1_t>
-inline SCEVAffineAddRec_match<Op0_t, Op1_t, class_match<const Loop>>
+inline SCEVAffineAddRec_match<Op0_t, Op1_t, match_isa<const Loop>>
 m_scev_AffineAddRec(const Op0_t &Op0, const Op1_t &Op1) {
-  return SCEVAffineAddRec_match<Op0_t, Op1_t, class_match<const Loop>>(
-      Op0, Op1, m_Loop());
+  return SCEVAffineAddRec_match<Op0_t, Op1_t, match_isa<const Loop>>(Op0, Op1,
+                                                                     m_Loop());
 }
 
 template <typename Op0_t, typename Op1_t, typename Loop_t>
diff --git a/llvm/include/llvm/IR/PatternMatch.h b/llvm/include/llvm/IR/PatternMatch.h
index 2160146245137..f64faa6d4b159 100644
--- a/llvm/include/llvm/IR/PatternMatch.h
+++ b/llvm/include/llvm/IR/PatternMatch.h
@@ -30,6 +30,7 @@
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/PatternMatchHelpers.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
@@ -44,6 +45,8 @@
 #include "llvm/Support/Casting.h"
 #include <cstdint>
 
+using namespace llvm::PatternMatchHelpers;
+
 namespace llvm {
 namespace PatternMatch {
 
@@ -128,30 +131,20 @@ m_NoSignedZeros(const T &SubPattern) {
   return SubPattern;
 }
 
-template <typename Class> struct class_match {
-  template <typename ITy> bool match(ITy *V) const { return isa<Class>(V); }
-};
-
 /// Match an arbitrary value and ignore it.
-inline class_match<Value> m_Value() { return class_match<Value>(); }
+inline auto m_Value() { return m_Isa<Value>(); }
 
 /// Match an arbitrary unary operation and ignore it.
-inline class_match<UnaryOperator> m_UnOp() {
-  return class_match<UnaryOperator>();
-}
+inline auto m_UnOp() { return m_Isa<UnaryOperator>(); }
 
 /// Match an arbitrary binary operation and ignore it.
-inline class_match<BinaryOperator> m_BinOp() {
-  return class_match<BinaryOperator>();
-}
+inline auto m_BinOp() { return m_Isa<BinaryOperator>(); }
 
 /// Matches any compare instruction and ignore it.
-inline class_match<CmpInst> m_Cmp() { return class_match<CmpInst>(); }
+inline auto m_Cmp() { return m_Isa<CmpInst>(); }
 
 /// Matches any intrinsic call and ignore it.
-inline class_match<IntrinsicInst> m_AnyIntrinsic() {
-  return class_match<IntrinsicInst>();
-}
+inline auto m_AnyIntrinsic() { return m_Isa<IntrinsicInst>(); }
 
 struct undef_match {
 private:
@@ -174,27 +167,19 @@ struct undef_match {
 inline auto m_Undef() { return undef_match(); }
 
 /// Match an arbitrary UndefValue constant.
-inline class_match<UndefValue> m_UndefValue() {
-  return class_match<UndefValue>();
-}
+inline auto m_UndefValue() { return m_Isa<UndefValue>(); }
 
 /// Match an arbitrary poison constant.
-inline class_match<PoisonValue> m_Poison() {
-  return class_match<PoisonValue>();
-}
+inline auto m_Poison() { return m_Isa<PoisonValue>(); }
 
 /// Match an arbitrary Constant and ignore it.
-inline class_match<Constant> m_Constant() { return class_match<Constant>(); }
+inline auto m_Constant() { return m_Isa<Constant>(); }
 
 /// Match an arbitrary ConstantInt and ignore it.
-inline class_match<ConstantInt> m_ConstantInt() {
-  return class_match<ConstantInt>();
-}
+inline auto m_ConstantInt() { return m_Isa<ConstantInt>(); }
 
 /// Match an arbitrary ConstantFP and ignore it.
-inline class_match<ConstantFP> m_ConstantFP() {
-  return class_match<ConstantFP>();
-}
+inline auto m_ConstantFP() { return m_Isa<ConstantFP>(); }
 
 struct constantexpr_match {
   template <typename ITy> bool match(ITy *V) const {
@@ -228,9 +213,7 @@ inline Splat_match<T> m_ConstantSplat(const T &SubPattern) {
 }
 
 /// Match an arbitrary basic block value and ignore it.
-inline class_match<BasicBlock> m_BasicBlock() {
-  return class_match<BasicBlock>();
-}
+inline auto m_BasicBlock() { return m_Isa<BasicBlock>(); }
 
 /// Inverting matcher
 template <typename Ty> struct match_unless {
@@ -246,48 +229,6 @@ template <typename Ty> inline match_unless<Ty> m_Unless(const Ty &M) {
   return match_unless<Ty>(M);
 }
 
-/// Matching combinators
-template <typename LTy, typename RTy> struct match_combine_or {
-  LTy L;
-  RTy R;
-
-  match_combine_or(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
-
-  template <typename ITy> bool match(ITy *V) const {
-    if (L.match(V))
-      return true;
-    if (R.match(V))
-      return true;
-    return false;
-  }
-};
-
-template <typename LTy, typename RTy> struct match_combine_and {
-  LTy L;
-  RTy R;
-
-  match_combine_and(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
-
-  template <typename ITy> bool match(ITy *V) const {
-    if (L.match(V))
-      if (R.match(V))
-        return true;
-    return false;
-  }
-};
-
-/// Combine two pattern matchers matching L || R
-template <typename LTy, typename RTy>
-inline match_combine_or<LTy, RTy> m_CombineOr(const LTy &L, const RTy &R) {
-  return match_combine_or<LTy, RTy>(L, R);
-}
-
-/// Combine two pattern matchers matching L && R
-template <typename LTy, typename RTy>
-inline match_combine_and<LTy, RTy> m_CombineAnd(const LTy &L, const RTy &R) {
-  return match_combine_and<LTy, RTy>(L, R);
-}
-
 template <typename APTy> struct ap_match {
   static_assert(std::is_same_v<APTy, APInt> || std::is_same_v<APTy, APFloat>);
   using ConstantTy =
@@ -2369,12 +2310,8 @@ m_ZExtOrSExtOrSelf(const OpTy &Op) {
   return m_CombineOr(m_ZExtOrSExt(Op), Op);
 }
 
-template <typename OpTy>
-inline match_combine_or<match_combine_or<CastInst_match<OpTy, ZExtInst>,
-                                         CastInst_match<OpTy, TruncInst>>,
-                        OpTy>
-m_ZExtOrTruncOrSelf(const OpTy &Op) {
-  return m_CombineOr(m_CombineOr(m_ZExt(Op), m_Trunc(Op)), Op);
+template <typename OpTy> inline auto m_ZExtOrTruncOrSelf(const OpTy &Op) {
+  return m_CombineOr(m_ZExt(Op), m_Trunc(Op), Op);
 }
 
 template <typename CondTy, typename LTy, typename RTy> struct SelectLike_match {
@@ -2654,14 +2591,8 @@ inline MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty> m_UMin(const LHS &L,
 }
 
 template <typename LHS, typename RHS>
-inline match_combine_or<
-    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty>,
-                     MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty>>,
-    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty>,
-                     MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty>>>
-m_MaxOrMin(const LHS &L, const RHS &R) {
-  return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
-                     m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
+inline auto m_MaxOrMin(const LHS &L, const RHS &R) {
+  return m_CombineOr(m_SMax(L, R), m_SMin(L, R), m_UMax(L, R), m_UMin(L, R));
 }
 
 /// Match an 'ordered' floating point maximum function.
@@ -3196,14 +3127,9 @@ m_c_UMax(const LHS &L, const RHS &R) {
 }
 
 template <typename LHS, typename RHS>
-inline match_combine_or<
-    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty, true>,
-                     MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true>>,
-    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty, true>,
-                     MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty, true>>>
-m_c_MaxOrMin(const LHS &L, const RHS &R) {
-  return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
-                     m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
+inline auto m_c_MaxOrMin(const LHS &L, const RHS &R) {
+  return m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R), m_c_UMax(L, R),
+                     m_c_UMin(L, R));
 }
 
 template <Intrinsic::ID IntrID, typename LHS, typename RHS>
diff --git a/llvm/include/llvm/Transforms/InstCombine/InstCombiner.h b/llvm/include/llvm/Transforms/InstCombine/InstCombiner.h
index bc52bf1168d4a..5578422a94c33 100644
--- a/llvm/include/llvm/Transforms/InstCombine/InstCombiner.h
+++ b/llvm/include/llvm/Transforms/InstCombine/InstCombiner.h
@@ -146,9 +146,9 @@ class LLVM_LIBRARY_VISIBILITY InstCombiner {
     if (isa<Constant>(V))
       return isa<UndefValue>(V) ? 0 : 1;
 
-    if (isa<CastInst>(V) || match(V, m_Neg(PatternMatch::m_Value())) ||
-        match(V, m_Not(PatternMatch::m_Value())) ||
-        match(V, m_FNeg(PatternMatch::m_Value())))
+    using namespace llvm::PatternMatch;
+    if (isa<CastInst>(V) || match(V, m_Neg(m_Value())) ||
+        match(V, m_Not(m_Value())) || match(V, m_FNeg(m_Value())))
       return 2;
 
     return 3;
@@ -262,7 +262,7 @@ class LLVM_LIBRARY_VISIBILITY InstCombiner {
         break; // Free to invert by swapping true/false values/destinations.
       case Instruction::Xor: // Can invert 'xor' if it's a 'not', by ignoring
                              // it.
-        if (!match(I, m_Not(PatternMatch::m_Value())))
+        if (!match(I, PatternMatch::m_Not(PatternMatch::m_Value())))
           return false; // Not a 'not'.
         break;
       default:
diff --git a/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h b/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
index e2f2899210425..a449282dba601 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
@@ -16,6 +16,9 @@
 #define LLVM_TRANSFORM_VECTORIZE_VPLANPATTERNMATCH_H
 
 #include "VPlan.h"
+#include "llvm/ADT/PatternMatchHelpers.h"
+
+using namespace llvm::PatternMatchHelpers;
 
 namespace llvm::VPlanPatternMatch {
 
@@ -43,17 +46,6 @@ template <typename Pattern> bool match(VPSingleDefRecipe *R, const Pattern &P) {
   return P.match(static_cast<const VPRecipeBase *>(R));
 }
 
-/// A match-wrapper around isa.
-template <typename... To> struct match_isapred {
-  template <typename ArgTy> bool match(const ArgTy *V) const {
-    return isa<To...>(V);
-  }
-};
-
-template <typename... To> inline match_isapred<To...> m_Isa() {
-  return match_isapred<To...>();
-}
-
 /// Match an arbitrary VPValue and ignore it.
 inline auto m_VPValue() { return m_Isa<VPValue>(); }
 
@@ -231,39 +223,6 @@ inline match_poison m_Poison() { return match_poison(); }
 /// match.
 inline bind_const_int m_ConstantInt(uint64_t &C) { return C; }
 
-/// Matching combinators
-template <typename... Ty> struct match_combine_or {
-  std::tuple<Ty...> Ps;
-
-  match_combine_or(const Ty &...Ps) : Ps(Ps...) {}
-
-  template <typename ITy> bool match(ITy *V) const {
-    return std::apply([V](auto &&...Ps) { return (Ps.match(V) || ...); }, Ps);
-  }
-};
-
-template <typename... Ty> struct match_combine_and {
-  std::tuple<Ty...> Ps;
-
-  match_combine_and(const Ty &...Ps) : Ps(Ps...) {}
-
-  template <typename ITy> bool match(ITy *V) const {
-    return std::apply([V](auto &&...Ps) { return (Ps.match(V) && ...); }, Ps);
-  }
-};
-
-/// Combine two pattern matchers matching any of Ps patterns.
-template <typename... Ty>
-inline match_combine_or<Ty...> m_CombineOr(const Ty &...Ps) {
-  return {Ps...};
-}
-
-/// Combine two pattern matchers matching all of Ps patterns.
-template <typename... Ty>
-inline match_combine_and<Ty...> m_CombineAnd(const Ty &...Ps) {
-  return {Ps...};
-}
-
 /// Match a VPValue, capturing it if we match.
 inline bind_ty<VPValue> m_VPValue(VPValue *&V) { return V; }
 
@@ -601,12 +560,6 @@ m_ZExtOrSExt(const Op0_t &Op0) {
   return m_CombineOr(m_ZExt(Op0), m_SExt(Op0));
 }
 
-/// A variant of m_Isa that also matches SubPattern.
-template <typename... To, typename SubPattern>
-inline auto m_Isa(const SubPattern &P) {
-  return m_CombineAnd(m_Isa<To...>(), P);
-}
-
 template <typename Op0_t> inline auto m_WidenAnyExtend(const Op0_t &Op0) {
   return m_Isa<VPWidenCastRecipe>(m_CombineOr(m_ZExtOrSExt(Op0), m_FPExt(Op0)));
 }



More information about the llvm-commits mailing list