mirror of
https://github.com/zama-ai/concrete.git
synced 2026-02-09 03:55:04 -05:00
73fd6c5fe7
Use `OpConversionPattern` instead of `OpRewritePattern` for operation conversion during dialect conversion. This makes explicit and in-place type conversions unnecessary, since `OpConversionPattern` already properly converts operand types and provides them to the rewrite rule through an operation adaptor. The main contributions of this commit are the two class templates `TypeConvertingReinstantiationPattern` and `GenericOneToOneOpConversionPattern`. The former allows for the definition of a simple replacement rule that re-instantiates an operation after the types of its operands have been converted. This is especially useful for type-polymorphic operations during dialect conversion. The latter allows for the definition of patterns, where one operation needs to be replaced with a different operation after conversion of its operands. The default implementations for the class templates provide conversions rules for operations that have a generic builder method that takes the desired return type(s), the operands and (optionally) a set of attributes. How attributes are discarded during a conversion (either by omitting the builder argument or by passing an empty set of attributes) can be defined through specialization of `ReinstantiationAttributeDismissalStrategy`. Custom replacement rules that deviate from the scheme above should be implemented by specializing `TypeConvertingReinstantiationPattern::matchAndRewrite()` and `GenericOneToOneOpConversionPattern::matchAndRewrite()`.
41 lines
1.6 KiB
C++
41 lines
1.6 KiB
C++
// Part of the Concrete Compiler Project, under the BSD3 License with Zama
|
|
// Exceptions. See
|
|
// https://github.com/zama-ai/concrete-compiler-internal/blob/main/LICENSE.txt
|
|
// for license information.
|
|
|
|
#include "concretelang/Conversion/Utils/Dialects/SCF.h"
|
|
#include "mlir/Transforms/RegionUtils.h"
|
|
#include <mlir/IR/BlockAndValueMapping.h>
|
|
|
|
namespace mlir {
|
|
namespace concretelang {
|
|
template <>
|
|
mlir::LogicalResult
|
|
TypeConvertingReinstantiationPattern<scf::ForOp, false>::matchAndRewrite(
|
|
scf::ForOp oldOp, mlir::OpConversionPattern<scf::ForOp>::OpAdaptor adaptor,
|
|
mlir::ConversionPatternRewriter &rewriter) const {
|
|
// Create new for loop with empty body, but converted iter args
|
|
scf::ForOp newForOp = rewriter.replaceOpWithNewOp<scf::ForOp>(
|
|
oldOp, adaptor.getLowerBound(), adaptor.getUpperBound(),
|
|
adaptor.getStep(), adaptor.getInitArgs(),
|
|
[&](OpBuilder &builder, Location loc, Value iv, ValueRange args) {});
|
|
|
|
// Move operations from old for op to new one
|
|
auto &newOperations = newForOp.getBody()->getOperations();
|
|
mlir::Block *oldBody = oldOp.getBody();
|
|
|
|
newOperations.splice(newOperations.begin(), oldBody->getOperations(),
|
|
oldBody->begin(), oldBody->end());
|
|
|
|
// Remap iter args and IV
|
|
for (auto argsPair : llvm::zip(oldOp.getBody()->getArguments(),
|
|
newForOp.getBody()->getArguments())) {
|
|
replaceAllUsesInRegionWith(std::get<0>(argsPair), std::get<1>(argsPair),
|
|
newForOp.getRegion());
|
|
}
|
|
|
|
return mlir::success();
|
|
}
|
|
} // namespace concretelang
|
|
} // namespace mlir
|