Add a breakpoint manager that matches based on File/Line/Col Locations

[mehdi_amini]

Summary

This will match the locations attached to the IRunits passed in as context
with an action.

[mehdi_amini]

rebase

[Mogball]

mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h

63

does this work on PointerUnion?

64

drop trivial braces

99

Couldn't you hash the FileLineColLoc directly?

mlir/lib/Debug/BreakpointManagers/FileLineColLocBreakpointManager.cpp

56

e

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

106

would it make more sense to set up this machinery inside MlirOptMain.cpp based on the string option? The static tricks going on here feel a little automagical

mlir/unittests/Debug/FileLineColLocBreakpointManagerTest.cpp

233

newline

[mehdi_amini]

mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h

63

It does not

99

Absolutely!

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

106

would it make more sense to set up this machinery inside MlirOptMain.cpp

We are inside MlirOptMain.cpp :)

I could move the vector outside of the lambda if you prefer, but it would still be static (like all the cl:: options actually.

I don't quite see where to handle this differently actually? The config does not hold a vector of strings and none of the cl options are available anywhere else.

[mehdi_amini]

address comments

[rriddle]

mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h

23

Can you document this class?

53–54

Same here, would love docs on this.

56

Can you add documentation to the various methods in this class?

72

Drop the trivial braces here.

88–92

Can we make this private?

89

Can we use StringAttr instead of StringRef here? Will be much more optimal on lookup.

94

Please use std::optional in new code.

95–97

Can we have a little bit more advanced checking here? This will miss out on things like FusedLoc/NameLoc/etc.

mlir/include/mlir/Debug/Observers/ActionLogging.h

33–34

Can you add a little more context here? I had to read the comment a few times to understand what it meant.

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

89–90

This comment feels slightly unrelated to the function, e.g. doesn't mention break point manager at all. Can this be tweaked?

95–96

I'm missing the connection between LocFilters(in the function name) and location breakpoints to use for logging actions? Can this comment be tweaked/beefed up?

mlir/lib/Debug/BreakpointManagers/FileLineColLocBreakpointManager.cpp

18

Likely can drop the llvm:: here.

45–50

Can you update the diagnostic function to use Twine instead of StringRef? That would simplify this function.

[mehdi_amini]

Address comments

mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h

56

These are override, do we usually repeat the parent comment here?

89

I don't think so: we don't have an MLIRContext when we create breakpoints. Imagine a gdb session connected to a process with multiple MLIRContext and you set a breakpoint based on a filename.

95–97

NameLoc isn't relevant I believe, FusedLoc matters though, using a walk should do?

[rriddle]

mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h

56

Missed it was override. Generally we don't if the behavior is clearly defined from the class, which should be the case here (if we get a class doc).

89

Gotcha, makes sense.

95–97

Yeah, though I think you'd just have to be careful to not include caller locations from callsites.

[mehdi_amini]

@rriddle : I think I addressed all of your comments? (judging by your last answer), but you didn't approve so I'm not sure if you wanted to review more?

mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h

+//===- FileLineColLocBreakpointManager.h - TODO: add message ----*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TRACING_BREAKPOINTMANAGERS_FILELINECOLLOCBREAKPOINTMANAGER_H
+#define MLIR_TRACING_BREAKPOINTMANAGERS_FILELINECOLLOCBREAKPOINTMANAGER_H
+
+#include "mlir/Debug/BreakpointManager.h"
+#include "mlir/Debug/ExecutionContext.h"
+#include "mlir/IR/Action.h"
+#include "mlir/IR/Location.h"
+#include "mlir/IR/Operation.h"
+#include "llvm/ADT/DenseMap.h"
+#include <memory>
+
+namespace mlir {
+namespace tracing {
+
+class FileLineColLocBreakpoint
+    : public BreakpointBase<FileLineColLocBreakpoint> {
+public:
+  FileLineColLocBreakpoint(StringRef file, int64_t line, int64_t col)
+      : line(line), col(col) {}
+
+  void print(raw_ostream &os) const override {
+    os << "Location: " << file << ':' << line << ':' << col;
+  }
+
+  /// Parse a string representation in the form of "<file>:<line>:<col>". Return
+  /// a tuple with these three elements, the first one is a StringRef pointing
+  /// into the original string.
+  static FailureOr<std::tuple<StringRef, int64_t, int64_t>> parseFromString(
+      StringRef str,
+      llvm::function_ref<void(StringRef)> diag = [](StringRef) {});
+
+private:
+  /// A filename on which to break.
+  StringRef file;
+
+  /// A particular line on which to break, or -1 to break on any line.
+  int64_t line;
+
+  /// A particular column on which to break, or -1 to break on any column
+  int64_t col;
+
+  friend class FileLineColLocBreakpointManager;
+};
+
+class FileLineColLocBreakpointManager
+    : public BreakpointManagerBase<FileLineColLocBreakpointManager> {
+public:
+  Breakpoint *match(const Action &action) const override {
+    for (const IRUnit &unit : action.getContextIRUnits()) {
+      if (auto *op = unit.dyn_cast<Operation *>()) {
+        if (auto match = matchFromLocation(op->getLoc()))
+          return *match;
+        continue;
+      }
+      if (auto *block = unit.dyn_cast<Block *>()) {
+        for (auto &op : block->getOperations()) {
+          if (auto match = matchFromLocation(op.getLoc()))
+            return *match;
+        }
+        continue;
+      }
+      if (Region *region = unit.dyn_cast<Region *>()) {
+        if (auto match = matchFromLocation(region->getLoc())) {
+          return *match;
+        }
+        continue;
+      }
+    }
+    return {};
+  }
+
+  FileLineColLocBreakpoint *addBreakpoint(StringRef file, int64_t line,
+                                          int64_t col = -1) {
+    auto &breakpoint = breakpoints[std::make_tuple(file, line, col)];
+    if (!breakpoint)
+      breakpoint = std::make_unique<FileLineColLocBreakpoint>(file, line, col);
+    return breakpoint.get();
+  }
+
+  /// A map from a (filename, line, column) -> breakpoint.
+  DenseMap<std::tuple<StringRef, int64_t, int64_t>,
+           std::unique_ptr<FileLineColLocBreakpoint>>
+      breakpoints;
+
+private:
+  llvm::Optional<Breakpoint *> matchFromLocation(Location loc) const {
+    auto fileLoc = loc.dyn_cast<FileLineColLoc>();
+    if (!fileLoc)
+      return {};
+    StringRef file = fileLoc.getFilename();
+    int64_t line = fileLoc.getLine();
+    int64_t col = fileLoc.getColumn();
+    auto lookup = breakpoints.find(std::make_tuple(file, line, col));
+    if (lookup != breakpoints.end() && lookup->second->isEnabled())
+      return lookup->second.get();
+    // If not found, check with the -1 key if we have a breakpoint for any col.
+    lookup = breakpoints.find(std::make_tuple(file, line, -1));
+    if (lookup != breakpoints.end() && lookup->second->isEnabled())
+      return lookup->second.get();
+    // If not found, check with the -1 key if we have a breakpoint for any line.
+    lookup = breakpoints.find(std::make_tuple(file, -1, -1));
+    if (lookup != breakpoints.end() && lookup->second->isEnabled())
+      return lookup->second.get();
+    return {};
+  }
+};
+
+} // namespace tracing
+} // namespace mlir
+
+#endif // MLIR_TRACING_BREAKPOINTMANAGERS_FILELINECOLLOCBREAKPOINTMANAGER_H

mlir/include/mlir/Debug/Observers/ActionLogging.h

ActionLogger(raw_ostream &os, bool printActions = true,
                bool printBreakpoints = true, bool printIRUnits = true)
       : os(os), printActions(printActions), printBreakpoints(printBreakpoints),
         printIRUnits(printIRUnits) {}
 
   void beforeExecute(const ActionActiveStack *action, Breakpoint *breakpoint,
                      bool willExecute) override;
   void afterExecute(const ActionActiveStack *action) override;
 
+  /// If one of multiple breakpoint managers are set, only matching breakpoint
+  /// will be logged.
+  void addBreakpointManager(const BreakpointManager *manager) {
+    breakpointManagers.push_back(manager);
+  }
+
 private:
+  /// Check if we should log this action or not.
+  bool shouldLog(const ActionActiveStack *action);
+
   raw_ostream &os;
   bool printActions;
   bool printBreakpoints;
   bool printIRUnits;
+  std::vector<const BreakpointManager *> breakpointManagers;
 };
 
 } // namespace tracing
 } // namespace mlir
 
 #endif // MLIR_TRACING_OBSERVERS_ACTIONLOGGING_H

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

 //===- MlirOptMain.h - MLIR Optimizer Driver main ---------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry function for mlir-opt for when built as standalone binary.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TOOLS_MLIROPT_MLIROPTMAIN_H
 #define MLIR_TOOLS_MLIROPT_MLIROPTMAIN_H
 
