MLIR] Add debug support for ignored patterns

[frgossen]

Summary

The rewrite engine's cost model may determine some patterns to be irrelevant
ahead of their application. These patterns were silently ignored previously and
now cause a message in --debug mode.

[mehdi_amini]

mlir/lib/IR/PatternMatch.cpp

242

Nit: I'm not sure the empty line before/after is really warranted.

[frgossen]

Address comment

mlir/lib/IR/PatternMatch.cpp

 //===- PatternMatch.cpp - Base classes for pattern match ------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Value.h"
+#include "llvm/Support/Debug.h"
 
 using namespace mlir;
 
+#define DEBUG_TYPE "pattern-match"
+
 PatternBenefit::PatternBenefit(unsigned benefit) : representation(benefit) {
   assert(representation == benefit && benefit != ImpossibleToMatchSentinel &&
          "This pattern match benefit is too large to represent");
 }
 
 unsigned short PatternBenefit::getBenefit() const {
   assert(!isImpossibleToMatch() && "Pattern doesn't match");
   return representation;

 //===----------------------------------------------------------------------===//
 
 void PatternApplicator::applyCostModel(CostModel model) {
   // Separate patterns by root kind to simplify lookup later on.
   patterns.clear();
   anyOpPatterns.clear();
   for (const auto &pat : owningPatternList) {
     // If the pattern is always impossible to match, just ignore it.
-    if (pat->getBenefit().isImpossibleToMatch())
+    if (pat->getBenefit().isImpossibleToMatch()) {
+      LLVM_DEBUG({
+        llvm::dbgs()
+            << "Ignoring pattern '" << pat->getRootKind()
+            << "' because it is impossible to match (by pattern benefit)\n";
+      });
       continue;
+    }
     if (Optional<OperationName> opName = pat->getRootKind())
       patterns[*opName].push_back(pat.get());
     else
       anyOpPatterns.push_back(pat.get());
   }
 
   // Sort the patterns using the provided cost model.
   llvm::SmallDenseMap<RewritePattern *, PatternBenefit> benefits;
   auto cmp = [&benefits](RewritePattern *lhs, RewritePattern *rhs) {
     return benefits[lhs] > benefits[rhs];
   };
   auto processPatternList = [&](SmallVectorImpl<RewritePattern *> &list) {
     // Special case for one pattern in the list, which is the most common case.
     if (list.size() == 1) {
-      if (model(*list.front()).isImpossibleToMatch())
+      if (model(*list.front()).isImpossibleToMatch()) {
+        LLVM_DEBUG({
+          llvm::dbgs() << "Ignoring pattern '" << list.front()->getRootKind()
+                       << "' because it is impossible to match or cannot lead "
+                          "to legal IR (by cost model)\n";
+        });
         list.clear();
+      }
       return;
     }
 
     // Collect the dynamic benefits for the current pattern list.
     benefits.clear();
     for (RewritePattern *pat : list)
       benefits.try_emplace(pat, model(*pat));
 
     // Sort patterns with highest benefit first, and remove those that are
     // impossible to match.
     std::stable_sort(list.begin(), list.end(), cmp);
-    while (!list.empty() && benefits[list.back()].isImpossibleToMatch())
+    while (!list.empty() && benefits[list.back()].isImpossibleToMatch()) {
+      LLVM_DEBUG({
+        llvm::dbgs() << "Ignoring pattern '" << list.back()->getRootKind()
+                     << "' because it is impossible to match or cannot lead to "
+                        "legal IR (by cost model)\n";
+      });
       list.pop_back();
+    }
   };
   for (auto &it : patterns)
     processPatternList(it.second);
   processPatternList(anyOpPatterns);
 }
 
 void PatternApplicator::walkAllPatterns(
     function_ref<void(const RewritePattern &)> walk) {