1//===- TestMakeIsolatedFromAbove.cpp - Test makeIsolatedFromAbove method -===//
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 "TestOpsCore.h"
10#include "mlir/Dialect/Func/IR/FuncOps.h"
11#include "mlir/IR/PatternMatch.h"
12#include "mlir/Pass/Pass.h"
13#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
14#include "mlir/Transforms/RegionUtils.h"
15
16using namespace mlir;
17
18/// Helper function to call the `makeRegionIsolatedFromAbove` to convert
19/// `test.one_region_op` to `test.isolated_one_region_op`.
20static LogicalResult
21makeIsolatedFromAboveImpl(RewriterBase &rewriter,
22 test::OneRegionWithOperandsOp regionOp,
23 llvm::function_ref<bool(Operation *)> callBack) {
24 Region &region = regionOp.getRegion();
25 SmallVector<Value> capturedValues =
26 makeRegionIsolatedFromAbove(rewriter, region, cloneOperationIntoRegion: callBack);
27 SmallVector<Value> operands = regionOp.getOperands();
28 operands.append(RHS: capturedValues);
29 auto isolatedRegionOp = test::IsolatedOneRegionOp::create(
30 rewriter, regionOp.getLoc(), TypeRange(), operands);
31 rewriter.inlineRegionBefore(region, isolatedRegionOp.getRegion(),
32 isolatedRegionOp.getRegion().begin());
33 rewriter.eraseOp(op: regionOp);
34 return success();
35}
36
37namespace {
38
39/// Simple test for making region isolated from above without cloning any
40/// operations.
41struct SimpleMakeIsolatedFromAbove
42 : OpRewritePattern<test::OneRegionWithOperandsOp> {
43 using Base::Base;
44
45 LogicalResult matchAndRewrite(test::OneRegionWithOperandsOp regionOp,
46 PatternRewriter &rewriter) const override {
47 return makeIsolatedFromAboveImpl(rewriter, regionOp,
48 [](Operation *) { return false; });
49 }
50};
51
52/// Test for making region isolated from above while clong operations
53/// with no operands.
54struct MakeIsolatedFromAboveAndCloneOpsWithNoOperands
55 : OpRewritePattern<test::OneRegionWithOperandsOp> {
56 using Base::Base;
57
58 LogicalResult matchAndRewrite(test::OneRegionWithOperandsOp regionOp,
59 PatternRewriter &rewriter) const override {
60 return makeIsolatedFromAboveImpl(rewriter, regionOp, [](Operation *op) {
61 return op->getNumOperands() == 0;
62 });
63 }
64};
65
66/// Test for making region isolated from above while clong operations
67/// with no operands.
68struct MakeIsolatedFromAboveAndCloneOpsWithOperands
69 : OpRewritePattern<test::OneRegionWithOperandsOp> {
70 using Base::Base;
71
72 LogicalResult matchAndRewrite(test::OneRegionWithOperandsOp regionOp,
73 PatternRewriter &rewriter) const override {
74 return makeIsolatedFromAboveImpl(rewriter, regionOp,
75 [](Operation *op) { return true; });
76 }
77};
78
79/// Test pass for testing the `makeIsolatedFromAbove` function.
80struct TestMakeIsolatedFromAbovePass
81 : public PassWrapper<TestMakeIsolatedFromAbovePass,
82 OperationPass<func::FuncOp>> {
83
84 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMakeIsolatedFromAbovePass)
85
86 TestMakeIsolatedFromAbovePass() = default;
87 TestMakeIsolatedFromAbovePass(const TestMakeIsolatedFromAbovePass &pass)
88 : PassWrapper(pass) {}
89
90 StringRef getArgument() const final {
91 return "test-make-isolated-from-above";
92 }
93
94 StringRef getDescription() const final {
95 return "Test making a region isolated from above";
96 }
97
98 Option<bool> simple{
99 *this, "simple",
100 llvm::cl::desc("Test simple case with no cloning of operations"),
101 llvm::cl::init(Val: false)};
102
103 Option<bool> cloneOpsWithNoOperands{
104 *this, "clone-ops-with-no-operands",
105 llvm::cl::desc("Test case with cloning of operations with no operands"),
106 llvm::cl::init(Val: false)};
107
108 Option<bool> cloneOpsWithOperands{
109 *this, "clone-ops-with-operands",
110 llvm::cl::desc("Test case with cloning of operations with no operands"),
111 llvm::cl::init(Val: false)};
112
113 void runOnOperation() override;
114};
115
116} // namespace
117
118void TestMakeIsolatedFromAbovePass::runOnOperation() {
119 MLIRContext *context = &getContext();
120 func::FuncOp funcOp = getOperation();
121
122 if (simple) {
123 RewritePatternSet patterns(context);
124 patterns.insert<SimpleMakeIsolatedFromAbove>(arg&: context);
125 if (failed(Result: applyPatternsGreedily(op: funcOp, patterns: std::move(patterns)))) {
126 return signalPassFailure();
127 }
128 return;
129 }
130
131 if (cloneOpsWithNoOperands) {
132 RewritePatternSet patterns(context);
133 patterns.insert<MakeIsolatedFromAboveAndCloneOpsWithNoOperands>(arg&: context);
134 if (failed(Result: applyPatternsGreedily(op: funcOp, patterns: std::move(patterns)))) {
135 return signalPassFailure();
136 }
137 return;
138 }
139
140 if (cloneOpsWithOperands) {
141 RewritePatternSet patterns(context);
142 patterns.insert<MakeIsolatedFromAboveAndCloneOpsWithOperands>(arg&: context);
143 if (failed(Result: applyPatternsGreedily(op: funcOp, patterns: std::move(patterns)))) {
144 return signalPassFailure();
145 }
146 return;
147 }
148}
149
150namespace mlir {
151namespace test {
152void registerTestMakeIsolatedFromAbovePass() {
153 PassRegistration<TestMakeIsolatedFromAbovePass>();
154}
155} // namespace test
156} // namespace mlir
157