+#include "mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <cstdlib>
 #include <functional>
 #include <memory>
 
 namespace llvm {
 class raw_ostream;
 class MemoryBuffer;
 } // namespace llvm
 
 namespace mlir {
 class DialectRegistry;
 class PassPipelineCLParser;
 class PassManager;
+namespace tracing {
+class FileLineColLocBreakpointManager;
+}
 
 /// Configuration options for the mlir-opt tool.
 /// This is intended to help building tools like mlir-opt by collecting the
 /// supported options.
 /// The API is fluent, and the options are sorted in alphabetical order below.
 /// The options can be exposed to the LLVM command line by registering them
 /// with `MlirOptMainConfig::registerCLOptions();` and creating a config using
 /// `auto config = MlirOptMainConfig::createFromCLOptions();`.
public:
   /// Set the filename to use for logging actions, use "-" for stdout.
   MlirOptMainConfig &logActionsTo(StringRef filename) {
     logActionsToFlag = filename;
     return *this;
   }
   /// Get the filename to use for logging actions.
   StringRef getLogActionsTo() const { return logActionsToFlag; }
 
+  /// Set the location breakpoints to use for logging actions.
+  /// Ownership stays with the caller.
+  void addLogActionLocFilter(tracing::BreakpointManager *breakpointManager) {
+    logActionLocationFilter.push_back(breakpointManager);
+  }
+
+  /// Get the location breakpoints to use for logging actions.
+  ArrayRef<tracing::BreakpointManager *> getLogActionsLocFilters() const {
+    return logActionLocationFilter;
+  }
+
   /// Set the callback to populate the pass manager.
   MlirOptMainConfig &
   setPassPipelineSetupFn(std::function<LogicalResult(PassManager &)> callback) {
     passPipelineCallback = std::move(callback);
     return *this;
   }
 
   /// Set the parser to use to populate the pass manager.
protected:
   bool dumpPassPipelineFlag = false;
 
   /// Emit bytecode instead of textual assembly when generating output.
   bool emitBytecodeFlag = false;
 
   /// Log action execution to the given file (or "-" for stdout)
   std::string logActionsToFlag;
 
+  /// Location Breakpoints to filter the action logging.
+  std::vector<tracing::BreakpointManager *> logActionLocationFilter;
+
   /// The callback to populate the pass manager.
   std::function<LogicalResult(PassManager &)> passPipelineCallback;
 
   /// Deprecated.
   bool preloadDialectsInContextFlag = false;
 
   /// Show the registered dialects before trying to load the input file.
   bool showDialectsFlag = false;

mlir/lib/Debug/BreakpointManagers/FileLineColLocBreakpointManager.cpp

+//===- FileLineColLocBreakpointManager.cpp - MLIR Optimizer Driver --------===//
+//
+// 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/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h"
+#include "mlir/IR/Diagnostics.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace mlir;
+using namespace mlir::tracing;
+
+FailureOr<std::tuple<StringRef, int64_t, int64_t>>
+FileLineColLocBreakpoint::parseFromString(
+    StringRef str, llvm::function_ref<void(StringRef)> diag) {
+  // Watch at debug locations arguments are expected to be in the form:
+  // `fileName:line:col`, `fileName:line`, or `fileName`.
+
+  auto [file, lineCol] = str.split(':');
+  auto [lineStr, colStr] = lineCol.split(':');
+  if (file.empty()) {
+    if (diag)
+      diag("error: initializing FileLineColLocBreakpoint with empty file name");
+    return failure();
+  }
+
+  // Extract the line and column value
+  int64_t line = -1, col = -1;
+  if (!lineStr.empty() && lineStr.getAsInteger(0, line)) {
+    if (diag) {
+      std::string error;
+      llvm::raw_string_ostream os{error};
+      os << "error: initializing FileLineColLocBreakpoint with a non-numeric "
+            "line value: `"
+         << lineStr << "`";
+      diag(os.str());
+    }
+    return failure();
+  }
+  if (!colStr.empty() && colStr.getAsInteger(0, col)) {
+    if (diag) {
+      std::string error;
+      llvm::raw_string_ostream os{error};
+      os << "error: initializing FileLineColLocBreakpoint with a non-numeric "
+            "col value: `"
+         << colStr << "`";
+      diag(os.str());
+    }
+    return failure();
+  }
+  return std::tuple<StringRef, int64_t, int64_t>{file, line, col};
+}

mlir/lib/Debug/CMakeLists.txt

 add_subdirectory(Observers)
 
 add_mlir_library(MLIRDebug
   DebugCounter.cpp
   ExecutionContext.cpp
+  BreakpointManagers/FileLineColLocBreakpointManager.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Debug
 
   LINK_LIBS PUBLIC
   ${LLVM_PTHREAD_LIB}
   MLIRIR
   MLIRSupport
 )
 

mlir/lib/Debug/Observers/ActionLogging.cpp

 //===- ExecutionContext.cpp - Debug Execution Context Support -------------===//
 //
 // 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/Debug/Observers/ActionLogging.h"
+#include "mlir/Debug/BreakpointManager.h"
 #include "mlir/IR/Action.h"
 #include "llvm/Support/Threading.h"
 
 using namespace mlir;
 using namespace mlir::tracing;
 
 //===----------------------------------------------------------------------===//
 // ActionLogger
 //===----------------------------------------------------------------------===//
 
+bool ActionLogger::shouldLog(const ActionActiveStack *action) {
+  // If some condition was set, we ensured it is met before logging.
+  if (breakpointManagers.empty())
+    return true;
+  return llvm::any_of(breakpointManagers,
+                      [&](const BreakpointManager *manager) {
+                        return manager->match(action->getAction());
+                      });
+}
+
 void ActionLogger::beforeExecute(const ActionActiveStack *action,
                                  Breakpoint *breakpoint, bool willExecute) {
+  if (!shouldLog(action))
+    return;
   os << "[thread " << llvm::get_threadid() << "] ";
   if (willExecute)
     os << "begins ";
   else
     os << "skipping ";
   if (printBreakpoints) {
     if (breakpoint)
       os << "(on breakpoint: " << *breakpoint << ") ";
     else
       os << "(no breakpoint) ";
   }
   os << "Action ";
   if (printActions)
     action->getAction().print(os);
   else
     os << action->getAction().getTag();
   if (printIRUnits) {
     os << " (";
     interleaveComma(action->getAction().getContextIRUnits(), os);
     os << ")\n";
   }
 }
 
 void ActionLogger::afterExecute(const ActionActiveStack *action) {
+  if (!shouldLog(action))
+    return;
   os << "[thread " << llvm::get_threadid() << "] completed `"
      << action->getAction().getTag() << "`\n";
 }

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Parser/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/Timing.h"
 #include "mlir/Support/ToolUtilities.h"
 #include "mlir/Tools/ParseUtilities.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/ThreadPool.h"
static cl::opt<bool, /*ExternalStorage=*/true> explicitModule(
         cl::location(useExplicitModuleFlag), cl::init(false));
 
     static cl::opt<std::string, /*ExternalStorage=*/true> logActionsTo{
         "log-actions-to",
         cl::desc("Log action execution to a file, or stderr if "
                  " '-' is passed"),
         cl::location(logActionsToFlag)};
 
+    static cl::list<std::string> logActionLocationFilter(
+        "log-mlir-actions-filter",
+        cl::desc(
+            "Comma separated list of locations to filter actions from logging"),
+        cl::CommaSeparated,
+        cl::cb<void, std::string>([&](const std::string &location) {
+          static bool register_once = [&] {
+            addLogActionLocFilter(&locBreakpointManager);
+            return true;
+          }();
+          (void)register_once;
+          static std::vector<std::string> locations;
+          locations.push_back(location);
+          StringRef locStr = locations.back();
+
+          // Parse the individual location filters and set the breakpoints.
+          auto diag = [](StringRef msg) { llvm::errs() << msg << "\n"; };
+          auto locBreakpoint =
+              tracing::FileLineColLocBreakpoint::parseFromString(locStr, diag);
+          if (failed(locBreakpoint)) {
+            llvm::errs() << "Invalid location filter: " << locStr << "\n";
+            exit(1);
+          }
+          auto [file, line, col] = *locBreakpoint;
+          locBreakpointManager.addBreakpoint(file, line, col);
+        }));
+
     static cl::opt<bool, /*ExternalStorage=*/true> showDialects(
         "show-dialects",
         cl::desc("Print the list of registered dialects and exit"),
         cl::location(showDialectsFlag), cl::init(false));
 
     static cl::opt<bool, /*ExternalStorage=*/true> splitInputFile(
         "split-input-file",
         cl::desc("Split the input file into pieces and process each "
MlirOptMainConfigCLOptions() {
     static cl::opt<bool, /*ExternalStorage=*/true> verifyPasses(
         "verify-each",
         cl::desc("Run the verifier after each transformation pass"),
         cl::location(verifyPassesFlag), cl::init(true));
 
     static PassPipelineCLParser passPipeline("", "Compiler passes to run", "p");
     setPassPipelineParser(passPipeline);
   }
+
+  tracing::FileLineColLocBreakpointManager locBreakpointManager;
 };
 } // namespace
 
 ManagedStatic<MlirOptMainConfigCLOptions> clOptionsConfig;
 
 void MlirOptMainConfig::registerCLOptions() { *clOptionsConfig; }
 
 MlirOptMainConfig MlirOptMainConfig::createFromCLOptions() {
if (!logActionsFile) {
       emitError(UnknownLoc::get(&context),
                 "Opening file for --log-actions-to failed: ")
           << errorMessage << "\n";
       return;
     }
     logActionsFile->keep();
     raw_fd_ostream &logActionsStream = logActionsFile->os();
     actionLogger = std::make_unique<tracing::ActionLogger>(logActionsStream);
+    for (const auto *locationBreakpoint : config.getLogActionsLocFilters())
+      actionLogger->addBreakpointManager(locationBreakpoint);
 
     executionContext.registerObserver(actionLogger.get());
     context.registerActionHandler(executionContext);
   }
 
 private:
   std::unique_ptr<llvm::ToolOutputFile> logActionsFile;
   tracing::ExecutionContext executionContext;
   std::unique_ptr<tracing::ActionLogger> actionLogger;
+  std::vector<std::unique_ptr<tracing::FileLineColLocBreakpoint>>
+      locationBreakpoints;
 };
 
 /// Perform the actions on the input file indicated by the command line flags
 /// within the specified context.
 ///
 /// This typically parses the main source file, runs zero or more optimization
 /// passes, then prints the output.
 ///

