1 // Copyright (c) 2015-2016 The Khronos Group Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // Test capability dependencies for enums.
16
17 #include <tuple>
18 #include <vector>
19
20 #include "gmock/gmock.h"
21 #include "source/assembly_grammar.h"
22 #include "source/enum_set.h"
23 #include "source/operand.h"
24 #include "test/unit_spirv.h"
25
26 namespace spvtools {
27 namespace {
28
29 using spvtest::ElementsIn;
30 using ::testing::Combine;
31 using ::testing::Eq;
32 using ::testing::TestWithParam;
33 using ::testing::Values;
34 using ::testing::ValuesIn;
35
36 // Emits a CapabilitySet to the given ostream, returning the ostream.
operator <<(std::ostream& out, const CapabilitySet& cs)37 inline std::ostream& operator<<(std::ostream& out, const CapabilitySet& cs) {
38 out << "CapabilitySet{";
39 auto ctx = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
40 spvtools::AssemblyGrammar grammar(ctx);
41 bool first = true;
42 for (auto c : cs) {
43 if (!first) {
44 out << " ";
45 first = false;
46 }
47 out << grammar.lookupOperandName(SPV_OPERAND_TYPE_CAPABILITY, uint32_t(c))
48 << "(" << uint32_t(c) << ")";
49 }
50 spvContextDestroy(ctx);
51 out << "}";
52 return out;
53 }
54
55 // A test case for mapping an enum to a capability mask.
56 struct EnumCapabilityCase {
57 spv_operand_type_t type;
58 uint32_t value;
59 CapabilitySet expected_capabilities;
60 };
61 // Emits an EnumCapabilityCase to the ostream, returning the ostream.
operator <<(std::ostream& out, const EnumCapabilityCase& ecc)62 inline std::ostream& operator<<(std::ostream& out,
63 const EnumCapabilityCase& ecc) {
64 out << "EnumCapabilityCase{ " << spvOperandTypeStr(ecc.type) << "("
65 << unsigned(ecc.type) << "), " << ecc.value << ", "
66 << ecc.expected_capabilities << "}";
67 return out;
68 }
69
70 // Test fixture for testing EnumCapabilityCases.
71 using EnumCapabilityTest =
72 TestWithParam<std::tuple<spv_target_env, EnumCapabilityCase>>;
73
TEST_P(EnumCapabilityTest, Sample)74 TEST_P(EnumCapabilityTest, Sample) {
75 const auto env = std::get<0>(GetParam());
76 const auto context = spvContextCreate(env);
77 const AssemblyGrammar grammar(context);
78 spv_operand_desc entry;
79
80 ASSERT_EQ(SPV_SUCCESS,
81 grammar.lookupOperand(std::get<1>(GetParam()).type,
82 std::get<1>(GetParam()).value, &entry));
83 const auto cap_set = grammar.filterCapsAgainstTargetEnv(
84 entry->capabilities, entry->numCapabilities);
85
86 EXPECT_THAT(ElementsIn(cap_set),
87 Eq(ElementsIn(std::get<1>(GetParam()).expected_capabilities)))
88 << " enum value " << std::get<1>(GetParam()).value;
89 spvContextDestroy(context);
90 }
91
92 #define CASE0(TYPE, VALUE) \
93 { \
94 SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), {} \
95 }
96 #define CASE1(TYPE, VALUE, CAP) \
97 { \
98 SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \
99 spv::Capability::CAP \
100 } \
101 }
102 #define CASE2(TYPE, VALUE, CAP1, CAP2) \
103 { \
104 SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \
105 spv::Capability::CAP1, spv::Capability::CAP2 \
106 } \
107 }
108 #define CASE3(TYPE, VALUE, CAP1, CAP2, CAP3) \
109 { \
110 SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \
111 spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3 \
112 } \
113 }
114 #define CASE4(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4) \
115 { \
116 SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \
117 spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \
118 spv::Capability::CAP4 \
119 } \
120 }
121 #define CASE5(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4, CAP5) \
122 { \
123 SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \
124 spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \
125 spv::Capability::CAP4, spv::Capability::CAP5 \
126 } \
127 }
128
129 #define CASE6(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4, CAP5, CAP6) \
130 { \
131 SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \
132 spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \
133 spv::Capability::CAP4, spv::Capability::CAP5, spv::Capability::CAP6 \
134 } \
135 }
136
137 // See SPIR-V Section 3.3 Execution Model
138 INSTANTIATE_TEST_SUITE_P(
139 ExecutionModel, EnumCapabilityTest,
140 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
141 ValuesIn(std::vector<EnumCapabilityCase>{
142 CASE1(EXECUTION_MODEL, ExecutionModel::Vertex, Shader),
143 CASE1(EXECUTION_MODEL, ExecutionModel::TessellationControl,
144 Tessellation),
145 CASE1(EXECUTION_MODEL, ExecutionModel::TessellationEvaluation,
146 Tessellation),
147 CASE1(EXECUTION_MODEL, ExecutionModel::Geometry, Geometry),
148 CASE1(EXECUTION_MODEL, ExecutionModel::Fragment, Shader),
149 CASE1(EXECUTION_MODEL, ExecutionModel::GLCompute, Shader),
150 CASE1(EXECUTION_MODEL, ExecutionModel::Kernel, Kernel),
151 })));
152
153 // See SPIR-V Section 3.4 Addressing Model
154 INSTANTIATE_TEST_SUITE_P(
155 AddressingModel, EnumCapabilityTest,
156 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
157 ValuesIn(std::vector<EnumCapabilityCase>{
158 CASE0(ADDRESSING_MODEL, AddressingModel::Logical),
159 CASE1(ADDRESSING_MODEL, AddressingModel::Physical32, Addresses),
160 CASE1(ADDRESSING_MODEL, AddressingModel::Physical64, Addresses),
161 })));
162
163 // See SPIR-V Section 3.5 Memory Model
164 INSTANTIATE_TEST_SUITE_P(
165 MemoryModel, EnumCapabilityTest,
166 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
167 ValuesIn(std::vector<EnumCapabilityCase>{
168 CASE1(MEMORY_MODEL, MemoryModel::Simple, Shader),
169 CASE1(MEMORY_MODEL, MemoryModel::GLSL450, Shader),
170 CASE1(MEMORY_MODEL, MemoryModel::OpenCL, Kernel),
171 })));
172
173 // See SPIR-V Section 3.6 Execution Mode
174 INSTANTIATE_TEST_SUITE_P(
175 ExecutionMode, EnumCapabilityTest,
176 Combine(
177 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
178 ValuesIn(std::vector<EnumCapabilityCase>{
179 CASE1(EXECUTION_MODE, ExecutionMode::Invocations, Geometry),
180 CASE1(EXECUTION_MODE, ExecutionMode::SpacingEqual, Tessellation),
181 CASE1(EXECUTION_MODE, ExecutionMode::SpacingFractionalEven,
182 Tessellation),
183 CASE1(EXECUTION_MODE, ExecutionMode::SpacingFractionalOdd,
184 Tessellation),
185 CASE1(EXECUTION_MODE, ExecutionMode::VertexOrderCw, Tessellation),
186 CASE1(EXECUTION_MODE, ExecutionMode::VertexOrderCcw, Tessellation),
187 CASE1(EXECUTION_MODE, ExecutionMode::PixelCenterInteger, Shader),
188 CASE1(EXECUTION_MODE, ExecutionMode::OriginUpperLeft, Shader),
189 CASE1(EXECUTION_MODE, ExecutionMode::OriginLowerLeft, Shader),
190 CASE1(EXECUTION_MODE, ExecutionMode::EarlyFragmentTests, Shader),
191 CASE1(EXECUTION_MODE, ExecutionMode::PointMode, Tessellation),
192 CASE1(EXECUTION_MODE, ExecutionMode::Xfb, TransformFeedback),
193 CASE1(EXECUTION_MODE, ExecutionMode::DepthReplacing, Shader),
194 CASE1(EXECUTION_MODE, ExecutionMode::DepthGreater, Shader),
195 CASE1(EXECUTION_MODE, ExecutionMode::DepthLess, Shader),
196 CASE1(EXECUTION_MODE, ExecutionMode::DepthUnchanged, Shader),
197 CASE0(EXECUTION_MODE, ExecutionMode::LocalSize),
198 CASE1(EXECUTION_MODE, ExecutionMode::LocalSizeHint, Kernel),
199 CASE1(EXECUTION_MODE, ExecutionMode::InputPoints, Geometry),
200 CASE1(EXECUTION_MODE, ExecutionMode::InputLines, Geometry),
201 CASE1(EXECUTION_MODE, ExecutionMode::InputLinesAdjacency, Geometry),
202 CASE2(EXECUTION_MODE, ExecutionMode::Triangles, Geometry,
203 Tessellation),
204 CASE1(EXECUTION_MODE, ExecutionMode::InputTrianglesAdjacency,
205 Geometry),
206 CASE1(EXECUTION_MODE, ExecutionMode::Quads, Tessellation),
207 CASE1(EXECUTION_MODE, ExecutionMode::Isolines, Tessellation),
208 CASE4(EXECUTION_MODE, ExecutionMode::OutputVertices, Geometry,
209 Tessellation, MeshShadingNV, MeshShadingEXT),
210 CASE3(EXECUTION_MODE, ExecutionMode::OutputPoints, Geometry,
211 MeshShadingNV, MeshShadingEXT),
212 CASE1(EXECUTION_MODE, ExecutionMode::OutputLineStrip, Geometry),
213 CASE1(EXECUTION_MODE, ExecutionMode::OutputTriangleStrip, Geometry),
214 CASE1(EXECUTION_MODE, ExecutionMode::VecTypeHint, Kernel),
215 CASE1(EXECUTION_MODE, ExecutionMode::ContractionOff, Kernel),
216 })));
217
218 INSTANTIATE_TEST_SUITE_P(
219 ExecutionModeV11, EnumCapabilityTest,
220 Combine(Values(SPV_ENV_UNIVERSAL_1_1),
221 ValuesIn(std::vector<EnumCapabilityCase>{
222 CASE1(EXECUTION_MODE, ExecutionMode::Initializer, Kernel),
223 CASE1(EXECUTION_MODE, ExecutionMode::Finalizer, Kernel),
224 CASE1(EXECUTION_MODE, ExecutionMode::SubgroupSize,
225 SubgroupDispatch),
226 CASE1(EXECUTION_MODE, ExecutionMode::SubgroupsPerWorkgroup,
227 SubgroupDispatch)})));
228
229 // See SPIR-V Section 3.7 Storage Class
230 INSTANTIATE_TEST_SUITE_P(
231 StorageClass, EnumCapabilityTest,
232 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
233 ValuesIn(std::vector<EnumCapabilityCase>{
234 CASE0(STORAGE_CLASS, StorageClass::UniformConstant),
235 CASE1(STORAGE_CLASS, StorageClass::Uniform, Shader),
236 CASE1(STORAGE_CLASS, StorageClass::Output, Shader),
237 CASE0(STORAGE_CLASS, StorageClass::Workgroup),
238 CASE0(STORAGE_CLASS, StorageClass::CrossWorkgroup),
239 CASE2(STORAGE_CLASS, StorageClass::Private, Shader,
240 VectorComputeINTEL),
241 CASE0(STORAGE_CLASS, StorageClass::Function),
242 CASE1(STORAGE_CLASS, StorageClass::Generic,
243 GenericPointer), // Bug 14287
244 CASE1(STORAGE_CLASS, StorageClass::PushConstant, Shader),
245 CASE1(STORAGE_CLASS, StorageClass::AtomicCounter,
246 AtomicStorage),
247 CASE0(STORAGE_CLASS, StorageClass::Image),
248 })));
249
250 // See SPIR-V Section 3.8 Dim
251 INSTANTIATE_TEST_SUITE_P(
252 Dim, EnumCapabilityTest,
253 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
254 ValuesIn(std::vector<EnumCapabilityCase>{
255 CASE1(DIMENSIONALITY, Dim::Dim1D, Sampled1D),
256 CASE0(DIMENSIONALITY, Dim::Dim2D),
257 CASE0(DIMENSIONALITY, Dim::Dim3D),
258 CASE1(DIMENSIONALITY, Dim::Cube, Shader),
259 CASE1(DIMENSIONALITY, Dim::Rect, SampledRect),
260 CASE1(DIMENSIONALITY, Dim::Buffer, SampledBuffer),
261 CASE1(DIMENSIONALITY, Dim::SubpassData, InputAttachment),
262 })));
263
264 // See SPIR-V Section 3.9 Sampler Addressing Mode
265 INSTANTIATE_TEST_SUITE_P(
266 SamplerAddressingMode, EnumCapabilityTest,
267 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
268 ValuesIn(std::vector<EnumCapabilityCase>{
269 CASE0(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::None),
270 CASE0(SAMPLER_ADDRESSING_MODE,
271 SamplerAddressingMode::ClampToEdge),
272 CASE0(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::Clamp),
273 CASE0(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::Repeat),
274 CASE0(SAMPLER_ADDRESSING_MODE,
275 SamplerAddressingMode::RepeatMirrored)})));
276
277 // See SPIR-V Section 3.10 Sampler Filter Mode
278 INSTANTIATE_TEST_SUITE_P(
279 SamplerFilterMode, EnumCapabilityTest,
280 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
281 ValuesIn(std::vector<EnumCapabilityCase>{
282 CASE0(SAMPLER_FILTER_MODE, SamplerFilterMode::Nearest),
283 CASE0(SAMPLER_FILTER_MODE, SamplerFilterMode::Linear),
284 })));
285
286 // See SPIR-V Section 3.11 Image Format
287 INSTANTIATE_TEST_SUITE_P(
288 ImageFormat, EnumCapabilityTest,
289 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
290 ValuesIn(std::vector<EnumCapabilityCase>{
291 // clang-format off
292 CASE0(SAMPLER_IMAGE_FORMAT, ImageFormat::Unknown),
293 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32f, Shader),
294 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16f, Shader),
295 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R32f, Shader),
296 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8, Shader),
297 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8Snorm, Shader),
298 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32f, StorageImageExtendedFormats),
299 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16f, StorageImageExtendedFormats),
300 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R11fG11fB10f, StorageImageExtendedFormats),
301 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16f, StorageImageExtendedFormats),
302 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16, StorageImageExtendedFormats),
303 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgb10A2, StorageImageExtendedFormats),
304 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16, StorageImageExtendedFormats),
305 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8, StorageImageExtendedFormats),
306 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16, StorageImageExtendedFormats),
307 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8, StorageImageExtendedFormats),
308 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16Snorm, StorageImageExtendedFormats),
309 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16Snorm, StorageImageExtendedFormats),
310 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8Snorm, StorageImageExtendedFormats),
311 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16Snorm, StorageImageExtendedFormats),
312 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8Snorm, StorageImageExtendedFormats),
313 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32i, Shader),
314 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16i, Shader),
315 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8i, Shader),
316 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R32i, Shader),
317 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32i, StorageImageExtendedFormats),
318 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16i, StorageImageExtendedFormats),
319 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8i, StorageImageExtendedFormats),
320 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16i, StorageImageExtendedFormats),
321 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8i, StorageImageExtendedFormats),
322 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32ui, Shader),
323 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16ui, Shader),
324 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8ui, Shader),
325 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8ui, Shader),
326 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgb10a2ui, StorageImageExtendedFormats),
327 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32ui, StorageImageExtendedFormats),
328 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16ui, StorageImageExtendedFormats),
329 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8ui, StorageImageExtendedFormats),
330 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16ui, StorageImageExtendedFormats),
331 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8ui, StorageImageExtendedFormats),
332 // clang-format on
333 })));
334
335 // See SPIR-V Section 3.12 Image Channel Order
336 INSTANTIATE_TEST_SUITE_P(
337 ImageChannelOrder, EnumCapabilityTest,
338 Combine(
339 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
340 ValuesIn(std::vector<EnumCapabilityCase>{
341 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::R, Kernel),
342 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::A, Kernel),
343 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RG, Kernel),
344 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RA, Kernel),
345 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGB, Kernel),
346 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGBA, Kernel),
347 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::BGRA, Kernel),
348 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::ARGB, Kernel),
349 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Intensity, Kernel),
350 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Luminance, Kernel),
351 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Rx, Kernel),
352 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGx, Kernel),
353 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGBx, Kernel),
354 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Depth, Kernel),
355 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::DepthStencil, Kernel),
356 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGB, Kernel),
357 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGBx, Kernel),
358 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGBA, Kernel),
359 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sBGRA, Kernel),
360 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::ABGR, Kernel),
361 })));
362
363 // See SPIR-V Section 3.13 Image Channel Data Type
364 INSTANTIATE_TEST_SUITE_P(
365 ImageChannelDataType, EnumCapabilityTest,
366 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
367 ValuesIn(std::vector<EnumCapabilityCase>{
368 // clang-format off
369 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SnormInt8, Kernel),
370 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SnormInt16, Kernel),
371 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt8, Kernel),
372 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt16, Kernel),
373 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormShort565, Kernel),
374 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormShort555, Kernel),
375 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt101010, Kernel),
376 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt8, Kernel),
377 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt16, Kernel),
378 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt32, Kernel),
379 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt8, Kernel),
380 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt16, Kernel),
381 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt32, Kernel),
382 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::HalfFloat, Kernel),
383 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::Float, Kernel),
384 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt24, Kernel),
385 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt101010_2, Kernel),
386 // clang-format on
387 })));
388
389 // See SPIR-V Section 3.14 Image Operands
390 INSTANTIATE_TEST_SUITE_P(
391 ImageOperands, EnumCapabilityTest,
392 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
393 ValuesIn(std::vector<EnumCapabilityCase>{
394 // clang-format off
395 CASE0(OPTIONAL_IMAGE, ImageOperandsMask::MaskNone),
396 CASE1(OPTIONAL_IMAGE, ImageOperandsMask::Bias, Shader),
397 CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Lod),
398 CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Grad),
399 CASE0(OPTIONAL_IMAGE, ImageOperandsMask::ConstOffset),
400 CASE1(OPTIONAL_IMAGE, ImageOperandsMask::Offset, ImageGatherExtended),
401 CASE1(OPTIONAL_IMAGE, ImageOperandsMask::ConstOffsets, ImageGatherExtended),
402 CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Sample),
403 CASE1(OPTIONAL_IMAGE, ImageOperandsMask::MinLod, MinLod),
404 // clang-format on
405 })));
406
407 // See SPIR-V Section 3.17 Linkage Type
408 INSTANTIATE_TEST_SUITE_P(
409 LinkageType, EnumCapabilityTest,
410 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
411 ValuesIn(std::vector<EnumCapabilityCase>{
412 CASE1(LINKAGE_TYPE, LinkageType::Export, Linkage),
413 CASE1(LINKAGE_TYPE, LinkageType::Import, Linkage),
414 })));
415
416 // See SPIR-V Section 3.18 Access Qualifier
417 INSTANTIATE_TEST_SUITE_P(
418 AccessQualifier, EnumCapabilityTest,
419 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
420 ValuesIn(std::vector<EnumCapabilityCase>{
421 CASE1(ACCESS_QUALIFIER, AccessQualifier::ReadOnly, Kernel),
422 CASE1(ACCESS_QUALIFIER, AccessQualifier::WriteOnly, Kernel),
423 CASE1(ACCESS_QUALIFIER, AccessQualifier::ReadWrite, Kernel),
424 })));
425
426 // See SPIR-V Section 3.19 Function Parameter Attribute
427 INSTANTIATE_TEST_SUITE_P(
428 FunctionParameterAttribute, EnumCapabilityTest,
429 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
430 ValuesIn(std::vector<EnumCapabilityCase>{
431 // clang-format off
432 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Zext, Kernel),
433 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Sext, Kernel),
434 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::ByVal, Kernel),
435 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Sret, Kernel),
436 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoAlias, Kernel),
437 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoCapture, Kernel),
438 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoWrite, Kernel),
439 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoReadWrite, Kernel),
440 // clang-format on
441 })));
442
443 // See SPIR-V Section 3.20 Decoration
444 INSTANTIATE_TEST_SUITE_P(
445 Decoration_1_1, EnumCapabilityTest,
446 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
447 ValuesIn(std::vector<EnumCapabilityCase>{
448 CASE1(DECORATION, Decoration::RelaxedPrecision, Shader),
449 // DecorationSpecId handled below.
450 CASE1(DECORATION, Decoration::Block, Shader),
451 CASE1(DECORATION, Decoration::BufferBlock, Shader),
452 CASE1(DECORATION, Decoration::RowMajor, Matrix),
453 CASE1(DECORATION, Decoration::ColMajor, Matrix),
454 CASE1(DECORATION, Decoration::ArrayStride, Shader),
455 CASE1(DECORATION, Decoration::MatrixStride,
456 Matrix), // Bug 15234
457 CASE1(DECORATION, Decoration::GLSLShared, Shader),
458 CASE1(DECORATION, Decoration::GLSLPacked, Shader),
459 CASE1(DECORATION, Decoration::CPacked, Kernel),
460 CASE0(DECORATION, Decoration::BuiltIn), // Bug 15248
461 // Value 12 placeholder
462 CASE1(DECORATION, Decoration::NoPerspective, Shader),
463 CASE1(DECORATION, Decoration::Flat, Shader),
464 CASE1(DECORATION, Decoration::Patch, Tessellation),
465 CASE1(DECORATION, Decoration::Centroid, Shader),
466 CASE1(DECORATION, Decoration::Sample,
467 SampleRateShading), // Bug 15234
468 CASE1(DECORATION, Decoration::Invariant, Shader),
469 CASE0(DECORATION, Decoration::Restrict),
470 CASE0(DECORATION, Decoration::Aliased),
471 CASE0(DECORATION, Decoration::Volatile),
472 CASE1(DECORATION, Decoration::Constant, Kernel),
473 CASE0(DECORATION, Decoration::Coherent),
474 CASE0(DECORATION, Decoration::NonWritable),
475 CASE0(DECORATION, Decoration::NonReadable),
476 CASE1(DECORATION, Decoration::Uniform, Shader),
477 // Value 27 is an intentional gap in the spec numbering.
478 CASE1(DECORATION, Decoration::SaturatedConversion, Kernel),
479 CASE1(DECORATION, Decoration::Stream, GeometryStreams),
480 CASE1(DECORATION, Decoration::Location, Shader),
481 CASE1(DECORATION, Decoration::Component, Shader),
482 CASE1(DECORATION, Decoration::Index, Shader),
483 CASE1(DECORATION, Decoration::Binding, Shader),
484 CASE1(DECORATION, Decoration::DescriptorSet, Shader),
485 CASE1(DECORATION, Decoration::Offset, Shader), // Bug 15268
486 CASE1(DECORATION, Decoration::XfbBuffer, TransformFeedback),
487 CASE1(DECORATION, Decoration::XfbStride, TransformFeedback),
488 CASE1(DECORATION, Decoration::FuncParamAttr, Kernel),
489 CASE1(DECORATION, Decoration::FPFastMathMode, Kernel),
490 CASE1(DECORATION, Decoration::LinkageAttributes, Linkage),
491 CASE1(DECORATION, Decoration::NoContraction, Shader),
492 CASE1(DECORATION, Decoration::InputAttachmentIndex,
493 InputAttachment),
494 CASE1(DECORATION, Decoration::Alignment, Kernel),
495 })));
496
497 // See SPIR-V Section 3.20 Decoration
498 INSTANTIATE_TEST_SUITE_P(Decoration_1_6, EnumCapabilityTest,
499 Combine(Values(SPV_ENV_UNIVERSAL_1_6),
500 ValuesIn(std::vector<EnumCapabilityCase>{
501 CASE2(DECORATION, Decoration::Uniform,
502 Shader, UniformDecoration)})));
503
504 #if 0
505 // SpecId has different requirements in v1.0 and v1.1:
506 INSTANTIATE_TEST_SUITE_P(DecorationSpecIdV10, EnumCapabilityTest,
507 Combine(Values(SPV_ENV_UNIVERSAL_1_0),
508 ValuesIn(std::vector<EnumCapabilityCase>{CASE1(
509 DECORATION, DecorationSpecId, Shader)})));
510 #endif
511
512 INSTANTIATE_TEST_SUITE_P(
513 DecorationV11, EnumCapabilityTest,
514 Combine(Values(SPV_ENV_UNIVERSAL_1_1),
515 ValuesIn(std::vector<EnumCapabilityCase>{
516 CASE2(DECORATION, Decoration::SpecId, Shader, Kernel),
517 CASE1(DECORATION, Decoration::MaxByteOffset, Addresses)})));
518
519 // See SPIR-V Section 3.21 BuiltIn
520 INSTANTIATE_TEST_SUITE_P(
521 BuiltIn, EnumCapabilityTest,
522 Combine(
523 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
524 ValuesIn(std::vector<EnumCapabilityCase>{
525 // clang-format off
526 CASE1(BUILT_IN, BuiltIn::Position, Shader),
527 CASE1(BUILT_IN, BuiltIn::PointSize, Shader),
528 // 2 is an intentional gap in the spec numbering.
529 CASE1(BUILT_IN, BuiltIn::ClipDistance, ClipDistance), // Bug 1407, 15234
530 CASE1(BUILT_IN, BuiltIn::CullDistance, CullDistance), // Bug 1407, 15234
531 CASE1(BUILT_IN, BuiltIn::VertexId, Shader),
532 CASE1(BUILT_IN, BuiltIn::InstanceId, Shader),
533 CASE6(BUILT_IN, BuiltIn::PrimitiveId, Geometry, Tessellation,
534 RayTracingNV, RayTracingKHR, MeshShadingNV, MeshShadingEXT),
535 CASE2(BUILT_IN, BuiltIn::InvocationId, Geometry, Tessellation),
536 CASE4(BUILT_IN, BuiltIn::Layer, Geometry, ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT),
537 CASE4(BUILT_IN, BuiltIn::ViewportIndex, MultiViewport, ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT), // Bug 15234
538 CASE1(BUILT_IN, BuiltIn::TessLevelOuter, Tessellation),
539 CASE1(BUILT_IN, BuiltIn::TessLevelInner, Tessellation),
540 CASE1(BUILT_IN, BuiltIn::TessCoord, Tessellation),
541 CASE1(BUILT_IN, BuiltIn::PatchVertices, Tessellation),
542 CASE1(BUILT_IN, BuiltIn::FragCoord, Shader),
543 CASE1(BUILT_IN, BuiltIn::PointCoord, Shader),
544 CASE1(BUILT_IN, BuiltIn::FrontFacing, Shader),
545 CASE1(BUILT_IN, BuiltIn::SampleId, SampleRateShading), // Bug 15234
546 CASE1(BUILT_IN, BuiltIn::SamplePosition, SampleRateShading), // Bug 15234
547 CASE1(BUILT_IN, BuiltIn::SampleMask, Shader), // Bug 15234, Issue 182
548 // Value 21 intentionally missing
549 CASE1(BUILT_IN, BuiltIn::FragDepth, Shader),
550 CASE1(BUILT_IN, BuiltIn::HelperInvocation, Shader),
551 CASE0(BUILT_IN, BuiltIn::NumWorkgroups),
552 CASE0(BUILT_IN, BuiltIn::WorkgroupSize),
553 CASE0(BUILT_IN, BuiltIn::WorkgroupId),
554 CASE0(BUILT_IN, BuiltIn::LocalInvocationId),
555 CASE0(BUILT_IN, BuiltIn::GlobalInvocationId),
556 CASE0(BUILT_IN, BuiltIn::LocalInvocationIndex),
557 CASE1(BUILT_IN, BuiltIn::WorkDim, Kernel),
558 CASE1(BUILT_IN, BuiltIn::GlobalSize, Kernel),
559 CASE1(BUILT_IN, BuiltIn::EnqueuedWorkgroupSize, Kernel),
560 CASE1(BUILT_IN, BuiltIn::GlobalOffset, Kernel),
561 CASE1(BUILT_IN, BuiltIn::GlobalLinearId, Kernel),
562 // Value 35 intentionally missing
563 CASE2(BUILT_IN, BuiltIn::SubgroupSize, Kernel, SubgroupBallotKHR),
564 CASE1(BUILT_IN, BuiltIn::SubgroupMaxSize, Kernel),
565 CASE1(BUILT_IN, BuiltIn::NumSubgroups, Kernel),
566 CASE1(BUILT_IN, BuiltIn::NumEnqueuedSubgroups, Kernel),
567 CASE1(BUILT_IN, BuiltIn::SubgroupId, Kernel),
568 CASE2(BUILT_IN, BuiltIn::SubgroupLocalInvocationId, Kernel, SubgroupBallotKHR),
569 CASE1(BUILT_IN, BuiltIn::VertexIndex, Shader),
570 CASE1(BUILT_IN, BuiltIn::InstanceIndex, Shader),
571 // clang-format on
572 })));
573
574 INSTANTIATE_TEST_SUITE_P(
575 BuiltInV1_5, EnumCapabilityTest,
576 Combine(
577 Values(SPV_ENV_UNIVERSAL_1_5),
578 ValuesIn(std::vector<EnumCapabilityCase>{
579 // SPIR-V 1.5 adds new capabilities to enable these two builtins.
580 CASE5(BUILT_IN, BuiltIn::Layer, Geometry, ShaderLayer,
581 ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT),
582 CASE5(BUILT_IN, BuiltIn::ViewportIndex, MultiViewport,
583 ShaderViewportIndex, ShaderViewportIndexLayerEXT,
584 MeshShadingNV, MeshShadingEXT),
585 })));
586
587 // See SPIR-V Section 3.22 Selection Control
588 INSTANTIATE_TEST_SUITE_P(
589 SelectionControl, EnumCapabilityTest,
590 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
591 ValuesIn(std::vector<EnumCapabilityCase>{
592 CASE0(SELECTION_CONTROL, SelectionControlMask::MaskNone),
593 CASE0(SELECTION_CONTROL, SelectionControlMask::Flatten),
594 CASE0(SELECTION_CONTROL, SelectionControlMask::DontFlatten),
595 })));
596
597 // See SPIR-V Section 3.23 Loop Control
598 INSTANTIATE_TEST_SUITE_P(
599 LoopControl, EnumCapabilityTest,
600 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
601 ValuesIn(std::vector<EnumCapabilityCase>{
602 CASE0(LOOP_CONTROL, LoopControlMask::MaskNone),
603 CASE0(LOOP_CONTROL, LoopControlMask::Unroll),
604 CASE0(LOOP_CONTROL, LoopControlMask::DontUnroll),
605 })));
606
607 INSTANTIATE_TEST_SUITE_P(
608 LoopControlV11, EnumCapabilityTest,
609 Combine(Values(SPV_ENV_UNIVERSAL_1_1),
610 ValuesIn(std::vector<EnumCapabilityCase>{
611 CASE0(LOOP_CONTROL, LoopControlMask::DependencyInfinite),
612 CASE0(LOOP_CONTROL, LoopControlMask::DependencyLength),
613 })));
614
615 // See SPIR-V Section 3.24 Function Control
616 INSTANTIATE_TEST_SUITE_P(
617 FunctionControl, EnumCapabilityTest,
618 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
619 ValuesIn(std::vector<EnumCapabilityCase>{
620 CASE0(FUNCTION_CONTROL, FunctionControlMask::MaskNone),
621 CASE0(FUNCTION_CONTROL, FunctionControlMask::Inline),
622 CASE0(FUNCTION_CONTROL, FunctionControlMask::DontInline),
623 CASE0(FUNCTION_CONTROL, FunctionControlMask::Pure),
624 CASE0(FUNCTION_CONTROL, FunctionControlMask::Const),
625 })));
626
627 // See SPIR-V Section 3.25 Memory Semantics <id>
628 INSTANTIATE_TEST_SUITE_P(
629 MemorySemantics, EnumCapabilityTest,
630 Combine(
631 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
632 ValuesIn(std::vector<EnumCapabilityCase>{
633 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::MaskNone),
634 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::Acquire),
635 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::Release),
636 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::AcquireRelease),
637 CASE0(MEMORY_SEMANTICS_ID,
638 MemorySemanticsMask::SequentiallyConsistent),
639 CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsMask::UniformMemory,
640 Shader),
641 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::SubgroupMemory),
642 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::WorkgroupMemory),
643 CASE0(MEMORY_SEMANTICS_ID,
644 MemorySemanticsMask::CrossWorkgroupMemory),
645 CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsMask::AtomicCounterMemory,
646 AtomicStorage), // Bug 15234
647 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::ImageMemory),
648 })));
649
650 // See SPIR-V Section 3.26 Memory Access
651 INSTANTIATE_TEST_SUITE_P(
652 MemoryAccess, EnumCapabilityTest,
653 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
654 ValuesIn(std::vector<EnumCapabilityCase>{
655 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::MaskNone),
656 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Volatile),
657 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Aligned),
658 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Nontemporal),
659 })));
660
661 // See SPIR-V Section 3.27 Scope <id>
662 INSTANTIATE_TEST_SUITE_P(
663 Scope, EnumCapabilityTest,
664 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
665 SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3),
666 ValuesIn(std::vector<EnumCapabilityCase>{
667 CASE0(SCOPE_ID, Scope::CrossDevice),
668 CASE0(SCOPE_ID, Scope::Device),
669 CASE0(SCOPE_ID, Scope::Workgroup),
670 CASE0(SCOPE_ID, Scope::Subgroup),
671 CASE0(SCOPE_ID, Scope::Invocation),
672 CASE1(SCOPE_ID, Scope::QueueFamilyKHR, VulkanMemoryModelKHR),
673 })));
674
675 // See SPIR-V Section 3.28 Group Operation
676 INSTANTIATE_TEST_SUITE_P(
677 GroupOperation, EnumCapabilityTest,
678 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
679 ValuesIn(std::vector<EnumCapabilityCase>{
680 CASE3(GROUP_OPERATION, GroupOperation::Reduce, Kernel,
681 GroupNonUniformArithmetic, GroupNonUniformBallot),
682 CASE3(GROUP_OPERATION, GroupOperation::InclusiveScan, Kernel,
683 GroupNonUniformArithmetic, GroupNonUniformBallot),
684 CASE3(GROUP_OPERATION, GroupOperation::ExclusiveScan, Kernel,
685 GroupNonUniformArithmetic, GroupNonUniformBallot),
686 })));
687
688 // See SPIR-V Section 3.29 Kernel Enqueue Flags
689 INSTANTIATE_TEST_SUITE_P(
690 KernelEnqueueFlags, EnumCapabilityTest,
691 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
692 ValuesIn(std::vector<EnumCapabilityCase>{
693 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::NoWait, Kernel),
694 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::WaitKernel, Kernel),
695 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::WaitWorkGroup,
696 Kernel),
697 })));
698
699 // See SPIR-V Section 3.30 Kernel Profiling Info
700 INSTANTIATE_TEST_SUITE_P(
701 KernelProfilingInfo, EnumCapabilityTest,
702 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
703 ValuesIn(std::vector<EnumCapabilityCase>{
704 CASE0(KERNEL_PROFILING_INFO, KernelProfilingInfoMask::MaskNone),
705 CASE1(KERNEL_PROFILING_INFO,
706 KernelProfilingInfoMask::CmdExecTime, Kernel),
707 })));
708
709 // See SPIR-V Section 3.31 Capability
710 INSTANTIATE_TEST_SUITE_P(
711 CapabilityDependsOn, EnumCapabilityTest,
712 Combine(
713 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
714 ValuesIn(std::vector<EnumCapabilityCase>{
715 // clang-format off
716 CASE0(CAPABILITY, Capability::Matrix),
717 CASE1(CAPABILITY, Capability::Shader, Matrix),
718 CASE1(CAPABILITY, Capability::Geometry, Shader),
719 CASE1(CAPABILITY, Capability::Tessellation, Shader),
720 CASE0(CAPABILITY, Capability::Addresses),
721 CASE0(CAPABILITY, Capability::Linkage),
722 CASE0(CAPABILITY, Capability::Kernel),
723 CASE1(CAPABILITY, Capability::Vector16, Kernel),
724 CASE1(CAPABILITY, Capability::Float16Buffer, Kernel),
725 CASE0(CAPABILITY, Capability::Float16), // Bug 15234
726 CASE0(CAPABILITY, Capability::Float64),
727 CASE0(CAPABILITY, Capability::Int64),
728 CASE1(CAPABILITY, Capability::Int64Atomics, Int64),
729 CASE1(CAPABILITY, Capability::ImageBasic, Kernel),
730 CASE1(CAPABILITY, Capability::ImageReadWrite, ImageBasic),
731 CASE1(CAPABILITY, Capability::ImageMipmap, ImageBasic),
732 // Value 16 intentionally missing.
733 CASE1(CAPABILITY, Capability::Pipes, Kernel),
734 CASE0(CAPABILITY, Capability::Groups),
735 CASE1(CAPABILITY, Capability::DeviceEnqueue, Kernel),
736 CASE1(CAPABILITY, Capability::LiteralSampler, Kernel),
737 CASE1(CAPABILITY, Capability::AtomicStorage, Shader),
738 CASE0(CAPABILITY, Capability::Int16),
739 CASE1(CAPABILITY, Capability::TessellationPointSize, Tessellation),
740 CASE1(CAPABILITY, Capability::GeometryPointSize, Geometry),
741 CASE1(CAPABILITY, Capability::ImageGatherExtended, Shader),
742 // Value 26 intentionally missing.
743 CASE1(CAPABILITY, Capability::StorageImageMultisample, Shader),
744 CASE1(CAPABILITY, Capability::UniformBufferArrayDynamicIndexing, Shader),
745 CASE1(CAPABILITY, Capability::SampledImageArrayDynamicIndexing, Shader),
746 CASE1(CAPABILITY, Capability::StorageBufferArrayDynamicIndexing, Shader),
747 CASE1(CAPABILITY, Capability::StorageImageArrayDynamicIndexing, Shader),
748 CASE1(CAPABILITY, Capability::ClipDistance, Shader),
749 CASE1(CAPABILITY, Capability::CullDistance, Shader),
750 CASE1(CAPABILITY, Capability::ImageCubeArray, SampledCubeArray),
751 CASE1(CAPABILITY, Capability::SampleRateShading, Shader),
752 CASE1(CAPABILITY, Capability::ImageRect, SampledRect),
753 CASE1(CAPABILITY, Capability::SampledRect, Shader),
754 CASE1(CAPABILITY, Capability::GenericPointer, Addresses),
755 CASE0(CAPABILITY, Capability::Int8),
756 CASE1(CAPABILITY, Capability::InputAttachment, Shader),
757 CASE1(CAPABILITY, Capability::SparseResidency, Shader),
758 CASE1(CAPABILITY, Capability::MinLod, Shader),
759 CASE1(CAPABILITY, Capability::Image1D, Sampled1D),
760 CASE1(CAPABILITY, Capability::SampledCubeArray, Shader),
761 CASE1(CAPABILITY, Capability::ImageBuffer, SampledBuffer),
762 CASE1(CAPABILITY, Capability::ImageMSArray, Shader),
763 CASE1(CAPABILITY, Capability::StorageImageExtendedFormats, Shader),
764 CASE1(CAPABILITY, Capability::ImageQuery, Shader),
765 CASE1(CAPABILITY, Capability::DerivativeControl, Shader),
766 CASE1(CAPABILITY, Capability::InterpolationFunction, Shader),
767 CASE1(CAPABILITY, Capability::TransformFeedback, Shader),
768 CASE1(CAPABILITY, Capability::GeometryStreams, Geometry),
769 CASE1(CAPABILITY, Capability::StorageImageReadWithoutFormat, Shader),
770 CASE1(CAPABILITY, Capability::StorageImageWriteWithoutFormat, Shader),
771 CASE1(CAPABILITY, Capability::MultiViewport, Geometry),
772 // clang-format on
773 })));
774
775 INSTANTIATE_TEST_SUITE_P(
776 CapabilityDependsOnV11, EnumCapabilityTest,
777 Combine(Values(SPV_ENV_UNIVERSAL_1_1),
778 ValuesIn(std::vector<EnumCapabilityCase>{
779 CASE1(CAPABILITY, Capability::SubgroupDispatch, DeviceEnqueue),
780 CASE1(CAPABILITY, Capability::NamedBarrier, Kernel),
781 CASE1(CAPABILITY, Capability::PipeStorage, Pipes),
782 })));
783
784 #undef CASE0
785 #undef CASE1
786 #undef CASE2
787
788 } // namespace
789 } // namespace spvtools
790