| // Copyright (c) 2015-2016 The Khronos Group Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // Test capability dependencies for enums. |
| |
| #include <tuple> |
| #include <vector> |
| |
| #include "gmock/gmock.h" |
| #include "source/enum_set.h" |
| #include "test/unit_spirv.h" |
| |
| namespace spvtools { |
| namespace { |
| |
| using spvtest::ElementsIn; |
| using ::testing::Combine; |
| using ::testing::Eq; |
| using ::testing::TestWithParam; |
| using ::testing::Values; |
| using ::testing::ValuesIn; |
| |
| // A test case for mapping an enum to a capability mask. |
| struct EnumCapabilityCase { |
| spv_operand_type_t type; |
| uint32_t value; |
| CapabilitySet expected_capabilities; |
| }; |
| |
| // Test fixture for testing EnumCapabilityCases. |
| using EnumCapabilityTest = |
| TestWithParam<std::tuple<spv_target_env, EnumCapabilityCase>>; |
| |
| TEST_P(EnumCapabilityTest, Sample) { |
| const auto env = std::get<0>(GetParam()); |
| const auto context = spvContextCreate(env); |
| const AssemblyGrammar grammar(context); |
| spv_operand_desc entry; |
| |
| ASSERT_EQ(SPV_SUCCESS, |
| grammar.lookupOperand(std::get<1>(GetParam()).type, |
| std::get<1>(GetParam()).value, &entry)); |
| const auto cap_set = grammar.filterCapsAgainstTargetEnv( |
| entry->capabilities, entry->numCapabilities); |
| |
| EXPECT_THAT(ElementsIn(cap_set), |
| Eq(ElementsIn(std::get<1>(GetParam()).expected_capabilities))) |
| << " capability value " << std::get<1>(GetParam()).value; |
| spvContextDestroy(context); |
| } |
| |
| #define CASE0(TYPE, VALUE) \ |
| { \ |
| SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), {} \ |
| } |
| #define CASE1(TYPE, VALUE, CAP) \ |
| { \ |
| SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ |
| spv::Capability::CAP \ |
| } \ |
| } |
| #define CASE2(TYPE, VALUE, CAP1, CAP2) \ |
| { \ |
| SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ |
| spv::Capability::CAP1, spv::Capability::CAP2 \ |
| } \ |
| } |
| #define CASE3(TYPE, VALUE, CAP1, CAP2, CAP3) \ |
| { \ |
| SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ |
| spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3 \ |
| } \ |
| } |
| #define CASE4(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4) \ |
| { \ |
| SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ |
| spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \ |
| spv::Capability::CAP4 \ |
| } \ |
| } |
| #define CASE5(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4, CAP5) \ |
| { \ |
| SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ |
| spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \ |
| spv::Capability::CAP4, spv::Capability::CAP5 \ |
| } \ |
| } |
| |
| #define CASE6(TYPE, VALUE, CAP1, CAP2, CAP3, CAP4, CAP5, CAP6) \ |
| { \ |
| SPV_OPERAND_TYPE_##TYPE, uint32_t(spv::VALUE), CapabilitySet { \ |
| spv::Capability::CAP1, spv::Capability::CAP2, spv::Capability::CAP3, \ |
| spv::Capability::CAP4, spv::Capability::CAP5, spv::Capability::CAP6 \ |
| } \ |
| } |
| |
| // See SPIR-V Section 3.3 Execution Model |
| INSTANTIATE_TEST_SUITE_P( |
| ExecutionModel, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(EXECUTION_MODEL, ExecutionModel::Vertex, Shader), |
| CASE1(EXECUTION_MODEL, ExecutionModel::TessellationControl, |
| Tessellation), |
| CASE1(EXECUTION_MODEL, ExecutionModel::TessellationEvaluation, |
| Tessellation), |
| CASE1(EXECUTION_MODEL, ExecutionModel::Geometry, Geometry), |
| CASE1(EXECUTION_MODEL, ExecutionModel::Fragment, Shader), |
| CASE1(EXECUTION_MODEL, ExecutionModel::GLCompute, Shader), |
| CASE1(EXECUTION_MODEL, ExecutionModel::Kernel, Kernel), |
| }))); |
| |
| // See SPIR-V Section 3.4 Addressing Model |
| INSTANTIATE_TEST_SUITE_P( |
| AddressingModel, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(ADDRESSING_MODEL, AddressingModel::Logical), |
| CASE1(ADDRESSING_MODEL, AddressingModel::Physical32, Addresses), |
| CASE1(ADDRESSING_MODEL, AddressingModel::Physical64, Addresses), |
| }))); |
| |
| // See SPIR-V Section 3.5 Memory Model |
| INSTANTIATE_TEST_SUITE_P( |
| MemoryModel, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(MEMORY_MODEL, MemoryModel::Simple, Shader), |
| CASE1(MEMORY_MODEL, MemoryModel::GLSL450, Shader), |
| CASE1(MEMORY_MODEL, MemoryModel::OpenCL, Kernel), |
| }))); |
| |
| // See SPIR-V Section 3.6 Execution Mode |
| INSTANTIATE_TEST_SUITE_P( |
| ExecutionMode, EnumCapabilityTest, |
| Combine( |
| Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(EXECUTION_MODE, ExecutionMode::Invocations, Geometry), |
| CASE1(EXECUTION_MODE, ExecutionMode::SpacingEqual, Tessellation), |
| CASE1(EXECUTION_MODE, ExecutionMode::SpacingFractionalEven, |
| Tessellation), |
| CASE1(EXECUTION_MODE, ExecutionMode::SpacingFractionalOdd, |
| Tessellation), |
| CASE1(EXECUTION_MODE, ExecutionMode::VertexOrderCw, Tessellation), |
| CASE1(EXECUTION_MODE, ExecutionMode::VertexOrderCcw, Tessellation), |
| CASE1(EXECUTION_MODE, ExecutionMode::PixelCenterInteger, Shader), |
| CASE1(EXECUTION_MODE, ExecutionMode::OriginUpperLeft, Shader), |
| CASE1(EXECUTION_MODE, ExecutionMode::OriginLowerLeft, Shader), |
| CASE1(EXECUTION_MODE, ExecutionMode::EarlyFragmentTests, Shader), |
| CASE1(EXECUTION_MODE, ExecutionMode::PointMode, Tessellation), |
| CASE1(EXECUTION_MODE, ExecutionMode::Xfb, TransformFeedback), |
| CASE1(EXECUTION_MODE, ExecutionMode::DepthReplacing, Shader), |
| CASE1(EXECUTION_MODE, ExecutionMode::DepthGreater, Shader), |
| CASE1(EXECUTION_MODE, ExecutionMode::DepthLess, Shader), |
| CASE1(EXECUTION_MODE, ExecutionMode::DepthUnchanged, Shader), |
| CASE0(EXECUTION_MODE, ExecutionMode::LocalSize), |
| CASE1(EXECUTION_MODE, ExecutionMode::LocalSizeHint, Kernel), |
| CASE1(EXECUTION_MODE, ExecutionMode::InputPoints, Geometry), |
| CASE1(EXECUTION_MODE, ExecutionMode::InputLines, Geometry), |
| CASE1(EXECUTION_MODE, ExecutionMode::InputLinesAdjacency, Geometry), |
| CASE2(EXECUTION_MODE, ExecutionMode::Triangles, Geometry, |
| Tessellation), |
| CASE1(EXECUTION_MODE, ExecutionMode::InputTrianglesAdjacency, |
| Geometry), |
| CASE1(EXECUTION_MODE, ExecutionMode::Quads, Tessellation), |
| CASE1(EXECUTION_MODE, ExecutionMode::Isolines, Tessellation), |
| CASE4(EXECUTION_MODE, ExecutionMode::OutputVertices, Geometry, |
| Tessellation, MeshShadingNV, MeshShadingEXT), |
| CASE3(EXECUTION_MODE, ExecutionMode::OutputPoints, Geometry, |
| MeshShadingNV, MeshShadingEXT), |
| CASE1(EXECUTION_MODE, ExecutionMode::OutputLineStrip, Geometry), |
| CASE1(EXECUTION_MODE, ExecutionMode::OutputTriangleStrip, Geometry), |
| CASE1(EXECUTION_MODE, ExecutionMode::VecTypeHint, Kernel), |
| CASE1(EXECUTION_MODE, ExecutionMode::ContractionOff, Kernel), |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ExecutionModeV11, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(EXECUTION_MODE, ExecutionMode::Initializer, Kernel), |
| CASE1(EXECUTION_MODE, ExecutionMode::Finalizer, Kernel), |
| CASE1(EXECUTION_MODE, ExecutionMode::SubgroupSize, |
| SubgroupDispatch), |
| CASE1(EXECUTION_MODE, ExecutionMode::SubgroupsPerWorkgroup, |
| SubgroupDispatch)}))); |
| |
| // See SPIR-V Section 3.7 Storage Class |
| INSTANTIATE_TEST_SUITE_P( |
| StorageClass, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(STORAGE_CLASS, StorageClass::UniformConstant), |
| CASE1(STORAGE_CLASS, StorageClass::Uniform, Shader), |
| CASE1(STORAGE_CLASS, StorageClass::Output, Shader), |
| CASE0(STORAGE_CLASS, StorageClass::Workgroup), |
| CASE0(STORAGE_CLASS, StorageClass::CrossWorkgroup), |
| CASE2(STORAGE_CLASS, StorageClass::Private, Shader, |
| VectorComputeINTEL), |
| CASE0(STORAGE_CLASS, StorageClass::Function), |
| CASE1(STORAGE_CLASS, StorageClass::Generic, |
| GenericPointer), // Bug 14287 |
| CASE1(STORAGE_CLASS, StorageClass::PushConstant, Shader), |
| CASE1(STORAGE_CLASS, StorageClass::AtomicCounter, |
| AtomicStorage), |
| CASE0(STORAGE_CLASS, StorageClass::Image), |
| }))); |
| |
| // See SPIR-V Section 3.8 Dim |
| INSTANTIATE_TEST_SUITE_P( |
| Dim, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE2(DIMENSIONALITY, Dim::Dim1D, Sampled1D, Image1D), |
| CASE3(DIMENSIONALITY, Dim::Dim2D, Kernel, Shader, ImageMSArray), |
| CASE0(DIMENSIONALITY, Dim::Dim3D), |
| CASE2(DIMENSIONALITY, Dim::Cube, Shader, ImageCubeArray), |
| CASE2(DIMENSIONALITY, Dim::Rect, SampledRect, ImageRect), |
| CASE2(DIMENSIONALITY, Dim::Buffer, SampledBuffer, ImageBuffer), |
| CASE1(DIMENSIONALITY, Dim::SubpassData, InputAttachment), |
| }))); |
| |
| // See SPIR-V Section 3.9 Sampler Addressing Mode |
| INSTANTIATE_TEST_SUITE_P( |
| SamplerAddressingMode, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::None, |
| Kernel), |
| CASE1(SAMPLER_ADDRESSING_MODE, |
| SamplerAddressingMode::ClampToEdge, Kernel), |
| CASE1(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::Clamp, |
| Kernel), |
| CASE1(SAMPLER_ADDRESSING_MODE, SamplerAddressingMode::Repeat, |
| Kernel), |
| CASE1(SAMPLER_ADDRESSING_MODE, |
| SamplerAddressingMode::RepeatMirrored, Kernel), |
| }))); |
| |
| // See SPIR-V Section 3.10 Sampler Filter Mode |
| INSTANTIATE_TEST_SUITE_P( |
| SamplerFilterMode, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(SAMPLER_FILTER_MODE, SamplerFilterMode::Nearest, Kernel), |
| CASE1(SAMPLER_FILTER_MODE, SamplerFilterMode::Linear, Kernel), |
| }))); |
| |
| // See SPIR-V Section 3.11 Image Format |
| INSTANTIATE_TEST_SUITE_P( |
| ImageFormat, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| // clang-format off |
| CASE0(SAMPLER_IMAGE_FORMAT, ImageFormat::Unknown), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32f, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16f, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R32f, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8Snorm, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32f, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16f, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R11fG11fB10f, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16f, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgb10A2, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16Snorm, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16Snorm, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8Snorm, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16Snorm, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8Snorm, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32i, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16i, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8i, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R32i, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32i, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16i, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8i, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16i, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8i, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba32ui, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba16ui, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8ui, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgba8ui, Shader), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rgb10a2ui, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg32ui, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg16ui, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::Rg8ui, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R16ui, StorageImageExtendedFormats), |
| CASE1(SAMPLER_IMAGE_FORMAT, ImageFormat::R8ui, StorageImageExtendedFormats), |
| // clang-format on |
| }))); |
| |
| // See SPIR-V Section 3.12 Image Channel Order |
| INSTANTIATE_TEST_SUITE_P( |
| ImageChannelOrder, EnumCapabilityTest, |
| Combine( |
| Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::R, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::A, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RG, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RA, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGB, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGBA, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::BGRA, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::ARGB, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Intensity, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Luminance, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Rx, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGx, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::RGBx, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::Depth, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::DepthStencil, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGB, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGBx, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sRGBA, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::sBGRA, Kernel), |
| CASE1(IMAGE_CHANNEL_ORDER, ImageChannelOrder::ABGR, Kernel), |
| }))); |
| |
| // See SPIR-V Section 3.13 Image Channel Data Type |
| INSTANTIATE_TEST_SUITE_P( |
| ImageChannelDataType, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| // clang-format off |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SnormInt8, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SnormInt16, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt8, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt16, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormShort565, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormShort555, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt101010, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt8, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt16, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::SignedInt32, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt8, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt16, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnsignedInt32, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::HalfFloat, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::Float, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt24, Kernel), |
| CASE1(IMAGE_CHANNEL_DATA_TYPE, ImageChannelDataType::UnormInt101010_2, Kernel), |
| // clang-format on |
| }))); |
| |
| // See SPIR-V Section 3.14 Image Operands |
| INSTANTIATE_TEST_SUITE_P( |
| ImageOperands, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| // clang-format off |
| CASE0(OPTIONAL_IMAGE, ImageOperandsMask::MaskNone), |
| CASE1(OPTIONAL_IMAGE, ImageOperandsMask::Bias, Shader), |
| CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Lod), |
| CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Grad), |
| CASE0(OPTIONAL_IMAGE, ImageOperandsMask::ConstOffset), |
| CASE1(OPTIONAL_IMAGE, ImageOperandsMask::Offset, ImageGatherExtended), |
| CASE1(OPTIONAL_IMAGE, ImageOperandsMask::ConstOffsets, ImageGatherExtended), |
| CASE0(OPTIONAL_IMAGE, ImageOperandsMask::Sample), |
| CASE1(OPTIONAL_IMAGE, ImageOperandsMask::MinLod, MinLod), |
| // clang-format on |
| }))); |
| |
| // See SPIR-V Section 3.17 Linkage Type |
| INSTANTIATE_TEST_SUITE_P( |
| LinkageType, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(LINKAGE_TYPE, LinkageType::Export, Linkage), |
| CASE1(LINKAGE_TYPE, LinkageType::Import, Linkage), |
| }))); |
| |
| // See SPIR-V Section 3.18 Access Qualifier |
| INSTANTIATE_TEST_SUITE_P( |
| AccessQualifier, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(ACCESS_QUALIFIER, AccessQualifier::ReadOnly, Kernel), |
| CASE1(ACCESS_QUALIFIER, AccessQualifier::WriteOnly, Kernel), |
| CASE1(ACCESS_QUALIFIER, AccessQualifier::ReadWrite, Kernel), |
| }))); |
| |
| // See SPIR-V Section 3.19 Function Parameter Attribute |
| INSTANTIATE_TEST_SUITE_P( |
| FunctionParameterAttribute, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| // clang-format off |
| CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Zext, Kernel), |
| CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Sext, Kernel), |
| CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::ByVal, Kernel), |
| CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::Sret, Kernel), |
| CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoAlias, Kernel), |
| CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoCapture, Kernel), |
| CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoWrite, Kernel), |
| CASE1(FUNCTION_PARAMETER_ATTRIBUTE, FunctionParameterAttribute::NoReadWrite, Kernel), |
| // clang-format on |
| }))); |
| |
| // See SPIR-V Section 3.20 Decoration |
| INSTANTIATE_TEST_SUITE_P( |
| Decoration, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(DECORATION, Decoration::RelaxedPrecision, Shader), |
| // DecorationSpecId handled below. |
| CASE1(DECORATION, Decoration::Block, Shader), |
| CASE1(DECORATION, Decoration::BufferBlock, Shader), |
| CASE1(DECORATION, Decoration::RowMajor, Matrix), |
| CASE1(DECORATION, Decoration::ColMajor, Matrix), |
| CASE1(DECORATION, Decoration::ArrayStride, Shader), |
| CASE1(DECORATION, Decoration::MatrixStride, |
| Matrix), // Bug 15234 |
| CASE1(DECORATION, Decoration::GLSLShared, Shader), |
| CASE1(DECORATION, Decoration::GLSLPacked, Shader), |
| CASE1(DECORATION, Decoration::CPacked, Kernel), |
| CASE0(DECORATION, Decoration::BuiltIn), // Bug 15248 |
| // Value 12 placeholder |
| CASE1(DECORATION, Decoration::NoPerspective, Shader), |
| CASE1(DECORATION, Decoration::Flat, Shader), |
| CASE1(DECORATION, Decoration::Patch, Tessellation), |
| CASE1(DECORATION, Decoration::Centroid, Shader), |
| CASE1(DECORATION, Decoration::Sample, |
| SampleRateShading), // Bug 15234 |
| CASE1(DECORATION, Decoration::Invariant, Shader), |
| CASE0(DECORATION, Decoration::Restrict), |
| CASE0(DECORATION, Decoration::Aliased), |
| CASE0(DECORATION, Decoration::Volatile), |
| CASE1(DECORATION, Decoration::Constant, Kernel), |
| CASE0(DECORATION, Decoration::Coherent), |
| CASE0(DECORATION, Decoration::NonWritable), |
| CASE0(DECORATION, Decoration::NonReadable), |
| CASE1(DECORATION, Decoration::Uniform, Shader), |
| // Value 27 is an intentional gap in the spec numbering. |
| CASE1(DECORATION, Decoration::SaturatedConversion, Kernel), |
| CASE1(DECORATION, Decoration::Stream, GeometryStreams), |
| CASE1(DECORATION, Decoration::Location, Shader), |
| CASE1(DECORATION, Decoration::Component, Shader), |
| CASE1(DECORATION, Decoration::Index, Shader), |
| CASE1(DECORATION, Decoration::Binding, Shader), |
| CASE1(DECORATION, Decoration::DescriptorSet, Shader), |
| CASE1(DECORATION, Decoration::Offset, Shader), // Bug 15268 |
| CASE1(DECORATION, Decoration::XfbBuffer, TransformFeedback), |
| CASE1(DECORATION, Decoration::XfbStride, TransformFeedback), |
| CASE1(DECORATION, Decoration::FuncParamAttr, Kernel), |
| CASE1(DECORATION, Decoration::FPFastMathMode, Kernel), |
| CASE1(DECORATION, Decoration::LinkageAttributes, Linkage), |
| CASE1(DECORATION, Decoration::NoContraction, Shader), |
| CASE1(DECORATION, Decoration::InputAttachmentIndex, |
| InputAttachment), |
| CASE1(DECORATION, Decoration::Alignment, Kernel), |
| }))); |
| |
| #if 0 |
| // SpecId has different requirements in v1.0 and v1.1: |
| INSTANTIATE_TEST_SUITE_P(DecorationSpecIdV10, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0), |
| ValuesIn(std::vector<EnumCapabilityCase>{CASE1( |
| DECORATION, DecorationSpecId, Shader)}))); |
| #endif |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DecorationV11, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE2(DECORATION, Decoration::SpecId, Shader, Kernel), |
| CASE1(DECORATION, Decoration::MaxByteOffset, Addresses)}))); |
| |
| // See SPIR-V Section 3.21 BuiltIn |
| INSTANTIATE_TEST_SUITE_P( |
| BuiltIn, EnumCapabilityTest, |
| Combine( |
| Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| // clang-format off |
| CASE1(BUILT_IN, BuiltIn::Position, Shader), |
| CASE1(BUILT_IN, BuiltIn::PointSize, Shader), |
| // 2 is an intentional gap in the spec numbering. |
| CASE1(BUILT_IN, BuiltIn::ClipDistance, ClipDistance), // Bug 1407, 15234 |
| CASE1(BUILT_IN, BuiltIn::CullDistance, CullDistance), // Bug 1407, 15234 |
| CASE1(BUILT_IN, BuiltIn::VertexId, Shader), |
| CASE1(BUILT_IN, BuiltIn::InstanceId, Shader), |
| CASE6(BUILT_IN, BuiltIn::PrimitiveId, Geometry, Tessellation, |
| RayTracingNV, RayTracingKHR, MeshShadingNV, MeshShadingEXT), |
| CASE2(BUILT_IN, BuiltIn::InvocationId, Geometry, Tessellation), |
| CASE4(BUILT_IN, BuiltIn::Layer, Geometry, ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT), |
| CASE4(BUILT_IN, BuiltIn::ViewportIndex, MultiViewport, ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT), // Bug 15234 |
| CASE1(BUILT_IN, BuiltIn::TessLevelOuter, Tessellation), |
| CASE1(BUILT_IN, BuiltIn::TessLevelInner, Tessellation), |
| CASE1(BUILT_IN, BuiltIn::TessCoord, Tessellation), |
| CASE1(BUILT_IN, BuiltIn::PatchVertices, Tessellation), |
| CASE1(BUILT_IN, BuiltIn::FragCoord, Shader), |
| CASE1(BUILT_IN, BuiltIn::PointCoord, Shader), |
| CASE1(BUILT_IN, BuiltIn::FrontFacing, Shader), |
| CASE1(BUILT_IN, BuiltIn::SampleId, SampleRateShading), // Bug 15234 |
| CASE1(BUILT_IN, BuiltIn::SamplePosition, SampleRateShading), // Bug 15234 |
| CASE1(BUILT_IN, BuiltIn::SampleMask, Shader), // Bug 15234, Issue 182 |
| // Value 21 intentionally missing |
| CASE1(BUILT_IN, BuiltIn::FragDepth, Shader), |
| CASE1(BUILT_IN, BuiltIn::HelperInvocation, Shader), |
| CASE0(BUILT_IN, BuiltIn::NumWorkgroups), |
| CASE0(BUILT_IN, BuiltIn::WorkgroupSize), |
| CASE0(BUILT_IN, BuiltIn::WorkgroupId), |
| CASE0(BUILT_IN, BuiltIn::LocalInvocationId), |
| CASE0(BUILT_IN, BuiltIn::GlobalInvocationId), |
| CASE0(BUILT_IN, BuiltIn::LocalInvocationIndex), |
| CASE1(BUILT_IN, BuiltIn::WorkDim, Kernel), |
| CASE1(BUILT_IN, BuiltIn::GlobalSize, Kernel), |
| CASE1(BUILT_IN, BuiltIn::EnqueuedWorkgroupSize, Kernel), |
| CASE1(BUILT_IN, BuiltIn::GlobalOffset, Kernel), |
| CASE1(BUILT_IN, BuiltIn::GlobalLinearId, Kernel), |
| // Value 35 intentionally missing |
| CASE2(BUILT_IN, BuiltIn::SubgroupSize, Kernel, SubgroupBallotKHR), |
| CASE1(BUILT_IN, BuiltIn::SubgroupMaxSize, Kernel), |
| CASE1(BUILT_IN, BuiltIn::NumSubgroups, Kernel), |
| CASE1(BUILT_IN, BuiltIn::NumEnqueuedSubgroups, Kernel), |
| CASE1(BUILT_IN, BuiltIn::SubgroupId, Kernel), |
| CASE2(BUILT_IN, BuiltIn::SubgroupLocalInvocationId, Kernel, SubgroupBallotKHR), |
| CASE1(BUILT_IN, BuiltIn::VertexIndex, Shader), |
| CASE1(BUILT_IN, BuiltIn::InstanceIndex, Shader), |
| // clang-format on |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| BuiltInV1_5, EnumCapabilityTest, |
| Combine( |
| Values(SPV_ENV_UNIVERSAL_1_5), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| // SPIR-V 1.5 adds new capabilities to enable these two builtins. |
| CASE5(BUILT_IN, BuiltIn::Layer, Geometry, ShaderLayer, |
| ShaderViewportIndexLayerEXT, MeshShadingNV, MeshShadingEXT), |
| CASE5(BUILT_IN, BuiltIn::ViewportIndex, MultiViewport, |
| ShaderViewportIndex, ShaderViewportIndexLayerEXT, |
| MeshShadingNV, MeshShadingEXT), |
| }))); |
| |
| // See SPIR-V Section 3.22 Selection Control |
| INSTANTIATE_TEST_SUITE_P( |
| SelectionControl, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(SELECTION_CONTROL, SelectionControlMask::MaskNone), |
| CASE0(SELECTION_CONTROL, SelectionControlMask::Flatten), |
| CASE0(SELECTION_CONTROL, SelectionControlMask::DontFlatten), |
| }))); |
| |
| // See SPIR-V Section 3.23 Loop Control |
| INSTANTIATE_TEST_SUITE_P( |
| LoopControl, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(LOOP_CONTROL, LoopControlMask::MaskNone), |
| CASE0(LOOP_CONTROL, LoopControlMask::Unroll), |
| CASE0(LOOP_CONTROL, LoopControlMask::DontUnroll), |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LoopControlV11, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(LOOP_CONTROL, LoopControlMask::DependencyInfinite), |
| CASE0(LOOP_CONTROL, LoopControlMask::DependencyLength), |
| }))); |
| |
| // See SPIR-V Section 3.24 Function Control |
| INSTANTIATE_TEST_SUITE_P( |
| FunctionControl, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(FUNCTION_CONTROL, FunctionControlMask::MaskNone), |
| CASE0(FUNCTION_CONTROL, FunctionControlMask::Inline), |
| CASE0(FUNCTION_CONTROL, FunctionControlMask::DontInline), |
| CASE0(FUNCTION_CONTROL, FunctionControlMask::Pure), |
| CASE0(FUNCTION_CONTROL, FunctionControlMask::Const), |
| }))); |
| |
| // See SPIR-V Section 3.25 Memory Semantics <id> |
| INSTANTIATE_TEST_SUITE_P( |
| MemorySemantics, EnumCapabilityTest, |
| Combine( |
| Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::MaskNone), |
| CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::Acquire), |
| CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::Release), |
| CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::AcquireRelease), |
| CASE0(MEMORY_SEMANTICS_ID, |
| MemorySemanticsMask::SequentiallyConsistent), |
| CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsMask::UniformMemory, |
| Shader), |
| CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::SubgroupMemory), |
| CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::WorkgroupMemory), |
| CASE0(MEMORY_SEMANTICS_ID, |
| MemorySemanticsMask::CrossWorkgroupMemory), |
| CASE1(MEMORY_SEMANTICS_ID, MemorySemanticsMask::AtomicCounterMemory, |
| AtomicStorage), // Bug 15234 |
| CASE0(MEMORY_SEMANTICS_ID, MemorySemanticsMask::ImageMemory), |
| }))); |
| |
| // See SPIR-V Section 3.26 Memory Access |
| INSTANTIATE_TEST_SUITE_P( |
| MemoryAccess, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::MaskNone), |
| CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Volatile), |
| CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Aligned), |
| CASE0(OPTIONAL_MEMORY_ACCESS, MemoryAccessMask::Nontemporal), |
| }))); |
| |
| // See SPIR-V Section 3.27 Scope <id> |
| INSTANTIATE_TEST_SUITE_P( |
| Scope, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, |
| SPV_ENV_UNIVERSAL_1_2, SPV_ENV_UNIVERSAL_1_3), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(SCOPE_ID, Scope::CrossDevice), |
| CASE0(SCOPE_ID, Scope::Device), |
| CASE0(SCOPE_ID, Scope::Workgroup), |
| CASE0(SCOPE_ID, Scope::Subgroup), |
| CASE0(SCOPE_ID, Scope::Invocation), |
| CASE1(SCOPE_ID, Scope::QueueFamilyKHR, VulkanMemoryModelKHR), |
| }))); |
| |
| // See SPIR-V Section 3.28 Group Operation |
| INSTANTIATE_TEST_SUITE_P( |
| GroupOperation, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE3(GROUP_OPERATION, GroupOperation::Reduce, Kernel, |
| GroupNonUniformArithmetic, GroupNonUniformBallot), |
| CASE3(GROUP_OPERATION, GroupOperation::InclusiveScan, Kernel, |
| GroupNonUniformArithmetic, GroupNonUniformBallot), |
| CASE3(GROUP_OPERATION, GroupOperation::ExclusiveScan, Kernel, |
| GroupNonUniformArithmetic, GroupNonUniformBallot), |
| }))); |
| |
| // See SPIR-V Section 3.29 Kernel Enqueue Flags |
| INSTANTIATE_TEST_SUITE_P( |
| KernelEnqueueFlags, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::NoWait, Kernel), |
| CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::WaitKernel, Kernel), |
| CASE1(KERNEL_ENQ_FLAGS, KernelEnqueueFlags::WaitWorkGroup, |
| Kernel), |
| }))); |
| |
| // See SPIR-V Section 3.30 Kernel Profiling Info |
| INSTANTIATE_TEST_SUITE_P( |
| KernelProfilingInfo, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE0(KERNEL_PROFILING_INFO, KernelProfilingInfoMask::MaskNone), |
| CASE1(KERNEL_PROFILING_INFO, |
| KernelProfilingInfoMask::CmdExecTime, Kernel), |
| }))); |
| |
| // See SPIR-V Section 3.31 Capability |
| INSTANTIATE_TEST_SUITE_P( |
| CapabilityDependsOn, EnumCapabilityTest, |
| Combine( |
| Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| // clang-format off |
| CASE0(CAPABILITY, Capability::Matrix), |
| CASE1(CAPABILITY, Capability::Shader, Matrix), |
| CASE1(CAPABILITY, Capability::Geometry, Shader), |
| CASE1(CAPABILITY, Capability::Tessellation, Shader), |
| CASE0(CAPABILITY, Capability::Addresses), |
| CASE0(CAPABILITY, Capability::Linkage), |
| CASE0(CAPABILITY, Capability::Kernel), |
| CASE1(CAPABILITY, Capability::Vector16, Kernel), |
| CASE1(CAPABILITY, Capability::Float16Buffer, Kernel), |
| CASE0(CAPABILITY, Capability::Float16), // Bug 15234 |
| CASE0(CAPABILITY, Capability::Float64), |
| CASE0(CAPABILITY, Capability::Int64), |
| CASE1(CAPABILITY, Capability::Int64Atomics, Int64), |
| CASE1(CAPABILITY, Capability::ImageBasic, Kernel), |
| CASE1(CAPABILITY, Capability::ImageReadWrite, ImageBasic), |
| CASE1(CAPABILITY, Capability::ImageMipmap, ImageBasic), |
| // Value 16 intentionally missing. |
| CASE1(CAPABILITY, Capability::Pipes, Kernel), |
| CASE0(CAPABILITY, Capability::Groups), |
| CASE1(CAPABILITY, Capability::DeviceEnqueue, Kernel), |
| CASE1(CAPABILITY, Capability::LiteralSampler, Kernel), |
| CASE1(CAPABILITY, Capability::AtomicStorage, Shader), |
| CASE0(CAPABILITY, Capability::Int16), |
| CASE1(CAPABILITY, Capability::TessellationPointSize, Tessellation), |
| CASE1(CAPABILITY, Capability::GeometryPointSize, Geometry), |
| CASE1(CAPABILITY, Capability::ImageGatherExtended, Shader), |
| // Value 26 intentionally missing. |
| CASE1(CAPABILITY, Capability::StorageImageMultisample, Shader), |
| CASE1(CAPABILITY, Capability::UniformBufferArrayDynamicIndexing, Shader), |
| CASE1(CAPABILITY, Capability::SampledImageArrayDynamicIndexing, Shader), |
| CASE1(CAPABILITY, Capability::StorageBufferArrayDynamicIndexing, Shader), |
| CASE1(CAPABILITY, Capability::StorageImageArrayDynamicIndexing, Shader), |
| CASE1(CAPABILITY, Capability::ClipDistance, Shader), |
| CASE1(CAPABILITY, Capability::CullDistance, Shader), |
| CASE1(CAPABILITY, Capability::ImageCubeArray, SampledCubeArray), |
| CASE1(CAPABILITY, Capability::SampleRateShading, Shader), |
| CASE1(CAPABILITY, Capability::ImageRect, SampledRect), |
| CASE1(CAPABILITY, Capability::SampledRect, Shader), |
| CASE1(CAPABILITY, Capability::GenericPointer, Addresses), |
| CASE0(CAPABILITY, Capability::Int8), |
| CASE1(CAPABILITY, Capability::InputAttachment, Shader), |
| CASE1(CAPABILITY, Capability::SparseResidency, Shader), |
| CASE1(CAPABILITY, Capability::MinLod, Shader), |
| CASE1(CAPABILITY, Capability::Image1D, Sampled1D), |
| CASE1(CAPABILITY, Capability::SampledCubeArray, Shader), |
| CASE1(CAPABILITY, Capability::ImageBuffer, SampledBuffer), |
| CASE1(CAPABILITY, Capability::ImageMSArray, Shader), |
| CASE1(CAPABILITY, Capability::StorageImageExtendedFormats, Shader), |
| CASE1(CAPABILITY, Capability::ImageQuery, Shader), |
| CASE1(CAPABILITY, Capability::DerivativeControl, Shader), |
| CASE1(CAPABILITY, Capability::InterpolationFunction, Shader), |
| CASE1(CAPABILITY, Capability::TransformFeedback, Shader), |
| CASE1(CAPABILITY, Capability::GeometryStreams, Geometry), |
| CASE1(CAPABILITY, Capability::StorageImageReadWithoutFormat, Shader), |
| CASE1(CAPABILITY, Capability::StorageImageWriteWithoutFormat, Shader), |
| CASE1(CAPABILITY, Capability::MultiViewport, Geometry), |
| // clang-format on |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| CapabilityDependsOnV11, EnumCapabilityTest, |
| Combine(Values(SPV_ENV_UNIVERSAL_1_1), |
| ValuesIn(std::vector<EnumCapabilityCase>{ |
| CASE1(CAPABILITY, Capability::SubgroupDispatch, DeviceEnqueue), |
| CASE1(CAPABILITY, Capability::NamedBarrier, Kernel), |
| CASE1(CAPABILITY, Capability::PipeStorage, Pipes), |
| }))); |
| |
| #undef CASE0 |
| #undef CASE1 |
| #undef CASE2 |
| |
| } // namespace |
| } // namespace spvtools |
