1418 lines
60 KiB
PHP
1418 lines
60 KiB
PHP
/* Autogenerated by mlir-tblgen; don't manually edit */
|
|
|
|
#ifdef GEN_PASS_DECL
|
|
// Generate declarations for all passes.
|
|
#define GEN_PASS_DECL_CONVERTELEMENTWISETOLINALGPASS
|
|
#define GEN_PASS_DECL_CONVERTLINALGTOAFFINELOOPSPASS
|
|
#define GEN_PASS_DECL_CONVERTLINALGTOLOOPSPASS
|
|
#define GEN_PASS_DECL_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
#define GEN_PASS_DECL_LINALGBLOCKPACKMATMUL
|
|
#define GEN_PASS_DECL_LINALGELEMENTWISEOPFUSIONPASS
|
|
#define GEN_PASS_DECL_LINALGFOLDINTOELEMENTWISEPASS
|
|
#define GEN_PASS_DECL_LINALGFOLDUNITEXTENTDIMSPASS
|
|
#define GEN_PASS_DECL_LINALGGENERALIZENAMEDOPSPASS
|
|
#define GEN_PASS_DECL_LINALGINLINESCALAROPERANDSPASS
|
|
#define GEN_PASS_DECL_LINALGMORPHOPSPASS
|
|
#define GEN_PASS_DECL_LINALGSPECIALIZEGENERICOPSPASS
|
|
#define GEN_PASS_DECL_SIMPLIFYDEPTHWISECONVPASS
|
|
#undef GEN_PASS_DECL
|
|
#endif // GEN_PASS_DECL
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ConvertElementwiseToLinalgPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_CONVERTELEMENTWISETOLINALGPASS
|
|
std::unique_ptr<::mlir::Pass> createConvertElementwiseToLinalgPass();
|
|
#undef GEN_PASS_DECL_CONVERTELEMENTWISETOLINALGPASS
|
|
#endif // GEN_PASS_DECL_CONVERTELEMENTWISETOLINALGPASS
|
|
#ifdef GEN_PASS_DEF_CONVERTELEMENTWISETOLINALGPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createConvertElementwiseToLinalgPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class ConvertElementwiseToLinalgPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = ConvertElementwiseToLinalgPassBase;
|
|
|
|
ConvertElementwiseToLinalgPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
ConvertElementwiseToLinalgPassBase(const ConvertElementwiseToLinalgPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
ConvertElementwiseToLinalgPassBase& operator=(const ConvertElementwiseToLinalgPassBase &) = delete;
|
|
ConvertElementwiseToLinalgPassBase(ConvertElementwiseToLinalgPassBase &&) = delete;
|
|
ConvertElementwiseToLinalgPassBase& operator=(ConvertElementwiseToLinalgPassBase &&) = delete;
|
|
~ConvertElementwiseToLinalgPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("convert-elementwise-to-linalg");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "convert-elementwise-to-linalg"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Convert ElementwiseMappable ops to linalg)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("ConvertElementwiseToLinalgPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "ConvertElementwiseToLinalgPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
registry.insert<memref::MemRefDialect>();
|
|
}
|
|
|
|
/// 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(ConvertElementwiseToLinalgPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createConvertElementwiseToLinalgPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createConvertElementwiseToLinalgPass() {
|
|
return impl::createConvertElementwiseToLinalgPass();
|
|
}
|
|
#undef GEN_PASS_DEF_CONVERTELEMENTWISETOLINALGPASS
|
|
#endif // GEN_PASS_DEF_CONVERTELEMENTWISETOLINALGPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ConvertLinalgToAffineLoopsPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_CONVERTLINALGTOAFFINELOOPSPASS
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToAffineLoopsPass();
|
|
#undef GEN_PASS_DECL_CONVERTLINALGTOAFFINELOOPSPASS
|
|
#endif // GEN_PASS_DECL_CONVERTLINALGTOAFFINELOOPSPASS
|
|
#ifdef GEN_PASS_DEF_CONVERTLINALGTOAFFINELOOPSPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToAffineLoopsPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class ConvertLinalgToAffineLoopsPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = ConvertLinalgToAffineLoopsPassBase;
|
|
|
|
ConvertLinalgToAffineLoopsPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
ConvertLinalgToAffineLoopsPassBase(const ConvertLinalgToAffineLoopsPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
ConvertLinalgToAffineLoopsPassBase& operator=(const ConvertLinalgToAffineLoopsPassBase &) = delete;
|
|
ConvertLinalgToAffineLoopsPassBase(ConvertLinalgToAffineLoopsPassBase &&) = delete;
|
|
ConvertLinalgToAffineLoopsPassBase& operator=(ConvertLinalgToAffineLoopsPassBase &&) = delete;
|
|
~ConvertLinalgToAffineLoopsPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("convert-linalg-to-affine-loops");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "convert-linalg-to-affine-loops"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Lower the operations from the linalg dialect into affine loops)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("ConvertLinalgToAffineLoopsPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "ConvertLinalgToAffineLoopsPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<affine::AffineDialect>();
|
|
registry.insert<linalg::LinalgDialect>();
|
|
registry.insert<memref::MemRefDialect>();
|
|
}
|
|
|
|
/// 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(ConvertLinalgToAffineLoopsPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createConvertLinalgToAffineLoopsPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToAffineLoopsPass() {
|
|
return impl::createConvertLinalgToAffineLoopsPass();
|
|
}
|
|
#undef GEN_PASS_DEF_CONVERTLINALGTOAFFINELOOPSPASS
|
|
#endif // GEN_PASS_DEF_CONVERTLINALGTOAFFINELOOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ConvertLinalgToLoopsPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_CONVERTLINALGTOLOOPSPASS
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToLoopsPass();
|
|
#undef GEN_PASS_DECL_CONVERTLINALGTOLOOPSPASS
|
|
#endif // GEN_PASS_DECL_CONVERTLINALGTOLOOPSPASS
|
|
#ifdef GEN_PASS_DEF_CONVERTLINALGTOLOOPSPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToLoopsPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class ConvertLinalgToLoopsPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = ConvertLinalgToLoopsPassBase;
|
|
|
|
ConvertLinalgToLoopsPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
ConvertLinalgToLoopsPassBase(const ConvertLinalgToLoopsPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
ConvertLinalgToLoopsPassBase& operator=(const ConvertLinalgToLoopsPassBase &) = delete;
|
|
ConvertLinalgToLoopsPassBase(ConvertLinalgToLoopsPassBase &&) = delete;
|
|
ConvertLinalgToLoopsPassBase& operator=(ConvertLinalgToLoopsPassBase &&) = delete;
|
|
~ConvertLinalgToLoopsPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("convert-linalg-to-loops");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "convert-linalg-to-loops"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Lower the operations from the linalg dialect into loops)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("ConvertLinalgToLoopsPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "ConvertLinalgToLoopsPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
registry.insert<scf::SCFDialect>();
|
|
registry.insert<affine::AffineDialect>();
|
|
}
|
|
|
|
/// 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(ConvertLinalgToLoopsPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createConvertLinalgToLoopsPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToLoopsPass() {
|
|
return impl::createConvertLinalgToLoopsPass();
|
|
}
|
|
#undef GEN_PASS_DEF_CONVERTLINALGTOLOOPSPASS
|
|
#endif // GEN_PASS_DEF_CONVERTLINALGTOLOOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ConvertLinalgToParallelLoopsPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToParallelLoopsPass();
|
|
#undef GEN_PASS_DECL_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
#endif // GEN_PASS_DECL_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
#ifdef GEN_PASS_DEF_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToParallelLoopsPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class ConvertLinalgToParallelLoopsPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = ConvertLinalgToParallelLoopsPassBase;
|
|
|
|
ConvertLinalgToParallelLoopsPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
ConvertLinalgToParallelLoopsPassBase(const ConvertLinalgToParallelLoopsPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
ConvertLinalgToParallelLoopsPassBase& operator=(const ConvertLinalgToParallelLoopsPassBase &) = delete;
|
|
ConvertLinalgToParallelLoopsPassBase(ConvertLinalgToParallelLoopsPassBase &&) = delete;
|
|
ConvertLinalgToParallelLoopsPassBase& operator=(ConvertLinalgToParallelLoopsPassBase &&) = delete;
|
|
~ConvertLinalgToParallelLoopsPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("convert-linalg-to-parallel-loops");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "convert-linalg-to-parallel-loops"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Lower the operations from the linalg dialect into parallel loops)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("ConvertLinalgToParallelLoopsPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "ConvertLinalgToParallelLoopsPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<affine::AffineDialect>();
|
|
registry.insert<linalg::LinalgDialect>();
|
|
registry.insert<memref::MemRefDialect>();
|
|
registry.insert<scf::SCFDialect>();
|
|
}
|
|
|
|
/// 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(ConvertLinalgToParallelLoopsPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createConvertLinalgToParallelLoopsPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createConvertLinalgToParallelLoopsPass() {
|
|
return impl::createConvertLinalgToParallelLoopsPass();
|
|
}
|
|
#undef GEN_PASS_DEF_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
#endif // GEN_PASS_DEF_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgBlockPackMatmul
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_LINALGBLOCKPACKMATMUL
|
|
struct LinalgBlockPackMatmulOptions {
|
|
::llvm::SmallVector<int64_t> blockFactors;
|
|
bool allowPadding = true;
|
|
::llvm::SmallVector<int64_t> mnkPaddedSizesNextMultipleOf;
|
|
::llvm::SmallVector<int64_t> mnkOrder;
|
|
bool lhsTransposeOuterBlocks = false;
|
|
bool lhsTransposeInnerBlocks = false;
|
|
bool rhsTransposeOuterBlocks = true;
|
|
bool rhsTransposeInnerBlocks = true;
|
|
};
|
|
std::unique_ptr<::mlir::Pass> createLinalgBlockPackMatmul();
|
|
std::unique_ptr<::mlir::Pass> createLinalgBlockPackMatmul(LinalgBlockPackMatmulOptions options);
|
|
#undef GEN_PASS_DECL_LINALGBLOCKPACKMATMUL
|
|
#endif // GEN_PASS_DECL_LINALGBLOCKPACKMATMUL
|
|
#ifdef GEN_PASS_DEF_LINALGBLOCKPACKMATMUL
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgBlockPackMatmul();
|
|
} // namespace impl
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgBlockPackMatmul(LinalgBlockPackMatmulOptions options);
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class LinalgBlockPackMatmulBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = LinalgBlockPackMatmulBase;
|
|
|
|
LinalgBlockPackMatmulBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
LinalgBlockPackMatmulBase(const LinalgBlockPackMatmulBase &other) : ::mlir::OperationPass<>(other) {}
|
|
LinalgBlockPackMatmulBase& operator=(const LinalgBlockPackMatmulBase &) = delete;
|
|
LinalgBlockPackMatmulBase(LinalgBlockPackMatmulBase &&) = delete;
|
|
LinalgBlockPackMatmulBase& operator=(LinalgBlockPackMatmulBase &&) = delete;
|
|
~LinalgBlockPackMatmulBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("linalg-block-pack-matmul");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "linalg-block-pack-matmul"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Convert linalg matmul ops to block layout and back)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("LinalgBlockPackMatmul");
|
|
}
|
|
::llvm::StringRef getName() const override { return "LinalgBlockPackMatmul"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
registry.insert<tensor::TensorDialect>();
|
|
}
|
|
|
|
/// 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(LinalgBlockPackMatmulBase<DerivedT>)
|
|
|
|
LinalgBlockPackMatmulBase(LinalgBlockPackMatmulOptions options) : LinalgBlockPackMatmulBase() {
|
|
blockFactors = std::move(options.blockFactors);
|
|
allowPadding = std::move(options.allowPadding);
|
|
mnkPaddedSizesNextMultipleOf = std::move(options.mnkPaddedSizesNextMultipleOf);
|
|
mnkOrder = std::move(options.mnkOrder);
|
|
lhsTransposeOuterBlocks = std::move(options.lhsTransposeOuterBlocks);
|
|
lhsTransposeInnerBlocks = std::move(options.lhsTransposeInnerBlocks);
|
|
rhsTransposeOuterBlocks = std::move(options.rhsTransposeOuterBlocks);
|
|
rhsTransposeInnerBlocks = std::move(options.rhsTransposeInnerBlocks);
|
|
}
|
|
protected:
|
|
::mlir::Pass::ListOption<int64_t> blockFactors{*this, "block-factors", ::llvm::cl::desc(R"PO(Block factors (mb, nb, kb) for relayout)PO")};
|
|
::mlir::Pass::Option<bool> allowPadding{*this, "allow-padding", ::llvm::cl::desc(R"PO(Allow packing padding)PO"), ::llvm::cl::init(true)};
|
|
::mlir::Pass::ListOption<int64_t> mnkPaddedSizesNextMultipleOf{*this, "mnk-padded-multiples", ::llvm::cl::desc(R"PO(Next multiples of the packing sizes)PO")};
|
|
::mlir::Pass::ListOption<int64_t> mnkOrder{*this, "mnk-order", ::llvm::cl::desc(R"PO(Permutation of matmul (M, N, K) dimensions order)PO")};
|
|
::mlir::Pass::Option<bool> lhsTransposeOuterBlocks{*this, "lhs-transpose-outer-blocks", ::llvm::cl::desc(R"PO(Transpose LHS outer block layout [MB][KB] -> [KB][MB])PO"), ::llvm::cl::init(false)};
|
|
::mlir::Pass::Option<bool> lhsTransposeInnerBlocks{*this, "lhs-transpose-inner-blocks", ::llvm::cl::desc(R"PO(Transpose LHS inner block layout [mb][kb] -> [kb][mb])PO"), ::llvm::cl::init(false)};
|
|
::mlir::Pass::Option<bool> rhsTransposeOuterBlocks{*this, "rhs-transpose-outer-blocks", ::llvm::cl::desc(R"PO(Transpose RHS outer block layout [KB][NB] -> [NB][KB])PO"), ::llvm::cl::init(true)};
|
|
::mlir::Pass::Option<bool> rhsTransposeInnerBlocks{*this, "rhs-transpose-inner-blocks", ::llvm::cl::desc(R"PO(Transpose RHS inner block layout [kb][nb] -> [nb][kb])PO"), ::llvm::cl::init(true)};
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgBlockPackMatmul() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgBlockPackMatmul(LinalgBlockPackMatmulOptions options) {
|
|
return std::make_unique<DerivedT>(std::move(options));
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgBlockPackMatmul() {
|
|
return impl::createLinalgBlockPackMatmul();
|
|
}
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgBlockPackMatmul(LinalgBlockPackMatmulOptions options) {
|
|
return impl::createLinalgBlockPackMatmul(std::move(options));
|
|
}
|
|
#undef GEN_PASS_DEF_LINALGBLOCKPACKMATMUL
|
|
#endif // GEN_PASS_DEF_LINALGBLOCKPACKMATMUL
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgElementwiseOpFusionPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_LINALGELEMENTWISEOPFUSIONPASS
|
|
std::unique_ptr<::mlir::Pass> createLinalgElementwiseOpFusionPass();
|
|
#undef GEN_PASS_DECL_LINALGELEMENTWISEOPFUSIONPASS
|
|
#endif // GEN_PASS_DECL_LINALGELEMENTWISEOPFUSIONPASS
|
|
#ifdef GEN_PASS_DEF_LINALGELEMENTWISEOPFUSIONPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgElementwiseOpFusionPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class LinalgElementwiseOpFusionPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = LinalgElementwiseOpFusionPassBase;
|
|
|
|
LinalgElementwiseOpFusionPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
LinalgElementwiseOpFusionPassBase(const LinalgElementwiseOpFusionPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
LinalgElementwiseOpFusionPassBase& operator=(const LinalgElementwiseOpFusionPassBase &) = delete;
|
|
LinalgElementwiseOpFusionPassBase(LinalgElementwiseOpFusionPassBase &&) = delete;
|
|
LinalgElementwiseOpFusionPassBase& operator=(LinalgElementwiseOpFusionPassBase &&) = delete;
|
|
~LinalgElementwiseOpFusionPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("linalg-fuse-elementwise-ops");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "linalg-fuse-elementwise-ops"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Fuse elementwise operations on tensors)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("LinalgElementwiseOpFusionPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "LinalgElementwiseOpFusionPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<affine::AffineDialect>();
|
|
registry.insert<linalg::LinalgDialect>();
|
|
registry.insert<memref::MemRefDialect>();
|
|
}
|
|
|
|
/// 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(LinalgElementwiseOpFusionPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgElementwiseOpFusionPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgElementwiseOpFusionPass() {
|
|
return impl::createLinalgElementwiseOpFusionPass();
|
|
}
|
|
#undef GEN_PASS_DEF_LINALGELEMENTWISEOPFUSIONPASS
|
|
#endif // GEN_PASS_DEF_LINALGELEMENTWISEOPFUSIONPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgFoldIntoElementwisePass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_LINALGFOLDINTOELEMENTWISEPASS
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldIntoElementwisePass();
|
|
#undef GEN_PASS_DECL_LINALGFOLDINTOELEMENTWISEPASS
|
|
#endif // GEN_PASS_DECL_LINALGFOLDINTOELEMENTWISEPASS
|
|
#ifdef GEN_PASS_DEF_LINALGFOLDINTOELEMENTWISEPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldIntoElementwisePass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class LinalgFoldIntoElementwisePassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = LinalgFoldIntoElementwisePassBase;
|
|
|
|
LinalgFoldIntoElementwisePassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
LinalgFoldIntoElementwisePassBase(const LinalgFoldIntoElementwisePassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
LinalgFoldIntoElementwisePassBase& operator=(const LinalgFoldIntoElementwisePassBase &) = delete;
|
|
LinalgFoldIntoElementwisePassBase(LinalgFoldIntoElementwisePassBase &&) = delete;
|
|
LinalgFoldIntoElementwisePassBase& operator=(LinalgFoldIntoElementwisePassBase &&) = delete;
|
|
~LinalgFoldIntoElementwisePassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("linalg-fold-into-elementwise");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "linalg-fold-into-elementwise"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Fold transpose and broadcast ops into elementwise)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("LinalgFoldIntoElementwisePass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "LinalgFoldIntoElementwisePass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
}
|
|
|
|
/// 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(LinalgFoldIntoElementwisePassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgFoldIntoElementwisePass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldIntoElementwisePass() {
|
|
return impl::createLinalgFoldIntoElementwisePass();
|
|
}
|
|
#undef GEN_PASS_DEF_LINALGFOLDINTOELEMENTWISEPASS
|
|
#endif // GEN_PASS_DEF_LINALGFOLDINTOELEMENTWISEPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgFoldUnitExtentDimsPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_LINALGFOLDUNITEXTENTDIMSPASS
|
|
struct LinalgFoldUnitExtentDimsPassOptions {
|
|
bool useRankReducingSlices = false;
|
|
};
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldUnitExtentDimsPass();
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldUnitExtentDimsPass(LinalgFoldUnitExtentDimsPassOptions options);
|
|
#undef GEN_PASS_DECL_LINALGFOLDUNITEXTENTDIMSPASS
|
|
#endif // GEN_PASS_DECL_LINALGFOLDUNITEXTENTDIMSPASS
|
|
#ifdef GEN_PASS_DEF_LINALGFOLDUNITEXTENTDIMSPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldUnitExtentDimsPass();
|
|
} // namespace impl
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldUnitExtentDimsPass(LinalgFoldUnitExtentDimsPassOptions options);
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class LinalgFoldUnitExtentDimsPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = LinalgFoldUnitExtentDimsPassBase;
|
|
|
|
LinalgFoldUnitExtentDimsPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
LinalgFoldUnitExtentDimsPassBase(const LinalgFoldUnitExtentDimsPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
LinalgFoldUnitExtentDimsPassBase& operator=(const LinalgFoldUnitExtentDimsPassBase &) = delete;
|
|
LinalgFoldUnitExtentDimsPassBase(LinalgFoldUnitExtentDimsPassBase &&) = delete;
|
|
LinalgFoldUnitExtentDimsPassBase& operator=(LinalgFoldUnitExtentDimsPassBase &&) = delete;
|
|
~LinalgFoldUnitExtentDimsPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("linalg-fold-unit-extent-dims");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "linalg-fold-unit-extent-dims"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Remove unit-extent dimension in Linalg ops on tensors)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("LinalgFoldUnitExtentDimsPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "LinalgFoldUnitExtentDimsPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
registry.insert<affine::AffineDialect>();
|
|
registry.insert<memref::MemRefDialect>();
|
|
}
|
|
|
|
/// 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(LinalgFoldUnitExtentDimsPassBase<DerivedT>)
|
|
|
|
LinalgFoldUnitExtentDimsPassBase(LinalgFoldUnitExtentDimsPassOptions options) : LinalgFoldUnitExtentDimsPassBase() {
|
|
useRankReducingSlices = std::move(options.useRankReducingSlices);
|
|
}
|
|
protected:
|
|
::mlir::Pass::Option<bool> useRankReducingSlices{*this, "use-rank-reducing-slices", ::llvm::cl::desc(R"PO(Generate rank-reducing slices instead of reassociative reshapes)PO"), ::llvm::cl::init(false)};
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgFoldUnitExtentDimsPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgFoldUnitExtentDimsPass(LinalgFoldUnitExtentDimsPassOptions options) {
|
|
return std::make_unique<DerivedT>(std::move(options));
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldUnitExtentDimsPass() {
|
|
return impl::createLinalgFoldUnitExtentDimsPass();
|
|
}
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgFoldUnitExtentDimsPass(LinalgFoldUnitExtentDimsPassOptions options) {
|
|
return impl::createLinalgFoldUnitExtentDimsPass(std::move(options));
|
|
}
|
|
#undef GEN_PASS_DEF_LINALGFOLDUNITEXTENTDIMSPASS
|
|
#endif // GEN_PASS_DEF_LINALGFOLDUNITEXTENTDIMSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgGeneralizeNamedOpsPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_LINALGGENERALIZENAMEDOPSPASS
|
|
std::unique_ptr<::mlir::Pass> createLinalgGeneralizeNamedOpsPass();
|
|
#undef GEN_PASS_DECL_LINALGGENERALIZENAMEDOPSPASS
|
|
#endif // GEN_PASS_DECL_LINALGGENERALIZENAMEDOPSPASS
|
|
#ifdef GEN_PASS_DEF_LINALGGENERALIZENAMEDOPSPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgGeneralizeNamedOpsPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class LinalgGeneralizeNamedOpsPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = LinalgGeneralizeNamedOpsPassBase;
|
|
|
|
LinalgGeneralizeNamedOpsPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
LinalgGeneralizeNamedOpsPassBase(const LinalgGeneralizeNamedOpsPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
LinalgGeneralizeNamedOpsPassBase& operator=(const LinalgGeneralizeNamedOpsPassBase &) = delete;
|
|
LinalgGeneralizeNamedOpsPassBase(LinalgGeneralizeNamedOpsPassBase &&) = delete;
|
|
LinalgGeneralizeNamedOpsPassBase& operator=(LinalgGeneralizeNamedOpsPassBase &&) = delete;
|
|
~LinalgGeneralizeNamedOpsPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("linalg-generalize-named-ops");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "linalg-generalize-named-ops"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Convert named ops into generic ops)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("LinalgGeneralizeNamedOpsPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "LinalgGeneralizeNamedOpsPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
}
|
|
|
|
/// 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(LinalgGeneralizeNamedOpsPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgGeneralizeNamedOpsPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgGeneralizeNamedOpsPass() {
|
|
return impl::createLinalgGeneralizeNamedOpsPass();
|
|
}
|
|
#undef GEN_PASS_DEF_LINALGGENERALIZENAMEDOPSPASS
|
|
#endif // GEN_PASS_DEF_LINALGGENERALIZENAMEDOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgInlineScalarOperandsPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_LINALGINLINESCALAROPERANDSPASS
|
|
std::unique_ptr<::mlir::Pass> createLinalgInlineScalarOperandsPass();
|
|
#undef GEN_PASS_DECL_LINALGINLINESCALAROPERANDSPASS
|
|
#endif // GEN_PASS_DECL_LINALGINLINESCALAROPERANDSPASS
|
|
#ifdef GEN_PASS_DEF_LINALGINLINESCALAROPERANDSPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgInlineScalarOperandsPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class LinalgInlineScalarOperandsPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = LinalgInlineScalarOperandsPassBase;
|
|
|
|
LinalgInlineScalarOperandsPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
LinalgInlineScalarOperandsPassBase(const LinalgInlineScalarOperandsPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
LinalgInlineScalarOperandsPassBase& operator=(const LinalgInlineScalarOperandsPassBase &) = delete;
|
|
LinalgInlineScalarOperandsPassBase(LinalgInlineScalarOperandsPassBase &&) = delete;
|
|
LinalgInlineScalarOperandsPassBase& operator=(LinalgInlineScalarOperandsPassBase &&) = delete;
|
|
~LinalgInlineScalarOperandsPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("linalg-inline-scalar-operands");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "linalg-inline-scalar-operands"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Inline scalar operands into linalg generic ops)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("LinalgInlineScalarOperandsPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "LinalgInlineScalarOperandsPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
}
|
|
|
|
/// 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(LinalgInlineScalarOperandsPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgInlineScalarOperandsPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgInlineScalarOperandsPass() {
|
|
return impl::createLinalgInlineScalarOperandsPass();
|
|
}
|
|
#undef GEN_PASS_DEF_LINALGINLINESCALAROPERANDSPASS
|
|
#endif // GEN_PASS_DEF_LINALGINLINESCALAROPERANDSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgMorphOpsPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_LINALGMORPHOPSPASS
|
|
struct LinalgMorphOpsPassOptions {
|
|
bool namedToCategory = false;
|
|
bool categoryToGeneric = false;
|
|
bool namedToGeneric = false;
|
|
bool genericToNamed = false;
|
|
bool genericToCategory = false;
|
|
};
|
|
std::unique_ptr<::mlir::Pass> createLinalgMorphOpsPass();
|
|
std::unique_ptr<::mlir::Pass> createLinalgMorphOpsPass(LinalgMorphOpsPassOptions options);
|
|
#undef GEN_PASS_DECL_LINALGMORPHOPSPASS
|
|
#endif // GEN_PASS_DECL_LINALGMORPHOPSPASS
|
|
#ifdef GEN_PASS_DEF_LINALGMORPHOPSPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgMorphOpsPass();
|
|
} // namespace impl
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgMorphOpsPass(LinalgMorphOpsPassOptions options);
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class LinalgMorphOpsPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = LinalgMorphOpsPassBase;
|
|
|
|
LinalgMorphOpsPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
LinalgMorphOpsPassBase(const LinalgMorphOpsPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
LinalgMorphOpsPassBase& operator=(const LinalgMorphOpsPassBase &) = delete;
|
|
LinalgMorphOpsPassBase(LinalgMorphOpsPassBase &&) = delete;
|
|
LinalgMorphOpsPassBase& operator=(LinalgMorphOpsPassBase &&) = delete;
|
|
~LinalgMorphOpsPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("linalg-morph-ops");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "linalg-morph-ops"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Convert linalg ops between forms)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("LinalgMorphOpsPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "LinalgMorphOpsPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
}
|
|
|
|
/// 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(LinalgMorphOpsPassBase<DerivedT>)
|
|
|
|
LinalgMorphOpsPassBase(LinalgMorphOpsPassOptions options) : LinalgMorphOpsPassBase() {
|
|
namedToCategory = std::move(options.namedToCategory);
|
|
categoryToGeneric = std::move(options.categoryToGeneric);
|
|
namedToGeneric = std::move(options.namedToGeneric);
|
|
genericToNamed = std::move(options.genericToNamed);
|
|
genericToCategory = std::move(options.genericToCategory);
|
|
}
|
|
protected:
|
|
::mlir::Pass::Option<bool> namedToCategory{*this, "named-to-category", ::llvm::cl::desc(R"PO(convert named ops to category op e.g. `linalg.elementwise`)PO"), ::llvm::cl::init(false)};
|
|
::mlir::Pass::Option<bool> categoryToGeneric{*this, "category-to-generic", ::llvm::cl::desc(R"PO(convert category ops e.g. `linalg.elementwise` to `linalg.generic`)PO"), ::llvm::cl::init(false)};
|
|
::mlir::Pass::Option<bool> namedToGeneric{*this, "named-to-generic", ::llvm::cl::desc(R"PO(convert named ops e.g. `linalg.add` to `linalg.generic`)PO"), ::llvm::cl::init(false)};
|
|
::mlir::Pass::Option<bool> genericToNamed{*this, "generic-to-named", ::llvm::cl::desc(R"PO(convert linalg.generic to equivalent named ops)PO"), ::llvm::cl::init(false)};
|
|
::mlir::Pass::Option<bool> genericToCategory{*this, "generic-to-category", ::llvm::cl::desc(R"PO(convert linalg.generic to equivalent category ops)PO"), ::llvm::cl::init(false)};
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgMorphOpsPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgMorphOpsPass(LinalgMorphOpsPassOptions options) {
|
|
return std::make_unique<DerivedT>(std::move(options));
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgMorphOpsPass() {
|
|
return impl::createLinalgMorphOpsPass();
|
|
}
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgMorphOpsPass(LinalgMorphOpsPassOptions options) {
|
|
return impl::createLinalgMorphOpsPass(std::move(options));
|
|
}
|
|
#undef GEN_PASS_DEF_LINALGMORPHOPSPASS
|
|
#endif // GEN_PASS_DEF_LINALGMORPHOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgSpecializeGenericOpsPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_LINALGSPECIALIZEGENERICOPSPASS
|
|
std::unique_ptr<::mlir::Pass> createLinalgSpecializeGenericOpsPass();
|
|
#undef GEN_PASS_DECL_LINALGSPECIALIZEGENERICOPSPASS
|
|
#endif // GEN_PASS_DECL_LINALGSPECIALIZEGENERICOPSPASS
|
|
#ifdef GEN_PASS_DEF_LINALGSPECIALIZEGENERICOPSPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createLinalgSpecializeGenericOpsPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class LinalgSpecializeGenericOpsPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = LinalgSpecializeGenericOpsPassBase;
|
|
|
|
LinalgSpecializeGenericOpsPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
LinalgSpecializeGenericOpsPassBase(const LinalgSpecializeGenericOpsPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
LinalgSpecializeGenericOpsPassBase& operator=(const LinalgSpecializeGenericOpsPassBase &) = delete;
|
|
LinalgSpecializeGenericOpsPassBase(LinalgSpecializeGenericOpsPassBase &&) = delete;
|
|
LinalgSpecializeGenericOpsPassBase& operator=(LinalgSpecializeGenericOpsPassBase &&) = delete;
|
|
~LinalgSpecializeGenericOpsPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("linalg-specialize-generic-ops");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "linalg-specialize-generic-ops"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Convert generic ops back to named ops)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("LinalgSpecializeGenericOpsPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "LinalgSpecializeGenericOpsPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
}
|
|
|
|
/// 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(LinalgSpecializeGenericOpsPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createLinalgSpecializeGenericOpsPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createLinalgSpecializeGenericOpsPass() {
|
|
return impl::createLinalgSpecializeGenericOpsPass();
|
|
}
|
|
#undef GEN_PASS_DEF_LINALGSPECIALIZEGENERICOPSPASS
|
|
#endif // GEN_PASS_DEF_LINALGSPECIALIZEGENERICOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// SimplifyDepthwiseConvPass
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_DECL_SIMPLIFYDEPTHWISECONVPASS
|
|
std::unique_ptr<::mlir::Pass> createSimplifyDepthwiseConvPass();
|
|
#undef GEN_PASS_DECL_SIMPLIFYDEPTHWISECONVPASS
|
|
#endif // GEN_PASS_DECL_SIMPLIFYDEPTHWISECONVPASS
|
|
#ifdef GEN_PASS_DEF_SIMPLIFYDEPTHWISECONVPASS
|
|
|
|
namespace impl {
|
|
std::unique_ptr<::mlir::Pass> createSimplifyDepthwiseConvPass();
|
|
} // namespace impl
|
|
namespace impl {
|
|
|
|
template <typename DerivedT>
|
|
class SimplifyDepthwiseConvPassBase : public ::mlir::OperationPass<> {
|
|
public:
|
|
using Base = SimplifyDepthwiseConvPassBase;
|
|
|
|
SimplifyDepthwiseConvPassBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
|
|
SimplifyDepthwiseConvPassBase(const SimplifyDepthwiseConvPassBase &other) : ::mlir::OperationPass<>(other) {}
|
|
SimplifyDepthwiseConvPassBase& operator=(const SimplifyDepthwiseConvPassBase &) = delete;
|
|
SimplifyDepthwiseConvPassBase(SimplifyDepthwiseConvPassBase &&) = delete;
|
|
SimplifyDepthwiseConvPassBase& operator=(SimplifyDepthwiseConvPassBase &&) = delete;
|
|
~SimplifyDepthwiseConvPassBase() = default;
|
|
|
|
/// Returns the command-line argument attached to this pass.
|
|
static constexpr ::llvm::StringLiteral getArgumentName() {
|
|
return ::llvm::StringLiteral("simplify-depthwise-conv");
|
|
}
|
|
::llvm::StringRef getArgument() const override { return "simplify-depthwise-conv"; }
|
|
|
|
::llvm::StringRef getDescription() const override { return R"PD(Simplify depthwise convolution.)PD"; }
|
|
|
|
/// Returns the derived pass name.
|
|
static constexpr ::llvm::StringLiteral getPassName() {
|
|
return ::llvm::StringLiteral("SimplifyDepthwiseConvPass");
|
|
}
|
|
::llvm::StringRef getName() const override { return "SimplifyDepthwiseConvPass"; }
|
|
|
|
/// 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 {
|
|
registry.insert<linalg::LinalgDialect>();
|
|
registry.insert<tensor::TensorDialect>();
|
|
}
|
|
|
|
/// 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(SimplifyDepthwiseConvPassBase<DerivedT>)
|
|
|
|
protected:
|
|
private:
|
|
|
|
friend std::unique_ptr<::mlir::Pass> createSimplifyDepthwiseConvPass() {
|
|
return std::make_unique<DerivedT>();
|
|
}
|
|
};
|
|
} // namespace impl
|
|
|
|
std::unique_ptr<::mlir::Pass> createSimplifyDepthwiseConvPass() {
|
|
return impl::createSimplifyDepthwiseConvPass();
|
|
}
|
|
#undef GEN_PASS_DEF_SIMPLIFYDEPTHWISECONVPASS
|
|
#endif // GEN_PASS_DEF_SIMPLIFYDEPTHWISECONVPASS
|
|
#ifdef GEN_PASS_REGISTRATION
|
|
// Generate registrations for all passes.
|
|
#define GEN_PASS_REGISTRATION_CONVERTELEMENTWISETOLINALGPASS
|
|
#define GEN_PASS_REGISTRATION_CONVERTLINALGTOAFFINELOOPSPASS
|
|
#define GEN_PASS_REGISTRATION_CONVERTLINALGTOLOOPSPASS
|
|
#define GEN_PASS_REGISTRATION_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
#define GEN_PASS_REGISTRATION_LINALGBLOCKPACKMATMUL
|
|
#define GEN_PASS_REGISTRATION_LINALGELEMENTWISEOPFUSIONPASS
|
|
#define GEN_PASS_REGISTRATION_LINALGFOLDINTOELEMENTWISEPASS
|
|
#define GEN_PASS_REGISTRATION_LINALGFOLDUNITEXTENTDIMSPASS
|
|
#define GEN_PASS_REGISTRATION_LINALGGENERALIZENAMEDOPSPASS
|
|
#define GEN_PASS_REGISTRATION_LINALGINLINESCALAROPERANDSPASS
|
|
#define GEN_PASS_REGISTRATION_LINALGMORPHOPSPASS
|
|
#define GEN_PASS_REGISTRATION_LINALGSPECIALIZEGENERICOPSPASS
|
|
#define GEN_PASS_REGISTRATION_SIMPLIFYDEPTHWISECONVPASS
|
|
#endif // GEN_PASS_REGISTRATION
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ConvertElementwiseToLinalgPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_CONVERTELEMENTWISETOLINALGPASS
|
|
|
|
inline void registerConvertElementwiseToLinalgPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createConvertElementwiseToLinalgPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerConvertElementwiseToLinalgPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createConvertElementwiseToLinalgPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_CONVERTELEMENTWISETOLINALGPASS
|
|
#endif // GEN_PASS_REGISTRATION_CONVERTELEMENTWISETOLINALGPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ConvertLinalgToAffineLoopsPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_CONVERTLINALGTOAFFINELOOPSPASS
|
|
|
|
inline void registerConvertLinalgToAffineLoopsPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createConvertLinalgToAffineLoopsPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerConvertLinalgToAffineLoopsPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createConvertLinalgToAffineLoopsPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_CONVERTLINALGTOAFFINELOOPSPASS
|
|
#endif // GEN_PASS_REGISTRATION_CONVERTLINALGTOAFFINELOOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ConvertLinalgToLoopsPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_CONVERTLINALGTOLOOPSPASS
|
|
|
|
inline void registerConvertLinalgToLoopsPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createConvertLinalgToLoopsPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerConvertLinalgToLoopsPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createConvertLinalgToLoopsPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_CONVERTLINALGTOLOOPSPASS
|
|
#endif // GEN_PASS_REGISTRATION_CONVERTLINALGTOLOOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ConvertLinalgToParallelLoopsPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
|
|
inline void registerConvertLinalgToParallelLoopsPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createConvertLinalgToParallelLoopsPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerConvertLinalgToParallelLoopsPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createConvertLinalgToParallelLoopsPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
#endif // GEN_PASS_REGISTRATION_CONVERTLINALGTOPARALLELLOOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgBlockPackMatmul Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_LINALGBLOCKPACKMATMUL
|
|
|
|
inline void registerLinalgBlockPackMatmul() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgBlockPackMatmul();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerLinalgBlockPackMatmulPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgBlockPackMatmul();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_LINALGBLOCKPACKMATMUL
|
|
#endif // GEN_PASS_REGISTRATION_LINALGBLOCKPACKMATMUL
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgElementwiseOpFusionPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_LINALGELEMENTWISEOPFUSIONPASS
|
|
|
|
inline void registerLinalgElementwiseOpFusionPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgElementwiseOpFusionPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerLinalgElementwiseOpFusionPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgElementwiseOpFusionPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_LINALGELEMENTWISEOPFUSIONPASS
|
|
#endif // GEN_PASS_REGISTRATION_LINALGELEMENTWISEOPFUSIONPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgFoldIntoElementwisePass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_LINALGFOLDINTOELEMENTWISEPASS
|
|
|
|
inline void registerLinalgFoldIntoElementwisePass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgFoldIntoElementwisePass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerLinalgFoldIntoElementwisePassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgFoldIntoElementwisePass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_LINALGFOLDINTOELEMENTWISEPASS
|
|
#endif // GEN_PASS_REGISTRATION_LINALGFOLDINTOELEMENTWISEPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgFoldUnitExtentDimsPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_LINALGFOLDUNITEXTENTDIMSPASS
|
|
|
|
inline void registerLinalgFoldUnitExtentDimsPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgFoldUnitExtentDimsPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerLinalgFoldUnitExtentDimsPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgFoldUnitExtentDimsPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_LINALGFOLDUNITEXTENTDIMSPASS
|
|
#endif // GEN_PASS_REGISTRATION_LINALGFOLDUNITEXTENTDIMSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgGeneralizeNamedOpsPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_LINALGGENERALIZENAMEDOPSPASS
|
|
|
|
inline void registerLinalgGeneralizeNamedOpsPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgGeneralizeNamedOpsPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerLinalgGeneralizeNamedOpsPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgGeneralizeNamedOpsPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_LINALGGENERALIZENAMEDOPSPASS
|
|
#endif // GEN_PASS_REGISTRATION_LINALGGENERALIZENAMEDOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgInlineScalarOperandsPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_LINALGINLINESCALAROPERANDSPASS
|
|
|
|
inline void registerLinalgInlineScalarOperandsPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgInlineScalarOperandsPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerLinalgInlineScalarOperandsPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgInlineScalarOperandsPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_LINALGINLINESCALAROPERANDSPASS
|
|
#endif // GEN_PASS_REGISTRATION_LINALGINLINESCALAROPERANDSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgMorphOpsPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_LINALGMORPHOPSPASS
|
|
|
|
inline void registerLinalgMorphOpsPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgMorphOpsPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerLinalgMorphOpsPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgMorphOpsPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_LINALGMORPHOPSPASS
|
|
#endif // GEN_PASS_REGISTRATION_LINALGMORPHOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LinalgSpecializeGenericOpsPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_LINALGSPECIALIZEGENERICOPSPASS
|
|
|
|
inline void registerLinalgSpecializeGenericOpsPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgSpecializeGenericOpsPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerLinalgSpecializeGenericOpsPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createLinalgSpecializeGenericOpsPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_LINALGSPECIALIZEGENERICOPSPASS
|
|
#endif // GEN_PASS_REGISTRATION_LINALGSPECIALIZEGENERICOPSPASS
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// SimplifyDepthwiseConvPass Registration
|
|
//===----------------------------------------------------------------------===//
|
|
#ifdef GEN_PASS_REGISTRATION_SIMPLIFYDEPTHWISECONVPASS
|
|
|
|
inline void registerSimplifyDepthwiseConvPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createSimplifyDepthwiseConvPass();
|
|
});
|
|
}
|
|
|
|
// Old registration code, kept for temporary backwards compatibility.
|
|
inline void registerSimplifyDepthwiseConvPassPass() {
|
|
::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
|
|
return createSimplifyDepthwiseConvPass();
|
|
});
|
|
}
|
|
|
|
#undef GEN_PASS_REGISTRATION_SIMPLIFYDEPTHWISECONVPASS
|
|
#endif // GEN_PASS_REGISTRATION_SIMPLIFYDEPTHWISECONVPASS
|
|
#ifdef GEN_PASS_REGISTRATION
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Linalg Registration
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
inline void registerLinalgPasses() {
|
|
registerConvertElementwiseToLinalgPass();
|
|
registerConvertLinalgToAffineLoopsPass();
|
|
registerConvertLinalgToLoopsPass();
|
|
registerConvertLinalgToParallelLoopsPass();
|
|
registerLinalgBlockPackMatmul();
|
|
registerLinalgElementwiseOpFusionPass();
|
|
registerLinalgFoldIntoElementwisePass();
|
|
registerLinalgFoldUnitExtentDimsPass();
|
|
registerLinalgGeneralizeNamedOpsPass();
|
|
registerLinalgInlineScalarOperandsPass();
|
|
registerLinalgMorphOpsPass();
|
|
registerLinalgSpecializeGenericOpsPass();
|
|
registerSimplifyDepthwiseConvPass();
|
|
}
|
|
#undef GEN_PASS_REGISTRATION
|
|
#endif // GEN_PASS_REGISTRATION
|
|
#ifdef GEN_PASS_CLASSES
|
|
#error "GEN_PASS_CLASSES is deprecated; use per-pass macros"
|
|
#undef GEN_PASS_CLASSES
|
|
#endif // GEN_PASS_CLASSES
|