Take out most pattern match changes

lukel97 · lukel97 · commit 50ca2e5e181f · 2025-08-06T16:28:59.000+08:00
diff --git a/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h b/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
@@ -195,7 +195,7 @@ inline bind_ty<VPValue> m_VPValue(VPValue *&V) { return V; }
 /// Match a VPInstruction, capturing if we match.
 inline bind_ty<VPInstruction> m_VPInstruction(VPInstruction *&V) { return V; }
 
-template <typename Ops_t, unsigned Opcode, bool Commutative, bool Variadic,
+template <typename Ops_t, unsigned Opcode, bool Commutative,
           typename... RecipeTys>
 struct Recipe_match {
   Ops_t Ops;
@@ -232,9 +232,9 @@ struct Recipe_match {
       return false;
 
     if (R->getNumOperands() != std::tuple_size<Ops_t>::value) {
-      assert(Variadic && "non-variadic recipe with matched opcode does not "
-                         "have the expected number of "
-                         "operands");
+      assert(Opcode == Instruction::PHI &&
+             "non-variadic recipe with matched opcode does not have the "
+             "expected number of operands");
       return false;
     }
 
@@ -259,9 +259,7 @@ struct Recipe_match {
                   std::is_same<RecipeTy, VPCanonicalIVPHIRecipe>::value ||
                   std::is_same<RecipeTy, VPWidenSelectRecipe>::value ||
                   std::is_same<RecipeTy, VPDerivedIVRecipe>::value ||
-                  std::is_same<RecipeTy, VPWidenGEPRecipe>::value ||
-                  std::is_same<RecipeTy, VPWidenPHIRecipe>::value ||
-                  std::is_same<RecipeTy, VPHeaderPHIRecipe>::value)
+                  std::is_same<RecipeTy, VPWidenGEPRecipe>::value)
       return DefR;
     else
       return DefR && DefR->getOpcode() == Opcode;
@@ -277,11 +275,11 @@ struct Recipe_match {
 
 template <unsigned Opcode, typename... RecipeTys>
 using ZeroOpRecipe_match =
-    Recipe_match<std::tuple<>, Opcode, false, false, RecipeTys...>;
+    Recipe_match<std::tuple<>, Opcode, false, RecipeTys...>;
 
 template <typename Op0_t, unsigned Opcode, typename... RecipeTys>
 using UnaryRecipe_match =
-    Recipe_match<std::tuple<Op0_t>, Opcode, false, false, RecipeTys...>;
+    Recipe_match<std::tuple<Op0_t>, Opcode, false, RecipeTys...>;
 
 template <typename Op0_t, unsigned Opcode>
 using UnaryVPInstruction_match =
@@ -298,8 +296,7 @@ using AllUnaryRecipe_match =
 template <typename Op0_t, typename Op1_t, unsigned Opcode, bool Commutative,
           typename... RecipeTys>
 using BinaryRecipe_match =
-    Recipe_match<std::tuple<Op0_t, Op1_t>, Opcode, Commutative,
-                 /*Variadic*/ false, RecipeTys...>;
+    Recipe_match<std::tuple<Op0_t, Op1_t>, Opcode, Commutative, RecipeTys...>;
 
 template <typename Op0_t, typename Op1_t, unsigned Opcode>
 using BinaryVPInstruction_match =
@@ -308,9 +305,8 @@ using BinaryVPInstruction_match =
 
 template <typename Op0_t, typename Op1_t, typename Op2_t, unsigned Opcode,
           bool Commutative, typename... RecipeTys>
-using TernaryRecipe_match =
-    Recipe_match<std::tuple<Op0_t, Op1_t, Op2_t>, Opcode, Commutative,
-                 /*Variadic*/ false, RecipeTys...>;
+using TernaryRecipe_match = Recipe_match<std::tuple<Op0_t, Op1_t, Op2_t>,
+                                         Opcode, Commutative, RecipeTys...>;
 
 template <typename Op0_t, typename Op1_t, typename Op2_t, unsigned Opcode>
 using TernaryVPInstruction_match =
@@ -350,9 +346,8 @@ m_VPInstruction(const Op0_t &Op0, const Op1_t &Op1, const Op2_t &Op2) {
 
 template <typename Op0_t, typename Op1_t, typename Op2_t, typename Op3_t,
           unsigned Opcode, bool Commutative, typename... RecipeTys>
-using Recipe4Op_match =
-    Recipe_match<std::tuple<Op0_t, Op1_t, Op2_t, Op3_t>, Opcode, Commutative,
-                 /*Variadic*/ false, RecipeTys...>;
+using Recipe4Op_match = Recipe_match<std::tuple<Op0_t, Op1_t, Op2_t, Op3_t>,
+                                     Opcode, Commutative, RecipeTys...>;
 
 template <typename Op0_t, typename Op1_t, typename Op2_t, typename Op3_t,
           unsigned Opcode>
@@ -386,12 +381,6 @@ m_Broadcast(const Op0_t &Op0) {
   return m_VPInstruction<VPInstruction::Broadcast>(Op0);
 }
 
-template <typename Op0_t>
-inline UnaryVPInstruction_match<Op0_t, VPInstruction::ExplicitVectorLength>
-m_ExplicitVectorLength(const Op0_t &Op0) {
-  return m_VPInstruction<VPInstruction::ExplicitVectorLength>(Op0);
-}
-
 template <typename Op0_t, typename Op1_t>
 inline BinaryVPInstruction_match<Op0_t, Op1_t, VPInstruction::ActiveLaneMask>
 m_ActiveLaneMask(const Op0_t &Op0, const Op1_t &Op1) {
@@ -451,12 +440,6 @@ m_c_Binary(const Op0_t &Op0, const Op1_t &Op1) {
   return AllBinaryRecipe_match<Op0_t, Op1_t, Opcode, true>(Op0, Op1);
 }
 
-template <typename Op0_t, typename Op1_t>
-inline AllBinaryRecipe_match<Op0_t, Op1_t, Instruction::Sub>
-m_Sub(const Op0_t &Op0, const Op1_t &Op1) {
-  return m_Binary<Instruction::Sub, Op0_t, Op1_t>(Op0, Op1);
-}
-
 template <typename Op0_t, typename Op1_t>
 inline AllBinaryRecipe_match<Op0_t, Op1_t, Instruction::Mul>
 m_Mul(const Op0_t &Op0, const Op1_t &Op1) {
@@ -502,8 +485,7 @@ inline GEPLikeRecipe_match<Op0_t, Op1_t> m_GetElementPtr(const Op0_t &Op0,
 template <typename Op0_t, typename Op1_t, typename Op2_t, unsigned Opcode>
 using AllTernaryRecipe_match =
     Recipe_match<std::tuple<Op0_t, Op1_t, Op2_t>, Opcode, false,
-                 /*Variadic*/ false, VPReplicateRecipe, VPInstruction,
-                 VPWidenSelectRecipe>;
+                 VPReplicateRecipe, VPInstruction, VPWidenSelectRecipe>;
 
 template <typename Op0_t, typename Op1_t, typename Op2_t>
 inline AllTernaryRecipe_match<Op0_t, Op1_t, Op2_t, Instruction::Select>
@@ -551,26 +533,14 @@ m_ScalarIVSteps(const Op0_t &Op0, const Op1_t &Op1, const Op2_t &Op2) {
 
 template <typename Op0_t, typename Op1_t, typename Op2_t>
 using VPDerivedIV_match =
-    Recipe_match<std::tuple<Op0_t, Op1_t, Op2_t>, 0, false, /*Variadic*/ false,
-                 VPDerivedIVRecipe>;
+    Recipe_match<std::tuple<Op0_t, Op1_t, Op2_t>, 0, false, VPDerivedIVRecipe>;
 
 template <typename Op0_t, typename Op1_t, typename Op2_t>
 inline VPDerivedIV_match<Op0_t, Op1_t, Op2_t>
 m_DerivedIV(const Op0_t &Op0, const Op1_t &Op1, const Op2_t &Op2) {
   return VPDerivedIV_match<Op0_t, Op1_t, Op2_t>({Op0, Op1, Op2});
 }
 
-template <typename... OpTys>
-using PhiLikeRecipe_match =
-    Recipe_match<std::tuple<OpTys...>, Instruction::PHI, false, true,
-                 VPWidenPHIRecipe, VPHeaderPHIRecipe, VPInstruction>;
-
-template <typename Op0_t, typename Op1_t, typename... OpTys>
-inline PhiLikeRecipe_match<Op0_t, Op1_t, OpTys...>
-m_Phi(const Op0_t &Op0, const Op1_t &Op1, const OpTys &...Ops) {
-  return PhiLikeRecipe_match<Op0_t, Op1_t, OpTys...>(Op0, Op1, Ops...);
-}
-
 /// Match a call argument at a given argument index.
 template <typename Opnd_t> struct Argument_match {
   /// Call argument index to match.
diff --git a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
@@ -328,7 +328,8 @@ VPPartialReductionRecipe::computeCost(ElementCount VF,
   // Pick out opcode, type/ext information and use sub side effects from a widen
   // recipe.
   auto HandleWiden = [&](VPWidenRecipe *Widen) {
-    if (match(Widen, m_Sub(m_SpecificInt(0), m_VPValue(Op)))) {
+    if (match(Widen,
+              m_Binary<Instruction::Sub>(m_SpecificInt(0), m_VPValue(Op)))) {
       Widen = dyn_cast<VPWidenRecipe>(Op->getDefiningRecipe());
     }
     Opcode = Widen->getOpcode();
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
@@ -740,7 +740,8 @@ static VPWidenInductionRecipe *getOptimizableIVOf(VPValue *VPV) {
       // IVStep will be the negated step of the subtraction. Check if Step == -1
       // * IVStep.
       VPValue *Step;
-      if (!match(VPV, m_Sub(m_VPValue(), m_VPValue(Step))) ||
+      if (!match(VPV,
+                 m_Binary<Instruction::Sub>(m_VPValue(), m_VPValue(Step))) ||
           !Step->isLiveIn() || !IVStep->isLiveIn())
         return false;
       auto *StepCI = dyn_cast<ConstantInt>(Step->getLiveInIRValue());
@@ -2400,13 +2401,18 @@ void VPlanTransforms::canonicalizeEVLLoops(VPlan &Plan) {
         continue;
       }
       if (match(PhiR,
-                m_Phi(m_Specific(Plan.getTripCount()), m_VPValue(Backedge))) &&
-          match(Backedge, m_Sub(m_Specific(PhiR),
-                                m_ZExtOrSelf(m_ExplicitVectorLength(m_CombineOr(
-                                    m_Specific(PhiR),
-                                    // The AVL may be capped to a safe distance.
-                                    m_Select(m_VPValue(), m_Specific(PhiR),
-                                             m_VPValue()))))))) {
+                m_VPInstruction<Instruction::PHI>(
+                    m_Specific(Plan.getTripCount()), m_VPValue(Backedge))) &&
+          match(Backedge,
+                m_VPInstruction<Instruction::Sub>(
+                    m_Specific(PhiR),
+                    m_ZExtOrSelf(
+                        m_VPInstruction<VPInstruction::ExplicitVectorLength>(
+                            m_CombineOr(
+                                m_Specific(PhiR),
+                                // The AVL may be capped to a safe distance.
+                                m_Select(m_VPValue(), m_Specific(PhiR),
+                                         m_VPValue()))))))) {
         AVLNext = Backedge;
       }
     }
