1//===- Transforms.cpp - Patterns and transforms for the EmitC 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#include "mlir/Dialect/EmitC/Transforms/Transforms.h"
10#include "mlir/Dialect/EmitC/IR/EmitC.h"
11#include "mlir/IR/IRMapping.h"
12#include "mlir/IR/Location.h"
13#include "mlir/IR/PatternMatch.h"
14#include "llvm/ADT/STLExtras.h"
15
16namespace mlir {
17namespace emitc {
18
19ExpressionOp createExpression(Operation *op, OpBuilder &builder) {
20 assert(isa<emitc::CExpressionInterface>(op) && "Expected a C expression");
21
22 // Create an expression yielding the value returned by op.
23 assert(op->getNumResults() == 1 && "Expected exactly one result");
24 Value result = op->getResult(idx: 0);
25 Type resultType = result.getType();
26 Location loc = op->getLoc();
27
28 builder.setInsertionPointAfter(op);
29 auto expressionOp =
30 emitc::ExpressionOp::create(builder, location: loc, result: resultType, defs: op->getOperands());
31
32 // Replace all op's uses with the new expression's result.
33 result.replaceAllUsesWith(newValue: expressionOp.getResult());
34
35 Block &block = expressionOp.createBody();
36 IRMapping mapper;
37 for (auto [operand, arg] :
38 llvm::zip(t: expressionOp.getOperands(), u: block.getArguments()))
39 mapper.map(from: operand, to: arg);
40 builder.setInsertionPointToEnd(&block);
41
42 Operation *rootOp = builder.clone(op&: *op, mapper);
43 op->erase();
44
45 // Create an op to yield op's value.
46 emitc::YieldOp::create(builder, location: loc, result: rootOp->getResults()[0]);
47 return expressionOp;
48}
49
50} // namespace emitc
51} // namespace mlir
52
53using namespace mlir;
54using namespace mlir::emitc;
55
56namespace {
57
58struct FoldExpressionOp : public OpRewritePattern<ExpressionOp> {
59 using OpRewritePattern<ExpressionOp>::OpRewritePattern;
60 LogicalResult matchAndRewrite(ExpressionOp expressionOp,
61 PatternRewriter &rewriter) const override {
62 Block *expressionBody = expressionOp.getBody();
63 ExpressionOp usedExpression;
64 SetVector<Value> foldedOperands;
65
66 // Select as expression to fold the first operand expression that
67 // - has a single user: assume any re-materialization was done separately,
68 // - has no side effects,
69 // and save all other operands to be used later as operands in the folded
70 // expression.
71 for (auto [operand, arg] : llvm::zip(t: expressionOp.getOperands(),
72 u: expressionBody->getArguments())) {
73 ExpressionOp operandExpression = operand.getDefiningOp<ExpressionOp>();
74 if (usedExpression || !operandExpression ||
75 !operandExpression.getResult().hasOneUse() ||
76 operandExpression.hasSideEffects())
77 foldedOperands.insert(X: operand);
78 else
79 usedExpression = operandExpression;
80 }
81
82 // If no operand expression was selected, bail out.
83 if (!usedExpression)
84 return failure();
85
86 // Collect additional operands from the folded expression.
87 for (Value operand : usedExpression.getOperands())
88 foldedOperands.insert(X: operand);
89
90 // Create a new expression to hold the folding result.
91 rewriter.setInsertionPointAfter(expressionOp);
92 auto foldedExpression = emitc::ExpressionOp::create(
93 builder&: rewriter, location: expressionOp.getLoc(), result: expressionOp.getResult().getType(),
94 defs: foldedOperands.getArrayRef(), do_not_inline: expressionOp.getDoNotInline());
95 Block &foldedExpressionBody = foldedExpression.createBody();
96
97 // Map each operand of the new expression to its matching block argument.
98 IRMapping mapper;
99 for (auto [operand, arg] : llvm::zip(t: foldedExpression.getOperands(),
100 u: foldedExpressionBody.getArguments()))
101 mapper.map(from: operand, to: arg);
102
103 // Prepare to fold the used expression and the matched expression into the
104 // newly created folded expression.
105 auto foldExpression = [&rewriter, &mapper](ExpressionOp expressionToFold,
106 bool withTerminator) {
107 Block *expressionToFoldBody = expressionToFold.getBody();
108 for (auto [operand, arg] :
109 llvm::zip(t: expressionToFold.getOperands(),
110 u: expressionToFoldBody->getArguments())) {
111 mapper.map(from: arg, to: mapper.lookup(from: operand));
112 }
113
114 for (Operation &opToClone : expressionToFoldBody->without_terminator())
115 rewriter.clone(op&: opToClone, mapper);
116
117 if (withTerminator)
118 rewriter.clone(op&: *expressionToFoldBody->getTerminator(), mapper);
119 };
120 rewriter.setInsertionPointToStart(&foldedExpressionBody);
121
122 // First, fold the used expression into the new expression and map its
123 // result to the clone of its root operation within the new expression.
124 foldExpression(usedExpression, /*withTerminator=*/false);
125 Operation *expressionRoot = usedExpression.getRootOp();
126 Operation *clonedExpressionRootOp = mapper.lookup(from: expressionRoot);
127 assert(clonedExpressionRootOp &&
128 "Expected cloned expression root to be in mapper");
129 assert(clonedExpressionRootOp->getNumResults() == 1 &&
130 "Expected cloned root to have a single result");
131 mapper.map(from: usedExpression.getResult(),
132 to: clonedExpressionRootOp->getResults()[0]);
133
134 // Now fold the matched expression into the new expression.
135 foldExpression(expressionOp, /*withTerminator=*/true);
136
137 // Complete the rewrite.
138 rewriter.replaceOp(op: expressionOp, newOp: foldedExpression);
139 rewriter.eraseOp(op: usedExpression);
140
141 return success();
142 }
143};
144
145} // namespace
146
147void mlir::emitc::populateExpressionPatterns(RewritePatternSet &patterns) {
148 ExpressionOp::getCanonicalizationPatterns(results&: patterns, context: patterns.getContext());
149 patterns.add<FoldExpressionOp>(arg: patterns.getContext());
150}
151