Rename DebugAction to tracing::Action and move related code from lib/Support to lib/IR and lib/Debug

[mehdi_amini]

Summary

This is a preparation for adding support for more infrastructure around the concept
of Action and make tracing Action more of a first class concept.
The doc will be updated later in a subsequent revision after the changes are
completed.

Action belongs to IR because of circular dependency: Actions are dispatched through
the MLIRContext but Action will learn to encapsulate IR construct.

[mehdi_amini]

reviewers

[mehdi_amini]

reviewers

[mehdi_amini]

rebase

[rriddle]

mlir/include/mlir/IR/Action.h

29–32

Why are any of these needed?

mlir/unittests/Debug/DebugCounterTest.cpp

25

Why is this not CounterAction::tag?

[mehdi_amini]

mlir/include/mlir/IR/Action.h

29–32

They aren't anymore, removed.

mlir/unittests/Debug/DebugCounterTest.cpp

25

Wasn't possible in a past iteration of the development, fixed now, thanks!

mlir/include/mlir/Debug/Counter.h

 //===- DebugCounter.h - Debug Counter support -------------------*- 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_SUPPORT_DEBUGCOUNTER_H
-#define MLIR_SUPPORT_DEBUGCOUNTER_H
+#ifndef MLIR_TRACING_DEBUGCOUNTER_H
+#define MLIR_TRACING_DEBUGCOUNTER_H
 
-#include "mlir/Support/DebugAction.h"
+#include "mlir/IR/Action.h"
 #include "llvm/ADT/StringMap.h"
 #include <string>
 
 namespace mlir {
+namespace tracing {
 
-/// This class implements a debug action handler that attaches a counter value
+/// This class implements an action handler that attaches a counter value
 /// to debug actions and enables/disables execution of these action based on the
 /// value of the counter. The counter controls the execution of the action with
 /// a "skip" and "count" value. The "skip" value is used to skip a certain
-/// number of initial executions of a debug action. The "count" value is used to
-/// prevent a debug action from executing after it has executed for a set number
+/// number of initial executions of an action. The "count" value is used to
+/// prevent an action from executing after it has executed for a set number
 /// of times (not including any executions that have been skipped). For example,
-/// a counter for a debug action with `skip=47` and `count=2`, would skip the
+/// a counter for an action with `skip=47` and `count=2`, would skip the
 /// first 47 executions, then execute twice, and finally prevent any further
 /// executions.
-class DebugCounter : public DebugActionManager::GenericHandler {
+class DebugCounter : public ActionManager::GenericHandler {
 public:
   DebugCounter();
   ~DebugCounter() override;
 
-  /// Add a counter for the given debug action tag. `countToSkip` is the number
+  /// Add a counter for the given action tag. `countToSkip` is the number
   /// of counter executions to skip before enabling execution of the action.
   /// `countToStopAfter` is the number of executions of the counter to allow
   /// before preventing the action from executing any more.
   void addCounter(StringRef actionTag, int64_t countToSkip,
                   int64_t countToStopAfter);
 
   /// Register a counter with the specified name.
   FailureOr<bool> execute(llvm::function_ref<void()> transform,
-                          const DebugActionBase &action) final;
+                          const Action &action) final;
 
   /// Print the counters that have been registered with this instance to the
   /// provided output stream.
   void print(raw_ostream &os) const;
 
   /// Register the command line options for debug counters.
   static void registerCLOptions();
 
struct Counter {
     /// The number of times to execute this counter before stopping.
     int64_t countToStopAfter;
   };
 
   /// A mapping between a given action tag and its counter information.
   llvm::StringMap<Counter> counters;
 };
 
+} // namespace tracing
 } // namespace mlir
 
-#endif
+#endif // MLIR_TRACING_DEBUGCOUNTER_H

mlir/include/mlir/IR/Action.h

-//===- DebugAction.h - Debug Action Support ---------------------*- C++ -*-===//
+//===- Action.h -  Action Support ---------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains definitions for the debug action framework. This framework
+// This file contains definitions for the action framework. This framework
 // allows for external entities to control certain actions taken by the compiler
 // by registering handler functions.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_SUPPORT_DEBUGACTION_H
