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/enum_set.h"
22 #include "test/unit_spirv.h"
23
24 namespace spvtools {
25 namespace {
26
27 using spvtest::ElementsIn;
28 using ::testing::Combine;
29 using ::testing::Eq;
30 using ::testing::TestWithParam;
31 using ::testing::Values;
32 using ::testing::ValuesIn;
33
34 // A test case for mapping an enum to a capability mask.
35 struct EnumCapabilityCase {
36 spv_operand_type_t type;
37 uint32_t value;
38 CapabilitySet expected_capabilities;
39 };
40
41 // Test fixture for testing EnumCapabilityCases.
42 using EnumCapabilityTest =
43 TestWithParam<std::tuple<spv_target_env, EnumCapabilityCase>>;
44
TEST_P(EnumCapabilityTest,Sample)45 TEST_P(EnumCapabilityTest, Sample) {
46 const auto env = std::get<0>(GetParam());
47 const auto context = spvContextCreate(env);
48 const AssemblyGrammar grammar(context);
49 spv_operand_desc entry;
50
51 ASSERT_EQ(SPV_SUCCESS,
52 grammar.lookupOperand(std::get<1>(GetParam()).type,
53 std::get<1>(GetParam()).value, &entry));
54 const auto cap_set = grammar.filterCapsAgainstTargetEnv(
55 entry->capabilities, entry->numCapabilities);
56
57 EXPECT_THAT(ElementsIn(cap_set),
58 Eq(ElementsIn(std::get<1>(GetParam()).expected_capabilities)))
59 << " capability value " << std::get<1>(GetParam()).value;
60 spvContextDestroy(context);
61 }
62
63 #define CASE0(TYPE, VALUE) \
64 { \
65 SPV_OPERAND_TYPE_##TYPE, uint32_t(Spv##VALUE), {} \
66 }
67 #define CASE1(TYPE, VALUE, CAP) \
68 { \
69 SPV_OPERAND_TYPE_##TYPE, uint32_t(Spv##VALUE), CapabilitySet { \
70 SpvCapability##CAP \
71 } \
72 }
73 #define CASE2(TYPE, VALUE, CAP1, CAP2) \
74 { \
75 SPV_OPERAND_TYPE_##TYPE, uint32_t(Spv##VALUE), CapabilitySet { \
76 SpvCapability##CAP1, SpvCapability##CAP2 \
77 } \
78 }
79 #define CASE3(TYPE, VALUE, CAP1, CAP2, CAP3) \
80 { \
81 SPV_OPERAND_TYPE_##TYPE, uint32_t(Spv##VALUE), CapabilitySet { \
82 SpvCapability##CAP1, SpvCapability##CAP2, SpvCapability##CAP3 \
83 } \
84 }
85 #define CASE5(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4, CAP5) \
86 { \
87 SPV_OPERAND_TYPE_##TYPE, uint32_t(Spv##VALUE), CapabilitySet { \
88 SpvCapability##CAP1, SpvCapability##CAP2, SpvCapability##CAP3, \
89 SpvCapability##CAP4, SpvCapability##CAP5 \
90 } \
91 }
92
93 // See SPIR-V Section 3.3 Execution Model
94 INSTANTIATE_TEST_SUITE_P(
95 ExecutionModel, EnumCapabilityTest,
96 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
97 ValuesIn(std::vector<EnumCapabilityCase>{
98 CASE1(EXECUTION_MODEL, ExecutionModelVertex, Shader),
99 CASE1(EXECUTION_MODEL, ExecutionModelTessellationControl,
100 Tessellation),
101 CASE1(EXECUTION_MODEL, ExecutionModelTessellationEvaluation,
102 Tessellation),
103 CASE1(EXECUTION_MODEL, ExecutionModelGeometry, Geometry),
104 CASE1(EXECUTION_MODEL, ExecutionModelFragment, Shader),
105 CASE1(EXECUTION_MODEL, ExecutionModelGLCompute, Shader),
106 CASE1(EXECUTION_MODEL, ExecutionModelKernel, Kernel),
107 })));
108
109 // See SPIR-V Section 3.4 Addressing Model
110 INSTANTIATE_TEST_SUITE_P(
111 AddressingModel, EnumCapabilityTest,
112 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
113 ValuesIn(std::vector<EnumCapabilityCase>{
114 CASE0(ADDRESSING_MODEL, AddressingModelLogical),
115 CASE1(ADDRESSING_MODEL, AddressingModelPhysical32, Addresses),
116 CASE1(ADDRESSING_MODEL, AddressingModelPhysical64, Addresses),
117 })));
118
119 // See SPIR-V Section 3.5 Memory Model
120 INSTANTIATE_TEST_SUITE_P(
121 MemoryModel, EnumCapabilityTest,
122 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
123 ValuesIn(std::vector<EnumCapabilityCase>{
124 CASE1(MEMORY_MODEL, MemoryModelSimple, Shader),
125 CASE1(MEMORY_MODEL, MemoryModelGLSL450, Shader),
126 CASE1(MEMORY_MODEL, MemoryModelOpenCL, Kernel),
127 })));
128
129 // See SPIR-V Section 3.6 Execution Mode
130 INSTANTIATE_TEST_SUITE_P(
131 ExecutionMode, EnumCapabilityTest,
132 Combine(
133 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
134 ValuesIn(std::vector<EnumCapabilityCase>{
135 CASE1(EXECUTION_MODE, ExecutionModeInvocations, Geometry),
136 CASE1(EXECUTION_MODE, ExecutionModeSpacingEqual, Tessellation),
137 CASE1(EXECUTION_MODE, ExecutionModeSpacingFractionalEven,
138 Tessellation),
139 CASE1(EXECUTION_MODE, ExecutionModeSpacingFractionalOdd,
140 Tessellation),
141 CASE1(EXECUTION_MODE, ExecutionModeVertexOrderCw, Tessellation),
142 CASE1(EXECUTION_MODE, ExecutionModeVertexOrderCcw, Tessellation),
143 CASE1(EXECUTION_MODE, ExecutionModePixelCenterInteger, Shader),
144 CASE1(EXECUTION_MODE, ExecutionModeOriginUpperLeft, Shader),
145 CASE1(EXECUTION_MODE, ExecutionModeOriginLowerLeft, Shader),
146 CASE1(EXECUTION_MODE, ExecutionModeEarlyFragmentTests, Shader),
147 CASE1(EXECUTION_MODE, ExecutionModePointMode, Tessellation),
148 CASE1(EXECUTION_MODE, ExecutionModeXfb, TransformFeedback),
149 CASE1(EXECUTION_MODE, ExecutionModeDepthReplacing, Shader),
150 CASE1(EXECUTION_MODE, ExecutionModeDepthGreater, Shader),
151 CASE1(EXECUTION_MODE, ExecutionModeDepthLess, Shader),
152 CASE1(EXECUTION_MODE, ExecutionModeDepthUnchanged, Shader),
153 CASE0(EXECUTION_MODE, ExecutionModeLocalSize),
154 CASE1(EXECUTION_MODE, ExecutionModeLocalSizeHint, Kernel),
155 CASE1(EXECUTION_MODE, ExecutionModeInputPoints, Geometry),
156 CASE1(EXECUTION_MODE, ExecutionModeInputLines, Geometry),
157 CASE1(EXECUTION_MODE, ExecutionModeInputLinesAdjacency, Geometry),
158 CASE2(EXECUTION_MODE, ExecutionModeTriangles, Geometry,
159 Tessellation),
160 CASE1(EXECUTION_MODE, ExecutionModeInputTrianglesAdjacency,
161 Geometry),
162 CASE1(EXECUTION_MODE, ExecutionModeQuads, Tessellation),
163 CASE1(EXECUTION_MODE, ExecutionModeIsolines, Tessellation),
164 CASE3(EXECUTION_MODE, ExecutionModeOutputVertices, Geometry,
165 Tessellation, MeshShadingNV),
166 CASE2(EXECUTION_MODE, ExecutionModeOutputPoints, Geometry,
167 MeshShadingNV),
168 CASE1(EXECUTION_MODE, ExecutionModeOutputLineStrip, Geometry),
169 CASE1(EXECUTION_MODE, ExecutionModeOutputTriangleStrip, Geometry),
170 CASE1(EXECUTION_MODE, ExecutionModeVecTypeHint, Kernel),
171 CASE1(EXECUTION_MODE, ExecutionModeContractionOff, Kernel),
172 })));
173
174 INSTANTIATE_TEST_SUITE_P(
175 ExecutionModeV11, EnumCapabilityTest,
176 Combine(Values(SPV_ENV_UNIVERSAL_1_1),
177 ValuesIn(std::vector<EnumCapabilityCase>{
178 CASE1(EXECUTION_MODE, ExecutionModeInitializer, Kernel),
179 CASE1(EXECUTION_MODE, ExecutionModeFinalizer, Kernel),
180 CASE1(EXECUTION_MODE, ExecutionModeSubgroupSize,
181 SubgroupDispatch),
182 CASE1(EXECUTION_MODE, ExecutionModeSubgroupsPerWorkgroup,
183 SubgroupDispatch)})));
184
185 // See SPIR-V Section 3.7 Storage Class
186 INSTANTIATE_TEST_SUITE_P(
187 StorageClass, EnumCapabilityTest,
188 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
189 ValuesIn(std::vector<EnumCapabilityCase>{
190 CASE0(STORAGE_CLASS, StorageClassUniformConstant),
191 CASE1(STORAGE_CLASS, StorageClassUniform, Shader),
192 CASE1(STORAGE_CLASS, StorageClassOutput, Shader),
193 CASE0(STORAGE_CLASS, StorageClassWorkgroup),
194 CASE0(STORAGE_CLASS, StorageClassCrossWorkgroup),
195 CASE1(STORAGE_CLASS, StorageClassPrivate, Shader),
196 CASE0(STORAGE_CLASS, StorageClassFunction),
197 CASE1(STORAGE_CLASS, StorageClassGeneric,
198 GenericPointer), // Bug 14287
199 CASE1(STORAGE_CLASS, StorageClassPushConstant, Shader),
200 CASE1(STORAGE_CLASS, StorageClassAtomicCounter, AtomicStorage),
201 CASE0(STORAGE_CLASS, StorageClassImage),
202 })));
203
204 // See SPIR-V Section 3.8 Dim
205 INSTANTIATE_TEST_SUITE_P(
206 Dim, EnumCapabilityTest,
207 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
208 ValuesIn(std::vector<EnumCapabilityCase>{
209 CASE2(DIMENSIONALITY, Dim1D, Sampled1D, Image1D),
210 CASE3(DIMENSIONALITY, Dim2D, Kernel, Shader, ImageMSArray),
211 CASE0(DIMENSIONALITY, Dim3D),
212 CASE2(DIMENSIONALITY, DimCube, Shader, ImageCubeArray),
213 CASE2(DIMENSIONALITY, DimRect, SampledRect, ImageRect),
214 CASE2(DIMENSIONALITY, DimBuffer, SampledBuffer, ImageBuffer),
215 CASE1(DIMENSIONALITY, DimSubpassData, InputAttachment),
216 })));
217
218 // See SPIR-V Section 3.9 Sampler Addressing Mode
219 INSTANTIATE_TEST_SUITE_P(
220 SamplerAddressingMode, EnumCapabilityTest,
221 Combine(
222 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
223 ValuesIn(std::vector<EnumCapabilityCase>{
224 CASE1(SAMPLER_ADDRESSING_MODE, SamplerAddressingModeNone, Kernel),
225 CASE1(SAMPLER_ADDRESSING_MODE, SamplerAddressingModeClampToEdge,
226 Kernel),
227 CASE1(SAMPLER_ADDRESSING_MODE, SamplerAddressingModeClamp, Kernel),
228 CASE1(SAMPLER_ADDRESSING_MODE, SamplerAddressingModeRepeat, Kernel),
229 CASE1(SAMPLER_ADDRESSING_MODE, SamplerAddressingModeRepeatMirrored,
230 Kernel),
231 })));
232
233 // See SPIR-V Section 3.10 Sampler Filter Mode
234 INSTANTIATE_TEST_SUITE_P(
235 SamplerFilterMode, EnumCapabilityTest,
236 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
237 ValuesIn(std::vector<EnumCapabilityCase>{
238 CASE1(SAMPLER_FILTER_MODE, SamplerFilterModeNearest, Kernel),
239 CASE1(SAMPLER_FILTER_MODE, SamplerFilterModeLinear, Kernel),
240 })));
241
242 // See SPIR-V Section 3.11 Image Format
243 INSTANTIATE_TEST_SUITE_P(
244 ImageFormat, EnumCapabilityTest,
245 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
246 ValuesIn(std::vector<EnumCapabilityCase>{
247 // clang-format off
248 CASE0(SAMPLER_IMAGE_FORMAT, ImageFormatUnknown),
249 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba32f, Shader),
250 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba16f, Shader),
251 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR32f, Shader),
252 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba8, Shader),
253 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba8Snorm, Shader),
254 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg32f, StorageImageExtendedFormats),
255 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg16f, StorageImageExtendedFormats),
256 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR11fG11fB10f, StorageImageExtendedFormats),
257 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR16f, StorageImageExtendedFormats),
258 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba16, StorageImageExtendedFormats),
259 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgb10A2, StorageImageExtendedFormats),
260 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg16, StorageImageExtendedFormats),
261 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg8, StorageImageExtendedFormats),
262 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR16, StorageImageExtendedFormats),
263 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR8, StorageImageExtendedFormats),
264 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba16Snorm, StorageImageExtendedFormats),
265 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg16Snorm, StorageImageExtendedFormats),
266 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg8Snorm, StorageImageExtendedFormats),
267 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR16Snorm, StorageImageExtendedFormats),
268 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR8Snorm, StorageImageExtendedFormats),
269 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba32i, Shader),
270 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba16i, Shader),
271 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba8i, Shader),
272 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR32i, Shader),
273 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg32i, StorageImageExtendedFormats),
274 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg16i, StorageImageExtendedFormats),
275 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg8i, StorageImageExtendedFormats),
276 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR16i, StorageImageExtendedFormats),
277 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR8i, StorageImageExtendedFormats),
278 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba32ui, Shader),
279 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba16ui, Shader),
280 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba8ui, Shader),
281 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgba8ui, Shader),
282 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRgb10a2ui, StorageImageExtendedFormats),
283 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg32ui, StorageImageExtendedFormats),
284 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg16ui, StorageImageExtendedFormats),
285 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatRg8ui, StorageImageExtendedFormats),
286 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR16ui, StorageImageExtendedFormats),
287 CASE1(SAMPLER_IMAGE_FORMAT, ImageFormatR8ui, StorageImageExtendedFormats),
288 // clang-format on
289 })));
290
291 // See SPIR-V Section 3.12 Image Channel Order
292 INSTANTIATE_TEST_SUITE_P(
293 ImageChannelOrder, EnumCapabilityTest,
294 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
295 ValuesIn(std::vector<EnumCapabilityCase>{
296 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderR, Kernel),
297 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderA, Kernel),
298 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderRG, Kernel),
299 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderRA, Kernel),
300 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderRGB, Kernel),
301 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderRGBA, Kernel),
302 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderBGRA, Kernel),
303 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderARGB, Kernel),
304 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderIntensity, Kernel),
305 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderLuminance, Kernel),
306 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderRx, Kernel),
307 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderRGx, Kernel),
308 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderRGBx, Kernel),
309 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderDepth, Kernel),
310 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderDepthStencil,
311 Kernel),
312 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrdersRGB, Kernel),
313 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrdersRGBx, Kernel),
314 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrdersRGBA, Kernel),
315 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrdersBGRA, Kernel),
316 CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrderABGR, Kernel),
317 })));
318
319 // See SPIR-V Section 3.13 Image Channel Data Type
320 INSTANTIATE_TEST_SUITE_P(
321 ImageChannelDataType, EnumCapabilityTest,
322 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
323 ValuesIn(std::vector<EnumCapabilityCase>{
324 // clang-format off
325 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeSnormInt8, Kernel),
326 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeSnormInt16, Kernel),
327 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnormInt8, Kernel),
328 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnormInt16, Kernel),
329 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnormShort565, Kernel),
330 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnormShort555, Kernel),
331 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnormInt101010, Kernel),
332 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeSignedInt8, Kernel),
333 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeSignedInt16, Kernel),
334 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeSignedInt32, Kernel),
335 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnsignedInt8, Kernel),
336 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnsignedInt16, Kernel),
337 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnsignedInt32, Kernel),
338 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeHalfFloat, Kernel),
339 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeFloat, Kernel),
340 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnormInt24, Kernel),
341 CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataTypeUnormInt101010_2, Kernel),
342 // clang-format on
343 })));
344
345 // See SPIR-V Section 3.14 Image Operands
346 INSTANTIATE_TEST_SUITE_P(
347 ImageOperands, EnumCapabilityTest,
348 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
349 ValuesIn(std::vector<EnumCapabilityCase>{
350 // clang-format off
351 CASE0(OPTIONAL_IMAGE, ImageOperandsMaskNone),
352 CASE1(OPTIONAL_IMAGE, ImageOperandsBiasMask, Shader),
353 CASE0(OPTIONAL_IMAGE, ImageOperandsLodMask),
354 CASE0(OPTIONAL_IMAGE, ImageOperandsGradMask),
355 CASE0(OPTIONAL_IMAGE, ImageOperandsConstOffsetMask),
356 CASE1(OPTIONAL_IMAGE, ImageOperandsOffsetMask, ImageGatherExtended),
357 CASE1(OPTIONAL_IMAGE, ImageOperandsConstOffsetsMask, ImageGatherExtended),
358 CASE0(OPTIONAL_IMAGE, ImageOperandsSampleMask),
359 CASE1(OPTIONAL_IMAGE, ImageOperandsMinLodMask, MinLod),
360 // clang-format on
361 })));
362
363 // See SPIR-V Section 3.15 FP Fast Math Mode
364 INSTANTIATE_TEST_SUITE_P(
365 FPFastMathMode, EnumCapabilityTest,
366 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
367 ValuesIn(std::vector<EnumCapabilityCase>{
368 CASE0(FP_FAST_MATH_MODE, FPFastMathModeMaskNone),
369 CASE1(FP_FAST_MATH_MODE, FPFastMathModeNotNaNMask, Kernel),
370 CASE1(FP_FAST_MATH_MODE, FPFastMathModeNotInfMask, Kernel),
371 CASE1(FP_FAST_MATH_MODE, FPFastMathModeNSZMask, Kernel),
372 CASE1(FP_FAST_MATH_MODE, FPFastMathModeAllowRecipMask, Kernel),
373 CASE1(FP_FAST_MATH_MODE, FPFastMathModeFastMask, Kernel),
374 })));
375
376 // See SPIR-V Section 3.17 Linkage Type
377 INSTANTIATE_TEST_SUITE_P(
378 LinkageType, EnumCapabilityTest,
379 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
380 ValuesIn(std::vector<EnumCapabilityCase>{
381 CASE1(LINKAGE_TYPE, LinkageTypeExport, Linkage),
382 CASE1(LINKAGE_TYPE, LinkageTypeImport, Linkage),
383 })));
384
385 // See SPIR-V Section 3.18 Access Qualifier
386 INSTANTIATE_TEST_SUITE_P(
387 AccessQualifier, EnumCapabilityTest,
388 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
389 ValuesIn(std::vector<EnumCapabilityCase>{
390 CASE1(ACCESS_QUALIFIER, AccessQualifierReadOnly, Kernel),
391 CASE1(ACCESS_QUALIFIER, AccessQualifierWriteOnly, Kernel),
392 CASE1(ACCESS_QUALIFIER, AccessQualifierReadWrite, Kernel),
393 })));
394
395 // See SPIR-V Section 3.19 Function Parameter Attribute
396 INSTANTIATE_TEST_SUITE_P(
397 FunctionParameterAttribute, EnumCapabilityTest,
398 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
399 ValuesIn(std::vector<EnumCapabilityCase>{
400 // clang-format off
401 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttributeZext, Kernel),
402 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttributeSext, Kernel),
403 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttributeByVal, Kernel),
404 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttributeSret, Kernel),
405 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttributeNoAlias, Kernel),
406 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttributeNoCapture, Kernel),
407 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttributeNoWrite, Kernel),
408 CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttributeNoReadWrite, Kernel),
409 // clang-format on
410 })));
411
412 // See SPIR-V Section 3.20 Decoration
413 INSTANTIATE_TEST_SUITE_P(
414 Decoration, EnumCapabilityTest,
415 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
416 ValuesIn(std::vector<EnumCapabilityCase>{
417 CASE1(DECORATION, DecorationRelaxedPrecision, Shader),
418 // DecorationSpecId handled below.
419 CASE1(DECORATION, DecorationBlock, Shader),
420 CASE1(DECORATION, DecorationBufferBlock, Shader),
421 CASE1(DECORATION, DecorationRowMajor, Matrix),
422 CASE1(DECORATION, DecorationColMajor, Matrix),
423 CASE1(DECORATION, DecorationArrayStride, Shader),
424 CASE1(DECORATION, DecorationMatrixStride, Matrix), // Bug 15234
425 CASE1(DECORATION, DecorationGLSLShared, Shader),
426 CASE1(DECORATION, DecorationGLSLPacked, Shader),
427 CASE1(DECORATION, DecorationCPacked, Kernel),
428 CASE0(DECORATION, DecorationBuiltIn), // Bug 15248
429 // Value 12 placeholder
430 CASE1(DECORATION, DecorationNoPerspective, Shader),
431 CASE1(DECORATION, DecorationFlat, Shader),
432 CASE1(DECORATION, DecorationPatch, Tessellation),
433 CASE1(DECORATION, DecorationCentroid, Shader),
434 CASE1(DECORATION, DecorationSample,
435 SampleRateShading), // Bug 15234
436 CASE1(DECORATION, DecorationInvariant, Shader),
437 CASE0(DECORATION, DecorationRestrict),
438 CASE0(DECORATION, DecorationAliased),
439 CASE0(DECORATION, DecorationVolatile),
440 CASE1(DECORATION, DecorationConstant, Kernel),
441 CASE0(DECORATION, DecorationCoherent),
442 CASE0(DECORATION, DecorationNonWritable),
443 CASE0(DECORATION, DecorationNonReadable),
444 CASE1(DECORATION, DecorationUniform, Shader),
445 // Value 27 is an intentional gap in the spec numbering.
446 CASE1(DECORATION, DecorationSaturatedConversion, Kernel),
447 CASE1(DECORATION, DecorationStream, GeometryStreams),
448 CASE1(DECORATION, DecorationLocation, Shader),
449 CASE1(DECORATION, DecorationComponent, Shader),
450 CASE1(DECORATION, DecorationIndex, Shader),
451 CASE1(DECORATION, DecorationBinding, Shader),
452 CASE1(DECORATION, DecorationDescriptorSet, Shader),
453 CASE1(DECORATION, DecorationOffset, Shader), // Bug 15268
454 CASE1(DECORATION, DecorationXfbBuffer, TransformFeedback),
455 CASE1(DECORATION, DecorationXfbStride, TransformFeedback),
456 CASE1(DECORATION, DecorationFuncParamAttr, Kernel),
457 CASE1(DECORATION, DecorationFPFastMathMode, Kernel),
458 CASE1(DECORATION, DecorationLinkageAttributes, Linkage),
459 CASE1(DECORATION, DecorationNoContraction, Shader),
460 CASE1(DECORATION, DecorationInputAttachmentIndex,
461 InputAttachment),
462 CASE1(DECORATION, DecorationAlignment, Kernel),
463 })));
464
465 #if 0
466 // SpecId has different requirements in v1.0 and v1.1:
467 INSTANTIATE_TEST_SUITE_P(DecorationSpecIdV10, EnumCapabilityTest,
468 Combine(Values(SPV_ENV_UNIVERSAL_1_0),
469 ValuesIn(std::vector<EnumCapabilityCase>{CASE1(
470 DECORATION, DecorationSpecId, Shader)})));
471 #endif
472
473 INSTANTIATE_TEST_SUITE_P(
474 DecorationV11, EnumCapabilityTest,
475 Combine(Values(SPV_ENV_UNIVERSAL_1_1),
476 ValuesIn(std::vector<EnumCapabilityCase>{
477 CASE2(DECORATION, DecorationSpecId, Shader, Kernel),
478 CASE1(DECORATION, DecorationMaxByteOffset, Addresses)})));
479
480 // See SPIR-V Section 3.21 BuiltIn
481 INSTANTIATE_TEST_SUITE_P(
482 BuiltIn, EnumCapabilityTest,
483 Combine(
484 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
485 ValuesIn(std::vector<EnumCapabilityCase>{
486 // clang-format off
487 CASE1(BUILT_IN, BuiltInPosition, Shader),
488 CASE1(BUILT_IN, BuiltInPointSize, Shader),
489 // 2 is an intentional gap in the spec numbering.
490 CASE1(BUILT_IN, BuiltInClipDistance, ClipDistance), // Bug 1407, 15234
491 CASE1(BUILT_IN, BuiltInCullDistance, CullDistance), // Bug 1407, 15234
492 CASE1(BUILT_IN, BuiltInVertexId, Shader),
493 CASE1(BUILT_IN, BuiltInInstanceId, Shader),
494 CASE3(BUILT_IN, BuiltInPrimitiveId, Geometry, Tessellation,
495 RayTracingNV),
496 CASE2(BUILT_IN, BuiltInInvocationId, Geometry, Tessellation),
497 CASE2(BUILT_IN, BuiltInLayer, Geometry, ShaderViewportIndexLayerEXT),
498 CASE2(BUILT_IN, BuiltInViewportIndex, MultiViewport, ShaderViewportIndexLayerEXT), // Bug 15234
499 CASE1(BUILT_IN, BuiltInTessLevelOuter, Tessellation),
500 CASE1(BUILT_IN, BuiltInTessLevelInner, Tessellation),
501 CASE1(BUILT_IN, BuiltInTessCoord, Tessellation),
502 CASE1(BUILT_IN, BuiltInPatchVertices, Tessellation),
503 CASE1(BUILT_IN, BuiltInFragCoord, Shader),
504 CASE1(BUILT_IN, BuiltInPointCoord, Shader),
505 CASE1(BUILT_IN, BuiltInFrontFacing, Shader),
506 CASE1(BUILT_IN, BuiltInSampleId, SampleRateShading), // Bug 15234
507 CASE1(BUILT_IN, BuiltInSamplePosition, SampleRateShading), // Bug 15234
508 CASE1(BUILT_IN, BuiltInSampleMask, Shader), // Bug 15234, Issue 182
509 // Value 21 intentionally missing
510 CASE1(BUILT_IN, BuiltInFragDepth, Shader),
511 CASE1(BUILT_IN, BuiltInHelperInvocation, Shader),
512 CASE0(BUILT_IN, BuiltInNumWorkgroups),
513 CASE0(BUILT_IN, BuiltInWorkgroupSize),
514 CASE0(BUILT_IN, BuiltInWorkgroupId),
515 CASE0(BUILT_IN, BuiltInLocalInvocationId),
516 CASE0(BUILT_IN, BuiltInGlobalInvocationId),
517 CASE0(BUILT_IN, BuiltInLocalInvocationIndex),
518 CASE1(BUILT_IN, BuiltInWorkDim, Kernel),
519 CASE1(BUILT_IN, BuiltInGlobalSize, Kernel),
520 CASE1(BUILT_IN, BuiltInEnqueuedWorkgroupSize, Kernel),
521 CASE1(BUILT_IN, BuiltInGlobalOffset, Kernel),
522 CASE1(BUILT_IN, BuiltInGlobalLinearId, Kernel),
523 // Value 35 intentionally missing
524 CASE2(BUILT_IN, BuiltInSubgroupSize, Kernel, SubgroupBallotKHR),
525 CASE1(BUILT_IN, BuiltInSubgroupMaxSize, Kernel),
526 CASE1(BUILT_IN, BuiltInNumSubgroups, Kernel),
527 CASE1(BUILT_IN, BuiltInNumEnqueuedSubgroups, Kernel),
528 CASE1(BUILT_IN, BuiltInSubgroupId, Kernel),
529 CASE2(BUILT_IN, BuiltInSubgroupLocalInvocationId, Kernel, SubgroupBallotKHR),
530 CASE1(BUILT_IN, BuiltInVertexIndex, Shader),
531 CASE1(BUILT_IN, BuiltInInstanceIndex, Shader),
532 // clang-format on
533 })));
534
535 INSTANTIATE_TEST_SUITE_P(
536 BuiltInV1_5, EnumCapabilityTest,
537 Combine(
538 Values(SPV_ENV_UNIVERSAL_1_5),
539 ValuesIn(std::vector<EnumCapabilityCase>{
540 // SPIR-V 1.5 adds new capabilities to enable these two builtins.
541 CASE3(BUILT_IN, BuiltInLayer, Geometry, ShaderLayer,
542 ShaderViewportIndexLayerEXT),
543 CASE3(BUILT_IN, BuiltInViewportIndex, MultiViewport,
544 ShaderViewportIndex, ShaderViewportIndexLayerEXT),
545 })));
546
547 // See SPIR-V Section 3.22 Selection Control
548 INSTANTIATE_TEST_SUITE_P(
549 SelectionControl, EnumCapabilityTest,
550 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
551 ValuesIn(std::vector<EnumCapabilityCase>{
552 CASE0(SELECTION_CONTROL, SelectionControlMaskNone),
553 CASE0(SELECTION_CONTROL, SelectionControlFlattenMask),
554 CASE0(SELECTION_CONTROL, SelectionControlDontFlattenMask),
555 })));
556
557 // See SPIR-V Section 3.23 Loop Control
558 INSTANTIATE_TEST_SUITE_P(
559 LoopControl, EnumCapabilityTest,
560 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
561 ValuesIn(std::vector<EnumCapabilityCase>{
562 CASE0(LOOP_CONTROL, LoopControlMaskNone),
563 CASE0(LOOP_CONTROL, LoopControlUnrollMask),
564 CASE0(LOOP_CONTROL, LoopControlDontUnrollMask),
565 })));
566
567 INSTANTIATE_TEST_SUITE_P(
568 LoopControlV11, EnumCapabilityTest,
569 Combine(Values(SPV_ENV_UNIVERSAL_1_1),
570 ValuesIn(std::vector<EnumCapabilityCase>{
571 CASE0(LOOP_CONTROL, LoopControlDependencyInfiniteMask),
572 CASE0(LOOP_CONTROL, LoopControlDependencyLengthMask),
573 })));
574
575 // See SPIR-V Section 3.24 Function Control
576 INSTANTIATE_TEST_SUITE_P(
577 FunctionControl, EnumCapabilityTest,
578 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
579 ValuesIn(std::vector<EnumCapabilityCase>{
580 CASE0(FUNCTION_CONTROL, FunctionControlMaskNone),
581 CASE0(FUNCTION_CONTROL, FunctionControlInlineMask),
582 CASE0(FUNCTION_CONTROL, FunctionControlDontInlineMask),
583 CASE0(FUNCTION_CONTROL, FunctionControlPureMask),
584 CASE0(FUNCTION_CONTROL, FunctionControlConstMask),
585 })));
586
587 // See SPIR-V Section 3.25 Memory Semantics <id>
588 INSTANTIATE_TEST_SUITE_P(
589 MemorySemantics, EnumCapabilityTest,
590 Combine(
591 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
592 ValuesIn(std::vector<EnumCapabilityCase>{
593 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMaskNone),
594 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsAcquireMask),
595 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsReleaseMask),
596 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsAcquireReleaseMask),
597 CASE0(MEMORY_SEMANTICS_ID,
598 MemorySemanticsSequentiallyConsistentMask),
599 CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsUniformMemoryMask,
600 Shader),
601 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsSubgroupMemoryMask),
602 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsWorkgroupMemoryMask),
603 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsCrossWorkgroupMemoryMask),
604 CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsAtomicCounterMemoryMask,
605 AtomicStorage), // Bug 15234
606 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsImageMemoryMask),
607 })));
608
609 // See SPIR-V Section 3.26 Memory Access
610 INSTANTIATE_TEST_SUITE_P(
611 MemoryAccess, EnumCapabilityTest,
612 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
613 ValuesIn(std::vector<EnumCapabilityCase>{
614 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMaskNone),
615 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessVolatileMask),
616 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessAlignedMask),
617 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessNontemporalMask),
618 })));
619
620 // See SPIR-V Section 3.27 Scope <id>
621 INSTANTIATE_TEST_SUITE_P(
622 Scope, EnumCapabilityTest,
623 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
624 SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3),
625 ValuesIn(std::vector<EnumCapabilityCase>{
626 CASE0(SCOPE_ID, ScopeCrossDevice),
627 CASE0(SCOPE_ID, ScopeDevice),
628 CASE0(SCOPE_ID, ScopeWorkgroup),
629 CASE0(SCOPE_ID, ScopeSubgroup),
630 CASE0(SCOPE_ID, ScopeInvocation),
631 CASE1(SCOPE_ID, ScopeQueueFamilyKHR, VulkanMemoryModelKHR),
632 })));
633
634 // See SPIR-V Section 3.28 Group Operation
635 INSTANTIATE_TEST_SUITE_P(
636 GroupOperation, EnumCapabilityTest,
637 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
638 ValuesIn(std::vector<EnumCapabilityCase>{
639 CASE3(GROUP_OPERATION, GroupOperationReduce, Kernel,
640 GroupNonUniformArithmetic, GroupNonUniformBallot),
641 CASE3(GROUP_OPERATION, GroupOperationInclusiveScan, Kernel,
642 GroupNonUniformArithmetic, GroupNonUniformBallot),
643 CASE3(GROUP_OPERATION, GroupOperationExclusiveScan, Kernel,
644 GroupNonUniformArithmetic, GroupNonUniformBallot),
645 })));
646
647 // See SPIR-V Section 3.29 Kernel Enqueue Flags
648 INSTANTIATE_TEST_SUITE_P(
649 KernelEnqueueFlags, EnumCapabilityTest,
650 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
651 ValuesIn(std::vector<EnumCapabilityCase>{
652 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlagsNoWait, Kernel),
653 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlagsWaitKernel, Kernel),
654 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlagsWaitWorkGroup,
655 Kernel),
656 })));
657
658 // See SPIR-V Section 3.30 Kernel Profiling Info
659 INSTANTIATE_TEST_SUITE_P(
660 KernelProfilingInfo, EnumCapabilityTest,
661 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
662 ValuesIn(std::vector<EnumCapabilityCase>{
663 CASE0(KERNEL_PROFILING_INFO, KernelProfilingInfoMaskNone),
664 CASE1(KERNEL_PROFILING_INFO, KernelProfilingInfoCmdExecTimeMask,
665 Kernel),
666 })));
667
668 // See SPIR-V Section 3.31 Capability
669 INSTANTIATE_TEST_SUITE_P(
670 CapabilityDependsOn, EnumCapabilityTest,
671 Combine(
672 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
673 ValuesIn(std::vector<EnumCapabilityCase>{
674 // clang-format off
675 CASE0(CAPABILITY, CapabilityMatrix),
676 CASE1(CAPABILITY, CapabilityShader, Matrix),
677 CASE1(CAPABILITY, CapabilityGeometry, Shader),
678 CASE1(CAPABILITY, CapabilityTessellation, Shader),
679 CASE0(CAPABILITY, CapabilityAddresses),
680 CASE0(CAPABILITY, CapabilityLinkage),
681 CASE0(CAPABILITY, CapabilityKernel),
682 CASE1(CAPABILITY, CapabilityVector16, Kernel),
683 CASE1(CAPABILITY, CapabilityFloat16Buffer, Kernel),
684 CASE0(CAPABILITY, CapabilityFloat16), // Bug 15234
685 CASE0(CAPABILITY, CapabilityFloat64),
686 CASE0(CAPABILITY, CapabilityInt64),
687 CASE1(CAPABILITY, CapabilityInt64Atomics, Int64),
688 CASE1(CAPABILITY, CapabilityImageBasic, Kernel),
689 CASE1(CAPABILITY, CapabilityImageReadWrite, ImageBasic),
690 CASE1(CAPABILITY, CapabilityImageMipmap, ImageBasic),
691 // Value 16 intentionally missing.
692 CASE1(CAPABILITY, CapabilityPipes, Kernel),
693 CASE0(CAPABILITY, CapabilityGroups),
694 CASE1(CAPABILITY, CapabilityDeviceEnqueue, Kernel),
695 CASE1(CAPABILITY, CapabilityLiteralSampler, Kernel),
696 CASE1(CAPABILITY, CapabilityAtomicStorage, Shader),
697 CASE0(CAPABILITY, CapabilityInt16),
698 CASE1(CAPABILITY, CapabilityTessellationPointSize, Tessellation),
699 CASE1(CAPABILITY, CapabilityGeometryPointSize, Geometry),
700 CASE1(CAPABILITY, CapabilityImageGatherExtended, Shader),
701 // Value 26 intentionally missing.
702 CASE1(CAPABILITY, CapabilityStorageImageMultisample, Shader),
703 CASE1(CAPABILITY, CapabilityUniformBufferArrayDynamicIndexing, Shader),
704 CASE1(CAPABILITY, CapabilitySampledImageArrayDynamicIndexing, Shader),
705 CASE1(CAPABILITY, CapabilityStorageBufferArrayDynamicIndexing, Shader),
706 CASE1(CAPABILITY, CapabilityStorageImageArrayDynamicIndexing, Shader),
707 CASE1(CAPABILITY, CapabilityClipDistance, Shader),
708 CASE1(CAPABILITY, CapabilityCullDistance, Shader),
709 CASE1(CAPABILITY, CapabilityImageCubeArray, SampledCubeArray),
710 CASE1(CAPABILITY, CapabilitySampleRateShading, Shader),
711 CASE1(CAPABILITY, CapabilityImageRect, SampledRect),
712 CASE1(CAPABILITY, CapabilitySampledRect, Shader),
713 CASE1(CAPABILITY, CapabilityGenericPointer, Addresses),
714 CASE0(CAPABILITY, CapabilityInt8),
715 CASE1(CAPABILITY, CapabilityInputAttachment, Shader),
716 CASE1(CAPABILITY, CapabilitySparseResidency, Shader),
717 CASE1(CAPABILITY, CapabilityMinLod, Shader),
718 CASE1(CAPABILITY, CapabilityImage1D, Sampled1D),
719 CASE1(CAPABILITY, CapabilitySampledCubeArray, Shader),
720 CASE1(CAPABILITY, CapabilityImageBuffer, SampledBuffer),
721 CASE1(CAPABILITY, CapabilityImageMSArray, Shader),
722 CASE1(CAPABILITY, CapabilityStorageImageExtendedFormats, Shader),
723 CASE1(CAPABILITY, CapabilityImageQuery, Shader),
724 CASE1(CAPABILITY, CapabilityDerivativeControl, Shader),
725 CASE1(CAPABILITY, CapabilityInterpolationFunction, Shader),
726 CASE1(CAPABILITY, CapabilityTransformFeedback, Shader),
727 CASE1(CAPABILITY, CapabilityGeometryStreams, Geometry),
728 CASE1(CAPABILITY, CapabilityStorageImageReadWithoutFormat, Shader),
729 CASE1(CAPABILITY, CapabilityStorageImageWriteWithoutFormat, Shader),
730 CASE1(CAPABILITY, CapabilityMultiViewport, Geometry),
731 // clang-format on
732 })));
733
734 INSTANTIATE_TEST_SUITE_P(
735 CapabilityDependsOnV11, EnumCapabilityTest,
736 Combine(Values(SPV_ENV_UNIVERSAL_1_1),
737 ValuesIn(std::vector<EnumCapabilityCase>{
738 CASE1(CAPABILITY, CapabilitySubgroupDispatch, DeviceEnqueue),
739 CASE1(CAPABILITY, CapabilityNamedBarrier, Kernel),
740 CASE1(CAPABILITY, CapabilityPipeStorage, Pipes),
741 })));
742
743 #undef CASE0
744 #undef CASE1
745 #undef CASE2
746
747 } // namespace
748 } // namespace spvtools
749