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