-#define MLIR_SUPPORT_DEBUGACTION_H
+#ifndef MLIR_IR_ACTION_H
+#define MLIR_IR_ACTION_H
 
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/TypeID.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/TypeName.h"
 #include "llvm/Support/raw_ostream.h"
 #include <functional>
 #include <type_traits>
 
 namespace mlir {
+class Block;
+class Operation;
+class Region;
+class Value;
+namespace tracing {
 
-/// This class represents the base class of a debug action.
-class DebugActionBase {
+/// An action is a specific action that is to be taken by the compiler,
+/// that can be toggled and controlled by an external user. There are no
+/// constraints on the granularity of an action, it could be as simple as
+/// "perform this fold" and as complex as "run this pass pipeline". Via template
+/// parameters `ParameterTs`, a user may provide the set of argument types that
+/// are provided when handling a query on this action.
+///
+/// This class represents the base class of the ActionImpl class (see below).
+/// This holds the template-invariant elements of the Action class.
+class Action {
 public:
-  virtual ~DebugActionBase() = default;
+  virtual ~Action() = default;
 
   /// Return the unique action id of this action, use for casting
   /// functionality.
   TypeID getActionID() const { return actionID; }
 
-  StringRef getTag() const { return tag; }
-
-  StringRef getDescription() const { return desc; }
+  /// Return a string "tag" which intends to uniquely identify this type of
+  /// action. For example "pass-application" or "pattern-rewrite".
+  virtual StringRef getTag() const = 0;
 
   virtual void print(raw_ostream &os) const {
-    os << "Action \"" << tag << "\" : " << desc << "\n";
+    os << "Action \"" << getTag() << "\"";
   }
 
 protected:
-  DebugActionBase(TypeID actionID, StringRef tag, StringRef desc)
-      : actionID(actionID), tag(tag), desc(desc) {}
+  Action(TypeID actionID) : actionID(actionID) {}
 
-  /// The type of the derived action class. This allows for detecting the
-  /// specific handler of a given action type.
+  /// The type of the derived action class, used for `isa`/`dyn_cast`.
   TypeID actionID;
-  StringRef tag;
-  StringRef desc;
 };
 
 //===----------------------------------------------------------------------===//
-// DebugActionManager
+// ActionManager
 //===----------------------------------------------------------------------===//
 
-/// This class represents manages debug actions, and orchestrates the
+/// This class represents manages actions, and orchestrates the
 /// communication between action queries and action handlers. An action handler
 /// is either an action specific handler, i.e. a derived class of
 /// `MyActionType::Handler`, or a generic handler, i.e. a derived class of
-/// `DebugActionManager::GenericHandler`. For more details on action specific
-/// handlers, see the definition of `DebugAction::Handler` below. For more
-/// details on generic handlers, see `DebugActionManager::GenericHandler` below.
-class DebugActionManager {
+/// `ActionManager::GenericHandler`. For more details on action specific
+/// handlers, see the definition of `Action::Handler` below. For more
+/// details on generic handlers, see `ActionManager::GenericHandler` below.
+class ActionManager {
 public:
   //===--------------------------------------------------------------------===//
   // Handlers
   //===--------------------------------------------------------------------===//
 
-  /// This class represents the base class of a debug action handler.
+  /// This class represents the base class of an action handler.
   class HandlerBase {
   public:
     virtual ~HandlerBase() = default;
 
     /// Return the unique handler id of this handler, use for casting
     /// functionality.
     TypeID getHandlerID() const { return handlerID; }
 
public:
   class GenericHandler : public HandlerBase {
   public:
     GenericHandler() : HandlerBase(TypeID::get<GenericHandler>()) {}
 
     /// This hook allows for controlling the execution of an action. It should
     /// return failure if the handler could not process the action, or whether
     /// the `transform` was executed or not.
     virtual FailureOr<bool> execute(llvm::function_ref<void()> transform,
-                                    const DebugActionBase &action) {
+                                    const Action &action) {
       return failure();
     }
 
     /// Provide classof to allow casting between handler types.
-    static bool classof(const DebugActionManager::HandlerBase *handler) {
+    static bool classof(const ActionManager::HandlerBase *handler) {
       return handler->getHandlerID() == TypeID::get<GenericHandler>();
     }
   };
 
   /// Register the given action handler with the manager.
   void registerActionHandler(std::unique_ptr<HandlerBase> handler) {
     actionHandlers.emplace_back(std::move(handler));
   }
FailureOr<bool> result = dispatchToHandler<ActionType, bool>(
         executeFn, std::forward<Args>(args)...);
     if (failed(result)) {
       transform();
       return true;
     }
 
     // Return the result of the handler.
     return *result;
-#endif
   }
 
 private:
   //===--------------------------------------------------------------------===//
   // Query to Handler Dispatch
   //===--------------------------------------------------------------------===//
 
   /// Dispath a given callback on any handlers that are able to process queries
FailureOr<ResultT> dispatchToHandler(HandlerCallbackT &&handlerCallback,
     }
     return failure();
   }
 
   /// The set of action handlers that have been registered with the manager.
   SmallVector<std::unique_ptr<HandlerBase>> actionHandlers;
 };
 
-//===----------------------------------------------------------------------===//
-// DebugAction
-//===----------------------------------------------------------------------===//
-
-/// A debug action is a specific action that is to be taken by the compiler,
-/// that can be toggled and controlled by an external user. There are no
-/// constraints on the granularity of an action, it could be as simple as
-/// "perform this fold" and as complex as "run this pass pipeline". Via template
-/// parameters `ParameterTs`, a user may provide the set of argument types that
-/// are provided when handling a query on this action. Derived classes are
-/// expected to provide the following:
-///   * static llvm::StringRef getTag()
+/// CRTP Implementation of an action. This class provides a base class for
+/// implementing specific actions.
+///  Derived classes are expected to provide the following:
+///   * static constexpr StringLiteral tag = "...";
 ///     - This method returns a unique string identifier, similar to a command
 ///       line flag or DEBUG_TYPE.
-///   * static llvm::StringRef getDescription()
-///     - This method returns a short description of what the action represents.
-///
-/// This class provides a handler class that can be derived from to handle
-/// instances of this action. The parameters to its query methods map 1-1 to the
-/// types on the action type.
 template <typename Derived, typename... ParameterTs>
-class DebugAction : public DebugActionBase {
+class ActionImpl : public Action {
 public:
-  DebugAction()
-      : DebugActionBase(TypeID::get<Derived>(), Derived::getTag(),
-                        Derived::getDescription()) {}
+  ActionImpl() : Action(TypeID::get<Derived>()) {}
 
   /// Provide classof to allow casting between action types.
-  static bool classof(const DebugActionBase *action) {
+  static bool classof(const Action *action) {
     return action->getActionID() == TypeID::get<Derived>();
   }
 
-  class Handler : public DebugActionManager::HandlerBase {
+  /// Forward tag access to the derived class.
+  StringRef getTag() const final { return Derived::tag; }
+
+  class Handler : public ActionManager::HandlerBase {
   public:
     Handler() : HandlerBase(TypeID::get<Derived>()) {}
 
     /// This hook allows for controlling the execution of an action.
     /// `parameters` correspond to the set of values provided by the
     /// action as context. It should return failure if the handler could not
     /// process the action, passing it to the next registered handler.
     virtual FailureOr<bool> execute(llvm::function_ref<void()> transform,
                                     const Derived &action) {
       return failure();
     }
 
     /// Provide classof to allow casting between handler types.
-    static bool classof(const DebugActionManager::HandlerBase *handler) {
+    static bool classof(const ActionManager::HandlerBase *handler) {
       return handler->getHandlerID() == TypeID::get<Derived>();
     }
   };
 
 private:
   /// Returns true if the action can be handled within the given set of
   /// parameter types.
   template <typename... CallerParameterTs>
   static constexpr bool canHandleWith() {
     return std::is_invocable_v<function_ref<void(ParameterTs...)>,
                                CallerParameterTs...>;
   }
 
   /// Allow access to `canHandleWith`.
-  friend class DebugActionManager;
+  friend class ActionManager;
 };
 
+} // namespace tracing
 } // namespace mlir
+
+#endif // MLIR_IR_ACTION_H
 No newline at end of file

mlir/include/mlir/IR/MLIRContext.h

 #include <memory>
 #include <vector>
 
 namespace llvm {
 class ThreadPool;
 } // namespace llvm
 
 namespace mlir {
-class DebugActionManager;
+namespace tracing {
+class ActionManager;
+}
 class DiagnosticEngine;
 class Dialect;
 class DialectRegistry;
 class DynamicDialect;
 class InFlightDiagnostic;
 class Location;
 class MLIRContextImpl;
 class RegisteredOperationName;
 class StorageUniquer;
+class IRUnit;
 
 /// MLIRContext is the top-level object for a collection of MLIR operations. It
 /// holds immortal uniqued objects like types, and the tables used to unique
 /// them.
 ///
 /// MLIRContext gets a redundant "MLIR" prefix because otherwise it ends up with
 /// a very generic name ("Context") and because it is uncommon for clients to
 /// interact with it.
public:
   /// This should not be used directly.
   StorageUniquer &getTypeUniquer();
 
   /// Returns the storage uniquer used for constructing attribute storage
   /// instances. This should not be used directly.
   StorageUniquer &getAttributeUniquer();
 
   /// Returns the manager of debug actions within the context.
-  DebugActionManager &getDebugActionManager();
+  tracing::ActionManager &getActionManager();
 
   /// These APIs are tracking whether the context will be used in a
   /// multithreading environment: this has no effect other than enabling
   /// assertions on misuses of some APIs.
   void enterMultiThreadedExecution();
   void exitMultiThreadedExecution();
 
   /// Get a dialect for the provided namespace and TypeID: abort the program if

mlir/lib/CMakeLists.txt

 # Enable errors for any global constructors.
 add_flag_if_supported("-Werror=global-constructors" WERROR_GLOBAL_CONSTRUCTOR)
 
 add_subdirectory(Analysis)
 add_subdirectory(AsmParser)
 add_subdirectory(Bytecode)
 add_subdirectory(Conversion)
+add_subdirectory(Debug)
 add_subdirectory(Dialect)
 add_subdirectory(IR)
 add_subdirectory(Interfaces)
 add_subdirectory(Parser)
 add_subdirectory(Pass)
 add_subdirectory(Reducer)
 add_subdirectory(Rewrite)
 add_subdirectory(Support)
 add_subdirectory(TableGen)
 add_subdirectory(Target)
 add_subdirectory(Tools)
 add_subdirectory(Transforms)
 add_subdirectory(ExecutionEngine)

mlir/lib/Debug/CMakeLists.txt

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

mlir/lib/Debug/DebugCounter.cpp

 //===- DebugCounter.cpp - Debug Counter Facilities ------------------------===//
 //
 // 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/Support/DebugCounter.h"
+#include "mlir/Debug/Counter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace mlir;
+using namespace mlir::tracing;
 
 //===----------------------------------------------------------------------===//
 // DebugCounter CommandLine Options
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This struct contains command line options that can be used to initialize
 /// various bits of a DebugCounter. This uses a struct wrapper to avoid the need
void DebugCounter::addCounter(StringRef actionTag, int64_t countToSkip,
                               int64_t countToStopAfter) {
   assert(!counters.count(actionTag) &&
          "a counter for the given action was already registered");
   counters.try_emplace(actionTag, countToSkip, countToStopAfter);
 }
 
 // Register a counter with the specified name.
 FailureOr<bool> DebugCounter::execute(llvm::function_ref<void()> transform,
-                                      const DebugActionBase &action) {
+                                      const Action &action) {
   auto counterIt = counters.find(action.getTag());
   if (counterIt == counters.end())
     return true;
 
   ++counterIt->second.count;
 
   // We only execute while the `countToSkip` is not smaller than `count`, and
   // `countToStopAfter + countToSkip` is larger than `count`. Negative counters

mlir/lib/IR/MLIRContext.cpp

 //===- MLIRContext.cpp - MLIR Type Classes --------------------------------===//
 //
 // 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/MLIRContext.h"
 #include "AffineExprDetail.h"
 #include "AffineMapDetail.h"
 #include "AttributeDetail.h"
 #include "IntegerSetDetail.h"
 #include "TypeDetail.h"
+#include "mlir/IR/Action.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Types.h"
-#include "mlir/Support/DebugAction.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"

 /// This class is completely private to this file, so everything is public.
 class MLIRContextImpl {
 public:
   //===--------------------------------------------------------------------===//
   // Debugging
   //===--------------------------------------------------------------------===//
 
   /// An action manager for use within the context.
-  DebugActionManager debugActionManager;
+  tracing::ActionManager actionManager;
 
   //===--------------------------------------------------------------------===//
   // Diagnostics
   //===--------------------------------------------------------------------===//
   DiagnosticEngine diagEngine;
 
   //===--------------------------------------------------------------------===//
   // Options
static ArrayRef<T> copyArrayRefInto(llvm::BumpPtrAllocator &allocator,
   std::uninitialized_copy(elements.begin(), elements.end(), result);
   return ArrayRef<T>(result, elements.size());
 }
 
 //===----------------------------------------------------------------------===//
 // Debugging
 //===----------------------------------------------------------------------===//
 
-DebugActionManager &MLIRContext::getDebugActionManager() {
-  return getImpl().debugActionManager;
+tracing::ActionManager &MLIRContext::getActionManager() {
+  return getImpl().actionManager;
 }
 
 //===----------------------------------------------------------------------===//
 // Diagnostic Handlers
 //===----------------------------------------------------------------------===//
 
 /// Returns the diagnostic engine for this context.
 DiagnosticEngine &MLIRContext::getDiagEngine() { return getImpl().diagEngine; }

mlir/lib/Support/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
-  DebugCounter.cpp
   FileUtilities.cpp
   IndentedOstream.cpp
   InterfaceSupport.cpp
   StorageUniquer.cpp
   Timing.cpp
   ToolUtilities.cpp
   TypeID.cpp
 )
 
 add_mlir_library(MLIRSupport
-  DebugCounter.cpp
   FileUtilities.cpp
   IndentedOstream.cpp
   InterfaceSupport.cpp
   StorageUniquer.cpp
   Timing.cpp
   ToolUtilities.cpp
   TypeID.cpp
 

mlir/lib/Tools/mlir-opt/CMakeLists.txt

 add_mlir_library(MLIROptLib
   MlirOptMain.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Tools/mlir-opt
 
   LINK_LIBS PUBLIC
   MLIRBytecodeWriter
+  MLIRDebug
   MLIRPass
   MLIRParser
   MLIRSupport
   )

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

 //===- MlirOptMain.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This is a utility that runs an optimization pass and prints the result back
 // out. It is designed to support unit testing.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Tools/mlir-opt/MlirOptMain.h"
 #include "mlir/Bytecode/BytecodeWriter.h"
+#include "mlir/Debug/Counter.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Parser/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
-#include "mlir/Support/DebugCounter.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/Timing.h"
 #include "mlir/Support/ToolUtilities.h"
 #include "mlir/Tools/ParseUtilities.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
if (threadPool)
     context.setThreadPool(*threadPool);
 
   // Parse the input file.
   if (config.shouldPreloadDialectsInContext())
     context.loadAllAvailableDialects();
   context.allowUnregisteredDialects(config.shouldAllowUnregisteredDialects());
   if (config.shouldVerifyDiagnostics())
     context.printOpOnDiagnostic(false);
-  context.getDebugActionManager().registerActionHandler<DebugCounter>();
+  context.getActionManager().registerActionHandler<tracing::DebugCounter>();
 
   // If we are in verify diagnostics mode then we have a lot of work to do,
   // otherwise just perform the actions without worrying about it.
   if (!config.shouldVerifyDiagnostics()) {
     SourceMgrDiagnosticHandler sourceMgrHandler(*sourceMgr, &context);
     return performActions(os, sourceMgr, &context, config);
   }
 
LogicalResult mlir::MlirOptMain(int argc, char **argv, llvm::StringRef toolName,
   InitLLVM y(argc, argv);
 
   // Register any command line options.
   MlirOptMainConfig::registerCLOptions();
   registerAsmPrinterCLOptions();
   registerMLIRContextCLOptions();
   registerPassManagerCLOptions();
   registerDefaultTimingManagerCLOptions();
-  DebugCounter::registerCLOptions();
+  tracing::DebugCounter::registerCLOptions();
 
   // Build the list of dialects as a header for the --help message.
   std::string helpHeader = (toolName + "\nAvailable Dialects: ").str();
   {
     llvm::raw_string_ostream os(helpHeader);
     interleaveComma(registry.getDialectNames(), os,
                     [&](auto name) { os << name; });
   }

mlir/unittests/CMakeLists.txt

 set_target_properties(MLIRUnitTests PROPERTIES FOLDER "MLIR Tests")
 
 function(add_mlir_unittest test_dirname)
   add_unittest(MLIRUnitTests ${test_dirname} ${ARGN})
 endfunction()
 
 add_subdirectory(Analysis)
 add_subdirectory(Conversion)
+add_subdirectory(Debug)
 add_subdirectory(Dialect)
 add_subdirectory(Interfaces)
 add_subdirectory(IR)
 add_subdirectory(Parser)
 add_subdirectory(Pass)
 add_subdirectory(Support)
 add_subdirectory(Rewrite)
 add_subdirectory(TableGen)
 add_subdirectory(Transforms)
 
 if(MLIR_ENABLE_EXECUTION_ENGINE)
   add_subdirectory(ExecutionEngine)
 endif()

mlir/unittests/Debug/CMakeLists.txt

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

mlir/unittests/Debug/DebugCounterTest.cpp

 //===- DebugCounterTest.cpp - Debug Counter Tests -------------------------===//
 //
 // 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/Support/DebugCounter.h"
+#include "mlir/Debug/Counter.h"
 #include "mlir/Support/TypeID.h"
 #include "gmock/gmock.h"
 
 using namespace mlir;
+using namespace mlir::tracing;
 
 namespace {
 
-struct CounterAction : public DebugAction<CounterAction> {
+struct CounterAction : public ActionImpl<CounterAction> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CounterAction)
-  static StringRef getTag() { return "counter-action"; }
-  static StringRef getDescription() { return "Test action for debug counters"; }
+  static constexpr StringLiteral tag = "counter-action";
 };
 
 TEST(DebugCounterTest, CounterTest) {
   std::unique_ptr<DebugCounter> counter = std::make_unique<DebugCounter>();
-  counter->addCounter(CounterAction::getTag(), /*countToSkip=*/1,
+  counter->addCounter(CounterAction{}.getTag(), /*countToSkip=*/1,
                       /*countToStopAfter=*/3);
 
-  DebugActionManager manager;
+  ActionManager manager;
   manager.registerActionHandler(std::move(counter));
 
   auto noOp = []() { return; };
 
   // The first execution is skipped.
   EXPECT_FALSE(manager.execute<CounterAction>(noOp));
 
   // The counter stops after 3 successful executions.
   EXPECT_TRUE(manager.execute<CounterAction>(noOp));
   EXPECT_TRUE(manager.execute<CounterAction>(noOp));
   EXPECT_TRUE(manager.execute<CounterAction>(noOp));
   EXPECT_FALSE(manager.execute<CounterAction>(noOp));
 }
 
 } // namespace

mlir/unittests/IR/ActionTest.cpp

-//===- DebugActionTest.cpp - Debug Action Tests ---------------------------===//
+//===- ActionTest.cpp - Debug Action Tests ---------------------------===//
 //
 // 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/Support/DebugAction.h"
+#include "mlir/IR/Action.h"
 #include "mlir/Support/TypeID.h"
 #include "gmock/gmock.h"
 
 using namespace mlir;
+using namespace mlir::tracing;
 
 namespace {
-struct SimpleAction : DebugAction<SimpleAction> {
+struct SimpleAction : ActionImpl<SimpleAction> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SimpleAction)
-  static StringRef getTag() { return "simple-action"; }
-  static StringRef getDescription() { return "simple-action-description"; }
+  static constexpr StringLiteral tag = "simple-action";
 };
-struct OtherSimpleAction : DebugAction<OtherSimpleAction> {
+struct OtherSimpleAction : ActionImpl<OtherSimpleAction> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OtherSimpleAction)
-  static StringRef getTag() { return "other-simple-action"; }
-  static StringRef getDescription() {
-    return "other-simple-action-description";
-  }
+  static constexpr StringLiteral tag = "other-simple-action";
 };
-struct ParametricAction : DebugAction<ParametricAction, bool> {
+struct ParametricAction : ActionImpl<ParametricAction, bool> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ParametricAction)
   ParametricAction(bool executeParam) : executeParam(executeParam) {}
   bool executeParam;
-  static StringRef getTag() { return "param-action"; }
-  static StringRef getDescription() { return "param-action-description"; }
+  static constexpr StringLiteral tag = "param-action";
 };
 
-TEST(DebugActionTest, GenericHandler) {
-  DebugActionManager manager;
+TEST(ActionTest, GenericHandler) {
+  ActionManager manager;
 
   // A generic handler that always executes the simple action, but not the
   // parametric action.
-  struct GenericHandler : DebugActionManager::GenericHandler {
+  struct GenericHandler : ActionManager::GenericHandler {
     FailureOr<bool> execute(llvm::function_ref<void()> transform,
-                            const DebugActionBase &action) final {
-      StringRef desc = action.getDescription();
+                            const Action &action) final {
+      StringRef tag = action.getTag();
       if (isa<SimpleAction>(action)) {
-        EXPECT_EQ(desc, SimpleAction::getDescription());
+        EXPECT_EQ(tag, SimpleAction{}.getTag());
         transform();
         return true;
       }
 
       EXPECT_TRUE(isa<ParametricAction>(action));
-      EXPECT_EQ(desc, ParametricAction::getDescription());
       return false;
     }
   };
   manager.registerActionHandler<GenericHandler>();
 
   auto noOp = []() { return; };
   EXPECT_TRUE(manager.execute<SimpleAction>(noOp));
   EXPECT_FALSE(manager.execute<ParametricAction>(noOp, true));
 }
 
-TEST(DebugActionTest, ActionSpecificHandler) {
-  DebugActionManager manager;
+TEST(ActionTest, ActionSpecificHandler) {
+  ActionManager manager;
 
   // Handler that simply uses the input as the decider.
   struct ActionSpecificHandler : ParametricAction::Handler {
     FailureOr<bool> execute(llvm::function_ref<void()> transform,
                             const ParametricAction &action) final {
       if (action.executeParam)
         transform();
       return action.executeParam;
     }
   };
   manager.registerActionHandler<ActionSpecificHandler>();
 
   int count = 0;
   auto incCount = [&]() { count++; };
   EXPECT_TRUE(manager.execute<ParametricAction>(incCount, true));
   EXPECT_EQ(count, 1);
   EXPECT_FALSE(manager.execute<ParametricAction>(incCount, false));
   EXPECT_EQ(count, 1);
 
   // There is no handler for the simple action, so it is always executed.
   EXPECT_TRUE(manager.execute<SimpleAction>(incCount));
   EXPECT_EQ(count, 2);
 }
 
-TEST(DebugActionTest, DebugCounterHandler) {
-  DebugActionManager manager;
+TEST(ActionTest, DebugCounterHandler) {
+  ActionManager manager;
 
   // Handler that uses the number of action executions as the decider.
   struct DebugCounterHandler : SimpleAction::Handler {
     FailureOr<bool> execute(llvm::function_ref<void()> transform,
                             const SimpleAction &action) final {
       bool shouldExecute = numExecutions++ < 3;
       if (shouldExecute)
         transform();
       return shouldExecute;
     }
     unsigned numExecutions = 0;
   };
   manager.registerActionHandler<DebugCounterHandler>();
 
   // Check that the action is executed 3 times, but no more after.
   auto noOp = []() { return; };
   EXPECT_TRUE(manager.execute<SimpleAction>(noOp));
   EXPECT_TRUE(manager.execute<SimpleAction>(noOp));
   EXPECT_TRUE(manager.execute<SimpleAction>(noOp));
   EXPECT_FALSE(manager.execute<SimpleAction>(noOp));
   EXPECT_FALSE(manager.execute<SimpleAction>(noOp));
 }
 
-TEST(DebugActionTest, NonOverlappingActionSpecificHandlers) {
-  DebugActionManager manager;
+TEST(ActionTest, NonOverlappingActionSpecificHandlers) {
+  ActionManager manager;
 
   // One handler returns true and another returns false
   struct SimpleActionHandler : SimpleAction::Handler {
     FailureOr<bool> execute(llvm::function_ref<void()> transform,
                             const SimpleAction &action) final {
       transform();
       return true;
     }

mlir/unittests/IR/CMakeLists.txt

 add_mlir_unittest(MLIRIRTests
+  ActionTest.cpp
   AdaptorTest.cpp
   AttributeTest.cpp
   DialectTest.cpp
   InterfaceTest.cpp
   IRMapping.cpp
   InterfaceAttachmentTest.cpp
   OperationSupportTest.cpp
   PatternMatchTest.cpp

mlir/unittests/Support/CMakeLists.txt

 add_mlir_unittest(MLIRSupportTests
-  DebugActionTest.cpp
-  DebugCounterTest.cpp
   IndentedOstreamTest.cpp
   MathExtrasTest.cpp
   StorageUniquerTest.cpp
 )
 
 target_link_libraries(MLIRSupportTests
   PRIVATE MLIRSupport)