Migrate "CheckUses" pass to the auto-generated constructor (NFC)

[mehdi_amini]

Summary

See #57475

[mscuttari]

mlir/include/mlir/Dialect/Transform/Transforms/Passes.h

19

If we want to generate a constructor that is equal to the old one, this should be GEN_PASS_DECL_CHECKUSESPASS, and the pass in tablegen should be named CheckUsesPass

[mehdi_amini]

Rename CheckUses to CheckUsesPass in TableGen

[mehdi_amini]

mlir/include/mlir/Dialect/Transform/Transforms/Passes.h

19

Good point for the TableGen naming!

mlir/include/mlir/Dialect/Transform/Transforms/Passes.h

 
 #include "mlir/Pass/Pass.h"
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace transform {
-#define GEN_PASS_DECL_CHECKUSES
+#define GEN_PASS_DECL_CHECKUSESPASS
 #include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
 
-std::unique_ptr<Pass> createCheckUsesPass();
-
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
 } // namespace transform
 } // namespace mlir
 
 #endif // MLIR_DIALECT_TRANSFORM_TRANSFORMS_PASSES_H

mlir/include/mlir/Dialect/Transform/Transforms/Passes.td

 //===-- Passes.td - Transform dialect pass definitions -----*- tablegen -*-===//
 //
 // 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_DIALECT_TRANSFORM_TRANSFORMS_PASSES
 #define MLIR_DIALECT_TRANSFORM_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def CheckUses : Pass<"transform-dialect-check-uses"> {
+def CheckUsesPass : Pass<"transform-dialect-check-uses"> {
   let summary = "warn about potential use-after-free in the transform dialect";
   let description = [{
     This pass analyzes operations from the transform dialect and its extensions
     and warns if a transform IR value may be used by an operation after it was
     "freed" by some other operation, as described by side effects on the
     `TransformMappingResource`. This statically detects situations that lead to
     errors when interpreting the Transform IR.
 
     The pass is capable of handling branching control flow and reports all
     _potential_ use-after-free situations, e.g., a may-use-after-free is
     reported if at least one of the control flow paths between the definition of
     a value and its use contains an operation with a "free" effect on the
     `TransformMappingResource`. It does not currently perform an SCCP-style data
     flow analysis to prove that some branches are not taken, however, SCCP and
     other control flow simplifications can be performed on the transform IR
     prior to this pass provided that transform ops implement the relevant
     control flow interfaces.
   }];
-  let constructor = "::mlir::transform::createCheckUsesPass()";
 }
 
 #endif // MLIR_DIALECT_TRANSFORM_TRANSFORMS_PASSES

mlir/lib/Dialect/Transform/Transforms/CheckUses.cpp

 
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/ADT/SetOperations.h"
 
 namespace mlir {
 namespace transform {
-#define GEN_PASS_DEF_CHECKUSES
+#define GEN_PASS_DEF_CHECKUSESPASS
 #include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
 } // namespace transform
 } // namespace mlir
 
 using namespace mlir;
 
 namespace {
 
private:
 
   /// Caches for sets of reachable blocks.
   DenseMap<Block *, llvm::SmallPtrSet<Block *, 4>> reachableCache;
   DenseMap<Block *, llvm::SmallPtrSet<Block *, 4>> reachableFromCache;
 };
 
 //// A simple pass that warns about any use of a value by a transform operation
 // that may be using the value after it has been freed.
-class CheckUsesPass : public transform::impl::CheckUsesBase<CheckUsesPass> {
+class CheckUsesPass : public transform::impl::CheckUsesPassBase<CheckUsesPass> {
 public:
   void runOnOperation() override {
     auto &analysis = getAnalysis<TransformOpMemFreeAnalysis>();
 
     getOperation()->walk([&](Operation *child) {
       for (OpOperand &operand : child->getOpOperands()) {
         TransformOpMemFreeAnalysis::PotentialDeleters deleters =
             analysis.isUseLive(operand);
getOperation()->walk([&](Operation *child) {
         }
       }
     });
   }
 };
 
 } // namespace
 
-namespace mlir {
-namespace transform {
-std::unique_ptr<Pass> createCheckUsesPass() {
-  return std::make_unique<CheckUsesPass>();
-}
-} // namespace transform
-} // namespace mlir