1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
//===- Transforms.cpp - Patterns and transforms for the EmitC 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/Dialect/EmitC/Transforms/Transforms.h"
#include "mlir/Dialect/EmitC/IR/EmitC.h"
#include "mlir/IR/IRMapping.h"
#include "mlir/IR/PatternMatch.h"
#include "llvm/Support/Debug.h"
namespace mlir {
namespace emitc {
ExpressionOp createExpression(Operation *op, OpBuilder &builder) {
assert(op->hasTrait<OpTrait::emitc::CExpression>() &&
"Expected a C expression");
// Create an expression yielding the value returned by op.
assert(op->getNumResults() == 1 && "Expected exactly one result");
Value result = op->getResult(0);
Type resultType = result.getType();
Location loc = op->getLoc();
builder.setInsertionPointAfter(op);
auto expressionOp = builder.create<emitc::ExpressionOp>(loc, resultType);
// Replace all op's uses with the new expression's result.
result.replaceAllUsesWith(expressionOp.getResult());
// Create an op to yield op's value.
Region ®ion = expressionOp.getRegion();
Block &block = region.emplaceBlock();
builder.setInsertionPointToEnd(&block);
auto yieldOp = builder.create<emitc::YieldOp>(loc, result);
// Move op into the new expression.
op->moveBefore(yieldOp);
return expressionOp;
}
} // namespace emitc
} // namespace mlir
using namespace mlir;
using namespace mlir::emitc;
namespace {
struct FoldExpressionOp : public OpRewritePattern<ExpressionOp> {
using OpRewritePattern<ExpressionOp>::OpRewritePattern;
LogicalResult matchAndRewrite(ExpressionOp expressionOp,
PatternRewriter &rewriter) const override {
bool anythingFolded = false;
for (Operation &op : llvm::make_early_inc_range(
expressionOp.getBody()->without_terminator())) {
// Don't fold expressions whose result value has its address taken.
auto applyOp = dyn_cast<emitc::ApplyOp>(op);
if (applyOp && applyOp.getApplicableOperator() == "&")
continue;
for (Value operand : op.getOperands()) {
auto usedExpression =
dyn_cast_if_present<ExpressionOp>(operand.getDefiningOp());
if (!usedExpression)
continue;
// Don't fold expressions with multiple users: assume any
// re-materialization was done separately.
if (!usedExpression.getResult().hasOneUse())
continue;
// Don't fold expressions with side effects.
if (usedExpression.hasSideEffects())
continue;
// Fold the used expression into this expression by cloning all
// instructions in the used expression just before the operation using
// its value.
rewriter.setInsertionPoint(&op);
IRMapping mapper;
for (Operation &opToClone :
usedExpression.getBody()->without_terminator()) {
Operation *clone = rewriter.clone(opToClone, mapper);
mapper.map(&opToClone, clone);
}
Operation *expressionRoot = usedExpression.getRootOp();
Operation *clonedExpressionRootOp = mapper.lookup(expressionRoot);
assert(clonedExpressionRootOp &&
"Expected cloned expression root to be in mapper");
assert(clonedExpressionRootOp->getNumResults() == 1 &&
"Expected cloned root to have a single result");
rewriter.replaceOp(usedExpression, clonedExpressionRootOp);
anythingFolded = true;
}
}
return anythingFolded ? success() : failure();
}
};
} // namespace
void mlir::emitc::populateExpressionPatterns(RewritePatternSet &patterns) {
patterns.add<FoldExpressionOp>(patterns.getContext());
}
|
