LLVM 22.0.0git
SPIRVCommandLine.cpp
Go to the documentation of this file.
1//===--- SPIRVCommandLine.cpp ---- Command Line Options ---------*- C++ -*-===//
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 contains definitions of classes and functions needed for
10// processing, parsing, and using CLI options for the SPIR-V backend.
11//
12//===----------------------------------------------------------------------===//
13
14#include "SPIRVCommandLine.h"
15#include "MCTargetDesc/SPIRVBaseInfo.h"
16#include "llvm/TargetParser/Triple.h"
17#include <algorithm>
18#include <map>
19
20#define DEBUG_TYPE "spirv-commandline"
21
22using namespace llvm;
23
24static const std::map<std::string, SPIRV::Extension::Extension, std::less<>>
25 SPIRVExtensionMap = {
26 {"SPV_EXT_shader_atomic_float_add",
27 SPIRV::Extension::Extension::SPV_EXT_shader_atomic_float_add},
28 {"SPV_EXT_shader_atomic_float16_add",
29 SPIRV::Extension::Extension::SPV_EXT_shader_atomic_float16_add},
30 {"SPV_EXT_shader_atomic_float_min_max",
31 SPIRV::Extension::Extension::SPV_EXT_shader_atomic_float_min_max},
32 {"SPV_EXT_arithmetic_fence",
33 SPIRV::Extension::Extension::SPV_EXT_arithmetic_fence},
34 {"SPV_EXT_demote_to_helper_invocation",
35 SPIRV::Extension::Extension::SPV_EXT_demote_to_helper_invocation},
36 {"SPV_EXT_descriptor_indexing",
37 SPIRV::Extension::Extension::SPV_EXT_descriptor_indexing},
38 {"SPV_EXT_fragment_fully_covered",
39 SPIRV::Extension::Extension::SPV_EXT_fragment_fully_covered},
40 {"SPV_EXT_fragment_invocation_density",
41 SPIRV::Extension::Extension::SPV_EXT_fragment_invocation_density},
42 {"SPV_EXT_fragment_shader_interlock",
43 SPIRV::Extension::Extension::SPV_EXT_fragment_shader_interlock},
44 {"SPV_EXT_mesh_shader",
45 SPIRV::Extension::Extension::SPV_EXT_mesh_shader},
46 {"SPV_EXT_shader_stencil_export",
47 SPIRV::Extension::Extension::SPV_EXT_shader_stencil_export},
48 {"SPV_EXT_shader_viewport_index_layer",
49 SPIRV::Extension::Extension::SPV_EXT_shader_viewport_index_layer},
50 {"SPV_GOOGLE_hlsl_functionality1",
51 SPIRV::Extension::Extension::SPV_GOOGLE_hlsl_functionality1},
52 {"SPV_GOOGLE_user_type",
53 SPIRV::Extension::Extension::SPV_GOOGLE_user_type},
54 {"SPV_INTEL_arbitrary_precision_integers",
55 SPIRV::Extension::Extension::SPV_INTEL_arbitrary_precision_integers},
56 {"SPV_INTEL_cache_controls",
57 SPIRV::Extension::Extension::SPV_INTEL_cache_controls},
58 {"SPV_INTEL_float_controls2",
59 SPIRV::Extension::Extension::SPV_INTEL_float_controls2},
60 {"SPV_INTEL_global_variable_fpga_decorations",
61 SPIRV::Extension::Extension::
62 SPV_INTEL_global_variable_fpga_decorations},
63 {"SPV_INTEL_global_variable_host_access",
64 SPIRV::Extension::Extension::SPV_INTEL_global_variable_host_access},
65 {"SPV_INTEL_optnone", SPIRV::Extension::Extension::SPV_INTEL_optnone},
66 {"SPV_EXT_optnone", SPIRV::Extension::Extension::SPV_EXT_optnone},
67 {"SPV_INTEL_usm_storage_classes",
68 SPIRV::Extension::Extension::SPV_INTEL_usm_storage_classes},
69 {"SPV_INTEL_split_barrier",
70 SPIRV::Extension::Extension::SPV_INTEL_split_barrier},
71 {"SPV_INTEL_subgroups",
72 SPIRV::Extension::Extension::SPV_INTEL_subgroups},
73 {"SPV_INTEL_media_block_io",
74 SPIRV::Extension::Extension::SPV_INTEL_media_block_io},
75 {"SPV_INTEL_memory_access_aliasing",
76 SPIRV::Extension::Extension::SPV_INTEL_memory_access_aliasing},
77 {"SPV_INTEL_joint_matrix",
78 SPIRV::Extension::Extension::SPV_INTEL_joint_matrix},
79 {"SPV_KHR_16bit_storage",
80 SPIRV::Extension::Extension::SPV_KHR_16bit_storage},
81 {"SPV_KHR_device_group",
82 SPIRV::Extension::Extension::SPV_KHR_device_group},
83 {"SPV_KHR_fragment_shading_rate",
84 SPIRV::Extension::Extension::SPV_KHR_fragment_shading_rate},
85 {"SPV_KHR_multiview", SPIRV::Extension::Extension::SPV_KHR_multiview},
86 {"SPV_KHR_post_depth_coverage",
87 SPIRV::Extension::Extension::SPV_KHR_post_depth_coverage},
88 {"SPV_KHR_shader_draw_parameters",
89 SPIRV::Extension::Extension::SPV_KHR_shader_draw_parameters},
90 {"SPV_KHR_ray_tracing",
91 SPIRV::Extension::Extension::SPV_KHR_ray_tracing},
92 {"SPV_KHR_uniform_group_instructions",
93 SPIRV::Extension::Extension::SPV_KHR_uniform_group_instructions},
94 {"SPV_KHR_no_integer_wrap_decoration",
95 SPIRV::Extension::Extension::SPV_KHR_no_integer_wrap_decoration},
96 {"SPV_KHR_float_controls",
97 SPIRV::Extension::Extension::SPV_KHR_float_controls},
98 {"SPV_KHR_expect_assume",
99 SPIRV::Extension::Extension::SPV_KHR_expect_assume},
100 {"SPV_KHR_bit_instructions",
101 SPIRV::Extension::Extension::SPV_KHR_bit_instructions},
102 {"SPV_KHR_integer_dot_product",
103 SPIRV::Extension::Extension::SPV_KHR_integer_dot_product},
104 {"SPV_KHR_linkonce_odr",
105 SPIRV::Extension::Extension::SPV_KHR_linkonce_odr},
106 {"SPV_INTEL_inline_assembly",
107 SPIRV::Extension::Extension::SPV_INTEL_inline_assembly},
108 {"SPV_INTEL_bindless_images",
109 SPIRV::Extension::Extension::SPV_INTEL_bindless_images},
110 {"SPV_INTEL_bfloat16_conversion",
111 SPIRV::Extension::Extension::SPV_INTEL_bfloat16_conversion},
112 {"SPV_KHR_subgroup_rotate",
113 SPIRV::Extension::Extension::SPV_KHR_subgroup_rotate},
114 {"SPV_INTEL_variable_length_array",
115 SPIRV::Extension::Extension::SPV_INTEL_variable_length_array},
116 {"SPV_INTEL_function_pointers",
117 SPIRV::Extension::Extension::SPV_INTEL_function_pointers},
118 {"SPV_KHR_shader_clock",
119 SPIRV::Extension::Extension::SPV_KHR_shader_clock},
120 {"SPV_KHR_cooperative_matrix",
121 SPIRV::Extension::Extension::SPV_KHR_cooperative_matrix},
122 {"SPV_KHR_non_semantic_info",
123 SPIRV::Extension::Extension::SPV_KHR_non_semantic_info},
124 {"SPV_KHR_ray_query", SPIRV::Extension::Extension::SPV_KHR_ray_query},
125 {"SPV_EXT_shader_image_int64",
126 SPIRV::Extension::Extension::SPV_EXT_shader_image_int64},
127 {"SPV_KHR_fragment_shader_barycentric",
128 SPIRV::Extension::Extension::SPV_KHR_fragment_shader_barycentric},
129 {"SPV_KHR_physical_storage_buffer",
130 SPIRV::Extension::Extension::SPV_KHR_physical_storage_buffer},
131 {"SPV_KHR_vulkan_memory_model",
132 SPIRV::Extension::Extension::SPV_KHR_vulkan_memory_model},
133 {"SPV_NV_shader_subgroup_partitioned",
134 SPIRV::Extension::Extension::SPV_NV_shader_subgroup_partitioned},
135 {"SPV_INTEL_long_composites",
136 SPIRV::Extension::Extension::SPV_INTEL_long_composites},
137 {"SPV_INTEL_fp_max_error",
138 SPIRV::Extension::Extension::SPV_INTEL_fp_max_error},
139 {"SPV_INTEL_subgroup_matrix_multiply_accumulate",
140 SPIRV::Extension::Extension::
141 SPV_INTEL_subgroup_matrix_multiply_accumulate},
142 {"SPV_INTEL_ternary_bitwise_function",
143 SPIRV::Extension::Extension::SPV_INTEL_ternary_bitwise_function},
144 {"SPV_INTEL_2d_block_io",
145 SPIRV::Extension::Extension::SPV_INTEL_2d_block_io},
146 {"SPV_INTEL_int4", SPIRV::Extension::Extension::SPV_INTEL_int4},
147 {"SPV_KHR_float_controls2",
148 SPIRV::Extension::Extension::SPV_KHR_float_controls2},
149 {"SPV_INTEL_tensor_float32_conversion",
150 SPIRV::Extension::Extension::SPV_INTEL_tensor_float32_conversion}};
151
152bool SPIRVExtensionsParser::parse(cl::Option &O, StringRef ArgName,
153 StringRef ArgValue,
154 std::set<SPIRV::Extension::Extension> &Vals) {
155 SmallVector<StringRef, 10> Tokens;
156 ArgValue.split(Tokens, ",", -1, false);
157 std::sort(Tokens.begin(), Tokens.end());
158
159 std::set<SPIRV::Extension::Extension> EnabledExtensions;
160
161 for (const auto &Token : Tokens) {
162 if (Token == "all") {
163 for (const auto &[ExtensionName, ExtensionEnum] : SPIRVExtensionMap)
164 EnabledExtensions.insert(ExtensionEnum);
165
166 continue;
167 }
168
169 if (Token.size() == 3 && Token.upper() == "KHR") {
170 for (const auto &[ExtensionName, ExtensionEnum] : SPIRVExtensionMap)
171 if (StringRef(ExtensionName).starts_with("SPV_KHR_"))
172 EnabledExtensions.insert(ExtensionEnum);
173 continue;
174 }
175
176 if (Token.empty() || (!Token.starts_with("+") && !Token.starts_with("-")))
177 return O.error("Invalid extension list format: " + Token.str());
178
179 StringRef ExtensionName = Token.substr(1);
180 auto NameValuePair = SPIRVExtensionMap.find(ExtensionName);
181
182 if (NameValuePair == SPIRVExtensionMap.end())
183 return O.error("Unknown SPIR-V extension: " + Token.str());
184
185 if (Token.starts_with("+")) {
186 EnabledExtensions.insert(NameValuePair->second);
187 } else if (EnabledExtensions.count(NameValuePair->second)) {
188 if (llvm::is_contained(Tokens, "+" + ExtensionName.str()))
189 return O.error(
190 "Extension cannot be allowed and disallowed at the same time: " +
191 ExtensionName.str());
192
193 EnabledExtensions.erase(NameValuePair->second);
194 }
195 }
196
197 Vals = std::move(EnabledExtensions);
198 return false;
199}
200
201StringRef SPIRVExtensionsParser::checkExtensions(
202 const std::vector<std::string> &ExtNames,
203 std::set<SPIRV::Extension::Extension> &AllowedExtensions) {
204 for (const auto &Ext : ExtNames) {
205 if (Ext == "all") {
206 for (const auto &[ExtensionName, ExtensionEnum] : SPIRVExtensionMap)
207 AllowedExtensions.insert(ExtensionEnum);
208 break;
209 }
210 auto It = SPIRVExtensionMap.find(Ext);
211 if (It == SPIRVExtensionMap.end())
212 return Ext;
213 AllowedExtensions.insert(It->second);
214 }
215 return StringRef();
216}
217
218std::set<SPIRV::Extension::Extension>
219SPIRVExtensionsParser::getValidExtensions(const Triple &TT) {
220 std::set<SPIRV::Extension::Extension> R;
221 SPIRV::Environment::Environment CurrentEnvironment =
222 SPIRV::Environment::Environment::EnvOpenCL;
223 if (TT.getOS() == Triple::Vulkan)
224 CurrentEnvironment = SPIRV::Environment::Environment::EnvVulkan;
225
226 for (const auto &[ExtensionName, ExtensionEnum] : SPIRVExtensionMap) {
227 EnvironmentList AllowedEnv = getSymbolicOperandAllowedEnvironments(
228 SPIRV::OperandCategory::OperandCategory::ExtensionOperand,
229 ExtensionEnum);
230
231 if (llvm::is_contained(AllowedEnv, CurrentEnvironment))
232 R.insert(ExtensionEnum);
233 }
234
235 return R;
236}
SPIRVExtensionMap
static const std::map< std::string, SPIRV::Extension::Extension, std::less<> > SPIRVExtensionMap
Definition SPIRVCommandLine.cpp:25
starts_with
DEMANGLE_NAMESPACE_BEGIN bool starts_with(std::string_view self, char C) noexcept
Definition StringViewExtras.h:24
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1197
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
llvm::StringRef::split
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition StringRef.h:710
llvm::StringRef::str
std::string str() const
str - Get the contents as an std::string.
Definition StringRef.h:233
llvm::StringRef::substr
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition StringRef.h:581
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:47
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
llvm::EnvironmentList
SmallVector< SPIRV::Environment::Environment, 8 > EnvironmentList
Definition SPIRVBaseInfo.h:249
llvm::getSymbolicOperandAllowedEnvironments
EnvironmentList getSymbolicOperandAllowedEnvironments(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
Definition SPIRVBaseInfo.cpp:145
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
Definition STLExtras.h:1879
llvm::SPIRVExtensionsParser::getValidExtensions
static std::set< SPIRV::Extension::Extension > getValidExtensions(const Triple &TT)
Returns the list of extensions that are valid for a particular target environment (i....
Definition SPIRVCommandLine.cpp:219
llvm::SPIRVExtensionsParser::parse
bool parse(cl::Option &O, StringRef ArgName, StringRef ArgValue, std::set< SPIRV::Extension::Extension > &Vals)
Parses SPIR-V extension name from CLI arguments.
Definition SPIRVCommandLine.cpp:152
llvm::SPIRVExtensionsParser::checkExtensions
static StringRef checkExtensions(const std::vector< std::string > &ExtNames, std::set< SPIRV::Extension::Extension > &AllowedExtensions)
Validates and converts extension names into internal enum values.
Definition SPIRVCommandLine.cpp:201
Generated on for LLVM by doxygen 1.14.0