1//===- TosaToSPIRVTosa.cpp - TOSA to SPIR-V Graph/TOSA patterns -----------===//
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// This file implements patterns to convert TOSA IR to SPIR-V Graph/TOSA.
10//
11//===----------------------------------------------------------------------===//
12
13#include "mlir/Conversion/TosaToSPIRVTosa/TosaToSPIRVTosa.h"
14#include "mlir/Dialect/Func/IR/FuncOps.h"
15#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
16#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
17#include "mlir/Transforms/DialectConversion.h"
18#include "llvm/ADT/STLExtras.h"
19
20#define DEBUG_TYPE "tosa-to-spirv-tosa-pattern"
21
22namespace mlir::tosa {
23namespace {
24
25void copyFuncAttrsToGraph(func::FuncOp funcOp, func::FuncOpAdaptor adaptor,
26 spirv::GraphARMOp graphOp) {
27 for (NamedAttribute attr : adaptor.getAttributes()) {
28 StringRef attrName = attr.getName().getValue();
29 if (llvm::is_contained(Set: {funcOp.getSymNameAttrName().getValue(),
30 funcOp.getFunctionTypeAttrName().getValue(),
31 funcOp.getArgAttrsAttrName().getValue(),
32 funcOp.getResAttrsAttrName().getValue(),
33 graphOp.getEntryPointAttrName().getValue()},
34 Element: attrName))
35 continue;
36
37 graphOp->setDiscardableAttr(name: attr.getName(), value: attr.getValue());
38 }
39}
40
41struct FuncGraphConvert final : OpConversionPattern<func::FuncOp> {
42 FuncGraphConvert(SPIRVTypeConverter &typeConverter, MLIRContext *context,
43 spirv::TargetEnvAttr targetAttr)
44 : OpConversionPattern<func::FuncOp>(typeConverter, context),
45 targetAttr(targetAttr) {}
46
47private:
48 spirv::TargetEnvAttr targetAttr;
49
50 // Prefer an explicit source-side GraphARM ABI annotation, then preserve an
51 // already-canonical SPIR-V ABI annotation, and otherwise synthesize the
52 // default descriptor set and binding id.
53 void normalizeInterfaceVarABIAttr(spirv::GraphARMOp graphOp,
54 MLIRContext *context, unsigned index,
55 bool isResult,
56 uint32_t defaultDescriptorSet,
57 uint32_t defaultBinding) const {
58 auto abiInfo =
59 isResult ? graphOp.getResultAttrOfType<spirv::InterfaceVarABIAttr>(
60 index, name: graphARMInterfaceVarABIAttrName)
61 : graphOp.getArgAttrOfType<spirv::InterfaceVarABIAttr>(
62 index, name: graphARMInterfaceVarABIAttrName);
63
64 if (!abiInfo) {
65 abiInfo = isResult
66 ? graphOp.getResultAttrOfType<spirv::InterfaceVarABIAttr>(
67 index, name: spirv::getInterfaceVarABIAttrName())
68 : graphOp.getArgAttrOfType<spirv::InterfaceVarABIAttr>(
69 index, name: spirv::getInterfaceVarABIAttrName());
70 }
71
72 if (!abiInfo) {
73 abiInfo = spirv::InterfaceVarABIAttr::get(
74 descriptorSet: defaultDescriptorSet, binding: defaultBinding, storageClass: std::nullopt, context);
75 }
76
77 if (isResult) {
78 graphOp.setResultAttr(index, name: spirv::getInterfaceVarABIAttrName(),
79 value: abiInfo);
80 graphOp.removeResultAttr(index, name: graphARMInterfaceVarABIAttrName);
81 } else {
82 graphOp.setArgAttr(index, name: spirv::getInterfaceVarABIAttrName(), value: abiInfo);
83 graphOp.removeArgAttr(index, name: graphARMInterfaceVarABIAttrName);
84 }
85 }
86
87 void normalizeInterfaceVarABIAttrs(spirv::GraphARMOp graphOp,
88 MLIRContext *context, unsigned inputs,
89 unsigned outputs) const {
90 constexpr uint32_t defaultDescriptorSet = 0;
91 for (auto argIndex : llvm::seq<unsigned>(Begin: 0, End: inputs)) {
92 normalizeInterfaceVarABIAttr(graphOp, context, index: argIndex, isResult: false,
93 defaultDescriptorSet, defaultBinding: argIndex);
94 }
95 for (auto resIndex : llvm::seq<unsigned>(Begin: 0, End: outputs)) {
96 normalizeInterfaceVarABIAttr(graphOp, context, index: resIndex, isResult: true,
97 defaultDescriptorSet, defaultBinding: resIndex + inputs);
98 }
99 }
100
101public:
102 LogicalResult
103 matchAndRewrite(func::FuncOp funcOp, func::FuncOpAdaptor adaptor,
104 ConversionPatternRewriter &rewriter) const override {
105 MLIRContext *context = rewriter.getContext();
106
107 StringRef name = adaptor.getSymName();
108 auto spvModule = spirv::ModuleOp::create(
109 builder&: rewriter, location: funcOp.getLoc(), addressing_model: spirv::AddressingModel::Logical,
110 memory_model: spirv::MemoryModel::Vulkan, vce_triple: std::nullopt,
111 name: ("_spirv_tosa_" + name).str());
112 spvModule->setDiscardableAttr(name: spirv::getTargetEnvAttrName(), value: targetAttr);
113
114 rewriter.setInsertionPoint(block: spvModule.getBody(), insertPoint: spvModule.begin());
115
116 FunctionType ftype = adaptor.getFunctionType();
117 ArrayAttr argAttrs = adaptor.getArgAttrsAttr();
118 ArrayAttr resAttrs = adaptor.getResAttrsAttr();
119
120 TypeConverter::SignatureConversion signatureConverter(ftype.getNumInputs());
121 if (failed(Result: typeConverter->convertSignatureArgs(types: ftype.getInputs(),
122 result&: signatureConverter))) {
123 return funcOp.emitError(message: "failed to convert function argument types");
124 }
125
126 // Update the signature of the function.
127 SmallVector<Type, 2> newResultTypes;
128 if (failed(Result: getTypeConverter()->convertTypes(types: ftype.getResults(),
129 results&: newResultTypes))) {
130 return funcOp.emitError(message: "failed to convert function result types");
131 }
132
133 // TOSA graphs cannot contain nested funcs, so the converted GraphARM op is
134 // an entry point.
135 auto entryPointAttr = BoolAttr::get(context, value: true);
136 auto graphTy = GraphType::get(
137 context, inputs: signatureConverter.getConvertedTypes(), results: newResultTypes);
138 auto graphOp = spirv::GraphARMOp::create(
139 builder&: rewriter, location: funcOp.getLoc(), function_type: graphTy, arg_attrs: argAttrs, res_attrs: resAttrs, entry_point: entryPointAttr,
140 sym_name: name, sym_visibility: funcOp.getSymVisibilityAttr());
141 copyFuncAttrsToGraph(funcOp, adaptor, graphOp);
142
143 rewriter.inlineRegionBefore(region&: funcOp.getBody(), parent&: graphOp.getBody(),
144 before: graphOp.end());
145 if (failed(Result: rewriter.convertRegionTypes(
146 region: &graphOp.getBody(), converter: *getTypeConverter(), entryConversion: &signatureConverter))) {
147 return funcOp.emitError(message: "failed to convert function regions");
148 }
149
150 normalizeInterfaceVarABIAttrs(graphOp, context, inputs: ftype.getNumInputs(),
151 outputs: ftype.getNumResults());
152
153 rewriter.eraseOp(op: funcOp);
154 return success();
155 }
156};
157
158/// Converts func.return to spirv.ARM.GraphOutputs.
159struct ReturnGraphOutputConvert final : OpConversionPattern<func::ReturnOp> {
160 using Base::Base;
161
162 LogicalResult
163 matchAndRewrite(func::ReturnOp returnOp, OpAdaptor adaptor,
164 ConversionPatternRewriter &rewriter) const override {
165 rewriter.replaceOpWithNewOp<spirv::GraphOutputsARMOp>(
166 op: returnOp, args: adaptor.getOperands());
167 return success();
168 }
169};
170
171} // namespace
172
173void populateTosaToSPIRVTosaConversionPatterns(
174 SPIRVTypeConverter &typeConverter, RewritePatternSet &patterns,
175 spirv::TargetEnvAttr targetAttr) {
176 patterns.add<FuncGraphConvert>(arg&: typeConverter, args: patterns.getContext(),
177 args&: targetAttr);
178 patterns.add<ReturnGraphOutputConvert>(arg&: typeConverter, args: patterns.getContext());
179}
180
181} // namespace mlir::tosa
182