mlir/test/Pass/action-logging-filter.mlir

+// Run the canonicalize on each function, use the --log-mlir-actions-filter= option
+// to filter which action should be logged.
+
+func.func @a() {
+    return
+}
+
+func.func @b() {
+    return
+}
+
+func.func @c() {
+    return
+}
+
+////////////////////////////////////
+/// 1. All actions should be logged.
+
+// RUN: mlir-opt %s --log-actions-to=- -pass-pipeline="builtin.module(func.func(canonicalize))" -o %t --mlir-disable-threading | FileCheck %s
+// Specify the current file as filter, expect to see all actions.
+// RUN: mlir-opt %s --log-mlir-actions-filter=%s --log-actions-to=- -pass-pipeline="builtin.module(func.func(canonicalize))" -o %t --mlir-disable-threading | FileCheck %s
+
+// CHECK: [thread {{.*}}] begins (no breakpoint) Action `pass-execution-action`  running "Canonicalizer" on Operation "func.func" (func.func @a() {/*skip region*/}
+// CHECK-NEXT: [thread {{.*}}] completed `pass-execution-action`
+// CHECK-NEXT: [thread {{.*}}] begins (no breakpoint) Action `pass-execution-action`  running "Canonicalizer" on Operation "func.func" (func.func @b() {/*skip region*/}
+// CHECK-NEXT: [thread {{.*}}] completed `pass-execution-action`
+// CHECK-NEXT: [thread {{.*}}] begins (no breakpoint) Action `pass-execution-action`  running "Canonicalizer" on Operation "func.func" (func.func @c() {/*skip region*/}
+// CHECK-NEXT: [thread {{.*}}] completed `pass-execution-action`
+
+////////////////////////////////////
+/// 2. No match
+
+// Specify a non-existing file as filter, expect to see no actions.
+// RUN: mlir-opt %s --log-mlir-actions-filter=foo.mlir --log-actions-to=- -pass-pipeline="builtin.module(func.func(canonicalize))" -o %t --mlir-disable-threading | FileCheck %s --check-prefix=CHECK-NONE --allow-empty
+// Filter on a non-matching line, expect to see no actions.
+// RUN: mlir-opt %s --log-mlir-actions-filter=%s:1 --log-actions-to=- -pass-pipeline="builtin.module(func.func(canonicalize))" -o %t --mlir-disable-threading | FileCheck %s --check-prefix=CHECK-NONE --allow-empty
+
+// Invalid Filter
+// CHECK-NONE-NOT: Canonicalizer
+
+////////////////////////////////////
+/// 3. Matching filters
+
+// Filter the second function only
+// RUN: mlir-opt %s --log-mlir-actions-filter=%s:8 --log-actions-to=- -pass-pipeline="builtin.module(func.func(canonicalize))" -o %t --mlir-disable-threading | FileCheck %s --check-prefix=CHECK-SECOND
+
+// CHECK-SECOND-NOT: @a
+// CHECK-SECOND-NOT: @c
+// CHECK-SECOND: [thread {{.*}}] begins (no breakpoint) Action `pass-execution-action`  running "Canonicalizer" on Operation "func.func" (func.func @b() {/*skip region*/}
+// CHECK-SECOND-NEXT: [thread {{.*}}] completed `pass-execution-action`
+
+// Filter the first and third functions
+// RUN: mlir-opt %s --log-mlir-actions-filter=%s:4,%s:12 --log-actions-to=- -pass-pipeline="builtin.module(func.func(canonicalize))" -o %t --mlir-disable-threading | FileCheck %s  --check-prefix=CHECK-FIRST-THIRD
+
+// CHECK-FIRST-THIRD-NOT: Canonicalizer
+// CHECK-FIRST-THIRD: [thread {{.*}}] begins (no breakpoint) Action `pass-execution-action`  running "Canonicalizer" on Operation "func.func" (func.func @a() {/*skip region*/}
+// CHECK-FIRST-THIRD-NEXT: [thread {{.*}}] completed `pass-execution-action`
+// CHECK-FIRST-THIRD-NEXT: [thread {{.*}}] begins (no breakpoint) Action `pass-execution-action`  running "Canonicalizer" on Operation "func.func" (func.func @c() {/*skip region*/}
+// CHECK-FIRST-THIRD-NEXT: [thread {{.*}}] completed `pass-execution-action`
+// CHECK-FIRST-THIRD-NOT: Canonicalizer

