1//===- TargetAndABI.cpp - SPIR-V target and ABI utilities -----------------===//
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/SPIRV/IR/TargetAndABI.h"
10#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
11#include "mlir/IR/Builders.h"
12#include "mlir/IR/Operation.h"
13#include "mlir/IR/SymbolTable.h"
14#include "mlir/Interfaces/FunctionInterfaces.h"
15#include <optional>
16
17using namespace mlir;
18
19//===----------------------------------------------------------------------===//
20// TargetEnv
21//===----------------------------------------------------------------------===//
22
23spirv::TargetEnv::TargetEnv(spirv::TargetEnvAttr targetAttr)
24 : targetAttr(targetAttr) {
25 givenExtensions.insert_range(R: targetAttr.getExtensions());
26
27 // Add extensions implied by the current version.
28 givenExtensions.insert_range(
29 R: spirv::getImpliedExtensions(version: targetAttr.getVersion()));
30
31 for (spirv::Capability cap : targetAttr.getCapabilities()) {
32 givenCapabilities.insert(V: cap);
33
34 // Add capabilities implied by the current capability.
35 givenCapabilities.insert_range(R: spirv::getRecursiveImpliedCapabilities(cap));
36 }
37}
38
39spirv::Version spirv::TargetEnv::getVersion() const {
40 return targetAttr.getVersion();
41}
42
43bool spirv::TargetEnv::allows(spirv::Capability capability) const {
44 return givenCapabilities.count(V: capability);
45}
46
47std::optional<spirv::Capability>
48spirv::TargetEnv::allows(ArrayRef<spirv::Capability> caps) const {
49 const auto *chosen = llvm::find_if(Range&: caps, P: [this](spirv::Capability cap) {
50 return givenCapabilities.count(V: cap);
51 });
52 if (chosen != caps.end())
53 return *chosen;
54 return std::nullopt;
55}
56
57bool spirv::TargetEnv::allows(spirv::Extension extension) const {
58 return givenExtensions.count(V: extension);
59}
60
61std::optional<spirv::Extension>
62spirv::TargetEnv::allows(ArrayRef<spirv::Extension> exts) const {
63 const auto *chosen = llvm::find_if(Range&: exts, P: [this](spirv::Extension ext) {
64 return givenExtensions.count(V: ext);
65 });
66 if (chosen != exts.end())
67 return *chosen;
68 return std::nullopt;
69}
70
71spirv::Vendor spirv::TargetEnv::getVendorID() const {
72 return targetAttr.getVendorID();
73}
74
75spirv::DeviceType spirv::TargetEnv::getDeviceType() const {
76 return targetAttr.getDeviceType();
77}
78
79uint32_t spirv::TargetEnv::getDeviceID() const {
80 return targetAttr.getDeviceID();
81}
82
83spirv::ResourceLimitsAttr spirv::TargetEnv::getResourceLimits() const {
84 return targetAttr.getResourceLimits();
85}
86
87MLIRContext *spirv::TargetEnv::getContext() const {
88 return targetAttr.getContext();
89}
90
91//===----------------------------------------------------------------------===//
92// Utility functions
93//===----------------------------------------------------------------------===//
94
95StringRef spirv::getFuncParamAlignmentAttrName() { return "spirv.alignment"; }
96
97StringRef spirv::getFuncParamAttrName() { return "spirv.func_param_attr"; }
98
99StringRef spirv::getInterfaceVarABIAttrName() {
100 return "spirv.interface_var_abi";
101}
102
103spirv::InterfaceVarABIAttr
104spirv::getInterfaceVarABIAttr(unsigned descriptorSet, unsigned binding,
105 std::optional<spirv::StorageClass> storageClass,
106 MLIRContext *context) {
107 return spirv::InterfaceVarABIAttr::get(descriptorSet, binding, storageClass,
108 context);
109}
110
111bool spirv::needsInterfaceVarABIAttrs(spirv::TargetEnvAttr targetAttr) {
112 for (spirv::Capability cap : targetAttr.getCapabilities()) {
113 if (cap == spirv::Capability::Kernel)
114 return false;
115 if (cap == spirv::Capability::Shader)
116 return true;
117 }
118 return false;
119}
120
121StringRef spirv::getEntryPointABIAttrName() { return "spirv.entry_point_abi"; }
122
123spirv::EntryPointABIAttr spirv::getEntryPointABIAttr(
124 MLIRContext *context, ArrayRef<int32_t> workgroupSize,
125 std::optional<int> subgroupSize, std::optional<int> targetWidth) {
126 DenseI32ArrayAttr workgroupSizeAttr;
127 if (!workgroupSize.empty()) {
128 assert(workgroupSize.size() == 3);
129 workgroupSizeAttr = DenseI32ArrayAttr::get(context, content: workgroupSize);
130 }
131 return spirv::EntryPointABIAttr::get(context, workgroup_size: workgroupSizeAttr, subgroup_size: subgroupSize,
132 target_width: targetWidth);
133}
134
135spirv::EntryPointABIAttr spirv::lookupEntryPointABI(Operation *op) {
136 while (op && !isa<FunctionOpInterface>(Val: op))
137 op = op->getParentOp();
138 if (!op)
139 return {};
140
141 if (auto attr = op->getDiscardableAttrOfType<spirv::EntryPointABIAttr>(
142 name: spirv::getEntryPointABIAttrName()))
143 return attr;
144
145 return {};
146}
147
148DenseI32ArrayAttr spirv::lookupLocalWorkGroupSize(Operation *op) {
149 if (auto entryPoint = spirv::lookupEntryPointABI(op))
150 return entryPoint.getWorkgroupSize();
151
152 return {};
153}
154
155spirv::ResourceLimitsAttr
156spirv::getDefaultResourceLimits(MLIRContext *context) {
157 // All the fields have default values. Here we just provide a nicer way to
158 // construct a default resource limit attribute.
159 Builder b(context);
160 return spirv::ResourceLimitsAttr::get(
161 context,
162 /*max_compute_shared_memory_size=*/16384,
163 /*max_compute_workgroup_invocations=*/128,
164 /*max_compute_workgroup_size=*/b.getI32ArrayAttr(values: {128, 128, 64}),
165 /*subgroup_size=*/32,
166 /*min_subgroup_size=*/std::nullopt,
167 /*max_subgroup_size=*/std::nullopt,
168 /*cooperative_matrix_properties_khr=*/ArrayAttr{},
169 /*cooperative_matrix_properties_nv=*/ArrayAttr{});
170}
171
172StringRef spirv::getLoopControlAttrName() { return "spirv.loop_control"; }
173
174StringRef spirv::getSelectionControlAttrName() {
175 return "spirv.selection_control";
176}
177
178StringRef spirv::getTargetEnvAttrName() { return "spirv.target_env"; }
179
180spirv::TargetEnvAttr spirv::getDefaultTargetEnv(MLIRContext *context) {
181 auto triple = spirv::VerCapExtAttr::get(version: spirv::Version::V_1_0,
182 capabilities: {spirv::Capability::Shader},
183 extensions: ArrayRef<Extension>(), context);
184 return spirv::TargetEnvAttr::get(
185 triple, limits: spirv::getDefaultResourceLimits(context),
186 clientAPI: spirv::ClientAPI::Unknown, vendorID: spirv::Vendor::Unknown,
187 deviceType: spirv::DeviceType::Unknown, deviceId: spirv::TargetEnvAttr::kUnknownDeviceID);
188}
189
190spirv::TargetEnvAttr spirv::lookupTargetEnv(Operation *op) {
191 while (op) {
192 op = SymbolTable::getNearestSymbolTable(from: op);
193 if (!op)
194 break;
195
196 if (auto attr = op->getDiscardableAttrOfType<spirv::TargetEnvAttr>(
197 name: spirv::getTargetEnvAttrName()))
198 return attr;
199
200 op = op->getParentOp();
201 }
202
203 return {};
204}
205
206spirv::TargetEnvAttr spirv::lookupTargetEnvOrDefault(Operation *op) {
207 if (spirv::TargetEnvAttr attr = spirv::lookupTargetEnv(op))
208 return attr;
209
210 return getDefaultTargetEnv(context: op->getContext());
211}
212
213spirv::AddressingModel
214spirv::getAddressingModel(spirv::TargetEnvAttr targetAttr,
215 bool use64bitAddress) {
216 for (spirv::Capability cap : targetAttr.getCapabilities()) {
217 if (cap == Capability::Kernel)
218 return use64bitAddress ? spirv::AddressingModel::Physical64
219 : spirv::AddressingModel::Physical32;
220 // TODO PhysicalStorageBuffer64 is hard-coded here, but some information
221 // should come from TargetEnvAttr to select between PhysicalStorageBuffer64
222 // and PhysicalStorageBuffer64EXT
223 if (cap == Capability::PhysicalStorageBufferAddresses)
224 return spirv::AddressingModel::PhysicalStorageBuffer64;
225 }
226 // Logical addressing doesn't need any capabilities so return it as default.
227 return spirv::AddressingModel::Logical;
228}
229
230FailureOr<spirv::ExecutionModel>
231spirv::getExecutionModel(spirv::TargetEnvAttr targetAttr) {
232 for (spirv::Capability cap : targetAttr.getCapabilities()) {
233 if (cap == spirv::Capability::Kernel)
234 return spirv::ExecutionModel::Kernel;
235 if (cap == spirv::Capability::Shader)
236 return spirv::ExecutionModel::GLCompute;
237 }
238 return failure();
239}
240
241FailureOr<spirv::MemoryModel>
242spirv::getMemoryModel(spirv::TargetEnvAttr targetAttr) {
243 for (spirv::Capability cap : targetAttr.getCapabilities()) {
244 if (cap == spirv::Capability::Kernel)
245 return spirv::MemoryModel::OpenCL;
246 if (cap == spirv::Capability::Shader)
247 return spirv::MemoryModel::GLSL450;
248 }
249 return failure();
250}
251