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