mlir/unittests/Debug/CMakeLists.txt

 add_mlir_unittest(MLIRDebugTests
   DebugCounterTest.cpp
   ExecutionContextTest.cpp
+  FileLineColLocBreakpointManagerTest.cpp
 )
 
 target_link_libraries(MLIRDebugTests
   PRIVATE MLIRDebug)

mlir/unittests/Debug/FileLineColLocBreakpointManagerTest.cpp

+//===- FileLineColLocBreakpointManagerTest.cpp - --------------------------===//
+//
+// 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/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h"
+#include "mlir/Debug/ExecutionContext.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/Location.h"
+#include "mlir/IR/OperationSupport.h"
+#include "llvm/ADT/STLExtras.h"
+#include "gtest/gtest.h"
+
+using namespace mlir;
+using namespace mlir::tracing;
+
+static Operation *createOp(MLIRContext *context, Location loc,
+                           StringRef operationName,
+                           unsigned int numRegions = 0) {
+  context->allowUnregisteredDialects();
+  return Operation::create(loc, OperationName(operationName, context),
+                           std::nullopt, std::nullopt, std::nullopt,
+                           std::nullopt, numRegions);
+}
+
+namespace {
+struct FileLineColLocTestingAction
+    : public ActionImpl<FileLineColLocTestingAction> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FileLineColLocTestingAction)
+  static constexpr StringLiteral tag = "file-line-col-loc-testing-action";
+  FileLineColLocTestingAction(ArrayRef<IRUnit> irUnits)
+      : ActionImpl<FileLineColLocTestingAction>(irUnits) {}
+};
+
+TEST(FileLineColLocBreakpointManager, OperationMatch) {
+  // This test will process a sequence of operation and check various situation
+  // with a breakpoint hitting or not based on the location attached to the
+  // operation. When a breakpoint hits, the action is skipped and the counter is
+  // not incremented.
+  ExecutionContext executionCtx(
+      [](const ActionActiveStack *) { return ExecutionContext::Skip; });
+  int counter = 0;
+  auto counterInc = [&]() { counter++; };
+
+  // Setup
+
+  MLIRContext context;
+  // Miscellaneous information to define operations
+  std::vector<StringRef> fileNames = {
+      StringRef("foo.bar"), StringRef("baz.qux"), StringRef("quux.corge")};
+  std::vector<std::pair<unsigned, unsigned>> lineColLoc = {{42, 7}, {24, 3}};
+  Location callee = UnknownLoc::get(&context),
+           caller = UnknownLoc::get(&context), loc = UnknownLoc::get(&context);
+
+  // Set of operations over where we are going to be testing the functionality
+  std::vector<Operation *> operations = {
+      createOp(&context, CallSiteLoc::get(callee, caller),
+               "callSiteLocOperation"),
+      createOp(&context,
+               FileLineColLoc::get(&context, fileNames[0], lineColLoc[0].first,
+                                   lineColLoc[0].second),
+               "fileLineColLocOperation"),
+      createOp(&context, FusedLoc::get(&context, {}, Attribute()),
+               "fusedLocOperation"),
+      createOp(&context, NameLoc::get(StringAttr::get(&context, fileNames[2])),
+               "nameLocOperation"),
+      createOp(&context, OpaqueLoc::get<void *>(nullptr, loc),
+               "opaqueLocOperation"),
+      createOp(&context,
+               FileLineColLoc::get(&context, fileNames[1], lineColLoc[1].first,
+                                   lineColLoc[1].second),
+               "anotherFileLineColLocOperation"),
+      createOp(&context, UnknownLoc::get(&context), "unknownLocOperation"),
+  };
+
+  FileLineColLocBreakpointManager breakpointManager;
+  executionCtx.addBreakpointManager(&breakpointManager);
+
+  // Test
+
+  // Basic case is that no breakpoint is set and the counter is incremented for
+  // every op.
+  auto checkNoMatch = [&]() {
+    counter = 0;
+    for (auto enumeratedOp : llvm::enumerate(operations)) {
+      executionCtx(counterInc,
+                   FileLineColLocTestingAction({enumeratedOp.value()}));
+      EXPECT_EQ(counter, static_cast<int>(enumeratedOp.index() + 1));
+    }
+  };
+  checkNoMatch();
+
+  // Set a breakpoint matching only the second operation in the list.
+  auto *breakpoint = breakpointManager.addBreakpoint(
+      fileNames[0], lineColLoc[0].first, lineColLoc[0].second);
+  auto checkMatchIdxs = [&](DenseSet<int> idxs) {
+    counter = 0;
+    int reference = 0;
+    for (int i = 0; i < (int)operations.size(); ++i) {
+      executionCtx(counterInc, FileLineColLocTestingAction({operations[i]}));
+      if (!idxs.contains(i))
+        reference++;
+      EXPECT_EQ(counter, reference);
+    }
+  };
+  checkMatchIdxs({1});
+
+  // Check that disabling the breakpoing brings us back to the original
+  // behavior.
+  breakpoint->disable();
+  checkNoMatch();
+
+  // Adding a breakpoint that won't match any location shouldn't affect the
+  // behavior.
+  breakpointManager.addBreakpoint(StringRef("random.file"), 3, 14);
+  checkNoMatch();
+
+  // Set a breakpoint matching only the fifth operation in the list.
+  breakpointManager.addBreakpoint(fileNames[1], lineColLoc[1].first,
+                                  lineColLoc[1].second);
+  counter = 0;
+  checkMatchIdxs({5});
+
+  // Re-enable the breakpoint matching only the second operation in the list.
+  // We now expect matching of operations 1 and 5.
+  breakpoint->enable();
+  checkMatchIdxs({1, 5});
+
+  for (auto *op : operations) {
+    op->destroy();
+  }
+}
+
+TEST(FileLineColLocBreakpointManager, BlockMatch) {
+  // This test will process a block and check various situation with
+  // a breakpoint hitting or not based on the location attached.
+  // When a breakpoint hits, the action is skipped and the counter is not
+  // incremented.
+  ExecutionContext executionCtx(
+      [](const ActionActiveStack *) { return ExecutionContext::Skip; });
+  int counter = 0;
+  auto counterInc = [&]() { counter++; };
+
+  // Setup
+
+  MLIRContext context;
+  std::vector<StringRef> fileNames = {StringRef("grault.garply"),
+                                      StringRef("waldo.fred")};
+  std::vector<std::pair<unsigned, unsigned>> lineColLoc = {{42, 7}, {24, 3}};
+  Operation *frontOp = createOp(&context,
+                                FileLineColLoc::get(&context, fileNames.front(),
+                                                    lineColLoc.front().first,
+                                                    lineColLoc.front().second),
+                                "firstOperation");
+  Operation *backOp = createOp(&context,
+                               FileLineColLoc::get(&context, fileNames.back(),
+                                                   lineColLoc.back().first,
+                                                   lineColLoc.back().second),
+                               "secondOperation");
+  Block block;
+  block.push_back(frontOp);
+  block.push_back(backOp);
+
+  FileLineColLocBreakpointManager breakpointManager;
+  executionCtx.addBreakpointManager(&breakpointManager);
+
+  // Test
+
+  executionCtx(counterInc, FileLineColLocTestingAction({&block}));
+  EXPECT_EQ(counter, 1);
+
+  auto *breakpoint = breakpointManager.addBreakpoint(
+      fileNames.front(), lineColLoc.front().first, lineColLoc.front().second);
+  counter = 0;
+  executionCtx(counterInc, FileLineColLocTestingAction({&block}));
+  EXPECT_EQ(counter, 0);
+  breakpoint->disable();
+  executionCtx(counterInc, FileLineColLocTestingAction({&block}));
+  EXPECT_EQ(counter, 1);
+
+  breakpoint = breakpointManager.addBreakpoint(
+      fileNames.back(), lineColLoc.back().first, lineColLoc.back().second);
+  counter = 0;
+  executionCtx(counterInc, FileLineColLocTestingAction({&block}));
+  EXPECT_EQ(counter, 0);
+  breakpoint->disable();
+  executionCtx(counterInc, FileLineColLocTestingAction({&block}));
+  EXPECT_EQ(counter, 1);
+}
+
+TEST(FileLineColLocBreakpointManager, RegionMatch) {
+  // This test will process a region and check various situation with
+  // a breakpoint hitting or not based on the location attached.
+  // When a breakpoint hits, the action is skipped and the counter is not
+  // incremented.
+  ExecutionContext executionCtx(
+      [](const ActionActiveStack *) { return ExecutionContext::Skip; });
+  int counter = 0;
+  auto counterInc = [&]() { counter++; };
+
+  // Setup
+
+  MLIRContext context;
+  StringRef fileName("plugh.xyzzy");
+  unsigned line = 42, col = 7;
+  Operation *containerOp =
+      createOp(&context, FileLineColLoc::get(&context, fileName, line, col),
+               "containerOperation", 1);
+  Region &region = containerOp->getRegion(0);
+
+  FileLineColLocBreakpointManager breakpointManager;
+  executionCtx.addBreakpointManager(&breakpointManager);
+
+  // Test
+  counter = 0;
+  executionCtx(counterInc, FileLineColLocTestingAction({&region}));
+  EXPECT_EQ(counter, 1);
+  auto *breakpoint = breakpointManager.addBreakpoint(fileName, line, col);
+  executionCtx(counterInc, FileLineColLocTestingAction({&region}));
+  EXPECT_EQ(counter, 1);
+  breakpoint->disable();
+  executionCtx(counterInc, FileLineColLocTestingAction({&region}));
+  EXPECT_EQ(counter, 2);
+
+  containerOp->destroy();
+}
+} // namespace