| 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 | |
| 22 | namespace mlir::tosa { |
| 23 | namespace { |
| 24 | |
| 25 | void 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 | |
| 41 | struct 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 | |
| 47 | private: |
| 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 | |
| 101 | public: |
| 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. |
| 159 | struct 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 | |
| 173 | void 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 | |