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