include "mlir/Pass/PassBase.td"
-def FIRToLLVMLoweringPass : Pass<"fir-to-llvm-ir", "mlir::ModuleOp"> {
+def FIRToLLVMLowering : Pass<"fir-to-llvm-ir", "mlir::ModuleOp"> {
let summary = "Convert FIR dialect to LLVM-IR dialect";
let description = [{
Convert the FIR dialect to the LLVM-IR dialect of MLIR. This conversion
];
}
-def CodeGenRewritePass : Pass<"cg-rewrite", "mlir::ModuleOp"> {
+def CodeGenRewrite : Pass<"cg-rewrite", "mlir::ModuleOp"> {
let summary = "Rewrite some FIR ops into their code-gen forms.";
let description = [{
Fuse specific subgraphs into single Ops for code generation.
];
}
-def TargetRewritePass : Pass<"target-rewrite", "mlir::ModuleOp"> {
+def TargetRewrite : Pass<"target-rewrite", "mlir::ModuleOp"> {
let summary = "Rewrite some FIR dialect into target specific forms.";
let description = [{
Certain abstractions in the FIR dialect need to be rewritten to reflect
struct NameUniquer;
-#define GEN_PASS_DECL_FIRTOLLVMLOWERINGPASS
-#define GEN_PASS_DECL_CODEGENREWRITEPASS
-#define GEN_PASS_DECL_TARGETREWRITEPASS
-#define GEN_PASS_DECL_BOXEDPROCEDUREPASS
-#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
-
/// Prerequiste pass for code gen. Perform intermediate rewrites to perform
/// the code gen (to LLVM-IR dialect) conversion.
std::unique_ptr<mlir::Pass> createFirCodeGenRewritePass();
// Passes defined in Passes.td
//===----------------------------------------------------------------------===//
-#define GEN_PASS_DECL_ABSTRACTRESULTONFUNCOPTPASS
-#define GEN_PASS_DECL_ABSTRACTRESULTONGLOBALOPTPASS
-#define GEN_PASS_DECL_AFFINEDIALECTPROMOTIONPASS
-#define GEN_PASS_DECL_AFFINEDIALECTDEMOTIONPASS
-#define GEN_PASS_DECL_ANNOTATECONSTANTOPERANDSPASS
-#define GEN_PASS_DECL_ARRAYVALUECOPYPASS
-#define GEN_PASS_DECL_CHARACTERCONVERSIONPASS
-#define GEN_PASS_DECL_CFGCONVERSIONPASS
-#define GEN_PASS_DECL_EXTERNALNAMECONVERSIONPASS
-#define GEN_PASS_DECL_MEMREFDATAFLOWOPTPASS
-#define GEN_PASS_DECL_SIMPLIFYINTRINSICSPASS
-#define GEN_PASS_DECL_MEMORYALLOCATIONOPTPASS
-#define GEN_PASS_DECL_SIMPLIFYREGIONLITEPASS
-#define GEN_PASS_DECL_ALGEBRAICSIMPLIFICATIONPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-
std::unique_ptr<mlir::Pass> createAbstractResultOnFuncOptPass();
std::unique_ptr<mlir::Pass> createAbstractResultOnGlobalOptPass();
std::unique_ptr<mlir::Pass> createAffineDemotionPass();
include "mlir/Pass/PassBase.td"
-class AbstractResultOptBase<string optExt, string operation>
+class AbstractResultOptBase<string optExt, string operation>
: Pass<"abstract-result-on-" # optExt # "-opt", operation> {
let summary = "Convert fir.array, fir.box and fir.rec function result to "
"function argument";
];
}
-def AbstractResultOnFuncOptPass : AbstractResultOptBase<"func", "mlir::func::FuncOp"> {
+def AbstractResultOnFuncOpt : AbstractResultOptBase<"func", "mlir::func::FuncOp"> {
let constructor = "::fir::createAbstractResultOnFuncOptPass()";
}
-def AbstractResultOnGlobalOptPass : AbstractResultOptBase<"global", "fir::GlobalOp"> {
+def AbstractResultOnGlobalOpt : AbstractResultOptBase<"global", "fir::GlobalOp"> {
let constructor = "::fir::createAbstractResultOnGlobalOptPass()";
}
-def AffineDialectPromotionPass : Pass<"promote-to-affine", "::mlir::func::FuncOp"> {
+def AffineDialectPromotion : Pass<"promote-to-affine", "::mlir::func::FuncOp"> {
let summary = "Promotes `fir.{do_loop,if}` to `affine.{for,if}`.";
let description = [{
Convert fir operations which satisfy affine constraints to the affine
];
}
-def AffineDialectDemotionPass : Pass<"demote-affine", "::mlir::func::FuncOp"> {
+def AffineDialectDemotion : Pass<"demote-affine", "::mlir::func::FuncOp"> {
let summary = "Converts `affine.{load,store}` back to fir operations";
let description = [{
Affine dialect's default lowering for loads and stores is different from
];
}
-def AnnotateConstantOperandsPass : Pass<"annotate-constant"> {
+def AnnotateConstantOperands : Pass<"annotate-constant"> {
let summary = "Annotate constant operands to all FIR operations";
let description = [{
The MLIR canonicalizer makes a distinction between constants based on how
let dependentDialects = [ "fir::FIROpsDialect" ];
}
-def ArrayValueCopyPass : Pass<"array-value-copy", "::mlir::func::FuncOp"> {
+def ArrayValueCopy : Pass<"array-value-copy", "::mlir::func::FuncOp"> {
let summary = "Convert array value operations to memory operations.";
let description = [{
Transform the set of array value primitives to a memory-based array
let dependentDialects = [ "fir::FIROpsDialect" ];
}
-def CharacterConversionPass : Pass<"character-conversion"> {
+def CharacterConversion : Pass<"character-conversion"> {
let summary = "Convert CHARACTER entities with different KINDs";
let description = [{
Translates entities of one CHARACTER KIND to another.
];
}
-def CFGConversionPass : Pass<"cfg-conversion", "::mlir::func::FuncOp"> {
+def CFGConversion : Pass<"cfg-conversion", "::mlir::func::FuncOp"> {
let summary = "Convert FIR structured control flow ops to CFG ops.";
let description = [{
Transform the `fir.do_loop`, `fir.if`, and `fir.iterate_while` ops into
];
}
-def ExternalNameConversionPass : Pass<"external-name-interop", "mlir::ModuleOp"> {
+def ExternalNameConversion : Pass<"external-name-interop", "mlir::ModuleOp"> {
let summary = "Convert name for external interoperability";
let description = [{
Demangle FIR internal name and mangle them for external interoperability.
let constructor = "::fir::createExternalNameConversionPass()";
}
-def MemRefDataFlowOptPass : Pass<"fir-memref-dataflow-opt", "::mlir::func::FuncOp"> {
+def MemRefDataFlowOpt : Pass<"fir-memref-dataflow-opt", "::mlir::func::FuncOp"> {
let summary =
"Perform store/load forwarding and potentially removing dead stores.";
let description = [{
// functions into the module, which is invalid if a finer grain mlir::Operation
// is used as the pass specification says to not touch things outside hte scope
// of the operation being processed.
-def SimplifyIntrinsicsPass : Pass<"simplify-intrinsics", "mlir::ModuleOp"> {
+def SimplifyIntrinsics : Pass<"simplify-intrinsics", "mlir::ModuleOp"> {
let summary = "Intrinsics simplification";
let description = [{
Qualifying intrinsics calls are replaced with calls to a specialized and
];
}
-def MemoryAllocationOptPass : Pass<"memory-allocation-opt", "mlir::func::FuncOp"> {
+def MemoryAllocationOpt : Pass<"memory-allocation-opt", "mlir::func::FuncOp"> {
let summary = "Convert stack to heap allocations and vice versa.";
let description = [{
Convert stack allocations to heap allocations and vice versa based on
let constructor = "::fir::createMemoryAllocationPass()";
}
-def SimplifyRegionLitePass : Pass<"simplify-region-lite", "mlir::ModuleOp"> {
+def SimplifyRegionLite : Pass<"simplify-region-lite", "mlir::ModuleOp"> {
let summary = "Region simplification";
let description = [{
Run region DCE and erase unreachable blocks in regions.
let constructor = "::fir::createSimplifyRegionLitePass()";
}
-def AlgebraicSimplificationPass : Pass<"flang-algebraic-simplification"> {
+def AlgebraicSimplification : Pass<"flang-algebraic-simplification"> {
let summary = "";
let description = [{
Run algebraic simplifications for Math/Complex/etc. dialect operations.
// convert control flow to CFG form
fir::addCfgConversionPass(pm);
- pm.addPass(mlir::createConvertSCFToControlFlowPass());
+ pm.addPass(mlir::createConvertSCFToCFPass());
pm.addPass(mlir::createCanonicalizerPass(config));
pm.addPass(fir::createSimplifyRegionLitePass());
//
//===----------------------------------------------------------------------===//
-#include "flang/Optimizer/CodeGen/CodeGen.h"
-
+#include "PassDetail.h"
#include "flang/Optimizer/Builder/FIRBuilder.h"
#include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace fir {
-#define GEN_PASS_DEF_BOXEDPROCEDUREPASS
-#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-procedure-pointer"
using namespace fir;
/// the frame pointer during execution. In LLVM IR, the frame pointer is
/// designated with the `nest` attribute. The thunk's address will then be used
/// as the call target instead of the original function's address directly.
-class BoxedProcedurePass
- : public fir::impl::BoxedProcedurePassBase<BoxedProcedurePass> {
+class BoxedProcedurePass : public BoxedProcedurePassBase<BoxedProcedurePass> {
public:
BoxedProcedurePass() { options = {true}; }
BoxedProcedurePass(bool useThunks) { options = {useThunks}; }
//===----------------------------------------------------------------------===//
#include "flang/Optimizer/CodeGen/CodeGen.h"
-
#include "CGOps.h"
+#include "PassDetail.h"
#include "flang/ISO_Fortran_binding.h"
#include "flang/Optimizer/Dialect/FIRAttr.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
#include "mlir/Conversion/MathToLibm/MathToLibm.h"
#include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Matchers.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Target/LLVMIR/ModuleTranslation.h"
#include "llvm/ADT/ArrayRef.h"
-namespace fir {
-#define GEN_PASS_DEF_FIRTOLLVMLOWERINGPASS
-#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-codegen"
// fir::LLVMTypeConverter for converting to LLVM IR dialect types.
auto ptr = adaptor.getOperands()[0];
if (isPresent.getVal().getType().isa<fir::BoxCharType>()) {
- [[maybe_unused]] auto structTy =
- ptr.getType().cast<mlir::LLVM::LLVMStructType>();
+ [[maybe_unused]] auto structTy = ptr.getType().cast<mlir::LLVM::LLVMStructType>();
assert(!structTy.isOpaque() && !structTy.getBody().empty());
ptr = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ptr, 0);
///
/// This pass lowers all FIR dialect operations to LLVM IR dialect. An
/// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
-class FIRToLLVMLowering
- : public fir::impl::FIRToLLVMLoweringPassBase<FIRToLLVMLowering> {
+class FIRToLLVMLowering : public fir::FIRToLLVMLoweringBase<FIRToLLVMLowering> {
public:
FIRToLLVMLowering() = default;
FIRToLLVMLowering(fir::FIRToLLVMPassOptions options) : options{options} {}
//
//===----------------------------------------------------------------------===//
-#include "flang/Optimizer/CodeGen/CodeGen.h"
-
#include "CGOps.h"
+#include "PassDetail.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Debug.h"
-namespace fir {
-#define GEN_PASS_DEF_CODEGENREWRITEPASS
-#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
-} // namespace fir
-
//===----------------------------------------------------------------------===//
// Codegen rewrite: rewriting of subgraphs of ops
//===----------------------------------------------------------------------===//
}
};
-class CodeGenRewrite
- : public fir::impl::CodeGenRewritePassBase<CodeGenRewrite> {
+class CodeGenRewrite : public fir::CodeGenRewriteBase<CodeGenRewrite> {
public:
void runOn(mlir::Operation *op, mlir::Region ®ion) {
auto &context = getContext();
//
//===----------------------------------------------------------------------===//
-#include "flang/Optimizer/CodeGen/CodeGen.h"
-
+#include "PassDetail.h"
#include "Target.h"
#include "flang/Optimizer/Builder/Character.h"
#include "flang/Optimizer/Builder/FIRBuilder.h"
#include "flang/Optimizer/Builder/Todo.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIROpsSupport.h"
#include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/Debug.h"
-namespace fir {
-#define GEN_PASS_DEF_TARGETREWRITEPASS
-#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-target-rewrite"
namespace {
/// generation that traverses the FIR and modifies types and operations to a
/// form that is appropriate for the specific target. LLVM IR has specific
/// idioms that are used for distinct target processor and ABI combinations.
-class TargetRewrite : public fir::impl::TargetRewritePassBase<TargetRewrite> {
+class TargetRewrite : public fir::TargetRewriteBase<TargetRewrite> {
public:
TargetRewrite(const fir::TargetRewriteOptions &options) {
noCharacterConversion = options.noCharacterConversion;
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Builder/Todo.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "mlir/Transforms/Passes.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace fir {
-#define GEN_PASS_DEF_ABSTRACTRESULTONFUNCOPTPASS
-#define GEN_PASS_DEF_ABSTRACTRESULTONGLOBALOPTPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-abstract-result-opt"
namespace fir {
};
class AbstractResultOnFuncOpt
- : public AbstractResultOptTemplate<
- AbstractResultOnFuncOpt, fir::impl::AbstractResultOnFuncOptPassBase> {
+ : public AbstractResultOptTemplate<AbstractResultOnFuncOpt,
+ fir::AbstractResultOnFuncOptBase> {
public:
void runOnSpecificOperation(mlir::func::FuncOp func, bool shouldBoxResult,
mlir::RewritePatternSet &patterns,
}
class AbstractResultOnGlobalOpt
- : public AbstractResultOptTemplate<
- AbstractResultOnGlobalOpt,
- fir::impl::AbstractResultOnGlobalOptPassBase> {
+ : public AbstractResultOptTemplate<AbstractResultOnGlobalOpt,
+ fir::AbstractResultOnGlobalOptBase> {
public:
void runOnSpecificOperation(fir::GlobalOp global, bool,
mlir::RewritePatternSet &,
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
-namespace fir {
-#define GEN_PASS_DEF_AFFINEDIALECTDEMOTIONPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-affine-demotion"
using namespace fir;
};
class AffineDialectDemotion
- : public fir::impl::AffineDialectDemotionPassBase<AffineDialectDemotion> {
+ : public AffineDialectDemotionBase<AffineDialectDemotion> {
public:
void runOnOperation() override {
auto *context = &getContext();
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "llvm/ADT/Optional.h"
#include "llvm/Support/Debug.h"
-namespace fir {
-#define GEN_PASS_DEF_AFFINEDIALECTPROMOTIONPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-affine-promotion"
using namespace fir;
/// Promote fir.do_loop and fir.if to affine.for and affine.if, in the cases
/// where such a promotion is possible.
class AffineDialectPromotion
- : public fir::impl::AffineDialectPromotionPassBase<AffineDialectPromotion> {
+ : public AffineDialectPromotionBase<AffineDialectPromotion> {
public:
void runOnOperation() override {
// the parameters of the patterns for Fortran programs.
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Transforms/Passes.h"
-#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Math/Transforms/Passes.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace fir {
-#define GEN_PASS_DEF_ALGEBRAICSIMPLIFICATIONPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
using namespace mlir;
namespace {
struct AlgebraicSimplification
- : public fir::impl::AlgebraicSimplificationPassBase<
- AlgebraicSimplification> {
+ : public fir::AlgebraicSimplificationBase<AlgebraicSimplification> {
AlgebraicSimplification(const GreedyRewriteConfig &rewriteConfig) {
config = rewriteConfig;
}
//
//===----------------------------------------------------------------------===//
-// #include "PassDetail.h"
-#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Transforms/Passes.h"
#include "mlir/IR/BuiltinAttributes.h"
-namespace fir {
-#define GEN_PASS_DEF_ANNOTATECONSTANTOPERANDSPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-annotate-constant"
using namespace fir;
namespace {
struct AnnotateConstantOperands
- : impl::AnnotateConstantOperandsPassBase<AnnotateConstantOperands> {
+ : AnnotateConstantOperandsBase<AnnotateConstantOperands> {
void runOnOperation() override {
auto *context = &getContext();
mlir::Dialect *firDialect = context->getLoadedDialect("fir");
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Builder/Array.h"
#include "flang/Optimizer/Builder/BoxValue.h"
#include "flang/Optimizer/Builder/FIRBuilder.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/Support/Debug.h"
-namespace fir {
-#define GEN_PASS_DEF_ARRAYVALUECOPYPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-array-value-copy"
using namespace fir;
};
class ArrayValueCopyConverter
- : public fir::impl::ArrayValueCopyPassBase<ArrayValueCopyConverter> {
+ : public ArrayValueCopyBase<ArrayValueCopyConverter> {
public:
void runOnOperation() override {
auto func = getOperation();
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "flang/Optimizer/Support/FIRContext.h"
#include "flang/Optimizer/Support/KindMapping.h"
#include "flang/Optimizer/Transforms/Passes.h"
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Diagnostics.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/Support/Debug.h"
-namespace fir {
-#define GEN_PASS_DEF_CHARACTERCONVERSIONPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-character-conversion"
namespace {
/// Rewrite the `fir.char_convert` op into a loop. This pass must be run only on
/// fir::CharConvertOp.
class CharacterConversion
- : public fir::impl::CharacterConversionPassBase<CharacterConversion> {
+ : public fir::CharacterConversionBase<CharacterConversion> {
public:
void runOnOperation() override {
CharacterConversionOptions clOpts{useRuntimeCalls.getValue()};
//
//===----------------------------------------------------------------------===//
-#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Support/InternalNames.h"
#include "flang/Optimizer/Transforms/Passes.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace fir {
-#define GEN_PASS_DEF_EXTERNALNAMECONVERSIONPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
using namespace mlir;
//===----------------------------------------------------------------------===//
};
class ExternalNameConversionPass
- : public fir::impl::ExternalNameConversionPassBase<
- ExternalNameConversionPass> {
+ : public fir::ExternalNameConversionBase<ExternalNameConversionPass> {
public:
mlir::ModuleOp getModule() { return getOperation(); }
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
-namespace fir {
-#define GEN_PASS_DEF_MEMREFDATAFLOWOPTPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "fir-memref-dataflow-opt"
using namespace mlir;
mlir::DominanceInfo *domInfo;
};
-class MemDataFlowOpt
- : public fir::impl::MemRefDataFlowOptPassBase<MemDataFlowOpt> {
+class MemDataFlowOpt : public fir::MemRefDataFlowOptBase<MemDataFlowOpt> {
public:
void runOnOperation() override {
mlir::func::FuncOp f = getOperation();
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "mlir/Transforms/Passes.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace fir {
-#define GEN_PASS_DEF_MEMORYALLOCATIONOPTPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-memory-allocation-opt"
// Number of elements in an array does not determine where it is allocated.
/// 2. If a stack allocation is an array with a runtime evaluated size make
/// it a heap allocation.
class MemoryAllocationOpt
- : public fir::impl::MemoryAllocationOptPassBase<MemoryAllocationOpt> {
+ : public fir::MemoryAllocationOptBase<MemoryAllocationOpt> {
public:
MemoryAllocationOpt() {
// Set options with default values. (See Passes.td.) Note that the
--- /dev/null
+//===- PassDetail.h - Optimizer Transforms Pass class details ---*- 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 FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H
+#define FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H
+
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/Math/IR/Math.h"
+#include "mlir/Dialect/OpenACC/OpenACC.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassRegistry.h"
+
+namespace fir {
+
+#define GEN_PASS_CLASSES
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+
+} // namespace fir
+
+#endif // FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Transforms/Passes.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/Support/CommandLine.h"
-namespace fir {
-#define GEN_PASS_DEF_CFGCONVERSIONPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
using namespace fir;
using namespace mlir;
};
/// Convert FIR structured control flow ops to CFG ops.
-class CfgConversion : public fir::impl::CFGConversionPassBase<CfgConversion> {
+class CfgConversion : public CFGConversionBase<CfgConversion> {
public:
void runOnOperation() override {
auto *context = &getContext();
/// and small in size.
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Builder/BoxValue.h"
#include "flang/Optimizer/Builder/FIRBuilder.h"
#include "flang/Optimizer/Builder/Todo.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "flang/Optimizer/Support/FIRContext.h"
#include "flang/Optimizer/Transforms/Passes.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/Matchers.h"
#include "mlir/IR/TypeUtilities.h"
#include "mlir/Pass/Pass.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
-namespace fir {
-#define GEN_PASS_DEF_SIMPLIFYINTRINSICSPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
#define DEBUG_TYPE "flang-simplify-intrinsics"
namespace {
class SimplifyIntrinsicsPass
- : public fir::impl::SimplifyIntrinsicsPassBase<SimplifyIntrinsicsPass> {
+ : public fir::SimplifyIntrinsicsBase<SimplifyIntrinsicsPass> {
using FunctionTypeGeneratorTy =
std::function<mlir::FunctionType(fir::FirOpBuilder &)>;
using FunctionBodyGeneratorTy =
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Transforms/Passes.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/RegionUtils.h"
-namespace fir {
-#define GEN_PASS_DEF_SIMPLIFYREGIONLITEPASS
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-} // namespace fir
-
namespace {
class SimplifyRegionLitePass
- : public fir::impl::SimplifyRegionLitePassBase<SimplifyRegionLitePass> {
+ : public fir::SimplifyRegionLiteBase<SimplifyRegionLitePass> {
public:
void runOnOperation() override;
};
class RewritePatternSet;
class Pass;
-#define GEN_PASS_DECL_CONVERTAMDGPUTOROCDLPASS
-#include "mlir/Conversion/Passes.h.inc"
-
void populateAMDGPUToROCDLConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns,
amdgpu::Chipset chipset);
+std::unique_ptr<Pass> createConvertAMDGPUToROCDLPass();
+
} // namespace mlir
#endif // MLIR_CONVERSION_AMDGPUTOROCDL_AMDGPUTOROCDL_H_
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTAFFINETOSTANDARDPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Collect a set of patterns to convert from the Affine dialect to the Standard
/// dialect, in particular convert structured affine control flow into CFG
/// branch-based control flow.
/// standard arithmetic operations.
Value lowerAffineUpperBound(AffineForOp op, OpBuilder &builder);
+/// Lowers affine control flow operations (ForStmt, IfStmt and AffineApplyOp)
+/// to equivalent lower-level constructs (flow of basic blocks and arithmetic
+/// primitives).
+std::unique_ptr<Pass> createLowerAffinePass();
+
} // namespace mlir
#endif // MLIR_CONVERSION_AFFINETOSTANDARD_AFFINETOSTANDARD_H
class RewritePatternSet;
class Pass;
-#define GEN_PASS_DECL_CONVERTARITHMETICTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
namespace arith {
void populateArithmeticToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
+std::unique_ptr<Pass> createConvertArithmeticToLLVMPass();
} // namespace arith
} // namespace mlir
class RewritePatternSet;
class Pass;
-#define GEN_PASS_DECL_CONVERTARITHMETICTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
namespace arith {
void populateArithmeticToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
RewritePatternSet &patterns);
-} // namespace arith
-
std::unique_ptr<OperationPass<>> createConvertArithmeticToSPIRVPass();
-
+} // namespace arith
} // namespace mlir
#endif // MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H
#ifndef MLIR_CONVERSION_ARMNEON2DTOINTR_ARMNEON2DTOINTR_H_
#define MLIR_CONVERSION_ARMNEON2DTOINTR_ARMNEON2DTOINTR_H_
-#include <memory>
+#include "mlir/Pass/Pass.h"
namespace mlir {
-class Pass;
-class RewritePatternSet;
-
-#define GEN_PASS_DECL_CONVERTARMNEON2DTOINTRPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Populates patterns for the lowering of Arm NEON 2D ops to intrinsics.
/// See createConvertArmNeon2dToIntrPass.
void populateConvertArmNeon2dToIntrPatterns(RewritePatternSet &patterns);
+/// Creates a pass to lower Arm NEON 2D ops to intrinsics, i.e.
+/// equivalent ops operating on flattened 1D vectors and mapping more
+/// directly to the corresponding Arm NEON instruction.
+std::unique_ptr<Pass> createConvertArmNeon2dToIntrPass();
+
} // namespace mlir
#endif // MLIR_CONVERSION_ARMNEON2DTOINTR_ARMNEON2DTOINTR_H_
class TypeConverter;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTASYNCTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
+/// Create a pass to convert Async operations to the LLVM dialect.
+std::unique_ptr<OperationPass<ModuleOp>> createConvertAsyncToLLVMPass();
/// Populates patterns for async structural type conversions.
///
TypeConverter &typeConverter, RewritePatternSet &patterns,
ConversionTarget &target);
-/// Create a pass to convert Async operations to the LLVM dialect.
-std::unique_ptr<OperationPass<ModuleOp>> createConvertAsyncToLLVMPass();
-
} // namespace mlir
#endif // MLIR_CONVERSION_ASYNCTOLLVM_ASYNCTOLLVM_H
class Pass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTBUFFERIZATIONTOMEMREFPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Collect a set of patterns to convert memory-related operations from the
/// Bufferization dialect to the MemRef dialect.
void populateBufferizationToMemRefConversionPatterns(
RewritePatternSet &patterns);
+std::unique_ptr<Pass> createBufferizationToMemRefPass();
} // namespace mlir
#endif // MLIR_CONVERSION_BUFFERIZATIONTOMEMREF_BUFFERIZATIONTOMEMREF_H
class Pass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTCOMPLEXTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
class ComplexStructBuilder : public StructBuilder {
public:
/// Construct a helper for the given complex number value.
void populateComplexToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
+/// Create a pass to convert Complex operations to the LLVMIR dialect.
+std::unique_ptr<Pass> createConvertComplexToLLVMPass();
+
} // namespace mlir
#endif // MLIR_CONVERSION_COMPLEXTOLLVM_COMPLEXTOLLVM_H_
template <typename T>
class OperationPass;
-#define GEN_PASS_DECL_CONVERTCOMPLEXTOLIBMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Populate the given list with patterns that convert from Complex to Libm
/// calls.
void populateComplexToLibmConversionPatterns(RewritePatternSet &patterns,
class RewritePatternSet;
class Pass;
-#define GEN_PASS_DECL_CONVERTCOMPLEXTOSTANDARDPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Populate the given list with patterns that convert from Complex to Standard.
void populateComplexToStandardConversionPatterns(RewritePatternSet &patterns);
+/// Create a pass to convert Complex operations to the Standard dialect.
+std::unique_ptr<Pass> createConvertComplexToStandardPass();
+
} // namespace mlir
#endif // MLIR_CONVERSION_COMPLEXTOSTANDARD_COMPLEXTOSTANDARD_H_
class RewritePatternSet;
class Pass;
-#define GEN_PASS_DECL_CONVERTCONTROLFLOWTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
namespace cf {
/// Collect the patterns to convert from the ControlFlow dialect to LLVM. The
/// conversion patterns capture the LLVMTypeConverter by reference meaning the
void populateControlFlowToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
+/// Creates a pass to convert the ControlFlow dialect into the LLVMIR dialect.
+std::unique_ptr<Pass> createConvertControlFlowToLLVMPass();
} // namespace cf
} // namespace mlir
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_CONVERTCONTROLFLOWTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert ControlFlow ops to SPIR-V ops.
std::unique_ptr<OperationPass<>> createConvertControlFlowToSPIRVPass();
#define MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVMPASS_H_
#include <memory>
-#include <string>
namespace mlir {
class LowerToLLVMOptions;
class OperationPass;
class Pass;
-#define GEN_PASS_DECL_CONVERTFUNCTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert the Func dialect into the LLVMIR dialect.
std::unique_ptr<OperationPass<ModuleOp>> createConvertFuncToLLVMPass();
std::unique_ptr<OperationPass<ModuleOp>>
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_CONVERTFUNCTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert Func ops to SPIR-V ops.
std::unique_ptr<OperationPass<>> createConvertFuncToSPIRVPass();
class LLVMDialect;
} // namespace LLVM
-#define GEN_PASS_DECL_CONVERTGPUTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
using OwnedBlob = std::unique_ptr<std::vector<char>>;
using BlobGenerator =
std::function<OwnedBlob(const std::string &, Location, StringRef)>;
using LoweringCallback = std::function<std::unique_ptr<llvm::Module>(
Operation *, llvm::LLVMContext &, StringRef)>;
-/// Collect a set of patterns to convert from the GPU dialect to LLVM and
-/// populate converter for gpu types.
-void populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,
- RewritePatternSet &patterns,
- StringRef gpuBinaryAnnotation = {},
- bool kernelBarePtrCallConv = false);
-
/// Creates a pass to convert a GPU operations into a sequence of GPU runtime
/// calls.
///
/// instead uses a small wrapper library that exports a stable and conveniently
/// typed ABI on top of GPU runtimes such as CUDA or ROCm (HIP).
std::unique_ptr<OperationPass<ModuleOp>>
-createConvertGpuToLLVMPass(bool kernelBarePtrCallConv = false);
+createGpuToLLVMConversionPass(bool kernelBarePtrCallConv = false);
+
+/// Collect a set of patterns to convert from the GPU dialect to LLVM and
+/// populate converter for gpu types.
+void populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,
+ RewritePatternSet &patterns,
+ StringRef gpuBinaryAnnotation = {},
+ bool kernelBarePtrCallConv = false);
} // namespace mlir
class MMAMatrixType;
} // namespace gpu
-#define GEN_PASS_DECL_CONVERTGPUTONVVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
LLVM::LLVMStructType convertMMAToLLVMType(gpu::MMAMatrixType type);
/// Configure target to convert from the GPU dialect to NVVM.
/// Creates a pass that lowers GPU dialect operations to NVVM counterparts. The
/// index bitwidth used for the lowering of the device side index computations
/// is configurable.
-std::unique_ptr<OperationPass<gpu::GPUModuleOp>> createConvertGpuToNVVMPass(
+std::unique_ptr<OperationPass<gpu::GPUModuleOp>> createLowerGpuOpsToNVVMOpsPass(
unsigned indexBitwidth = kDeriveIndexBitwidthFromDataLayout);
} // namespace mlir
class GPUModuleOp;
} // namespace gpu
-#define GEN_PASS_DECL_CONVERTGPUTOROCDLPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Collect a set of patterns to convert from the GPU dialect to ROCDL.
/// If `runtime` is Unknown, gpu.printf will not be lowered
/// The resulting pattern set should be run over a gpu.module op
/// Creates a pass that lowers GPU dialect operations to ROCDL counterparts. The
/// index bitwidth used for the lowering of the device side index computations
/// is configurable.
-std::unique_ptr<OperationPass<gpu::GPUModuleOp>> createConvertGpuToROCDLPass(
+std::unique_ptr<OperationPass<gpu::GPUModuleOp>>
+createLowerGpuOpsToROCDLOpsPass(
const std::string &chipset = "gfx900",
unsigned indexBitwidth = kDeriveIndexBitwidthFromDataLayout,
bool useBarePtrCallConv = false,
template <typename T>
class OperationPass;
-#define GEN_PASS_DECL_CONVERTGPUTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert GPU kernel ops to corresponding SPIR-V ops. For a
/// gpu.func to be converted, it should have a spv.entry_point_abi attribute.
/// If `mapMemorySpace` is true, performs MemRef memory space to SPIR-V mapping
template <typename T>
class OperationPass;
-#define GEN_PASS_DECL_CONVERTVULKANLAUNCHFUNCTOVULKANCALLSPASS
-#define GEN_PASS_DECL_CONVERTGPULAUNCHFUNCTOVULKANLAUNCHFUNCPASS
-#include "mlir/Conversion/Passes.h.inc"
-
std::unique_ptr<OperationPass<ModuleOp>>
createConvertVulkanLaunchFuncToVulkanCallsPass();
class OperationPass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTLINALGTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Populate the given list with patterns that convert from Linalg to LLVM.
void populateLinalgToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
#ifndef MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRVPASS_H
#define MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRVPASS_H
-#include <memory>
+#include "mlir/Pass/Pass.h"
namespace mlir {
class ModuleOp;
-template <typename T>
-class OperationPass;
-
-#define GEN_PASS_DECL_CONVERTLINALGTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
/// Creates and returns a pass to convert Linalg ops to SPIR-V ops.
-std::unique_ptr<OperationPass<ModuleOp>> createConvertLinalgToSPIRVPass();
+std::unique_ptr<OperationPass<ModuleOp>> createLinalgToSPIRVPass();
} // namespace mlir
template <typename T>
class OperationPass;
-#define GEN_PASS_DECL_CONVERTLINALGTOSTANDARDPASS
-#include "mlir/Conversion/Passes.h.inc"
-
namespace linalg {
//===----------------------------------------------------------------------===//
namespace mlir {
class Pass;
-#define GEN_PASS_DECL_CONVERTMATHTOFUNCSPASS
-#include "mlir/Conversion/Passes.h.inc"
-
+// Pass to convert some Math operations into calls of functions
+// containing software implementation of these operations.
+std::unique_ptr<Pass> createConvertMathToFuncsPass();
} // namespace mlir
#endif // MLIR_CONVERSION_MATHTOFUNCS_MATHTOFUNCS_H
class RewritePatternSet;
class Pass;
-#define GEN_PASS_DECL_CONVERTMATHTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
void populateMathToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
+std::unique_ptr<Pass> createConvertMathToLLVMPass();
} // namespace mlir
#endif // MLIR_CONVERSION_MATHTOLLVM_MATHTOLLVM_H
template <typename T>
class OperationPass;
-#define GEN_PASS_DECL_CONVERTMATHTOLIBMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Populate the given list with patterns that convert from Math to Libm calls.
/// If log1pBenefit is present, use it instead of benefit for the Log1p op.
void populateMathToLibmConversionPatterns(
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_CONVERTMATHTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert Math ops to SPIR-V ops.
std::unique_ptr<OperationPass<>> createConvertMathToSPIRVPass();
class LLVMTypeConverter;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTMEMREFTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Collect a set of patterns to convert memory-related operations from the
/// MemRef dialect to the LLVM dialect.
void populateMemRefToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
+std::unique_ptr<Pass> createMemRefToLLVMPass();
} // namespace mlir
#endif // MLIR_CONVERSION_MEMREFTOLLVM_MEMREFTOLLVM_H
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_MAPMEMREFSTORAGECLASSPASS
-#define GEN_PASS_DECL_CONVERTMEMREFTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to map numeric MemRef memory spaces to symbolic SPIR-V
/// storage classes. The mapping is read from the command-line option.
std::unique_ptr<OperationPass<>> createMapMemRefStorageClassPass();
class RewritePatternSet;
class Pass;
-#define GEN_PASS_DECL_CONVERTNVGPUTONVVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
void populateNVGPUToNVVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
+std::unique_ptr<Pass> createConvertNVGPUToNVVMPass();
+
} // namespace mlir
#endif // MLIR_CONVERSION_NVGPUTONVVM_NVGPUTONVVMPASS_H_
class OperationPass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTOPENACCTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
static constexpr unsigned kPtrBasePosInDataDescriptor = 0;
static constexpr unsigned kPtrPosInDataDescriptor = 1;
static constexpr unsigned kSizePosInDataDescriptor = 2;
class OperationPass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTOPENACCTOSCFPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Collect the patterns to convert from the OpenACC dialect to OpenACC with
/// SCF dialect.
void populateOpenACCToSCFConversionPatterns(RewritePatternSet &patterns);
class OperationPass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTOOPENMPTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Configure dynamic conversion legality of regionless operations from OpenMP
/// to LLVM.
void configureOpenMPToLLVMConversionLegality(ConversionTarget &target,
template <typename OpT>
class OperationPass;
-#define GEN_PASS_DECL_CONVERTPDLTOPDLINTERPPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates and returns a pass to convert PDL ops to PDL interpreter ops.
std::unique_ptr<OperationPass<ModuleOp>> createPDLToPDLInterpPass();
// AffineToStandard
//===----------------------------------------------------------------------===//
-def ConvertAffineToStandardPass : Pass<"lower-affine"> {
+def ConvertAffineToStandard : Pass<"lower-affine"> {
let summary = "Lower Affine operations to a combination of Standard and SCF "
"operations";
let description = [{
if they do not depend on the loop iterator value or on the result of
`affine.apply`.
}];
+ let constructor = "mlir::createLowerAffinePass()";
let dependentDialects = [
"memref::MemRefDialect",
"scf::SCFDialect",
// AMDGPUToROCDL
//===----------------------------------------------------------------------===//
-def ConvertAMDGPUToROCDLPass : Pass<"convert-amdgpu-to-rocdl"> {
+def ConvertAMDGPUToROCDL : Pass<"convert-amdgpu-to-rocdl"> {
let summary = "Convert AMDGPU dialect to ROCDL dialect";
let description = [{
This pass converts supported AMDGPU ops to ROCDL dialect intrinsics.
}];
+ let constructor = "mlir::createConvertAMDGPUToROCDLPass()";
let dependentDialects = [
"LLVM::LLVMDialect",
"ROCDL::ROCDLDialect",
// ArithmeticToLLVM
//===----------------------------------------------------------------------===//
-def ConvertArithmeticToLLVMPass : Pass<"convert-arith-to-llvm"> {
+def ConvertArithmeticToLLVM : Pass<"convert-arith-to-llvm"> {
let summary = "Convert Arithmetic dialect to LLVM dialect";
let description = [{
This pass converts supported Arithmetic ops to LLVM dialect instructions.
}];
+ let constructor = "mlir::arith::createConvertArithmeticToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
Option<"indexBitwidth", "index-bitwidth", "unsigned",
// ArithmeticToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertArithmeticToSPIRVPass : Pass<"convert-arith-to-spirv"> {
+def ConvertArithmeticToSPIRV : Pass<"convert-arith-to-spirv"> {
let summary = "Convert Arithmetic dialect to SPIR-V dialect";
- let constructor = "mlir::createConvertArithmeticToSPIRVPass()";
+ let constructor = "mlir::arith::createConvertArithmeticToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
let options = [
Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
// ArmNeon2dToIntr
//===----------------------------------------------------------------------===//
-def ConvertArmNeon2dToIntrPass : Pass<"arm-neon-2d-to-intr"> {
+def ConvertArmNeon2dToIntr : Pass<"arm-neon-2d-to-intr"> {
let summary = "Convert Arm NEON structured ops to intrinsics";
- let description = [{
- Lower Arm NEON 2D ops to intrinsics, i.e. equivalent ops operating on
- flattened 1D vectors and mapping more directly to the corresponding Arm
- NEON instruction.
- }];
+ let constructor = "mlir::createConvertArmNeon2dToIntrPass()";
let dependentDialects = ["arm_neon::ArmNeonDialect", "vector::VectorDialect"];
}
// AsyncToLLVM
//===----------------------------------------------------------------------===//
-def ConvertAsyncToLLVMPass : Pass<"convert-async-to-llvm", "ModuleOp"> {
+def ConvertAsyncToLLVM : Pass<"convert-async-to-llvm", "ModuleOp"> {
let summary = "Convert the operations from the async dialect into the LLVM "
"dialect";
let description = [{
// BufferizationToMemRef
//===----------------------------------------------------------------------===//
-def ConvertBufferizationToMemRefPass : Pass<"convert-bufferization-to-memref"> {
+def ConvertBufferizationToMemRef : Pass<"convert-bufferization-to-memref"> {
let summary = "Convert operations from the Bufferization dialect to the "
"MemRef dialect";
let description = [{
and hence does not resolve any memory leaks.
}];
+ let constructor = "mlir::createBufferizationToMemRefPass()";
let dependentDialects = ["arith::ArithmeticDialect", "memref::MemRefDialect"];
}
// ComplexToLLVM
//===----------------------------------------------------------------------===//
-def ConvertComplexToLLVMPass : Pass<"convert-complex-to-llvm"> {
+def ConvertComplexToLLVM : Pass<"convert-complex-to-llvm"> {
let summary = "Convert Complex dialect to LLVM dialect";
+ let constructor = "mlir::createConvertComplexToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
}
// ComplexToLibm
//===----------------------------------------------------------------------===//
-def ConvertComplexToLibmPass : Pass<"convert-complex-to-libm", "ModuleOp"> {
+def ConvertComplexToLibm : Pass<"convert-complex-to-libm", "ModuleOp"> {
let summary = "Convert Complex dialect to libm calls";
let description = [{
This pass converts supported Complex ops to libm calls.
// ComplexToStandard
//===----------------------------------------------------------------------===//
-def ConvertComplexToStandardPass : Pass<"convert-complex-to-standard"> {
+def ConvertComplexToStandard : Pass<"convert-complex-to-standard"> {
let summary = "Convert Complex dialect to standard dialect";
+ let constructor = "mlir::createConvertComplexToStandardPass()";
let dependentDialects = ["math::MathDialect"];
}
// ControlFlowToLLVM
//===----------------------------------------------------------------------===//
-def ConvertControlFlowToLLVMPass : Pass<"convert-cf-to-llvm", "ModuleOp"> {
+def ConvertControlFlowToLLVM : Pass<"convert-cf-to-llvm", "ModuleOp"> {
let summary = "Convert ControlFlow operations to the LLVM dialect";
let description = [{
Convert ControlFlow operations into LLVM IR dialect operations.
IR dialect operations, the pass will fail. Any LLVM IR operations or types
already present in the IR will be kept as is.
}];
+ let constructor = "mlir::cf::createConvertControlFlowToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
Option<"indexBitwidth", "index-bitwidth", "unsigned",
// ControlFlowToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertControlFlowToSPIRVPass : Pass<"convert-cf-to-spirv"> {
+def ConvertControlFlowToSPIRV : Pass<"convert-cf-to-spirv"> {
let summary = "Convert ControlFlow dialect to SPIR-V dialect";
let constructor = "mlir::createConvertControlFlowToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
// FuncToLLVM
//===----------------------------------------------------------------------===//
-def ConvertFuncToLLVMPass : Pass<"convert-func-to-llvm", "ModuleOp"> {
+def ConvertFuncToLLVM : Pass<"convert-func-to-llvm", "ModuleOp"> {
let summary = "Convert from the Func dialect to the LLVM dialect";
let description = [{
Convert Func dialect operations into the LLVM IR dialect operations.
// FuncToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertFuncToSPIRVPass : Pass<"convert-func-to-spirv"> {
+def ConvertFuncToSPIRV : Pass<"convert-func-to-spirv"> {
let summary = "Convert Func dialect to SPIR-V dialect";
let constructor = "mlir::createConvertFuncToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
// GPUCommon
//===----------------------------------------------------------------------===//
-def ConvertGpuToLLVMPass : Pass<"gpu-to-llvm", "ModuleOp"> {
+def GpuToLLVMConversionPass : Pass<"gpu-to-llvm", "ModuleOp"> {
let summary = "Convert GPU dialect to LLVM dialect with GPU runtime calls";
- let constructor = "mlir::createConvertGpuToLLVMPass()";
+ let constructor = "mlir::createGpuToLLVMConversionPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
}
-def LowerHostCodeToLLVMPass : Pass<"lower-host-to-llvm", "ModuleOp"> {
+def LowerHostCodeToLLVM : Pass<"lower-host-to-llvm", "ModuleOp"> {
let summary = "Lowers the host module code and `gpu.launch_func` to LLVM";
let constructor = "mlir::createLowerHostCodeToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
// GPUToNVVM
//===----------------------------------------------------------------------===//
-def ConvertGpuToNVVMPass : Pass<"convert-gpu-to-nvvm", "gpu::GPUModuleOp"> {
+def ConvertGpuOpsToNVVMOps : Pass<"convert-gpu-to-nvvm", "gpu::GPUModuleOp"> {
let summary = "Generate NVVM operations for gpu operations";
- let constructor = "mlir::createConvertGpuToNVVMPass()";
+ let constructor = "mlir::createLowerGpuOpsToNVVMOpsPass()";
let dependentDialects = [
"cf::ControlFlowDialect",
"memref::MemRefDialect",
// GPUToROCDL
//===----------------------------------------------------------------------===//
-def ConvertGpuToROCDLPass : Pass<"convert-gpu-to-rocdl", "gpu::GPUModuleOp"> {
+def ConvertGpuOpsToROCDLOps : Pass<"convert-gpu-to-rocdl", "gpu::GPUModuleOp"> {
let summary = "Generate ROCDL operations for gpu operations";
- let constructor = "mlir::createConvertGpuToROCDLPass()";
+ let constructor = "mlir::createLowerGpuOpsToROCDLOpsPass()";
let dependentDialects = ["ROCDL::ROCDLDialect"];
let options = [
Option<"chipset", "chipset", "std::string",
// GPUToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertGPUToSPIRVPass : Pass<"convert-gpu-to-spirv", "ModuleOp"> {
+def ConvertGPUToSPIRV : Pass<"convert-gpu-to-spirv", "ModuleOp"> {
let summary = "Convert GPU dialect to SPIR-V dialect";
let description = [{
This pass converts supported GPU device ops to SPIR-V ops. It does not
// GPUToVulkan
//===----------------------------------------------------------------------===//
-def ConvertGpuLaunchFuncToVulkanLaunchFuncPass
+def ConvertGpuLaunchFuncToVulkanLaunchFunc
: Pass<"convert-gpu-launch-to-vulkan-launch", "ModuleOp"> {
let summary = "Convert gpu.launch_func to vulkanLaunch external call";
let description = [{
let dependentDialects = ["spirv::SPIRVDialect"];
}
-def ConvertVulkanLaunchFuncToVulkanCallsPass
+def ConvertVulkanLaunchFuncToVulkanCalls
: Pass<"launch-func-to-vulkan", "ModuleOp"> {
let summary = "Convert vulkanLaunch external call to Vulkan runtime external "
"calls";
// LinalgToLLVM
//===----------------------------------------------------------------------===//
-def ConvertLinalgToLLVMPass : Pass<"convert-linalg-to-llvm", "ModuleOp"> {
+def ConvertLinalgToLLVM : Pass<"convert-linalg-to-llvm", "ModuleOp"> {
let summary = "Convert the operations from the linalg dialect into the LLVM "
"dialect";
let constructor = "mlir::createConvertLinalgToLLVMPass()";
// LinalgToStandard
//===----------------------------------------------------------------------===//
-def ConvertLinalgToStandardPass : Pass<"convert-linalg-to-std", "ModuleOp"> {
+def ConvertLinalgToStandard : Pass<"convert-linalg-to-std", "ModuleOp"> {
let summary = "Convert the operations from the linalg dialect into the "
"Standard dialect";
let constructor = "mlir::createConvertLinalgToStandardPass()";
// LinalgToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertLinalgToSPIRVPass : Pass<"convert-linalg-to-spirv", "ModuleOp"> {
+def ConvertLinalgToSPIRV : Pass<"convert-linalg-to-spirv", "ModuleOp"> {
let summary = "Convert Linalg dialect to SPIR-V dialect";
let description = [{
This pass converts supported Linalg ops to SPIR-V ops. It's quite
experimental and are expected to migrate to other proper conversions.
}];
- let constructor = "mlir::createConvertLinalgToSPIRVPass()";
+ let constructor = "mlir::createLinalgToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
}
// MathToLibm
//===----------------------------------------------------------------------===//
-def ConvertMathToLibmPass : Pass<"convert-math-to-libm", "ModuleOp"> {
+def ConvertMathToLibm : Pass<"convert-math-to-libm", "ModuleOp"> {
let summary = "Convert Math dialect to libm calls";
let description = [{
This pass converts supported Math ops to libm calls.
// MathToLLVM
//===----------------------------------------------------------------------===//
-def ConvertMathToLLVMPass : Pass<"convert-math-to-llvm"> {
+def ConvertMathToLLVM : Pass<"convert-math-to-llvm"> {
let summary = "Convert Math dialect to LLVM dialect";
let description = [{
This pass converts supported Math ops to LLVM dialect intrinsics.
}];
+ let constructor = "mlir::createConvertMathToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
}
// MathToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertMathToSPIRVPass : Pass<"convert-math-to-spirv"> {
+def ConvertMathToSPIRV : Pass<"convert-math-to-spirv"> {
let summary = "Convert Math dialect to SPIR-V dialect";
let constructor = "mlir::createConvertMathToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
// MathToFuncs
//===----------------------------------------------------------------------===//
-def ConvertMathToFuncsPass : Pass<"convert-math-to-funcs", "ModuleOp"> {
+def ConvertMathToFuncs : Pass<"convert-math-to-funcs", "ModuleOp"> {
let summary = "Convert Math operations to calls of outlined implementations.";
let description = [{
This pass converts supported Math ops to calls of compiler generated
functions implementing these operations in software.
The LLVM dialect is used for LinkonceODR linkage of the generated functions.
}];
+ let constructor = "mlir::createConvertMathToFuncsPass()";
let dependentDialects = [
"arith::ArithmeticDialect",
"cf::ControlFlowDialect",
// MemRefToLLVM
//===----------------------------------------------------------------------===//
-def ConvertMemRefToLLVMPass : Pass<"convert-memref-to-llvm", "ModuleOp"> {
+def ConvertMemRefToLLVM : Pass<"convert-memref-to-llvm", "ModuleOp"> {
let summary = "Convert operations from the MemRef dialect to the LLVM "
"dialect";
+ let constructor = "mlir::createMemRefToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
Option<"useAlignedAlloc", "use-aligned-alloc", "bool", /*default=*/"false",
// MemRefToSPIRV
//===----------------------------------------------------------------------===//
-def MapMemRefStorageClassPass : Pass<"map-memref-spirv-storage-class"> {
+def MapMemRefStorageClass : Pass<"map-memref-spirv-storage-class"> {
let summary = "Map numeric MemRef memory spaces to SPIR-V storage classes";
let constructor = "mlir::createMapMemRefStorageClassPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
];
}
-def ConvertMemRefToSPIRVPass : Pass<"convert-memref-to-spirv"> {
+def ConvertMemRefToSPIRV : Pass<"convert-memref-to-spirv"> {
let summary = "Convert MemRef dialect to SPIR-V dialect";
let constructor = "mlir::createConvertMemRefToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
// NVGPUToNVVM
//===----------------------------------------------------------------------===//
-def ConvertNVGPUToNVVMPass : Pass<"convert-nvgpu-to-nvvm"> {
+def ConvertNVGPUToNVVM : Pass<"convert-nvgpu-to-nvvm"> {
let summary = "Convert NVGPU dialect to NVVM dialect";
let description = [{
This pass converts supported NVGPU ops to NVVM dialect intrinsics.
}];
+ let constructor = "mlir::createConvertNVGPUToNVVMPass()";
let dependentDialects = [
"NVVM::NVVMDialect",
];
// OpenACCToSCF
//===----------------------------------------------------------------------===//
-def ConvertOpenACCToSCFPass : Pass<"convert-openacc-to-scf", "ModuleOp"> {
+def ConvertOpenACCToSCF : Pass<"convert-openacc-to-scf", "ModuleOp"> {
let summary = "Convert the OpenACC ops to OpenACC with SCF dialect";
let constructor = "mlir::createConvertOpenACCToSCFPass()";
let dependentDialects = ["scf::SCFDialect", "acc::OpenACCDialect"];
// OpenACCToLLVM
//===----------------------------------------------------------------------===//
-def ConvertOpenACCToLLVMPass : Pass<"convert-openacc-to-llvm", "ModuleOp"> {
+def ConvertOpenACCToLLVM : Pass<"convert-openacc-to-llvm", "ModuleOp"> {
let summary = "Convert the OpenACC ops to LLVM dialect";
let constructor = "mlir::createConvertOpenACCToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
// OpenMPToLLVM
//===----------------------------------------------------------------------===//
-def ConvertOpenMPToLLVMPass : Pass<"convert-openmp-to-llvm", "ModuleOp"> {
+def ConvertOpenMPToLLVM : Pass<"convert-openmp-to-llvm", "ModuleOp"> {
let summary = "Convert the OpenMP ops to OpenMP ops with LLVM dialect";
let constructor = "mlir::createConvertOpenMPToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
// PDLToPDLInterp
//===----------------------------------------------------------------------===//
-def ConvertPDLToPDLInterpPass : Pass<"convert-pdl-to-pdl-interp", "ModuleOp"> {
+def ConvertPDLToPDLInterp : Pass<"convert-pdl-to-pdl-interp", "ModuleOp"> {
let summary = "Convert PDL ops to PDL interpreter ops";
let constructor = "mlir::createPDLToPDLInterpPass()";
let dependentDialects = ["pdl_interp::PDLInterpDialect"];
// ReconcileUnrealizedCasts
//===----------------------------------------------------------------------===//
-def ReconcileUnrealizedCastsPass : Pass<"reconcile-unrealized-casts"> {
+def ReconcileUnrealizedCasts : Pass<"reconcile-unrealized-casts"> {
let summary = "Simplify and eliminate unrealized conversion casts";
let description = [{
Eliminate `unrealized_conversion_cast` operations, commonly introduced by
and the producer operation is converted by another pass, each of which
produces an unrealized cast. This pass can be used to clean up the IR.
}];
+ let constructor = "mlir::createReconcileUnrealizedCastsPass()";
}
//===----------------------------------------------------------------------===//
// SCFToControlFlow
//===----------------------------------------------------------------------===//
-def ConvertSCFToControlFlowPass : Pass<"convert-scf-to-cf"> {
+def SCFToControlFlow : Pass<"convert-scf-to-cf"> {
let summary = "Convert SCF dialect to ControlFlow dialect, replacing structured"
" control flow with a CFG";
+ let constructor = "mlir::createConvertSCFToCFPass()";
let dependentDialects = ["cf::ControlFlowDialect"];
}
// SCFToOpenMP
//===----------------------------------------------------------------------===//
-def ConvertSCFToOpenMPPass : Pass<"convert-scf-to-openmp", "ModuleOp"> {
+def ConvertSCFToOpenMP : Pass<"convert-scf-to-openmp", "ModuleOp"> {
let summary = "Convert SCF parallel loop to OpenMP parallel + workshare "
"constructs.";
let constructor = "mlir::createConvertSCFToOpenMPPass()";
// SCFToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertSCFToSPIRVPass : Pass<"convert-scf-to-spirv"> {
+def SCFToSPIRV : Pass<"convert-scf-to-spirv"> {
let summary = "Convert SCF dialect to SPIR-V dialect.";
let description = [{
This pass converts SCF ops into SPIR-V structured control flow ops.
// SCFToGPU
//===----------------------------------------------------------------------===//
-def ConvertAffineForToGPUPass
+def ConvertAffineForToGPU
: InterfacePass<"convert-affine-for-to-gpu", "FunctionOpInterface"> {
let summary = "Convert top-level AffineFor Ops to GPU kernels";
let constructor = "mlir::createAffineForToGPUPass()";
];
}
-def ConvertParallelLoopToGpuPass : Pass<"convert-parallel-loops-to-gpu"> {
+def ConvertParallelLoopToGpu : Pass<"convert-parallel-loops-to-gpu"> {
let summary = "Convert mapped scf.parallel ops to gpu launch operations";
- let description = [{
- Convert `scf.parallel` operations into a `gpu.launch` operation. The
- mapping of loop dimensions to launch dimensions is derived from mapping
- attributes. See `ParallelToGpuLaunchLowering::matchAndRewrite` for a
- description of the used attributes.
- }];
+ let constructor = "mlir::createParallelLoopToGpuPass()";
let dependentDialects = ["AffineDialect", "gpu::GPUDialect"];
}
// ShapeToStandard
//===----------------------------------------------------------------------===//
-def ConvertShapeToStandardPass : Pass<"convert-shape-to-std", "ModuleOp"> {
+def ConvertShapeToStandard : Pass<"convert-shape-to-std", "ModuleOp"> {
let summary = "Convert operations from the shape dialect into the standard "
"dialect";
let constructor = "mlir::createConvertShapeToStandardPass()";
];
}
-def ConvertShapeConstraintsPass : Pass<"convert-shape-constraints"> {
+def ConvertShapeConstraints : Pass<"convert-shape-constraints"> {
let summary = "Convert shape constraint operations to the standard dialect";
let description = [{
This pass eliminates shape constraints from the program, converting them to
can happen at a different part of the program than general shape
computation lowering.
}];
+ let constructor = "mlir::createConvertShapeConstraintsPass()";
let dependentDialects = ["cf::ControlFlowDialect", "scf::SCFDialect"];
}
// SPIRVToLLVM
//===----------------------------------------------------------------------===//
-def ConvertSPIRVToLLVMPass : Pass<"convert-spirv-to-llvm", "ModuleOp"> {
+def ConvertSPIRVToLLVM : Pass<"convert-spirv-to-llvm", "ModuleOp"> {
let summary = "Convert SPIR-V dialect to LLVM dialect";
let description = [{
See https://mlir.llvm.org/docs/SPIRVToLLVMDialectConversion/
// TensorToLinalg
//===----------------------------------------------------------------------===//
-def ConvertTensorToLinalgPass : Pass<"convert-tensor-to-linalg", "ModuleOp"> {
+def ConvertTensorToLinalg : Pass<"convert-tensor-to-linalg", "ModuleOp"> {
let summary = "Convert some Tensor dialect ops to Linalg dialect";
let constructor = "mlir::createConvertTensorToLinalgPass()";
let dependentDialects = [
];
}
+
//===----------------------------------------------------------------------===//
// TensorToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertTensorToSPIRVPass : Pass<"convert-tensor-to-spirv"> {
+def ConvertTensorToSPIRV : Pass<"convert-tensor-to-spirv"> {
let summary = "Convert Tensor dialect to SPIR-V dialect";
let constructor = "mlir::createConvertTensorToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
// TosaToArith
//===----------------------------------------------------------------------===//
-def ConvertTosaToArithPass : Pass<"tosa-to-arith"> {
+def TosaToArith : Pass<"tosa-to-arith"> {
let summary = "Lower TOSA to the Arith dialect";
let dependentDialects = [
"arith::ArithmeticDialect",
"bool", /*default=*/"false",
"Whether to prioritze lowering to 32-bit operations">
];
+
+ let constructor = "tosa::createTosaToArith()";
}
//===----------------------------------------------------------------------===//
// TosaToLinalg
//===----------------------------------------------------------------------===//
-def ConvertTosaToLinalgPass
+def TosaToLinalg
: InterfacePass<"tosa-to-linalg", "FunctionOpInterface"> {
let summary = "Lower TOSA to LinAlg on tensors";
let description = [{
Pass that converts TOSA operations to the equivalent operations using the
tensor operations in LinAlg.
}];
+
+ let constructor = "tosa::createTosaToLinalg()";
}
//===----------------------------------------------------------------------===//
// TosaToLinalgNamed
//===----------------------------------------------------------------------===//
-def ConvertTosaToLinalgNamedPass
+def TosaToLinalgNamed
: InterfacePass<"tosa-to-linalg-named", "FunctionOpInterface"> {
let summary = "Lower TOSA to LinAlg named operations";
let description = [{
Pass that converts TOSA operations to the equivalent operations using the
Linalg named operations.
}];
+
+ let constructor = "tosa::createTosaToLinalgNamed()";
}
//===----------------------------------------------------------------------===//
// TosaToSCF
//===----------------------------------------------------------------------===//
-def ConvertTosaToSCFPass : Pass<"tosa-to-scf"> {
+def TosaToSCF : Pass<"tosa-to-scf"> {
let summary = "Lower TOSA to the SCF dialect";
let dependentDialects = ["tensor::TensorDialect, scf::SCFDialect"];
let description = [{
Pass that converts TOSA's control flow operations to the equivalent SCF
operations.
}];
+
+ let constructor = "tosa::createTosaToSCF()";
}
//===----------------------------------------------------------------------===//
// TosaToTensor
//===----------------------------------------------------------------------===//
-def ConvertTosaToTensorPass : Pass<"tosa-to-tensor"> {
+def TosaToTensor : Pass<"tosa-to-tensor"> {
let summary = "Lower TOSA to the Tensor dialect";
let dependentDialects = [
"tensor::TensorDialect",
Pass that converts TOSA operations to the equivalent operations using the
operations in the Tensor dialect.
}];
+
+ let constructor = "tosa::createTosaToTensor()";
}
//===----------------------------------------------------------------------===//
// VectorToGPU
//===----------------------------------------------------------------------===//
-def ConvertVectorToGPUPass : Pass<"convert-vector-to-gpu"> {
+def ConvertVectorToGPU : Pass<"convert-vector-to-gpu"> {
let summary = "Lower the operations from the vector dialect into the GPU "
"dialect";
let constructor = "mlir::createConvertVectorToGPUPass()";
// VectorToSCF
//===----------------------------------------------------------------------===//
-def ConvertVectorToSCFPass : Pass<"convert-vector-to-scf"> {
+def ConvertVectorToSCF : Pass<"convert-vector-to-scf"> {
let summary = "Lower the operations from the vector dialect into the SCF "
"dialect";
let constructor = "mlir::createConvertVectorToSCFPass()";
// VectorToLLVM
//===----------------------------------------------------------------------===//
-def ConvertVectorToLLVMPass : Pass<"convert-vector-to-llvm", "ModuleOp"> {
+def ConvertVectorToLLVM : Pass<"convert-vector-to-llvm", "ModuleOp"> {
let summary = "Lower the operations from the vector dialect into the LLVM "
"dialect";
let description = [{
// VectorToSPIRV
//===----------------------------------------------------------------------===//
-def ConvertVectorToSPIRVPass : Pass<"convert-vector-to-spirv"> {
+def ConvertVectorToSPIRV : Pass<"convert-vector-to-spirv"> {
let summary = "Convert Vector dialect to SPIR-V dialect";
let constructor = "mlir::createConvertVectorToSPIRVPass()";
let dependentDialects = ["spirv::SPIRVDialect"];
class Pass;
class RewritePatternSet;
-#define GEN_PASS_DECL_RECONCILEUNREALIZEDCASTSPASS
-#include "mlir/Conversion/Passes.h.inc"
+/// Creates a pass that eliminates noop `unrealized_conversion_cast` operation
+/// sequences.
+std::unique_ptr<Pass> createReconcileUnrealizedCastsPass();
/// Populates `patterns` with rewrite patterns that eliminate noop
/// `unrealized_conversion_cast` operation sequences.
void populateReconcileUnrealizedCastsPatterns(RewritePatternSet &patterns);
-
} // namespace mlir
#endif // MLIR_CONVERSION_RECONCILEUNREALIZEDCASTS_RECONCILEUNREALIZEDCASTS_H_
class Pass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTSCFTOCONTROLFLOWPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Collect a set of patterns to convert SCF operations to CFG branch-based
/// operations within the ControlFlow dialect.
void populateSCFToControlFlowConversionPatterns(RewritePatternSet &patterns);
+/// Creates a pass to convert SCF operations to CFG branch-based operation in
+/// the ControlFlow dialect.
+std::unique_ptr<Pass> createConvertSCFToCFPass();
+
} // namespace mlir
#endif // MLIR_CONVERSION_SCFTOCONTROLFLOW_SCFTOCONTROLFLOW_H_
class InterfacePass;
class Pass;
-#define GEN_PASS_DECL_CONVERTAFFINEFORTOGPUPASS
-#define GEN_PASS_DECL_CONVERTPARALLELLOOPTOGPUPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Create a pass that converts loop nests into GPU kernels. It considers
/// top-level affine.for operations as roots of loop nests and converts them to
/// the gpu.launch operations if possible.
createAffineForToGPUPass(unsigned numBlockDims, unsigned numThreadDims);
std::unique_ptr<InterfacePass<FunctionOpInterface>> createAffineForToGPUPass();
+/// Creates a pass that converts scf.parallel operations into a gpu.launch
+/// operation. The mapping of loop dimensions to launch dimensions is derived
+/// from mapping attributes. See ParallelToGpuLaunchLowering::matchAndRewrite
+/// for a description of the used attributes.
+std::unique_ptr<Pass> createParallelLoopToGpuPass();
+
} // namespace mlir
#endif // MLIR_CONVERSION_SCFTOGPU_SCFTOGPUPASS_H_
template <typename T>
class OperationPass;
-#define GEN_PASS_DECL_CONVERTSCFTOOPENMPPASS
-#include "mlir/Conversion/Passes.h.inc"
-
std::unique_ptr<OperationPass<ModuleOp>> createConvertSCFToOpenMPPass();
} // namespace mlir
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_CONVERTSCFTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert SCF ops into SPIR-V ops.
std::unique_ptr<OperationPass<>> createConvertSCFToSPIRVPass();
template <typename T>
class OperationPass;
-#define GEN_PASS_DECL_LOWERHOSTCODETOLLVMPASS
-#define GEN_PASS_DECL_CONVERTSPIRVTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to emulate `gpu.launch_func` call in LLVM dialect and lower
/// the host module code to LLVM.
///
class OperationPass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTSHAPECONSTRAINTSPASS
-#define GEN_PASS_DECL_CONVERTSHAPETOSTANDARDPASS
-#include "mlir/Conversion/Passes.h.inc"
-
void populateShapeToStandardConversionPatterns(RewritePatternSet &patterns);
+std::unique_ptr<OperationPass<ModuleOp>> createConvertShapeToStandardPass();
+
void populateConvertShapeConstraintsConversionPatterns(
RewritePatternSet &patterns);
-std::unique_ptr<OperationPass<ModuleOp>> createConvertShapeToStandardPass();
+std::unique_ptr<Pass> createConvertShapeConstraintsPass();
} // namespace mlir
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_CONVERTTENSORTOLINALGPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert Tensor ops to Linalg ops.
std::unique_ptr<OperationPass<ModuleOp>> createConvertTensorToLinalgPass();
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_CONVERTTENSORTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert Tensor ops to SPIR-V ops.
std::unique_ptr<OperationPass<>> createConvertTensorToSPIRVPass();
#include "mlir/Pass/Pass.h"
namespace mlir {
-
-#define GEN_PASS_DECL_CONVERTTOSATOARITHPASS
-#include "mlir/Conversion/Passes.h.inc"
-
namespace tosa {
+std::unique_ptr<Pass> createTosaToArith();
+
void populateTosaToArithConversionPatterns(RewritePatternSet *patterns);
void populateTosaRescaleToArithConversionPatterns(RewritePatternSet *patterns,
#include "mlir/Pass/Pass.h"
namespace mlir {
-
-#define GEN_PASS_DECL_CONVERTTOSATOLINALGPASS
-#define GEN_PASS_DECL_CONVERTTOSATOLINALGNAMEDPASS
-#include "mlir/Conversion/Passes.h.inc"
-
namespace tosa {
+std::unique_ptr<Pass> createTosaToLinalg();
+std::unique_ptr<Pass> createTosaToLinalgNamed();
+
/// Populates passes to convert from TOSA to Linalg on buffers. At the end of
/// the pass, the function will only contain linalg ops or standard ops if the
/// pipeline succeeds. The option to disable decompositions is available for
#include "mlir/Pass/Pass.h"
namespace mlir {
-
-#define GEN_PASS_DECL_CONVERTTOSATOSCFPASS
-#include "mlir/Conversion/Passes.h.inc"
-
namespace tosa {
+std::unique_ptr<Pass> createTosaToSCF();
+
void populateTosaToSCFConversionPatterns(RewritePatternSet *patterns);
/// Populates passes to convert from TOSA to SCF.
#include "mlir/Pass/Pass.h"
namespace mlir {
-
-#define GEN_PASS_DECL_CONVERTTOSATOTENSORPASS
-#include "mlir/Conversion/Passes.h.inc"
-
namespace tosa {
+std::unique_ptr<Pass> createTosaToTensor();
+
void populateTosaToTensorConversionPatterns(RewritePatternSet *patterns);
} // namespace tosa
class Pass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTVECTORTOGPUPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Patterns to transform vector ops into a canonical form to convert to MMA
/// matrix operations. If `useNvGpu` is true, then the patterns will populated
/// will prepare for conversion to `nvgpu` mma operations rather than the `gpu`
template <typename T>
class OperationPass;
-#define GEN_PASS_DECL_CONVERTVECTORTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Options to control Vector to LLVM lowering.
///
/// This should kept in sync with VectorToLLVM options defined for the
class Pass;
class RewritePatternSet;
-#define GEN_PASS_DECL_CONVERTVECTORTOSCFPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// When lowering an N-d vector transfer op to an (N-1)-d vector transfer op,
/// a temporary buffer is created through which individual (N-1)-d vector are
/// staged. This pattern can be applied multiple time, until the transfer op
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_CONVERTVECTORTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-
/// Creates a pass to convert Vector Ops to SPIR-V ops.
std::unique_ptr<OperationPass<>> createConvertVectorToSPIRVPass();
/// producer-consumer and sibling fusion.
enum FusionMode { Greedy, ProducerConsumer, Sibling };
-#define GEN_PASS_DECL_AFFINEDATACOPYGENERATIONPASS
-#define GEN_PASS_DECL_AFFINELOOPFUSIONPASS
-#define GEN_PASS_DECL_AFFINELOOPINVARIANTCODEMOTIONPASS
-#define GEN_PASS_DECL_AFFINELOOPTILINGPASS
-#define GEN_PASS_DECL_AFFINELOOPUNROLLPASS
-#define GEN_PASS_DECL_AFFINELOOPUNROLLANDJAMPASS
-#define GEN_PASS_DECL_AFFINEPIPELINEDATATRANSFERPASS
-#define GEN_PASS_DECL_AFFINESCALARREPLACEMENTPASS
-#define GEN_PASS_DECL_AFFINEVECTORIZEPASS
-#define GEN_PASS_DECL_AFFINEPARALLELIZEPASS
-#define GEN_PASS_DECL_AFFINELOOPNORMALIZEPASS
-#define GEN_PASS_DECL_LOOPCOALESCINGPASS
-#define GEN_PASS_DECL_SIMPLIFYAFFINESTRUCTURESPASS
-#define GEN_PASS_DECL_AFFINEEXPANDINDEXOPSPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-
/// Creates a simplification pass for affine structures (maps and sets). In
/// addition, this pass also normalizes memrefs to have the trivial (identity)
/// layout map.
include "mlir/Pass/PassBase.td"
-def AffineDataCopyGenerationPass : Pass<"affine-data-copy-generate", "func::FuncOp"> {
+def AffineDataCopyGeneration : Pass<"affine-data-copy-generate", "func::FuncOp"> {
let summary = "Generate explicit copying for affine memory operations";
let constructor = "mlir::createAffineDataCopyGenerationPass()";
let dependentDialects = ["memref::MemRefDialect"];
];
}
-def AffineLoopFusionPass : Pass<"affine-loop-fusion", "func::FuncOp"> {
+def AffineLoopFusion : Pass<"affine-loop-fusion", "func::FuncOp"> {
let summary = "Fuse affine loop nests";
let description = [{
This pass performs fusion of loop nests using a slicing-based approach. It
let dependentDialects = ["memref::MemRefDialect"];
}
-def AffineLoopInvariantCodeMotionPass
+def AffineLoopInvariantCodeMotion
: Pass<"affine-loop-invariant-code-motion", "func::FuncOp"> {
let summary = "Hoist loop invariant instructions outside of affine loops";
let constructor = "mlir::createAffineLoopInvariantCodeMotionPass()";
}
-def AffineLoopTilingPass : Pass<"affine-loop-tile", "func::FuncOp"> {
+def AffineLoopTiling : Pass<"affine-loop-tile", "func::FuncOp"> {
let summary = "Tile affine loop nests";
let constructor = "mlir::createLoopTilingPass()";
let options = [
];
}
-def AffineLoopUnrollPass : Pass<"affine-loop-unroll", "func::FuncOp"> {
+def AffineLoopUnroll : Pass<"affine-loop-unroll", "func::FuncOp"> {
let summary = "Unroll affine loops";
let constructor = "mlir::createLoopUnrollPass()";
let options = [
];
}
-def AffineLoopUnrollAndJamPass : Pass<"affine-loop-unroll-jam", "func::FuncOp"> {
+def AffineLoopUnrollAndJam : Pass<"affine-loop-unroll-jam", "func::FuncOp"> {
let summary = "Unroll and jam affine loops";
let constructor = "mlir::createLoopUnrollAndJamPass()";
let options = [
];
}
-def AffinePipelineDataTransferPass
+def AffinePipelineDataTransfer
: Pass<"affine-pipeline-data-transfer", "func::FuncOp"> {
let summary = "Pipeline non-blocking data transfers between explicitly "
"managed levels of the memory hierarchy";
let constructor = "mlir::createPipelineDataTransferPass()";
}
-def AffineScalarReplacementPass : Pass<"affine-scalrep", "func::FuncOp"> {
+def AffineScalarReplacement : Pass<"affine-scalrep", "func::FuncOp"> {
let summary = "Replace affine memref acceses by scalars by forwarding stores "
"to loads and eliminating redundant loads";
let description = [{
let constructor = "mlir::createAffineScalarReplacementPass()";
}
-def AffineVectorizePass : Pass<"affine-super-vectorize", "func::FuncOp"> {
+def AffineVectorize : Pass<"affine-super-vectorize", "func::FuncOp"> {
let summary = "Vectorize to a target independent n-D vector abstraction";
let constructor = "mlir::createSuperVectorizePass()";
let dependentDialects = ["vector::VectorDialect"];
];
}
-def AffineParallelizePass : Pass<"affine-parallelize", "func::FuncOp"> {
+def AffineParallelize : Pass<"affine-parallelize", "func::FuncOp"> {
let summary = "Convert affine.for ops into 1-D affine.parallel";
let constructor = "mlir::createAffineParallelizePass()";
let options = [
];
}
-def AffineLoopNormalizePass : Pass<"affine-loop-normalize", "func::FuncOp"> {
+def AffineLoopNormalize : Pass<"affine-loop-normalize", "func::FuncOp"> {
let summary = "Apply normalization transformations to affine loop-like ops";
let constructor = "mlir::createAffineLoopNormalizePass()";
}
-def LoopCoalescingPass : Pass<"affine-loop-coalescing", "func::FuncOp"> {
+def LoopCoalescing : Pass<"affine-loop-coalescing", "func::FuncOp"> {
let summary = "Coalesce nested loops with independent bounds into a single "
"loop";
let constructor = "mlir::createLoopCoalescingPass()";
let dependentDialects = ["arith::ArithmeticDialect"];
}
-def SimplifyAffineStructuresPass : Pass<"affine-simplify-structures", "func::FuncOp"> {
+def SimplifyAffineStructures : Pass<"affine-simplify-structures", "func::FuncOp"> {
let summary = "Simplify affine expressions in maps/sets and normalize "
"memrefs";
let constructor = "mlir::createSimplifyAffineStructuresPass()";
}
-def AffineExpandIndexOpsPass : Pass<"affine-expand-index-ops"> {
+def AffineExpandIndexOps : Pass<"affine-expand-index-ops"> {
let summary = "Lower affine operations operating on indices into more fundamental operations";
let constructor = "mlir::createAffineExpandIndexOpsPass()";
}
namespace mlir {
namespace arith {
-#define GEN_PASS_DECL_ARITHMETICBUFFERIZEPASS
-#define GEN_PASS_DECL_ARITHMETICEXPANDOPSPASS
-#define GEN_PASS_DECL_ARITHMETICUNSIGNEDWHENEQUIVALENTPASS
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
-
/// Create a pass to bufferize Arithmetic ops.
std::unique_ptr<Pass> createArithmeticBufferizePass();
include "mlir/Pass/PassBase.td"
-def ArithmeticBufferizePass : Pass<"arith-bufferize", "ModuleOp"> {
+def ArithmeticBufferize : Pass<"arith-bufferize", "ModuleOp"> {
let summary = "Bufferize Arithmetic dialect ops.";
let description = [{
This pass bufferizes arith dialect ops.
];
}
-def ArithmeticExpandOpsPass : Pass<"arith-expand"> {
+def ArithmeticExpandOps : Pass<"arith-expand"> {
let summary = "Legalize Arithmetic ops to be convertible to LLVM.";
let constructor = "mlir::arith::createArithmeticExpandOpsPass()";
}
-def ArithmeticUnsignedWhenEquivalentPass : Pass<"arith-unsigned-when-equivalent"> {
+def ArithmeticUnsignedWhenEquivalent : Pass<"arith-unsigned-when-equivalent"> {
let summary = "Replace signed ops with unsigned ones where they are proven equivalent";
let description = [{
Replace signed ops with their unsigned equivalents when integer range analysis
namespace mlir {
class ModuleOp;
-#define GEN_PASS_DECL_ASYNCPARALLELFORPASS
-#define GEN_PASS_DECL_ASYNCTOASYNCRUNTIMEPASS
-#define GEN_PASS_DECL_ASYNCRUNTIMEREFCOUNTINGPASS
-#define GEN_PASS_DECL_ASYNCRUNTIMEREFCOUNTINGOPTPASS
-#define GEN_PASS_DECL_ASYNCRUNTIMEPOLICYBASEDREFCOUNTINGPASS
-#include "mlir/Dialect/Async/Passes.h.inc"
-
std::unique_ptr<Pass> createAsyncParallelForPass();
std::unique_ptr<Pass> createAsyncParallelForPass(bool asyncDispatch,
include "mlir/Pass/PassBase.td"
-def AsyncParallelForPass : Pass<"async-parallel-for", "ModuleOp"> {
+def AsyncParallelFor : Pass<"async-parallel-for", "ModuleOp"> {
let summary = "Convert scf.parallel operations to multiple async compute ops "
"executed concurrently for non-overlapping iteration ranges";
let constructor = "mlir::createAsyncParallelForPass()";
];
}
-def AsyncToAsyncRuntimePass : Pass<"async-to-async-runtime", "ModuleOp"> {
+def AsyncToAsyncRuntime : Pass<"async-to-async-runtime", "ModuleOp"> {
let summary = "Lower high level async operations (e.g. async.execute) to the"
"explicit async.runtime and async.coro operations";
let constructor = "mlir::createAsyncToAsyncRuntimePass()";
let dependentDialects = ["async::AsyncDialect"];
}
-def AsyncRuntimeRefCountingPass : Pass<"async-runtime-ref-counting"> {
+def AsyncRuntimeRefCounting : Pass<"async-runtime-ref-counting"> {
let summary = "Automatic reference counting for Async runtime operations";
let description = [{
This pass works at the async runtime abtraction level, after all
let dependentDialects = ["async::AsyncDialect"];
}
-def AsyncRuntimeRefCountingOptPass : Pass<"async-runtime-ref-counting-opt"> {
+def AsyncRuntimeRefCountingOpt : Pass<"async-runtime-ref-counting-opt"> {
let summary = "Optimize automatic reference counting operations for the"
"Async runtime by removing redundant operations";
let constructor = "mlir::createAsyncRuntimeRefCountingOptPass()";
let dependentDialects = ["async::AsyncDialect"];
}
-def AsyncRuntimePolicyBasedRefCountingPass
+def AsyncRuntimePolicyBasedRefCounting
: Pass<"async-runtime-policy-based-ref-counting"> {
let summary = "Policy based reference counting for Async runtime operations";
let description = [{
// Passes
//===----------------------------------------------------------------------===//
-#define GEN_PASS_DECL_BUFFERDEALLOCATIONPASS
-#define GEN_PASS_DECL_BUFFERHOISTINGPASS
-#define GEN_PASS_DECL_BUFFERLOOPHOISTINGPASS
-#define GEN_PASS_DECL_BUFFERRESULTSTOOUTPARAMSPASS
-#define GEN_PASS_DECL_FINALIZINGBUFFERIZEPASS
-#define GEN_PASS_DECL_BUFFERIZATIONBUFFERIZEPASS
-#define GEN_PASS_DECL_DROPEQUIVALENTBUFFERRESULTSPASS
-#define GEN_PASS_DECL_ONESHOTBUFFERIZEPASS
-#define GEN_PASS_DECL_PROMOTEBUFFERSTOSTACKPASS
-#define GEN_PASS_DECL_TENSORCOPYINSERTIONPASS
-#define GEN_PASS_DECL_ALLOCTENSORELIMINATIONPASS
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-
/// Creates an instance of the BufferDeallocation pass to free all allocated
/// buffers.
std::unique_ptr<Pass> createBufferDeallocationPass();
include "mlir/Pass/PassBase.td"
-def BufferDeallocationPass : Pass<"buffer-deallocation", "func::FuncOp"> {
+def BufferDeallocation : Pass<"buffer-deallocation", "func::FuncOp"> {
let summary = "Adds all required dealloc operations for all allocations in "
"the input program";
let description = [{
let constructor = "mlir::bufferization::createBufferDeallocationPass()";
}
-def BufferHoistingPass : Pass<"buffer-hoisting", "func::FuncOp"> {
+def BufferHoisting : Pass<"buffer-hoisting", "func::FuncOp"> {
let summary = "Optimizes placement of allocation operations by moving them "
"into common dominators and out of nested regions";
let description = [{
let constructor = "mlir::bufferization::createBufferHoistingPass()";
}
-def BufferLoopHoistingPass : Pass<"buffer-loop-hoisting", "func::FuncOp"> {
+def BufferLoopHoisting : Pass<"buffer-loop-hoisting", "func::FuncOp"> {
let summary = "Optimizes placement of allocation operations by moving them "
"out of loop nests";
let description = [{
let constructor = "mlir::bufferization::createBufferLoopHoistingPass()";
}
-def BufferResultsToOutParamsPass : Pass<"buffer-results-to-out-params", "ModuleOp"> {
+def BufferResultsToOutParams : Pass<"buffer-results-to-out-params", "ModuleOp"> {
let summary = "Converts memref-typed function results to out-params";
let description = [{
Some calling conventions prefer to pass output memrefs as "out params". The
let dependentDialects = ["memref::MemRefDialect"];
}
-def FinalizingBufferizePass : Pass<"finalizing-bufferize", "func::FuncOp"> {
+def FinalizingBufferize : Pass<"finalizing-bufferize", "func::FuncOp"> {
let summary = "Finalize a partial bufferization";
let description = [{
A bufferize pass that finalizes a partial bufferization by removing
let constructor = "mlir::bufferization::createFinalizingBufferizePass()";
}
-def BufferizationBufferizePass : Pass<"bufferization-bufferize", "func::FuncOp"> {
+def BufferizationBufferize : Pass<"bufferization-bufferize", "func::FuncOp"> {
let summary = "Bufferize the `bufferization` dialect";
let constructor = "mlir::bufferization::createBufferizationBufferizePass()";
}
-def DropEquivalentBufferResultsPass : Pass<"drop-equivalent-buffer-results", "ModuleOp"> {
+def DropEquivalentBufferResults : Pass<"drop-equivalent-buffer-results", "ModuleOp"> {
let summary = "Remove MemRef return values that are equivalent to a bbArg";
let description = [{
This pass removes MemRef return values from functions if they are equivalent
let dependentDialects = ["memref::MemRefDialect"];
}
-def OneShotBufferizePass : Pass<"one-shot-bufferize", "ModuleOp"> {
+def OneShotBufferize : Pass<"one-shot-bufferize", "ModuleOp"> {
let summary = "One-Shot Bufferize";
let description = [{
This pass bufferizes all ops that implement `BufferizableOpInterface`. It
let constructor = "mlir::bufferization::createOneShotBufferizePass()";
}
-def PromoteBuffersToStackPass : Pass<"promote-buffers-to-stack", "func::FuncOp"> {
+def PromoteBuffersToStack : Pass<"promote-buffers-to-stack", "func::FuncOp"> {
let summary = "Promotes heap-based allocations to automatically managed "
"stack-based allocations";
let description = [{
];
}
-def TensorCopyInsertionPass : Pass<"tensor-copy-insertion"> {
+def TensorCopyInsertion : Pass<"tensor-copy-insertion"> {
let summary = "Make all tensor IR inplaceable by inserting copies";
let description = [{
This pass runs One-Shot Analysis and inserts copies for all OpOperands that
let constructor = "mlir::bufferization::createTensorCopyInsertionPass()";
}
-def AllocTensorEliminationPass : Pass<"eliminate-alloc-tensors"> {
+def AllocTensorElimination : Pass<"eliminate-alloc-tensors"> {
let summary = "Try to eliminate all alloc_tensor ops.";
let description = [{
This pass tries to eliminate all insert_slice op-anchored alloc_tensor ops.
class RewritePatternSet;
namespace func {
-
-#define GEN_PASS_DECL_FUNCBUFFERIZEPASS
-#include "mlir/Dialect/Func/Transforms/Passes.h.inc"
-
/// Creates an instance of func bufferization pass.
std::unique_ptr<Pass> createFuncBufferizePass();
include "mlir/Pass/PassBase.td"
-def FuncBufferizePass : Pass<"func-bufferize", "ModuleOp"> {
+def FuncBufferize : Pass<"func-bufferize", "ModuleOp"> {
let summary = "Bufferize func/call/return ops";
let description = [{
A bufferize pass that bufferizes func.func and func.call ops.
class FuncOp;
} // namespace func
-#define GEN_PASS_DECL_GPULAUNCHSINKINDEXCOMPUTATIONSPASS
-#define GEN_PASS_DECL_GPUKERNELOUTLININGPASS
-#define GEN_PASS_DECL_GPUASYNCREGIONPASS
-#define GEN_PASS_DECL_GPUMAPPARALLELLOOPSPASS
-#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
-
/// Pass that moves ops which are likely an index computation into gpu.launch
/// body.
std::unique_ptr<Pass> createGpuLauchSinkIndexComputationsPass();
include "mlir/Pass/PassBase.td"
-def GpuLaunchSinkIndexComputationsPass : Pass<"gpu-launch-sink-index-computations"> {
+def GpuLaunchSinkIndexComputations : Pass<"gpu-launch-sink-index-computations"> {
let summary = "Sink index computations into gpu.launch body";
let constructor = "mlir::createGpuLauchSinkIndexComputationsPass()";
let dependentDialects = ["mlir::gpu::GPUDialect"];
}
-def GpuKernelOutliningPass : Pass<"gpu-kernel-outlining", "ModuleOp"> {
+def GpuKernelOutlining : Pass<"gpu-kernel-outlining", "ModuleOp"> {
let summary = "Outline gpu.launch bodies to kernel functions";
let constructor = "mlir::createGpuKernelOutliningPass()";
let dependentDialects = ["mlir::DLTIDialect"];
namespace LLVM {
-#define GEN_PASS_DECL_LLVMLEGALIZEFOREXPORTPASS
-#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
-
/// Make argument-taking successors of each block distinct. PHI nodes in LLVM
/// IR use the predecessor ID to identify which value to take. They do not
/// support different values coming from the same predecessor. If a block has
namespace NVVM {
-#define GEN_PASS_DECL_NVVMOPTIMIZEFORTARGETPASS
-#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
-
/// Creates a pass that optimizes LLVM IR for the NVVM target.
std::unique_ptr<Pass> createOptimizeForTargetPass();
include "mlir/Pass/PassBase.td"
-def LLVMLegalizeForExportPass : Pass<"llvm-legalize-for-export"> {
+def LLVMLegalizeForExport : Pass<"llvm-legalize-for-export"> {
let summary = "Legalize LLVM dialect to be convertible to LLVM IR";
let constructor = "::mlir::LLVM::createLegalizeForExportPass()";
}
-def LLVMRequestCWrappersPass
+def LLVMRequestCWrappers
: Pass<"llvm-request-c-wrappers", "::mlir::func::FuncOp"> {
let summary = "Request C wrapper emission for all functions";
let description = [{
let constructor = "::mlir::LLVM::createRequestCWrappersPass()";
}
-def NVVMOptimizeForTargetPass : Pass<"llvm-optimize-for-nvvm-target"> {
+def NVVMOptimizeForTarget : Pass<"llvm-optimize-for-nvvm-target"> {
let summary = "Optimize NVVM IR";
let constructor = "::mlir::NVVM::createOptimizeForTargetPass()";
}
class Pass;
namespace LLVM {
-
-#define GEN_PASS_DECL_LLVMREQUESTCWRAPPERSPASS
-#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
-
std::unique_ptr<Pass> createRequestCWrappersPass();
} // namespace LLVM
} // namespace mlir
struct OneShotBufferizationOptions;
} // namespace bufferization
-#define GEN_PASS_DECL_CONVERTELEMENTWISETOLINALGPASS
-#define GEN_PASS_DECL_LINALGINITTENSORTOALLOCTENSORPASS
-#define GEN_PASS_DECL_LINALGFOLDUNITEXTENTDIMSPASS
-#define GEN_PASS_DECL_LINALGELEMENTWISEOPFUSIONPASS
-#define GEN_PASS_DECL_LINALGNAMEDOPCONVERSIONPASS
-#define GEN_PASS_DECL_LINALGINLINESCALAROPERANDSPASS
-#define GEN_PASS_DECL_LINALGLOWERTOAFFINELOOPSPASS
-#define GEN_PASS_DECL_LINALGLOWERTOLOOPSPASS
-#define GEN_PASS_DECL_LINALGLOWERTOPARALLELLOOPSPASS
-#define GEN_PASS_DECL_LINALGBUFFERIZEPASS
-#define GEN_PASS_DECL_LINALGTILINGPASS
-#define GEN_PASS_DECL_LINALGGENERALIZATIONPASS
-#define GEN_PASS_DECL_LINALGDETENSORIZEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYTILEANDFUSEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYTILEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYPADPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYDECOMPOSEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYPEELPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYVECTORIZEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYENABLEPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYLOWERVECTORSPASS
-#define GEN_PASS_DECL_LINALGSTRATEGYREMOVEMARKERSPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-
std::unique_ptr<Pass> createConvertElementwiseToLinalgPass();
std::unique_ptr<Pass> createLinalgFoldUnitExtentDimsPass();
include "mlir/Pass/PassBase.td"
-def ConvertElementwiseToLinalgPass : Pass<"convert-elementwise-to-linalg", ""> {
+def ConvertElementwiseToLinalg : Pass<"convert-elementwise-to-linalg", ""> {
let summary = "Convert ElementwiseMappable ops to linalg";
let description = [{
Convert ops with the `ElementwiseMappable` trait to linalg parallel loops.
let dependentDialects = ["linalg::LinalgDialect", "memref::MemRefDialect"];
}
-def LinalgInitTensorToAllocTensorPass : Pass<"linalg-init-tensor-to-alloc-tensor"> {
+def LinalgInitTensorToAllocTensor : Pass<"linalg-init-tensor-to-alloc-tensor"> {
let summary = "Replace all init_tensor ops by alloc_tensor ops.";
let description = [{
init_tensor ops return a tensor of unspecified contents who's only purpose
let constructor = "mlir::createLinalgInitTensorToAllocTensorPass()";
}
-def LinalgFoldUnitExtentDimsPass : Pass<"linalg-fold-unit-extent-dims", ""> {
+def LinalgFoldUnitExtentDims : Pass<"linalg-fold-unit-extent-dims", ""> {
let summary = "Remove unit-extent dimension in Linalg ops on tensors";
let constructor = "mlir::createLinalgFoldUnitExtentDimsPass()";
let options = [
];
}
-def LinalgElementwiseOpFusionPass : Pass<"linalg-fuse-elementwise-ops"> {
+def LinalgElementwiseOpFusion : Pass<"linalg-fuse-elementwise-ops"> {
let summary = "Fuse elementwise operations on tensors";
let constructor = "mlir::createLinalgElementwiseOpFusionPass()";
let dependentDialects = [
];
}
-def LinalgNamedOpConversionPass : Pass<"linalg-named-op-conversion"> {
+def LinalgNamedOpConversion: Pass<"linalg-named-op-conversion"> {
let summary = "Convert from one named linalg op to another.";
let constructor = "mlir::createLinalgNamedOpConversionPass()";
let dependentDialects = ["linalg::LinalgDialect", "tensor::TensorDialect"];
}
-def LinalgInlineScalarOperandsPass : Pass<"linalg-inline-scalar-operands", "func::FuncOp"> {
+def LinalgInlineScalarOperands : Pass<"linalg-inline-scalar-operands", "func::FuncOp"> {
let summary = "Inline scalar operands into linalg generic ops";
let constructor = "mlir::createLinalgInlineScalarOperandsPass()";
let dependentDialects = [
];
}
-def LinalgLowerToAffineLoopsPass : Pass<"convert-linalg-to-affine-loops", "func::FuncOp"> {
+def LinalgLowerToAffineLoops : Pass<"convert-linalg-to-affine-loops", "func::FuncOp"> {
let summary = "Lower the operations from the linalg dialect into affine "
"loops";
let constructor = "mlir::createConvertLinalgToAffineLoopsPass()";
"AffineDialect", "linalg::LinalgDialect", "memref::MemRefDialect"];
}
-def LinalgLowerToLoopsPass : Pass<"convert-linalg-to-loops", "func::FuncOp"> {
+def LinalgLowerToLoops : Pass<"convert-linalg-to-loops", "func::FuncOp"> {
let summary = "Lower the operations from the linalg dialect into loops";
let constructor = "mlir::createConvertLinalgToLoopsPass()";
let dependentDialects = [
];
}
-def LinalgLowerToParallelLoopsPass
+def LinalgLowerToParallelLoops
: Pass<"convert-linalg-to-parallel-loops", "func::FuncOp"> {
let summary = "Lower the operations from the linalg dialect into parallel "
"loops";
];
}
-def LinalgBufferizePass : Pass<"linalg-bufferize", "func::FuncOp"> {
+def LinalgBufferize : Pass<"linalg-bufferize", "func::FuncOp"> {
let summary = "Bufferize the linalg dialect";
let constructor = "mlir::createLinalgBufferizePass()";
let dependentDialects = [
];
}
-def LinalgTilingPass : Pass<"linalg-tile", "func::FuncOp"> {
+def LinalgTiling : Pass<"linalg-tile", "func::FuncOp"> {
let summary = "Tile operations in the linalg dialect";
let constructor = "mlir::createLinalgTilingPass()";
let dependentDialects = [
];
}
-def LinalgGeneralizationPass : Pass<"linalg-generalize-named-ops", "func::FuncOp"> {
+def LinalgGeneralization : Pass<"linalg-generalize-named-ops", "func::FuncOp"> {
let summary = "Convert named ops into generic ops";
let constructor = "mlir::createLinalgGeneralizationPass()";
let dependentDialects = ["linalg::LinalgDialect"];
}
-def LinalgDetensorizePass : Pass<"linalg-detensorize", ""> {
+def LinalgDetensorize : Pass<"linalg-detensorize", ""> {
let summary = "Detensorize linalg ops";
let constructor = "mlir::createLinalgDetensorizePass()";
let dependentDialects = [];
// Passes
//===----------------------------------------------------------------------===//
-#define GEN_PASS_DECL_EXPANDOPSPASS
-#define GEN_PASS_DECL_FOLDMEMREFALIASOPSPASS
-#define GEN_PASS_DECL_NORMALIZEMEMREFSPASS
-#define GEN_PASS_DECL_RESOLVERANKEDSHAPETYPERESULTDIMSPASS
-#define GEN_PASS_DECL_RESOLVESHAPEDTYPERESULTDIMSPASS
-#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
-
/// Creates an instance of the ExpandOps pass that legalizes memref dialect ops
/// to be convertible to LLVM. For example, `memref.reshape` gets converted to
/// `memref_reinterpret_cast`.
include "mlir/Pass/PassBase.td"
-def ExpandOpsPass : Pass<"memref-expand"> {
+def ExpandOps : Pass<"memref-expand"> {
let summary = "Legalize memref operations to be convertible to LLVM.";
let constructor = "mlir::memref::createExpandOpsPass()";
}
-def FoldMemRefAliasOpsPass : Pass<"fold-memref-alias-ops"> {
+def FoldMemRefAliasOps : Pass<"fold-memref-alias-ops"> {
let summary = "Fold memref alias ops into consumer load/store ops";
let description = [{
The pass folds loading/storing from/to memref aliasing ops to loading/storing
];
}
-def NormalizeMemRefsPass : Pass<"normalize-memrefs", "ModuleOp"> {
+def NormalizeMemRefs : Pass<"normalize-memrefs", "ModuleOp"> {
let summary = "Normalize memrefs";
let description = [{
This pass transforms memref types with a non-trivial
let dependentDialects = ["AffineDialect"];
}
-def ResolveRankedShapeTypeResultDimsPass :
+def ResolveRankedShapeTypeResultDims :
Pass<"resolve-ranked-shaped-type-result-dims"> {
let summary = "Resolve memref.dim of result values of ranked shape type";
let description = [{
];
}
-def ResolveShapedTypeResultDimsPass : Pass<"resolve-shaped-type-result-dims"> {
+def ResolveShapedTypeResultDims : Pass<"resolve-shaped-type-result-dims"> {
let summary = "Resolve memref.dim of result values";
let description = [{
The pass resolves memref.dim of result of operations that
namespace mlir {
namespace nvgpu {
-#define GEN_PASS_DECL_OPTIMIZESHAREDMEMORYPASS
-#include "mlir/Dialect/NVGPU/Passes.h.inc"
-
/// Create a pass to optimize shared memory reads and writes.
std::unique_ptr<Pass> createOptimizeSharedMemoryPass();
include "mlir/Pass/PassBase.td"
-def OptimizeSharedMemoryPass : Pass<"nvgpu-optimize-shared-memory"> {
+def OptimizeSharedMemory : Pass<"nvgpu-optimize-shared-memory"> {
let summary = "Optimizes accesses to shard memory memrefs in order to reduce bank conflicts.";
let constructor = "mlir::nvgpu::createOptimizeSharedMemoryPass()";
let dependentDialects = [
namespace mlir {
-#define GEN_PASS_DECL_SCFBUFFERIZEPASS
-#define GEN_PASS_DECL_SCFFORLOOPCANONICALIZATIONPASS
-#define GEN_PASS_DECL_SCFFORLOOPPEELINGPASS
-#define GEN_PASS_DECL_SCFFORLOOPSPECIALIZATIONPASS
-#define GEN_PASS_DECL_SCFPARALLELLOOPFUSIONPASS
-#define GEN_PASS_DECL_SCFPARALLELLOOPCOLLAPSINGPASS
-#define GEN_PASS_DECL_SCFPARALLELLOOPSPECIALIZATIONPASS
-#define GEN_PASS_DECL_SCFPARALLELLOOPTILINGPASS
-#define GEN_PASS_DECL_SCFFORLOOPRANGEFOLDINGPASS
-#define GEN_PASS_DECL_SCFFORTOWHILELOOPPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+/// Creates a pass that bufferizes the SCF dialect.
+std::unique_ptr<Pass> createSCFBufferizePass();
+
+/// Creates a pass that specializes for loop for unrolling and
+/// vectorization.
+std::unique_ptr<Pass> createForLoopSpecializationPass();
+
+/// Creates a pass that peels for loops at their upper bounds for
+/// better vectorization.
+std::unique_ptr<Pass> createForLoopPeelingPass();
+
+/// Creates a pass that canonicalizes affine.min and affine.max operations
+/// inside of scf.for loops with known lower and upper bounds.
+std::unique_ptr<Pass> createSCFForLoopCanonicalizationPass();
+
+/// Creates a pass that transforms a single ParallelLoop over N induction
+/// variables into another ParallelLoop over less than N induction variables.
+std::unique_ptr<Pass> createParallelLoopCollapsingPass();
+
+/// Creates a loop fusion pass which fuses parallel loops.
+std::unique_ptr<Pass> createParallelLoopFusionPass();
+
+/// Creates a pass that specializes parallel loop for unrolling and
+/// vectorization.
+std::unique_ptr<Pass> createParallelLoopSpecializationPass();
+
+/// Creates a pass which tiles innermost parallel loops.
+/// If noMinMaxBounds, the upper bound of the inner loop will
+/// be a same value among different outter loop iterations, and
+/// an additional inbound check will be emitted inside the internal
+/// loops.
+std::unique_ptr<Pass>
+createParallelLoopTilingPass(llvm::ArrayRef<int64_t> tileSize = {},
+ bool noMinMaxBounds = false);
+
+/// Creates a pass which folds arith ops on induction variable into
+/// loop range.
+std::unique_ptr<Pass> createForLoopRangeFoldingPass();
+
+// Creates a pass which lowers for loops into while loops.
+std::unique_ptr<Pass> createForToWhileLoopPass();
//===----------------------------------------------------------------------===//
// Registration
include "mlir/Pass/PassBase.td"
-def SCFBufferizePass : Pass<"scf-bufferize"> {
+def SCFBufferize : Pass<"scf-bufferize"> {
let summary = "Bufferize the scf dialect.";
+ let constructor = "mlir::createSCFBufferizePass()";
let dependentDialects = ["bufferization::BufferizationDialect",
"memref::MemRefDialect"];
}
// Note: Making these canonicalization patterns would require a dependency
// of the SCF dialect on the Affine/Tensor/MemRef dialects or vice versa.
-def SCFForLoopCanonicalizationPass
+def SCFForLoopCanonicalization
: Pass<"scf-for-loop-canonicalization"> {
let summary = "Canonicalize operations within scf.for loop bodies";
- let description = [{
- Canonicalize `affine.min` and `affine.max` operations inside of `scf.for`
- loops with known lower and upper bounds.
- }];
+ let constructor = "mlir::createSCFForLoopCanonicalizationPass()";
let dependentDialects = ["AffineDialect", "tensor::TensorDialect",
"memref::MemRefDialect"];
}
-def SCFForLoopPeelingPass : Pass<"scf-for-loop-peeling"> {
+def SCFForLoopPeeling : Pass<"scf-for-loop-peeling"> {
let summary = "Peel `for` loops at their upper bounds.";
- let description = [{
- Peel for loops at their upper bounds for better vectorization.
- }];
+ let constructor = "mlir::createForLoopPeelingPass()";
let options = [
Option<"skipPartial", "skip-partial", "bool",
/*default=*/"true",
let dependentDialects = ["AffineDialect"];
}
-def SCFForLoopSpecializationPass : Pass<"scf-for-loop-specialization"> {
+def SCFForLoopSpecialization : Pass<"scf-for-loop-specialization"> {
let summary = "Specialize `for` loops for vectorization";
+ let constructor = "mlir::createForLoopSpecializationPass()";
}
-def SCFParallelLoopFusionPass : Pass<"scf-parallel-loop-fusion"> {
+def SCFParallelLoopFusion : Pass<"scf-parallel-loop-fusion"> {
let summary = "Fuse adjacent parallel loops";
+ let constructor = "mlir::createParallelLoopFusionPass()";
}
-def SCFParallelLoopCollapsingPass : Pass<"scf-parallel-loop-collapsing"> {
+def SCFParallelLoopCollapsing : Pass<"scf-parallel-loop-collapsing"> {
let summary = "Collapse parallel loops to use less induction variables";
- let description = [{
- Transforms a single `ParallelLoop` over N induction variables into
- another `ParallelLoop` over less than N induction variables.
- }];
+ let constructor = "mlir::createParallelLoopCollapsingPass()";
let options = [
ListOption<"clCollapsedIndices0", "collapsed-indices-0", "unsigned",
"Which loop indices to combine 0th loop index">,
];
}
-def SCFParallelLoopSpecializationPass
+def SCFParallelLoopSpecialization
: Pass<"scf-parallel-loop-specialization"> {
let summary = "Specialize parallel loops for vectorization";
- let description = [{
- Specialize parallel loop for unrolling and vectorization.
- }];
+ let constructor = "mlir::createParallelLoopSpecializationPass()";
}
-def SCFParallelLoopTilingPass : Pass<"scf-parallel-loop-tiling"> {
+def SCFParallelLoopTiling : Pass<"scf-parallel-loop-tiling"> {
let summary = "Tile parallel loops";
- let description = [{
- Tile innermost parallel loops.
- If `noMinMaxBounds`, the upper bound of the inner loop will be a same
- value among different outter loop iterations, and an additional inbound
- check will be emitted inside the internal loops.
- }];
+ let constructor = "mlir::createParallelLoopTilingPass()";
let options = [
ListOption<"tileSizes", "parallel-loop-tile-sizes", "int64_t",
"Factors to tile parallel loops by">,
let dependentDialects = ["AffineDialect"];
}
-def SCFForLoopRangeFoldingPass : Pass<"scf-for-loop-range-folding"> {
+def SCFForLoopRangeFolding : Pass<"scf-for-loop-range-folding"> {
let summary = "Fold add/mul ops into loop range";
- let description = [{
- Fold arith ops on induction variable into loop range.
- }];
+ let constructor = "mlir::createForLoopRangeFoldingPass()";
}
-def SCFForToWhileLoopPass : Pass<"scf-for-to-while"> {
+def SCFForToWhileLoop : Pass<"scf-for-to-while"> {
let summary = "Convert SCF for loops to SCF while loops";
+ let constructor = "mlir::createForToWhileLoopPass()";
let description = [{
This pass transforms SCF.ForOp operations to SCF.WhileOp. The For loop
condition is placed in the 'before' region of the while operation, and the
// Passes
//===----------------------------------------------------------------------===//
-#define GEN_PASS_DECL_SPIRVDECORATECOMPOSITETYPELAYOUTPASS
-#define GEN_PASS_DECL_SPIRVCANONICALIZEGLPASS
-#define GEN_PASS_DECL_SPIRVLOWERABIATTRIBUTESPASS
-#define GEN_PASS_DECL_SPIRVREWRITEINSERTSPASS
-#define GEN_PASS_DECL_SPIRVUNIFYALIASEDRESOURCEPASS
-#define GEN_PASS_DECL_SPIRVUPDATEVCEPASS
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
-
/// Creates a pass to run canoncalization patterns that involve GL ops.
/// These patterns cannot be run in default canonicalization because GL ops
/// aren't always available. So they should be involed specifically when needed.
include "mlir/Pass/PassBase.td"
-def SPIRVDecorateCompositeTypeLayoutPass
- : Pass<"decorate-spirv-composite-type-layout", "mlir::ModuleOp"> {
+def SPIRVCompositeTypeLayout
+ : Pass<"decorate-spirv-composite-type-layout", "ModuleOp"> {
let summary = "Decorate SPIR-V composite type with layout info";
let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()";
}
-def SPIRVCanonicalizeGLPass : Pass<"spirv-canonicalize-gl", ""> {
+def SPIRVCanonicalizeGL : Pass<"spirv-canonicalize-gl", ""> {
let summary = "Run canonicalization involving GLSL ops";
let constructor = "mlir::spirv::createCanonicalizeGLPass()";
}
-def SPIRVLowerABIAttributesPass : Pass<"spirv-lower-abi-attrs", "spirv::ModuleOp"> {
+def SPIRVLowerABIAttributes : Pass<"spirv-lower-abi-attrs", "spirv::ModuleOp"> {
let summary = "Decorate SPIR-V composite type with layout info";
let constructor = "mlir::spirv::createLowerABIAttributesPass()";
}
let constructor = "mlir::spirv::createUnifyAliasedResourcePass()";
}
-def SPIRVUpdateVCEPass : Pass<"spirv-update-vce", "spirv::ModuleOp"> {
+def SPIRVUpdateVCE : Pass<"spirv-update-vce", "spirv::ModuleOp"> {
let summary = "Deduce and attach minimal (version, capabilities, extensions) "
"requirements to spv.module ops";
let constructor = "mlir::spirv::createUpdateVersionCapabilityExtensionPass()";
} // namespace mlir
namespace mlir {
-
-#define GEN_PASS_DECL_SHAPETOSHAPELOWERINGPASS
-#define GEN_PASS_DECL_REMOVESHAPECONSTRAINTSPASS
-#define GEN_PASS_DECL_SHAPEBUFFERIZEPASS
-#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
-
/// Creates an instance of the ShapeToShapeLowering pass that legalizes Shape
/// dialect to be convertible to Arithmetic. For example, `shape.num_elements`
/// get transformed to `shape.reduce`, which can be lowered to SCF and
include "mlir/Pass/PassBase.td"
-def RemoveShapeConstraintsPass : Pass<"remove-shape-constraints", "func::FuncOp"> {
+def RemoveShapeConstraints : Pass<"remove-shape-constraints", "func::FuncOp"> {
let summary = "Replace all cstr_ ops with a true witness";
let constructor = "mlir::createRemoveShapeConstraintsPass()";
}
-def ShapeToShapeLoweringPass : Pass<"shape-to-shape-lowering", "func::FuncOp"> {
+def ShapeToShapeLowering : Pass<"shape-to-shape-lowering", "func::FuncOp"> {
let summary = "Legalize Shape dialect to be convertible to Arithmetic";
let constructor = "mlir::createShapeToShapeLowering()";
}
// TODO: Generalize this to allow any type conversions desired.
-def ShapeBufferizePass : Pass<"shape-bufferize", "func::FuncOp"> {
+def ShapeBufferize : Pass<"shape-bufferize", "func::FuncOp"> {
let summary = "Bufferize the shape dialect.";
let constructor = "mlir::createShapeBufferizePass()";
let dependentDialects = ["bufferization::BufferizationDialect",
struct OneShotBufferizationOptions;
} // namespace bufferization
-#define GEN_PASS_DECL_SPARSIFICATIONPASS
-#define GEN_PASS_DECL_SPARSETENSORCONVERSIONPASS
-#define GEN_PASS_DECL_SPARSETENSORCODEGENPASS
-#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
-
//===----------------------------------------------------------------------===//
// The Sparsification pass.
//===----------------------------------------------------------------------===//
include "mlir/Pass/PassBase.td"
-def SparsificationPass : Pass<"sparsification", "ModuleOp"> {
+def Sparsification : Pass<"sparsification", "ModuleOp"> {
let summary = "Automatically generate sparse tensor code from sparse tensor types";
let description = [{
A pass that implements the core functionality of a **sparse compiler**.
];
}
-def SparseTensorConversionPass : Pass<"sparse-tensor-conversion", "ModuleOp"> {
+def SparseTensorConversion : Pass<"sparse-tensor-conversion", "ModuleOp"> {
let summary = "Convert sparse tensors and primitives to library calls";
let description = [{
A pass that converts sparse tensor primitives into calls into a runtime
];
}
-def SparseTensorCodegenPass : Pass<"sparse-tensor-codegen", "ModuleOp"> {
+def SparseTensorCodegen : Pass<"sparse-tensor-codegen", "ModuleOp"> {
let summary = "Convert sparse tensors and primitives to actual code";
let description = [{
A pass that converts sparse tensor types and primitives to actual
#include "mlir/Pass/Pass.h"
namespace mlir {
-namespace tensor {
-
-#define GEN_PASS_DECL_TENSORBUFFERIZEPASS
-#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
+/// Creates an instance of `tensor` dialect bufferization pass.
+std::unique_ptr<Pass> createTensorBufferizePass();
//===----------------------------------------------------------------------===//
// Registration
//===----------------------------------------------------------------------===//
+namespace tensor {
/// Generate the code for registering passes.
#define GEN_PASS_REGISTRATION
#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
include "mlir/Pass/PassBase.td"
-def TensorBufferizePass : Pass<"tensor-bufferize", "func::FuncOp"> {
+def TensorBufferize : Pass<"tensor-bufferize", "func::FuncOp"> {
let summary = "Bufferize the `tensor` dialect";
+ let constructor = "mlir::createTensorBufferizePass()";
}
#endif // MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES
--- /dev/null
+//===- PassDetail.h - TOSA Pass class details -------------------*- 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_DIALECT_TOSA_TRANSFORMS_PASSDETAIL_H
+#define MLIR_DIALECT_TOSA_TRANSFORMS_PASSDETAIL_H
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Tensor/IR/Tensor.h"
+#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSDETAIL_H
namespace mlir {
namespace tosa {
-#define GEN_PASS_DECL_TOSALAYERWISECONSTANTFOLDPASS
-#define GEN_PASS_DECL_TOSAINFERSHAPESPASS
-#define GEN_PASS_DECL_TOSAMAKEBROADCASTABLEPASS
-#define GEN_PASS_DECL_TOSAOPTIONALDECOMPOSITIONSPASS
-#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
-
// Expose Rewrite Functions that decompose TOSA Ops into further TOSA Ops.
// The rewrites can be selectively added to a conversion pass.
void populateTosaDecomposeConv2D(MLIRContext *ctx, RewritePatternSet &patterns);
void populateTosaFoldConstantTransposePatterns(MLIRContext *ctx,
RewritePatternSet &patterns);
+std::unique_ptr<Pass> createTosaLayerwiseConstantFoldPass();
+std::unique_ptr<Pass> createTosaInferShapesPass();
+std::unique_ptr<Pass> createTosaMakeBroadcastablePass();
+std::unique_ptr<Pass> createTosaTestQuantUtilAPIPass();
+std::unique_ptr<Pass> createTosaOptionalDecompositions();
+
#define GEN_PASS_REGISTRATION
#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
let description = [{
Pass that enables folding of full-layer operations on constant tensors.
}];
+
+ let constructor = "createTosaLayerwiseConstantFoldPass()";
}
-def TosaInferShapesPass : Pass<"tosa-infer-shapes", "func::FuncOp"> {
+def TosaInferShapes : Pass<"tosa-infer-shapes", "func::FuncOp"> {
let summary = "Propagate shapes across TOSA operations";
let description = [{
Pass that uses operand types and propagates shapes to TOSA operations.
This includes legalizing rankless and dynamic shapes towards static.
}];
+
+ let constructor = "createTosaInferShapesPass()";
let dependentDialects = [
"func::FuncDialect",
"tensor::TensorDialect",
];
}
-def TosaMakeBroadcastablePass : Pass<"tosa-make-broadcastable", "func::FuncOp"> {
+def TosaMakeBroadcastable : Pass<"tosa-make-broadcastable", "func::FuncOp"> {
let summary = "TOSA rank Reshape to enable Broadcasting";
let description = [{
Pass that enables broadcast by making all input arrays have the same
approach similar to step 1 of Numpy 4-step broadcasting:
https://numpy.org/doc/stable/reference/ufuncs.html#broadcasting
}];
+
+ let constructor = "createTosaMakeBroadcastablePass()";
}
-def TosaOptionalDecompositionsPass
+def TosaOptionalDecompositions
: Pass<"tosa-optional-decompositions", "func::FuncOp"> {
let summary = "Applies Tosa operations optional decompositions";
let description = [{
Pass to apply the Tosa operations decompositions
exposed as populate functions in include/mlir/Dialect/Tosa/Transforms/Passes.h
}];
+
+ let constructor = "tosa::createTosaOptionalDecompositions()";
}
#endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSES
class Pass;
namespace transform {
-#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"
include "mlir/Pass/PassBase.td"
-def CheckUsesPass : Pass<"transform-dialect-check-uses"> {
+def CheckUses : 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
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
namespace mlir {
namespace vector {
-#define GEN_PASS_DECL_VECTORBUFFERIZEPASS
-#include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
+/// Creates an instance of the `vector` dialect bufferization pass.
+std::unique_ptr<Pass> createVectorBufferizePass();
//===----------------------------------------------------------------------===//
// Registration
include "mlir/Pass/PassBase.td"
-def VectorBufferizePass : Pass<"vector-bufferize", "func::FuncOp"> {
+def VectorBufferize : Pass<"vector-bufferize", "func::FuncOp"> {
let summary = "Bufferize Vector dialect ops";
+ let constructor = "mlir::vector::createVectorBufferizePass()";
}
#endif // MLIR_DIALECT_VECTOR_TRANSFORMS_PASSES
--- /dev/null
+//===- PassDetail.h - Reducer Pass class details ----------------*- 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_REDUCER_PASSDETAIL_H
+#define MLIR_REDUCER_PASSDETAIL_H
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+#define GEN_PASS_CLASSES
+#include "mlir/Reducer/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // MLIR_REDUCER_PASSDETAIL_H
namespace mlir {
-#define GEN_PASS_DECL_REDUCTIONTREEPASS
-#define GEN_PASS_DECL_OPTREDUCTIONPASS
-#include "mlir/Reducer/Passes.h.inc"
-
std::unique_ptr<Pass> createReductionTreePass();
std::unique_ptr<Pass> createOptReductionPass();
];
}
-def ReductionTreePass : Pass<"reduction-tree"> {
+def ReductionTree : Pass<"reduction-tree"> {
let summary = "Reduce the input with reduction-tree algorithm";
let constructor = "mlir::createReductionTreePass()";
] # CommonReductionPassOptions.options;
}
-def OptReductionPass : Pass<"opt-reduction-pass", "ModuleOp"> {
+def OptReduction : Pass<"opt-reduction-pass", "ModuleOp"> {
let summary = "A wrapper pass that reduces the file with optimization passes";
let constructor = "mlir::createOptReductionPass()";
class OpPrintingFlags;
class Pass;
-#define GEN_PASS_DECL_LOCATIONSNAPSHOTPASS
-#include "mlir/Transforms/Passes.h.inc"
-
/// This function generates new locations from the given IR by snapshotting the
/// IR to the given stream, and using the printed locations within that stream.
/// The generated locations replace the current operation locations.
// Passes
//===----------------------------------------------------------------------===//
-#define GEN_PASS_DECL_CANONICALIZERPASS
-#define GEN_PASS_DECL_CONTROLFLOWSINKPASS
-#define GEN_PASS_DECL_CSEPASS
-#define GEN_PASS_DECL_LOOPINVARIANTCODEMOTIONPASS
-#define GEN_PASS_DECL_STRIPDEBUGINFOPASS
-#define GEN_PASS_DECL_PRINTOPSTATSPASS
-#define GEN_PASS_DECL_INLINERPASS
-#define GEN_PASS_DECL_SCCPPASS
-#define GEN_PASS_DECL_SYMBOLDCEPASS
-#define GEN_PASS_DECL_SYMBOLPRIVATIZEPASS
-#define GEN_PASS_DECL_TOPOLOGICALSORTPASS
-#include "mlir/Transforms/Passes.h.inc"
-
/// Creates an instance of the Canonicalizer pass, configured with default
/// settings (which can be overridden by pass options on the command line).
std::unique_ptr<Pass> createCanonicalizerPass();
ArrayRef<std::string> disabledPatterns = llvm::None,
ArrayRef<std::string> enabledPatterns = llvm::None);
+/// Creates a pass to perform control-flow sinking.
+std::unique_ptr<Pass> createControlFlowSinkPass();
+
+/// Creates a pass to perform common sub expression elimination.
+std::unique_ptr<Pass> createCSEPass();
+
+/// Creates a loop invariant code motion pass that hoists loop invariant
+/// instructions out of the loop.
+std::unique_ptr<Pass> createLoopInvariantCodeMotionPass();
+
+/// Creates a pass to strip debug information from a function.
+std::unique_ptr<Pass> createStripDebugInfoPass();
+
/// Creates a pass which prints the list of ops and the number of occurrences in
/// the module.
std::unique_ptr<Pass> createPrintOpStatsPass(raw_ostream &os = llvm::errs());
createInlinerPass(llvm::StringMap<OpPassManager> opPipelines,
std::function<void(OpPassManager &)> defaultPipelineBuilder);
+/// Creates a pass which performs sparse conditional constant propagation over
+/// nested operations.
+std::unique_ptr<Pass> createSCCPPass();
+
+/// Creates a pass which delete symbol operations that are unreachable. This
+/// pass may *only* be scheduled on an operation that defines a SymbolTable.
+std::unique_ptr<Pass> createSymbolDCEPass();
+
/// Creates a pass which marks top-level symbol operations as `private` unless
/// listed in `excludeSymbols`.
std::unique_ptr<Pass>
createSymbolPrivatizePass(ArrayRef<std::string> excludeSymbols = {});
+/// Creates a pass that recursively sorts nested regions without SSA dominance
+/// topologically such that, as much as possible, users of values appear after
+/// their producers.
+std::unique_ptr<Pass> createTopologicalSortPass();
+
//===----------------------------------------------------------------------===//
// Registration
//===----------------------------------------------------------------------===//
include "mlir/Pass/PassBase.td"
include "mlir/Rewrite/PassUtil.td"
-def CanonicalizerPass : Pass<"canonicalize"> {
+def Canonicalizer : Pass<"canonicalize"> {
let summary = "Canonicalize operations";
let description = [{
This pass performs various types of canonicalizations over a set of
] # RewritePassUtils.options;
}
-def ControlFlowSinkPass : Pass<"control-flow-sink"> {
+def ControlFlowSink : Pass<"control-flow-sink"> {
let summary = "Sink operations into conditional blocks";
let description = [{
This pass implements control-flow sink on operations that implement
blocks: ops in unreachable blocks may prevent other operations from being
sunk as they may contain uses of their results
}];
+ let constructor = "::mlir::createControlFlowSinkPass()";
let statistics = [
Statistic<"numSunk", "num-sunk", "Number of operations sunk">,
];
}
-def CSEPass : Pass<"cse"> {
+def CSE : Pass<"cse"> {
let summary = "Eliminate common sub-expressions";
let description = [{
This pass implements a generalized algorithm for common sub-expression
operations. See [Common subexpression elimination](https://en.wikipedia.org/wiki/Common_subexpression_elimination)
for more general details on this optimization.
}];
+ let constructor = "mlir::createCSEPass()";
let statistics = [
Statistic<"numCSE", "num-cse'd", "Number of operations CSE'd">,
Statistic<"numDCE", "num-dce'd", "Number of operations DCE'd">
];
}
-def InlinerPass : Pass<"inline"> {
+def Inliner : Pass<"inline"> {
let summary = "Inline function calls";
let constructor = "mlir::createInlinerPass()";
let options = [
];
}
-def LocationSnapshotPass : Pass<"snapshot-op-locations"> {
+def LocationSnapshot : Pass<"snapshot-op-locations"> {
let summary = "Generate new locations from the current IR";
let description = [{
This pass allows for generating new locations from the IR during any stage
];
}
-def LoopInvariantCodeMotionPass : Pass<"loop-invariant-code-motion"> {
+def LoopInvariantCodeMotion : Pass<"loop-invariant-code-motion"> {
let summary = "Hoist loop invariant instructions outside of the loop";
+ let constructor = "mlir::createLoopInvariantCodeMotionPass()";
}
-def PrintOpStatsPass : Pass<"print-op-stats"> {
+def PrintOpStats : Pass<"print-op-stats"> {
let summary = "Print statistics of operations";
let constructor = "mlir::createPrintOpStatsPass()";
let options = [
];
}
-def SCCPPass : Pass<"sccp"> {
+def SCCP : Pass<"sccp"> {
let summary = "Sparse Conditional Constant Propagation";
let description = [{
This pass implements a general algorithm for sparse conditional constant
This implementation is based on the algorithm described by Wegman and Zadeck
in [“Constant Propagation with Conditional Branches”](https://dl.acm.org/doi/10.1145/103135.103136) (1991).
}];
+ let constructor = "mlir::createSCCPPass()";
}
-def StripDebugInfoPass : Pass<"strip-debuginfo"> {
+def StripDebugInfo : Pass<"strip-debuginfo"> {
let summary = "Strip debug info from all operations";
let description = [{
This pass strips the IR of any location information, by replacing all
operation locations with [`unknown`](Diagnostics.md#unknown-location).
}];
+ let constructor = "mlir::createStripDebugInfoPass()";
}
-def SymbolDCEPass : Pass<"symbol-dce"> {
+def SymbolDCE : Pass<"symbol-dce"> {
let summary = "Eliminate dead symbols";
let description = [{
This pass deletes all symbols that are found to be unreachable. This is done
See [Symbols and SymbolTables](SymbolsAndSymbolTables.md) for more
information on `Symbols`.
}];
+ let constructor = "mlir::createSymbolDCEPass()";
let statistics = [
Statistic<"numDCE", "num-dce'd", "Number of symbols DCE'd">,
];
}
-def SymbolPrivatizePass : Pass<"symbol-privatize"> {
+def SymbolPrivatize : Pass<"symbol-privatize"> {
let summary = "Mark symbols private";
let description = [{
This pass marks all top-level symbols of the operation run as `private`
let constructor = "mlir::createSymbolPrivatizePass()";
}
-def ViewOpGraphPass : Pass<"view-op-graph"> {
+def ViewOpGraph : Pass<"view-op-graph"> {
let summary = "Print Graphviz visualization of an operation";
let description = [{
This pass prints a Graphviz graph of a module.
Option<"printResultTypes", "print-result-types", "bool",
/*default=*/"true", "Print result types of operations">
];
- let constructor = "mlir::createViewOpGraphPass()";
+ let constructor = "mlir::createPrintOpGraphPass()";
}
-def TopologicalSortPass : Pass<"topological-sort"> {
+def TopologicalSort : Pass<"topological-sort"> {
let summary = "Sort regions without SSA dominance in topological order";
let description = [{
Recursively sorts all nested regions without SSA dominance in topological
is not changed. Operations that form a cycle are moved to the end of the
regions in a stable order.
}];
+
+ let constructor = "mlir::createTopologicalSortPass()";
}
#endif // MLIR_TRANSFORMS_PASSES
namespace mlir {
class Pass;
-#define GEN_PASS_DECL_VIEWOPGRAPHPASS
-#include "mlir/Transforms/Passes.h.inc"
-
/// Creates a pass to print op graphs.
-std::unique_ptr<Pass> createViewOpGraphPass(raw_ostream &os = llvm::errs());
+std::unique_ptr<Pass> createPrintOpGraphPass(raw_ostream &os = llvm::errs());
} // namespace mlir
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Dialect/AMDGPU/AMDGPUDialect.h"
#include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTAMDGPUTOROCDLPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
using namespace mlir::amdgpu;
};
struct ConvertAMDGPUToROCDLPass
- : public impl::ConvertAMDGPUToROCDLPassBase<ConvertAMDGPUToROCDLPass> {
- using ConvertAMDGPUToROCDLPassBase::ConvertAMDGPUToROCDLPassBase;
+ : public ConvertAMDGPUToROCDLBase<ConvertAMDGPUToROCDLPass> {
+ ConvertAMDGPUToROCDLPass() = default;
void runOnOperation() override {
MLIRContext *ctx = &getContext();
RawBufferOpLowering<RawBufferAtomicFaddOp, ROCDL::RawBufferAtomicFAddOp>>(
converter, chipset);
}
+
+std::unique_ptr<Pass> mlir::createConvertAMDGPUToROCDLPass() {
+ return std::make_unique<ConvertAMDGPUToROCDLPass>();
+}
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
+#include "../PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/IntegerSet.h"
#include "mlir/IR/MLIRContext.h"
+#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/Passes.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTAFFINETOSTANDARDPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::vector;
}
namespace {
-class ConvertAffineToStandardPass
- : public impl::ConvertAffineToStandardPassBase<
- ConvertAffineToStandardPass> {
- using ConvertAffineToStandardPassBase::ConvertAffineToStandardPassBase;
-
+class LowerAffinePass : public ConvertAffineToStandardBase<LowerAffinePass> {
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns);
}
};
} // namespace
+
+/// Lowers If and For operations within a function into their lower level CFG
+/// equivalent blocks.
+std::unique_ptr<Pass> mlir::createLowerAffinePass() {
+ return std::make_unique<LowerAffinePass>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/TypeUtilities.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTARITHMETICTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
struct ConvertArithmeticToLLVMPass
- : public impl::ConvertArithmeticToLLVMPassBase<
- ConvertArithmeticToLLVMPass> {
- using ConvertArithmeticToLLVMPassBase::ConvertArithmeticToLLVMPassBase;
+ : public ConvertArithmeticToLLVMBase<ConvertArithmeticToLLVMPass> {
+ ConvertArithmeticToLLVMPass() = default;
void runOnOperation() override {
LLVMConversionTarget target(getContext());
>(converter);
// clang-format on
}
+
+std::unique_ptr<Pass> mlir::arith::createConvertArithmeticToLLVMPass() {
+ return std::make_unique<ConvertArithmeticToLLVMPass>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
-
+#include "../PassDetail.h"
#include "../SPIRVCommon/Pattern.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTARITHMETICTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "arith-to-spirv-pattern"
using namespace mlir;
ConversionPatternRewriter &rewriter) const {
Type dstElemTy = adaptor.getLhs().getType();
Location loc = op->getLoc();
- Value result = rewriter.create<spirv::IAddCarryOp>(loc, adaptor.getLhs(),
- adaptor.getRhs());
+ Value result = rewriter.create<spirv::IAddCarryOp>(
+ loc, adaptor.getLhs(), adaptor.getRhs());
Value sumResult = rewriter.create<spirv::CompositeExtractOp>(
loc, result, llvm::makeArrayRef(0));
namespace {
struct ConvertArithmeticToSPIRVPass
- : public impl::ConvertArithmeticToSPIRVPassBase<
- ConvertArithmeticToSPIRVPass> {
- using ConvertArithmeticToSPIRVPassBase::ConvertArithmeticToSPIRVPassBase;
-
+ : public ConvertArithmeticToSPIRVBase<ConvertArithmeticToSPIRVPass> {
void runOnOperation() override {
Operation *op = getOperation();
auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
};
} // namespace
-std::unique_ptr<OperationPass<>> mlir::createConvertArithmeticToSPIRVPass() {
+std::unique_ptr<OperationPass<>>
+mlir::arith::createConvertArithmeticToSPIRVPass() {
return std::make_unique<ConvertArithmeticToSPIRVPass>();
}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h"
-
+#include "../PassDetail.h"
#include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/PassRegistry.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTARMNEON2DTOINTRPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::arm_neon;
}
};
-class ConvertArmNeon2dToIntrPass
- : public impl::ConvertArmNeon2dToIntrPassBase<ConvertArmNeon2dToIntrPass> {
- using ConvertArmNeon2dToIntrPassBase::ConvertArmNeon2dToIntrPassBase;
-
+class ConvertArmNeon2dToIntr
+ : public ConvertArmNeon2dToIntrBase<ConvertArmNeon2dToIntr> {
void runOnOperation() override {
auto *context = &getContext();
void mlir::populateConvertArmNeon2dToIntrPatterns(RewritePatternSet &patterns) {
patterns.add<Sdot2dLoweringPattern>(patterns.getContext());
}
+
+std::unique_ptr<Pass> mlir::createConvertArmNeon2dToIntrPass() {
+ return std::make_unique<ConvertArmNeon2dToIntr>();
+}
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
+#include "../PassDetail.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTASYNCTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "convert-async-to-llvm"
using namespace mlir;
namespace {
struct ConvertAsyncToLLVMPass
- : public impl::ConvertAsyncToLLVMPassBase<ConvertAsyncToLLVMPass> {
- using ConvertAsyncToLLVMPassBase::ConvertAsyncToLLVMPassBase;
-
+ : public ConvertAsyncToLLVMBase<ConvertAsyncToLLVMPass> {
void runOnOperation() override;
};
} // namespace
};
} // namespace
+std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertAsyncToLLVMPass() {
+ return std::make_unique<ConvertAsyncToLLVMPass>();
+}
+
void mlir::populateAsyncStructuralTypeConversionsAndLegality(
TypeConverter &typeConverter, RewritePatternSet &patterns,
ConversionTarget &target) {
target.addDynamicallyLegalOp<AwaitOp, ExecuteOp, async::YieldOp>(
[&](Operation *op) { return typeConverter.isLegal(op); });
}
-
-std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertAsyncToLLVMPass() {
- return std::make_unique<ConvertAsyncToLLVMPass>();
-}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h"
-
+#include "../PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BuiltinTypes.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Support/LogicalResult.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTBUFFERIZATIONTOMEMREFPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
}
namespace {
-struct ConvertBufferizationToMemRefPass
- : public impl::ConvertBufferizationToMemRefPassBase<
- ConvertBufferizationToMemRefPass> {
- using ConvertBufferizationToMemRefPassBase::
- ConvertBufferizationToMemRefPassBase;
+struct BufferizationToMemRefPass
+ : public ConvertBufferizationToMemRefBase<BufferizationToMemRefPass> {
+ BufferizationToMemRefPass() = default;
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createBufferizationToMemRefPass() {
+ return std::make_unique<BufferizationToMemRefPass>();
+}
#include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
+#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTCOMPLEXTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
using namespace mlir::LLVM;
namespace {
struct ConvertComplexToLLVMPass
- : public impl::ConvertComplexToLLVMPassBase<ConvertComplexToLLVMPass> {
- using ConvertComplexToLLVMPassBase::ConvertComplexToLLVMPassBase;
-
+ : public ConvertComplexToLLVMBase<ConvertComplexToLLVMPass> {
void runOnOperation() override;
};
} // namespace
applyPartialConversion(getOperation(), target, std::move(patterns))))
signalPassFailure();
}
+
+std::unique_ptr<Pass> mlir::createConvertComplexToLLVMPass() {
+ return std::make_unique<ConvertComplexToLLVMPass>();
+}
#include "mlir/Conversion/ComplexToLibm/ComplexToLibm.h"
+#include "../PassDetail.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/PatternMatch.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTCOMPLEXTOLIBMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
struct ConvertComplexToLibmPass
- : public impl::ConvertComplexToLibmPassBase<ConvertComplexToLibmPass> {
- using ConvertComplexToLibmPassBase::ConvertComplexToLibmPassBase;
-
+ : public ConvertComplexToLibmBase<ConvertComplexToLibmPass> {
void runOnOperation() override;
};
} // namespace
#include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h"
+#include <memory>
+#include <type_traits>
+
+#include "../PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/PatternMatch.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
-#include <memory>
-#include <type_traits>
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTCOMPLEXTOSTANDARDPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
struct ConvertComplexToStandardPass
- : public impl::ConvertComplexToStandardPassBase<
- ConvertComplexToStandardPass> {
- using ConvertComplexToStandardPassBase::ConvertComplexToStandardPassBase;
-
+ : public ConvertComplexToStandardBase<ConvertComplexToStandardPass> {
void runOnOperation() override;
};
signalPassFailure();
}
} // namespace
+
+std::unique_ptr<Pass> mlir::createConvertComplexToStandardPass() {
+ return std::make_unique<ConvertComplexToStandardPass>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/PatternMatch.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/StringRef.h"
#include <functional>
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTCONTROLFLOWTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
#define PASS_NAME "convert-cf-to-llvm"
namespace {
/// A pass converting MLIR operations into the LLVM IR dialect.
-struct ConvertControlFlowToLLVMPass
- : public impl::ConvertControlFlowToLLVMPassBase<
- ConvertControlFlowToLLVMPass> {
- using ConvertControlFlowToLLVMPassBase::ConvertControlFlowToLLVMPassBase;
+struct ConvertControlFlowToLLVM
+ : public ConvertControlFlowToLLVMBase<ConvertControlFlowToLLVM> {
+ ConvertControlFlowToLLVM() = default;
/// Run the dialect converter on the module.
void runOnOperation() override {
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::cf::createConvertControlFlowToLLVMPass() {
+ return std::make_unique<ConvertControlFlowToLLVM>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRVPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTCONTROLFLOWTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
/// A pass converting MLIR ControlFlow operations into the SPIR-V dialect.
class ConvertControlFlowToSPIRVPass
- : public impl::ConvertControlFlowToSPIRVPassBase<
- ConvertControlFlowToSPIRVPass> {
- using ConvertControlFlowToSPIRVPassBase::ConvertControlFlowToSPIRVPassBase;
-
+ : public ConvertControlFlowToSPIRVBase<ConvertControlFlowToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Analysis/DataLayoutAnalysis.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
+#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include <algorithm>
#include <functional>
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTFUNCTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
#define PASS_NAME "convert-func-to-llvm"
namespace {
/// A pass converting Func operations into the LLVM IR dialect.
struct ConvertFuncToLLVMPass
- : public impl::ConvertFuncToLLVMPassBase<ConvertFuncToLLVMPass> {
+ : public ConvertFuncToLLVMBase<ConvertFuncToLLVMPass> {
ConvertFuncToLLVMPass() = default;
ConvertFuncToLLVMPass(bool useBarePtrCallConv, unsigned indexBitwidth,
bool useAlignedAlloc,
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTFUNCTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
/// A pass converting MLIR Func operations into the SPIR-V dialect.
class ConvertFuncToSPIRVPass
- : public impl::ConvertFuncToSPIRVPassBase<ConvertFuncToSPIRVPass> {
- using ConvertFuncToSPIRVPassBase::ConvertFuncToSPIRVPassBase;
-
+ : public ConvertFuncToSPIRVBase<ConvertFuncToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
#include "mlir/Conversion/GPUCommon/GPUCommonPass.h"
+#include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/FormatVariadic.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTGPUTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
static constexpr const char *kGpuBinaryStorageSuffix = "_gpubin_cst";
namespace {
-class ConvertGpuToLLVMPass
- : public impl::ConvertGpuToLLVMPassBase<ConvertGpuToLLVMPass> {
+class GpuToLLVMConversionPass
+ : public GpuToLLVMConversionPassBase<GpuToLLVMConversionPass> {
public:
- ConvertGpuToLLVMPass() = default;
+ GpuToLLVMConversionPass() = default;
- ConvertGpuToLLVMPass(bool kernelBarePtrCallConv) : ConvertGpuToLLVMPass() {
+ GpuToLLVMConversionPass(bool kernelBarePtrCallConv)
+ : GpuToLLVMConversionPass() {
if (this->kernelBarePtrCallConv.getNumOccurrences() == 0)
this->kernelBarePtrCallConv = kernelBarePtrCallConv;
}
- ConvertGpuToLLVMPass(const ConvertGpuToLLVMPass &other)
- : ConvertGpuToLLVMPassBase(other) {}
+ GpuToLLVMConversionPass(const GpuToLLVMConversionPass &other)
+ : GpuToLLVMConversionPassBase(other) {}
// Run the dialect converter on the module.
void runOnOperation() override;
};
} // namespace
-void ConvertGpuToLLVMPass::runOnOperation() {
+void GpuToLLVMConversionPass::runOnOperation() {
LLVMTypeConverter converter(&getContext());
RewritePatternSet patterns(&getContext());
LLVMConversionTarget target(getContext());
return success();
}
+std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
+mlir::createGpuToLLVMConversionPass(bool kernelBarePtrCallConv) {
+ return std::make_unique<GpuToLLVMConversionPass>(kernelBarePtrCallConv);
+}
+
void mlir::populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns,
StringRef gpuBinaryAnnotation,
converter, gpuBinaryAnnotation, kernelBarePtrCallConv);
patterns.add<EraseGpuModuleOpPattern>(&converter.getContext());
}
-
-std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
-mlir::createConvertGpuToLLVMPass(bool kernelBarePtrCallConv) {
- return std::make_unique<ConvertGpuToLLVMPass>(kernelBarePtrCallConv);
-}
#include "../GPUCommon/GPUOpsLowering.h"
#include "../GPUCommon/IndexIntrinsicsOpLowering.h"
#include "../GPUCommon/OpToFuncCallLowering.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTGPUTONVVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
+#include "../PassDetail.h"
using namespace mlir;
///
/// This pass only handles device code and is not meant to be run on GPU host
/// code.
-struct ConvertGpuToNVVMPass
- : public impl::ConvertGpuToNVVMPassBase<ConvertGpuToNVVMPass> {
- ConvertGpuToNVVMPass() = default;
- ConvertGpuToNVVMPass(unsigned indexBitwidth) {
+struct LowerGpuOpsToNVVMOpsPass
+ : public ConvertGpuOpsToNVVMOpsBase<LowerGpuOpsToNVVMOpsPass> {
+ LowerGpuOpsToNVVMOpsPass() = default;
+ LowerGpuOpsToNVVMOpsPass(unsigned indexBitwidth) {
this->indexBitwidth = indexBitwidth;
}
}
std::unique_ptr<OperationPass<gpu::GPUModuleOp>>
-mlir::createConvertGpuToNVVMPass(unsigned indexBitwidth) {
- return std::make_unique<ConvertGpuToNVVMPass>(indexBitwidth);
+mlir::createLowerGpuOpsToNVVMOpsPass(unsigned indexBitwidth) {
+ return std::make_unique<LowerGpuOpsToNVVMOpsPass>(indexBitwidth);
}
#include "../GPUCommon/GPUOpsLowering.h"
#include "../GPUCommon/IndexIntrinsicsOpLowering.h"
#include "../GPUCommon/OpToFuncCallLowering.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTGPUTOROCDLPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
+#include "../PassDetail.h"
using namespace mlir;
//
// This pass only handles device code and is not meant to be run on GPU host
// code.
-struct ConvertGpuToROCDLPass
- : public impl::ConvertGpuToROCDLPassBase<ConvertGpuToROCDLPass> {
- ConvertGpuToROCDLPass() = default;
- ConvertGpuToROCDLPass(const std::string &chipset, unsigned indexBitwidth,
- bool useBarePtrCallConv, gpu::amd::Runtime runtime) {
+struct LowerGpuOpsToROCDLOpsPass
+ : public ConvertGpuOpsToROCDLOpsBase<LowerGpuOpsToROCDLOpsPass> {
+ LowerGpuOpsToROCDLOpsPass() = default;
+ LowerGpuOpsToROCDLOpsPass(const std::string &chipset, unsigned indexBitwidth,
+ bool useBarePtrCallConv,
+ gpu::amd::Runtime runtime) {
if (this->chipset.getNumOccurrences() == 0)
this->chipset = chipset;
if (this->indexBitwidth.getNumOccurrences() == 0)
}
std::unique_ptr<OperationPass<gpu::GPUModuleOp>>
-mlir::createConvertGpuToROCDLPass(const std::string &chipset,
- unsigned indexBitwidth,
- bool useBarePtrCallConv,
- gpu::amd::Runtime runtime) {
- return std::make_unique<ConvertGpuToROCDLPass>(chipset, indexBitwidth,
- useBarePtrCallConv, runtime);
+mlir::createLowerGpuOpsToROCDLOpsPass(const std::string &chipset,
+ unsigned indexBitwidth,
+ bool useBarePtrCallConv,
+ gpu::amd::Runtime runtime) {
+ return std::make_unique<LowerGpuOpsToROCDLOpsPass>(
+ chipset, indexBitwidth, useBarePtrCallConv, runtime);
}
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
+#include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTGPUTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
/// replace it).
///
/// 2) Lower the body of the spirv::ModuleOp.
-class ConvertGPUToSPIRVPass
- : public impl::ConvertGPUToSPIRVPassBase<ConvertGPUToSPIRVPass> {
+class GPUToSPIRVPass : public ConvertGPUToSPIRVBase<GPUToSPIRVPass> {
public:
- explicit ConvertGPUToSPIRVPass(bool mapMemorySpace)
+ explicit GPUToSPIRVPass(bool mapMemorySpace)
: mapMemorySpace(mapMemorySpace) {}
void runOnOperation() override;
};
} // namespace
-void ConvertGPUToSPIRVPass::runOnOperation() {
+void GPUToSPIRVPass::runOnOperation() {
MLIRContext *context = &getContext();
ModuleOp module = getOperation();
std::unique_ptr<OperationPass<ModuleOp>>
mlir::createConvertGPUToSPIRVPass(bool mapMemorySpace) {
- return std::make_unique<ConvertGPUToSPIRVPass>(mapMemorySpace);
+ return std::make_unique<GPUToSPIRVPass>(mapMemorySpace);
}
//
//===----------------------------------------------------------------------===//
+#include "../PassDetail.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
-
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Target/SPIRV/Serialization.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTGPULAUNCHFUNCTOVULKANLAUNCHFUNCPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
static constexpr const char *kSPIRVBlobAttrName = "spirv_blob";
/// SPIR-V binary shader from `spirv::ModuleOp` using `spirv::serialize`
/// function and attaching binary data and entry point name as an attributes to
/// created vulkan launch call op.
-class ConvertGpuLaunchFuncToVulkanLaunchFuncPass
- : public impl::ConvertGpuLaunchFuncToVulkanLaunchFuncPassBase<
- ConvertGpuLaunchFuncToVulkanLaunchFuncPass> {
+class ConvertGpuLaunchFuncToVulkanLaunchFunc
+ : public ConvertGpuLaunchFuncToVulkanLaunchFuncBase<
+ ConvertGpuLaunchFuncToVulkanLaunchFunc> {
public:
- using ConvertGpuLaunchFuncToVulkanLaunchFuncPassBase::
- ConvertGpuLaunchFuncToVulkanLaunchFuncPassBase;
-
void runOnOperation() override;
private:
} // namespace
-void ConvertGpuLaunchFuncToVulkanLaunchFuncPass::runOnOperation() {
+void ConvertGpuLaunchFuncToVulkanLaunchFunc::runOnOperation() {
bool done = false;
getOperation().walk([this, &done](gpu::LaunchFuncOp op) {
if (done) {
spirvModule.erase();
}
-LogicalResult
-ConvertGpuLaunchFuncToVulkanLaunchFuncPass::declareVulkanLaunchFunc(
+LogicalResult ConvertGpuLaunchFuncToVulkanLaunchFunc::declareVulkanLaunchFunc(
Location loc, gpu::LaunchFuncOp launchOp) {
auto builder = OpBuilder::atBlockEnd(getOperation().getBody());
return success();
}
-LogicalResult ConvertGpuLaunchFuncToVulkanLaunchFuncPass::createBinaryShader(
+LogicalResult ConvertGpuLaunchFuncToVulkanLaunchFunc::createBinaryShader(
ModuleOp module, std::vector<char> &binaryShader) {
bool done = false;
SmallVector<uint32_t, 0> binary;
return success();
}
-void ConvertGpuLaunchFuncToVulkanLaunchFuncPass::convertGpuLaunchFunc(
+void ConvertGpuLaunchFuncToVulkanLaunchFunc::convertGpuLaunchFunc(
gpu::LaunchFuncOp launchOp) {
ModuleOp module = getOperation();
OpBuilder builder(launchOp);
std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
mlir::createConvertGpuLaunchFuncToVulkanLaunchFuncPass() {
- return std::make_unique<ConvertGpuLaunchFuncToVulkanLaunchFuncPass>();
+ return std::make_unique<ConvertGpuLaunchFuncToVulkanLaunchFunc>();
}
//
//===----------------------------------------------------------------------===//
+#include "../PassDetail.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
-
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/Attributes.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
-#include "mlir/Pass/Pass.h"
+
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/FormatVariadic.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTVULKANLAUNCHFUNCTOVULKANCALLSPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
static constexpr const char *kCInterfaceVulkanLaunch =
/// * deinitVulkan -- deinitializes vulkan runtime
///
class VulkanLaunchFuncToVulkanCallsPass
- : public impl::ConvertVulkanLaunchFuncToVulkanCallsPassBase<
+ : public ConvertVulkanLaunchFuncToVulkanCallsBase<
VulkanLaunchFuncToVulkanCallsPass> {
private:
void initializeCachedTypes() {
}
public:
- using ConvertVulkanLaunchFuncToVulkanCallsPassBase::
- ConvertVulkanLaunchFuncToVulkanCallsPassBase;
-
void runOnOperation() override;
private:
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
+#include "../PassDetail.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/ErrorHandling.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTLINALGTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::LLVM;
using namespace mlir::linalg;
namespace {
struct ConvertLinalgToLLVMPass
- : public impl::ConvertLinalgToLLVMPassBase<ConvertLinalgToLLVMPass> {
- using ConvertLinalgToLLVMPassBase::ConvertLinalgToLLVMPassBase;
-
+ : public ConvertLinalgToLLVMBase<ConvertLinalgToLLVMPass> {
void runOnOperation() override;
};
} // namespace
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTLINALGTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
/// A pass converting MLIR Linalg ops into SPIR-V ops.
-class ConvertLinalgToSPIRVPass
- : public impl::ConvertLinalgToSPIRVPassBase<ConvertLinalgToSPIRVPass> {
- using ConvertLinalgToSPIRVPassBase::ConvertLinalgToSPIRVPassBase;
-
+class LinalgToSPIRVPass : public ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
-void ConvertLinalgToSPIRVPass::runOnOperation() {
+void LinalgToSPIRVPass::runOnOperation() {
MLIRContext *context = &getContext();
ModuleOp module = getOperation();
return signalPassFailure();
}
-std::unique_ptr<OperationPass<ModuleOp>>
-mlir::createConvertLinalgToSPIRVPass() {
- return std::make_unique<ConvertLinalgToSPIRVPass>();
+std::unique_ptr<OperationPass<ModuleOp>> mlir::createLinalgToSPIRVPass() {
+ return std::make_unique<LinalgToSPIRVPass>();
}
#include "mlir/Conversion/LinalgToStandard/LinalgToStandard.h"
+#include "../PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTLINALGTOSTANDARDPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
using namespace mlir::linalg;
namespace {
struct ConvertLinalgToStandardPass
- : public impl::ConvertLinalgToStandardPassBase<
- ConvertLinalgToStandardPass> {
- using ConvertLinalgToStandardPassBase::ConvertLinalgToStandardPassBase;
-
+ : public ConvertLinalgToStandardBase<ConvertLinalgToStandardPass> {
void runOnOperation() override;
};
} // namespace
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/MathToFuncs/MathToFuncs.h"
-
+#include "../PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/TypeUtilities.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTMATHTOFUNCSPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
namespace {
struct ConvertMathToFuncsPass
- : public impl::ConvertMathToFuncsPassBase<ConvertMathToFuncsPass> {
- using ConvertMathToFuncsPassBase::ConvertMathToFuncsPassBase;
+ : public ConvertMathToFuncsBase<ConvertMathToFuncsPass> {
+ ConvertMathToFuncsPass() = default;
void runOnOperation() override;
if (failed(applyPartialConversion(module, target, std::move(patterns))))
signalPassFailure();
}
+
+std::unique_ptr<Pass> mlir::createConvertMathToFuncsPass() {
+ return std::make_unique<ConvertMathToFuncsPass>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/VectorPattern.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/IR/TypeUtilities.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTMATHTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
};
struct ConvertMathToLLVMPass
- : public impl::ConvertMathToLLVMPassBase<ConvertMathToLLVMPass> {
- using ConvertMathToLLVMPassBase::ConvertMathToLLVMPassBase;
+ : public ConvertMathToLLVMBase<ConvertMathToLLVMPass> {
+ ConvertMathToLLVMPass() = default;
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
>(converter);
// clang-format on
}
+
+std::unique_ptr<Pass> mlir::createConvertMathToLLVMPass() {
+ return std::make_unique<ConvertMathToLLVMPass>();
+}
#include "mlir/Conversion/MathToLibm/MathToLibm.h"
+#include "../PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/BuiltinDialect.h"
#include "mlir/IR/PatternMatch.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTMATHTOLIBMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
struct ConvertMathToLibmPass
- : public impl::ConvertMathToLibmPassBase<ConvertMathToLibmPass> {
- using ConvertMathToLibmPassBase::ConvertMathToLibmPassBase;
-
+ : public ConvertMathToLibmBase<ConvertMathToLibmPass> {
void runOnOperation() override;
};
} // namespace
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/MathToSPIRV/MathToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTMATHTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
/// A pass converting MLIR Math operations into the SPIR-V dialect.
class ConvertMathToSPIRVPass
- : public impl::ConvertMathToSPIRVPassBase<ConvertMathToSPIRVPass> {
- using ConvertMathToSPIRVPassBase::ConvertMathToSPIRVPassBase;
-
+ : public ConvertMathToSPIRVBase<ConvertMathToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
-
+#include "../PassDetail.h"
#include "mlir/Analysis/DataLayoutAnalysis.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h"
-#include "mlir/Pass/Pass.h"
#include "llvm/ADT/SmallBitVector.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTMEMREFTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
}
namespace {
-struct ConvertMemRefToLLVMPass
- : public impl::ConvertMemRefToLLVMPassBase<ConvertMemRefToLLVMPass> {
- using ConvertMemRefToLLVMPassBase::ConvertMemRefToLLVMPassBase;
+struct MemRefToLLVMPass : public ConvertMemRefToLLVMBase<MemRefToLLVMPass> {
+ MemRefToLLVMPass() = default;
void runOnOperation() override {
Operation *op = getOperation();
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createMemRefToLLVMPass() {
+ return std::make_unique<MemRefToLLVMPass>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
+#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_MAPMEMREFSTORAGECLASSPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "mlir-map-memref-storage-class"
using namespace mlir;
namespace {
class MapMemRefStorageClassPass final
- : public impl::MapMemRefStorageClassPassBase<MapMemRefStorageClassPass> {
+ : public MapMemRefStorageClassBase<MapMemRefStorageClassPass> {
public:
explicit MapMemRefStorageClassPass() {
memorySpaceMap = spirv::mapMemorySpaceToVulkanStorageClass;
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTMEMREFTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
/// A pass converting MLIR MemRef operations into the SPIR-V dialect.
class ConvertMemRefToSPIRVPass
- : public impl::ConvertMemRefToSPIRVPassBase<ConvertMemRefToSPIRVPass> {
- using ConvertMemRefToSPIRVPassBase::ConvertMemRefToSPIRVPassBase;
-
+ : public ConvertMemRefToSPIRVBase<ConvertMemRefToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/NVGPUToNVVM/NVGPUToNVVM.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/LLVMIR/NVVMDialect.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTNVGPUTONVVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
};
struct ConvertNVGPUToNVVMPass
- : public impl::ConvertNVGPUToNVVMPassBase<ConvertNVGPUToNVVMPass> {
- using ConvertNVGPUToNVVMPassBase::ConvertNVGPUToNVVMPassBase;
+ : public ConvertNVGPUToNVVMBase<ConvertNVGPUToNVVMPass> {
+ ConvertNVGPUToNVVMPass() = default;
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
NVGPUAsyncCreateGroupLowering, NVGPUAsyncWaitLowering>(
converter);
}
+
+std::unique_ptr<Pass> mlir::createConvertNVGPUToNVVMPass() {
+ return std::make_unique<ConvertNVGPUToNVVMPass>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
+#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/OpenACC/OpenACC.h"
#include "mlir/IR/Builders.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTOPENACCTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
struct ConvertOpenACCToLLVMPass
- : public impl::ConvertOpenACCToLLVMPassBase<ConvertOpenACCToLLVMPass> {
- using ConvertOpenACCToLLVMPassBase::ConvertOpenACCToLLVMPassBase;
-
+ : public ConvertOpenACCToLLVMBase<ConvertOpenACCToLLVMPass> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
+#include "../PassDetail.h"
#include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h"
-
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/OpenACC/OpenACC.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTOPENACCTOSCFPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
//===----------------------------------------------------------------------===//
namespace {
struct ConvertOpenACCToSCFPass
- : public impl::ConvertOpenACCToSCFPassBase<ConvertOpenACCToSCFPass> {
- using ConvertOpenACCToSCFPassBase::ConvertOpenACCToSCFPassBase;
-
+ : public ConvertOpenACCToSCFBase<ConvertOpenACCToSCFPass> {
void runOnOperation() override;
};
} // namespace
#include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
+#include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTOPENMPTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
struct ConvertOpenMPToLLVMPass
- : public impl::ConvertOpenMPToLLVMPassBase<ConvertOpenMPToLLVMPass> {
- using ConvertOpenMPToLLVMPassBase::ConvertOpenMPToLLVMPassBase;
-
+ : public ConvertOpenMPToLLVMBase<ConvertOpenMPToLLVMPass> {
void runOnOperation() override;
};
} // namespace
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h"
-
+#include "../PassDetail.h"
#include "PredicateTree.h"
#include "mlir/Dialect/PDL/IR/PDL.h"
#include "mlir/Dialect/PDL/IR/PDLTypes.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTPDLTOPDLINTERPPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::pdl_to_pdl_interp;
//===----------------------------------------------------------------------===//
namespace {
-struct ConvertPDLToPDLInterpPass
- : public impl::ConvertPDLToPDLInterpPassBase<ConvertPDLToPDLInterpPass> {
- using ConvertPDLToPDLInterpPassBase::ConvertPDLToPDLInterpPassBase;
-
+struct PDLToPDLInterpPass
+ : public ConvertPDLToPDLInterpBase<PDLToPDLInterpPass> {
void runOnOperation() final;
};
} // namespace
/// Convert the given module containing PDL pattern operations into a PDL
/// Interpreter operations.
-void ConvertPDLToPDLInterpPass::runOnOperation() {
+void PDLToPDLInterpPass::runOnOperation() {
ModuleOp module = getOperation();
// Create the main matcher function This function contains all of the match
}
std::unique_ptr<OperationPass<ModuleOp>> mlir::createPDLToPDLInterpPass() {
- return std::make_unique<ConvertPDLToPDLInterpPass>();
+ return std::make_unique<PDLToPDLInterpPass>();
}
--- /dev/null
+//===- PassDetail.h - Conversion Pass class details -------------*- 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 CONVERSION_PASSDETAIL_H_
+#define CONVERSION_PASSDETAIL_H_
+
+#include "mlir/Pass/Pass.h"
+
+#include "mlir/Conversion/GPUToROCDL/Runtimes.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/FunctionInterfaces.h"
+
+namespace mlir {
+class AffineDialect;
+
+// Forward declaration from Dialect.h
+template <typename ConcreteDialect>
+void registerDialect(DialectRegistry ®istry);
+
+namespace acc {
+class OpenACCDialect;
+} // namespace acc
+
+namespace arith {
+class ArithmeticDialect;
+} // namespace arith
+
+namespace cf {
+class ControlFlowDialect;
+} // namespace cf
+
+namespace complex {
+class ComplexDialect;
+} // namespace complex
+
+namespace gpu {
+class GPUDialect;
+class GPUModuleOp;
+} // namespace gpu
+
+namespace func {
+class FuncDialect;
+} // namespace func
+
+namespace linalg {
+class LinalgDialect;
+} // namespace linalg
+
+namespace LLVM {
+class LLVMDialect;
+} // namespace LLVM
+
+namespace nvgpu {
+class NVGPUDialect;
+}
+
+namespace NVVM {
+class NVVMDialect;
+} // namespace NVVM
+
+namespace math {
+class MathDialect;
+} // namespace math
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+namespace omp {
+class OpenMPDialect;
+} // namespace omp
+
+namespace pdl_interp {
+class PDLInterpDialect;
+} // namespace pdl_interp
+
+namespace ROCDL {
+class ROCDLDialect;
+} // namespace ROCDL
+
+namespace scf {
+class SCFDialect;
+} // namespace scf
+
+namespace spirv {
+class SPIRVDialect;
+} // namespace spirv
+
+namespace tensor {
+class TensorDialect;
+} // namespace tensor
+
+namespace tosa {
+class TosaDialect;
+} // namespace tosa
+
+namespace vector {
+class VectorDialect;
+} // namespace vector
+
+namespace arm_neon {
+class ArmNeonDialect;
+} // namespace arm_neon
+
+#define GEN_PASS_CLASSES
+#include "mlir/Conversion/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // CONVERSION_PASSDETAIL_H_
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
-
+#include "../PassDetail.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_RECONCILEUNREALIZEDCASTSPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
};
/// Pass to simplify and eliminate unrealized conversion casts.
-struct ReconcileUnrealizedCastsPass
- : public impl::ReconcileUnrealizedCastsPassBase<
- ReconcileUnrealizedCastsPass> {
- using ReconcileUnrealizedCastsPassBase::ReconcileUnrealizedCastsPassBase;
+struct ReconcileUnrealizedCasts
+ : public ReconcileUnrealizedCastsBase<ReconcileUnrealizedCasts> {
+ ReconcileUnrealizedCasts() = default;
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
RewritePatternSet &patterns) {
patterns.add<UnrealizedConversionCastPassthrough>(patterns.getContext());
}
+
+std::unique_ptr<Pass> mlir::createReconcileUnrealizedCastsPass() {
+ return std::make_unique<ReconcileUnrealizedCasts>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
-
+#include "../PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/Passes.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTSCFTOCONTROLFLOWPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::scf;
namespace {
-struct ConvertSCFToControlFlowPass
- : public impl::ConvertSCFToControlFlowPassBase<
- ConvertSCFToControlFlowPass> {
- using ConvertSCFToControlFlowPassBase::ConvertSCFToControlFlowPassBase;
-
+struct SCFToControlFlowPass
+ : public SCFToControlFlowBase<SCFToControlFlowPass> {
void runOnOperation() override;
};
patterns.add<DoWhileLowering>(patterns.getContext(), /*benefit=*/2);
}
-void ConvertSCFToControlFlowPass::runOnOperation() {
+void SCFToControlFlowPass::runOnOperation() {
RewritePatternSet patterns(&getContext());
populateSCFToControlFlowConversionPatterns(patterns);
applyPartialConversion(getOperation(), target, std::move(patterns))))
signalPassFailure();
}
+
+std::unique_ptr<Pass> mlir::createConvertSCFToCFPass() {
+ return std::make_unique<SCFToControlFlowPass>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/SCFToGPU/SCFToGPU.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
+
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/CommandLine.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTAFFINEFORTOGPUPASS
-#define GEN_PASS_DEF_CONVERTPARALLELLOOPTOGPUPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::scf;
// A pass that traverses top-level loops in the function and converts them to
// GPU launch operations. Nested launches are not allowed, so this does not
// walk the function recursively to avoid considering nested loops.
-struct ForLoopMapper
- : public impl::ConvertAffineForToGPUPassBase<ForLoopMapper> {
+struct ForLoopMapper : public ConvertAffineForToGPUBase<ForLoopMapper> {
ForLoopMapper() = default;
ForLoopMapper(unsigned numBlockDims, unsigned numThreadDims) {
this->numBlockDims = numBlockDims;
};
struct ParallelLoopToGpuPass
- : public impl::ConvertParallelLoopToGpuPassBase<ParallelLoopToGpuPass> {
- using ConvertParallelLoopToGpuPassBase::ConvertParallelLoopToGpuPassBase;
-
+ : public ConvertParallelLoopToGpuBase<ParallelLoopToGpuPass> {
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
populateParallelLoopToGPUPatterns(patterns);
mlir::createAffineForToGPUPass() {
return std::make_unique<ForLoopMapper>();
}
+
+std::unique_ptr<Pass> mlir::createParallelLoopToGpuPass() {
+ return std::make_unique<ParallelLoopToGpuPass>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
-
+#include "../PassDetail.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/IR/SymbolTable.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTSCFTOOPENMPPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
/// Matches a block containing a "simple" reduction. The expected shape of the
}
/// A pass converting SCF operations to OpenMP operations.
-struct ConvertSCFToOpenMPPass
- : public impl::ConvertSCFToOpenMPPassBase<ConvertSCFToOpenMPPass> {
- using ConvertSCFToOpenMPPassBase::ConvertSCFToOpenMPPassBase;
-
+struct SCFToOpenMPPass : public ConvertSCFToOpenMPBase<SCFToOpenMPPass> {
/// Pass entry point.
void runOnOperation() override {
if (failed(applyPatterns(getOperation())))
} // namespace
std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertSCFToOpenMPPass() {
- return std::make_unique<ConvertSCFToOpenMPPass>();
+ return std::make_unique<SCFToOpenMPPass>();
}
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"
+#include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTSCFTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
-struct ConvertSCFToSPIRVPass
- : public impl::ConvertSCFToSPIRVPassBase<ConvertSCFToSPIRVPass> {
- using ConvertSCFToSPIRVPassBase::ConvertSCFToSPIRVPassBase;
-
+struct SCFToSPIRVPass : public SCFToSPIRVBase<SCFToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
-void ConvertSCFToSPIRVPass::runOnOperation() {
+void SCFToSPIRVPass::runOnOperation() {
MLIRContext *context = &getContext();
Operation *op = getOperation();
}
std::unique_ptr<OperationPass<>> mlir::createConvertSCFToSPIRVPass() {
- return std::make_unique<ConvertSCFToSPIRVPass>();
+ return std::make_unique<SCFToSPIRVPass>();
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h"
+#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/SymbolTable.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
+
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/FormatVariadic.h"
-namespace mlir {
-#define GEN_PASS_DEF_LOWERHOSTCODETOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
static constexpr const char kSPIRVModule[] = "__spv__";
}
};
-class LowerHostCodeToLLVMPass
- : public impl::LowerHostCodeToLLVMPassBase<LowerHostCodeToLLVMPass> {
+class LowerHostCodeToLLVM
+ : public LowerHostCodeToLLVMBase<LowerHostCodeToLLVM> {
public:
- using LowerHostCodeToLLVMPassBase::LowerHostCodeToLLVMPassBase;
-
void runOnOperation() override {
ModuleOp module = getOperation();
std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
mlir::createLowerHostCodeToLLVMPass() {
- return std::make_unique<LowerHostCodeToLLVMPass>();
+ return std::make_unique<LowerHostCodeToLLVM>();
}
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTSPIRVTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
namespace {
/// A pass converting MLIR SPIR-V operations into LLVM dialect.
class ConvertSPIRVToLLVMPass
- : public impl::ConvertSPIRVToLLVMPassBase<ConvertSPIRVToLLVMPass> {
- using ConvertSPIRVToLLVMPassBase::ConvertSPIRVToLLVMPassBase;
-
+ : public ConvertSPIRVToLLVMBase<ConvertSPIRVToLLVMPass> {
void runOnOperation() override;
};
} // namespace
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
+#include "../PassDetail.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/Pass/PassRegistry.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTSHAPECONSTRAINTSPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
-
namespace {
#include "ShapeToStandard.cpp.inc"
} // namespace
// eager (side-effecting) error handling code. After eager error handling code
// is emitted, witnesses are satisfied, so they are replace with
// `shape.const_witness true`.
-class ConvertShapeConstraintsPass
- : public impl::ConvertShapeConstraintsPassBase<
- ConvertShapeConstraintsPass> {
- using ConvertShapeConstraintsPassBase::ConvertShapeConstraintsPassBase;
-
+class ConvertShapeConstraints
+ : public ConvertShapeConstraintsBase<ConvertShapeConstraints> {
void runOnOperation() override {
auto *func = getOperation();
auto *context = &getContext();
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createConvertShapeConstraintsPass() {
+ return std::make_unique<ConvertShapeConstraints>();
+}
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
+#include "../PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/ImplicitLocOpBuilder.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/STLExtras.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTSHAPETOSTANDARDPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::shape;
using namespace mlir::scf;
namespace {
/// Conversion pass.
class ConvertShapeToStandardPass
- : public impl::ConvertShapeToStandardPassBase<ConvertShapeToStandardPass> {
- using ConvertShapeToStandardPassBase::ConvertShapeToStandardPassBase;
+ : public ConvertShapeToStandardBase<ConvertShapeToStandardPass> {
void runOnOperation() override;
};
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/TensorToLinalg/TensorToLinalgPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/TensorToLinalg/TensorToLinalg.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTTENSORTOLINALGPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
/// A pass converting MLIR Tensor operations into the Linalg dialect.
class ConvertTensorToLinalgPass
- : public impl::ConvertTensorToLinalgPassBase<ConvertTensorToLinalgPass> {
- using ConvertTensorToLinalgPassBase::ConvertTensorToLinalgPassBase;
-
+ : public ConvertTensorToLinalgBase<ConvertTensorToLinalgPass> {
void runOnOperation() override {
auto &context = getContext();
ConversionTarget target(context);
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h"
-
+#include "../PassDetail.h"
#include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
#include "mlir/Conversion/TensorToSPIRV/TensorToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTTENSORTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
/// A pass converting MLIR Tensor operations into the SPIR-V dialect.
class ConvertTensorToSPIRVPass
- : public impl::ConvertTensorToSPIRVPassBase<ConvertTensorToSPIRVPass> {
- using ConvertTensorToSPIRVPassBase::ConvertTensorToSPIRVPassBase;
-
+ : public ConvertTensorToSPIRVBase<ConvertTensorToSPIRVPass> {
void runOnOperation() override {
MLIRContext *context = &getContext();
Operation *op = getOperation();
//
//===----------------------------------------------------------------------===//
+#include "../PassDetail.h"
#include "mlir/Conversion/TosaToArith/TosaToArith.h"
-
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTTOSATOARITHPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace tosa;
namespace {
-struct ConvertTosaToArithPass
- : public impl::ConvertTosaToArithPassBase<ConvertTosaToArithPass> {
+struct TosaToArith : public TosaToArithBase<TosaToArith> {
public:
- using ConvertTosaToArithPassBase::ConvertTosaToArithPassBase;
-
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext());
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::tosa::createTosaToArith() {
+ return std::make_unique<TosaToArith>();
+}
//
//===----------------------------------------------------------------------===//
+#include "../PassDetail.h"
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
-
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTTOSATOLINALGNAMEDPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
-struct ConvertTosaToLinalgNamedPass
- : public impl::ConvertTosaToLinalgNamedPassBase<
- ConvertTosaToLinalgNamedPass> {
+struct TosaToLinalgNamed : public TosaToLinalgNamedBase<TosaToLinalgNamed> {
public:
- using ConvertTosaToLinalgNamedPassBase::ConvertTosaToLinalgNamedPassBase;
-
void getDependentDialects(DialectRegistry ®istry) const override {
registry
.insert<arith::ArithmeticDialect, linalg::LinalgDialect,
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::tosa::createTosaToLinalgNamed() {
+ return std::make_unique<TosaToLinalgNamed>();
+}
//
//===----------------------------------------------------------------------===//
+#include "../PassDetail.h"
#include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
-
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/Passes.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTTOSATOLINALGPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
-struct ConvertTosaToLinalgPass
- : public impl::ConvertTosaToLinalgPassBase<ConvertTosaToLinalgPass> {
+struct TosaToLinalg : public TosaToLinalgBase<TosaToLinalg> {
public:
- using ConvertTosaToLinalgPassBase::ConvertTosaToLinalgPassBase;
-
void getDependentDialects(DialectRegistry ®istry) const override {
registry
.insert<arith::ArithmeticDialect, linalg::LinalgDialect,
};
} // namespace
+std::unique_ptr<Pass> mlir::tosa::createTosaToLinalg() {
+ return std::make_unique<TosaToLinalg>();
+}
+
void mlir::tosa::addTosaToLinalgPasses(OpPassManager &pm,
bool disableTosaDecompositions) {
// Optional decompositions are designed to benefit linalg.
if (!disableTosaDecompositions)
- pm.addNestedPass<func::FuncOp>(
- tosa::createTosaOptionalDecompositionsPass());
+ pm.addNestedPass<func::FuncOp>(tosa::createTosaOptionalDecompositions());
pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
pm.addNestedPass<func::FuncOp>(tosa::createTosaMakeBroadcastablePass());
- pm.addNestedPass<func::FuncOp>(createConvertTosaToLinalgNamedPass());
+ pm.addNestedPass<func::FuncOp>(tosa::createTosaToLinalgNamed());
pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
// TODO: Remove pass that operates on const tensor and enable optionality
pm.addNestedPass<func::FuncOp>(tosa::createTosaLayerwiseConstantFoldPass());
pm.addNestedPass<func::FuncOp>(tosa::createTosaMakeBroadcastablePass());
- pm.addNestedPass<func::FuncOp>(createConvertTosaToLinalgPass());
+ pm.addNestedPass<func::FuncOp>(tosa::createTosaToLinalg());
}
//
//===----------------------------------------------------------------------===//
+#include "../PassDetail.h"
#include "mlir/Conversion/TosaToSCF/TosaToSCF.h"
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTTOSATOSCFPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace tosa;
namespace {
-struct TosaToSCF : public impl::ConvertTosaToSCFPassBase<TosaToSCF> {
+struct TosaToSCF : public TosaToSCFBase<TosaToSCF> {
public:
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
};
} // namespace
+std::unique_ptr<Pass> mlir::tosa::createTosaToSCF() {
+ return std::make_unique<TosaToSCF>();
+}
+
void mlir::tosa::addTosaToSCFPasses(OpPassManager &pm) {
- pm.addNestedPass<func::FuncOp>(createConvertTosaToSCFPass());
+ pm.addNestedPass<func::FuncOp>(createTosaToSCF());
}
//
//===----------------------------------------------------------------------===//
+#include "../PassDetail.h"
#include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
-
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTTOSATOTENSORPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace tosa;
namespace {
-struct ConvertTosaToTensorPass
- : public impl::ConvertTosaToTensorPassBase<ConvertTosaToTensorPass> {
+struct TosaToTensor : public TosaToTensorBase<TosaToTensor> {
public:
- using ConvertTosaToTensorPassBase::ConvertTosaToTensorPassBase;
-
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext());
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::tosa::createTosaToTensor() {
+ return std::make_unique<TosaToTensor>();
+}
#include "NvGpuSupport.h"
#include "mlir/Conversion/VectorToGPU/VectorToGPU.h"
+#include "../PassDetail.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Transforms/Passes.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTVECTORTOGPUPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
/// For a vector TransferOpType `xferOp`, an empty `indices` vector, and an
namespace {
struct ConvertVectorToGPUPass
- : public impl::ConvertVectorToGPUPassBase<ConvertVectorToGPUPass> {
+ : public ConvertVectorToGPUBase<ConvertVectorToGPUPass> {
explicit ConvertVectorToGPUPass(bool useNvGpu_) {
useNvGpu.setValue(useNvGpu_);
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
+#include "../PassDetail.h"
+
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Dialect/AMX/AMXDialect.h"
#include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h"
#include "mlir/Dialect/X86Vector/Transforms.h"
#include "mlir/Dialect/X86Vector/X86VectorDialect.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTVECTORTOLLVMPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::vector;
namespace {
-struct ConvertVectorToLLVMPass
- : public impl::ConvertVectorToLLVMPassBase<ConvertVectorToLLVMPass> {
- ConvertVectorToLLVMPass(const LowerVectorToLLVMOptions &options) {
+struct LowerVectorToLLVMPass
+ : public ConvertVectorToLLVMBase<LowerVectorToLLVMPass> {
+ LowerVectorToLLVMPass(const LowerVectorToLLVMOptions &options) {
this->reassociateFPReductions = options.reassociateFPReductions;
this->force32BitVectorIndices = options.force32BitVectorIndices;
this->armNeon = options.armNeon;
};
} // namespace
-void ConvertVectorToLLVMPass::runOnOperation() {
+void LowerVectorToLLVMPass::runOnOperation() {
// Perform progressive lowering of operations on slices and
// all contraction operations. Also applies folding and DCE.
{
std::unique_ptr<OperationPass<ModuleOp>>
mlir::createConvertVectorToLLVMPass(const LowerVectorToLLVMOptions &options) {
- return std::make_unique<ConvertVectorToLLVMPass>(options);
+ return std::make_unique<LowerVectorToLLVMPass>(options);
}
#include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
+#include "../PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/Passes.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTVECTORTOSCFPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using vector::TransferReadOp;
using vector::TransferWriteOp;
namespace {
struct ConvertVectorToSCFPass
- : public impl::ConvertVectorToSCFPassBase<ConvertVectorToSCFPass> {
+ : public ConvertVectorToSCFBase<ConvertVectorToSCFPass> {
ConvertVectorToSCFPass() = default;
ConvertVectorToSCFPass(const VectorTransferToSCFOptions &options) {
this->fullUnroll = options.unroll;
#include "mlir/Conversion/VectorToSPIRV/VectorToSPIRV.h"
+#include "../PassDetail.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Conversion/VectorToSPIRV/VectorToSPIRVPass.h"
+#include "../PassDetail.h"
#include "mlir/Conversion/VectorToSPIRV/VectorToSPIRV.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTVECTORTOSPIRVPASS
-#include "mlir/Conversion/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
struct ConvertVectorToSPIRVPass
- : public impl::ConvertVectorToSPIRVPassBase<ConvertVectorToSPIRVPass> {
- using ConvertVectorToSPIRVPassBase::ConvertVectorToSPIRVPassBase;
-
+ : public ConvertVectorToSPIRVBase<ConvertVectorToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
+#include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/Support/Debug.h"
#include <algorithm>
-namespace mlir {
-#define GEN_PASS_DEF_AFFINEDATACOPYGENERATIONPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "affine-data-copy-generate"
using namespace mlir;
/// provided.
// TODO: We currently can't generate copies correctly when stores
// are strided. Check for strided stores.
-struct AffineDataCopyGenerationPass
- : public impl::AffineDataCopyGenerationPassBase<
- AffineDataCopyGenerationPass> {
- AffineDataCopyGenerationPass() = default;
- explicit AffineDataCopyGenerationPass(unsigned slowMemorySpace,
- unsigned fastMemorySpace,
- unsigned tagMemorySpace,
- int minDmaTransferSize,
- uint64_t fastMemCapacityBytes) {
+struct AffineDataCopyGeneration
+ : public AffineDataCopyGenerationBase<AffineDataCopyGeneration> {
+ AffineDataCopyGeneration() = default;
+ explicit AffineDataCopyGeneration(unsigned slowMemorySpace,
+ unsigned fastMemorySpace,
+ unsigned tagMemorySpace,
+ int minDmaTransferSize,
+ uint64_t fastMemCapacityBytes) {
this->slowMemorySpace = slowMemorySpace;
this->fastMemorySpace = fastMemorySpace;
this->tagMemorySpace = tagMemorySpace;
unsigned tagMemorySpace,
int minDmaTransferSize,
uint64_t fastMemCapacityBytes) {
- return std::make_unique<AffineDataCopyGenerationPass>(
+ return std::make_unique<AffineDataCopyGeneration>(
slowMemorySpace, fastMemorySpace, tagMemorySpace, minDmaTransferSize,
fastMemCapacityBytes);
}
std::unique_ptr<OperationPass<func::FuncOp>>
mlir::createAffineDataCopyGenerationPass() {
- return std::make_unique<AffineDataCopyGenerationPass>();
+ return std::make_unique<AffineDataCopyGeneration>();
}
/// Generate copies for this block. The block is partitioned into separate
/// ranges: each range is either a sequence of one or more operations starting
/// and ending with an affine load or store op, or just an affine.forop (which
/// could have other affine for op's nested within).
-void AffineDataCopyGenerationPass::runOnBlock(
- Block *block, DenseSet<Operation *> ©Nests) {
+void AffineDataCopyGeneration::runOnBlock(Block *block,
+ DenseSet<Operation *> ©Nests) {
if (block->empty())
return;
}
}
-void AffineDataCopyGenerationPass::runOnOperation() {
+void AffineDataCopyGeneration::runOnOperation() {
func::FuncOp f = getOperation();
OpBuilder topBuilder(f.getBody());
zeroIndex = topBuilder.create<arith::ConstantIndexOp>(f.getLoc(), 0);
// fundamental operations.
//===----------------------------------------------------------------------===//
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Passes.h"
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_AFFINEEXPANDINDEXOPSPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
};
class ExpandAffineIndexOpsPass
- : public impl::AffineExpandIndexOpsPassBase<ExpandAffineIndexOpsPass> {
+ : public AffineExpandIndexOpsBase<ExpandAffineIndexOpsPass> {
public:
ExpandAffineIndexOpsPass() = default;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
+#include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/Builders.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
-namespace mlir {
-#define GEN_PASS_DEF_AFFINELOOPINVARIANTCODEMOTIONPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "licm"
using namespace mlir;
/// TODO: This code should be removed once the new LICM pass can handle its
/// uses.
struct LoopInvariantCodeMotion
- : public impl::AffineLoopInvariantCodeMotionPassBase<
- LoopInvariantCodeMotion> {
+ : public AffineLoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
void runOnOperation() override;
void runOnAffineForOp(AffineForOp forOp);
};
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_AFFINELOOPNORMALIZEPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
/// As currently implemented, this pass cannot fail, but it might skip over ops
/// that are already in a normalized form.
struct AffineLoopNormalizePass
- : public impl::AffineLoopNormalizePassBase<AffineLoopNormalizePass> {
+ : public AffineLoopNormalizeBase<AffineLoopNormalizePass> {
void runOnOperation() override {
getOperation().walk([](Operation *op) {
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
+#include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Affine/Passes.h.inc"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "llvm/Support/Debug.h"
#include <deque>
-namespace mlir {
-#define GEN_PASS_DEF_AFFINEPARALLELIZEPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "affine-parallel"
using namespace mlir;
namespace {
/// Convert all parallel affine.for op into 1-D affine.parallel op.
-struct AffineParallelize
- : public impl::AffineParallelizePassBase<AffineParallelize> {
+struct AffineParallelize : public AffineParallelizeBase<AffineParallelize> {
void runOnOperation() override;
};
#include "mlir/Dialect/Affine/Passes.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/Dominance.h"
#include "mlir/Support/LogicalResult.h"
#include <algorithm>
-namespace mlir {
-#define GEN_PASS_DEF_AFFINESCALARREPLACEMENTPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "affine-scalrep"
using namespace mlir;
namespace {
struct AffineScalarReplacement
- : public impl::AffineScalarReplacementPassBase<AffineScalarReplacement> {
+ : public AffineScalarReplacementBase<AffineScalarReplacement> {
void runOnOperation() override;
};
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Transforms/Passes.h"
#include "mlir/Transforms/RegionUtils.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_LOOPCOALESCINGPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
#define PASS_NAME "loop-coalescing"
#define DEBUG_TYPE PASS_NAME
using namespace mlir;
namespace {
-struct LoopCoalescingPass
- : public impl::LoopCoalescingPassBase<LoopCoalescingPass> {
+struct LoopCoalescingPass : public LoopCoalescingBase<LoopCoalescingPass> {
/// Walk either an scf.for or an affine.for to find a band to coalesce.
template <typename LoopOpTy>
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/LoopFusionUtils.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
#include "llvm/Support/raw_ostream.h"
#include <iomanip>
#include <sstream>
-
-namespace mlir {
-#define GEN_PASS_DEF_AFFINELOOPFUSIONPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "affine-loop-fusion"
using namespace mlir;
// TODO: Extend this pass to check for fusion preventing dependences,
// and add support for more general loop fusion algorithms.
-struct LoopFusion : public impl::AffineLoopFusionPassBase<LoopFusion> {
+struct LoopFusion : public AffineLoopFusionBase<LoopFusion> {
LoopFusion() = default;
LoopFusion(unsigned fastMemorySpace, uint64_t localBufSizeThresholdBytes,
bool maximalFusion, enum FusionMode affineFusionMode) {
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
+#include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_AFFINELOOPTILINGPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
+using namespace mlir;
#define DEBUG_TYPE "affine-loop-tile"
-using namespace mlir;
-
namespace {
/// A pass to perform loop tiling on all suitable loop nests of a Function.
-struct LoopTiling : public impl::AffineLoopTilingPassBase<LoopTiling> {
+struct LoopTiling : public AffineLoopTilingBase<LoopTiling> {
LoopTiling() = default;
explicit LoopTiling(uint64_t cacheSizeBytes, bool avoidMaxMinBounds = true)
: avoidMaxMinBounds(avoidMaxMinBounds) {
// This file implements loop unrolling.
//
//===----------------------------------------------------------------------===//
-
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Affine/Passes.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/Builders.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_AFFINELOOPUNROLLPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
+using namespace mlir;
#define DEBUG_TYPE "affine-loop-unroll"
-using namespace mlir;
-
namespace {
// TODO: this is really a test pass and should be moved out of dialect
/// full unroll threshold was specified, in which case, fully unrolls all loops
/// with trip count less than the specified threshold. The latter is for testing
/// purposes, especially for testing outer loop unrolling.
-struct LoopUnroll : public impl::AffineLoopUnrollPassBase<LoopUnroll> {
+struct LoopUnroll : public AffineLoopUnrollBase<LoopUnroll> {
// Callback to obtain unroll factors; if this has a callable target, takes
// precedence over command-line argument or passed argument.
const std::function<unsigned(AffineForOp)> getUnrollFactor;
// op's, bodies of those loops will not be jammed.
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Affine/Passes.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/Support/CommandLine.h"
-namespace mlir {
-#define GEN_PASS_DEF_AFFINELOOPUNROLLANDJAMPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
+using namespace mlir;
#define DEBUG_TYPE "affine-loop-unroll-jam"
-using namespace mlir;
-
namespace {
/// Loop unroll jam pass. Currently, this just unroll jams the first
/// outer loop in a Function.
-struct LoopUnrollAndJam
- : public impl::AffineLoopUnrollAndJamPassBase<LoopUnrollAndJam> {
+struct LoopUnrollAndJam : public AffineLoopUnrollAndJamBase<LoopUnrollAndJam> {
explicit LoopUnrollAndJam(Optional<unsigned> unrollJamFactor = None) {
if (unrollJamFactor)
this->unrollJamFactor = *unrollJamFactor;
--- /dev/null
+//===- PassDetail.h - Affine Pass class details -----------------*- 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 DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/Affine/Passes.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+// Forward declaration from Dialect.h
+template <typename ConcreteDialect>
+void registerDialect(DialectRegistry ®istry);
+
+namespace arith {
+class ArithmeticDialect;
+} // namespace arith
+
+namespace linalg {
+class LinalgDialect;
+} // namespace linalg
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+namespace vector {
+class VectorDialect;
+} // namespace vector
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Affine/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Builders.h"
#include "mlir/Transforms/Passes.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_AFFINEPIPELINEDATATRANSFERPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "affine-pipeline-data-transfer"
using namespace mlir;
namespace {
struct PipelineDataTransfer
- : public impl::AffinePipelineDataTransferPassBase<PipelineDataTransfer> {
+ : public AffinePipelineDataTransferBase<PipelineDataTransfer> {
void runOnOperation() override;
void runOnAffineForOp(AffineForOp forOp);
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/Utils.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/IntegerSet.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_SIMPLIFYAFFINESTRUCTURESPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "simplify-affine-structure"
using namespace mlir;
/// all memrefs with non-trivial layout maps are converted to ones with trivial
/// identity layout ones.
struct SimplifyAffineStructures
- : public impl::SimplifyAffineStructuresPassBase<SimplifyAffineStructures> {
+ : public SimplifyAffineStructuresBase<SimplifyAffineStructures> {
void runOnOperation() override;
/// Utility to simplify an affine attribute and update its entry in the parent
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Utils/VectorUtils.h"
#include "mlir/IR/BlockAndValueMapping.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Support/LLVM.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_AFFINEVECTORIZEPASS
-#include "mlir/Dialect/Affine/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace vector;
/// Base state for the vectorize pass.
/// Command line arguments are preempted by non-empty pass arguments.
-struct Vectorize : public impl::AffineVectorizePassBase<Vectorize> {
+struct Vectorize : public AffineVectorizeBase<Vectorize> {
Vectorize() = default;
Vectorize(ArrayRef<int64_t> virtualVectorSize);
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h"
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
-namespace mlir {
-namespace arith {
-#define GEN_PASS_DEF_ARITHMETICBUFFERIZEPASS
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
-} // namespace arith
-} // namespace mlir
-
using namespace mlir;
using namespace bufferization;
namespace {
/// Pass to bufferize Arithmetic ops.
struct ArithmeticBufferizePass
- : public arith::impl::ArithmeticBufferizePassBase<ArithmeticBufferizePass> {
+ : public ArithmeticBufferizeBase<ArithmeticBufferizePass> {
ArithmeticBufferizePass(uint64_t alignment = 0, bool constantOpOnly = false)
: constantOpOnly(constantOpOnly) {
this->alignment = alignment;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
#include "mlir/IR/TypeUtilities.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-namespace arith {
-#define GEN_PASS_DEF_ARITHMETICEXPANDOPSPASS
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
-} // namespace arith
-} // namespace mlir
-
using namespace mlir;
/// Create an integer or index constant.
};
struct ArithmeticExpandOpsPass
- : public arith::impl::ArithmeticExpandOpsPassBase<ArithmeticExpandOpsPass> {
+ : public ArithmeticExpandOpsBase<ArithmeticExpandOpsPass> {
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
ConversionTarget target(getContext());
--- /dev/null
+//===- PassDetail.h - Arithmetic Pass details -------------------*- 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 DIALECT_ARITHMETIC_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_ARITHMETIC_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+namespace bufferization {
+class BufferizationDialect;
+} // namespace bufferization
+
+namespace func {
+class FuncDialect;
+} // namespace func
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_ARITHMETIC_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
#include "mlir/Analysis/DataFlow/IntegerRangeAnalysis.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-namespace arith {
-#define GEN_PASS_DEF_ARITHMETICUNSIGNEDWHENEQUIVALENTPASS
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
-} // namespace arith
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::arith;
using namespace mlir::dataflow;
};
struct ArithmeticUnsignedWhenEquivalentPass
- : public arith::impl::ArithmeticUnsignedWhenEquivalentPassBase<
+ : public ArithmeticUnsignedWhenEquivalentBase<
ArithmeticUnsignedWhenEquivalentPass> {
/// Implementation structure: first find all equivalent ops and collect them,
/// then perform all the rewrites in a second pass over the target op. This
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Async/Passes.h"
+#include <utility>
#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Async/IR/Async.h"
+#include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/Async/Transforms.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Support/LLVM.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/RegionUtils.h"
-#include <utility>
-
-namespace mlir {
-#define GEN_PASS_DEF_ASYNCPARALLELFORPASS
-#include "mlir/Dialect/Async/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
using namespace mlir::async;
// }
//
struct AsyncParallelForPass
- : public impl::AsyncParallelForPassBase<AsyncParallelForPass> {
+ : public AsyncParallelForBase<AsyncParallelForPass> {
AsyncParallelForPass() = default;
AsyncParallelForPass(bool asyncDispatch, int32_t numWorkerThreads,
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Async/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Analysis/Liveness.h"
#include "mlir/Dialect/Async/IR/Async.h"
+#include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/SmallSet.h"
-namespace mlir {
-#define GEN_PASS_DEF_ASYNCRUNTIMEREFCOUNTINGPASS
-#define GEN_PASS_DEF_ASYNCRUNTIMEPOLICYBASEDREFCOUNTINGPASS
-#include "mlir/Dialect/Async/Passes.h.inc"
-} // namespace mlir
-
-#define DEBUG_TYPE "async-runtime-ref-counting"
-
using namespace mlir;
using namespace mlir::async;
+#define DEBUG_TYPE "async-runtime-ref-counting"
+
//===----------------------------------------------------------------------===//
// Utility functions shared by reference counting passes.
//===----------------------------------------------------------------------===//
namespace {
class AsyncRuntimeRefCountingPass
- : public impl::AsyncRuntimeRefCountingPassBase<
- AsyncRuntimeRefCountingPass> {
+ : public AsyncRuntimeRefCountingBase<AsyncRuntimeRefCountingPass> {
public:
AsyncRuntimeRefCountingPass() = default;
void runOnOperation() override;
namespace {
class AsyncRuntimePolicyBasedRefCountingPass
- : public impl::AsyncRuntimePolicyBasedRefCountingPassBase<
+ : public AsyncRuntimePolicyBasedRefCountingBase<
AsyncRuntimePolicyBasedRefCountingPass> {
public:
AsyncRuntimePolicyBasedRefCountingPass() { initializeDefaultPolicy(); }
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Async/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Async/IR/Async.h"
+#include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_ASYNCRUNTIMEREFCOUNTINGOPTPASS
-#include "mlir/Dialect/Async/Passes.h.inc"
-} // namespace mlir
-
-#define DEBUG_TYPE "async-ref-counting"
-
using namespace mlir;
using namespace mlir::async;
+#define DEBUG_TYPE "async-ref-counting"
+
namespace {
class AsyncRuntimeRefCountingOptPass
- : public impl::AsyncRuntimeRefCountingOptPassBase<
- AsyncRuntimeRefCountingOptPass> {
+ : public AsyncRuntimeRefCountingOptBase<AsyncRuntimeRefCountingOptPass> {
public:
AsyncRuntimeRefCountingOptPass() = default;
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Async/Passes.h"
-
#include "PassDetail.h"
#include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Async/IR/Async.h"
+#include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_ASYNCTOASYNCRUNTIMEPASS
-#include "mlir/Dialect/Async/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::async;
namespace {
class AsyncToAsyncRuntimePass
- : public impl::AsyncToAsyncRuntimePassBase<AsyncToAsyncRuntimePass> {
+ : public AsyncToAsyncRuntimeBase<AsyncToAsyncRuntimePass> {
public:
AsyncToAsyncRuntimePass() = default;
void runOnOperation() override;
class SCFDialect;
} // namespace scf
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Async/Passes.h.inc"
+
// -------------------------------------------------------------------------- //
// Utility functions shared by Async Transformations.
// -------------------------------------------------------------------------- //
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/AllocTensorElimination.h"
#include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/Dominance.h"
#include "mlir/Pass/Pass.h"
-namespace mlir {
-namespace bufferization {
-#define GEN_PASS_DEF_ALLOCTENSORELIMINATIONPASS
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-} // namespace bufferization
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::bufferization;
namespace {
struct AllocTensorElimination
- : public bufferization::impl::AllocTensorEliminationPassBase<
- AllocTensorElimination> {
+ : public AllocTensorEliminationBase<AllocTensorElimination> {
AllocTensorElimination() = default;
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/AllocationOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "llvm/ADT/SetOperations.h"
-namespace mlir {
-namespace bufferization {
-#define GEN_PASS_DEF_BUFFERDEALLOCATIONPASS
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-} // namespace bufferization
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::bufferization;
/// The actual buffer deallocation pass that inserts and moves dealloc nodes
/// into the right positions. Furthermore, it inserts additional clones if
/// necessary. It uses the algorithm described at the top of the file.
-struct BufferDeallocationPass
- : bufferization::impl::BufferDeallocationPassBase<BufferDeallocationPass> {
+struct BufferDeallocationPass : BufferDeallocationBase<BufferDeallocationPass> {
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<bufferization::BufferizationDialect>();
registry.insert<memref::MemRefDialect>();
// allocations and copies during buffer deallocation. The third pass tries to
// convert heap-based allocations to stack-based allocations, if possible.
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Operation.h"
#include "mlir/Interfaces/LoopLikeInterface.h"
#include "mlir/Pass/Pass.h"
-namespace mlir {
-namespace bufferization {
-#define GEN_PASS_DEF_BUFFERHOISTINGPASS
-#define GEN_PASS_DEF_BUFFERLOOPHOISTINGPASS
-#define GEN_PASS_DEF_PROMOTEBUFFERSTOSTACKPASS
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-} // namespace bufferization
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::bufferization;
/// The buffer hoisting pass that hoists allocation nodes into dominating
/// blocks.
-struct BufferHoistingPass
- : bufferization::impl::BufferHoistingPassBase<BufferHoistingPass> {
+struct BufferHoistingPass : BufferHoistingBase<BufferHoistingPass> {
void runOnOperation() override {
// Hoist all allocations into dominator blocks.
};
/// The buffer loop hoisting pass that hoists allocation nodes out of loops.
-struct BufferLoopHoistingPass
- : bufferization::impl::BufferLoopHoistingPassBase<BufferLoopHoistingPass> {
+struct BufferLoopHoistingPass : BufferLoopHoistingBase<BufferLoopHoistingPass> {
void runOnOperation() override {
// Hoist all allocations out of loops.
/// The promote buffer to stack pass that tries to convert alloc nodes into
/// alloca nodes.
class PromoteBuffersToStackPass
- : public bufferization::impl::PromoteBuffersToStackPassBase<
- PromoteBuffersToStackPass> {
+ : public PromoteBuffersToStackBase<PromoteBuffersToStackPass> {
public:
PromoteBuffersToStackPass(unsigned maxAllocSizeInBytes,
unsigned maxRankOfAllocatedMemRef) {
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
-
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Operation.h"
#include "mlir/Pass/Pass.h"
-namespace mlir {
-namespace bufferization {
-#define GEN_PASS_DEF_BUFFERRESULTSTOOUTPARAMSPASS
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-} // namespace bufferization
-} // namespace mlir
-
using namespace mlir;
/// Return `true` if the given MemRef type has a fully dynamic layout.
namespace {
struct BufferResultsToOutParamsPass
- : bufferization::impl::BufferResultsToOutParamsPassBase<
- BufferResultsToOutParamsPass> {
+ : BufferResultsToOutParamsBase<BufferResultsToOutParamsPass> {
void runOnOperation() override {
if (failed(bufferization::promoteBufferResultsToOutParams(getOperation())))
return signalPassFailure();
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
#include "mlir/Dialect/Bufferization/Transforms/OneShotModuleBufferize.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
#include "mlir/Dialect/Bufferization/Transforms/TensorCopyInsertion.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/Passes.h"
-namespace mlir {
-namespace bufferization {
-#define GEN_PASS_DEF_FINALIZINGBUFFERIZEPASS
-#define GEN_PASS_DEF_BUFFERIZATIONBUFFERIZEPASS
-#define GEN_PASS_DEF_ONESHOTBUFFERIZEPASS
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-} // namespace bufferization
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::bufferization;
namespace {
struct FinalizingBufferizePass
- : public bufferization::impl::FinalizingBufferizePassBase<
- FinalizingBufferizePass> {
- using FinalizingBufferizePassBase::FinalizingBufferizePassBase;
+ : public FinalizingBufferizeBase<FinalizingBufferizePass> {
+ using FinalizingBufferizeBase<
+ FinalizingBufferizePass>::FinalizingBufferizeBase;
void runOnOperation() override {
auto func = getOperation();
}
struct OneShotBufferizePass
- : public bufferization::impl::OneShotBufferizePassBase<
- OneShotBufferizePass> {
+ : public OneShotBufferizeBase<OneShotBufferizePass> {
OneShotBufferizePass() {}
explicit OneShotBufferizePass(const OneShotBufferizationOptions &options)
namespace {
struct BufferizationBufferizePass
- : public bufferization::impl::BufferizationBufferizePassBase<
- BufferizationBufferizePass> {
+ : public BufferizationBufferizeBase<BufferizationBufferizePass> {
void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<BufferizationDialect>();
// function argument, it is also considered equivalent. A cast is inserted at
// the call site in that case.
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
-
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/Operation.h"
#include "mlir/Pass/Pass.h"
-namespace mlir {
-namespace bufferization {
-#define GEN_PASS_DEF_DROPEQUIVALENTBUFFERRESULTSPASS
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-} // namespace bufferization
-} // namespace mlir
-
using namespace mlir;
/// Return the unique ReturnOp that terminates `funcOp`.
namespace {
struct DropEquivalentBufferResultsPass
- : bufferization::impl::DropEquivalentBufferResultsPassBase<
- DropEquivalentBufferResultsPass> {
+ : DropEquivalentBufferResultsBase<DropEquivalentBufferResultsPass> {
void runOnOperation() override {
if (failed(bufferization::dropEquivalentBufferResults(getOperation())))
return signalPassFailure();
--- /dev/null
+//===- PassDetail.h - Bufferization Pass details ----------------*- 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 DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+namespace bufferization {
+class BufferizationDialect;
+} // namespace bufferization
+
+namespace func {
+class FuncDialect;
+} // namespace func
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+#include "mlir/Dialect/Bufferization/Transforms/TensorCopyInsertion.h"
+
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
#include "mlir/Dialect/Bufferization/Transforms/OneShotModuleBufferize.h"
-#include "mlir/Dialect/Bufferization/Transforms/TensorCopyInsertion.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-
-namespace mlir {
-namespace bufferization {
-#define GEN_PASS_DEF_TENSORCOPYINSERTIONPASS
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-} // namespace bufferization
-} // namespace mlir
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
using namespace mlir;
using namespace mlir::bufferization;
namespace {
struct TensorCopyInsertionPass
- : bufferization::impl::TensorCopyInsertionPassBase<
- TensorCopyInsertionPass> {
+ : TensorCopyInsertionBase<TensorCopyInsertionPass> {
TensorCopyInsertionPass() : options(llvm::None) {}
TensorCopyInsertionPass(const OneShotBufferizationOptions &options)
: options(options) {}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Func/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h"
+#include "mlir/Dialect/Func/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_FUNCBUFFERIZEPASS
-#include "mlir/Dialect/Func/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::func;
namespace {
-struct FuncBufferizePass
- : public impl::FuncBufferizePassBase<FuncBufferizePass> {
- using FuncBufferizePassBase::FuncBufferizePassBase;
-
+struct FuncBufferizePass : public FuncBufferizeBase<FuncBufferizePass> {
+ using FuncBufferizeBase<FuncBufferizePass>::FuncBufferizeBase;
void runOnOperation() override {
auto module = getOperation();
auto *context = &getContext();
--- /dev/null
+//===- PassDetail.h - Func Pass class details -------------------*- 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 DIALECT_FUNC_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_FUNC_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+class AtomicRMWOp;
+
+namespace bufferization {
+class BufferizationDialect;
+} // namespace bufferization
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Func/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_FUNC_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/GPU/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Async/IR/Async.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/GPU/Transforms/Utils.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h"
#include "mlir/Transforms/RegionUtils.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace mlir {
-#define GEN_PASS_DEF_GPUASYNCREGIONPASS
-#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
-
namespace {
-class GpuAsyncRegionPass
- : public impl::GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
+class GpuAsyncRegionPass : public GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
struct ThreadTokenCallback;
struct DeferWaitCallback;
struct SingleTokenUseCallback;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/GPU/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/AsmParser/AsmParser.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
#include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/GPU/Transforms/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/Support/LLVM.h"
#include "mlir/Transforms/RegionUtils.h"
-namespace mlir {
-#define GEN_PASS_DEF_GPULAUNCHSINKINDEXCOMPUTATIONSPASS
-#define GEN_PASS_DEF_GPUKERNELOUTLININGPASS
-#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
template <typename OpTy>
/// Pass that moves ops which are likely an index computation into gpu.launch
/// body.
class GpuLaunchSinkIndexComputationsPass
- : public impl::GpuLaunchSinkIndexComputationsPassBase<
+ : public GpuLaunchSinkIndexComputationsBase<
GpuLaunchSinkIndexComputationsPass> {
public:
void runOnOperation() override {
/// a separate pass. The external functions can then be annotated with the
/// symbol of the cubin accessor function.
class GpuKernelOutliningPass
- : public impl::GpuKernelOutliningPassBase<GpuKernelOutliningPass> {
+ : public GpuKernelOutliningBase<GpuKernelOutliningPass> {
public:
GpuKernelOutliningPass(StringRef dlStr) {
if (!dlStr.empty() && !dataLayoutStr.hasValue())
}
GpuKernelOutliningPass(const GpuKernelOutliningPass &other)
- : GpuKernelOutliningPassBase(other),
- dataLayoutSpec(other.dataLayoutSpec) {
+ : GpuKernelOutliningBase(other), dataLayoutSpec(other.dataLayoutSpec) {
dataLayoutStr = other.dataLayoutStr.getValue();
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/GPU/Transforms/Passes.h"
+#include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "PassDetail.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
-#include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/IR/AffineMap.h"
namespace mlir {
-#define GEN_PASS_DEF_GPUMAPPARALLELLOOPSPASS
-#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
-} // namespace mlir
-
-namespace mlir {
using scf::ParallelOp;
namespace {
struct GpuMapParallelLoopsPass
- : public impl::GpuMapParallelLoopsPassBase<GpuMapParallelLoopsPass> {
+ : public GpuMapParallelLoopsPassBase<GpuMapParallelLoopsPass> {
void runOnOperation() override {
for (Region ®ion : getOperation()->getRegions()) {
region.walk([](ParallelOp parallelOp) { mapParallelOp(parallelOp); });
--- /dev/null
+//===- PassDetail.h - GPU Pass class details --------------------*- 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 DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/Async/IR/Async.h"
+#include "mlir/Dialect/DLTI/DLTI.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/GPU/IR/GPUDialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/Block.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-namespace LLVM {
-#define GEN_PASS_DEF_LLVMLEGALIZEFOREXPORTPASS
-#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
-} // namespace LLVM
-} // namespace mlir
using namespace mlir;
}
namespace {
-struct LLVMLegalizeForExportPass
- : public LLVM::impl::LLVMLegalizeForExportPassBase<
- LLVMLegalizeForExportPass> {
- using LLVMLegalizeForExportPassBase::LLVMLegalizeForExportPassBase;
-
+struct LegalizeForExportPass
+ : public LLVMLegalizeForExportBase<LegalizeForExportPass> {
void runOnOperation() override {
LLVM::ensureDistinctSuccessors(getOperation());
}
} // namespace
std::unique_ptr<Pass> LLVM::createLegalizeForExportPass() {
- return std::make_unique<LLVMLegalizeForExportPass>();
+ return std::make_unique<LegalizeForExportPass>();
}
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/LLVMIR/Transforms/OptimizeForNVVM.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/LLVMIR/NVVMDialect.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/PatternMatch.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-namespace NVVM {
-#define GEN_PASS_DEF_NVVMOPTIMIZEFORTARGETPASS
-#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
-} // namespace NVVM
-} // namespace mlir
-
using namespace mlir;
namespace {
PatternRewriter &rewriter) const override;
};
-struct NVVMOptimizeForTargetPass
- : public NVVM::impl::NVVMOptimizeForTargetPassBase<
- NVVMOptimizeForTargetPass> {
- using NVVMOptimizeForTargetPassBase::NVVMOptimizeForTargetPassBase;
-
+struct NVVMOptimizeForTarget
+ : public NVVMOptimizeForTargetBase<NVVMOptimizeForTarget> {
void runOnOperation() override;
void getDependentDialects(DialectRegistry ®istry) const override {
return success();
}
-void NVVMOptimizeForTargetPass::runOnOperation() {
+void NVVMOptimizeForTarget::runOnOperation() {
MLIRContext *ctx = getOperation()->getContext();
RewritePatternSet patterns(ctx);
patterns.add<ExpandDivF16>(ctx);
}
std::unique_ptr<Pass> NVVM::createOptimizeForTargetPass() {
- return std::make_unique<NVVMOptimizeForTargetPass>();
+ return std::make_unique<NVVMOptimizeForTarget>();
}
--- /dev/null
+//===- PassDetail.h - LLVM Pass class details -------------------*- 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 DIALECT_LLVMIR_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_LLVMIR_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+namespace func {
+class FuncOp;
+} // namespace func
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_LLVMIR_TRANSFORMS_PASSDETAIL_H_
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/LLVMIR/Transforms/RequestCWrappers.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-namespace LLVM {
-#define GEN_PASS_DEF_LLVMREQUESTCWRAPPERSPASS
-#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
-} // namespace LLVM
-} // namespace mlir
using namespace mlir;
namespace {
-struct LLVMRequestCWrappersPass
- : public LLVM::impl::LLVMRequestCWrappersPassBase<
- LLVMRequestCWrappersPass> {
- using LLVMRequestCWrappersPassBase::LLVMRequestCWrappersPassBase;
-
+class RequestCWrappersPass
+ : public LLVMRequestCWrappersBase<RequestCWrappersPass> {
+public:
void runOnOperation() override {
getOperation()->setAttr(LLVM::LLVMDialect::getEmitCWrapperAttrName(),
UnitAttr::get(&getContext()));
} // namespace
std::unique_ptr<Pass> mlir::LLVM::createRequestCWrappersPass() {
- return std::make_unique<LLVMRequestCWrappersPass>();
+ return std::make_unique<RequestCWrappersPass>();
}
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
+#include "PassDetail.h"
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/Operation.h"
#include "mlir/Pass/Pass.h"
-namespace mlir {
-#define GEN_PASS_DEF_LINALGBUFFERIZEPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace bufferization;
namespace {
/// Converts Linalg operations that work on tensor-type operands or results to
/// work on buffers.
-struct LinalgBufferizePass
- : public impl::LinalgBufferizePassBase<LinalgBufferizePass> {
+struct LinalgBufferizePass : public LinalgBufferizeBase<LinalgBufferizePass> {
void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<linalg::LinalgDialect>();
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/OpDefinition.h"
#include "mlir/Transforms/DialectConversion.h"
#include <memory>
#include <utility>
-namespace mlir {
-#define GEN_PASS_DEF_LINALGDETENSORIZEPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::linalg;
};
/// @see LinalgDetensorize in Linalg/Passes.td for more details.
-struct LinalgDetensorize
- : public impl::LinalgDetensorizePassBase<LinalgDetensorize> {
+struct LinalgDetensorize : public LinalgDetensorizeBase<LinalgDetensorize> {
LinalgDetensorize() = default;
class CostModel {
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
-
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_LINALGFOLDUNITEXTENTDIMSPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "linalg-drop-unit-dims"
using namespace mlir;
namespace {
/// Pass that removes unit-extent dims within generic ops.
struct LinalgFoldUnitExtentDimsPass
- : public impl::LinalgFoldUnitExtentDimsPassBase<
- LinalgFoldUnitExtentDimsPass> {
+ : public LinalgFoldUnitExtentDimsBase<LinalgFoldUnitExtentDimsPass> {
void runOnOperation() override {
Operation *op = getOperation();
MLIRContext *context = op->getContext();
// This file implements the linalg dialect Fusion on tensors operations pass.
//
//===----------------------------------------------------------------------===//
+#include <utility>
-#include "mlir/Dialect/Linalg/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Support/LLVM.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-#include <utility>
-
-namespace mlir {
-#define GEN_PASS_DEF_LINALGFOLDUNITEXTENTDIMSPASS
-#define GEN_PASS_DEF_LINALGELEMENTWISEOPFUSIONPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
using namespace mlir::linalg;
// favor of test passes that check the functionality of each of the patterns
// added here individually.
struct LinalgElementwiseOpFusionPass
- : public impl::LinalgElementwiseOpFusionPassBase<
- LinalgElementwiseOpFusionPass> {
+ : public LinalgElementwiseOpFusionBase<LinalgElementwiseOpFusionPass> {
void runOnOperation() override {
Operation *op = getOperation();
MLIRContext *context = op->getContext();
#include "mlir/Dialect/Linalg/Passes.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONVERTELEMENTWISETOLINALGPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
static bool isElementwiseMappableOpOnRankedTensors(Operation *op) {
namespace {
class ConvertElementwiseToLinalgPass
- : public impl::ConvertElementwiseToLinalgPassBase<
- ConvertElementwiseToLinalgPass> {
+ : public ConvertElementwiseToLinalgBase<ConvertElementwiseToLinalgPass> {
void runOnOperation() final {
auto *func = getOperation();
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/Attributes.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_LINALGGENERALIZATIONPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "linalg-generalization"
using namespace mlir;
namespace {
struct LinalgGeneralizationPass
- : public impl::LinalgGeneralizationPassBase<LinalgGeneralizationPass> {
+ : public LinalgGeneralizationBase<LinalgGeneralizationPass> {
void runOnOperation() override;
};
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_LINALGINITTENSORTOALLOCTENSORPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::bufferization;
using namespace mlir::linalg;
};
struct LinalgInitTensorToAllocTensor
- : public impl::LinalgInitTensorToAllocTensorPassBase<
- LinalgInitTensorToAllocTensor> {
+ : public LinalgInitTensorToAllocTensorBase<LinalgInitTensorToAllocTensor> {
LinalgInitTensorToAllocTensor() = default;
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/IR/AffineExpr.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_LINALGINLINESCALAROPERANDSPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::linalg;
namespace {
/// Pass that removes unit-extent dims within generic ops.
struct LinalgInlineScalarOperandsPass
- : public impl::LinalgInlineScalarOperandsPassBase<
- LinalgInlineScalarOperandsPass> {
+ : public LinalgInlineScalarOperandsBase<LinalgInlineScalarOperandsPass> {
void runOnOperation() override {
func::FuncOp funcOp = getOperation();
MLIRContext *context = funcOp.getContext();
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
+#include <utility>
+#include "PassDetail.h"
#include "mlir/Analysis/SliceAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
#include "mlir/Dialect/Affine/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Transforms/LoopInvariantCodeMotionUtils.h"
#include "mlir/Transforms/Passes.h"
-#include <utility>
-
-namespace mlir {
-#define GEN_PASS_DEF_LINALGSTRATEGYTILEANDFUSEPASS
-#define GEN_PASS_DEF_LINALGSTRATEGYTILEPASS
-#define GEN_PASS_DEF_LINALGSTRATEGYPADPASS
-#define GEN_PASS_DEF_LINALGSTRATEGYDECOMPOSEPASS
-#define GEN_PASS_DEF_LINALGSTRATEGYPEELPASS
-#define GEN_PASS_DEF_LINALGSTRATEGYVECTORIZEPASS
-#define GEN_PASS_DEF_LINALGSTRATEGYENABLEPASS
-#define GEN_PASS_DEF_LINALGSTRATEGYLOWERVECTORSPASS
-#define GEN_PASS_DEF_LINALGSTRATEGYREMOVEMARKERSPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
using namespace mlir;
using namespace mlir::vector;
/// Configurable pass to apply pattern-based tiling and fusion.
struct LinalgStrategyTileAndFusePass
- : public impl::LinalgStrategyTileAndFusePassBase<
- LinalgStrategyTileAndFusePass> {
+ : public LinalgStrategyTileAndFusePassBase<LinalgStrategyTileAndFusePass> {
LinalgStrategyTileAndFusePass() = default;
/// Configurable pass to apply pattern-based linalg tiling.
struct LinalgStrategyTilePass
- : public impl::LinalgStrategyTilePassBase<LinalgStrategyTilePass> {
+ : public LinalgStrategyTilePassBase<LinalgStrategyTilePass> {
LinalgStrategyTilePass() = default;
/// Configurable pass to apply hoisting and padding.
struct LinalgStrategyPadPass
- : public impl::LinalgStrategyPadPassBase<LinalgStrategyPadPass> {
+ : public LinalgStrategyPadPassBase<LinalgStrategyPadPass> {
LinalgStrategyPadPass() = default;
LinalgTransformationFilter filter;
};
+
/// Configurable pass to apply lowering of coarser-grained named linalg ops into
/// finer-grained named versions.
struct LinalgStrategyDecomposePass
- : public impl::LinalgStrategyDecomposePassBase<
- LinalgStrategyDecomposePass> {
+ : public LinalgStrategyDecomposePassBase<LinalgStrategyDecomposePass> {
LinalgStrategyDecomposePass() = default;
/// Configurable pass to apply pattern-based linalg peeling.
struct LinalgStrategyPeelPass
- : public impl::LinalgStrategyPeelPassBase<LinalgStrategyPeelPass> {
+ : public LinalgStrategyPeelPassBase<LinalgStrategyPeelPass> {
LinalgStrategyPeelPass() = default;
/// Configurable pass to apply pattern-based linalg vectorization.
struct LinalgStrategyVectorizePass
- : public impl::LinalgStrategyVectorizePassBase<
- LinalgStrategyVectorizePass> {
+ : public LinalgStrategyVectorizePassBase<LinalgStrategyVectorizePass> {
LinalgStrategyVectorizePass() = default;
/// Configurable pass to enable the application of other pattern-based linalg
/// passes.
struct LinalgStrategyEnablePass
- : public impl::LinalgStrategyEnablePassBase<LinalgStrategyEnablePass> {
+ : public LinalgStrategyEnablePassBase<LinalgStrategyEnablePass> {
LinalgStrategyEnablePass(LinalgEnablingOptions opt,
LinalgTransformationFilter filt)
/// Configurable pass to lower vector operations.
struct LinalgStrategyLowerVectorsPass
- : public impl::LinalgStrategyLowerVectorsPassBase<
+ : public LinalgStrategyLowerVectorsPassBase<
LinalgStrategyLowerVectorsPass> {
LinalgStrategyLowerVectorsPass(LinalgVectorLoweringOptions opt,
/// Configurable pass to lower vector operations.
struct LinalgStrategyRemoveMarkersPass
- : public impl::LinalgStrategyRemoveMarkersPassBase<
+ : public LinalgStrategyRemoveMarkersPassBase<
LinalgStrategyRemoveMarkersPass> {
void runOnOperation() override {
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
-
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace mlir {
-#define GEN_PASS_DEF_LINALGLOWERTOAFFINELOOPSPASS
-#define GEN_PASS_DEF_LINALGLOWERTOLOOPSPASS
-#define GEN_PASS_DEF_LINALGLOWERTOPARALLELLOOPSPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::linalg;
}
struct LowerToAffineLoops
- : public impl::LinalgLowerToAffineLoopsPassBase<LowerToAffineLoops> {
+ : public LinalgLowerToAffineLoopsBase<LowerToAffineLoops> {
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<memref::MemRefDialect>();
}
}
};
-struct LowerToLoops : public impl::LinalgLowerToLoopsPassBase<LowerToLoops> {
+struct LowerToLoops : public LinalgLowerToLoopsBase<LowerToLoops> {
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<memref::MemRefDialect, scf::SCFDialect>();
}
};
struct LowerToParallelLoops
- : public impl::LinalgLowerToParallelLoopsPassBase<LowerToParallelLoops> {
+ : public LinalgLowerToParallelLoopsBase<LowerToParallelLoops> {
void runOnOperation() override {
lowerLinalgToLoopsImpl<scf::ParallelOp>(getOperation());
}
// canonicalizations of named ops.
//
//===----------------------------------------------------------------------===//
-
-#include "mlir/Dialect/Linalg/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-#include "llvm/ADT/SmallVector.h"
-namespace mlir {
-#define GEN_PASS_DEF_LINALGNAMEDOPCONVERSIONPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
+#include "llvm/ADT/SmallVector.h"
using namespace mlir;
using namespace mlir::linalg;
};
struct LinalgNamedOpConversionPass
- : public impl::LinalgNamedOpConversionPassBase<
- LinalgNamedOpConversionPass> {
+ : public LinalgNamedOpConversionBase<LinalgNamedOpConversionPass> {
LinalgNamedOpConversionPass() = default;
LinalgNamedOpConversionPass(const LinalgNamedOpConversionPass &) = default;
--- /dev/null
+//===- PassDetail.h - Linalg Pass class details -----------------*- 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 DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+namespace arith {
+class ArithmeticDialect;
+} // namespace arith
+
+namespace bufferization {
+class BufferizationDialect;
+} // namespace bufferization
+
+namespace linalg {
+class LinalgDialect;
+} // namespace linalg
+
+namespace scf {
+class SCFDialect;
+} // namespace scf
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+namespace tensor {
+class TensorDialect;
+} // namespace tensor
+
+namespace vector {
+class VectorDialect;
+} // namespace vector
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Complex/IR/Complex.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Linalg/Passes.h"
+#include <utility>
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/Utils/Utils.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Linalg/Transforms/Transforms.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/Transforms/FoldUtils.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-#include "llvm/Support/CommandLine.h"
-#include <utility>
-namespace mlir {
-#define GEN_PASS_DEF_LINALGTILINGPASS
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-} // namespace mlir
-
-#define DEBUG_TYPE "linalg-tiling"
+#include "llvm/Support/CommandLine.h"
using namespace mlir;
using namespace mlir::linalg;
using namespace mlir::scf;
+#define DEBUG_TYPE "linalg-tiling"
+
static bool isZero(OpFoldResult v) {
if (!v)
return false;
}
namespace {
-struct LinalgTilingPass : public impl::LinalgTilingPassBase<LinalgTilingPass> {
+struct LinalgTilingPass : public LinalgTilingBase<LinalgTilingPass> {
LinalgTilingPass() = default;
LinalgTilingPass(ArrayRef<int64_t> tileSizes, LinalgTilingLoopType loopType) {
this->tileSizes = tileSizes;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/MemRef/Transforms/Passes.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/IR/TypeUtilities.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-namespace memref {
-#define GEN_PASS_DEF_EXPANDOPSPASS
-#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
-} // namespace memref
-} // namespace mlir
-
using namespace mlir;
namespace {
}
};
-struct ExpandOpsPass : public memref::impl::ExpandOpsPassBase<ExpandOpsPass> {
+struct ExpandOpsPass : public ExpandOpsBase<ExpandOpsPass> {
void runOnOperation() override {
MLIRContext &ctx = getContext();
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/MemRef/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/Utils/IndexingUtils.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/IR/BuiltinTypes.h"
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace mlir {
-namespace memref {
-#define GEN_PASS_DEF_FOLDMEMREFALIASOPSPASS
-#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
-} // namespace memref
-} // namespace mlir
-
using namespace mlir;
//===----------------------------------------------------------------------===//
namespace {
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+
struct FoldMemRefAliasOpsPass final
- : public memref::impl::FoldMemRefAliasOpsPassBase<FoldMemRefAliasOpsPass> {
+ : public FoldMemRefAliasOpsBase<FoldMemRefAliasOpsPass> {
void runOnOperation() override;
};
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-namespace memref {
-#define GEN_PASS_DEF_NORMALIZEMEMREFSPASS
-#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
-} // namespace memref
-} // namespace mlir
-
#define DEBUG_TYPE "normalize-memrefs"
using namespace mlir;
/// such functions as normalizable. Also, if a normalizable function is known
/// to call a non-normalizable function, we treat that function as
/// non-normalizable as well. We assume external functions to be normalizable.
-struct NormalizeMemRefs
- : public memref::impl::NormalizeMemRefsPassBase<NormalizeMemRefs> {
+struct NormalizeMemRefs : public NormalizeMemRefsBase<NormalizeMemRefs> {
void runOnOperation() override;
void normalizeFuncOpMemRefs(func::FuncOp funcOp, ModuleOp moduleOp);
bool areMemRefsNormalizable(func::FuncOp funcOp);
--- /dev/null
+//===- PassDetail.h - MemRef Pass class details -----------------*- 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 DIALECT_MEMREF_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_MEMREF_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/DialectRegistry.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+class AffineDialect;
+
+// Forward declaration from Dialect.h
+template <typename ConcreteDialect>
+void registerDialect(DialectRegistry ®istry);
+
+namespace arith {
+class ArithmeticDialect;
+} // namespace arith
+
+namespace func {
+class FuncDialect;
+} // namespace func
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+namespace tensor {
+class TensorDialect;
+} // namespace tensor
+
+namespace vector {
+class VectorDialect;
+} // namespace vector
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_MEMREF_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/MemRef/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Interfaces/InferTypeOpInterface.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-namespace memref {
-#define GEN_PASS_DEF_RESOLVERANKEDSHAPETYPERESULTDIMSPASS
-#define GEN_PASS_DEF_RESOLVESHAPEDTYPERESULTDIMSPASS
-#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
-} // namespace memref
-} // namespace mlir
-
using namespace mlir;
namespace {
namespace {
struct ResolveRankedShapeTypeResultDimsPass final
- : public memref::impl::ResolveRankedShapeTypeResultDimsPassBase<
+ : public ResolveRankedShapeTypeResultDimsBase<
ResolveRankedShapeTypeResultDimsPass> {
void runOnOperation() override;
};
struct ResolveShapedTypeResultDimsPass final
- : public memref::impl::ResolveShapedTypeResultDimsPassBase<
- ResolveShapedTypeResultDimsPass> {
+ : public ResolveShapedTypeResultDimsBase<ResolveShapedTypeResultDimsPass> {
void runOnOperation() override;
};
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
// This file implements transforms to optimize accesses to shared memory.
//
//===----------------------------------------------------------------------===//
-
-#include "mlir/Dialect/NVGPU/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
+#include "mlir/Dialect/NVGPU/Passes.h"
#include "mlir/Dialect/NVGPU/Transforms/Transforms.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/MathExtras.h"
-namespace mlir {
-namespace nvgpu {
-#define GEN_PASS_DEF_OPTIMIZESHAREDMEMORYPASS
-#include "mlir/Dialect/NVGPU/Passes.h.inc"
-} // namespace nvgpu
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::nvgpu;
namespace {
class OptimizeSharedMemoryPass
- : public nvgpu::impl::OptimizeSharedMemoryPassBase<
- OptimizeSharedMemoryPass> {
+ : public OptimizeSharedMemoryBase<OptimizeSharedMemoryPass> {
public:
- using OptimizeSharedMemoryPassBase::OptimizeSharedMemoryPassBase;
+ OptimizeSharedMemoryPass() = default;
void runOnOperation() override {
Operation *op = getOperation();
--- /dev/null
+//===- PassDetail.h - NVGPU Pass class details -----------------*- 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 DIALECT_NVGPU_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_NVGPU_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+namespace arith {
+class ArithmeticDialect;
+} // namespace arith
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+namespace vector {
+class VectorDialect;
+} // namespace vector
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/NVGPU/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_NVGPU_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
-
-#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
+#include "PassDetail.h"
+#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_SCFBUFFERIZEPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::scf;
namespace {
-struct SCFBufferizePass : public impl::SCFBufferizePassBase<SCFBufferizePass> {
- using SCFBufferizePassBase::SCFBufferizePassBase;
-
+struct SCFBufferizePass : public SCFBufferizeBase<SCFBufferizePass> {
void runOnOperation() override {
auto func = getOperation();
auto *context = &getContext();
};
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createSCFBufferizePass() {
+ return std::make_unique<SCFBufferizePass>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_SCFFORTOWHILELOOPPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace llvm;
using namespace mlir;
using scf::ForOp;
}
};
-struct SCFForToWhileLoopPass
- : public impl::SCFForToWhileLoopPassBase<SCFForToWhileLoopPass> {
- using SCFForToWhileLoopPassBase::SCFForToWhileLoopPassBase;
-
+struct ForToWhileLoop : public SCFForToWhileLoopBase<ForToWhileLoop> {
void runOnOperation() override {
auto *parentOp = getOperation();
MLIRContext *ctx = parentOp->getContext();
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createForToWhileLoopPass() {
+ return std::make_unique<ForToWhileLoop>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/TypeSwitch.h"
-namespace mlir {
-#define GEN_PASS_DEF_SCFFORLOOPCANONICALIZATIONPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::scf;
}
};
-struct SCFForLoopCanonicalizationPass
- : public impl::SCFForLoopCanonicalizationPassBase<
- SCFForLoopCanonicalizationPass> {
- using SCFForLoopCanonicalizationPassBase::SCFForLoopCanonicalizationPassBase;
-
+struct SCFForLoopCanonicalization
+ : public SCFForLoopCanonicalizationBase<SCFForLoopCanonicalization> {
void runOnOperation() override {
auto *parentOp = getOperation();
MLIRContext *ctx = parentOp->getContext();
DimOfLoopResultFolder<tensor::DimOp>,
DimOfLoopResultFolder<memref::DimOp>>(ctx);
}
+
+std::unique_ptr<Pass> mlir::createSCFForLoopCanonicalizationPass() {
+ return std::make_unique<SCFForLoopCanonicalization>();
+}
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Patterns.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Support/MathExtras.h"
-#include "llvm/ADT/MapVector.h"
using namespace mlir;
using namespace mlir::scf;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/IR/BlockAndValueMapping.h"
-namespace mlir {
-#define GEN_PASS_DEF_SCFFORLOOPRANGEFOLDINGPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::scf;
namespace {
-struct SCFForLoopRangeFoldingPass
- : public impl::SCFForLoopRangeFoldingPassBase<SCFForLoopRangeFoldingPass> {
- using SCFForLoopRangeFoldingPassBase::SCFForLoopRangeFoldingPassBase;
-
+struct ForLoopRangeFolding
+ : public SCFForLoopRangeFoldingBase<ForLoopRangeFolding> {
void runOnOperation() override;
};
} // namespace
-void SCFForLoopRangeFoldingPass::runOnOperation() {
+void ForLoopRangeFolding::runOnOperation() {
getOperation()->walk([&](ForOp op) {
Value indVar = op.getInductionVar();
}
});
}
+
+std::unique_ptr<Pass> mlir::createForLoopRangeFoldingPass() {
+ return std::make_unique<ForLoopRangeFolding>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
#include "mlir/Dialect/Utils/StaticValueUtils.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/ADT/DenseMap.h"
-namespace mlir {
-#define GEN_PASS_DEF_SCFFORLOOPPEELINGPASS
-#define GEN_PASS_DEF_SCFFORLOOPSPECIALIZATIONPASS
-#define GEN_PASS_DEF_SCFPARALLELLOOPSPECIALIZATIONPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using scf::ForOp;
using scf::ParallelOp;
} // namespace
namespace {
-struct SCFParallelLoopSpecializationPass
- : public impl::SCFParallelLoopSpecializationPassBase<
- SCFParallelLoopSpecializationPass> {
- using SCFParallelLoopSpecializationPassBase::
- SCFParallelLoopSpecializationPassBase;
-
+struct ParallelLoopSpecialization
+ : public SCFParallelLoopSpecializationBase<ParallelLoopSpecialization> {
void runOnOperation() override {
getOperation()->walk(
[](ParallelOp op) { specializeParallelLoopForUnrolling(op); });
}
};
-struct SCFForLoopSpecializationPass
- : public impl::SCFForLoopSpecializationPassBase<
- SCFForLoopSpecializationPass> {
- using SCFForLoopSpecializationPassBase::SCFForLoopSpecializationPassBase;
-
+struct ForLoopSpecialization
+ : public SCFForLoopSpecializationBase<ForLoopSpecialization> {
void runOnOperation() override {
getOperation()->walk([](ForOp op) { specializeForLoopForUnrolling(op); });
}
};
-struct SCFForLoopPeelingPass
- : public impl::SCFForLoopPeelingPassBase<SCFForLoopPeelingPass> {
- using SCFForLoopPeelingPassBase::SCFForLoopPeelingPassBase;
-
+struct ForLoopPeeling : public SCFForLoopPeelingBase<ForLoopPeeling> {
void runOnOperation() override {
auto *parentOp = getOperation();
MLIRContext *ctx = parentOp->getContext();
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createParallelLoopSpecializationPass() {
+ return std::make_unique<ParallelLoopSpecialization>();
+}
+
+std::unique_ptr<Pass> mlir::createForLoopSpecializationPass() {
+ return std::make_unique<ForLoopSpecialization>();
+}
+
+std::unique_ptr<Pass> mlir::createForLoopPeelingPass() {
+ return std::make_unique<ForLoopPeeling>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
#include "mlir/Transforms/RegionUtils.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_SCFPARALLELLOOPCOLLAPSINGPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "parallel-loop-collapsing"
using namespace mlir;
namespace {
-struct SCFParallelLoopCollapsingPass
- : public impl::SCFParallelLoopCollapsingPassBase<
- SCFParallelLoopCollapsingPass> {
- using SCFParallelLoopCollapsingPassBase::SCFParallelLoopCollapsingPassBase;
-
+struct ParallelLoopCollapsing
+ : public SCFParallelLoopCollapsingBase<ParallelLoopCollapsing> {
void runOnOperation() override {
Operation *module = getOperation();
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createParallelLoopCollapsingPass() {
+ return std::make_unique<ParallelLoopCollapsing>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/OpDefinition.h"
-namespace mlir {
-#define GEN_PASS_DEF_SCFPARALLELLOOPFUSIONPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::scf;
}
namespace {
-struct SCFParallelLoopFusionPass
- : public impl::SCFParallelLoopFusionPassBase<SCFParallelLoopFusionPass> {
- using SCFParallelLoopFusionPassBase::SCFParallelLoopFusionPassBase;
-
+struct ParallelLoopFusion
+ : public SCFParallelLoopFusionBase<ParallelLoopFusion> {
void runOnOperation() override {
getOperation()->walk([&](Operation *child) {
for (Region ®ion : child->getRegions())
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createParallelLoopFusionPass() {
+ return std::make_unique<ParallelLoopFusion>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
#include "mlir/Dialect/SCF/Utils/Utils.h"
-namespace mlir {
-#define GEN_PASS_DEF_SCFPARALLELLOOPTILINGPASS
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::scf;
}
namespace {
-struct SCFParallelLoopTilingPass
- : public impl::SCFParallelLoopTilingPassBase<SCFParallelLoopTilingPass> {
- using SCFParallelLoopTilingPassBase::SCFParallelLoopTilingPassBase;
+struct ParallelLoopTiling
+ : public SCFParallelLoopTilingBase<ParallelLoopTiling> {
+ ParallelLoopTiling() = default;
+ explicit ParallelLoopTiling(ArrayRef<int64_t> tileSizes,
+ bool noMinMaxBounds = false) {
+ this->tileSizes = tileSizes;
+ this->noMinMaxBounds = noMinMaxBounds;
+ }
void runOnOperation() override {
auto *parentOp = getOperation();
}
};
} // namespace
+
+std::unique_ptr<Pass>
+mlir::createParallelLoopTilingPass(ArrayRef<int64_t> tileSizes,
+ bool noMinMaxBounds) {
+ return std::make_unique<ParallelLoopTiling>(tileSizes, noMinMaxBounds);
+}
--- /dev/null
+//===- PassDetail.h - Loop Pass class details -------------------*- 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 DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+// Forward declaration from Dialect.h
+template <typename ConcreteDialect>
+void registerDialect(DialectRegistry ®istry);
+
+class AffineDialect;
+
+namespace arith {
+class ArithmeticDialect;
+} // namespace arith
+
+namespace bufferization {
+class BufferizationDialect;
+} // namespace bufferization
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+namespace tensor {
+class TensorDialect;
+} // namespace tensor
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
+#include "PassDetail.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Passes.h"
#include "mlir/Dialect/SCF/Transforms/Transforms.h"
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVGLCanonicalization.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-namespace spirv {
-#define GEN_PASS_DEF_SPIRVCANONICALIZEGLPASS
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
-} // namespace spirv
-} // namespace mlir
-
using namespace mlir;
namespace {
-class SPIRVCanonicalizeGLPass final
- : public spirv::impl::SPIRVCanonicalizeGLPassBase<SPIRVCanonicalizeGLPass> {
+class CanonicalizeGLPass final
+ : public SPIRVCanonicalizeGLBase<CanonicalizeGLPass> {
public:
- using SPIRVCanonicalizeGLPassBase::SPIRVCanonicalizeGLPassBase;
-
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
spirv::populateSPIRVGLCanonicalizationPatterns(patterns);
} // namespace
std::unique_ptr<OperationPass<>> spirv::createCanonicalizeGLPass() {
- return std::make_unique<SPIRVCanonicalizeGLPass>();
+ return std::make_unique<CanonicalizeGLPass>();
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/Transforms/DialectConversion.h"
using namespace mlir;
-namespace mlir {
-namespace spirv {
-#define GEN_PASS_DEF_SPIRVDECORATECOMPOSITETYPELAYOUTPASS
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
-} // namespace spirv
-} // namespace mlir
-
namespace {
class SPIRVGlobalVariableOpLayoutInfoDecoration
: public OpRewritePattern<spirv::GlobalVariableOp> {
}
namespace {
-class SPIRVDecorateCompositeTypeLayoutPass
- : public spirv::impl::SPIRVDecorateCompositeTypeLayoutPassBase<
- SPIRVDecorateCompositeTypeLayoutPass> {
- using SPIRVDecorateCompositeTypeLayoutPassBase::
- SPIRVDecorateCompositeTypeLayoutPassBase;
-
+class DecorateSPIRVCompositeTypeLayoutPass
+ : public SPIRVCompositeTypeLayoutBase<
+ DecorateSPIRVCompositeTypeLayoutPass> {
void runOnOperation() override;
};
} // namespace
-void SPIRVDecorateCompositeTypeLayoutPass::runOnOperation() {
+void DecorateSPIRVCompositeTypeLayoutPass::runOnOperation() {
auto module = getOperation();
RewritePatternSet patterns(module.getContext());
populateSPIRVLayoutInfoPatterns(patterns);
std::unique_ptr<OperationPass<ModuleOp>>
mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass() {
- return std::make_unique<SPIRVDecorateCompositeTypeLayoutPass>();
+ return std::make_unique<DecorateSPIRVCompositeTypeLayoutPass>();
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/SetVector.h"
-namespace mlir {
-namespace spirv {
-#define GEN_PASS_DEF_SPIRVLOWERABIATTRIBUTESPASS
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
-} // namespace spirv
-} // namespace mlir
-
using namespace mlir;
/// Creates a global variable for an argument based on the ABI info.
};
/// Pass to implement the ABI information specified as attributes.
-class SPIRVLowerABIAttributesPass final
- : public spirv::impl::SPIRVLowerABIAttributesPassBase<
- SPIRVLowerABIAttributesPass> {
- using SPIRVLowerABIAttributesPassBase::SPIRVLowerABIAttributesPassBase;
-
+class LowerABIAttributesPass final
+ : public SPIRVLowerABIAttributesBase<LowerABIAttributesPass> {
void runOnOperation() override;
};
} // namespace
return success();
}
-void SPIRVLowerABIAttributesPass::runOnOperation() {
+void LowerABIAttributesPass::runOnOperation() {
// Uses the signature conversion methodology of the dialect conversion
// framework to implement the conversion.
spirv::ModuleOp module = getOperation();
std::unique_ptr<OperationPass<spirv::ModuleOp>>
mlir::spirv::createLowerABIAttributesPass() {
- return std::make_unique<SPIRVLowerABIAttributesPass>();
+ return std::make_unique<LowerABIAttributesPass>();
}
--- /dev/null
+//===- PassDetail.h - SPIRV Pass class details ------------------*- 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 DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+namespace spirv {
+class ModuleOp;
+} // namespace spirv
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
-namespace mlir {
-namespace spirv {
-#define GEN_PASS_DEF_SPIRVREWRITEINSERTSPASS
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
-} // namespace spirv
-} // namespace mlir
-
using namespace mlir;
namespace {
/// Replaces sequential chains of `spirv::CompositeInsertOp` operation into
/// `spirv::CompositeConstructOp` operation if possible.
-class SPIRVRewriteInsertsPass
- : public spirv::impl::SPIRVRewriteInsertsPassBase<SPIRVRewriteInsertsPass> {
+class RewriteInsertsPass
+ : public SPIRVRewriteInsertsPassBase<RewriteInsertsPass> {
public:
- using SPIRVRewriteInsertsPassBase::SPIRVRewriteInsertsPassBase;
-
void runOnOperation() override;
private:
} // namespace
-void SPIRVRewriteInsertsPass::runOnOperation() {
+void RewriteInsertsPass::runOnOperation() {
SmallVector<SmallVector<spirv::CompositeInsertOp, 4>, 4> workList;
getOperation().walk([this, &workList](spirv::CompositeInsertOp op) {
SmallVector<spirv::CompositeInsertOp, 4> insertions;
}
}
-LogicalResult SPIRVRewriteInsertsPass::collectInsertionChain(
+LogicalResult RewriteInsertsPass::collectInsertionChain(
spirv::CompositeInsertOp op,
SmallVectorImpl<spirv::CompositeInsertOp> &insertions) {
auto indicesArrayAttr = op.indices().cast<ArrayAttr>();
std::unique_ptr<mlir::OperationPass<spirv::ModuleOp>>
mlir::spirv::createRewriteInsertsPass() {
- return std::make_unique<SPIRVRewriteInsertsPass>();
+ return std::make_unique<RewriteInsertsPass>();
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/BuiltinTypes.h"
#include <algorithm>
#include <iterator>
-namespace mlir {
-namespace spirv {
-#define GEN_PASS_DEF_SPIRVUNIFYALIASEDRESOURCEPASS
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
-} // namespace spirv
-} // namespace mlir
-
#define DEBUG_TYPE "spirv-unify-aliased-resource"
using namespace mlir;
//===----------------------------------------------------------------------===//
namespace {
-class SPIRVUnifyAliasedResourcePass final
- : public spirv::impl::SPIRVUnifyAliasedResourcePassBase<
- SPIRVUnifyAliasedResourcePass> {
+class UnifyAliasedResourcePass final
+ : public SPIRVUnifyAliasedResourcePassBase<UnifyAliasedResourcePass> {
public:
- using SPIRVUnifyAliasedResourcePassBase::SPIRVUnifyAliasedResourcePassBase;
-
void runOnOperation() override;
};
} // namespace
-void SPIRVUnifyAliasedResourcePass::runOnOperation() {
+void UnifyAliasedResourcePass::runOnOperation() {
spirv::ModuleOp moduleOp = getOperation();
MLIRContext *context = &getContext();
std::unique_ptr<mlir::OperationPass<spirv::ModuleOp>>
spirv::createUnifyAliasedResourcePass() {
- return std::make_unique<SPIRVUnifyAliasedResourcePass>();
+ return std::make_unique<UnifyAliasedResourcePass>();
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/Visitors.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringExtras.h"
-namespace mlir {
-namespace spirv {
-#define GEN_PASS_DEF_SPIRVUPDATEVCEPASS
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
-} // namespace spirv
-} // namespace mlir
-
using namespace mlir;
namespace {
/// Pass to deduce minimal version/extension/capability requirements for a
/// spirv::ModuleOp.
-class SPIRVUpdateVCEPass final
- : public spirv::impl::SPIRVUpdateVCEPassBase<SPIRVUpdateVCEPass> {
- using SPIRVUpdateVCEPassBase::SPIRVUpdateVCEPassBase;
-
+class UpdateVCEPass final : public SPIRVUpdateVCEBase<UpdateVCEPass> {
void runOnOperation() override;
};
} // namespace
return success();
}
-void SPIRVUpdateVCEPass::runOnOperation() {
+void UpdateVCEPass::runOnOperation() {
spirv::ModuleOp module = getOperation();
spirv::TargetEnvAttr targetAttr = spirv::lookupTargetEnv(module);
std::unique_ptr<OperationPass<spirv::ModuleOp>>
mlir::spirv::createUpdateVersionCapabilityExtensionPass() {
- return std::make_unique<SPIRVUpdateVCEPass>();
+ return std::make_unique<UpdateVCEPass>();
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Shape/Transforms/Passes.h"
-
+#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
-#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.h"
+#include "mlir/Dialect/Shape/Transforms/Passes.h"
#include "mlir/Pass/Pass.h"
-namespace mlir {
-#define GEN_PASS_DEF_SHAPEBUFFERIZEPASS
-#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace bufferization;
namespace {
-struct ShapeBufferizePass
- : public impl::ShapeBufferizePassBase<ShapeBufferizePass> {
+struct ShapeBufferizePass : public ShapeBufferizeBase<ShapeBufferizePass> {
void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<shape::ShapeDialect>();
--- /dev/null
+//===- PassDetail.h - Shape Pass class details ------------------*- 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 DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+namespace bufferization {
+class BufferizationDialect;
+} // namespace bufferization
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Shape/Transforms/Passes.h"
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Shape/IR/Shape.h"
+#include "mlir/Dialect/Shape/Transforms/Passes.h"
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_REMOVESHAPECONSTRAINTSPASS
-#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
};
/// Removal pass.
-struct RemoveShapeConstraintsPass
- : public impl::RemoveShapeConstraintsPassBase<RemoveShapeConstraintsPass> {
- using RemoveShapeConstraintsPassBase::RemoveShapeConstraintsPassBase;
+class RemoveShapeConstraintsPass
+ : public RemoveShapeConstraintsBase<RemoveShapeConstraintsPass> {
void runOnOperation() override {
MLIRContext &ctx = getContext();
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Shape/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Shape/IR/Shape.h"
+#include "mlir/Dialect/Shape/Transforms/Passes.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-#define GEN_PASS_DEF_SHAPETOSHAPELOWERINGPASS
-#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::shape;
}
namespace {
-struct ShapeToShapeLoweringPass
- : public impl::ShapeToShapeLoweringPassBase<ShapeToShapeLoweringPass> {
- using ShapeToShapeLoweringPassBase::ShapeToShapeLoweringPassBase;
-
+struct ShapeToShapeLowering
+ : public ShapeToShapeLoweringBase<ShapeToShapeLowering> {
void runOnOperation() override;
};
} // namespace
-void ShapeToShapeLoweringPass::runOnOperation() {
+void ShapeToShapeLowering::runOnOperation() {
MLIRContext &ctx = getContext();
RewritePatternSet patterns(&ctx);
}
std::unique_ptr<Pass> mlir::createShapeToShapeLowering() {
- return std::make_unique<ShapeToShapeLoweringPass>();
+ return std::make_unique<ShapeToShapeLowering>();
}
// it to this pipeline.
pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
- pm.addNestedPass<func::FuncOp>(createConvertSCFToControlFlowPass());
- pm.addPass(createConvertAffineToStandardPass());
+ pm.addNestedPass<func::FuncOp>(createConvertSCFToCFPass());
+ pm.addPass(createLowerAffinePass());
pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
- pm.addPass(createConvertMemRefToLLVMPass());
+ pm.addPass(createMemRefToLLVMPass());
pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass());
pm.addNestedPass<mlir::func::FuncOp>(
mlir::arith::createArithmeticExpandOpsPass());
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-#define GEN_PASS_DEF_SPARSIFICATIONPASS
-#define GEN_PASS_DEF_SPARSETENSORCONVERSIONPASS
-#define GEN_PASS_DEF_SPARSETENSORCODEGENPASS
-#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::sparse_tensor;
namespace {
//===----------------------------------------------------------------------===//
+// Passes declaration.
+//===----------------------------------------------------------------------===//
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
+
+//===----------------------------------------------------------------------===//
// Passes implementation.
//===----------------------------------------------------------------------===//
-struct SparsificationPass
- : public mlir::impl::SparsificationPassBase<SparsificationPass> {
+struct SparsificationPass : public SparsificationBase<SparsificationPass> {
SparsificationPass() = default;
SparsificationPass(const SparsificationPass &pass) = default;
};
struct SparseTensorConversionPass
- : public mlir::impl::SparseTensorConversionPassBase<
- SparseTensorConversionPass> {
+ : public SparseTensorConversionBase<SparseTensorConversionPass> {
SparseTensorConversionPass() = default;
SparseTensorConversionPass(const SparseTensorConversionPass &pass) = default;
};
struct SparseTensorCodegenPass
- : public mlir::impl::SparseTensorCodegenPassBase<SparseTensorCodegenPass> {
+ : public SparseTensorCodegenBase<SparseTensorCodegenPass> {
SparseTensorCodegenPass() = default;
SparseTensorCodegenPass(const SparseTensorCodegenPass &pass) = default;
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
+#include "PassDetail.h"
#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/ImplicitLocOpBuilder.h"
#include "mlir/Transforms/DialectConversion.h"
-namespace mlir {
-namespace tensor {
-#define GEN_PASS_DEF_TENSORBUFFERIZEPASS
-#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
-} // namespace tensor
-} // namespace mlir
-
using namespace mlir;
using namespace bufferization;
namespace {
-struct TensorBufferizePass
- : public tensor::impl::TensorBufferizePassBase<TensorBufferizePass> {
- using TensorBufferizePassBase::TensorBufferizePassBase;
-
+struct TensorBufferizePass : public TensorBufferizeBase<TensorBufferizePass> {
void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<tensor::TensorDialect>();
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::createTensorBufferizePass() {
+ return std::make_unique<TensorBufferizePass>();
+}
--- /dev/null
+//===- PassDetail.h - GPU Pass class details --------------------*- 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 DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+namespace bufferization {
+class BufferizationDialect;
+} // namespace bufferization
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+namespace scf {
+class SCFDialect;
+} // namespace scf
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Tosa/Transforms/Passes.h"
-
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
+#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Dialect/Tosa/Utils/ShapeUtils.h"
#include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "llvm/Support/FormatVariadic.h"
-namespace mlir {
-namespace tosa {
-#define GEN_PASS_DEF_TOSAINFERSHAPESPASS
-#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
-} // namespace tosa
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::tosa;
/// Pass that performs shape propagation across TOSA operations. This includes
/// migrating to within the regions of if/while operations.
-struct TosaInferShapesPass
- : public tosa::impl::TosaInferShapesPassBase<TosaInferShapesPass> {
+struct TosaInferShapes : public TosaInferShapesBase<TosaInferShapes> {
public:
- using TosaInferShapesPassBase::TosaInferShapesPassBase;
-
void runOnOperation() override {
func::FuncOp func = getOperation();
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::tosa::createTosaInferShapesPass() {
+ return std::make_unique<TosaInferShapes>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Tosa/Transforms/Passes.h"
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
+#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-namespace tosa {
-#define GEN_PASS_DEF_TOSALAYERWISECONSTANTFOLDPASS
-#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
-} // namespace tosa
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::tosa;
}
struct TosaLayerwiseConstantFoldPass
- : public tosa::impl::TosaLayerwiseConstantFoldPassBase<
- TosaLayerwiseConstantFoldPass> {
- using TosaLayerwiseConstantFoldPassBase::TosaLayerwiseConstantFoldPassBase;
-
+ : public TosaLayerwiseConstantFoldPassBase<TosaLayerwiseConstantFoldPass> {
void runOnOperation() override {
auto *ctx = &getContext();
RewritePatternSet patterns(ctx);
};
} // namespace
+
+std::unique_ptr<Pass> mlir::tosa::createTosaLayerwiseConstantFoldPass() {
+ return std::make_unique<TosaLayerwiseConstantFoldPass>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
-#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/IR//TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-namespace tosa {
-#define GEN_PASS_DEF_TOSAMAKEBROADCASTABLEPASS
-#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
-} // namespace tosa
-} // namespace mlir
-
using namespace mlir;
using namespace mlir::tosa;
namespace {
/// Pass that enables broadcast by making all input arrays have the same
/// number of dimensions. Insert RESHAPE operations to lower rank operand
-struct TosaMakeBroadcastablePass
- : public tosa::impl::TosaMakeBroadcastablePassBase<
- TosaMakeBroadcastablePass> {
+struct TosaMakeBroadcastable
+ : public TosaMakeBroadcastableBase<TosaMakeBroadcastable> {
public:
- using TosaMakeBroadcastablePassBase::TosaMakeBroadcastablePassBase;
-
void runOnOperation() override {
auto func = getOperation();
RewritePatternSet patterns(func.getContext());
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::tosa::createTosaMakeBroadcastablePass() {
+ return std::make_unique<TosaMakeBroadcastable>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Tosa/Transforms/Passes.h"
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
+#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-namespace mlir {
-namespace tosa {
-#define GEN_PASS_DEF_TOSAOPTIONALDECOMPOSITIONSPASS
-#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
-} // namespace tosa
-} // namespace mlir
-
using namespace mlir;
namespace {
-struct TosaOptionalDecompositionsPass
- : public tosa::impl::TosaOptionalDecompositionsPassBase<
- TosaOptionalDecompositionsPass> {
- using TosaOptionalDecompositionsPassBase::TosaOptionalDecompositionsPassBase;
-
+struct TosaOptionalDecompositions
+ : public TosaOptionalDecompositionsBase<TosaOptionalDecompositions> {
void runOnOperation() override {
auto *ctx = &getContext();
RewritePatternSet patterns(ctx);
};
} // namespace
+
+std::unique_ptr<Pass> mlir::tosa::createTosaOptionalDecompositions() {
+ return std::make_unique<TosaOptionalDecompositions>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Transform/Transforms/Passes.h"
-
#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
+#include "mlir/Dialect/Transform/Transforms/Passes.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Pass/Pass.h"
#include "llvm/ADT/SetOperations.h"
-namespace mlir {
-namespace transform {
-#define GEN_PASS_DEF_CHECKUSESPASS
-#include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
-} // namespace transform
-} // namespace mlir
-
using namespace mlir;
namespace {
DenseMap<Block *, llvm::SmallPtrSet<Block *, 4>> reachableFromCache;
};
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
+
//// 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::CheckUsesPassBase<CheckUsesPass> {
+class CheckUsesPass : public CheckUsesBase<CheckUsesPass> {
public:
- using CheckUsesPassBase::CheckUsesPassBase;
-
void runOnOperation() override {
auto &analysis = getAnalysis<TransformOpMemFreeAnalysis>();
};
} // namespace
+
+namespace mlir {
+namespace transform {
+std::unique_ptr<Pass> createCheckUsesPass() {
+ return std::make_unique<CheckUsesPass>();
+}
+} // namespace transform
+} // namespace mlir
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-
+#include "PassDetail.h"
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Vector/IR/VectorOps.h"
#include "mlir/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.h"
#include "mlir/Dialect/Vector/Transforms/Passes.h"
-namespace mlir {
-namespace vector {
-#define GEN_PASS_DEF_VECTORBUFFERIZEPASS
-#include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
-} // namespace vector
-} // namespace mlir
-
using namespace mlir;
using namespace bufferization;
namespace {
-struct VectorBufferizePass
- : public vector::impl::VectorBufferizePassBase<VectorBufferizePass> {
- using VectorBufferizePassBase::VectorBufferizePassBase;
-
+struct VectorBufferizePass : public VectorBufferizeBase<VectorBufferizePass> {
void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<vector::VectorDialect>();
}
};
} // namespace
+
+std::unique_ptr<Pass> mlir::vector::createVectorBufferizePass() {
+ return std::make_unique<VectorBufferizePass>();
+}
--- /dev/null
+//===- PassDetail.h - Vector Pass class details -----------------*- 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 DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_
+#define DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+namespace bufferization {
+class BufferizationDialect;
+} // namespace bufferization
+
+namespace memref {
+class MemRefDialect;
+} // namespace memref
+
+#define GEN_PASS_CLASSES
+#include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_
#include "mlir/Pass/PassManager.h"
#include "mlir/Pass/PassRegistry.h"
+#include "mlir/Reducer/PassDetail.h"
#include "mlir/Reducer/Passes.h"
#include "mlir/Reducer/Tester.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_OPTREDUCTIONPASS
-#include "mlir/Reducer/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "mlir-reduce"
using namespace mlir;
namespace {
-class OptReductionPass
- : public mlir::impl::OptReductionPassBase<OptReductionPass> {
+class OptReductionPass : public OptReductionBase<OptReductionPass> {
public:
/// Runs the pass instance in the pass pipeline.
void runOnOperation() override;
#include "mlir/IR/DialectInterface.h"
#include "mlir/IR/OpDefinition.h"
+#include "mlir/Reducer/PassDetail.h"
#include "mlir/Reducer/Passes.h"
#include "mlir/Reducer/ReductionNode.h"
#include "mlir/Reducer/ReductionPatternInterface.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/ManagedStatic.h"
-namespace mlir {
-#define GEN_PASS_DEF_REDUCTIONTREEPASS
-#include "mlir/Reducer/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
/// We implicitly number each operation in the region and if an operation's
/// This class defines the Reduction Tree Pass. It provides a framework to
/// to implement a reduction pass using a tree structure to keep track of the
/// generated reduced variants.
-class ReductionTreePass
- : public mlir::impl::ReductionTreePassBase<ReductionTreePass> {
+class ReductionTreePass : public ReductionTreeBase<ReductionTreePass> {
public:
ReductionTreePass() = default;
ReductionTreePass(const ReductionTreePass &pass) = default;
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/IR/Dominance.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/Passes.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/ScopedHashTable.h"
#include "llvm/Support/RecyclingAllocator.h"
#include <deque>
-namespace mlir {
-#define GEN_PASS_DEF_CSEPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
namespace {
/// Simple common sub-expression elimination.
-struct CSEPass : public impl::CSEPassBase<CSEPass> {
- using CSEPassBase::CSEPassBase;
-
+struct CSE : public CSEBase<CSE> {
/// Shared implementation of operation elimination and scoped map definitions.
using AllocatorTy = llvm::RecyclingAllocator<
llvm::BumpPtrAllocator,
};
} // namespace
-void CSEPass::replaceUsesAndDelete(ScopedMapTy &knownValues, Operation *op,
- Operation *existing, bool hasSSADominance) {
+void CSE::replaceUsesAndDelete(ScopedMapTy &knownValues, Operation *op,
+ Operation *existing, bool hasSSADominance) {
// If we find one then replace all uses of the current operation with the
// existing one and mark it for deletion. We can only replace an operand in
// an operation if it has not been visited yet.
++numCSE;
}
-bool CSEPass::hasOtherSideEffectingOpInBetween(Operation *fromOp,
- Operation *toOp) {
+bool CSE::hasOtherSideEffectingOpInBetween(Operation *fromOp, Operation *toOp) {
assert(fromOp->getBlock() == toOp->getBlock());
assert(
isa<MemoryEffectOpInterface>(fromOp) &&
}
/// Attempt to eliminate a redundant operation.
-LogicalResult CSEPass::simplifyOperation(ScopedMapTy &knownValues,
- Operation *op, bool hasSSADominance) {
+LogicalResult CSE::simplifyOperation(ScopedMapTy &knownValues, Operation *op,
+ bool hasSSADominance) {
// Don't simplify terminator operations.
if (op->hasTrait<OpTrait::IsTerminator>())
return failure();
return failure();
}
-void CSEPass::simplifyBlock(ScopedMapTy &knownValues, Block *bb,
- bool hasSSADominance) {
+void CSE::simplifyBlock(ScopedMapTy &knownValues, Block *bb,
+ bool hasSSADominance) {
for (auto &op : *bb) {
// If the operation is simplified, we don't process any held regions.
if (succeeded(simplifyOperation(knownValues, &op, hasSSADominance)))
memEffectsCache.clear();
}
-void CSEPass::simplifyRegion(ScopedMapTy &knownValues, Region ®ion) {
+void CSE::simplifyRegion(ScopedMapTy &knownValues, Region ®ion) {
// If the region is empty there is nothing to do.
if (region.empty())
return;
}
}
-void CSEPass::runOnOperation() {
+void CSE::runOnOperation() {
/// A scoped hash table of defining operations within a region.
ScopedMapTy knownValues;
markAnalysesPreserved<DominanceInfo, PostDominanceInfo>();
domInfo = nullptr;
}
+
+std::unique_ptr<Pass> mlir::createCSEPass() { return std::make_unique<CSE>(); }
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_CANONICALIZERPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
+#include "mlir/Transforms/Passes.h"
using namespace mlir;
namespace {
/// Canonicalize operations in nested regions.
-struct CanonicalizerPass
- : public impl::CanonicalizerPassBase<CanonicalizerPass> {
- CanonicalizerPass() = default;
- CanonicalizerPass(const GreedyRewriteConfig &config,
- ArrayRef<std::string> disabledPatterns,
- ArrayRef<std::string> enabledPatterns) {
+struct Canonicalizer : public CanonicalizerBase<Canonicalizer> {
+ Canonicalizer() = default;
+ Canonicalizer(const GreedyRewriteConfig &config,
+ ArrayRef<std::string> disabledPatterns,
+ ArrayRef<std::string> enabledPatterns) {
this->topDownProcessingEnabled = config.useTopDownTraversal;
this->enableRegionSimplification = config.enableRegionSimplification;
this->maxIterations = config.maxIterations;
/// Create a Canonicalizer pass.
std::unique_ptr<Pass> mlir::createCanonicalizerPass() {
- return std::make_unique<CanonicalizerPass>();
+ return std::make_unique<Canonicalizer>();
}
/// Creates an instance of the Canonicalizer pass with the specified config.
mlir::createCanonicalizerPass(const GreedyRewriteConfig &config,
ArrayRef<std::string> disabledPatterns,
ArrayRef<std::string> enabledPatterns) {
- return std::make_unique<CanonicalizerPass>(config, disabledPatterns,
- enabledPatterns);
+ return std::make_unique<Canonicalizer>(config, disabledPatterns,
+ enabledPatterns);
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/IR/Dominance.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Transforms/ControlFlowSinkUtils.h"
+#include "mlir/Transforms/Passes.h"
#include "mlir/Transforms/SideEffectUtils.h"
-namespace mlir {
-#define GEN_PASS_DEF_CONTROLFLOWSINKPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
/// A control-flow sink pass.
-struct ControlFlowSinkPass
- : public impl::ControlFlowSinkPassBase<ControlFlowSinkPass> {
- using ControlFlowSinkPassBase::ControlFlowSinkPassBase;
-
+struct ControlFlowSink : public ControlFlowSinkBase<ControlFlowSink> {
void runOnOperation() override;
};
} // end anonymous namespace
-void ControlFlowSinkPass::runOnOperation() {
+void ControlFlowSink::runOnOperation() {
auto &domInfo = getAnalysis<DominanceInfo>();
getOperation()->walk([&](RegionBranchOpInterface branch) {
SmallVector<Region *> regionsToSink;
});
});
}
+
+std::unique_ptr<Pass> mlir::createControlFlowSinkPass() {
+ return std::make_unique<ControlFlowSink>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Analysis/CallGraph.h"
#include "mlir/IR/Threading.h"
#include "mlir/Interfaces/CallInterfaces.h"
#include "mlir/Pass/PassManager.h"
#include "mlir/Support/DebugStringHelper.h"
#include "mlir/Transforms/InliningUtils.h"
+#include "mlir/Transforms/Passes.h"
#include "llvm/ADT/SCCIterator.h"
#include "llvm/Support/Debug.h"
-namespace mlir {
-#define GEN_PASS_DEF_INLINERPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
#define DEBUG_TYPE "inlining"
using namespace mlir;
//===----------------------------------------------------------------------===//
namespace {
-class InlinerPass : public impl::InlinerPassBase<InlinerPass> {
+class InlinerPass : public InlinerBase<InlinerPass> {
public:
InlinerPass();
InlinerPass(const InlinerPass &) = default;
//===----------------------------------------------------------------------===//
#include "mlir/Transforms/LocationSnapshot.h"
-
+#include "PassDetail.h"
#include "mlir/IR/AsmState.h"
#include "mlir/IR/Builders.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Support/FileUtilities.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/ToolOutputFile.h"
-namespace mlir {
-#define GEN_PASS_DEF_LOCATIONSNAPSHOTPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
/// This function generates new locations from the given IR by snapshotting the
namespace {
struct LocationSnapshotPass
- : public impl::LocationSnapshotPassBase<LocationSnapshotPass> {
+ : public LocationSnapshotBase<LocationSnapshotPass> {
LocationSnapshotPass() = default;
LocationSnapshotPass(OpPrintingFlags flags, StringRef fileName, StringRef tag)
: flags(flags) {
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Interfaces/LoopLikeInterface.h"
#include "mlir/Transforms/LoopInvariantCodeMotionUtils.h"
+#include "mlir/Transforms/Passes.h"
#include "mlir/Transforms/SideEffectUtils.h"
-namespace mlir {
-#define GEN_PASS_DEF_LOOPINVARIANTCODEMOTIONPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
/// Loop invariant code motion (LICM) pass.
-struct LoopInvariantCodeMotionPass
- : public impl::LoopInvariantCodeMotionPassBase<
- LoopInvariantCodeMotionPass> {
- using LoopInvariantCodeMotionPassBase::LoopInvariantCodeMotionPassBase;
-
+struct LoopInvariantCodeMotion
+ : public LoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
void runOnOperation() override;
};
} // namespace
-void LoopInvariantCodeMotionPass::runOnOperation() {
+void LoopInvariantCodeMotion::runOnOperation() {
// Walk through all loops in a function in innermost-loop-first order. This
// way, we first LICM from the inner loop, and place the ops in
// the outer loop, which in turn can be further LICM'ed.
getOperation()->walk(
[&](LoopLikeOpInterface loopLike) { moveLoopInvariantCode(loopLike); });
}
+
+std::unique_ptr<Pass> mlir::createLoopInvariantCodeMotionPass() {
+ return std::make_unique<LoopInvariantCodeMotion>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Operation.h"
#include "mlir/IR/OperationSupport.h"
+#include "mlir/Transforms/Passes.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
-namespace mlir {
-#define GEN_PASS_DEF_PRINTOPSTATSPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
-struct PrintOpStatsPass : public impl::PrintOpStatsPassBase<PrintOpStatsPass> {
+struct PrintOpStatsPass : public PrintOpStatsBase<PrintOpStatsPass> {
explicit PrintOpStatsPass(raw_ostream &os) : os(os) {}
explicit PrintOpStatsPass(raw_ostream &os, bool printAsJSON) : os(os) {
--- /dev/null
+//===- PassDetail.h - Transforms Pass class details -------------*- 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 TRANSFORMS_PASSDETAIL_H_
+#define TRANSFORMS_PASSDETAIL_H_
+
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/Passes.h"
+
+namespace mlir {
+#define GEN_PASS_CLASSES
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
+#endif // TRANSFORMS_PASSDETAIL_H_
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/Analysis/DataFlow/ConstantPropagationAnalysis.h"
#include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
#include "mlir/IR/Builders.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/FoldUtils.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_SCCPPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
+#include "mlir/Transforms/Passes.h"
using namespace mlir;
using namespace mlir::dataflow;
//===----------------------------------------------------------------------===//
namespace {
-struct SCCPPass : public impl::SCCPPassBase<SCCPPass> {
- using SCCPPassBase::SCCPPassBase;
-
+struct SCCP : public SCCPBase<SCCP> {
void runOnOperation() override;
};
} // namespace
-void SCCPPass::runOnOperation() {
+void SCCP::runOnOperation() {
Operation *op = getOperation();
DataFlowSolver solver;
return signalPassFailure();
rewrite(solver, op->getContext(), op->getRegions());
}
+
+std::unique_ptr<Pass> mlir::createSCCPPass() {
+ return std::make_unique<SCCP>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Operation.h"
#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_STRIPDEBUGINFOPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
+#include "mlir/Transforms/Passes.h"
using namespace mlir;
namespace {
-struct StripDebugInfoPass
- : public impl::StripDebugInfoPassBase<StripDebugInfoPass> {
- using StripDebugInfoPassBase::StripDebugInfoPassBase;
-
+struct StripDebugInfo : public StripDebugInfoBase<StripDebugInfo> {
void runOnOperation() override;
};
} // namespace
-void StripDebugInfoPass::runOnOperation() {
+void StripDebugInfo::runOnOperation() {
auto unknownLoc = UnknownLoc::get(&getContext());
// Strip the debug info from all operations.
}
});
}
+
+/// Creates a pass to strip debug information from a function.
+std::unique_ptr<Pass> mlir::createStripDebugInfoPass() {
+ return std::make_unique<StripDebugInfo>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/IR/SymbolTable.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_SYMBOLDCEPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
+#include "mlir/Transforms/Passes.h"
using namespace mlir;
namespace {
-struct SymbolDCEPass : public impl::SymbolDCEPassBase<SymbolDCEPass> {
- using SymbolDCEPassBase::SymbolDCEPassBase;
-
+struct SymbolDCE : public SymbolDCEBase<SymbolDCE> {
void runOnOperation() override;
/// Compute the liveness of the symbols within the given symbol table.
};
} // namespace
-void SymbolDCEPass::runOnOperation() {
+void SymbolDCE::runOnOperation() {
Operation *symbolTableOp = getOperation();
// SymbolDCE should only be run on operations that define a symbol table.
/// Compute the liveness of the symbols within the given symbol table.
/// `symbolTableIsHidden` is true if this symbol table is known to be
/// unaccessible from operations in its parent regions.
-LogicalResult SymbolDCEPass::computeLiveness(
- Operation *symbolTableOp, SymbolTableCollection &symbolTable,
- bool symbolTableIsHidden, DenseSet<Operation *> &liveSymbols) {
+LogicalResult SymbolDCE::computeLiveness(Operation *symbolTableOp,
+ SymbolTableCollection &symbolTable,
+ bool symbolTableIsHidden,
+ DenseSet<Operation *> &liveSymbols) {
// A worklist of live operations to propagate uses from.
SmallVector<Operation *, 16> worklist;
return success();
}
+
+std::unique_ptr<Pass> mlir::createSymbolDCEPass() {
+ return std::make_unique<SymbolDCE>();
+}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/IR/SymbolTable.h"
-
-namespace mlir {
-#define GEN_PASS_DEF_SYMBOLPRIVATIZEPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
+#include "mlir/Transforms/Passes.h"
using namespace mlir;
namespace {
-struct SymbolPrivatizePass
- : public impl::SymbolPrivatizePassBase<SymbolPrivatizePass> {
- explicit SymbolPrivatizePass(ArrayRef<std::string> excludeSymbols);
+struct SymbolPrivatize : public SymbolPrivatizeBase<SymbolPrivatize> {
+ explicit SymbolPrivatize(ArrayRef<std::string> excludeSymbols);
LogicalResult initialize(MLIRContext *context) override;
void runOnOperation() override;
};
} // namespace
-SymbolPrivatizePass::SymbolPrivatizePass(
- llvm::ArrayRef<std::string> excludeSymbols) {
+SymbolPrivatize::SymbolPrivatize(llvm::ArrayRef<std::string> excludeSymbols) {
exclude = excludeSymbols;
}
-LogicalResult SymbolPrivatizePass::initialize(MLIRContext *context) {
+LogicalResult SymbolPrivatize::initialize(MLIRContext *context) {
for (const std::string &symbol : exclude)
excludedSymbols.insert(StringAttr::get(context, symbol));
return success();
}
-void SymbolPrivatizePass::runOnOperation() {
+void SymbolPrivatize::runOnOperation() {
for (Region ®ion : getOperation()->getRegions()) {
for (Block &block : region) {
for (Operation &op : block) {
std::unique_ptr<Pass>
mlir::createSymbolPrivatizePass(ArrayRef<std::string> exclude) {
- return std::make_unique<SymbolPrivatizePass>(exclude);
+ return std::make_unique<SymbolPrivatize>(exclude);
}
//
//===----------------------------------------------------------------------===//
-#include "mlir/Transforms/Passes.h"
-
+#include "PassDetail.h"
#include "mlir/IR/RegionKindInterface.h"
#include "mlir/Transforms/TopologicalSortUtils.h"
-namespace mlir {
-#define GEN_PASS_DEF_TOPOLOGICALSORTPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
namespace {
-struct TopologicalSortPass
- : public impl::TopologicalSortPassBase<TopologicalSortPass> {
- using TopologicalSortPassBase::TopologicalSortPassBase;
-
+struct TopologicalSortPass : public TopologicalSortBase<TopologicalSortPass> {
void runOnOperation() override {
// Topologically sort the regions of the operation without SSA dominance.
getOperation()->walk([](RegionKindInterface op) {
}
};
} // end anonymous namespace
+
+std::unique_ptr<Pass> mlir::createTopologicalSortPass() {
+ return std::make_unique<TopologicalSortPass>();
+}
//===----------------------------------------------------------------------===//
#include "mlir/Transforms/ViewOpGraph.h"
-
+#include "PassDetail.h"
#include "mlir/IR/Block.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Operation.h"
-#include "mlir/Pass/Pass.h"
#include "mlir/Support/IndentedOstream.h"
-#include "llvm/ADT/StringMap.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/GraphWriter.h"
#include <utility>
-namespace mlir {
-#define GEN_PASS_DEF_VIEWOPGRAPHPASS
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
using namespace mlir;
static const StringRef kLineStyleControlFlow = "dashed";
/// This pass generates a Graphviz dataflow visualization of an MLIR operation.
/// Note: See https://www.graphviz.org/doc/info/lang.html for more information
/// about the Graphviz DOT language.
-class ViewOpGraphPass : public impl::ViewOpGraphPassBase<ViewOpGraphPass> {
+class PrintOpPass : public ViewOpGraphBase<PrintOpPass> {
public:
- ViewOpGraphPass(raw_ostream &os) : os(os) {}
- ViewOpGraphPass(const ViewOpGraphPass &o)
- : ViewOpGraphPass(o.os.getOStream()) {}
+ PrintOpPass(raw_ostream &os) : os(os) {}
+ PrintOpPass(const PrintOpPass &o) : PrintOpPass(o.os.getOStream()) {}
void runOnOperation() override {
emitGraph([&]() {
} // namespace
-std::unique_ptr<Pass> mlir::createViewOpGraphPass(raw_ostream &os) {
- return std::make_unique<ViewOpGraphPass>(os);
+std::unique_ptr<Pass> mlir::createPrintOpGraphPass(raw_ostream &os) {
+ return std::make_unique<PrintOpPass>(os);
}
/// Generate a CFG for a region and show it in a window.
llvm::errs() << "error opening file '" << filename << "' for writing\n";
return;
}
- ViewOpGraphPass pass(os);
+ PrintOpPass pass(os);
pass.emitRegionCFG(region);
}
llvm::DisplayGraph(filename, /*wait=*/false, llvm::GraphProgram::DOT);
MlirPassManager pm = mlirPassManagerCreate(ctx);
MlirOpPassManager opm = mlirPassManagerGetNestedUnder(
pm, mlirStringRefCreateFromCString("func.func"));
- mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVMPass());
- mlirOpPassManagerAddOwnedPass(
- opm, mlirCreateConversionConvertArithmeticToLLVMPass());
+ mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM());
+ mlirOpPassManagerAddOwnedPass(opm,
+ mlirCreateConversionConvertArithmeticToLLVM());
MlirLogicalResult status = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(status)) {
fprintf(stderr, "Unexpected failure running pass pipeline\n");
// CHECK: func.return , 1
{
MlirPassManager pm = mlirPassManagerCreate(ctx);
- MlirPass printOpStatPass = mlirCreateTransformsPrintOpStatsPass();
+ MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
mlirPassManagerAddOwnedPass(pm, printOpStatPass);
MlirLogicalResult success = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(success)) {
MlirPassManager pm = mlirPassManagerCreate(ctx);
MlirOpPassManager nestedFuncPm = mlirPassManagerGetNestedUnder(
pm, mlirStringRefCreateFromCString("func.func"));
- MlirPass printOpStatPass = mlirCreateTransformsPrintOpStatsPass();
+ MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
MlirLogicalResult success = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(success))
pm, mlirStringRefCreateFromCString("builtin.module"));
MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
nestedModulePm, mlirStringRefCreateFromCString("func.func"));
- MlirPass printOpStatPass = mlirCreateTransformsPrintOpStatsPass();
+ MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
MlirLogicalResult success = mlirPassManagerRun(pm, module);
if (mlirLogicalResultIsFailure(success))
pm, mlirStringRefCreateFromCString("builtin.module"));
MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
nestedModulePm, mlirStringRefCreateFromCString("func.func"));
- MlirPass printOpStatPass = mlirCreateTransformsPrintOpStatsPass();
+ MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
// Print the top level pass manager
exit(EXIT_FAILURE);
}
// Try again after registrating the pass.
- mlirRegisterTransformsPrintOpStatsPass();
+ mlirRegisterTransformsPrintOpStats();
status = mlirParsePassPipeline(
mlirPassManagerGetAsOpPassManager(pm),
mlirStringRefCreateFromCString(
return
}
-// BEFORE: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
+// BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
// BEFORE-NEXT: func @foo()
-// BEFORE: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
+// BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
// BEFORE-NEXT: func @bar()
-// BEFORE-NOT: // -----// IR Dump Before{{.*}}CanonicalizerPass (canonicalize) //----- //
+// BEFORE-NOT: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
// BEFORE-NOT: // -----// IR Dump After
-// BEFORE_ALL: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
+// BEFORE_ALL: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
// BEFORE_ALL-NEXT: func @foo()
-// BEFORE_ALL: // -----// IR Dump Before{{.*}}CanonicalizerPass (canonicalize) //----- //
+// BEFORE_ALL: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
// BEFORE_ALL-NEXT: func @foo()
-// BEFORE_ALL: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
+// BEFORE_ALL: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
// BEFORE_ALL-NEXT: func @bar()
-// BEFORE_ALL: // -----// IR Dump Before{{.*}}CanonicalizerPass (canonicalize) //----- //
+// BEFORE_ALL: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
// BEFORE_ALL-NEXT: func @bar()
// BEFORE_ALL-NOT: // -----// IR Dump After
// AFTER-NOT: // -----// IR Dump Before
-// AFTER: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
+// AFTER: // -----// IR Dump After{{.*}}CSE (cse) //----- //
// AFTER-NEXT: func @foo()
-// AFTER: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
+// AFTER: // -----// IR Dump After{{.*}}CSE (cse) //----- //
// AFTER-NEXT: func @bar()
-// AFTER-NOT: // -----// IR Dump After{{.*}}CanonicalizerPass (canonicalize) //----- //
+// AFTER-NOT: // -----// IR Dump After{{.*}}Canonicalizer (canonicalize) //----- //
// AFTER_ALL-NOT: // -----// IR Dump Before
-// AFTER_ALL: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
+// AFTER_ALL: // -----// IR Dump After{{.*}}CSE (cse) //----- //
// AFTER_ALL-NEXT: func @foo()
-// AFTER_ALL: // -----// IR Dump After{{.*}}CanonicalizerPass (canonicalize) //----- //
+// AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer (canonicalize) //----- //
// AFTER_ALL-NEXT: func @foo()
-// AFTER_ALL: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
+// AFTER_ALL: // -----// IR Dump After{{.*}}CSE (cse) //----- //
// AFTER_ALL-NEXT: func @bar()
-// AFTER_ALL: // -----// IR Dump After{{.*}}CanonicalizerPass (canonicalize) //----- //
+// AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer (canonicalize) //----- //
// AFTER_ALL-NEXT: func @bar()
-// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSEPass (cse) ('func.func' operation: @foo) //----- //
+// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE (cse) ('func.func' operation: @foo) //----- //
// BEFORE_MODULE: func @foo()
// BEFORE_MODULE: func @bar()
-// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSEPass (cse) ('func.func' operation: @bar) //----- //
+// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE (cse) ('func.func' operation: @bar) //----- //
// BEFORE_MODULE: func @foo()
// BEFORE_MODULE: func @bar()
-// AFTER_ALL_CHANGE: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
+// AFTER_ALL_CHANGE: // -----// IR Dump After{{.*}}CSE (cse) //----- //
// AFTER_ALL_CHANGE-NEXT: func @foo()
-// AFTER_ALL_CHANGE-NOT: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
+// AFTER_ALL_CHANGE-NOT: // -----// IR Dump After{{.*}}CSE (cse) //----- //
// We expect that only 'foo' changed during CSE, and the second run of CSE did
// nothing.
-// AFTER_FAILURE-NOT: // -----// IR Dump After{{.*}}CSEPass
+// AFTER_FAILURE-NOT: // -----// IR Dump After{{.*}}CSE
// AFTER_FAILURE: // -----// IR Dump After{{.*}}TestFailurePass Failed (test-pass-failure) //----- //
// AFTER_FAILURE: func @foo()
}
#-}
-// BEFORE: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
+// BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
// BEFORE-NEXT: func @foo()
-// BEFORE: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
+// BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
// BEFORE-NEXT: func @bar()
-// BEFORE-NOT: // -----// IR Dump Before{{.*}}CanonicalizerPass (canonicalize) //----- //
+// BEFORE-NOT: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
// BEFORE-NOT: // -----// IR Dump After
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
#include "mlir/IR/BuiltinTypes.h"
return wrap({2}.release());
}
void mlirRegister{0}{1}() {
- register{1}();
+ register{1}Pass();
}
)";
constructorCall = constructor.str();
else
constructorCall =
- llvm::formatv("create{0}()", pass.getDef()->getName()).str();
+ llvm::formatv("create{0}Pass()", pass.getDef()->getName()).str();
os << llvm::formatv(passCreateDef, groupName, defName, constructorCall);
}
groupName("name", llvm::cl::desc("The name of this group of passes"),
llvm::cl::cat(passGenCat));
+static void emitOldPassDecl(const Pass &pass, raw_ostream &os);
+
/// Extract the list of passes from the TableGen records.
static std::vector<Pass> getPasses(const llvm::RecordKeeper &recordKeeper) {
std::vector<Pass> passes;
os << "#endif // " << enableVarName << "\n";
}
+// TODO drop old pass declarations
+// The old pass base class is being kept until all the passes have switched to
+// the new decls/defs design.
+const char *const oldPassDeclBegin = R"(
+template <typename DerivedT>
+class {0}Base : public {1} {
+public:
+ using Base = {0}Base;
+
+ {0}Base() : {1}(::mlir::TypeID::get<DerivedT>()) {{}
+ {0}Base(const {0}Base &other) : {1}(other) {{}
+
+ /// Returns the command-line argument attached to this pass.
+ static constexpr ::llvm::StringLiteral getArgumentName() {
+ return ::llvm::StringLiteral("{2}");
+ }
+ ::llvm::StringRef getArgument() const override { return "{2}"; }
+
+ ::llvm::StringRef getDescription() const override { return "{3}"; }
+
+ /// Returns the derived pass name.
+ static constexpr ::llvm::StringLiteral getPassName() {
+ return ::llvm::StringLiteral("{0}");
+ }
+ ::llvm::StringRef getName() const override { return "{0}"; }
+
+ /// Support isa/dyn_cast functionality for the derived pass class.
+ static bool classof(const ::mlir::Pass *pass) {{
+ return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+ }
+
+ /// A clone method to create a copy of this pass.
+ std::unique_ptr<::mlir::Pass> clonePass() const override {{
+ return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+ }
+
+ /// Return the dialect that must be loaded in the context before this pass.
+ void getDependentDialects(::mlir::DialectRegistry ®istry) const override {
+ {4}
+ }
+
+ /// Explicitly declare the TypeID for this class. We declare an explicit private
+ /// instantiation because Pass classes should only be visible by the current
+ /// library.
+ MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID({0}Base<DerivedT>)
+
+protected:
+)";
+
+/// Emit a backward-compatible declaration of the pass base class.
+static void emitOldPassDecl(const Pass &pass, raw_ostream &os) {
+ StringRef defName = pass.getDef()->getName();
+ std::string dependentDialectRegistrations;
+ {
+ llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);
+ for (StringRef dependentDialect : pass.getDependentDialects())
+ dialectsOs << llvm::formatv(dialectRegistrationTemplate,
+ dependentDialect);
+ }
+ os << llvm::formatv(oldPassDeclBegin, defName, pass.getBaseClass(),
+ pass.getArgument(), pass.getSummary(),
+ dependentDialectRegistrations);
+ emitPassOptionDecls(pass, os);
+ emitPassStatisticDecls(pass, os);
+ os << "};\n";
+}
+
static void emitPass(const Pass &pass, raw_ostream &os) {
StringRef passName = pass.getDef()->getName();
os << llvm::formatv(passHeader, passName);
emitPass(pass, os);
emitRegistrations(passes, os);
+
+ // TODO: Drop old pass declarations.
+ // Emit the old code until all the passes have switched to the new design.
+ os << "#ifdef GEN_PASS_CLASSES\n";
+ for (const Pass &pass : passes)
+ emitOldPassDecl(pass, os);
+ os << "#undef GEN_PASS_CLASSES\n";
+ os << "#endif // GEN_PASS_CLASSES\n";
}
static mlir::GenRegistration
/// dialects lowering to LLVM Dialect.
static LogicalResult lowerToLLVMDialect(ModuleOp module) {
PassManager pm(module.getContext());
- pm.addPass(mlir::createConvertMemRefToLLVMPass());
- pm.addNestedPass<func::FuncOp>(mlir::createConvertArithmeticToLLVMPass());
+ pm.addPass(mlir::createMemRefToLLVMPass());
+ pm.addNestedPass<func::FuncOp>(
+ mlir::arith::createConvertArithmeticToLLVMPass());
pm.addPass(mlir::createConvertFuncToLLVMPass());
pm.addPass(mlir::createReconcileUnrealizedCastsPass());
return pm.run(module);