1//===- ExpandDivs.cpp - Expansion patterns for MemRef operations ----------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "mlir/Dialect/Arith/IR/Arith.h"
10#include "mlir/Dialect/Arith/Transforms/Passes.h"
11#include "mlir/Dialect/MemRef/IR/MemRef.h"
12#include "mlir/Dialect/MemRef/Transforms/Transforms.h"
13#include "mlir/IR/TypeUtilities.h"
14#include "mlir/Transforms/DialectConversion.h"
15
16namespace mlir {
17namespace memref {
18#define GEN_PASS_DEF_EXPANDOPSPASS
19#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
20} // namespace memref
21} // namespace mlir
22
23using namespace mlir;
24
25namespace {
26
27/// Converts `memref.reshape` that has a target shape of a statically-known
28/// size to `memref.reinterpret_cast`.
29struct MemRefReshapeOpConverter : public OpRewritePattern<memref::ReshapeOp> {
30public:
31 using Base::Base;
32
33 LogicalResult matchAndRewrite(memref::ReshapeOp op,
34 PatternRewriter &rewriter) const final {
35 auto shapeType = cast<MemRefType>(Val: op.getShape().getType());
36 if (!shapeType.hasStaticShape())
37 return failure();
38
39 int64_t rank = cast<MemRefType>(Val&: shapeType).getDimSize(idx: 0);
40 SmallVector<OpFoldResult, 4> sizes, strides;
41 sizes.resize(N: rank);
42 strides.resize(N: rank);
43
44 Location loc = op.getLoc();
45 Value stride = nullptr;
46 int64_t staticStride = 1;
47 MemRefType resultType = cast<MemRefType>(Val: op.getType());
48 for (int i = rank - 1; i >= 0; --i) {
49 Value size;
50 // Load dynamic sizes from the shape input, use constants for static dims.
51 if (resultType.isDynamicDim(idx: i)) {
52 Value index = arith::ConstantIndexOp::create(builder&: rewriter, location: loc, value: i);
53 size = memref::LoadOp::create(builder&: rewriter, location: loc, memref: op.getShape(), indices: index);
54 if (!isa<IndexType>(Val: size.getType()))
55 size = arith::IndexCastOp::create(builder&: rewriter, location: loc,
56 out: rewriter.getIndexType(), in: size);
57 sizes[i] = size;
58 } else {
59 auto sizeAttr = rewriter.getIndexAttr(value: resultType.getDimSize(idx: i));
60 size = arith::ConstantOp::create(builder&: rewriter, location: loc, value: sizeAttr);
61 sizes[i] = sizeAttr;
62 }
63 if (stride)
64 strides[i] = stride;
65 else
66 strides[i] = rewriter.getIndexAttr(value: staticStride);
67
68 if (i > 0) {
69 if (stride) {
70 stride = arith::MulIOp::create(builder&: rewriter, location: loc, lhs: stride, rhs: size);
71 } else if (resultType.isDynamicDim(idx: i)) {
72 stride = arith::MulIOp::create(
73 builder&: rewriter, location: loc,
74 lhs: arith::ConstantIndexOp::create(builder&: rewriter, location: loc, value: staticStride),
75 rhs: size);
76 } else {
77 staticStride *= resultType.getDimSize(idx: i);
78 }
79 }
80 }
81 rewriter.replaceOpWithNewOp<memref::ReinterpretCastOp>(
82 op, args&: resultType, args: op.getSource(), /*offset=*/args: rewriter.getIndexAttr(value: 0),
83 args&: sizes, args&: strides);
84 return success();
85 }
86};
87
88struct ExpandOpsPass : public memref::impl::ExpandOpsPassBase<ExpandOpsPass> {
89 void runOnOperation() override {
90 MLIRContext &ctx = getContext();
91
92 RewritePatternSet patterns(&ctx);
93 memref::populateExpandOpsPatterns(patterns);
94 ConversionTarget target(ctx);
95
96 target.addLegalDialect<arith::ArithDialect, memref::MemRefDialect>();
97 target.addDynamicallyLegalOp<memref::ReshapeOp>(callback: [](memref::ReshapeOp op) {
98 return !cast<MemRefType>(Val: op.getShape().getType()).hasStaticShape();
99 });
100 if (failed(Result: applyPartialConversion(op: getOperation(), target,
101 patterns: std::move(patterns))))
102 signalPassFailure();
103 }
104};
105
106} // namespace
107
108void mlir::memref::populateExpandOpsPatterns(RewritePatternSet &patterns) {
109 patterns.add<MemRefReshapeOpConverter>(arg: patterns.getContext());
110}
111