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