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 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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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_CASE_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 CASE1(BUILT_IN, BuiltInLayer, Geometry), 498 CASE1(BUILT_IN, BuiltInViewportIndex, MultiViewport), // 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 // See SPIR-V Section 3.22 Selection Control 536 INSTANTIATE_TEST_CASE_P( 537 SelectionControl, EnumCapabilityTest, 538 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 539 ValuesIn(std::vector<EnumCapabilityCase>{ 540 CASE0(SELECTION_CONTROL, SelectionControlMaskNone), 541 CASE0(SELECTION_CONTROL, SelectionControlFlattenMask), 542 CASE0(SELECTION_CONTROL, SelectionControlDontFlattenMask), 543 })), ); 544 545 // See SPIR-V Section 3.23 Loop Control 546 INSTANTIATE_TEST_CASE_P( 547 LoopControl, EnumCapabilityTest, 548 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 549 ValuesIn(std::vector<EnumCapabilityCase>{ 550 CASE0(LOOP_CONTROL, LoopControlMaskNone), 551 CASE0(LOOP_CONTROL, LoopControlUnrollMask), 552 CASE0(LOOP_CONTROL, LoopControlDontUnrollMask), 553 })), ); 554 555 INSTANTIATE_TEST_CASE_P( 556 LoopControlV11, EnumCapabilityTest, 557 Combine(Values(SPV_ENV_UNIVERSAL_1_1), 558 ValuesIn(std::vector<EnumCapabilityCase>{ 559 CASE0(LOOP_CONTROL, LoopControlDependencyInfiniteMask), 560 CASE0(LOOP_CONTROL, LoopControlDependencyLengthMask), 561 })), ); 562 563 // See SPIR-V Section 3.24 Function Control 564 INSTANTIATE_TEST_CASE_P( 565 FunctionControl, EnumCapabilityTest, 566 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 567 ValuesIn(std::vector<EnumCapabilityCase>{ 568 CASE0(FUNCTION_CONTROL, FunctionControlMaskNone), 569 CASE0(FUNCTION_CONTROL, FunctionControlInlineMask), 570 CASE0(FUNCTION_CONTROL, FunctionControlDontInlineMask), 571 CASE0(FUNCTION_CONTROL, FunctionControlPureMask), 572 CASE0(FUNCTION_CONTROL, FunctionControlConstMask), 573 })), ); 574 575 // See SPIR-V Section 3.25 Memory Semantics <id> 576 INSTANTIATE_TEST_CASE_P( 577 MemorySemantics, EnumCapabilityTest, 578 Combine( 579 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 580 ValuesIn(std::vector<EnumCapabilityCase>{ 581 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMaskNone), 582 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsAcquireMask), 583 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsReleaseMask), 584 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsAcquireReleaseMask), 585 CASE0(MEMORY_SEMANTICS_ID, 586 MemorySemanticsSequentiallyConsistentMask), 587 CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsUniformMemoryMask, 588 Shader), 589 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsSubgroupMemoryMask), 590 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsWorkgroupMemoryMask), 591 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsCrossWorkgroupMemoryMask), 592 CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsAtomicCounterMemoryMask, 593 AtomicStorage), // Bug 15234 594 CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsImageMemoryMask), 595 })), ); 596 597 // See SPIR-V Section 3.26 Memory Access 598 INSTANTIATE_TEST_CASE_P( 599 MemoryAccess, EnumCapabilityTest, 600 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 601 ValuesIn(std::vector<EnumCapabilityCase>{ 602 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMaskNone), 603 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessVolatileMask), 604 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessAlignedMask), 605 CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessNontemporalMask), 606 })), ); 607 608 // See SPIR-V Section 3.27 Scope <id> 609 INSTANTIATE_TEST_CASE_P( 610 Scope, EnumCapabilityTest, 611 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, 612 SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), 613 ValuesIn(std::vector<EnumCapabilityCase>{ 614 CASE0(SCOPE_ID, ScopeCrossDevice), 615 CASE0(SCOPE_ID, ScopeDevice), 616 CASE0(SCOPE_ID, ScopeWorkgroup), 617 CASE0(SCOPE_ID, ScopeSubgroup), 618 CASE0(SCOPE_ID, ScopeInvocation), 619 CASE1(SCOPE_ID, ScopeQueueFamilyKHR, VulkanMemoryModelKHR), 620 })), ); 621 622 // See SPIR-V Section 3.28 Group Operation 623 INSTANTIATE_TEST_CASE_P( 624 GroupOperation, EnumCapabilityTest, 625 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 626 ValuesIn(std::vector<EnumCapabilityCase>{ 627 CASE3(GROUP_OPERATION, GroupOperationReduce, Kernel, 628 GroupNonUniformArithmetic, GroupNonUniformBallot), 629 CASE3(GROUP_OPERATION, GroupOperationInclusiveScan, Kernel, 630 GroupNonUniformArithmetic, GroupNonUniformBallot), 631 CASE3(GROUP_OPERATION, GroupOperationExclusiveScan, Kernel, 632 GroupNonUniformArithmetic, GroupNonUniformBallot), 633 })), ); 634 635 // See SPIR-V Section 3.29 Kernel Enqueue Flags 636 INSTANTIATE_TEST_CASE_P( 637 KernelEnqueueFlags, EnumCapabilityTest, 638 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 639 ValuesIn(std::vector<EnumCapabilityCase>{ 640 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlagsNoWait, Kernel), 641 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlagsWaitKernel, Kernel), 642 CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlagsWaitWorkGroup, 643 Kernel), 644 })), ); 645 646 // See SPIR-V Section 3.30 Kernel Profiling Info 647 INSTANTIATE_TEST_CASE_P( 648 KernelProfilingInfo, EnumCapabilityTest, 649 Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 650 ValuesIn(std::vector<EnumCapabilityCase>{ 651 CASE0(KERNEL_PROFILING_INFO, KernelProfilingInfoMaskNone), 652 CASE1(KERNEL_PROFILING_INFO, KernelProfilingInfoCmdExecTimeMask, 653 Kernel), 654 })), ); 655 656 // See SPIR-V Section 3.31 Capability 657 INSTANTIATE_TEST_CASE_P( 658 CapabilityDependsOn, EnumCapabilityTest, 659 Combine( 660 Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), 661 ValuesIn(std::vector<EnumCapabilityCase>{ 662 // clang-format off 663 CASE0(CAPABILITY, CapabilityMatrix), 664 CASE1(CAPABILITY, CapabilityShader, Matrix), 665 CASE1(CAPABILITY, CapabilityGeometry, Shader), 666 CASE1(CAPABILITY, CapabilityTessellation, Shader), 667 CASE0(CAPABILITY, CapabilityAddresses), 668 CASE0(CAPABILITY, CapabilityLinkage), 669 CASE0(CAPABILITY, CapabilityKernel), 670 CASE1(CAPABILITY, CapabilityVector16, Kernel), 671 CASE1(CAPABILITY, CapabilityFloat16Buffer, Kernel), 672 CASE0(CAPABILITY, CapabilityFloat16), // Bug 15234 673 CASE0(CAPABILITY, CapabilityFloat64), 674 CASE0(CAPABILITY, CapabilityInt64), 675 CASE1(CAPABILITY, CapabilityInt64Atomics, Int64), 676 CASE1(CAPABILITY, CapabilityImageBasic, Kernel), 677 CASE1(CAPABILITY, CapabilityImageReadWrite, ImageBasic), 678 CASE1(CAPABILITY, CapabilityImageMipmap, ImageBasic), 679 // Value 16 intentionally missing. 680 CASE1(CAPABILITY, CapabilityPipes, Kernel), 681 CASE0(CAPABILITY, CapabilityGroups), 682 CASE1(CAPABILITY, CapabilityDeviceEnqueue, Kernel), 683 CASE1(CAPABILITY, CapabilityLiteralSampler, Kernel), 684 CASE1(CAPABILITY, CapabilityAtomicStorage, Shader), 685 CASE0(CAPABILITY, CapabilityInt16), 686 CASE1(CAPABILITY, CapabilityTessellationPointSize, Tessellation), 687 CASE1(CAPABILITY, CapabilityGeometryPointSize, Geometry), 688 CASE1(CAPABILITY, CapabilityImageGatherExtended, Shader), 689 // Value 26 intentionally missing. 690 CASE1(CAPABILITY, CapabilityStorageImageMultisample, Shader), 691 CASE1(CAPABILITY, CapabilityUniformBufferArrayDynamicIndexing, Shader), 692 CASE1(CAPABILITY, CapabilitySampledImageArrayDynamicIndexing, Shader), 693 CASE1(CAPABILITY, CapabilityStorageBufferArrayDynamicIndexing, Shader), 694 CASE1(CAPABILITY, CapabilityStorageImageArrayDynamicIndexing, Shader), 695 CASE1(CAPABILITY, CapabilityClipDistance, Shader), 696 CASE1(CAPABILITY, CapabilityCullDistance, Shader), 697 CASE1(CAPABILITY, CapabilityImageCubeArray, SampledCubeArray), 698 CASE1(CAPABILITY, CapabilitySampleRateShading, Shader), 699 CASE1(CAPABILITY, CapabilityImageRect, SampledRect), 700 CASE1(CAPABILITY, CapabilitySampledRect, Shader), 701 CASE1(CAPABILITY, CapabilityGenericPointer, Addresses), 702 CASE0(CAPABILITY, CapabilityInt8), 703 CASE1(CAPABILITY, CapabilityInputAttachment, Shader), 704 CASE1(CAPABILITY, CapabilitySparseResidency, Shader), 705 CASE1(CAPABILITY, CapabilityMinLod, Shader), 706 CASE1(CAPABILITY, CapabilityImage1D, Sampled1D), 707 CASE1(CAPABILITY, CapabilitySampledCubeArray, Shader), 708 CASE1(CAPABILITY, CapabilityImageBuffer, SampledBuffer), 709 CASE1(CAPABILITY, CapabilityImageMSArray, Shader), 710 CASE1(CAPABILITY, CapabilityStorageImageExtendedFormats, Shader), 711 CASE1(CAPABILITY, CapabilityImageQuery, Shader), 712 CASE1(CAPABILITY, CapabilityDerivativeControl, Shader), 713 CASE1(CAPABILITY, CapabilityInterpolationFunction, Shader), 714 CASE1(CAPABILITY, CapabilityTransformFeedback, Shader), 715 CASE1(CAPABILITY, CapabilityGeometryStreams, Geometry), 716 CASE1(CAPABILITY, CapabilityStorageImageReadWithoutFormat, Shader), 717 CASE1(CAPABILITY, CapabilityStorageImageWriteWithoutFormat, Shader), 718 CASE1(CAPABILITY, CapabilityMultiViewport, Geometry), 719 // clang-format on 720 })), ); 721 722 INSTANTIATE_TEST_CASE_P( 723 CapabilityDependsOnV11, EnumCapabilityTest, 724 Combine(Values(SPV_ENV_UNIVERSAL_1_1), 725 ValuesIn(std::vector<EnumCapabilityCase>{ 726 CASE1(CAPABILITY, CapabilitySubgroupDispatch, DeviceEnqueue), 727 CASE1(CAPABILITY, CapabilityNamedBarrier, Kernel), 728 CASE1(CAPABILITY, CapabilityPipeStorage, Pipes), 729 })), ); 730 731 #undef CASE0 732 #undef CASE1 733 #undef CASE2 734 735 } // namespace 736 } // namespace spvtools 737
