1//===- TosaToSCF.cpp - Lowering Tosa to SCF Dialect -----------------------===//
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// These rewriters lower from the Tosa to the SCF dialect.
10//
11//===----------------------------------------------------------------------===//
12
13#include "mlir/Conversion/TosaToSCF/TosaToSCF.h"
14#include "mlir/Dialect/SCF/IR/SCF.h"
15#include "mlir/Dialect/Tensor/IR/Tensor.h"
16#include "mlir/Dialect/Tosa/IR/TosaOps.h"
17#include "mlir/IR/PatternMatch.h"
18
19using namespace mlir;
20using namespace tosa;
21
22static void inlineIfCase(Region &srcRegion, Region &dstRegion,
23 OperandRange operands, PatternRewriter &rewriter) {
24 rewriter.cloneRegionBefore(region&: srcRegion, before: &dstRegion.front());
25 rewriter.eraseBlock(block: &dstRegion.back());
26
27 Block *headBlock = &dstRegion.front();
28 for (auto it : llvm::zip(t: headBlock->getArguments(), u&: operands))
29 std::get<0>(t&: it).replaceAllUsesWith(newValue: std::get<1>(t&: it));
30
31 auto yield = cast<YieldOp>(Val: headBlock->getTerminator());
32 rewriter.setInsertionPoint(yield);
33 scf::YieldOp::create(builder&: rewriter, location: yield.getLoc(), results: yield.getInputs());
34 rewriter.eraseOp(op: yield);
35
36 headBlock->eraseArguments(start: 0, num: headBlock->getNumArguments());
37}
38
39static void inlineWhileCase(Region &srcRegion, Region &dstRegion,
40 PatternRewriter &rewriter, bool isCond) {
41 rewriter.cloneRegionBefore(region&: srcRegion, before: &dstRegion.back());
42 rewriter.eraseBlock(block: &dstRegion.back());
43
44 Block *headBlock = &dstRegion.front();
45
46 auto yield = cast<YieldOp>(Val: headBlock->getTerminator());
47 rewriter.setInsertionPoint(yield);
48 if (isCond) {
49 auto condition = tensor::ExtractOp::create(builder&: rewriter, location: yield.getLoc(),
50 operands: yield.getOperand(i: 0));
51 scf::ConditionOp::create(builder&: rewriter, location: yield.getLoc(), condition,
52 args: headBlock->getArguments());
53 } else {
54 rewriter.setInsertionPoint(yield);
55 scf::YieldOp::create(builder&: rewriter, location: yield.getLoc(), results: yield.getInputs());
56 }
57 rewriter.eraseOp(op: yield);
58}
59
60namespace {
61
62class IfOpConverter : public OpRewritePattern<tosa::IfOp> {
63public:
64 using OpRewritePattern<tosa::IfOp>::OpRewritePattern;
65
66 LogicalResult matchAndRewrite(tosa::IfOp op,
67 PatternRewriter &rewriter) const final {
68 auto condition =
69 tensor::ExtractOp::create(builder&: rewriter, location: op.getLoc(), operands: op.getCondition());
70 auto newIf = scf::IfOp::create(builder&: rewriter, location: op.getLoc(), resultTypes: op.getResultTypes(),
71 cond: condition, withElseRegion: true);
72
73 inlineIfCase(srcRegion&: op.getThenGraph(), dstRegion&: newIf.getThenRegion(), operands: op.getInputList(),
74 rewriter);
75 inlineIfCase(srcRegion&: op.getElseGraph(), dstRegion&: newIf.getElseRegion(), operands: op.getInputList(),
76 rewriter);
77
78 rewriter.replaceOp(op, newValues: newIf.getResults());
79 return success();
80 }
81};
82
83class ScatterOpConverter : public OpRewritePattern<tosa::ScatterOp> {
84 static Value createTensorDim(OpBuilder &builder, Location loc, Value tensor,
85 int64_t dim) {
86 return builder.createOrFold<tensor::DimOp>(location: loc, args&: tensor, args&: dim);
87 }
88
89 static Value createIndexConst(OpBuilder &builder, Location loc,
90 int64_t value) {
91 return arith::ConstantIndexOp::create(builder, location: loc, value);
92 }
93
94public:
95 using OpRewritePattern<tosa::ScatterOp>::OpRewritePattern;
96
97 LogicalResult matchAndRewrite(tosa::ScatterOp scatter,
98 PatternRewriter &rewriter) const final {
99 auto valuesIn = scatter.getValuesIn();
100 auto indices = scatter.getIndices();
101 auto input = scatter.getInput();
102 auto loc = scatter.getLoc();
103
104 if (!isa<RankedTensorType>(Val: valuesIn.getType()) ||
105 !isa<RankedTensorType>(Val: indices.getType()) ||
106 !isa<RankedTensorType>(Val: input.getType())) {
107 return rewriter.notifyMatchFailure(
108 arg&: scatter, msg: "expected ranked tensor operands for scatter lowering");
109 }
110
111 // N, W, C are chosen to match the TOSA spec
112 auto dimN = createTensorDim(builder&: rewriter, loc, tensor: input, dim: 0);
113 auto dimW = createTensorDim(builder&: rewriter, loc, tensor: input, dim: 1);
114 auto dimC = createTensorDim(builder&: rewriter, loc, tensor: input, dim: 2);
115
116 auto zero = createIndexConst(builder&: rewriter, loc, value: 0);
117 auto one = createIndexConst(builder&: rewriter, loc, value: 1);
118
119 // Loop bounds
120 auto lbs = Repeated<Value>(2, zero);
121 auto steps = Repeated<Value>(2, one);
122 auto ubs = llvm::SmallVector<Value>{{dimN, dimW}};
123
124 auto buildBody = [&](OpBuilder &builder, Location loc, ValueRange ivs,
125 ValueRange args) -> scf::ValueVector {
126 auto n = ivs[0];
127
128 // Read the index and cast it to index type
129 auto index = tensor::ExtractOp::create(builder, location: loc, tensor: indices, indices: ivs);
130 auto castIndex = arith::IndexCastOp::create(
131 builder, location: loc, out: builder.getIndexType(), in: index);
132
133 // Offset, sizes, and strides for the input tensor
134 auto inputOffset = llvm::to_vector(Range&: ivs);
135 inputOffset.push_back(Elt: zero);
136
137 llvm::SmallVector<Value> sizes = {one, one, dimC};
138 llvm::SmallVector<Value> strides = {one, one, one};
139
140 auto slice = tensor::ExtractSliceOp::create(builder, location: loc, source: input,
141 offsets: inputOffset, sizes, strides);
142
143 // Insert the slice into the output accumulator tensor.
144 llvm::SmallVector<Value> outputOffset = {n, castIndex, zero};
145 auto updated = tensor::InsertSliceOp::create(
146 builder, location: loc, source: slice, dest: args[0], offsets: outputOffset, sizes, strides);
147
148 return {updated};
149 };
150
151 auto loops = scf::buildLoopNest(builder&: rewriter, loc, lbs, ubs, steps,
152 iterArgs: ValueRange{valuesIn}, bodyBuilder: buildBody);
153 rewriter.replaceOp(op: scatter, newValues: loops.results);
154
155 return success();
156 }
157};
158
159class WhileOpConverter : public OpRewritePattern<tosa::WhileOp> {
160public:
161 using OpRewritePattern<tosa::WhileOp>::OpRewritePattern;
162
163 LogicalResult matchAndRewrite(tosa::WhileOp op,
164 PatternRewriter &rewriter) const final {
165 auto newWhile = scf::WhileOp::create(
166 builder&: rewriter, location: op.getLoc(), resultTypes: op.getResultTypes(), operands: op.getInputList());
167 rewriter.createBlock(parent: &newWhile.getBefore());
168 rewriter.createBlock(parent: &newWhile.getAfter());
169
170 inlineWhileCase(srcRegion&: op.getCondGraph(), dstRegion&: newWhile.getBefore(), rewriter, isCond: true);
171 inlineWhileCase(srcRegion&: op.getBodyGraph(), dstRegion&: newWhile.getAfter(), rewriter, isCond: false);
172
173 rewriter.replaceOp(op, newValues: newWhile.getResults());
174
175 return success();
176 }
177};
178
179} // namespace
180
181void mlir::tosa::populateTosaToSCFConversionPatterns(
182 RewritePatternSet *patterns) {
183 patterns->add<IfOpConverter, ScatterOpConverter, WhileOpConverter>(
184 arg: patterns->getContext());
185}
186