8d67d187ba
This revision removes the TypeConverter parameter passed to the apply* methods, and instead moves the responsibility of region type conversion to patterns. The types of a region can be converted using the 'convertRegionTypes' method, which acts similarly to the existing 'applySignatureConversion'. This method ensures that all blocks within, and including those moved into, a region will have the block argument types converted using the provided converter. This has the benefit of making more of the legalization logic controlled by patterns, instead of being handled explicitly by the driver. It also opens up the possibility to support multiple type conversions at some point in the future. This revision also adds a new utility class `FailureOr<T>` that provides a LogicalResult friendly facility for returning a failure or a valid result value. Differential Revision: https://reviews.llvm.org/D81681
118 lines
3.7 KiB
C++
118 lines
3.7 KiB
C++
//===- ShapeToStandard.cpp - conversion from Shape to Standard dialect ----===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
|
|
|
|
#include "../PassDetail.h"
|
|
#include "mlir/Dialect/SCF/SCF.h"
|
|
#include "mlir/Dialect/Shape/IR/Shape.h"
|
|
#include "mlir/Dialect/StandardOps/IR/Ops.h"
|
|
#include "mlir/Transforms/DialectConversion.h"
|
|
|
|
using namespace mlir;
|
|
using namespace mlir::shape;
|
|
|
|
namespace {
|
|
|
|
/// Generated conversion patterns.
|
|
#include "ShapeToStandardPatterns.inc"
|
|
|
|
/// Conversion patterns.
|
|
template <typename SrcOpTy, typename DstOpTy>
|
|
class BinaryOpConversion : public OpConversionPattern<SrcOpTy> {
|
|
public:
|
|
using OpConversionPattern<SrcOpTy>::OpConversionPattern;
|
|
|
|
LogicalResult
|
|
matchAndRewrite(SrcOpTy op, ArrayRef<Value> operands,
|
|
ConversionPatternRewriter &rewriter) const override {
|
|
typename SrcOpTy::Adaptor adaptor(operands);
|
|
rewriter.replaceOpWithNewOp<DstOpTy>(op.getOperation(), adaptor.lhs(),
|
|
adaptor.rhs());
|
|
return success();
|
|
}
|
|
};
|
|
|
|
class ConstSizeOpConverter : public OpConversionPattern<ConstSizeOp> {
|
|
public:
|
|
using OpConversionPattern<ConstSizeOp>::OpConversionPattern;
|
|
|
|
LogicalResult
|
|
matchAndRewrite(ConstSizeOp op, ArrayRef<Value> operands,
|
|
ConversionPatternRewriter &rewriter) const override {
|
|
rewriter.replaceOpWithNewOp<ConstantIndexOp>(op.getOperation(),
|
|
op.value().getSExtValue());
|
|
return success();
|
|
}
|
|
};
|
|
|
|
/// Type conversions.
|
|
class ShapeTypeConverter : public TypeConverter {
|
|
public:
|
|
using TypeConverter::convertType;
|
|
|
|
ShapeTypeConverter(MLIRContext *ctx) {
|
|
// Add default pass-through conversion.
|
|
addConversion([&](Type type) { return type; });
|
|
|
|
addConversion([ctx](SizeType type) { return IndexType::get(ctx); });
|
|
addConversion([ctx](ShapeType type) {
|
|
return RankedTensorType::get({ShapedType::kDynamicSize},
|
|
IndexType::get(ctx));
|
|
});
|
|
}
|
|
};
|
|
|
|
/// Conversion pass.
|
|
class ConvertShapeToStandardPass
|
|
: public ConvertShapeToStandardBase<ConvertShapeToStandardPass> {
|
|
|
|
void runOnOperation() override {
|
|
// Setup type conversion.
|
|
MLIRContext &ctx = getContext();
|
|
ShapeTypeConverter typeConverter(&ctx);
|
|
|
|
// Setup target legality.
|
|
ConversionTarget target(ctx);
|
|
target.addLegalDialect<scf::SCFDialect, StandardOpsDialect>();
|
|
target.addLegalOp<ModuleOp, ModuleTerminatorOp, ReturnOp>();
|
|
target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
|
|
return typeConverter.isSignatureLegal(op.getType()) &&
|
|
typeConverter.isLegal(&op.getBody());
|
|
});
|
|
|
|
// Setup conversion patterns.
|
|
OwningRewritePatternList patterns;
|
|
populateShapeToStandardConversionPatterns(patterns, &ctx);
|
|
populateFuncOpTypeConversionPattern(patterns, &ctx, typeConverter);
|
|
|
|
// Apply conversion.
|
|
auto module = getOperation();
|
|
if (failed(applyFullConversion(module, target, patterns)))
|
|
signalPassFailure();
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
void mlir::populateShapeToStandardConversionPatterns(
|
|
OwningRewritePatternList &patterns, MLIRContext *ctx) {
|
|
populateWithGenerated(ctx, &patterns);
|
|
// clang-format off
|
|
patterns.insert<
|
|
BinaryOpConversion<AddOp, AddIOp>,
|
|
BinaryOpConversion<MulOp, MulIOp>,
|
|
ConstSizeOpConverter>(ctx);
|
|
// clang-format on
|
|
}
|
|
|
|
std::unique_ptr<OperationPass<ModuleOp>>
|
|
mlir::createConvertShapeToStandardPass() {
|
|
return std::make_unique<ConvertShapeToStandardPass>();
|
|
}
|