[mlir][func] refactor namespace to support passing options to passes

[c-rhodes]

Summary

PATCH [2 / 3] in series for RFC: https://discourse.llvm.org/t/rfc-supporting-armv9-scalable-matrix-extension-sme-streaming-sve-ssve-mode-in-mlir/70678

[awarzynski]

Thank you :)

I am wondering whether this is really required. Looking at Bufferization/Transforms/Passes.h and then Bufferization/Transforms/Passes.td, which also defines some pass options, right? It doesn't look that different to what you are trying to do for https://reviews.llvm.org/D150934.

If this is indeed required, I'd merge this change https://reviews.llvm.org/D150934. In isolation the rationale is less clear.

[c-rhodes]

In D150933#4356283, @awarzynski wrote:

Thank you :)

I am wondering whether this is really required. Looking at Bufferization/Transforms/Passes.h and then Bufferization/Transforms/Passes.td, which also defines some pass options, right? It doesn't look that different to what you are trying to do for https://reviews.llvm.org/D150934.

If this is indeed required, I'd merge this change https://reviews.llvm.org/D150934. In isolation the rationale is less clear.

Thanks for the pointer, this patch isn't necessary when following how it's done there, abandoning this and updating the pass, cheers!

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

 
 namespace mlir {
 namespace bufferization {
 class BufferizeTypeConverter;
 } // namespace bufferization
 
 class RewritePatternSet;
 
-namespace func {
 
 #define GEN_PASS_DECL
 #include "mlir/Dialect/Func/Transforms/Passes.h.inc"
 
 /// Creates an instance of func bufferization pass.
 std::unique_ptr<Pass> createFuncBufferizePass();
 
 /// Pass to deduplicate functions.
 std::unique_ptr<Pass> createDuplicateFunctionEliminationPass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Func/Transforms/Passes.h.inc"
 
-} // namespace func
 } // namespace mlir
 
 #endif // MLIR_DIALECT_FUNC_TRANSFORMS_PASSES_H

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

let description = [{
     `BranchOpInterface`.
     As this pass rewrites function operations, it also rewrites the
     corresponding return operations. Other return-like operations that
     implement the `ReturnLike` trait are not rewritten in general, as they
     require that the corresponding parent operation is also rewritten.
     Finally, this pass fails for unknown terminators, as we cannot decide
     whether they need rewriting.
   }];
-  let constructor = "mlir::func::createFuncBufferizePass()";
+  let constructor = "mlir::createFuncBufferizePass()";
   let dependentDialects = ["bufferization::BufferizationDialect",
                            "memref::MemRefDialect"];
 }
 
 def DuplicateFunctionEliminationPass : Pass<"duplicate-function-elimination",
     "ModuleOp"> {
   let summary = "Deduplicate functions";
   let description = [{
     Deduplicate functions that are equivalent in all aspects but their symbol
     name. The pass chooses one representative per equivalence class, erases
     the remainder, and updates function calls accordingly.
   }];
-  let constructor = "mlir::func::createDuplicateFunctionEliminationPass()";
+  let constructor = "mlir::createDuplicateFunctionEliminationPass()";
 }
 
 #endif // MLIR_DIALECT_FUNC_TRANSFORMS_PASSES_TD

mlir/include/mlir/InitAllPasses.h

inline void registerAllPasses() {
   registerConversionPasses();
 
   // Dialect passes
   affine::registerAffinePasses();
   amdgpu::registerAMDGPUPasses();
   registerAsyncPasses();
   arith::registerArithPasses();
   bufferization::registerBufferizationPasses();
-  func::registerFuncPasses();
+  registerFuncPasses();
   registerGPUPasses();
   registerGpuSerializeToCubinPass();
   registerGpuSerializeToHsacoPass();
   registerLinalgPasses();
   registerNVGPUPasses();
   registerSparseTensorPasses();
   LLVM::registerLLVMPasses();
   memref::registerMemRefPasses();

mlir/lib/Dialect/Func/Transforms/DuplicateFunctionElimination.cpp

 //===- DuplicateFunctionElimination.cpp - Duplicate function elimination --===//
 //
 // 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/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Func/Transforms/Passes.h"
 
 namespace mlir {
-namespace {
-
 #define GEN_PASS_DEF_DUPLICATEFUNCTIONELIMINATIONPASS
 #include "mlir/Dialect/Func/Transforms/Passes.h.inc"
+} // namespace mlir
+
+using namespace mlir;
+using namespace mlir::func;
 
+namespace {
 // Define a notion of function equivalence that allows for reuse. Ignore the
 // symbol name for this purpose.
 struct DuplicateFuncOpEquivalenceInfo
     : public llvm::DenseMapInfo<func::FuncOp> {
 
   static unsigned getHashValue(const func::FuncOp cFunc) {
     if (!cFunc) {
       return DenseMapInfo<func::FuncOp>::getHashValue(cFunc);
void runOnOperation() override {
     for (auto it : toBeErased) {
       it.erase();
     }
   }
 };
 
 } // namespace
 
-std::unique_ptr<Pass> mlir::func::createDuplicateFunctionEliminationPass() {
+std::unique_ptr<Pass> mlir::createDuplicateFunctionEliminationPass() {
   return std::make_unique<DuplicateFunctionEliminationPass>();
 }
-
-} // namespace mlir

mlir/lib/Dialect/Func/Transforms/FuncBufferize.cpp

void runOnOperation() override {
     });
 
     if (failed(applyFullConversion(module, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<Pass> mlir::func::createFuncBufferizePass() {
+std::unique_ptr<Pass> mlir::createFuncBufferizePass() {
   return std::make_unique<FuncBufferizePass>();
 }