The patch introduces the required changes to update the pass declarations and definitions to use the new autogenerated files and allow dropping the old infrastructure.
Reviewed By: mehdi_amini, rriddle
Differential Review: https://reviews.llvm.org/D132838
];
}
-def TargetRewrite : Pass<"target-rewrite", "mlir::ModuleOp"> {
+def TargetRewritePass : 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_FIRTOLLVMLOWERING
+#define GEN_PASS_DECL_CODEGENREWRITE
+#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_ABSTRACTRESULTONFUNCOPT
+#define GEN_PASS_DECL_ABSTRACTRESULTONGLOBALOPT
+#define GEN_PASS_DECL_AFFINEDIALECTPROMOTION
+#define GEN_PASS_DECL_AFFINEDIALECTDEMOTION
+#define GEN_PASS_DECL_ANNOTATECONSTANTOPERANDS
+#define GEN_PASS_DECL_ARRAYVALUECOPY
+#define GEN_PASS_DECL_CHARACTERCONVERSION
+#define GEN_PASS_DECL_CFGCONVERSION
+#define GEN_PASS_DECL_EXTERNALNAMECONVERSION
+#define GEN_PASS_DECL_MEMREFDATAFLOWOPT
+#define GEN_PASS_DECL_SIMPLIFYINTRINSICS
+#define GEN_PASS_DECL_MEMORYALLOCATIONOPT
+#define GEN_PASS_DECL_SIMPLIFYREGIONLITE
+#define GEN_PASS_DECL_ALGEBRAICSIMPLIFICATION
+#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 "PassDetail.h"
+#include "flang/Optimizer/CodeGen/CodeGen.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 BoxedProcedurePassBase<BoxedProcedurePass> {
+class BoxedProcedurePass
+ : public fir::impl::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_FIRTOLLVMLOWERING
+#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::FIRToLLVMLoweringBase<FIRToLLVMLowering> {
+class FIRToLLVMLowering
+ : public fir::impl::FIRToLLVMLoweringBase<FIRToLLVMLowering> {
public:
FIRToLLVMLowering() = default;
FIRToLLVMLowering(fir::FIRToLLVMPassOptions options) : options{options} {}
//
//===----------------------------------------------------------------------===//
-#include "CGOps.h"
-#include "PassDetail.h"
#include "flang/Optimizer/CodeGen/CodeGen.h"
+
+#include "CGOps.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_CODEGENREWRITE
+#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
+} // namespace fir
+
//===----------------------------------------------------------------------===//
// Codegen rewrite: rewriting of subgraphs of ops
//===----------------------------------------------------------------------===//
}
};
-class CodeGenRewrite : public fir::CodeGenRewriteBase<CodeGenRewrite> {
+class CodeGenRewrite : public fir::impl::CodeGenRewriteBase<CodeGenRewrite> {
public:
void runOn(mlir::Operation *op, mlir::Region ®ion) {
auto &context = getContext();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "flang/Optimizer/CodeGen/CodeGen.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::TargetRewriteBase<TargetRewrite> {
+class TargetRewrite : public fir::impl::TargetRewritePassBase<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_ABSTRACTRESULTONFUNCOPT
+#define GEN_PASS_DEF_ABSTRACTRESULTONGLOBALOPT
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
#define DEBUG_TYPE "flang-abstract-result-opt"
namespace fir {
class AbstractResultOnFuncOpt
: public AbstractResultOptTemplate<AbstractResultOnFuncOpt,
- fir::AbstractResultOnFuncOptBase> {
+ fir::impl::AbstractResultOnFuncOptBase> {
public:
void runOnSpecificOperation(mlir::func::FuncOp func, bool shouldBoxResult,
mlir::RewritePatternSet &patterns,
}
class AbstractResultOnGlobalOpt
- : public AbstractResultOptTemplate<AbstractResultOnGlobalOpt,
- fir::AbstractResultOnGlobalOptBase> {
+ : public AbstractResultOptTemplate<
+ AbstractResultOnGlobalOpt, fir::impl::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_AFFINEDIALECTDEMOTION
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
#define DEBUG_TYPE "flang-affine-demotion"
using namespace fir;
};
class AffineDialectDemotion
- : public AffineDialectDemotionBase<AffineDialectDemotion> {
+ : public
fir::impl::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_AFFINEDIALECTPROMOTION
+#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 AffineDialectPromotionBase<AffineDialectPromotion> {
+ : public
fir::impl::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_ALGEBRAICSIMPLIFICATION
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
using namespace mlir;
namespace {
struct AlgebraicSimplification
- : public fir::AlgebraicSimplificationBase<AlgebraicSimplification> {
+ : public fir::
impl::AlgebraicSimplificationBase<AlgebraicSimplification> {
AlgebraicSimplification(const GreedyRewriteConfig &rewriteConfig) {
config = rewriteConfig;
}
//
//===----------------------------------------------------------------------===//
-#include "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/IR/BuiltinAttributes.h"
+namespace fir {
+#define GEN_PASS_DEF_ANNOTATECONSTANTOPERANDS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
#define DEBUG_TYPE "flang-annotate-constant"
using namespace fir;
namespace {
struct AnnotateConstantOperands
- : AnnotateConstantOperandsBase<AnnotateConstantOperands> {
+ :
public impl::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_ARRAYVALUECOPY
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
#define DEBUG_TYPE "flang-array-value-copy"
using namespace fir;
};
class ArrayValueCopyConverter
- : public ArrayValueCopyBase<ArrayValueCopyConverter> {
+ : public
fir::impl::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_CHARACTERCONVERSION
+#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::CharacterConversionBase<CharacterConversion> {
+ : public fir::impl::CharacterConversionBase<CharacterConversion> {
public:
void runOnOperation() override {
CharacterConversionOptions clOpts{useRuntimeCalls.getValue()};
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "flang/Optimizer/Dialect/FIRDialect.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_EXTERNALNAMECONVERSION
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
using namespace mlir;
//===----------------------------------------------------------------------===//
};
class ExternalNameConversionPass
- : public fir::ExternalNameConversionBase<ExternalNameConversionPass> {
+ : public fir::impl::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_MEMREFDATAFLOWOPT
+#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::MemRefDataFlowOptBase<MemDataFlowOpt> {
+class MemDataFlowOpt : public fir::impl::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_MEMORYALLOCATIONOPT
+#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::MemoryAllocationOptBase<MemoryAllocationOpt> {
+ : public fir::impl::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_CFGCONVERSION
+#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 CFGConversionBase<CfgConversion> {
+class CfgConversion : public fir::impl::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_SIMPLIFYINTRINSICS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
#define DEBUG_TYPE "flang-simplify-intrinsics"
namespace {
class SimplifyIntrinsicsPass
- : public fir::SimplifyIntrinsicsBase<SimplifyIntrinsicsPass> {
+ : public fir::impl::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_SIMPLIFYREGIONLITE
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
namespace {
class SimplifyRegionLitePass
- : public fir::SimplifyRegionLiteBase<SimplifyRegionLitePass> {
+ : public fir::impl::SimplifyRegionLiteBase<SimplifyRegionLitePass> {
public:
void runOnOperation() override;
};
class RewritePatternSet;
class Pass;
+#define GEN_PASS_DECL_CONVERTAMDGPUTOROCDL
+#include "mlir/Conversion/Passes.h.inc"
+
void populateAMDGPUToROCDLConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns,
amdgpu::Chipset chipset);
class RewritePatternSet;
+#define GEN_PASS_DECL_CONVERTAFFINETOSTANDARD
+#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.
class RewritePatternSet;
class Pass;
+#define GEN_PASS_DECL_CONVERTARITHMETICTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+
namespace arith {
void populateArithmeticToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
class RewritePatternSet;
class Pass;
+#define GEN_PASS_DECL_CONVERTARITHMETICTOSPIRV
+#include "mlir/Conversion/Passes.h.inc"
+
namespace arith {
void populateArithmeticToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
RewritePatternSet &patterns);
#ifndef MLIR_CONVERSION_ARMNEON2DTOINTR_ARMNEON2DTOINTR_H_
#define MLIR_CONVERSION_ARMNEON2DTOINTR_ARMNEON2DTOINTR_H_
-#include "mlir/Pass/Pass.h"
+#include <memory>
namespace mlir {
+class Pass;
+class RewritePatternSet;
+
+#define GEN_PASS_DECL_CONVERTARMNEON2DTOINTR
+#include "mlir/Conversion/Passes.h.inc"
+
/// Populates patterns for the lowering of Arm NEON 2D ops to intrinsics.
/// See createConvertArmNeon2dToIntrPass.
void populateConvertArmNeon2dToIntrPatterns(RewritePatternSet &patterns);
class TypeConverter;
class RewritePatternSet;
+#define GEN_PASS_DECL_CONVERTASYNCTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+
/// Create a pass to convert Async operations to the LLVM dialect.
std::unique_ptr<OperationPass<ModuleOp>> createConvertAsyncToLLVMPass();
class Pass;
class RewritePatternSet;
+#define GEN_PASS_DECL_CONVERTBUFFERIZATIONTOMEMREF
+#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(
class Pass;
class RewritePatternSet;
+#define GEN_PASS_DECL_CONVERTCOMPLEXTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+
class ComplexStructBuilder : public StructBuilder {
public:
/// Construct a helper for the given complex number value.
template <typename T>
class OperationPass;
+#define GEN_PASS_DECL_CONVERTCOMPLEXTOLIBM
+#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_CONVERTCOMPLEXTOSTANDARD
+#include "mlir/Conversion/Passes.h.inc"
+
/// Populate the given list with patterns that convert from Complex to Standard.
void populateComplexToStandardConversionPatterns(RewritePatternSet &patterns);
class RewritePatternSet;
class Pass;
+#define GEN_PASS_DECL_CONVERTCONTROLFLOWTOLLVM
+#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
namespace mlir {
class ModuleOp;
+#define GEN_PASS_DECL_CONVERTCONTROLFLOWTOSPIRV
+#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_CONVERTFUNCTOLLVM
+#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_CONVERTFUNCTOSPIRV
+#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_GPUTOLLVMCONVERSIONPASS
+#include "mlir/Conversion/Passes.h.inc"
+
using OwnedBlob = std::unique_ptr<std::vector<char>>;
using BlobGenerator =
std::function<OwnedBlob(const std::string &, Location, StringRef)>;
class MMAMatrixType;
} // namespace gpu
+#define GEN_PASS_DECL_CONVERTGPUOPSTONVVMOPS
+#include "mlir/Conversion/Passes.h.inc"
+
LLVM::LLVMStructType convertMMAToLLVMType(gpu::MMAMatrixType type);
/// Configure target to convert from the GPU dialect to NVVM.
class GPUModuleOp;
} // namespace gpu
+#define GEN_PASS_DECL_CONVERTGPUOPSTOROCDLOPS
+#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
template <typename T>
class OperationPass;
+#define GEN_PASS_DECL_CONVERTGPUTOSPIRV
+#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_CONVERTVULKANLAUNCHFUNCTOVULKANCALLS
+#define GEN_PASS_DECL_CONVERTGPULAUNCHFUNCTOVULKANLAUNCHFUNC
+#include "mlir/Conversion/Passes.h.inc"
+
std::unique_ptr<OperationPass<ModuleOp>>
createConvertVulkanLaunchFuncToVulkanCallsPass();
class OperationPass;
class RewritePatternSet;
+#define GEN_PASS_DECL_CONVERTLINALGTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+
/// Populate the given list with patterns that convert from Linalg to LLVM.
void populateLinalgToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
namespace mlir {
class ModuleOp;
+#define GEN_PASS_DECL_CONVERTLINALGTOSPIRV
+#include "mlir/Conversion/Passes.h.inc"
+
/// Creates and returns a pass to convert Linalg ops to SPIR-V ops.
std::unique_ptr<OperationPass<ModuleOp>> createLinalgToSPIRVPass();
template <typename T>
class OperationPass;
+#define GEN_PASS_DECL_CONVERTLINALGTOSTANDARD
+#include "mlir/Conversion/Passes.h.inc"
+
namespace linalg {
//===----------------------------------------------------------------------===//
namespace mlir {
class Pass;
+#define GEN_PASS_DECL_CONVERTMATHTOFUNCS
+#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();
class RewritePatternSet;
class Pass;
+#define GEN_PASS_DECL_CONVERTMATHTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+
void populateMathToLLVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
template <typename T>
class OperationPass;
+#define GEN_PASS_DECL_CONVERTMATHTOLIBM
+#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_CONVERTMATHTOSPIRV
+#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_CONVERTMEMREFTOLLVM
+#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,
namespace mlir {
class ModuleOp;
+#define GEN_PASS_DECL_MAPMEMREFSTORAGECLASS
+#define GEN_PASS_DECL_CONVERTMEMREFTOSPIRV
+#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_CONVERTNVGPUTONVVM
+#include "mlir/Conversion/Passes.h.inc"
+
void populateNVGPUToNVVMConversionPatterns(LLVMTypeConverter &converter,
RewritePatternSet &patterns);
class OperationPass;
class RewritePatternSet;
+#define GEN_PASS_DECL_CONVERTOPENACCTOLLVM
+#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_CONVERTOPENACCTOSCF
+#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_CONVERTOOPENMPTOLLVM
+#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_CONVERTPDLTOPDLINTERP
+#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();
];
}
-
//===----------------------------------------------------------------------===//
// TensorToSPIRV
//===----------------------------------------------------------------------===//
class Pass;
class RewritePatternSet;
+#define GEN_PASS_DECL_RECONCILEUNREALIZEDCASTS
+#include "mlir/Conversion/Passes.h.inc"
+
/// Creates a pass that eliminates noop `unrealized_conversion_cast` operation
/// sequences.
std::unique_ptr<Pass> createReconcileUnrealizedCastsPass();
class Pass;
class RewritePatternSet;
+#define GEN_PASS_DECL_SCFTOCONTROLFLOW
+#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);
class InterfacePass;
class Pass;
+#define GEN_PASS_DECL_CONVERTAFFINEFORTOGPU
+#define GEN_PASS_DECL_CONVERTPARALLELLOOPTOGPU
+#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.
template <typename T>
class OperationPass;
+#define GEN_PASS_DECL_CONVERTSCFTOOPENMP
+#include "mlir/Conversion/Passes.h.inc"
+
std::unique_ptr<OperationPass<ModuleOp>> createConvertSCFToOpenMPPass();
} // namespace mlir
namespace mlir {
class ModuleOp;
+#define GEN_PASS_DECL_SCFTOSPIRV
+#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_LOWERHOSTCODETOLLVM
+#define GEN_PASS_DECL_CONVERTSPIRVTOLLVM
+#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_CONVERTSHAPECONSTRAINTS
+#define GEN_PASS_DECL_CONVERTSHAPETOSTANDARD
+#include "mlir/Conversion/Passes.h.inc"
+
void populateShapeToStandardConversionPatterns(RewritePatternSet &patterns);
std::unique_ptr<OperationPass<ModuleOp>> createConvertShapeToStandardPass();
namespace mlir {
class ModuleOp;
+#define GEN_PASS_DECL_CONVERTTENSORTOLINALG
+#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_CONVERTTENSORTOSPIRV
+#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_TOSATOARITH
+#include "mlir/Conversion/Passes.h.inc"
+
namespace tosa {
std::unique_ptr<Pass> createTosaToArith();
#include "mlir/Pass/Pass.h"
namespace mlir {
+
+#define GEN_PASS_DECL_TOSATOLINALG
+#define GEN_PASS_DECL_TOSATOLINALGNAMED
+#include "mlir/Conversion/Passes.h.inc"
+
namespace tosa {
std::unique_ptr<Pass> createTosaToLinalg();
#include "mlir/Pass/Pass.h"
namespace mlir {
+
+#define GEN_PASS_DECL_TOSATOSCF
+#include "mlir/Conversion/Passes.h.inc"
+
namespace tosa {
std::unique_ptr<Pass> createTosaToSCF();
#include "mlir/Pass/Pass.h"
namespace mlir {
+
+#define GEN_PASS_DECL_TOSATOTENSOR
+#include "mlir/Conversion/Passes.h.inc"
+
namespace tosa {
std::unique_ptr<Pass> createTosaToTensor();
class Pass;
class RewritePatternSet;
+#define GEN_PASS_DECL_CONVERTVECTORTOGPU
+#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_CONVERTVECTORTOLLVM
+#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_CONVERTVECTORTOSCF
+#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_VECTORTOSPIRVPASS
+#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_AFFINEDATACOPYGENERATION
+#define GEN_PASS_DECL_AFFINELOOPFUSION
+#define GEN_PASS_DECL_AFFINELOOPINVARIANTCODEMOTION
+#define GEN_PASS_DECL_AFFINELOOPTILING
+#define GEN_PASS_DECL_AFFINELOOPUNROLL
+#define GEN_PASS_DECL_AFFINELOOPUNROLLANDJAM
+#define GEN_PASS_DECL_AFFINEPIPELINEDATATRANSFER
+#define GEN_PASS_DECL_AFFINESCALARREPLACEMENT
+#define GEN_PASS_DECL_AFFINEVECTORIZE
+#define GEN_PASS_DECL_AFFINEPARALLELIZE
+#define GEN_PASS_DECL_AFFINELOOPNORMALIZE
+#define GEN_PASS_DECL_LOOPCOALESCING
+#define GEN_PASS_DECL_SIMPLIFYAFFINESTRUCTURES
+#define GEN_PASS_DECL_AFFINEEXPANDINDEXOPS
+#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.
namespace mlir {
namespace arith {
+#define GEN_PASS_DECL_ARITHMETICBUFFERIZE
+#define GEN_PASS_DECL_ARITHMETICEXPANDOPS
+#define GEN_PASS_DECL_ARITHMETICUNSIGNEDWHENEQUIVALENT
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+
/// Create a pass to bufferize Arithmetic ops.
std::unique_ptr<Pass> createArithmeticBufferizePass();
namespace mlir {
class ModuleOp;
+#define GEN_PASS_DECL_ASYNCPARALLELFOR
+#define GEN_PASS_DECL_ASYNCTOASYNCRUNTIME
+#define GEN_PASS_DECL_ASYNCRUNTIMEREFCOUNTING
+#define GEN_PASS_DECL_ASYNCRUNTIMEREFCOUNTINGOPT
+#define GEN_PASS_DECL_ASYNCRUNTIMEPOLICYBASEDREFCOUNTING
+#include "mlir/Dialect/Async/Passes.h.inc"
+
std::unique_ptr<Pass> createAsyncParallelForPass();
std::unique_ptr<Pass> createAsyncParallelForPass(bool asyncDispatch,
// Passes
//===----------------------------------------------------------------------===//
+#define GEN_PASS_DECL_BUFFERDEALLOCATION
+#define GEN_PASS_DECL_BUFFERHOISTING
+#define GEN_PASS_DECL_BUFFERLOOPHOISTING
+#define GEN_PASS_DECL_BUFFERRESULTSTOOUTPARAMS
+#define GEN_PASS_DECL_FINALIZINGBUFFERIZE
+#define GEN_PASS_DECL_BUFFERIZATIONBUFFERIZE
+#define GEN_PASS_DECL_DROPEQUIVALENTBUFFERRESULTS
+#define GEN_PASS_DECL_ONESHOTBUFFERIZE
+#define GEN_PASS_DECL_PROMOTEBUFFERSTOSTACK
+#define GEN_PASS_DECL_TENSORCOPYINSERTION
+#define GEN_PASS_DECL_ALLOCTENSORELIMINATION
+#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();
class RewritePatternSet;
namespace func {
+
+#define GEN_PASS_DECL_FUNCBUFFERIZE
+#include "mlir/Dialect/Func/Transforms/Passes.h.inc"
+
/// Creates an instance of func bufferization pass.
std::unique_ptr<Pass> createFuncBufferizePass();
class FuncOp;
} // namespace func
+#define GEN_PASS_DECL_GPULAUNCHSINKINDEXCOMPUTATIONS
+#define GEN_PASS_DECL_GPUKERNELOUTLINING
+#define GEN_PASS_DECL_GPUASYNCREGION
+#define GEN_PASS_DECL_GPUMAPPARALLELLOOPS
+#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();
namespace LLVM {
+#define GEN_PASS_DECL_LLVMLEGALIZEFOREXPORT
+#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_NVVMOPTIMIZEFORTARGET
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+
/// Creates a pass that optimizes LLVM IR for the NVVM target.
std::unique_ptr<Pass> createOptimizeForTargetPass();
class Pass;
namespace LLVM {
+
+#define GEN_PASS_DECL_LLVMREQUESTCWRAPPERS
+#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_CONVERTELEMENTWISETOLINALG
+#define GEN_PASS_DECL_LINALGINITTENSORTOALLOCTENSOR
+#define GEN_PASS_DECL_LINALGFOLDUNITEXTENTDIMS
+#define GEN_PASS_DECL_LINALGELEMENTWISEOPFUSION
+#define GEN_PASS_DECL_LINALGNAMEDOPCONVERSION
+#define GEN_PASS_DECL_LINALGINLINESCALAROPERANDS
+#define GEN_PASS_DECL_LINALGLOWERTOAFFINELOOPS
+#define GEN_PASS_DECL_LINALGLOWERTOLOOPSPASS
+#define GEN_PASS_DECL_LINALGLOWERTOPARALLELLOOPS
+#define GEN_PASS_DECL_LINALGBUFFERIZE
+#define GEN_PASS_DECL_LINALGTILINGPASS
+#define GEN_PASS_DECL_LINALGGENERALIZATION
+#define GEN_PASS_DECL_LINALGDETENSORIZE
+#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();
];
}
-def LinalgTiling : Pass<"linalg-tile", "func::FuncOp"> {
+def LinalgTilingPass : Pass<"linalg-tile", "func::FuncOp"> {
let summary = "Tile operations in the linalg dialect";
let constructor = "mlir::createLinalgTilingPass()";
let dependentDialects = [
// Passes
//===----------------------------------------------------------------------===//
+#define GEN_PASS_DECL_EXPANDOPS
+#define GEN_PASS_DECL_FOLDMEMREFALIASOPS
+#define GEN_PASS_DECL_NORMALIZEMEMREFS
+#define GEN_PASS_DECL_RESOLVERANKEDSHAPETYPERESULTDIMS
+#define GEN_PASS_DECL_RESOLVESHAPEDTYPERESULTDIMS
+#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`.
namespace mlir {
namespace nvgpu {
+#define GEN_PASS_DECL_OPTIMIZESHAREDMEMORY
+#include "mlir/Dialect/NVGPU/Passes.h.inc"
+
/// Create a pass to optimize shared memory reads and writes.
std::unique_ptr<Pass> createOptimizeSharedMemoryPass();
namespace mlir {
+#define GEN_PASS_DECL_SCFBUFFERIZE
+#define GEN_PASS_DECL_SCFFORLOOPCANONICALIZATION
+#define GEN_PASS_DECL_SCFFORLOOPPEELING
+#define GEN_PASS_DECL_SCFFORLOOPSPECIALIZATION
+#define GEN_PASS_DECL_SCFPARALLELLOOPFUSION
+#define GEN_PASS_DECL_SCFPARALLELLOOPCOLLAPSING
+#define GEN_PASS_DECL_SCFPARALLELLOOPSPECIALIZATION
+#define GEN_PASS_DECL_SCFPARALLELLOOPTILING
+#define GEN_PASS_DECL_SCFFORLOOPRANGEFOLDING
+#define GEN_PASS_DECL_SCFFORTOWHILELOOP
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+
/// Creates a pass that bufferizes the SCF dialect.
std::unique_ptr<Pass> createSCFBufferizePass();
// Passes
//===----------------------------------------------------------------------===//
+#define GEN_PASS_DECL_SPIRVCOMPOSITETYPELAYOUT
+#define GEN_PASS_DECL_SPIRVCANONICALIZEGL
+#define GEN_PASS_DECL_SPIRVLOWERABIATTRIBUTES
+#define GEN_PASS_DECL_SPIRVREWRITEINSERTSPASS
+#define GEN_PASS_DECL_SPIRVUNIFYALIASEDRESOURCEPASS
+#define GEN_PASS_DECL_SPIRVUPDATEVCE
+#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 SPIRVCompositeTypeLayout
- : Pass<"decorate-spirv-composite-type-layout", "ModuleOp"> {
+ : Pass<"decorate-spirv-composite-type-layout", "mlir::ModuleOp"> {
let summary = "Decorate SPIR-V composite type with layout info";
let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()";
}
} // namespace mlir
namespace mlir {
+
+#define GEN_PASS_DECL_SHAPETOSHAPELOWERING
+#define GEN_PASS_DECL_REMOVESHAPECONSTRAINTS
+#define GEN_PASS_DECL_SHAPEBUFFERIZE
+#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
struct OneShotBufferizationOptions;
} // namespace bufferization
+#define GEN_PASS_DECL_SPARSIFICATIONPASS
+#define GEN_PASS_DECL_SPARSETENSORCONVERSIONPASS
+#define GEN_PASS_DECL_SPARSETENSORCODEGEN
+#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
+
//===----------------------------------------------------------------------===//
// The Sparsification pass.
//===----------------------------------------------------------------------===//
include "mlir/Pass/PassBase.td"
-def Sparsification : Pass<"sparsification", "ModuleOp"> {
+def SparsificationPass : 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 SparseTensorConversion : Pass<"sparse-tensor-conversion", "ModuleOp"> {
+def SparseTensorConversionPass : 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
#include "mlir/Pass/Pass.h"
namespace mlir {
+
+#define GEN_PASS_DECL_TENSORBUFFERIZE
+#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
+
/// Creates an instance of `tensor` dialect bufferization pass.
std::unique_ptr<Pass> createTensorBufferizePass();
+++ /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_TOSALAYERWISECONSTANTFOLD
+#define GEN_PASS_DECL_TOSAINFERSHAPES
+#define GEN_PASS_DECL_TOSAMAKEBROADCASTABLE
+#define GEN_PASS_DECL_TOSAOPTIONALDECOMPOSITIONS
+#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);
class Pass;
namespace transform {
+#define GEN_PASS_DECL_CHECKUSES
+#include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
+
std::unique_ptr<Pass> createCheckUsesPass();
#define GEN_PASS_REGISTRATION
namespace mlir {
namespace vector {
+#define GEN_PASS_DECL_VECTORBUFFERIZE
+#include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
+
/// Creates an instance of the `vector` dialect bufferization pass.
std::unique_ptr<Pass> createVectorBufferizePass();
+++ /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_REDUCTIONTREE
+#define GEN_PASS_DECL_OPTREDUCTION
+#include "mlir/Reducer/Passes.h.inc"
+
std::unique_ptr<Pass> createReductionTreePass();
std::unique_ptr<Pass> createOptReductionPass();
class OpPrintingFlags;
class Pass;
+#define GEN_PASS_DECL_LOCATIONSNAPSHOT
+#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_CANONICALIZER
+#define GEN_PASS_DECL_CONTROLFLOWSINK
+#define GEN_PASS_DECL_CSEPASS
+#define GEN_PASS_DECL_LOOPINVARIANTCODEMOTION
+#define GEN_PASS_DECL_STRIPDEBUGINFO
+#define GEN_PASS_DECL_PRINTOPSTATS
+#define GEN_PASS_DECL_INLINER
+#define GEN_PASS_DECL_SCCP
+#define GEN_PASS_DECL_SYMBOLDCE
+#define GEN_PASS_DECL_SYMBOLPRIVATIZE
+#define GEN_PASS_DECL_TOPOLOGICALSORT
+#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();
namespace mlir {
class Pass;
+#define GEN_PASS_DECL_VIEWOPGRAPH
+#include "mlir/Transforms/Passes.h.inc"
+
/// Creates a pass to print op graphs.
std::unique_ptr<Pass> createPrintOpGraphPass(raw_ostream &os = llvm::errs());
//===----------------------------------------------------------------------===//
#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_CONVERTAMDGPUTOROCDL
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
using namespace mlir::amdgpu;
};
struct ConvertAMDGPUToROCDLPass
- : public ConvertAMDGPUToROCDLBase<ConvertAMDGPUToROCDLPass> {
+ : public impl::ConvertAMDGPUToROCDLBase<ConvertAMDGPUToROCDLPass> {
ConvertAMDGPUToROCDLPass() = default;
void runOnOperation() override {
#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_CONVERTAFFINETOSTANDARD
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::vector;
}
namespace {
-class LowerAffinePass : public ConvertAffineToStandardBase<LowerAffinePass> {
+class LowerAffinePass
+ : public impl::ConvertAffineToStandardBase<LowerAffinePass> {
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns);
//===----------------------------------------------------------------------===//
#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_CONVERTARITHMETICTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
struct ConvertArithmeticToLLVMPass
- : public ConvertArithmeticToLLVMBase<ConvertArithmeticToLLVMPass> {
+ : public impl::ConvertArithmeticToLLVMBase<ConvertArithmeticToLLVMPass> {
ConvertArithmeticToLLVMPass() = default;
void runOnOperation() override {
//===----------------------------------------------------------------------===//
#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_CONVERTARITHMETICTOSPIRV
+#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 ConvertArithmeticToSPIRVBase<ConvertArithmeticToSPIRVPass> {
+ : public impl::ConvertArithmeticToSPIRVBase<ConvertArithmeticToSPIRVPass> {
void runOnOperation() override {
Operation *op = getOperation();
auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
//===----------------------------------------------------------------------===//
#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_CONVERTARMNEON2DTOINTR
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::arm_neon;
};
class ConvertArmNeon2dToIntr
- : public ConvertArmNeon2dToIntrBase<ConvertArmNeon2dToIntr> {
+ : public impl::ConvertArmNeon2dToIntrBase<ConvertArmNeon2dToIntr> {
void runOnOperation() override {
auto *context = &getContext();
#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_CONVERTASYNCTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "convert-async-to-llvm"
using namespace mlir;
namespace {
struct ConvertAsyncToLLVMPass
- : public ConvertAsyncToLLVMBase<ConvertAsyncToLLVMPass> {
+ : public impl::ConvertAsyncToLLVMBase<ConvertAsyncToLLVMPass> {
void runOnOperation() override;
};
} // namespace
//===----------------------------------------------------------------------===//
#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_CONVERTBUFFERIZATIONTOMEMREF
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
namespace {
struct BufferizationToMemRefPass
- : public ConvertBufferizationToMemRefBase<BufferizationToMemRefPass> {
+ : public impl::ConvertBufferizationToMemRefBase<BufferizationToMemRefPass> {
BufferizationToMemRefPass() = default;
void runOnOperation() override {
#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_CONVERTCOMPLEXTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
using namespace mlir::LLVM;
namespace {
struct ConvertComplexToLLVMPass
- : public ConvertComplexToLLVMBase<ConvertComplexToLLVMPass> {
+ : public impl::ConvertComplexToLLVMBase<ConvertComplexToLLVMPass> {
void runOnOperation() override;
};
} // namespace
#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_CONVERTCOMPLEXTOLIBM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
struct ConvertComplexToLibmPass
- : public ConvertComplexToLibmBase<ConvertComplexToLibmPass> {
+ : public impl::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_CONVERTCOMPLEXTOSTANDARD
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
struct ConvertComplexToStandardPass
- : public ConvertComplexToStandardBase<ConvertComplexToStandardPass> {
+ : public impl::ConvertComplexToStandardBase<ConvertComplexToStandardPass> {
void runOnOperation() override;
};
//===----------------------------------------------------------------------===//
#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_CONVERTCONTROLFLOWTOLLVM
+#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 ConvertControlFlowToLLVM
- : public ConvertControlFlowToLLVMBase<ConvertControlFlowToLLVM> {
+ : public impl::ConvertControlFlowToLLVMBase<ConvertControlFlowToLLVM> {
ConvertControlFlowToLLVM() = default;
/// Run the dialect converter on the module.
//===----------------------------------------------------------------------===//
#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_CONVERTCONTROLFLOWTOSPIRV
+#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 ConvertControlFlowToSPIRVBase<ConvertControlFlowToSPIRVPass> {
+ : public impl::ConvertControlFlowToSPIRVBase<
+ ConvertControlFlowToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "../PassDetail.h"
+#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.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_CONVERTFUNCTOLLVM
+#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 ConvertFuncToLLVMBase<ConvertFuncToLLVMPass> {
+ : public impl::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_CONVERTFUNCTOSPIRV
+#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 ConvertFuncToSPIRVBase<ConvertFuncToSPIRVPass> {
+ : public impl::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_GPUTOLLVMCONVERSIONPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
static constexpr const char *kGpuBinaryStorageSuffix = "_gpubin_cst";
namespace {
class GpuToLLVMConversionPass
- : public GpuToLLVMConversionPassBase<GpuToLLVMConversionPass> {
+ : public impl::GpuToLLVMConversionPassBase<GpuToLLVMConversionPass> {
public:
GpuToLLVMConversionPass() = default;
#include "../GPUCommon/GPUOpsLowering.h"
#include "../GPUCommon/IndexIntrinsicsOpLowering.h"
#include "../GPUCommon/OpToFuncCallLowering.h"
-#include "../PassDetail.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTGPUOPSTONVVMOPS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
/// This pass only handles device code and is not meant to be run on GPU host
/// code.
struct LowerGpuOpsToNVVMOpsPass
- : public ConvertGpuOpsToNVVMOpsBase<LowerGpuOpsToNVVMOpsPass> {
+ : public impl::ConvertGpuOpsToNVVMOpsBase<LowerGpuOpsToNVVMOpsPass> {
LowerGpuOpsToNVVMOpsPass() = default;
LowerGpuOpsToNVVMOpsPass(unsigned indexBitwidth) {
this->indexBitwidth = indexBitwidth;
#include "../GPUCommon/GPUOpsLowering.h"
#include "../GPUCommon/IndexIntrinsicsOpLowering.h"
#include "../GPUCommon/OpToFuncCallLowering.h"
-#include "../PassDetail.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTGPUOPSTOROCDLOPS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
// This pass only handles device code and is not meant to be run on GPU host
// code.
struct LowerGpuOpsToROCDLOpsPass
- : public ConvertGpuOpsToROCDLOpsBase<LowerGpuOpsToROCDLOpsPass> {
+ : public impl::ConvertGpuOpsToROCDLOpsBase<LowerGpuOpsToROCDLOpsPass> {
LowerGpuOpsToROCDLOpsPass() = default;
LowerGpuOpsToROCDLOpsPass(const std::string &chipset, unsigned indexBitwidth,
bool useBarePtrCallConv,
#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_CONVERTGPUTOSPIRV
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
/// replace it).
///
/// 2) Lower the body of the spirv::ModuleOp.
-class GPUToSPIRVPass : public ConvertGPUToSPIRVBase<GPUToSPIRVPass> {
+class GPUToSPIRVPass : public impl::ConvertGPUToSPIRVBase<GPUToSPIRVPass> {
public:
explicit GPUToSPIRVPass(bool mapMemorySpace)
: mapMemorySpace(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_CONVERTGPULAUNCHFUNCTOVULKANLAUNCHFUNC
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
static constexpr const char *kSPIRVBlobAttrName = "spirv_blob";
/// function and attaching binary data and entry point name as an attributes to
/// created vulkan launch call op.
class ConvertGpuLaunchFuncToVulkanLaunchFunc
- : public ConvertGpuLaunchFuncToVulkanLaunchFuncBase<
+ : public impl::ConvertGpuLaunchFuncToVulkanLaunchFuncBase<
ConvertGpuLaunchFuncToVulkanLaunchFunc> {
public:
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#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_CONVERTVULKANLAUNCHFUNCTOVULKANCALLS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
static constexpr const char *kCInterfaceVulkanLaunch =
/// * deinitVulkan -- deinitializes vulkan runtime
///
class VulkanLaunchFuncToVulkanCallsPass
- : public ConvertVulkanLaunchFuncToVulkanCallsBase<
+ : public impl::ConvertVulkanLaunchFuncToVulkanCallsBase<
VulkanLaunchFuncToVulkanCallsPass> {
private:
void initializeCachedTypes() {
#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_CONVERTLINALGTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::LLVM;
using namespace mlir::linalg;
namespace {
struct ConvertLinalgToLLVMPass
- : public ConvertLinalgToLLVMBase<ConvertLinalgToLLVMPass> {
+ : public impl::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_CONVERTLINALGTOSPIRV
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
/// A pass converting MLIR Linalg ops into SPIR-V ops.
-class LinalgToSPIRVPass : public ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> {
+class LinalgToSPIRVPass
+ : public impl::ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
#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_CONVERTLINALGTOSTANDARD
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
using namespace mlir::linalg;
namespace {
struct ConvertLinalgToStandardPass
- : public ConvertLinalgToStandardBase<ConvertLinalgToStandardPass> {
+ : public impl::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_CONVERTMATHTOFUNCS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
namespace {
struct ConvertMathToFuncsPass
- : public ConvertMathToFuncsBase<ConvertMathToFuncsPass> {
+ : public impl::ConvertMathToFuncsBase<ConvertMathToFuncsPass> {
ConvertMathToFuncsPass() = default;
void runOnOperation() override;
//===----------------------------------------------------------------------===//
#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_CONVERTMATHTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
};
struct ConvertMathToLLVMPass
- : public ConvertMathToLLVMBase<ConvertMathToLLVMPass> {
+ : public impl::ConvertMathToLLVMBase<ConvertMathToLLVMPass> {
ConvertMathToLLVMPass() = default;
void runOnOperation() override {
#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_CONVERTMATHTOLIBM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
struct ConvertMathToLibmPass
- : public ConvertMathToLibmBase<ConvertMathToLibmPass> {
+ : public impl::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_CONVERTMATHTOSPIRV
+#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 ConvertMathToSPIRVBase<ConvertMathToSPIRVPass> {
+ : public impl::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_CONVERTMEMREFTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
}
namespace {
-struct MemRefToLLVMPass : public ConvertMemRefToLLVMBase<MemRefToLLVMPass> {
+struct MemRefToLLVMPass
+ : public impl::ConvertMemRefToLLVMBase<MemRefToLLVMPass> {
MemRefToLLVMPass() = default;
void runOnOperation() override {
//
//===----------------------------------------------------------------------===//
-#include "../PassDetail.h"
-#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
+
+#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.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_MAPMEMREFSTORAGECLASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "mlir-map-memref-storage-class"
using namespace mlir;
namespace {
class MapMemRefStorageClassPass final
- : public MapMemRefStorageClassBase<MapMemRefStorageClassPass> {
+ : public impl::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_CONVERTMEMREFTOSPIRV
+#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 ConvertMemRefToSPIRVBase<ConvertMemRefToSPIRVPass> {
+ : public impl::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_CONVERTNVGPUTONVVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
};
struct ConvertNVGPUToNVVMPass
- : public ConvertNVGPUToNVVMBase<ConvertNVGPUToNVVMPass> {
+ : public impl::ConvertNVGPUToNVVMBase<ConvertNVGPUToNVVMPass> {
ConvertNVGPUToNVVMPass() = default;
void runOnOperation() override {
//
//===----------------------------------------------------------------------===//
-#include "../PassDetail.h"
-#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
+
+#include "mlir/Conversion/LLVMCommon/Pattern.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_CONVERTOPENACCTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
struct ConvertOpenACCToLLVMPass
- : public ConvertOpenACCToLLVMBase<ConvertOpenACCToLLVMPass> {
+ : public impl::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_CONVERTOPENACCTOSCF
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
//===----------------------------------------------------------------------===//
namespace {
struct ConvertOpenACCToSCFPass
- : public ConvertOpenACCToSCFBase<ConvertOpenACCToSCFPass> {
+ : public impl::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_CONVERTOPENMPTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
struct ConvertOpenMPToLLVMPass
- : public ConvertOpenMPToLLVMBase<ConvertOpenMPToLLVMPass> {
+ : public impl::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_CONVERTPDLTOPDLINTERP
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::pdl_to_pdl_interp;
namespace {
struct PDLToPDLInterpPass
- : public ConvertPDLToPDLInterpBase<PDLToPDLInterpPass> {
+ : public
impl::ConvertPDLToPDLInterpBase<PDLToPDLInterpPass> {
void runOnOperation() final;
};
} // namespace
+++ /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_RECONCILEUNREALIZEDCASTS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
/// Pass to simplify and eliminate unrealized conversion casts.
struct ReconcileUnrealizedCasts
- : public ReconcileUnrealizedCastsBase<ReconcileUnrealizedCasts> {
+ : public impl::ReconcileUnrealizedCastsBase<ReconcileUnrealizedCasts> {
ReconcileUnrealizedCasts() = default;
void runOnOperation() override {
//===----------------------------------------------------------------------===//
#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_SCFTOCONTROLFLOW
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::scf;
namespace {
struct SCFToControlFlowPass
- : public SCFToControlFlowBase<SCFToControlFlowPass> {
+ : public impl::SCFToControlFlowBase<SCFToControlFlowPass> {
void runOnOperation() override;
};
//===----------------------------------------------------------------------===//
#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_CONVERTAFFINEFORTOGPU
+#define GEN_PASS_DEF_CONVERTPARALLELLOOPTOGPU
+#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 ConvertAffineForToGPUBase<ForLoopMapper> {
+struct ForLoopMapper : public impl::ConvertAffineForToGPUBase<ForLoopMapper> {
ForLoopMapper() = default;
ForLoopMapper(unsigned numBlockDims, unsigned numThreadDims) {
this->numBlockDims = numBlockDims;
};
struct ParallelLoopToGpuPass
- : public ConvertParallelLoopToGpuBase<ParallelLoopToGpuPass> {
+ : public
impl::ConvertParallelLoopToGpuBase<ParallelLoopToGpuPass> {
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
populateParallelLoopToGPUPatterns(patterns);
//===----------------------------------------------------------------------===//
#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_CONVERTSCFTOOPENMP
+#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 SCFToOpenMPPass : public ConvertSCFToOpenMPBase<SCFToOpenMPPass> {
+struct SCFToOpenMPPass : public impl::ConvertSCFToOpenMPBase<SCFToOpenMPPass> {
/// Pass entry point.
void runOnOperation() override {
if (failed(applyPatterns(getOperation())))
#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_SCFTOSPIRV
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
-struct SCFToSPIRVPass : public SCFToSPIRVBase<SCFToSPIRVPass> {
+struct SCFToSPIRVPass : public impl::SCFToSPIRVBase<SCFToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "../PassDetail.h"
+#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.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_LOWERHOSTCODETOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
static constexpr const char kSPIRVModule[] = "__spv__";
};
class LowerHostCodeToLLVM
- : public LowerHostCodeToLLVMBase<LowerHostCodeToLLVM> {
+ : public impl::LowerHostCodeToLLVMBase<LowerHostCodeToLLVM> {
public:
void runOnOperation() override {
ModuleOp module = getOperation();
//===----------------------------------------------------------------------===//
#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_CONVERTSPIRVTOLLVM
+#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 ConvertSPIRVToLLVMBase<ConvertSPIRVToLLVMPass> {
+ : public impl::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_CONVERTSHAPECONSTRAINTS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
+
namespace {
#include "ShapeToStandard.cpp.inc"
} // namespace
// is emitted, witnesses are satisfied, so they are replace with
// `shape.const_witness true`.
class ConvertShapeConstraints
- : public ConvertShapeConstraintsBase<ConvertShapeConstraints> {
+ : public impl::ConvertShapeConstraintsBase<ConvertShapeConstraints> {
void runOnOperation() override {
auto *func = getOperation();
auto *context = &getContext();
#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_CONVERTSHAPETOSTANDARD
+#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 ConvertShapeToStandardBase<ConvertShapeToStandardPass> {
+ : public impl::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_CONVERTTENSORTOLINALG
+#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 ConvertTensorToLinalgBase<ConvertTensorToLinalgPass> {
+ : public impl::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_CONVERTTENSORTOSPIRV
+#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 ConvertTensorToSPIRVBase<ConvertTensorToSPIRVPass> {
+ : public impl::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_TOSATOARITH
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace tosa;
namespace {
-struct TosaToArith : public TosaToArithBase<TosaToArith> {
+struct TosaToArith : public impl::TosaToArithBase<TosaToArith> {
public:
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
//
//===----------------------------------------------------------------------===//
-#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_TOSATOLINALGNAMED
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
-struct TosaToLinalgNamed : public TosaToLinalgNamedBase<TosaToLinalgNamed> {
+struct TosaToLinalgNamed
+ : public impl::TosaToLinalgNamedBase<TosaToLinalgNamed> {
public:
void getDependentDialects(DialectRegistry ®istry) const override {
registry
//
//===----------------------------------------------------------------------===//
-#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_TOSATOLINALG
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
-struct TosaToLinalg : public TosaToLinalgBase<TosaToLinalg> {
+struct TosaToLinalg : public impl::TosaToLinalgBase<TosaToLinalg> {
public:
void getDependentDialects(DialectRegistry ®istry) const override {
registry
//
//===----------------------------------------------------------------------===//
-#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_TOSATOSCF
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace tosa;
namespace {
-struct TosaToSCF : public TosaToSCFBase<TosaToSCF> {
+struct TosaToSCF : public impl::TosaToSCFBase<TosaToSCF> {
public:
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
//
//===----------------------------------------------------------------------===//
-#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_TOSATOTENSOR
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace tosa;
namespace {
-struct TosaToTensor : public TosaToTensorBase<TosaToTensor> {
+struct TosaToTensor : public impl::TosaToTensorBase<TosaToTensor> {
public:
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
#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_CONVERTVECTORTOGPU
+#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 ConvertVectorToGPUBase<ConvertVectorToGPUPass> {
+ : public impl::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_CONVERTVECTORTOLLVM
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::vector;
namespace {
struct LowerVectorToLLVMPass
- : public ConvertVectorToLLVMBase<LowerVectorToLLVMPass> {
+ : public impl::ConvertVectorToLLVMBase<LowerVectorToLLVMPass> {
LowerVectorToLLVMPass(const LowerVectorToLLVMOptions &options) {
this->reassociateFPReductions = options.reassociateFPReductions;
this->force32BitVectorIndices = options.force32BitVectorIndices;
#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_CONVERTVECTORTOSCF
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using vector::TransferReadOp;
using vector::TransferWriteOp;
namespace {
struct ConvertVectorToSCFPass
- : public ConvertVectorToSCFBase<ConvertVectorToSCFPass> {
+ : public impl::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_CONVERTVECTORTOSPIRV
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
struct ConvertVectorToSPIRVPass
- : public ConvertVectorToSPIRVBase<ConvertVectorToSPIRVPass> {
+ : public impl::ConvertVectorToSPIRVBase<ConvertVectorToSPIRVPass> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_AFFINEDATACOPYGENERATION
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "affine-data-copy-generate"
using namespace mlir;
// TODO: We currently can't generate copies correctly when stores
// are strided. Check for strided stores.
struct AffineDataCopyGeneration
- : public AffineDataCopyGenerationBase<AffineDataCopyGeneration> {
+ : public
impl::AffineDataCopyGenerationBase<AffineDataCopyGeneration> {
AffineDataCopyGeneration() = default;
explicit AffineDataCopyGeneration(unsigned slowMemorySpace,
unsigned fastMemorySpace,
// fundamental operations.
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Passes.h"
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Utils.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+namespace mlir {
+#define GEN_PASS_DEF_AFFINEEXPANDINDEXOPS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
};
class ExpandAffineIndexOpsPass
- : public AffineExpandIndexOpsBase<ExpandAffineIndexOpsPass> {
+ : public impl::AffineExpandIndexOpsBase<ExpandAffineIndexOpsPass> {
public:
ExpandAffineIndexOpsPass() = default;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_AFFINELOOPINVARIANTCODEMOTION
+#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 AffineLoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
+ : public impl::AffineLoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
void runOnOperation() override;
void runOnAffineForOp(AffineForOp forOp);
};
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Passes.h"
+
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPNORMALIZE
+#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 AffineLoopNormalizeBase<AffineLoopNormalizePass> {
+ : public
impl::AffineLoopNormalizeBase<AffineLoopNormalizePass> {
void runOnOperation() override {
getOperation().walk([](Operation *op) {
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_AFFINEPARALLELIZE
+#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 AffineParallelizeBase<AffineParallelize> {
+struct AffineParallelize
+ : public impl::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_AFFINESCALARREPLACEMENT
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "affine-scalrep"
using namespace mlir;
namespace {
struct AffineScalarReplacement
- : public AffineScalarReplacementBase<AffineScalarReplacement> {
+ : public
impl::AffineScalarReplacementBase<AffineScalarReplacement> {
void runOnOperation() override;
};
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_LOOPCOALESCING
+#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 LoopCoalescingBase<LoopCoalescingPass> {
+struct LoopCoalescingPass
+ : public impl::LoopCoalescingBase<LoopCoalescingPass> {
/// Walk either an scf.for or an affine.for to find a band to coalesce.
template <typename LoopOpTy>
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_AFFINELOOPFUSION
+#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 AffineLoopFusionBase<LoopFusion> {
+struct LoopFusion : public impl::AffineLoopFusionBase<LoopFusion> {
LoopFusion() = default;
LoopFusion(unsigned fastMemorySpace, uint64_t localBufSizeThresholdBytes,
bool maximalFusion, enum FusionMode affineFusionMode) {
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_AFFINELOOPTILING
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
#define DEBUG_TYPE "affine-loop-tile"
namespace {
/// A pass to perform loop tiling on all suitable loop nests of a Function.
-struct LoopTiling : public AffineLoopTilingBase<LoopTiling> {
+struct LoopTiling : public impl::AffineLoopTilingBase<LoopTiling> {
LoopTiling() = default;
explicit LoopTiling(uint64_t cacheSizeBytes, bool avoidMaxMinBounds = true)
: avoidMaxMinBounds(avoidMaxMinBounds) {
// This file implements loop unrolling.
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+
+#include "mlir/Dialect/Affine/Passes.h"
+
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Affine/Passes.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/CommandLine.h"
#include "llvm/Support/Debug.h"
-using namespace mlir;
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPUNROLL
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // 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 AffineLoopUnrollBase<LoopUnroll> {
+struct LoopUnroll : public impl::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 "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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/Affine/Passes.h"
+#include "mlir/Dialect/Func/IR/FuncOps.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"
-using namespace mlir;
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPUNROLLANDJAM
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // 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 AffineLoopUnrollAndJamBase<LoopUnrollAndJam> {
+struct LoopUnrollAndJam
+ : public impl::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 "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_AFFINEPIPELINEDATATRANSFER
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "affine-pipeline-data-transfer"
using namespace mlir;
namespace {
struct PipelineDataTransfer
- : public AffinePipelineDataTransferBase<PipelineDataTransfer> {
+ : public
impl::AffinePipelineDataTransferBase<PipelineDataTransfer> {
void runOnOperation() override;
void runOnAffineForOp(AffineForOp forOp);
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_SIMPLIFYAFFINESTRUCTURES
+#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 SimplifyAffineStructuresBase<SimplifyAffineStructures> {
+ : public impl::SimplifyAffineStructuresBase<SimplifyAffineStructures> {
void runOnOperation() override;
/// Utility to simplify an affine attribute and update its entry in the parent
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.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_AFFINEVECTORIZE
+#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 AffineVectorizeBase<Vectorize> {
+struct Vectorize : public impl::AffineVectorizeBase<Vectorize> {
Vectorize() = default;
Vectorize(ArrayRef<int64_t> virtualVectorSize);
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.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_ARITHMETICBUFFERIZE
+#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 ArithmeticBufferizeBase<ArithmeticBufferizePass> {
+ : public
arith::impl::ArithmeticBufferizeBase<ArithmeticBufferizePass> {
ArithmeticBufferizePass(uint64_t alignment = 0, bool constantOpOnly = false)
: constantOpOnly(constantOpOnly) {
this->alignment = alignment;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+
+#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
#include "mlir/IR/TypeUtilities.h"
#include "mlir/Transforms/DialectConversion.h"
+namespace mlir {
+namespace arith {
+#define GEN_PASS_DEF_ARITHMETICEXPANDOPS
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+} // namespace arith
+} // namespace mlir
+
using namespace mlir;
/// Create an integer or index constant.
};
struct ArithmeticExpandOpsPass
- : public ArithmeticExpandOpsBase<ArithmeticExpandOpsPass> {
+ : public
arith::impl::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 "PassDetail.h"
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.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_ARITHMETICUNSIGNEDWHENEQUIVALENT
+#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 ArithmeticUnsignedWhenEquivalentBase<
+ : public arith::impl::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 <utility>
+#include "mlir/Dialect/Async/Passes.h"
#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_ASYNCPARALLELFOR
+#include "mlir/Dialect/Async/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
using namespace mlir::async;
// }
//
struct AsyncParallelForPass
- : public AsyncParallelForBase<AsyncParallelForPass> {
+ : public
impl::AsyncParallelForBase<AsyncParallelForPass> {
AsyncParallelForPass() = default;
AsyncParallelForPass(bool asyncDispatch, int32_t numWorkerThreads,
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Async/Passes.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"
-using namespace mlir;
-using namespace mlir::async;
+namespace mlir {
+#define GEN_PASS_DEF_ASYNCRUNTIMEREFCOUNTING
+#define GEN_PASS_DEF_ASYNCRUNTIMEPOLICYBASEDREFCOUNTING
+#include "mlir/Dialect/Async/Passes.h.inc"
+} // namespace mlir
#define DEBUG_TYPE "async-runtime-ref-counting"
+using namespace mlir;
+using namespace mlir::async;
+
//===----------------------------------------------------------------------===//
// Utility functions shared by reference counting passes.
//===----------------------------------------------------------------------===//
namespace {
class AsyncRuntimeRefCountingPass
- : public AsyncRuntimeRefCountingBase<AsyncRuntimeRefCountingPass> {
+ : public
impl::AsyncRuntimeRefCountingBase<AsyncRuntimeRefCountingPass> {
public:
AsyncRuntimeRefCountingPass() = default;
void runOnOperation() override;
namespace {
class AsyncRuntimePolicyBasedRefCountingPass
- : public AsyncRuntimePolicyBasedRefCountingBase<
+ : public impl::AsyncRuntimePolicyBasedRefCountingBase<
AsyncRuntimePolicyBasedRefCountingPass> {
public:
AsyncRuntimePolicyBasedRefCountingPass() { initializeDefaultPolicy(); }
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
-#include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Async/Passes.h"
+
+#include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/Support/Debug.h"
-using namespace mlir;
-using namespace mlir::async;
+namespace mlir {
+#define GEN_PASS_DEF_ASYNCRUNTIMEREFCOUNTINGOPT
+#include "mlir/Dialect/Async/Passes.h.inc"
+} // namespace mlir
#define DEBUG_TYPE "async-ref-counting"
+using namespace mlir;
+using namespace mlir::async;
+
namespace {
class AsyncRuntimeRefCountingOptPass
- : public AsyncRuntimeRefCountingOptBase<AsyncRuntimeRefCountingOptPass> {
+ : public impl::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_ASYNCTOASYNCRUNTIME
+#include "mlir/Dialect/Async/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::async;
namespace {
class AsyncToAsyncRuntimePass
- : public AsyncToAsyncRuntimeBase<AsyncToAsyncRuntimePass> {
+ : public
impl::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 "PassDetail.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.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_ALLOCTENSORELIMINATION
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::bufferization;
namespace {
struct AllocTensorElimination
- : public AllocTensorEliminationBase<AllocTensorElimination> {
+ : public bufferization::impl::AllocTensorEliminationBase<
+ AllocTensorElimination> {
AllocTensorElimination() = default;
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.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/Bufferization/Transforms/Passes.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "llvm/ADT/SetOperations.h"
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_BUFFERDEALLOCATION
+#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 : BufferDeallocationBase<BufferDeallocationPass> {
+struct BufferDeallocationPass
+ : public bufferization::impl::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 "PassDetail.h"
-#include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+
+#include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.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_BUFFERHOISTING
+#define GEN_PASS_DEF_BUFFERLOOPHOISTING
+#define GEN_PASS_DEF_PROMOTEBUFFERSTOSTACK
+#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 : BufferHoistingBase<BufferHoistingPass> {
+struct BufferHoistingPass
+ : public bufferization::impl::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 : BufferLoopHoistingBase<BufferLoopHoistingPass> {
+struct BufferLoopHoistingPass
+ : public bufferization::impl::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 PromoteBuffersToStackBase<PromoteBuffersToStackPass> {
+ : public bufferization::impl::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_BUFFERRESULTSTOOUTPARAMS
+#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
- : BufferResultsToOutParamsBase<BufferResultsToOutParamsPass> {
+ : bufferization::impl::BufferResultsToOutParamsBase<
+ BufferResultsToOutParamsPass> {
void runOnOperation() override {
if (failed(bufferization::promoteBufferResultsToOutParams(getOperation())))
return signalPassFailure();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Bufferization/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/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_FINALIZINGBUFFERIZE
+#define GEN_PASS_DEF_BUFFERIZATIONBUFFERIZE
+#define GEN_PASS_DEF_ONESHOTBUFFERIZE
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::bufferization;
namespace {
struct FinalizingBufferizePass
- : public FinalizingBufferizeBase<FinalizingBufferizePass> {
+ : public bufferization::impl::FinalizingBufferizeBase<
+ FinalizingBufferizePass> {
using FinalizingBufferizeBase<
FinalizingBufferizePass>::FinalizingBufferizeBase;
}
struct OneShotBufferizePass
- : public OneShotBufferizeBase<OneShotBufferizePass> {
+ : public bufferization::impl::OneShotBufferizeBase<OneShotBufferizePass> {
OneShotBufferizePass() {}
explicit OneShotBufferizePass(const OneShotBufferizationOptions &options)
namespace {
struct BufferizationBufferizePass
- : public BufferizationBufferizeBase<BufferizationBufferizePass> {
+ : public bufferization::impl::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_DROPEQUIVALENTBUFFERRESULTS
+#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
- : DropEquivalentBufferResultsBase<DropEquivalentBufferResultsPass> {
+ : bufferization::impl::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/TensorCopyInsertion.h"
-
-#include "PassDetail.h"
+#include "mlir/Dialect/Bufferization/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/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"
+
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_TENSORCOPYINSERTION
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
using namespace mlir;
using namespace mlir::bufferization;
namespace {
struct TensorCopyInsertionPass
- : TensorCopyInsertionBase<TensorCopyInsertionPass> {
+ : public bufferization::impl::TensorCopyInsertionBase<
+ TensorCopyInsertionPass> {
TensorCopyInsertionPass() : options(llvm::None) {}
TensorCopyInsertionPass(const OneShotBufferizationOptions &options)
: options(options) {}
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Func/Transforms/Passes.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_FUNCBUFFERIZE
+#include "mlir/Dialect/Func/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::func;
namespace {
-struct FuncBufferizePass : public FuncBufferizeBase<FuncBufferizePass> {
+struct FuncBufferizePass : public impl::FuncBufferizeBase<FuncBufferizePass> {
using FuncBufferizeBase<FuncBufferizePass>::FuncBufferizeBase;
void runOnOperation() override {
auto module = getOperation();
+++ /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 "PassDetail.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.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 GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
+class GpuAsyncRegionPass
+ : public impl::GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
struct ThreadTokenCallback;
struct DeferWaitCallback;
struct SingleTokenUseCallback;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.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_GPULAUNCHSINKINDEXCOMPUTATIONS
+#define GEN_PASS_DEF_GPUKERNELOUTLINING
+#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 GpuLaunchSinkIndexComputationsBase<
+ : public impl::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 GpuKernelOutliningBase<GpuKernelOutliningPass> {
+ : public impl::GpuKernelOutliningBase<GpuKernelOutliningPass> {
public:
GpuKernelOutliningPass(StringRef dlStr) {
if (!dlStr.empty() && !dataLayoutStr.hasValue())
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.h"
-#include "PassDetail.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/ParallelLoopMapper.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 GpuMapParallelLoopsPassBase<GpuMapParallelLoopsPass> {
+ : public impl::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_LLVMLEGALIZEFOREXPORT
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+} // namespace LLVM
+} // namespace mlir
using namespace mlir;
namespace {
struct LegalizeForExportPass
- : public LLVMLegalizeForExportBase<LegalizeForExportPass> {
+ : public LLVM::impl::LLVMLegalizeForExportBase<LegalizeForExportPass> {
void runOnOperation() override {
LLVM::ensureDistinctSuccessors(getOperation());
}
//===----------------------------------------------------------------------===//
#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_NVVMOPTIMIZEFORTARGET
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+} // namespace NVVM
+} // namespace mlir
+
using namespace mlir;
namespace {
};
struct NVVMOptimizeForTarget
- : public NVVMOptimizeForTargetBase<NVVMOptimizeForTarget> {
+ : public NVVM::impl::NVVMOptimizeForTargetBase<NVVMOptimizeForTarget> {
void runOnOperation() override;
void getDependentDialects(DialectRegistry ®istry) const override {
+++ /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_LLVMREQUESTCWRAPPERS
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+} // namespace LLVM
+} // namespace mlir
using namespace mlir;
namespace {
class RequestCWrappersPass
- : public LLVMRequestCWrappersBase<RequestCWrappersPass> {
+ : public LLVM::impl::LLVMRequestCWrappersBase<RequestCWrappersPass> {
public:
void runOnOperation() override {
getOperation()->setAttr(LLVM::LLVMDialect::getEmitCWrapperAttrName(),
//
//===----------------------------------------------------------------------===//
-#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 "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.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_LINALGBUFFERIZE
+#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 LinalgBufferizeBase<LinalgBufferizePass> {
+struct LinalgBufferizePass
+ : public impl::LinalgBufferizeBase<LinalgBufferizePass> {
void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<linalg::LinalgDialect>();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.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_LINALGDETENSORIZE
+#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 LinalgDetensorizeBase<LinalgDetensorize> {
+struct LinalgDetensorize
+ : public impl::LinalgDetensorizeBase<LinalgDetensorize> {
LinalgDetensorize() = default;
class CostModel {
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
+
+#include "mlir/Dialect/Affine/IR/AffineOps.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_LINALGFOLDUNITEXTENTDIMS
+#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 LinalgFoldUnitExtentDimsBase<LinalgFoldUnitExtentDimsPass> {
+ : public impl::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 "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.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_LINALGFOLDUNITEXTENTDIMS
+#define GEN_PASS_DEF_LINALGELEMENTWISEOPFUSION
+#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 LinalgElementwiseOpFusionBase<LinalgElementwiseOpFusionPass> {
+ : public impl::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_CONVERTELEMENTWISETOLINALG
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
static bool isElementwiseMappableOpOnRankedTensors(Operation *op) {
namespace {
class ConvertElementwiseToLinalgPass
- : public ConvertElementwiseToLinalgBase<ConvertElementwiseToLinalgPass> {
+ : public impl::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 "PassDetail.h"
-#include "mlir/Dialect/Linalg/IR/Linalg.h"
#include "mlir/Dialect/Linalg/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Linalg/IR/Linalg.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_LINALGGENERALIZATION
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "linalg-generalization"
using namespace mlir;
namespace {
struct LinalgGeneralizationPass
- : public LinalgGeneralizationBase<LinalgGeneralizationPass> {
+ : public impl::LinalgGeneralizationBase<LinalgGeneralizationPass> {
void runOnOperation() override;
};
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.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_LINALGINITTENSORTOALLOCTENSOR
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::bufferization;
using namespace mlir::linalg;
};
struct LinalgInitTensorToAllocTensor
- : public LinalgInitTensorToAllocTensorBase<LinalgInitTensorToAllocTensor> {
+ : public impl::LinalgInitTensorToAllocTensorBase<
+ LinalgInitTensorToAllocTensor> {
LinalgInitTensorToAllocTensor() = default;
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.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_LINALGINLINESCALAROPERANDS
+#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 LinalgInlineScalarOperandsBase<LinalgInlineScalarOperandsPass> {
+ : public impl::LinalgInlineScalarOperandsBase<
+ LinalgInlineScalarOperandsPass> {
void runOnOperation() override {
func::FuncOp funcOp = getOperation();
MLIRContext *context = funcOp.getContext();
//
//===----------------------------------------------------------------------===//
-#include <utility>
+#include "mlir/Dialect/Linalg/Passes.h"
-#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 LinalgStrategyTileAndFusePassBase<LinalgStrategyTileAndFusePass> {
+ : public impl::LinalgStrategyTileAndFusePassBase<
+ LinalgStrategyTileAndFusePass> {
LinalgStrategyTileAndFusePass() = default;
/// Configurable pass to apply pattern-based linalg tiling.
struct LinalgStrategyTilePass
- : public LinalgStrategyTilePassBase<LinalgStrategyTilePass> {
+ : public impl::LinalgStrategyTilePassBase<LinalgStrategyTilePass> {
LinalgStrategyTilePass() = default;
- LinalgStrategyTilePass(StringRef opName, LinalgTilingOptions opt,
+ LinalgStrategyTilePass(StringRef opName,
+ mlir::linalg::LinalgTilingOptions opt,
LinalgTransformationFilter filt)
: options(std::move(opt)), filter(std::move(filt)) {
this->anchorOpName.setValue(opName.str());
(void)applyPatternsAndFoldGreedily(funcOp, std::move(tilingPattern));
}
- LinalgTilingOptions options;
+ mlir::linalg::LinalgTilingOptions options;
LinalgTransformationFilter filter;
};
/// Configurable pass to apply hoisting and padding.
struct LinalgStrategyPadPass
- : public LinalgStrategyPadPassBase<LinalgStrategyPadPass> {
+ : public impl::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 LinalgStrategyDecomposePassBase<LinalgStrategyDecomposePass> {
+ : public impl::LinalgStrategyDecomposePassBase<
+ LinalgStrategyDecomposePass> {
LinalgStrategyDecomposePass() = default;
/// Configurable pass to apply pattern-based linalg peeling.
struct LinalgStrategyPeelPass
- : public LinalgStrategyPeelPassBase<LinalgStrategyPeelPass> {
+ : public impl::LinalgStrategyPeelPassBase<LinalgStrategyPeelPass> {
LinalgStrategyPeelPass() = default;
/// Configurable pass to apply pattern-based linalg vectorization.
struct LinalgStrategyVectorizePass
- : public LinalgStrategyVectorizePassBase<LinalgStrategyVectorizePass> {
+ : public impl::LinalgStrategyVectorizePassBase<
+ LinalgStrategyVectorizePass> {
LinalgStrategyVectorizePass() = default;
/// Configurable pass to enable the application of other pattern-based linalg
/// passes.
struct LinalgStrategyEnablePass
- : public LinalgStrategyEnablePassBase<LinalgStrategyEnablePass> {
+ : public impl::LinalgStrategyEnablePassBase<LinalgStrategyEnablePass> {
LinalgStrategyEnablePass(LinalgEnablingOptions opt,
LinalgTransformationFilter filt)
/// Configurable pass to lower vector operations.
struct LinalgStrategyLowerVectorsPass
- : public LinalgStrategyLowerVectorsPassBase<
+ : public impl::LinalgStrategyLowerVectorsPassBase<
LinalgStrategyLowerVectorsPass> {
LinalgStrategyLowerVectorsPass(LinalgVectorLoweringOptions opt,
/// Configurable pass to lower vector operations.
struct LinalgStrategyRemoveMarkersPass
- : public LinalgStrategyRemoveMarkersPassBase<
+ : public impl::LinalgStrategyRemoveMarkersPassBase<
LinalgStrategyRemoveMarkersPass> {
void runOnOperation() override {
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
+
+#include "mlir/Dialect/Affine/IR/AffineOps.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_LINALGLOWERTOAFFINELOOPS
+#define GEN_PASS_DEF_LINALGLOWERTOLOOPS
+#define GEN_PASS_DEF_LINALGLOWERTOPARALLELLOOPS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::linalg;
}
struct LowerToAffineLoops
- : public LinalgLowerToAffineLoopsBase<LowerToAffineLoops> {
+ : public impl::LinalgLowerToAffineLoopsBase<LowerToAffineLoops> {
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<memref::MemRefDialect>();
}
}
};
-struct LowerToLoops : public LinalgLowerToLoopsBase<LowerToLoops> {
+struct LowerToLoops : public impl::LinalgLowerToLoopsBase<LowerToLoops> {
void getDependentDialects(DialectRegistry ®istry) const override {
registry.insert<memref::MemRefDialect, scf::SCFDialect>();
}
};
struct LowerToParallelLoops
- : public LinalgLowerToParallelLoopsBase<LowerToParallelLoops> {
+ : public impl::LinalgLowerToParallelLoopsBase<LowerToParallelLoops> {
void runOnOperation() override {
lowerLinalgToLoopsImpl<scf::ParallelOp>(getOperation());
}
// canonicalizations of named ops.
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
-#include "mlir/Dialect/Linalg/IR/Linalg.h"
+
#include "mlir/Dialect/Linalg/Passes.h"
+
+#include "mlir/Dialect/Linalg/IR/Linalg.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_LINALGNAMEDOPCONVERSION
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::linalg;
};
struct LinalgNamedOpConversionPass
- : public LinalgNamedOpConversionBase<LinalgNamedOpConversionPass> {
+ : public impl::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 <utility>
+#include "mlir/Dialect/Linalg/Passes.h"
-#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
using namespace mlir;
using namespace mlir::linalg;
}
namespace {
-struct LinalgTilingPass : public LinalgTilingBase<LinalgTilingPass> {
+struct LinalgTilingPass : public impl::LinalgTilingPassBase<LinalgTilingPass> {
LinalgTilingPass() = default;
LinalgTilingPass(ArrayRef<int64_t> tileSizes, LinalgTilingLoopType loopType) {
this->tileSizes = tileSizes;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.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_EXPANDOPS
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+} // namespace memref
+} // namespace mlir
+
using namespace mlir;
namespace {
}
};
-struct ExpandOpsPass : public ExpandOpsBase<ExpandOpsPass> {
+struct ExpandOpsPass : public memref::impl::ExpandOpsBase<ExpandOpsPass> {
void runOnOperation() override {
MLIRContext &ctx = getContext();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.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_FOLDMEMREFALIASOPS
+#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 FoldMemRefAliasOpsBase<FoldMemRefAliasOpsPass> {
+ : public memref::impl::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_NORMALIZEMEMREFS
+#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 NormalizeMemRefsBase<NormalizeMemRefs> {
+struct NormalizeMemRefs
+ : public memref::impl::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 "PassDetail.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.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_RESOLVERANKEDSHAPETYPERESULTDIMS
+#define GEN_PASS_DEF_RESOLVESHAPEDTYPERESULTDIMS
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+} // namespace memref
+} // namespace mlir
+
using namespace mlir;
namespace {
namespace {
struct ResolveRankedShapeTypeResultDimsPass final
- : public ResolveRankedShapeTypeResultDimsBase<
+ : public memref::impl::ResolveRankedShapeTypeResultDimsBase<
ResolveRankedShapeTypeResultDimsPass> {
void runOnOperation() override;
};
struct ResolveShapedTypeResultDimsPass final
- : public ResolveShapedTypeResultDimsBase<ResolveShapedTypeResultDimsPass> {
+ : public memref::impl::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 "PassDetail.h"
+
+#include "mlir/Dialect/NVGPU/Passes.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_OPTIMIZESHAREDMEMORY
+#include "mlir/Dialect/NVGPU/Passes.h.inc"
+} // namespace nvgpu
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::nvgpu;
namespace {
class OptimizeSharedMemoryPass
- : public OptimizeSharedMemoryBase<OptimizeSharedMemoryPass> {
+ : public nvgpu::impl::OptimizeSharedMemoryBase<OptimizeSharedMemoryPass> {
public:
OptimizeSharedMemoryPass() = default;
+++ /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/Bufferization/Transforms/Bufferize.h"
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
+#include "mlir/Dialect/Bufferization/Transforms/Bufferize.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_SCFBUFFERIZE
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::scf;
namespace {
-struct SCFBufferizePass : public SCFBufferizeBase<SCFBufferizePass> {
+struct SCFBufferizePass : public impl::SCFBufferizeBase<SCFBufferizePass> {
void runOnOperation() override {
auto func = getOperation();
auto *context = &getContext();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.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_SCFFORTOWHILELOOP
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace llvm;
using namespace mlir;
using scf::ForOp;
}
};
-struct ForToWhileLoop : public SCFForToWhileLoopBase<ForToWhileLoop> {
+struct ForToWhileLoop : public impl::SCFForToWhileLoopBase<ForToWhileLoop> {
void runOnOperation() override {
auto *parentOp = getOperation();
MLIRContext *ctx = parentOp->getContext();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.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_SCFFORLOOPCANONICALIZATION
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::scf;
};
struct SCFForLoopCanonicalization
- : public SCFForLoopCanonicalizationBase<SCFForLoopCanonicalization> {
+ : public impl::SCFForLoopCanonicalizationBase<SCFForLoopCanonicalization> {
void runOnOperation() override {
auto *parentOp = getOperation();
MLIRContext *ctx = parentOp->getContext();
//
//===----------------------------------------------------------------------===//
-#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 "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.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_SCFFORLOOPRANGEFOLDING
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::scf;
namespace {
struct ForLoopRangeFolding
- : public SCFForLoopRangeFoldingBase<ForLoopRangeFolding> {
+ : public impl::SCFForLoopRangeFoldingBase<ForLoopRangeFolding> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.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_SCFFORLOOPPEELING
+#define GEN_PASS_DEF_SCFFORLOOPSPECIALIZATION
+#define GEN_PASS_DEF_SCFPARALLELLOOPSPECIALIZATION
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using scf::ForOp;
using scf::ParallelOp;
namespace {
struct ParallelLoopSpecialization
- : public SCFParallelLoopSpecializationBase<ParallelLoopSpecialization> {
+ : public impl::SCFParallelLoopSpecializationBase<
+ ParallelLoopSpecialization> {
void runOnOperation() override {
getOperation()->walk(
[](ParallelOp op) { specializeParallelLoopForUnrolling(op); });
};
struct ForLoopSpecialization
- : public SCFForLoopSpecializationBase<ForLoopSpecialization> {
+ : public impl::SCFForLoopSpecializationBase<ForLoopSpecialization> {
void runOnOperation() override {
getOperation()->walk([](ForOp op) { specializeForLoopForUnrolling(op); });
}
};
-struct ForLoopPeeling : public SCFForLoopPeelingBase<ForLoopPeeling> {
+struct ForLoopPeeling : public impl::SCFForLoopPeelingBase<ForLoopPeeling> {
void runOnOperation() override {
auto *parentOp = getOperation();
MLIRContext *ctx = parentOp->getContext();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
-#include "mlir/Dialect/SCF/IR/SCF.h"
#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
+#include "mlir/Dialect/SCF/IR/SCF.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_SCFPARALLELLOOPCOLLAPSING
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "parallel-loop-collapsing"
using namespace mlir;
namespace {
struct ParallelLoopCollapsing
- : public SCFParallelLoopCollapsingBase<ParallelLoopCollapsing> {
+ : public
impl::SCFParallelLoopCollapsingBase<ParallelLoopCollapsing> {
void runOnOperation() override {
Operation *module = getOperation();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.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_SCFPARALLELLOOPFUSION
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::scf;
namespace {
struct ParallelLoopFusion
- : public SCFParallelLoopFusionBase<ParallelLoopFusion> {
+ : public
impl::SCFParallelLoopFusionBase<ParallelLoopFusion> {
void runOnOperation() override {
getOperation()->walk([&](Operation *child) {
for (Region ®ion : child->getRegions())
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.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_SCFPARALLELLOOPTILING
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::scf;
namespace {
struct ParallelLoopTiling
- : public SCFParallelLoopTilingBase<ParallelLoopTiling> {
+ : public
impl::SCFParallelLoopTilingBase<ParallelLoopTiling> {
ParallelLoopTiling() = default;
explicit ParallelLoopTiling(ArrayRef<int64_t> tileSizes,
bool noMinMaxBounds = false) {
+++ /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 "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.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_SPIRVCANONICALIZEGL
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+} // namespace spirv
+} // namespace mlir
+
using namespace mlir;
namespace {
class CanonicalizeGLPass final
- : public SPIRVCanonicalizeGLBase<CanonicalizeGLPass> {
+ : public spirv::impl::SPIRVCanonicalizeGLBase<CanonicalizeGLPass> {
public:
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.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_SPIRVCOMPOSITETYPELAYOUT
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+} // namespace spirv
+} // namespace mlir
+
namespace {
class SPIRVGlobalVariableOpLayoutInfoDecoration
: public OpRewritePattern<spirv::GlobalVariableOp> {
namespace {
class DecorateSPIRVCompositeTypeLayoutPass
- : public SPIRVCompositeTypeLayoutBase<
+ : public spirv::impl::SPIRVCompositeTypeLayoutBase<
DecorateSPIRVCompositeTypeLayoutPass> {
void runOnOperation() override;
};
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.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_SPIRVLOWERABIATTRIBUTES
+#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 LowerABIAttributesPass final
- : public SPIRVLowerABIAttributesBase<LowerABIAttributesPass> {
+ : public spirv::impl::SPIRVLowerABIAttributesBase<LowerABIAttributesPass> {
void runOnOperation() override;
};
} // namespace
+++ /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 "PassDetail.h"
-#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.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 RewriteInsertsPass
- : public SPIRVRewriteInsertsPassBase<RewriteInsertsPass> {
+ : public spirv::impl::SPIRVRewriteInsertsPassBase<RewriteInsertsPass> {
public:
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.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 UnifyAliasedResourcePass final
- : public SPIRVUnifyAliasedResourcePassBase<UnifyAliasedResourcePass> {
+ : public spirv::impl::SPIRVUnifyAliasedResourcePassBase<
+ UnifyAliasedResourcePass> {
public:
void runOnOperation() override;
};
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.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_SPIRVUPDATEVCE
+#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 UpdateVCEPass final : public SPIRVUpdateVCEBase<UpdateVCEPass> {
+class UpdateVCEPass final
+ : public spirv::impl::SPIRVUpdateVCEBase<UpdateVCEPass> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-#include "PassDetail.h"
+#include "mlir/Dialect/Shape/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/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_SHAPEBUFFERIZE
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace bufferization;
namespace {
-struct ShapeBufferizePass : public ShapeBufferizeBase<ShapeBufferizePass> {
+struct ShapeBufferizePass
+ : public impl::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 "PassDetail.h"
-#include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/Dialect/Shape/Transforms/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+namespace mlir {
+#define GEN_PASS_DEF_REMOVESHAPECONSTRAINTS
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
/// Removal pass.
class RemoveShapeConstraintsPass
- : public RemoveShapeConstraintsBase<RemoveShapeConstraintsPass> {
+ : public impl::RemoveShapeConstraintsBase<RemoveShapeConstraintsPass> {
void runOnOperation() override {
MLIRContext &ctx = getContext();
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Dialect/Shape/Transforms/Passes.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_SHAPETOSHAPELOWERING
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::shape;
namespace {
struct ShapeToShapeLowering
- : public ShapeToShapeLoweringBase<ShapeToShapeLowering> {
+ : public impl::ShapeToShapeLoweringBase<ShapeToShapeLowering> {
void runOnOperation() override;
};
} // namespace
#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_SPARSETENSORCODEGEN
+#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 SparsificationBase<SparsificationPass> {
+struct SparsificationPass
+ : public impl::SparsificationPassBase<SparsificationPass> {
SparsificationPass() = default;
SparsificationPass(const SparsificationPass &pass) = default;
};
struct SparseTensorConversionPass
- : public SparseTensorConversionBase<SparseTensorConversionPass> {
+ : public impl::SparseTensorConversionPassBase<SparseTensorConversionPass> {
SparseTensorConversionPass() = default;
SparseTensorConversionPass(const SparseTensorConversionPass &pass) = default;
};
struct SparseTensorCodegenPass
- : public SparseTensorCodegenBase<SparseTensorCodegenPass> {
+ : public impl::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_TENSORBUFFERIZE
+#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
+} // namespace tensor
+} // namespace mlir
+
using namespace mlir;
using namespace bufferization;
namespace {
-struct TensorBufferizePass : public TensorBufferizeBase<TensorBufferizePass> {
+struct TensorBufferizePass
+ : public tensor::impl::TensorBufferizeBase<TensorBufferizePass> {
void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<tensor::TensorDialect>();
+++ /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_TOSAINFERSHAPES
+#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 TosaInferShapes : public TosaInferShapesBase<TosaInferShapes> {
+struct TosaInferShapes
+ : public tosa::impl::TosaInferShapesBase<TosaInferShapes> {
public:
void runOnOperation() override {
func::FuncOp func = getOperation();
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Tosa/IR/TosaOps.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 TosaLayerwiseConstantFoldPassBase<TosaLayerwiseConstantFoldPass> {
+ : public tosa::impl::TosaLayerwiseConstantFoldPassBase<
+ TosaLayerwiseConstantFoldPass> {
void runOnOperation() override {
auto *ctx = &getContext();
RewritePatternSet patterns(ctx);
//
//===----------------------------------------------------------------------===//
+#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/IR/TosaOps.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_TOSAMAKEBROADCASTABLE
+#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
+} // namespace tosa
+} // namespace mlir
+
using namespace mlir;
using namespace mlir::tosa;
/// Pass that enables broadcast by making all input arrays have the same
/// number of dimensions. Insert RESHAPE operations to lower rank operand
struct TosaMakeBroadcastable
- : public TosaMakeBroadcastableBase<TosaMakeBroadcastable> {
+ : public tosa::impl::TosaMakeBroadcastableBase<TosaMakeBroadcastable> {
public:
void runOnOperation() override {
auto func = getOperation();
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+namespace mlir {
+namespace tosa {
+#define GEN_PASS_DEF_TOSAOPTIONALDECOMPOSITIONS
+#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
+} // namespace tosa
+} // namespace mlir
+
using namespace mlir;
namespace {
struct TosaOptionalDecompositions
- : public TosaOptionalDecompositionsBase<TosaOptionalDecompositions> {
+ : public tosa::impl::TosaOptionalDecompositionsBase<
+ TosaOptionalDecompositions> {
void runOnOperation() override {
auto *ctx = &getContext();
RewritePatternSet patterns(ctx);
//
//===----------------------------------------------------------------------===//
-#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
#include "mlir/Dialect/Transform/Transforms/Passes.h"
+
+#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#include "mlir/Pass/Pass.h"
#include "llvm/ADT/SetOperations.h"
+namespace mlir {
+namespace transform {
+#define GEN_PASS_DEF_CHECKUSES
+#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 CheckUsesBase<CheckUsesPass> {
+class CheckUsesPass : public transform::impl::CheckUsesBase<CheckUsesPass> {
public:
void runOnOperation() override {
auto &analysis = getAnalysis<TransformOpMemFreeAnalysis>();
//===----------------------------------------------------------------------===//
#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_VECTORBUFFERIZE
+#include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
+} // namespace vector
+} // namespace mlir
+
using namespace mlir;
using namespace bufferization;
namespace {
-struct VectorBufferizePass : public VectorBufferizeBase<VectorBufferizePass> {
+struct VectorBufferizePass
+ : public vector::impl::VectorBufferizeBase<VectorBufferizePass> {
void runOnOperation() override {
BufferizationOptions options = getPartialBufferizationOptions();
options.opFilter.allowDialect<vector::VectorDialect>();
+++ /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_OPTREDUCTION
+#include "mlir/Reducer/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "mlir-reduce"
using namespace mlir;
namespace {
-class OptReductionPass : public OptReductionBase<OptReductionPass> {
+class OptReductionPass : public impl::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_REDUCTIONTREE
+#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 ReductionTreeBase<ReductionTreePass> {
+class ReductionTreePass : public impl::ReductionTreeBase<ReductionTreePass> {
public:
ReductionTreePass() = default;
ReductionTreePass(const ReductionTreePass &pass) = default;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.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_CSE
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
namespace {
/// Simple common sub-expression elimination.
-struct CSE : public CSEBase<CSE> {
+struct CSE : public impl::CSEBase<CSE> {
/// Shared implementation of operation elimination and scoped map definitions.
using AllocatorTy = llvm::RecyclingAllocator<
llvm::BumpPtrAllocator,
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-#include "mlir/Transforms/Passes.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CANONICALIZER
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
/// Canonicalize operations in nested regions.
-struct Canonicalizer : public CanonicalizerBase<Canonicalizer> {
+struct Canonicalizer : public impl::CanonicalizerBase<Canonicalizer> {
Canonicalizer() = default;
Canonicalizer(const GreedyRewriteConfig &config,
ArrayRef<std::string> disabledPatterns,
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.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_CONTROLFLOWSINK
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
/// A control-flow sink pass.
-struct ControlFlowSink : public ControlFlowSinkBase<ControlFlowSink> {
+struct ControlFlowSink : public impl::ControlFlowSinkBase<ControlFlowSink> {
void runOnOperation() override;
};
} // end anonymous namespace
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.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_INLINER
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
#define DEBUG_TYPE "inlining"
using namespace mlir;
//===----------------------------------------------------------------------===//
namespace {
-class InlinerPass : public InlinerBase<InlinerPass> {
+class InlinerPass : public impl::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_LOCATIONSNAPSHOT
+#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 LocationSnapshotBase<LocationSnapshotPass> {
+ : public impl::LocationSnapshotBase<LocationSnapshotPass> {
LocationSnapshotPass() = default;
LocationSnapshotPass(OpPrintingFlags flags, StringRef fileName, StringRef tag)
: flags(flags) {
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.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_LOOPINVARIANTCODEMOTION
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
/// Loop invariant code motion (LICM) pass.
struct LoopInvariantCodeMotion
- : public LoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
+ : public impl::LoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.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_PRINTOPSTATS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
-struct PrintOpStatsPass : public PrintOpStatsBase<PrintOpStatsPass> {
+struct PrintOpStatsPass : public
impl::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 "PassDetail.h"
+#include "mlir/Transforms/Passes.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"
-#include "mlir/Transforms/Passes.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_SCCP
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
using namespace mlir::dataflow;
//===----------------------------------------------------------------------===//
namespace {
-struct SCCP : public SCCPBase<SCCP> {
+struct SCCP : public impl::SCCPBase<SCCP> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Operation.h"
#include "mlir/Pass/Pass.h"
-#include "mlir/Transforms/Passes.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_STRIPDEBUGINFO
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
using namespace mlir;
namespace {
-struct StripDebugInfo : public StripDebugInfoBase<StripDebugInfo> {
+struct StripDebugInfo : public impl::StripDebugInfoBase<StripDebugInfo> {
void runOnOperation() override;
};
} // namespace
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
-#include "mlir/IR/SymbolTable.h"
#include "mlir/Transforms/Passes.h"
+#include "mlir/IR/SymbolTable.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_SYMBOLDCE
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
-struct SymbolDCE : public SymbolDCEBase<SymbolDCE> {
+struct SymbolDCE : public impl::SymbolDCEBase<SymbolDCE> {
void runOnOperation() override;
/// Compute the liveness of the symbols within the given symbol table.
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
-#include "mlir/IR/SymbolTable.h"
#include "mlir/Transforms/Passes.h"
+#include "mlir/IR/SymbolTable.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_SYMBOLPRIVATIZE
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
-struct SymbolPrivatize : public SymbolPrivatizeBase<SymbolPrivatize> {
+struct SymbolPrivatize : public impl::SymbolPrivatizeBase<SymbolPrivatize> {
explicit SymbolPrivatize(ArrayRef<std::string> excludeSymbols);
LogicalResult initialize(MLIRContext *context) override;
void runOnOperation() override;
//
//===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
#include "mlir/IR/RegionKindInterface.h"
#include "mlir/Transforms/TopologicalSortUtils.h"
+namespace mlir {
+#define GEN_PASS_DEF_TOPOLOGICALSORT
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
using namespace mlir;
namespace {
-struct TopologicalSortPass : public TopologicalSortBase<TopologicalSortPass> {
+struct TopologicalSortPass
+ : public impl::TopologicalSortBase<TopologicalSortPass> {
void runOnOperation() override {
// Topologically sort the regions of the operation without SSA dominance.
getOperation()->walk([](RegionKindInterface op) {
//===----------------------------------------------------------------------===//
#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_VIEWOPGRAPH
+#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 PrintOpPass : public ViewOpGraphBase<PrintOpPass> {
+class PrintOpPass : public
impl::ViewOpGraphBase<PrintOpPass> {
public:
PrintOpPass(raw_ostream &os) : os(os) {}
PrintOpPass(const PrintOpPass &o) : PrintOpPass(o.os.getOStream()) {}
//
//===----------------------------------------------------------------------===//
+#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}Pass();
+ register{1}();
}
)";
constructorCall = constructor.str();
else
constructorCall =
- llvm::formatv("create{0}Pass()", pass.getDef()->getName()).str();
+ llvm::formatv("create{0}()", 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
projects / platform / upstream / llvm.git / commitdiff