1//===- WrapFuncInClass.cpp - Wrap Emitc Funcs in classes -------------===//
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/IR/EmitC.h"
10#include "mlir/Dialect/EmitC/Transforms/Passes.h"
11#include "mlir/Dialect/EmitC/Transforms/Transforms.h"
12#include "mlir/IR/Attributes.h"
13#include "mlir/IR/Builders.h"
14#include "mlir/IR/BuiltinAttributes.h"
15#include "mlir/IR/PatternMatch.h"
16#include "mlir/IR/SymbolTable.h"
17#include "mlir/Transforms/WalkPatternRewriteDriver.h"
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/DenseSet.h"
20#include "llvm/Support/FormatVariadic.h"
21
22using namespace mlir;
23using namespace emitc;
24
25namespace mlir {
26namespace emitc {
27#define GEN_PASS_DEF_WRAPFUNCINCLASSPASS
28#include "mlir/Dialect/EmitC/Transforms/Passes.h.inc"
29
30namespace {
31struct WrapFuncInClassPass
32 : public impl::WrapFuncInClassPassBase<WrapFuncInClassPass> {
33 using WrapFuncInClassPassBase::WrapFuncInClassPassBase;
34 void runOnOperation() override {
35 mlir::ModuleOp moduleOp = getOperation();
36
37 DenseMap<FuncOp, llvm::DenseSet<GlobalOp>> globalsUsedByFuncs;
38
39 SymbolTableCollection symbolTable;
40 moduleOp.walk(callback: [&globalsUsedByFuncs, &symbolTable](FuncOp funcOp) {
41 funcOp.walk(callback: [&globalsUsedByFuncs, &symbolTable,
42 &funcOp](GetGlobalOp getGlobalOp) {
43 if (auto globalOp = symbolTable.lookupNearestSymbolFrom<GlobalOp>(
44 from: getGlobalOp, symbol: getGlobalOp.getNameAttr())) {
45 globalsUsedByFuncs[funcOp].insert(V: globalOp);
46 }
47 });
48 });
49
50 RewritePatternSet patterns(&getContext());
51 populateWrapFuncInClass(patterns, funcName, classNameFormat,
52 globalsToMove&: globalsUsedByFuncs);
53
54 walkAndApplyPatterns(op: moduleOp, patterns: std::move(patterns));
55
56 DenseSet<GlobalOp> globalsToErase;
57 for (auto &[_, globals] : globalsUsedByFuncs)
58 globalsToErase.insert_range(R&: globals);
59
60 for (GlobalOp globalOp : globalsToErase)
61 globalOp.erase();
62 }
63};
64
65} // namespace
66} // namespace emitc
67} // namespace mlir
68
69class WrapFuncInClass : public OpRewritePattern<FuncOp> {
70public:
71 WrapFuncInClass(
72 MLIRContext *context, StringRef funcName, StringRef classNameFormat,
73 const DenseMap<FuncOp, llvm::DenseSet<GlobalOp>> &globalsToMove)
74 : OpRewritePattern<FuncOp>(context), funcName(funcName),
75 classNameFormat(classNameFormat), globalsToMove(globalsToMove) {}
76
77 LogicalResult matchAndRewrite(FuncOp funcOp,
78 PatternRewriter &rewriter) const override {
79
80 std::string className = llvm::formatv(
81 /*Validate=*/false, Fmt: classNameFormat.c_str(), Vals: funcOp.getName());
82 ClassOp newClassOp = ClassOp::create(builder&: rewriter, location: funcOp.getLoc(), sym_name: className,
83 /*sym_visibility=*/nullptr);
84
85 SmallVector<std::pair<StringAttr, TypeAttr>> fields;
86 rewriter.createBlock(parent: &newClassOp.getBody());
87 rewriter.setInsertionPointToStart(&newClassOp.getBody().front());
88
89 auto argAttrs = funcOp.getArgAttrs();
90 for (auto [idx, val] : llvm::enumerate(First: funcOp.getArguments())) {
91 StringAttr fieldName =
92 rewriter.getStringAttr(bytes: "fieldName" + std::to_string(val: idx));
93
94 TypeAttr typeAttr = TypeAttr::get(type: val.getType());
95 fields.push_back(Elt: {fieldName, typeAttr});
96
97 FieldOp fieldop =
98 FieldOp::create(builder&: rewriter, location: funcOp->getLoc(), sym_name: fieldName,
99 /*sym_visibility=*/nullptr, type: typeAttr, initial_value: nullptr);
100
101 if (argAttrs && idx < argAttrs->size()) {
102 fieldop->setDiscardableAttrs(funcOp.getArgAttrDict(index: idx));
103 }
104 }
105
106 auto globalsIt = globalsToMove.find(Val: funcOp);
107 if (globalsIt != globalsToMove.end()) {
108 for (auto global : globalsIt->second) {
109 FieldOp::create(builder&: rewriter, location: funcOp->getLoc(), sym_name: global.getSymNameAttr(),
110 /*sym_visibility=*/nullptr, type: global.getTypeAttr(),
111 initial_value: global.getInitialValueAttr());
112 }
113 }
114
115 rewriter.setInsertionPointToEnd(&newClassOp.getBody().front());
116 FunctionType funcType = funcOp.getFunctionType();
117 Location loc = funcOp.getLoc();
118 FuncOp newFuncOp = FuncOp::create(builder&: rewriter, location: loc, name: (funcName), type: funcType);
119
120 // Rewrite globals while they are still descendants of the matched op.
121 funcOp.walk(callback: [&](GetGlobalOp getGlobalOp) {
122 rewriter.setInsertionPoint(getGlobalOp);
123 GetFieldOp getFieldOp =
124 GetFieldOp::create(builder&: rewriter, location: getGlobalOp.getLoc(),
125 result: getGlobalOp.getType(), field_name: getGlobalOp.getNameAttr());
126 rewriter.replaceOp(op: getGlobalOp, newOp: getFieldOp);
127 });
128
129 rewriter.createBlock(parent: &newFuncOp.getBody());
130 newFuncOp.getBody().takeBody(other&: funcOp.getBody());
131
132 rewriter.setInsertionPointToStart(&newFuncOp.getBody().front());
133 std::vector<Value> newArguments;
134 newArguments.reserve(n: fields.size());
135 for (auto &[fieldName, attr] : fields) {
136 GetFieldOp arg =
137 GetFieldOp::create(builder&: rewriter, location: loc, result: attr.getValue(), field_name: fieldName);
138 newArguments.push_back(x: arg);
139 }
140
141 for (auto [oldArg, newArg] :
142 llvm::zip(t: newFuncOp.getArguments(), u&: newArguments)) {
143 rewriter.replaceAllUsesWith(from: oldArg, to: newArg);
144 }
145
146 llvm::BitVector argsToErase(newFuncOp.getNumArguments(), true);
147 if (failed(Result: newFuncOp.eraseArguments(argIndices: argsToErase)))
148 newFuncOp->emitOpError(message: "failed to erase all arguments using BitVector");
149
150 rewriter.replaceOp(op: funcOp, newOp: newClassOp);
151 return success();
152 }
153
154private:
155 /// Name of the newly generated member function with body matching the input
156 /// function.
157 std::string funcName;
158
159 /// Format string used to create the wrapper class name where the
160 /// function-name placeholder '{}' is optional.
161 std::string classNameFormat;
162
163 /// Map of FuncOp and the GlobalOps it uses which need to be moved into the
164 /// ClassOp wrapper.
165 DenseMap<FuncOp, llvm::DenseSet<GlobalOp>> globalsToMove;
166};
167
168void mlir::emitc::populateWrapFuncInClass(
169 RewritePatternSet &patterns, StringRef funcName, StringRef classNameFormat,
170 DenseMap<FuncOp, DenseSet<GlobalOp>> &globalsToMove) {
171 patterns.add<WrapFuncInClass>(arg: patterns.getContext(), args&: funcName,
172 args&: classNameFormat, args&: globalsToMove);
173}
174