1 //===- LinalgToStandard.cpp - conversion from Linalg to Standard 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/Conversion/LinalgToStandard/LinalgToStandard.h"
10 
11 #include "../PassDetail.h"
12 #include "mlir/Dialect/Affine/IR/AffineOps.h"
13 #include "mlir/Dialect/Func/IR/FuncOps.h"
14 #include "mlir/Dialect/Linalg/IR/Linalg.h"
15 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
16 #include "mlir/Dialect/MemRef/IR/MemRef.h"
17 #include "mlir/Dialect/SCF/SCF.h"
18 
19 using namespace mlir;
20 using namespace mlir::linalg;
21 
22 /// Helper function to extract the operand types that are passed to the
23 /// generated CallOp. MemRefTypes have their layout canonicalized since the
24 /// information is not used in signature generation.
25 /// Note that static size information is not modified.
26 static SmallVector<Type, 4> extractOperandTypes(Operation *op) {
27   SmallVector<Type, 4> result;
28   result.reserve(op->getNumOperands());
29   for (auto type : op->getOperandTypes()) {
30     // The underlying descriptor type (e.g. LLVM) does not have layout
31     // information. Canonicalizing the type at the level of std when going into
32     // a library call avoids needing to introduce DialectCastOp.
33     if (auto memrefType = type.dyn_cast<MemRefType>())
34       result.push_back(eraseStridedLayout(memrefType));
35     else
36       result.push_back(type);
37   }
38   return result;
39 }
40 
41 // Get a SymbolRefAttr containing the library function name for the LinalgOp.
42 // If the library function does not exist, insert a declaration.
43 static FlatSymbolRefAttr getLibraryCallSymbolRef(Operation *op,
44                                                  PatternRewriter &rewriter) {
45   auto linalgOp = cast<LinalgOp>(op);
46   auto fnName = linalgOp.getLibraryCallName();
47   if (fnName.empty()) {
48     op->emitWarning("No library call defined for: ") << *op;
49     return {};
50   }
51 
52   // fnName is a dynamic std::string, unique it via a SymbolRefAttr.
53   FlatSymbolRefAttr fnNameAttr =
54       SymbolRefAttr::get(rewriter.getContext(), fnName);
55   auto module = op->getParentOfType<ModuleOp>();
56   if (module.lookupSymbol(fnNameAttr.getAttr()))
57     return fnNameAttr;
58 
59   SmallVector<Type, 4> inputTypes(extractOperandTypes(op));
60   assert(op->getNumResults() == 0 &&
61          "Library call for linalg operation can be generated only for ops that "
62          "have void return types");
63   auto libFnType = rewriter.getFunctionType(inputTypes, {});
64 
65   OpBuilder::InsertionGuard guard(rewriter);
66   // Insert before module terminator.
67   rewriter.setInsertionPoint(module.getBody(),
68                              std::prev(module.getBody()->end()));
69   func::FuncOp funcOp = rewriter.create<func::FuncOp>(
70       op->getLoc(), fnNameAttr.getValue(), libFnType);
71   // Insert a function attribute that will trigger the emission of the
72   // corresponding `_mlir_ciface_xxx` interface so that external libraries see
73   // a normalized ABI. This interface is added during std to llvm conversion.
74   funcOp->setAttr("llvm.emit_c_interface", UnitAttr::get(op->getContext()));
75   funcOp.setPrivate();
76   return fnNameAttr;
77 }
78 
79 static SmallVector<Value, 4>
80 createTypeCanonicalizedMemRefOperands(OpBuilder &b, Location loc,
81                                       ValueRange operands) {
82   SmallVector<Value, 4> res;
83   res.reserve(operands.size());
84   for (auto op : operands) {
85     auto memrefType = op.getType().dyn_cast<MemRefType>();
86     if (!memrefType) {
87       res.push_back(op);
88       continue;
89     }
90     Value cast =
91         b.create<memref::CastOp>(loc, eraseStridedLayout(memrefType), op);
92     res.push_back(cast);
93   }
94   return res;
95 }
96 
97 LogicalResult mlir::linalg::LinalgOpToLibraryCallRewrite::matchAndRewrite(
98     LinalgOp op, PatternRewriter &rewriter) const {
99   auto libraryCallName = getLibraryCallSymbolRef(op, rewriter);
100   if (!libraryCallName)
101     return failure();
102 
103   // TODO: Add support for more complex library call signatures that include
104   // indices or captured values.
105   rewriter.replaceOpWithNewOp<func::CallOp>(
106       op, libraryCallName.getValue(), TypeRange(),
107       createTypeCanonicalizedMemRefOperands(rewriter, op->getLoc(),
108                                             op->getOperands()));
109   return success();
110 }
111 
112 
113 /// Populate the given list with patterns that convert from Linalg to Standard.
114 void mlir::linalg::populateLinalgToStandardConversionPatterns(
115     RewritePatternSet &patterns) {
116   // TODO: ConvOp conversion needs to export a descriptor with relevant
117   // attribute values such as kernel striding and dilation.
118   patterns.add<LinalgOpToLibraryCallRewrite>(patterns.getContext());
119 }
120 
121 namespace {
122 struct ConvertLinalgToStandardPass
123     : public ConvertLinalgToStandardBase<ConvertLinalgToStandardPass> {
124   void runOnOperation() override;
125 };
126 } // namespace
127 
128 void ConvertLinalgToStandardPass::runOnOperation() {
129   auto module = getOperation();
130   ConversionTarget target(getContext());
131   target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,
132                          func::FuncDialect, memref::MemRefDialect,
133                          scf::SCFDialect>();
134   target.addLegalOp<ModuleOp, func::FuncOp, func::ReturnOp>();
135   RewritePatternSet patterns(&getContext());
136   populateLinalgToStandardConversionPatterns(patterns);
137   if (failed(applyFullConversion(module, target, std::move(patterns))))
138     signalPassFailure();
139 }
140 
141 std::unique_ptr<OperationPass<ModuleOp>>
142 mlir::createConvertLinalgToStandardPass() {
143   return std::make_unique<ConvertLinalgToStandardPass>();
144 }
145