| // Copyright (c) 2017 Google Inc. |
| // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights |
| // reserved. |
| // |
| // 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. |
| |
| // Tests for unique type declaration rules validator. |
| |
| #include <sstream> |
| #include <string> |
| |
| #include "gmock/gmock.h" |
| #include "test/unit_spirv.h" |
| #include "test/val/val_fixtures.h" |
| |
| namespace spvtools { |
| namespace val { |
| namespace { |
| |
| using ::testing::Eq; |
| using ::testing::HasSubstr; |
| using ::testing::Not; |
| |
| using ValidateImage = spvtest::ValidateBase<bool>; |
| |
| std::string GenerateShaderCode( |
| const std::string& body, |
| const std::string& capabilities_and_extensions = "", |
| const std::string& execution_model = "Fragment", |
| const std::string& execution_mode = "", |
| const spv_target_env env = SPV_ENV_UNIVERSAL_1_0, |
| const std::string& memory_model = "GLSL450", |
| const std::string& declarations = "") { |
| std::ostringstream ss; |
| ss << R"( |
| OpCapability Shader |
| OpCapability InputAttachment |
| OpCapability ImageGatherExtended |
| OpCapability MinLod |
| OpCapability Sampled1D |
| OpCapability ImageQuery |
| OpCapability Int64 |
| OpCapability Float64 |
| OpCapability SparseResidency |
| OpCapability ImageBuffer |
| )"; |
| |
| if (env == SPV_ENV_UNIVERSAL_1_0) { |
| ss << "OpCapability SampledRect\n"; |
| } |
| |
| // In 1.4, the entry point must list all module-scope variables used. Just |
| // list all of them. |
| // |
| // For Vulkan, anything Location decoration needs to be an interface variable |
| std::string interface_vars = |
| (env != SPV_ENV_UNIVERSAL_1_4) ? "%input_flat_u32" : |
| R"( |
| %uniform_image_f32_1d_0001 |
| %uniform_image_f32_1d_0002_rgba32f |
| %uniform_image_f32_2d_0001 |
| %uniform_image_f32_2d_0011 ; multisampled sampled |
| %uniform_image_u32_2d_0001 |
| %uniform_image_u32_2d_0002 |
| %uniform_image_s32_3d_0001 |
| %uniform_image_f32_2d_0002 |
| %uniform_image_s32_2d_0002 |
| %uniform_image_f32_spd_0002 |
| %uniform_image_f32_3d_0111 |
| %uniform_image_f32_cube_0101 |
| %uniform_image_f32_cube_0102_rgba32f |
| %uniform_sampler |
| %private_image_u32_buffer_0002_r32ui |
| %private_image_u32_spd_0002 |
| %private_image_f32_buffer_0002_r32ui |
| %input_flat_u32 |
| )"; |
| |
| ss << capabilities_and_extensions; |
| ss << "OpMemoryModel Logical " << memory_model << "\n"; |
| ss << "OpEntryPoint " << execution_model |
| << " %main \"main\" " + interface_vars + "\n"; |
| if (execution_model == "Fragment") { |
| ss << "OpExecutionMode %main OriginUpperLeft\n"; |
| } |
| ss << execution_mode; |
| |
| if (env == SPV_ENV_VULKAN_1_0) { |
| ss << R"( |
| OpDecorate %uniform_image_f32_1d_0001 DescriptorSet 0 |
| OpDecorate %uniform_image_f32_1d_0001 Binding 0 |
| OpDecorate %uniform_image_f32_1d_0002_rgba32f DescriptorSet 0 |
| OpDecorate %uniform_image_f32_1d_0002_rgba32f Binding 1 |
| OpDecorate %uniform_image_f32_2d_0001 DescriptorSet 0 |
| OpDecorate %uniform_image_f32_2d_0001 Binding 2 |
| OpDecorate %uniform_image_f32_2d_0011 DescriptorSet 0 |
| OpDecorate %uniform_image_f32_2d_0011 Binding 3 |
| OpDecorate %uniform_image_u32_2d_0001 DescriptorSet 1 |
| OpDecorate %uniform_image_u32_2d_0001 Binding 0 |
| OpDecorate %uniform_image_u32_2d_0002 DescriptorSet 1 |
| OpDecorate %uniform_image_u32_2d_0002 Binding 1 |
| OpDecorate %uniform_image_s32_3d_0001 DescriptorSet 1 |
| OpDecorate %uniform_image_s32_3d_0001 Binding 2 |
| OpDecorate %uniform_image_f32_2d_0002 DescriptorSet 1 |
| OpDecorate %uniform_image_f32_2d_0002 Binding 3 |
| OpDecorate %uniform_image_s32_2d_0002 DescriptorSet 1 |
| OpDecorate %uniform_image_s32_2d_0002 Binding 4 |
| OpDecorate %uniform_image_f32_spd_0002 DescriptorSet 2 |
| OpDecorate %uniform_image_f32_spd_0002 Binding 0 |
| OpDecorate %uniform_image_f32_3d_0111 DescriptorSet 2 |
| OpDecorate %uniform_image_f32_3d_0111 Binding 1 |
| OpDecorate %uniform_image_f32_cube_0101 DescriptorSet 2 |
| OpDecorate %uniform_image_f32_cube_0101 Binding 2 |
| OpDecorate %uniform_image_f32_cube_0102_rgba32f DescriptorSet 2 |
| OpDecorate %uniform_image_f32_cube_0102_rgba32f Binding 3 |
| OpDecorate %uniform_sampler DescriptorSet 3 |
| OpDecorate %uniform_sampler Binding 0 |
| OpDecorate %input_flat_u32 Flat |
| OpDecorate %input_flat_u32 Location 0 |
| )"; |
| } |
| |
| ss << R"( |
| %void = OpTypeVoid |
| %func = OpTypeFunction %void |
| %bool = OpTypeBool |
| %f32 = OpTypeFloat 32 |
| %f64 = OpTypeFloat 64 |
| %u32 = OpTypeInt 32 0 |
| %s32 = OpTypeInt 32 1 |
| %u64 = OpTypeInt 64 0 |
| %s64 = OpTypeInt 64 1 |
| %s32vec2 = OpTypeVector %s32 2 |
| %u32vec2 = OpTypeVector %u32 2 |
| %f32vec2 = OpTypeVector %f32 2 |
| %u32vec3 = OpTypeVector %u32 3 |
| %s32vec3 = OpTypeVector %s32 3 |
| %f32vec3 = OpTypeVector %f32 3 |
| %u32vec4 = OpTypeVector %u32 4 |
| %s32vec4 = OpTypeVector %s32 4 |
| %f32vec4 = OpTypeVector %f32 4 |
| %boolvec4 = OpTypeVector %bool 4 |
| |
| %f32_0 = OpConstant %f32 0 |
| %f32_1 = OpConstant %f32 1 |
| %f32_0_5 = OpConstant %f32 0.5 |
| %f32_0_25 = OpConstant %f32 0.25 |
| %f32_0_75 = OpConstant %f32 0.75 |
| |
| %f64_0 = OpConstant %f64 0 |
| %f64_1 = OpConstant %f64 1 |
| |
| %s32_0 = OpConstant %s32 0 |
| %s32_1 = OpConstant %s32 1 |
| %s32_2 = OpConstant %s32 2 |
| %s32_3 = OpConstant %s32 3 |
| %s32_4 = OpConstant %s32 4 |
| %s32_m1 = OpConstant %s32 -1 |
| |
| %u32_0 = OpConstant %u32 0 |
| %u32_1 = OpConstant %u32 1 |
| %u32_2 = OpConstant %u32 2 |
| %u32_3 = OpConstant %u32 3 |
| %u32_4 = OpConstant %u32 4 |
| |
| %u64_0 = OpConstant %u64 0 |
| %u64_1 = OpConstant %u64 1 |
| |
| %bool_t = OpConstantTrue %bool |
| |
| %u32vec2arr4 = OpTypeArray %u32vec2 %u32_4 |
| %u32vec2arr3 = OpTypeArray %u32vec2 %u32_3 |
| %u32arr4 = OpTypeArray %u32 %u32_4 |
| %u32vec3arr4 = OpTypeArray %u32vec3 %u32_4 |
| |
| %struct_u32_f32vec4 = OpTypeStruct %u32 %f32vec4 |
| %struct_u64_f32vec4 = OpTypeStruct %u64 %f32vec4 |
| %struct_u32_u32vec4 = OpTypeStruct %u32 %u32vec4 |
| %struct_u32_f32vec3 = OpTypeStruct %u32 %f32vec3 |
| %struct_f32_f32vec4 = OpTypeStruct %f32 %f32vec4 |
| %struct_u32_u32 = OpTypeStruct %u32 %u32 |
| %struct_f32_f32 = OpTypeStruct %f32 %f32 |
| %struct_u32 = OpTypeStruct %u32 |
| %struct_u32_f32_u32 = OpTypeStruct %u32 %f32 %u32 |
| %struct_u32_f32vec4_u32 = OpTypeStruct %u32 %f32vec4 %u32 |
| %struct_u32_u32arr4 = OpTypeStruct %u32 %u32arr4 |
| |
| %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 |
| %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 |
| %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 |
| %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 |
| %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 |
| %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 |
| |
| %s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1 |
| %s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2 |
| %s32vec3_012 = OpConstantComposite %s32vec3 %s32_0 %s32_1 %s32_2 |
| %s32vec3_123 = OpConstantComposite %s32vec3 %s32_1 %s32_2 %s32_3 |
| %s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3 |
| %s32vec4_1234 = OpConstantComposite %s32vec4 %s32_1 %s32_2 %s32_3 %s32_4 |
| |
| %f32vec2_00 = OpConstantComposite %f32vec2 %f32_0 %f32_0 |
| %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 |
| %f32vec2_10 = OpConstantComposite %f32vec2 %f32_1 %f32_0 |
| %f32vec2_11 = OpConstantComposite %f32vec2 %f32_1 %f32_1 |
| %f32vec2_hh = OpConstantComposite %f32vec2 %f32_0_5 %f32_0_5 |
| |
| %f32vec3_000 = OpConstantComposite %f32vec3 %f32_0 %f32_0 %f32_0 |
| %f32vec3_hhh = OpConstantComposite %f32vec3 %f32_0_5 %f32_0_5 %f32_0_5 |
| |
| %f32vec4_0000 = OpConstantComposite %f32vec4 %f32_0 %f32_0 %f32_0 %f32_0 |
| |
| %boolvec4_tttt = OpConstantComposite %boolvec4 %bool_t %bool_t %bool_t %bool_t |
| |
| %const_offsets = OpConstantComposite %u32vec2arr4 %u32vec2_01 %u32vec2_12 %u32vec2_01 %u32vec2_12 |
| %const_offsets3x2 = OpConstantComposite %u32vec2arr3 %u32vec2_01 %u32vec2_12 %u32vec2_01 |
| %const_offsets4xu = OpConstantComposite %u32arr4 %u32_0 %u32_0 %u32_0 %u32_0 |
| %const_offsets4x3 = OpConstantComposite %u32vec3arr4 %u32vec3_012 %u32vec3_012 %u32vec3_012 %u32vec3_012 |
| |
| %type_image_f32_1d_0001 = OpTypeImage %f32 1D 0 0 0 1 Unknown |
| %ptr_image_f32_1d_0001 = OpTypePointer UniformConstant %type_image_f32_1d_0001 |
| %uniform_image_f32_1d_0001 = OpVariable %ptr_image_f32_1d_0001 UniformConstant |
| %type_sampled_image_f32_1d_0001 = OpTypeSampledImage %type_image_f32_1d_0001 |
| |
| %type_image_f32_1d_0002_rgba32f = OpTypeImage %f32 1D 0 0 0 2 Rgba32f |
| %ptr_image_f32_1d_0002_rgba32f = OpTypePointer UniformConstant %type_image_f32_1d_0002_rgba32f |
| %uniform_image_f32_1d_0002_rgba32f = OpVariable %ptr_image_f32_1d_0002_rgba32f UniformConstant |
| |
| %type_image_f32_2d_0001 = OpTypeImage %f32 2D 0 0 0 1 Unknown |
| %ptr_image_f32_2d_0001 = OpTypePointer UniformConstant %type_image_f32_2d_0001 |
| %uniform_image_f32_2d_0001 = OpVariable %ptr_image_f32_2d_0001 UniformConstant |
| %type_sampled_image_f32_2d_0001 = OpTypeSampledImage %type_image_f32_2d_0001 |
| |
| %type_image_f32_2d_0011 = OpTypeImage %f32 2D 0 0 1 1 Unknown |
| %ptr_image_f32_2d_0011 = OpTypePointer UniformConstant %type_image_f32_2d_0011 |
| %uniform_image_f32_2d_0011 = OpVariable %ptr_image_f32_2d_0011 UniformConstant |
| %type_sampled_image_f32_2d_0011 = OpTypeSampledImage %type_image_f32_2d_0011 |
| |
| %type_image_u32_2d_0001 = OpTypeImage %u32 2D 0 0 0 1 Unknown |
| %ptr_image_u32_2d_0001 = OpTypePointer UniformConstant %type_image_u32_2d_0001 |
| %uniform_image_u32_2d_0001 = OpVariable %ptr_image_u32_2d_0001 UniformConstant |
| %type_sampled_image_u32_2d_0001 = OpTypeSampledImage %type_image_u32_2d_0001 |
| |
| %type_image_u32_3d_0001 = OpTypeImage %u32 3D 0 0 0 1 Unknown |
| %ptr_image_u32_3d_0001 = OpTypePointer UniformConstant %type_image_u32_3d_0001 |
| %uniform_image_u32_3d_0001 = OpVariable %ptr_image_u32_3d_0001 UniformConstant |
| %type_sampled_image_u32_3d_0001 = OpTypeSampledImage %type_image_u32_3d_0001 |
| |
| %type_image_u32_2d_0002 = OpTypeImage %u32 2D 0 0 0 2 Unknown |
| %ptr_image_u32_2d_0002 = OpTypePointer UniformConstant %type_image_u32_2d_0002 |
| %uniform_image_u32_2d_0002 = OpVariable %ptr_image_u32_2d_0002 UniformConstant |
| |
| %type_image_s32_3d_0001 = OpTypeImage %s32 3D 0 0 0 1 Unknown |
| %ptr_image_s32_3d_0001 = OpTypePointer UniformConstant %type_image_s32_3d_0001 |
| %uniform_image_s32_3d_0001 = OpVariable %ptr_image_s32_3d_0001 UniformConstant |
| %type_sampled_image_s32_3d_0001 = OpTypeSampledImage %type_image_s32_3d_0001 |
| |
| %type_image_f32_2d_0002 = OpTypeImage %f32 2D 0 0 0 2 Unknown |
| %ptr_image_f32_2d_0002 = OpTypePointer UniformConstant %type_image_f32_2d_0002 |
| %uniform_image_f32_2d_0002 = OpVariable %ptr_image_f32_2d_0002 UniformConstant |
| |
| %type_image_s32_2d_0002 = OpTypeImage %s32 2D 0 0 0 2 Unknown |
| %ptr_image_s32_2d_0002 = OpTypePointer UniformConstant %type_image_s32_2d_0002 |
| %uniform_image_s32_2d_0002 = OpVariable %ptr_image_s32_2d_0002 UniformConstant |
| |
| %type_image_f32_spd_0002 = OpTypeImage %f32 SubpassData 0 0 0 2 Unknown |
| %ptr_image_f32_spd_0002 = OpTypePointer UniformConstant %type_image_f32_spd_0002 |
| %uniform_image_f32_spd_0002 = OpVariable %ptr_image_f32_spd_0002 UniformConstant |
| |
| %type_image_f32_3d_0111 = OpTypeImage %f32 3D 0 1 1 1 Unknown |
| %ptr_image_f32_3d_0111 = OpTypePointer UniformConstant %type_image_f32_3d_0111 |
| %uniform_image_f32_3d_0111 = OpVariable %ptr_image_f32_3d_0111 UniformConstant |
| %type_sampled_image_f32_3d_0111 = OpTypeSampledImage %type_image_f32_3d_0111 |
| |
| %type_image_f32_3d_0001 = OpTypeImage %f32 3D 0 0 0 1 Unknown |
| %ptr_image_f32_3d_0001 = OpTypePointer UniformConstant %type_image_f32_3d_0001 |
| %uniform_image_f32_3d_0001 = OpVariable %ptr_image_f32_3d_0001 UniformConstant |
| %type_sampled_image_f32_3d_0001 = OpTypeSampledImage %type_image_f32_3d_0001 |
| |
| %type_image_f32_cube_0101 = OpTypeImage %f32 Cube 0 1 0 1 Unknown |
| %ptr_image_f32_cube_0101 = OpTypePointer UniformConstant %type_image_f32_cube_0101 |
| %uniform_image_f32_cube_0101 = OpVariable %ptr_image_f32_cube_0101 UniformConstant |
| %type_sampled_image_f32_cube_0101 = OpTypeSampledImage %type_image_f32_cube_0101 |
| |
| %type_image_f32_cube_0102_rgba32f = OpTypeImage %f32 Cube 0 1 0 2 Rgba32f |
| %ptr_image_f32_cube_0102_rgba32f = OpTypePointer UniformConstant %type_image_f32_cube_0102_rgba32f |
| %uniform_image_f32_cube_0102_rgba32f = OpVariable %ptr_image_f32_cube_0102_rgba32f UniformConstant |
| |
| %type_sampler = OpTypeSampler |
| %ptr_sampler = OpTypePointer UniformConstant %type_sampler |
| %uniform_sampler = OpVariable %ptr_sampler UniformConstant |
| |
| %type_image_u32_buffer_0002_r32ui = OpTypeImage %u32 Buffer 0 0 0 2 R32ui |
| %ptr_Image_u32 = OpTypePointer Image %u32 |
| %ptr_image_u32_buffer_0002_r32ui = OpTypePointer Private %type_image_u32_buffer_0002_r32ui |
| %private_image_u32_buffer_0002_r32ui = OpVariable %ptr_image_u32_buffer_0002_r32ui Private |
| |
| %ptr_Image_u32arr4 = OpTypePointer Image %u32arr4 |
| |
| %type_image_u32_spd_0002 = OpTypeImage %u32 SubpassData 0 0 0 2 Unknown |
| %ptr_image_u32_spd_0002 = OpTypePointer Private %type_image_u32_spd_0002 |
| %private_image_u32_spd_0002 = OpVariable %ptr_image_u32_spd_0002 Private |
| |
| %type_image_f32_buffer_0002_r32ui = OpTypeImage %f32 Buffer 0 0 0 2 R32ui |
| %ptr_Image_f32 = OpTypePointer Image %f32 |
| %ptr_image_f32_buffer_0002_r32ui = OpTypePointer Private %type_image_f32_buffer_0002_r32ui |
| %private_image_f32_buffer_0002_r32ui = OpVariable %ptr_image_f32_buffer_0002_r32ui Private |
| |
| %ptr_input_flat_u32 = OpTypePointer Input %u32 |
| %input_flat_u32 = OpVariable %ptr_input_flat_u32 Input |
| )"; |
| |
| if (env == SPV_ENV_UNIVERSAL_1_0) { |
| ss << R"( |
| %type_image_void_2d_0001 = OpTypeImage %void 2D 0 0 0 1 Unknown |
| %ptr_image_void_2d_0001 = OpTypePointer UniformConstant %type_image_void_2d_0001 |
| %uniform_image_void_2d_0001 = OpVariable %ptr_image_void_2d_0001 UniformConstant |
| %type_sampled_image_void_2d_0001 = OpTypeSampledImage %type_image_void_2d_0001 |
| |
| %type_image_void_2d_0002 = OpTypeImage %void 2D 0 0 0 2 Unknown |
| %ptr_image_void_2d_0002 = OpTypePointer UniformConstant %type_image_void_2d_0002 |
| %uniform_image_void_2d_0002 = OpVariable %ptr_image_void_2d_0002 UniformConstant |
| |
| %type_image_f32_rect_0001 = OpTypeImage %f32 Rect 0 0 0 1 Unknown |
| %ptr_image_f32_rect_0001 = OpTypePointer UniformConstant %type_image_f32_rect_0001 |
| %uniform_image_f32_rect_0001 = OpVariable %ptr_image_f32_rect_0001 UniformConstant |
| %type_sampled_image_f32_rect_0001 = OpTypeSampledImage %type_image_f32_rect_0001 |
| )"; |
| } |
| |
| ss << declarations; |
| |
| ss << R"( |
| %main = OpFunction %void None %func |
| %main_entry = OpLabel |
| )"; |
| |
| ss << body; |
| |
| ss << R"( |
| OpReturn |
| OpFunctionEnd)"; |
| |
| return ss.str(); |
| } |
| |
| std::string GenerateKernelCode( |
| const std::string& body, |
| const std::string& capabilities_and_extensions = "", |
| const std::string& declarations = "") { |
| std::ostringstream ss; |
| ss << R"( |
| OpCapability Addresses |
| OpCapability Kernel |
| OpCapability Linkage |
| OpCapability ImageQuery |
| OpCapability ImageGatherExtended |
| OpCapability InputAttachment |
| OpCapability SampledRect |
| )"; |
| |
| ss << capabilities_and_extensions; |
| ss << R"( |
| OpMemoryModel Physical32 OpenCL |
| %void = OpTypeVoid |
| %func = OpTypeFunction %void |
| %bool = OpTypeBool |
| %f32 = OpTypeFloat 32 |
| %u32 = OpTypeInt 32 0 |
| %u32vec2 = OpTypeVector %u32 2 |
| %f32vec2 = OpTypeVector %f32 2 |
| %u32vec3 = OpTypeVector %u32 3 |
| %f32vec3 = OpTypeVector %f32 3 |
| %u32vec4 = OpTypeVector %u32 4 |
| %f32vec4 = OpTypeVector %f32 4 |
| |
| %f32_0 = OpConstant %f32 0 |
| %f32_1 = OpConstant %f32 1 |
| %f32_0_5 = OpConstant %f32 0.5 |
| %f32_0_25 = OpConstant %f32 0.25 |
| %f32_0_75 = OpConstant %f32 0.75 |
| |
| %u32_0 = OpConstant %u32 0 |
| %u32_1 = OpConstant %u32 1 |
| %u32_2 = OpConstant %u32 2 |
| %u32_3 = OpConstant %u32 3 |
| %u32_4 = OpConstant %u32 4 |
| |
| %u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1 |
| %u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2 |
| %u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2 |
| %u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3 |
| %u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3 |
| %u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4 |
| |
| %f32vec2_00 = OpConstantComposite %f32vec2 %f32_0 %f32_0 |
| %f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1 |
| %f32vec2_10 = OpConstantComposite %f32vec2 %f32_1 %f32_0 |
| %f32vec2_11 = OpConstantComposite %f32vec2 %f32_1 %f32_1 |
| %f32vec2_hh = OpConstantComposite %f32vec2 %f32_0_5 %f32_0_5 |
| |
| %f32vec3_000 = OpConstantComposite %f32vec3 %f32_0 %f32_0 %f32_0 |
| %f32vec3_hhh = OpConstantComposite %f32vec3 %f32_0_5 %f32_0_5 %f32_0_5 |
| |
| %f32vec4_0000 = OpConstantComposite %f32vec4 %f32_0 %f32_0 %f32_0 %f32_0 |
| |
| %type_image_f32_2d_0001 = OpTypeImage %f32 2D 0 0 0 1 Unknown |
| %ptr_image_f32_2d_0001 = OpTypePointer UniformConstant %type_image_f32_2d_0001 |
| %uniform_image_f32_2d_0001 = OpVariable %ptr_image_f32_2d_0001 UniformConstant |
| %type_sampled_image_f32_2d_0001 = OpTypeSampledImage %type_image_f32_2d_0001 |
| |
| %type_image_f32_2d_0011 = OpTypeImage %f32 2D 0 0 1 1 Unknown |
| %ptr_image_f32_2d_0011 = OpTypePointer UniformConstant %type_image_f32_2d_0011 |
| %uniform_image_f32_2d_0011 = OpVariable %ptr_image_f32_2d_0011 UniformConstant |
| %type_sampled_image_f32_2d_0011 = OpTypeSampledImage %type_image_f32_2d_0011 |
| |
| %type_image_f32_3d_0011 = OpTypeImage %f32 3D 0 0 1 1 Unknown |
| %ptr_image_f32_3d_0011 = OpTypePointer UniformConstant %type_image_f32_3d_0011 |
| %uniform_image_f32_3d_0011 = OpVariable %ptr_image_f32_3d_0011 UniformConstant |
| %type_sampled_image_f32_3d_0011 = OpTypeSampledImage %type_image_f32_3d_0011 |
| |
| %type_image_f32_rect_0001 = OpTypeImage %f32 Rect 0 0 0 1 Unknown |
| %ptr_image_f32_rect_0001 = OpTypePointer UniformConstant %type_image_f32_rect_0001 |
| %uniform_image_f32_rect_0001 = OpVariable %ptr_image_f32_rect_0001 UniformConstant |
| %type_sampled_image_f32_rect_0001 = OpTypeSampledImage %type_image_f32_rect_0001 |
| |
| %type_sampler = OpTypeSampler |
| %ptr_sampler = OpTypePointer UniformConstant %type_sampler |
| %uniform_sampler = OpVariable %ptr_sampler UniformConstant |
| )"; |
| |
| ss << declarations; |
| |
| ss << R"( |
| %main = OpFunction %void None %func |
| %main_entry = OpLabel |
| )"; |
| |
| ss << body; |
| ss << R"( |
| OpReturn |
| OpFunctionEnd)"; |
| |
| return ss.str(); |
| } |
| |
| std::string GetKernelHeader() { |
| return R"( |
| OpCapability Kernel |
| OpCapability Addresses |
| OpCapability Linkage |
| OpMemoryModel Physical32 OpenCL |
| %void = OpTypeVoid |
| %func = OpTypeFunction %void |
| %f32 = OpTypeFloat 32 |
| %u32 = OpTypeInt 32 0 |
| )"; |
| } |
| |
| std::string TrivialMain() { |
| return R"( |
| %main = OpFunction %void None %func |
| %entry = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| } |
| |
| std::string GetShaderHeader(const std::string& capabilities_and_extensions = "", |
| bool include_entry_point = true) { |
| std::ostringstream ss; |
| ss << R"( |
| OpCapability Shader |
| OpCapability Int64 |
| OpCapability Float64 |
| )"; |
| |
| if (!include_entry_point) { |
| ss << "OpCapability Linkage\n"; |
| } |
| ss << capabilities_and_extensions; |
| |
| ss << R"( |
| OpMemoryModel Logical GLSL450 |
| )"; |
| |
| if (include_entry_point) { |
| ss << "OpEntryPoint Fragment %main \"main\"\n"; |
| ss << "OpExecutionMode %main OriginUpperLeft"; |
| } |
| ss << R"( |
| %void = OpTypeVoid |
| %func = OpTypeFunction %void |
| %bool = OpTypeBool |
| %f32 = OpTypeFloat 32 |
| %f64 = OpTypeFloat 64 |
| %u32 = OpTypeInt 32 0 |
| %u64 = OpTypeInt 64 0 |
| %s32 = OpTypeInt 32 1 |
| %s64 = OpTypeInt 64 1 |
| )"; |
| |
| return ss.str(); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongSampledType) { |
| const std::string code = GetShaderHeader("", false) + R"( |
| %img_type = OpTypeImage %bool 2D 0 0 0 1 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Sampled Type to be either void or " |
| "numerical scalar " |
| "type")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageVoidSampledTypeVulkan) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %void 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), |
| AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04656")); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Sampled Type to be a 32-bit int, 64-bit int " |
| "or 32-bit float scalar type for Vulkan environment")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageU32SampledTypeVulkan) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %u32 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageI32SampledTypeVulkan) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %s32 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageI64SampledTypeNoCapabilityVulkan) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %s64 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Capability Int64ImageEXT is required when using " |
| "Sampled Type of 64-bit int")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageI64SampledTypeVulkan) { |
| const std::string code = GetShaderHeader( |
| "OpCapability Int64ImageEXT\nOpExtension " |
| "\"SPV_EXT_shader_image_int64\"\n") + |
| R"( |
| %img_type = OpTypeImage %s64 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageU64SampledTypeNoCapabilityVulkan) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %u64 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Capability Int64ImageEXT is required when using " |
| "Sampled Type of 64-bit int")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageU64SampledTypeVulkan) { |
| const std::string code = GetShaderHeader( |
| "OpCapability Int64ImageEXT\nOpExtension " |
| "\"SPV_EXT_shader_image_int64\"\n") + |
| R"( |
| %img_type = OpTypeImage %u64 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageF32SampledTypeVulkan) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %f32 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageF64SampledTypeVulkan) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %f64 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), |
| AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04656")); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Sampled Type to be a 32-bit int, 64-bit int " |
| "or 32-bit float scalar type for Vulkan environment")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageF64SampledTypeWithInt64Vulkan) { |
| const std::string code = GetShaderHeader( |
| "OpCapability Int64ImageEXT\nOpExtension " |
| "\"SPV_EXT_shader_image_int64\"\n") + |
| R"( |
| %img_type = OpTypeImage %f64 2D 0 0 0 1 Unknown |
| %main = OpFunction %void None %func |
| %main_lab = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(code, env); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(env)); |
| EXPECT_THAT(getDiagnosticString(), |
| AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04656")); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Sampled Type to be a 32-bit int, 64-bit int " |
| "or 32-bit float scalar type for Vulkan environment")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongDepth) { |
| const std::string code = GetShaderHeader("", false) + R"( |
| %img_type = OpTypeImage %f32 2D 3 0 0 1 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Invalid Depth 3 (must be 0, 1 or 2)")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongArrayed) { |
| const std::string code = GetShaderHeader("", false) + R"( |
| %img_type = OpTypeImage %f32 2D 0 2 0 1 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Invalid Arrayed 2 (must be 0 or 1)")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongMS) { |
| const std::string code = GetShaderHeader("", false) + R"( |
| %img_type = OpTypeImage %f32 2D 0 0 2 1 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Invalid MS 2 (must be 0 or 1)")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongSampled) { |
| const std::string code = GetShaderHeader("", false) + R"( |
| %img_type = OpTypeImage %f32 2D 0 0 0 3 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Invalid Sampled 3 (must be 0, 1 or 2)")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongSampledForSubpassData) { |
| const std::string code = |
| GetShaderHeader("OpCapability InputAttachment\n", false) + |
| R"( |
| %img_type = OpTypeImage %f32 SubpassData 0 0 0 1 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Dim SubpassData requires Sampled to be 2")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongSampledForSubpassDataVulkan) { |
| const std::string code = GetShaderHeader("OpCapability InputAttachment\n") + |
| R"( |
| %img_type = OpTypeImage %f32 SubpassData 0 0 0 1 Unknown |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| EXPECT_THAT(getDiagnosticString(), |
| AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06214")); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Dim SubpassData requires Sampled to be 2")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongArrayForSubpassDataVulkan) { |
| const std::string code = GetShaderHeader("OpCapability InputAttachment\n") + |
| R"( |
| %img_type = OpTypeImage %f32 SubpassData 0 1 0 2 Unknown |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| EXPECT_THAT(getDiagnosticString(), |
| AnyVUID("VUID-StandaloneSpirv-OpTypeImage-06214")); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Dim SubpassData requires Arrayed to be 0")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageDimRectVulkan) { |
| const std::string code = GetShaderHeader("OpCapability InputAttachment\n") + |
| R"( |
| %img_type = OpTypeImage %f32 Rect 0 1 0 2 Unknown |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, |
| ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| // Can't actually hit VUID-StandaloneSpirv-OpTypeImage-09638 |
| EXPECT_THAT( |
| getDiagnosticString(), |
| AnyVUID("TypeImage requires one of these capabilities: SampledRect")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongSampledTypeForTileImageDataEXT) { |
| const std::string code = GetShaderHeader( |
| "OpCapability TileImageColorReadAccessEXT\n" |
| "OpExtension \"SPV_EXT_shader_tile_image\"\n", |
| false) + |
| R"( |
| %img_type = OpTypeImage %void TileImageDataEXT 0 0 0 2 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Dim TileImageDataEXT requires Sampled Type to be not OpTypeVoid")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongSampledForTileImageDataEXT) { |
| const std::string code = GetShaderHeader( |
| "OpCapability TileImageColorReadAccessEXT\n" |
| "OpExtension \"SPV_EXT_shader_tile_image\"\n", |
| false) + |
| R"( |
| %img_type = OpTypeImage %f32 TileImageDataEXT 0 0 0 1 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Dim TileImageDataEXT requires Sampled to be 2")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongFormatForTileImageDataEXT) { |
| const std::string code = GetShaderHeader( |
| "OpCapability TileImageColorReadAccessEXT\n" |
| "OpExtension \"SPV_EXT_shader_tile_image\"\n", |
| false) + |
| R"( |
| %img_type = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Rgba32f |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Dim TileImageDataEXT requires format Unknown")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongDepthForTileImageDataEXT) { |
| const std::string code = GetShaderHeader( |
| "OpCapability TileImageColorReadAccessEXT\n" |
| "OpExtension \"SPV_EXT_shader_tile_image\"\n", |
| false) + |
| R"( |
| %img_type = OpTypeImage %f32 TileImageDataEXT 1 0 0 2 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Dim TileImageDataEXT requires Depth to be 0")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongArrayedForTileImageDataEXT) { |
| const std::string code = GetShaderHeader( |
| "OpCapability TileImageColorReadAccessEXT\n" |
| "OpExtension \"SPV_EXT_shader_tile_image\"\n", |
| false) + |
| R"( |
| %img_type = OpTypeImage %f32 TileImageDataEXT 0 1 0 2 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Dim TileImageDataEXT requires Arrayed to be 0")); |
| } |
| |
| TEST_F(ValidateImage, TypeSampledImage_TileImageDataEXT_Error) { |
| const std::string code = GetShaderHeader( |
| "OpCapability TileImageColorReadAccessEXT\n" |
| "OpExtension \"SPV_EXT_shader_tile_image\"\n", |
| false) + |
| R"( |
| %img_type = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown |
| %simg_type = OpTypeSampledImage %img_type |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampled image type requires an image type with " |
| "\"Sampled\" operand set to 0 or 1")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerImageDimTileImageDataEXTBad) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %tile_image_u32_tid_0002 %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| const std::string decl = R"( |
| %type_image_u32_tid_0002 = OpTypeImage %u32 TileImageDataEXT 0 0 0 2 Unknown |
| %ptr_image_u32_tid_0002 = OpTypePointer TileImageEXT %type_image_u32_tid_0002 |
| %tile_image_u32_tid_0002 = OpVariable %ptr_image_u32_tid_0002 TileImageEXT |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability TileImageColorReadAccessEXT |
| OpExtension "SPV_EXT_shader_tile_image" |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) |
| .c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Image Dim TileImageDataEXT cannot be used with " |
| "OpImageTexelPointer")); |
| } |
| |
| TEST_F(ValidateImage, ReadTileImageDataEXT) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 |
| %res1 = OpImageRead %f32vec4 %img %u32vec2_01 |
| )"; |
| |
| const std::string decl = R"( |
| %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown |
| %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 |
| %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability StorageImageReadWithoutFormat |
| OpCapability TileImageColorReadAccessEXT |
| OpExtension "SPV_EXT_shader_tile_image" |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) |
| .c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Image Dim TileImageDataEXT cannot be used with ImageRead")); |
| } |
| |
| TEST_F(ValidateImage, WriteTileImageDataEXT) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 |
| OpImageWrite %img %u32vec2_01 %f32vec4_0000 |
| )"; |
| |
| const std::string decl = R"( |
| %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown |
| %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 |
| %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability TileImageColorReadAccessEXT |
| OpExtension "SPV_EXT_shader_tile_image" |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) |
| .c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Image 'Dim' cannot be TileImageDataEXT")); |
| } |
| |
| TEST_F(ValidateImage, QueryFormatTileImageDataEXT) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 |
| %res1 = OpImageQueryFormat %u32 %img |
| )"; |
| |
| const std::string decl = R"( |
| %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown |
| %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 |
| %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability TileImageColorReadAccessEXT |
| OpExtension "SPV_EXT_shader_tile_image" |
| )"; |
| |
| CompileSuccessfully(GenerateKernelCode(body, extra, decl).c_str()); |
| |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Image 'Dim' cannot be TileImageDataEXT")); |
| } |
| |
| TEST_F(ValidateImage, QueryOrderTileImageDataEXT) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 |
| %res1 = OpImageQueryOrder %u32 %img |
| )"; |
| |
| const std::string decl = R"( |
| %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown |
| %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 |
| %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability TileImageColorReadAccessEXT |
| OpExtension "SPV_EXT_shader_tile_image" |
| )"; |
| |
| CompileSuccessfully(GenerateKernelCode(body, extra, decl).c_str()); |
| |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Image 'Dim' cannot be TileImageDataEXT")); |
| } |
| |
| TEST_F(ValidateImage, SparseFetchTileImageDataEXT) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 |
| %res1 = OpImageSparseFetch %struct_u32_f32vec4 %img %u32vec2_01 |
| )"; |
| |
| const std::string decl = R"( |
| %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown |
| %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 |
| %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability StorageImageReadWithoutFormat |
| OpCapability TileImageColorReadAccessEXT |
| OpExtension "SPV_EXT_shader_tile_image" |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) |
| .c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image 'Sampled' parameter to be 1")); |
| } |
| |
| TEST_F(ValidateImage, SparseReadTileImageDataEXT) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_tid_0002 %uniform_image_f32_tid_0002 |
| %res1 = OpImageSparseRead %struct_u32_f32vec4 %img %u32vec2_01 |
| )"; |
| |
| const std::string decl = R"( |
| %type_image_f32_tid_0002 = OpTypeImage %f32 TileImageDataEXT 0 0 0 2 Unknown |
| %ptr_image_f32_tid_0002 = OpTypePointer UniformConstant %type_image_f32_tid_0002 |
| %uniform_image_f32_tid_0002 = OpVariable %ptr_image_f32_tid_0002 UniformConstant |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability StorageImageReadWithoutFormat |
| OpCapability TileImageColorReadAccessEXT |
| OpExtension "SPV_EXT_shader_tile_image" |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_5, "GLSL450", decl) |
| .c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Image Dim TileImageDataEXT cannot be used with ImageSparseRead")); |
| } |
| |
| TEST_F(ValidateImage, TypeImage_OpenCL_Sampled0_OK) { |
| const std::string code = GetKernelHeader() + R"( |
| %img_type = OpTypeImage %void 2D 0 0 0 0 Unknown ReadOnly |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_1)); |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImage_OpenCL_Sampled1_Invalid) { |
| const std::string code = GetKernelHeader() + R"( |
| %img_type = OpTypeImage %void 2D 0 0 0 1 Unknown ReadOnly |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_2_1)); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampled must be 0 in the OpenCL environment.")); |
| } |
| |
| TEST_F(ValidateImage, TypeImage_OpenCL_Sampled2_Invalid) { |
| const std::string code = GetKernelHeader() + R"( |
| %img_type = OpTypeImage %void 2D 0 0 0 2 Unknown ReadOnly |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_2_1)); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampled must be 0 in the OpenCL environment.")); |
| } |
| |
| TEST_F(ValidateImage, TypeImage_OpenCL_AccessQualifierMissing) { |
| const std::string code = GetKernelHeader() + R"( |
| %img_type = OpTypeImage %void 2D 0 0 0 0 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_OPENCL_2_1)); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("In the OpenCL environment, the optional Access " |
| "Qualifier must be present")); |
| } |
| |
| TEST_F(ValidateImage, TypeImage_Vulkan_Sampled1_OK) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %f32 2D 0 0 0 1 Unknown |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImage_Vulkan_Sampled2_OK) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %f32 2D 0 0 0 2 Rgba32f |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImage_Vulkan_Sampled0_Invalid) { |
| const std::string code = GetShaderHeader() + R"( |
| %img_type = OpTypeImage %f32 2D 0 0 0 0 Unknown |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| EXPECT_THAT(getDiagnosticString(), |
| AnyVUID("VUID-StandaloneSpirv-OpTypeImage-04657")); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampled must be 1 or 2 in the Vulkan environment.")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageWrongFormatForSubpassData) { |
| const std::string code = |
| GetShaderHeader("OpCapability InputAttachment\n", false) + |
| R"( |
| %img_type = OpTypeImage %f32 SubpassData 0 0 0 2 Rgba32f |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Dim SubpassData requires format Unknown")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageMultisampleStorageImage_MissingCapability) { |
| const std::string code = GetShaderHeader("", false) + |
| R"( |
| %img_type = OpTypeImage %f32 2D 0 0 1 2 Rgba32f |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()) << code; |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Capability StorageImageMultisample is required when " |
| "using multisampled storage image")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageMultisampleStorageImage_UsesCapability) { |
| const std::string code = |
| GetShaderHeader("OpCapability StorageImageMultisample\n", false) + |
| R"( |
| %img_type = OpTypeImage %f32 2D 0 0 1 2 Rgba32f |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << code; |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeImageMultisampleSubpassData_OK) { |
| const std::string code = |
| GetShaderHeader("OpCapability InputAttachment\n", false) + |
| R"( |
| %img_type = OpTypeImage %f32 SubpassData 0 0 1 2 Unknown |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << code; |
| EXPECT_THAT(getDiagnosticString(), Eq("")); |
| } |
| |
| TEST_F(ValidateImage, TypeSampledImage_NotImage_Error) { |
| const std::string code = GetShaderHeader("", false) + R"( |
| %simg_type = OpTypeSampledImage %f32 |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image to be of type OpTypeImage")); |
| } |
| |
| TEST_F(ValidateImage, TypeSampledImage_Sampled0_Success) { |
| // This is ok in the OpenCL and universal environments. |
| // Vulkan will reject an OpTypeImage with Sampled=0, checked elsewhere. |
| const std::string code = GetShaderHeader() + R"( |
| %imty = OpTypeImage %f32 2D 0 0 0 0 Unknown |
| %simg_type = OpTypeSampledImage %imty |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| EXPECT_EQ(getDiagnosticString(), ""); |
| } |
| |
| TEST_F(ValidateImage, TypeSampledImage_Sampled2_Error) { |
| const std::string code = GetShaderHeader() + R"( |
| %storage_image = OpTypeImage %f32 2D 0 0 0 2 Rgba32f |
| %simg_type = OpTypeSampledImage %storage_image |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampled image type requires an image type with " |
| "\"Sampled\" operand set to 0 or 1")); |
| } |
| |
| TEST_F(ValidateImage, TypeSampledImage_Sampled1_Success) { |
| const std::string code = GetShaderHeader() + R"( |
| %im = OpTypeImage %f32 2D 0 0 0 1 Unknown |
| %simg_type = OpTypeSampledImage %im |
| )" + TrivialMain(); |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| EXPECT_EQ(getDiagnosticString(), ""); |
| } |
| |
| TEST_F(ValidateImage, SampledImageSuccess) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampledImageVulkanSuccess) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| )"; |
| |
| const spv_target_env env = SPV_ENV_VULKAN_1_0; |
| CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", env), env); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(env)); |
| } |
| |
| TEST_F(ValidateImage, SampledImageWrongResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_image_f32_2d_0001 %img %sampler |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to be OpTypeSampledImage")); |
| } |
| |
| TEST_F(ValidateImage, SampledImageNotImage) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg1 = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %simg2 = OpSampledImage %type_sampled_image_f32_2d_0001 %simg1 %sampler |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image to be of type OpTypeImage")); |
| } |
| |
| TEST_F(ValidateImage, SampledImageImageNotForSampling) { |
| const std::string code = GetShaderHeader() + R"( |
| %im_ty = OpTypeImage %f32 2D 0 0 0 2 Unknown |
| %sampler_ty = OpTypeSampler |
| %sampled_image_ty = OpTypeSampledImage %im_ty ; will fail here first! |
| |
| %ptr_im_ty = OpTypePointer UniformConstant %im_ty |
| %var_im = OpVariable %ptr_im_ty UniformConstant |
| |
| %ptr_sampler_ty = OpTypePointer UniformConstant %sampler_ty |
| %var_sampler = OpVariable %ptr_sampler_ty UniformConstant |
| |
| %main = OpFunction %void None %func |
| %entry = OpLabel |
| %im = OpLoad %im_ty %var_im |
| %sampler = OpLoad %sampler_ty %var_sampler |
| %sampled_image = OpSampledImage %sampled_image_ty %im %sampler |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| CompileSuccessfully(code.c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampled image type requires an image type with " |
| "\"Sampled\" operand set to 0 or 1")) |
| << code; |
| } |
| |
| TEST_F(ValidateImage, SampledImageNotSampler) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %img |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Sampler to be of type OpTypeSampler")); |
| } |
| |
| TEST_F(ValidateImage, SampledImageIsStorage) { |
| const std::string declarations = R"( |
| %type_sampled_image_f32_2d_0002 = OpTypeSampledImage %type_image_f32_2d_0002 |
| )"; |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0002 %uniform_image_f32_2d_0002 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0002 %img %sampler |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body, "", "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_0, "GLSL450", |
| declarations) |
| .c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampled image type requires an image type with " |
| "\"Sampled\" operand set to 0 or 1")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerSuccess) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerResultTypeNotPointer) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %type_image_u32_buffer_0002_r32ui %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to be OpTypePointer")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerResultTypeNotImageClass) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_image_f32_cube_0101 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to be OpTypePointer whose " |
| "Storage Class operand is Image")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerResultTypeNotNumericNorVoid) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32arr4 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Result Type to be OpTypePointer whose Type operand " |
| "must be a scalar numerical type or OpTypeVoid")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerImageNotResultTypePointer) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %type_image_f32_buffer_0002_r32ui %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Operand '148[%148]' cannot be a " |
| "type")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerImageNotImage) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %uniform_sampler %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Image to be OpTypePointer with Type OpTypeImage")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerImageSampledNotResultType) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %uniform_image_f32_cube_0101 %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image 'Sampled Type' to be the same as the " |
| "Type pointed to by Result Type")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerImageDimSubpassDataBad) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_spd_0002 %u32_0 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Image Dim SubpassData cannot be used with OpImageTexelPointer")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerImageCoordTypeBad) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_f32 %private_image_f32_buffer_0002_r32ui %f32_0 %f32_0 |
| %sum = OpAtomicIAdd %f32 %texel_ptr %f32_1 %f32_0 %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to be integer scalar or vector")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerImageCoordSizeBad) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %uniform_image_u32_2d_0002 %u32vec3_012 %u32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Coordinate to have 2 components, but given 3")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerSampleNotIntScalar) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_buffer_0002_r32ui %u32_0 %f32_0 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Sample to be integer scalar")); |
| } |
| |
| TEST_F(ValidateImage, ImageTexelPointerSampleNotZeroForImageWithMSZero) { |
| const std::string body = R"( |
| %texel_ptr = OpImageTexelPointer %ptr_Image_u32 %private_image_u32_buffer_0002_r32ui %u32_0 %u32_1 |
| %sum = OpAtomicIAdd %u32 %texel_ptr %u32_1 %u32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Sample for Image with MS 0 to be a valid " |
| "<id> for the value 0")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodSuccess) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh |
| %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Bias %f32_0_25 |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh ConstOffset %s32vec2_01 |
| %res5 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Offset %s32vec2_01 |
| %res6 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh MinLod %f32_0_5 |
| %res7 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 |
| %res8 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh NonPrivateTexelKHR |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability VulkanMemoryModelKHR |
| OpExtension "SPV_KHR_vulkan_memory_model" |
| )"; |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") |
| .c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodWrongResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleImplicitLod %f32 %simg %f32vec2_hh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to be int or float vector type")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodWrongNumComponentsResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleImplicitLod %f32vec3 %simg %f32vec2_hh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to have 4 components")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodNotSampledImage) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %res1 = OpImageSampleImplicitLod %f32vec4 %img %f32vec2_hh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodMultisampleError) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh Sample %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampling operation is invalid for multisample image")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodWrongSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleImplicitLod %u32vec4 %simg %f32vec2_00 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image 'Sampled Type' to be the same as " |
| "Result Type components")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodVoidSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler |
| %res1 = OpImageSampleImplicitLod %u32vec4 %simg %f32vec2_00 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodWrongCoordinateType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleImplicitLod %f32vec4 %simg %img |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to be float scalar or vector")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodCoordinateSizeTooSmall) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32_0_5 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to have at least 2 components, " |
| "but given only 1")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodSuccessShader) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Lod %f32_1 |
| %res2 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh Grad %f32vec2_10 %f32vec2_01 |
| %res3 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh ConstOffset %s32vec2_01 |
| %res4 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec3_hhh Offset %s32vec2_01 |
| %res5 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh Grad|Offset|MinLod %f32vec2_10 %f32vec2_01 %s32vec2_01 %f32_0_5 |
| %res6 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Lod|NonPrivateTexelKHR %f32_1 |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability VulkanMemoryModelKHR |
| OpExtension "SPV_KHR_vulkan_memory_model" |
| )"; |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") |
| .c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodSuccessKernel) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %u32vec4_0123 Lod %f32_1 |
| %res2 = OpImageSampleExplicitLod %f32vec4 %simg %u32vec2_01 Grad %f32vec2_10 %f32vec2_01 |
| %res3 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh ConstOffset %u32vec2_01 |
| %res4 = OpImageSampleExplicitLod %f32vec4 %simg %u32vec2_01 Offset %u32vec2_01 |
| %res5 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_hh Grad|Offset %f32vec2_10 %f32vec2_01 %u32vec2_01 |
| )"; |
| |
| CompileSuccessfully(GenerateKernelCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodSuccessCubeArrayed) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %f32vec3_hhh %f32vec3_hhh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodWrongResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32 %simg %f32vec2_hh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to be int or float vector type")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodWrongNumComponentsResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec3 %simg %f32vec2_hh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to have 4 components")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodNotSampledImage) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %res1 = OpImageSampleExplicitLod %f32vec4 %img %f32vec2_hh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodMultisampleError) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler |
| %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Lod|Sample %f32_0 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Sampling operation is invalid for multisample image")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodWrongSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %u32vec4 %simg %f32vec2_00 Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image 'Sampled Type' to be the same as " |
| "Result Type components")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodVoidSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %u32vec4 %simg %f32vec2_00 Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodWrongCoordinateType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %img Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to be float scalar or vector")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodCoordinateSizeTooSmall) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32_0_5 Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to have at least 2 components, " |
| "but given only 1")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodBias) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Bias|Lod %f32_1 %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Image Operand Bias can only be used with ImplicitLod opcodes")); |
| } |
| |
| TEST_F(ValidateImage, LodAndGrad) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Lod|Grad %f32_1 %f32vec2_hh %f32vec2_hh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Image Operand bits Lod and Grad cannot be set at the same time")); |
| } |
| |
| TEST_F(ValidateImage, ImplicitLodWithLod) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Lod %f32_0_5 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Image Operand Lod can only be used with ExplicitLod opcodes " |
| "and OpImageFetch")); |
| } |
| |
| TEST_F(ValidateImage, LodWrongType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Lod %f32vec2_hh)"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image Operand Lod to be float scalar when " |
| "used with ExplicitLod")); |
| } |
| |
| TEST_F(ValidateImage, LodWrongDim) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Lod %f32_0)"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Image Operand Lod requires 'Dim' parameter to be 1D, " |
| "2D, 3D or Cube")); |
| } |
| |
| TEST_F(ValidateImage, MinLodIncompatible) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec2_00 Lod|MinLod %f32_0 %f32_0)"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Image Operand MinLod can only be used with ImplicitLod opcodes or " |
| "together with Image Operand Grad")); |
| } |
| |
| TEST_F(ValidateImage, ImplicitLodWithGrad) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Grad %f32vec2_hh %f32vec2_hh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Image Operand Grad can only be used with ExplicitLod opcodes")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodCubeArrayedSuccess) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 |
| %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Bias %f32_0_25 |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 MinLod %f32_0_5 |
| %res5 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Bias|MinLod %f32_0_25 %f32_0_5 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodBiasWrongType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Bias %u32_0 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image Operand Bias to be float scalar")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodBiasWrongDim) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler |
| %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh Bias %f32_0 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Image Operand Bias requires 'Dim' parameter to be 1D, " |
| "2D, 3D or Cube")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodGradDxWrongType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %s32vec3_012 %f32vec3_hhh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected both Image Operand Grad ids to be float " |
| "scalars or vectors")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodGradDyWrongType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %f32vec3_hhh %s32vec3_012 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected both Image Operand Grad ids to be float " |
| "scalars or vectors")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodGradDxWrongSize) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %f32vec2_00 %f32vec3_hhh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Expected Image Operand Grad dx to have 3 components, but given 2")); |
| } |
| |
| TEST_F(ValidateImage, SampleExplicitLodGradDyWrongSize) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res1 = OpImageSampleExplicitLod %f32vec4 %simg %f32vec4_0000 Grad %f32vec3_hhh %f32vec2_00 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Expected Image Operand Grad dy to have 3 components, but given 2")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodConstOffsetCubeDim) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 ConstOffset %s32vec3_012 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Image Operand ConstOffset cannot be used with Cube Image 'Dim'")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodConstOffsetWrongType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_00 ConstOffset %f32vec2_00 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Expected Image Operand ConstOffset to be int scalar or vector")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodConstOffsetWrongSize) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_00 ConstOffset %s32vec3_012 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image Operand ConstOffset to have 2 " |
| "components, but given 3")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodConstOffsetNotConst) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %offset = OpSNegate %s32vec3 %s32vec3_012 |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_00 ConstOffset %offset |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Image Operand ConstOffset to be a const object")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodOffsetCubeDim) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec3_012 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Image Operand Offset cannot be used with Cube Image 'Dim'")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodOffsetWrongType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %f32vec2_00 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Image Operand Offset to be int scalar or vector")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodOffsetWrongSize) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec3_012 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "Expected Image Operand Offset to have 2 components, but given 3")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodVulkanOffsetWrongSize) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec2_01 |
| )"; |
| |
| CompileSuccessfully( |
| GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| EXPECT_THAT(getDiagnosticString(), |
| AnyVUID("VUID-StandaloneSpirv-Offset-04663")); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Image Operand Offset can only be used with " |
| "OpImage*Gather operations")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodVulkanOffsetWrongBeforeLegalization) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 Offset %s32vec2_01 |
| )"; |
| |
| CompileSuccessfully( |
| GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); |
| getValidatorOptions()->before_hlsl_legalization = true; |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodMoreThanOneOffset) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 ConstOffset|Offset %s32vec2_01 %s32vec2_01 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Image Operands Offset, ConstOffset, ConstOffsets, Offsets " |
| "cannot be used together")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodVulkanMoreThanOneOffset) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res4 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 ConstOffset|Offset %s32vec2_01 %s32vec2_01 |
| )"; |
| |
| CompileSuccessfully( |
| GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Image Operands Offset, ConstOffset, ConstOffsets, Offsets " |
| "cannot be used together")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodMinLodWrongType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_cube_0101 %uniform_image_f32_cube_0101 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_cube_0101 %img %sampler |
| %res1 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec4_0000 MinLod %s32_0 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image Operand MinLod to be float scalar")); |
| } |
| |
| TEST_F(ValidateImage, SampleImplicitLodMinLodWrongDim) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler |
| %res2 = OpImageSampleImplicitLod %f32vec4 %simg %f32vec2_hh MinLod %f32_0_25 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Image Operand MinLod requires 'Dim' parameter to be " |
| "1D, 2D, 3D or Cube")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodSuccess2D) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Lod %f32_1 |
| %res3 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Grad %f32vec2_10 %f32vec2_01 |
| %res4 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh ConstOffset %s32vec2_01 |
| %res5 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Offset %s32vec2_01 |
| %res7 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Grad|Offset %f32vec2_10 %f32vec2_01 %s32vec2_01 |
| %res8 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Lod|NonPrivateTexelKHR %f32_1 |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability VulkanMemoryModelKHR |
| OpExtension "SPV_KHR_vulkan_memory_model" |
| )"; |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") |
| .c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodSuccessRect) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_rect_0001 %uniform_image_f32_rect_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_rect_0001 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Grad %f32vec2_10 %f32vec2_01 |
| %res2 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec3_hhh Grad|Offset %f32vec2_10 %f32vec2_01 %s32vec2_01 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodWrongResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %f32 %simg %f32vec3_hhh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to be int or float vector type")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodWrongNumComponentsResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %f32vec3 %simg %f32vec3_hhh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to have 4 components")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodNotSampledImage) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %res1 = OpImageSampleProjExplicitLod %f32vec4 %img %f32vec3_hhh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodMultisampleError) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec2_hh Lod|Sample %f32_1 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image 'MS' parameter to be 0")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodWrongSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %u32vec4 %simg %f32vec3_hhh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image 'Sampled Type' to be the same as " |
| "Result Type components")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodVoidSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %u32vec4 %simg %f32vec3_hhh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodWrongCoordinateType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %img Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to be float scalar or vector")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjExplicitLodCoordinateSizeTooSmall) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjExplicitLod %f32vec4 %simg %f32vec2_hh Lod %f32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to have at least 3 components, " |
| "but given only 2")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodSuccess) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh |
| %res2 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh Bias %f32_0_25 |
| %res4 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh ConstOffset %s32vec2_01 |
| %res5 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh Offset %s32vec2_01 |
| %res6 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh MinLod %f32_0_5 |
| %res7 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 |
| %res8 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec3_hhh NonPrivateTexelKHR |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability VulkanMemoryModelKHR |
| OpExtension "SPV_KHR_vulkan_memory_model" |
| )"; |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") |
| .c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodWrongResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjImplicitLod %f32 %simg %f32vec3_hhh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to be int or float vector type")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodWrongNumComponentsResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjImplicitLod %f32vec3 %simg %f32vec3_hhh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to have 4 components")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodNotSampledImage) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %res1 = OpImageSampleProjImplicitLod %f32vec4 %img %f32vec3_hhh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodMultisampleError) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler |
| %res1 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec2_hh Sample %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image 'MS' parameter to be 0")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodWrongSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjImplicitLod %u32vec4 %simg %f32vec3_hhh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Image 'Sampled Type' to be the same as " |
| "Result Type components")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodVoidSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjImplicitLod %u32vec4 %simg %f32vec3_hhh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodWrongCoordinateType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjImplicitLod %f32vec4 %simg %img |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to be float scalar or vector")); |
| } |
| |
| TEST_F(ValidateImage, SampleProjImplicitLodCoordinateSizeTooSmall) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleProjImplicitLod %f32vec4 %simg %f32vec2_hh |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to have at least 3 components, " |
| "but given only 2")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodSuccess) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 |
| %res2 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 Bias %f32_0_25 |
| %res4 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 ConstOffset %s32vec2_01 |
| %res5 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 Offset %s32vec2_01 |
| %res6 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 MinLod %f32_0_5 |
| %res7 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 Bias|Offset|MinLod %f32_0_25 %s32vec2_01 %f32_0_5 |
| %res8 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_hh %f32_1 NonPrivateTexelKHR |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability VulkanMemoryModelKHR |
| OpExtension "SPV_KHR_vulkan_memory_model" |
| )"; |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") |
| .c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3)); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodWrongResultType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %void %simg %f32vec2_hh %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Result Type to be int or float scalar type")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodNotSampledImage) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 |
| %res1 = OpImageSampleDrefImplicitLod %u32 %img %f32vec2_hh %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodMultisampleError) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0011 %uniform_image_f32_2d_0011 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0011 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %f32 %simg %f32vec2_hh %f32_1 Sample %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Dref sampling operation is invalid for multisample image")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodWrongSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %f32 %simg %f32vec2_00 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodVoidSampledType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_void_2d_0001 %uniform_image_void_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_void_2d_0001 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_00 %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodWrongCoordinateType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %u32 %simg %img %u32_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to be float scalar or vector")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodCoordinateSizeTooSmall) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_f32_2d_0001 %uniform_image_f32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_f32_2d_0001 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %f32 %simg %f32_0_5 %f32_0_5 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Coordinate to have at least 2 components, " |
| "but given only 1")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodWrongDrefType) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_u32_2d_0001 %uniform_image_u32_2d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_u32_2d_0001 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec2_00 %f64_1 |
| )"; |
| |
| CompileSuccessfully(GenerateShaderCode(body).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("Expected Dref to be of 32-bit float type")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefImplicitLodWrongDimVulkan) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_u32_3d_0001 %uniform_image_u32_3d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_u32_3d_0001 %img %sampler |
| %res1 = OpImageSampleDrefImplicitLod %u32 %simg %f32vec3_hhh %f32_1 |
| )"; |
| |
| CompileSuccessfully( |
| GenerateShaderCode(body, "", "Fragment", "", SPV_ENV_VULKAN_1_0).c_str()); |
| ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| EXPECT_THAT(getDiagnosticString(), |
| AnyVUID("VUID-StandaloneSpirv-OpImage-04777")); |
| EXPECT_THAT(getDiagnosticString(), |
| HasSubstr("In Vulkan, OpImage*Dref* instructions must not use " |
| "images with a 3D Dim")); |
| } |
| |
| TEST_F(ValidateImage, SampleDrefExplicitLodSuccess) { |
| const std::string body = R"( |
| %img = OpLoad %type_image_s32_3d_0001 %uniform_image_s32_3d_0001 |
| %sampler = OpLoad %type_sampler %uniform_sampler |
| %simg = OpSampledImage %type_sampled_image_s32_3d_0001 %img %sampler |
| %res1 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec4_0000 %f32_1 Lod %f32_1 |
| %res3 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec3_hhh %f32_1 Grad %f32vec3_hhh %f32vec3_hhh |
| %res4 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec3_hhh %f32_1 ConstOffset %s32vec3_012 |
| %res5 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec4_0000 %f32_1 Offset %s32vec3_012 |
| %res7 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec3_hhh %f32_1 Grad|Offset %f32vec3_hhh %f32vec3_hhh %s32vec3_012 |
| %res8 = OpImageSampleDrefExplicitLod %s32 %simg %f32vec4_0000 %f32_1 Lod|NonPrivateTexelKHR %f32_1 |
| )"; |
| |
| const std::string extra = R"( |
| OpCapability VulkanMemoryModelKHR |
| OpExtension "SPV_KHR_vulkan_memory_model" |
| )"; |
| CompileSuccessfully(GenerateShaderCode(body, extra, "Fragment", "", |
| SPV_ENV_UNIVERSAL_1_3, "VulkanKHR") |
| .c_str()); |
| ASSERT_EQ(SPV_SUCCESS, ValidateInstructions( |