| // Copyright (c) 2025 Google LLC |
| // |
| // 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. |
| |
| #include <array> |
| #include <iostream> |
| #include <ostream> |
| |
| #include "spirv-tools/optimizer.hpp" |
| #include "test/opt/pass_fixture.h" |
| #include "test/opt/pass_utils.h" |
| |
| namespace spvtools { |
| namespace opt { |
| namespace { |
| |
| struct SplitCombinedImageSamplerPassTest : public PassTest<::testing::Test> { |
| virtual void SetUp() override { |
| SetTargetEnv(SPV_ENV_VULKAN_1_0); |
| SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); |
| SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | |
| SPV_BINARY_TO_TEXT_OPTION_INDENT | |
| SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); |
| } |
| }; |
| |
| struct TypeCase { |
| const char* glsl_type; |
| const char* image_type_decl; |
| }; |
| std::ostream& operator<<(std::ostream& os, const TypeCase& tc) { |
| os << tc.glsl_type; |
| return os; |
| } |
| |
| struct SplitCombinedImageSamplerPassTypeCaseTest |
| : public PassTest<::testing::TestWithParam<TypeCase>> { |
| virtual void SetUp() override { |
| SetTargetEnv(SPV_ENV_VULKAN_1_0); |
| SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); |
| SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | |
| SPV_BINARY_TO_TEXT_OPTION_INDENT | |
| SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); |
| } |
| }; |
| |
| std::vector<TypeCase> ImageTypeCases() { |
| return std::vector<TypeCase>{ |
| {"sampler2D", "OpTypeImage %float 2D 0 0 0 1 Unknown"}, |
| {"sampler2DShadow", "OpTypeImage %float 2D 1 0 0 1 Unknown"}, |
| {"sampler2DArray", "OpTypeImage %float 2D 0 1 0 1 Unknown"}, |
| {"sampler2DArrayShadow", "OpTypeImage %float 2D 1 1 0 1 Unknown"}, |
| {"sampler2DMS", "OpTypeImage %float 2D 0 0 1 1 Unknown"}, |
| {"sampler2DMSArray", "OpTypeImage %float 2D 0 1 1 1 Unknown"}, |
| {"sampler3D", "OpTypeImage %float 3D 0 0 0 1 Unknown"}, |
| {"samplerCube", "OpTypeImage %float Cube 0 0 0 1 Unknown"}, |
| {"samplerCubeShadow", "OpTypeImage %float Cube 1 0 0 1 Unknown"}, |
| {"samplerCubeArray", "OpTypeImage %float Cube 0 1 0 1 Unknown"}, |
| {"samplerCubeArrayShadow", "OpTypeImage %float Cube 1 1 0 1 Unknown"}, |
| {"isampler2D", "OpTypeImage %int 2D 0 0 0 1 Unknown"}, |
| {"isampler2DShadow", "OpTypeImage %int 2D 1 0 0 1 Unknown"}, |
| {"isampler2DArray", "OpTypeImage %int 2D 0 1 0 1 Unknown"}, |
| {"isampler2DArrayShadow", "OpTypeImage %int 2D 1 1 0 1 Unknown"}, |
| {"isampler2DMS", "OpTypeImage %int 2D 0 0 1 1 Unknown"}, |
| {"isampler2DMSArray", "OpTypeImage %int 2D 0 1 1 1 Unknown"}, |
| {"isampler3D", "OpTypeImage %int 3D 0 0 0 1 Unknown"}, |
| {"isamplerCube", "OpTypeImage %int Cube 0 0 0 1 Unknown"}, |
| {"isamplerCubeShadow", "OpTypeImage %int Cube 1 0 0 1 Unknown"}, |
| {"isamplerCubeArray", "OpTypeImage %int Cube 0 1 0 1 Unknown"}, |
| {"isamplerCubeArrayShadow", "OpTypeImage %int Cube 1 1 0 1 Unknown"}, |
| {"usampler2D", "OpTypeImage %uint 2D 0 0 0 1 Unknown"}, |
| {"usampler2DShadow", "OpTypeImage %uint 2D 1 0 0 1 Unknown"}, |
| {"usampler2DArray", "OpTypeImage %uint 2D 0 1 0 1 Unknown"}, |
| {"usampler2DArrayShadow", "OpTypeImage %uint 2D 1 1 0 1 Unknown"}, |
| {"usampler2DMS", "OpTypeImage %uint 2D 0 0 1 1 Unknown"}, |
| {"usampler2DMSArray", "OpTypeImage %uint 2D 0 1 1 1 Unknown"}, |
| {"usampler3D", "OpTypeImage %uint 3D 0 0 0 1 Unknown"}, |
| {"usamplerCube", "OpTypeImage %uint Cube 0 0 0 1 Unknown"}, |
| {"usamplerCubeShadow", "OpTypeImage %uint Cube 1 0 0 1 Unknown"}, |
| {"usamplerCubeArray", "OpTypeImage %uint Cube 0 1 0 1 Unknown"}, |
| {"usamplerCubeArrayShadow", "OpTypeImage %uint Cube 1 1 0 1 Unknown"}, |
| }; |
| } |
| |
| std::string Preamble(const std::string shader_interface = "") { |
| return R"( OpCapability Shader |
| OpCapability RuntimeDescriptorArray |
| OpExtension "SPV_EXT_descriptor_indexing" |
| OpMemoryModel Logical GLSL450 |
| OpEntryPoint GLCompute %main "main")" + |
| shader_interface + R"( |
| OpExecutionMode %main LocalSize 1 1 1 |
| OpName %main "main" |
| OpName %main_0 "main_0" |
| OpName %voidfn "voidfn" |
| )"; |
| } |
| |
| std::string PreambleFragment(const std::string shader_interface = "") { |
| return R"( OpCapability Shader |
| OpMemoryModel Logical GLSL450 |
| OpEntryPoint Fragment %main "main")" + |
| shader_interface + R"( |
| OpExecutionMode %main OriginUpperLeft |
| OpName %main "main" |
| OpName %main_0 "main_0" |
| OpName %voidfn "voidfn" |
| )"; |
| } |
| |
| std::string BasicTypes() { |
| return R"( %float = OpTypeFloat 32 |
| %uint = OpTypeInt 32 0 |
| %int = OpTypeInt 32 1 |
| %uint_0 = OpConstant %uint 0 |
| %uint_1 = OpConstant %uint 1 |
| %uint_3 = OpConstant %uint 3 |
| %float_0 = OpConstant %float 0 |
| %v2float = OpTypeVector %float 2 |
| %v3float = OpTypeVector %float 3 |
| %v4float = OpTypeVector %float 4 |
| %13 = OpConstantNull %v2float |
| %14 = OpConstantNull %v3float |
| %15 = OpConstantNull %v4float |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )"; |
| } |
| std::string Main() { |
| return R"( |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| } |
| std::string NoCheck() { return "; CHECK-NOT: nothing to see"; } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, SamplerOnly_NoChange) { |
| const std::string kTest = Preamble() + |
| R"( OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| )" + BasicTypes() + R"( %10 = OpTypeSampler |
| %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 |
| %100 = OpVariable %_ptr_UniformConstant_10 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %6 = OpLoad %10 %100 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest + NoCheck(), /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithoutChange) |
| << "status" << kTest << "\n -> \n" |
| << disasm; |
| EXPECT_EQ(disasm, kTest) << "disasm"; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, ImageOnly_NoChange) { |
| const std::string kTest = Preamble() + |
| R"( OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| )" + BasicTypes() + R"( %10 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %_ptr_UniformConstant_10 = OpTypePointer UniformConstant %10 |
| %100 = OpVariable %_ptr_UniformConstant_10 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %6 = OpLoad %10 %100 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| SCOPED_TRACE("image only"); |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest + NoCheck(), /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithoutChange); |
| EXPECT_EQ(disasm, kTest); |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, PtrSampledImageOnly_DeletesPtrType) { |
| const std::string kTest = Preamble() + BasicTypes() + R"( |
| ; CHECK: OpCapability Shader |
| ; CHECK-NOT: OpTypePointer UniformConstant |
| ; CHECK: OpFunction %void |
| %100 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %101 = OpTypeSampledImage %100 |
| %102 = OpTypePointer UniformConstant %101 |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest + NoCheck(), /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << "status"; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| PtrArraySampledImageOnly_DeletesPtrType) { |
| const std::string kTest = Preamble() + BasicTypes() + R"( |
| ; CHECK: OpCapability Shader |
| ; CHECK-NOT: OpTypePointer UniformConstant |
| ; CHECK: OpFunction %void |
| %100 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %101 = OpTypeSampledImage %100 |
| %103 = OpTypeArray %101 %uint_1 |
| %104 = OpTypePointer UniformConstant %103 |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest + NoCheck(), /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << "status"; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| PtrRtArraySampledImageOnly_DeletesPtrType) { |
| const std::string kTest = Preamble() + BasicTypes() + R"( |
| ; CHECK: OpCapability Shader |
| ; CHECK-NOT: OpTypePointer UniformConstant |
| ; CHECK: OpFunction %void |
| %100 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %101 = OpTypeSampledImage %100 |
| %103 = OpTypeRuntimeArray %101 |
| %104 = OpTypePointer UniformConstant %103 |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest + NoCheck(), /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << "status"; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| Combined_NoSampler_CreatedBeforeSampledImage) { |
| // No OpTypeSampler to begin with. |
| const std::string kTest = Preamble() + |
| R"( OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| |
| ; A sampler type is created and placed at the start of types. |
| ; CHECK: OpDecorate %{{\d+}} Binding 0 |
| ; CHECK: OpDecorate %{{\d+}} Binding 0 |
| ; CHECK-NOT: TypeSampledImage |
| ; CHECK: TypeSampler |
| ; CHECK: TypeSampledImage |
| |
| )" + BasicTypes() + R"( %10 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| |
| %100 = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %6 = OpLoad %11 %100 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, Combined_SynthesizeVarNames) { |
| // Also tests binding info is copied to both variables. |
| const std::string kTest = Preamble() + |
| R"( |
| OpName %orig_var "orig_var" |
| OpDecorate %orig_var DescriptorSet 0 |
| OpDecorate %orig_var Binding 0 |
| |
| ; The combined image variable is replaced by an image variable and a sampler variable. |
| |
| ; CHECK: OpCapability |
| ; The original name is deleted |
| ; CHECK-NOT: OpName %orig_var " |
| ; CHECK: OpName %orig_var_image "orig_var_image" |
| ; CHECK: OpName %orig_var_sampler "orig_var_sampler" |
| ; CHECK-NOT: OpName %orig_var " |
| |
| ; CHECK: OpDecorate %orig_var_image DescriptorSet 0 |
| ; CHECK: OpDecorate %orig_var_sampler DescriptorSet 0 |
| ; CHECK: OpDecorate %orig_var_image Binding 0 |
| ; CHECK: OpDecorate %orig_var_sampler Binding 0 |
| |
| ; CHECK: %10 = OpTypeImage % |
| ; CHECK: %[[image_ptr_ty:\w+]] = OpTypePointer UniformConstant %10 |
| ; CHECK: %[[sampler_ty:\d+]] = OpTypeSampler |
| ; CHECK: %[[sampler_ptr_ty:\w+]] = OpTypePointer UniformConstant %[[sampler_ty]] |
| |
| |
| ; CHECK-NOT: %orig_var = OpVariable |
| ; CHECK-DAG: %orig_var_sampler = OpVariable %[[sampler_ptr_ty]] UniformConstant |
| ; CHECK-DAG: %orig_var_image = OpVariable %[[image_ptr_ty]] UniformConstant |
| ; CHECK: = OpFunction |
| |
| )" + BasicTypes() + R"( |
| %10 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| |
| %orig_var = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %101 = OpLoad %11 %orig_var |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassTypeCaseTest, Combined_RemapLoad) { |
| // Also tests binding info is copied to both variables. |
| const std::string kTest = Preamble() + |
| R"( |
| OpName %combined "combined" |
| OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| |
| ; CHECK: OpName |
| ; CHECK-NOT: OpDecorate %100 |
| ; CHECK: OpDecorate %[[image_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[sampler_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[image_var]] Binding 0 |
| ; CHECK: OpDecorate %[[sampler_var]] Binding 0 |
| |
| ; CHECK: %10 = OpTypeImage % |
| ; CHECK: %[[image_ptr_ty:\w+]] = OpTypePointer UniformConstant %10 |
| ; CHECK: %[[sampler_ty:\d+]] = OpTypeSampler |
| ; CHECK: %[[sampler_ptr_ty:\w+]] = OpTypePointer UniformConstant %[[sampler_ty]] |
| |
| ; The combined image variable is replaced by an image variable and a sampler variable. |
| |
| ; CHECK-NOT: %100 = OpVariable |
| ; CHECK-DAG: %[[sampler_var]] = OpVariable %[[sampler_ptr_ty]] UniformConstant |
| ; CHECK-DAG: %[[image_var]] = OpVariable %[[image_ptr_ty]] UniformConstant |
| ; CHECK: = OpFunction |
| |
| ; The load of the combined image+sampler is replaced by a two loads, then |
| ; a combination operation. |
| ; CHECK: %[[im:\d+]] = OpLoad %10 %[[image_var]] |
| ; CHECK: %[[s:\d+]] = OpLoad %[[sampler_ty]] %[[sampler_var]] |
| ; CHECK: %combined = OpSampledImage %11 %[[im]] %[[s]] |
| |
| )" + BasicTypes() + |
| " %10 = " + GetParam().image_type_decl + R"( |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| |
| %100 = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %combined = OpLoad %11 %100 |
| |
| ; Uses of the combined image sampler are preserved. |
| ; CHECK: OpCopyObject %11 %combined |
| |
| %7 = OpCopyObject %11 %combined |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassTypeCaseTest, |
| Combined_RemapLoad_RelaxedPrecisionOnVarCopied) { |
| // All decorations on the variable are copied. In this case, RelaxedPrecision |
| const std::string kTest = Preamble() + |
| R"( |
| OpName %combined "combined" |
| OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| OpDecorate %100 RelaxedPrecision |
| |
| ; CHECK: OpName |
| ; CHECK-NOT: OpDecorate %100 |
| ; CHECK: OpDecorate %[[image_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[sampler_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[image_var]] Binding 0 |
| ; CHECK: OpDecorate %[[sampler_var]] Binding 0 |
| ; CHECK: OpDecorate %[[image_var:\d+]] RelaxedPrecision |
| ; CHECK: OpDecorate %[[sampler_var:\d+]] RelaxedPrecision |
| |
| ; CHECK: %10 = OpTypeImage % |
| ; CHECK: %[[image_ptr_ty:\w+]] = OpTypePointer UniformConstant %10 |
| ; CHECK: %[[sampler_ty:\d+]] = OpTypeSampler |
| ; CHECK: %[[sampler_ptr_ty:\w+]] = OpTypePointer UniformConstant %[[sampler_ty]] |
| |
| ; The combined image variable is replaced by an image variable and a sampler variable. |
| |
| ; CHECK-NOT: %100 = OpVariable |
| ; CHECK-NOT: OpVariable _ptr_UniformConstant_11 |
| ; CHECK-DAG: %[[sampler_var]] = OpVariable %[[sampler_ptr_ty]] UniformConstant |
| ; CHECK-DAG: %[[image_var]] = OpVariable %[[image_ptr_ty]] UniformConstant |
| ; CHECK: = OpFunction |
| |
| ; The load of the combined image+sampler is replaced by a two loads, then |
| ; a combination operation. |
| ; CHECK: %[[im:\d+]] = OpLoad %10 %[[image_var]] |
| ; CHECK: %[[s:\d+]] = OpLoad %[[sampler_ty]] %[[sampler_var]] |
| ; CHECK: %combined = OpSampledImage %11 %[[im]] %[[s]] |
| |
| %bool = OpTypeBool ; location marker |
| )" + BasicTypes() + |
| " %10 = " + GetParam().image_type_decl + R"( |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| |
| %100 = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %combined = OpLoad %11 %100 |
| |
| ; Uses of the combined image sampler are preserved. |
| ; CHECK: OpCopyObject %11 %combined |
| |
| %7 = OpCopyObject %11 %combined |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassTypeCaseTest, |
| Combined_RemapLoad_RelaxedPrecisionOnLoadCopied) { |
| // Copy decorations form an OpLoad that is replaced. |
| const std::string kTest = Preamble() + |
| R"( |
| OpName %combined "combined" |
| OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| OpDecorate %combined RelaxedPrecision |
| |
| ; CHECK: OpName |
| ; CHECK-NOT: OpDecorate %100 |
| ; CHECK: OpDecorate %[[image_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[sampler_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[image_var]] Binding 0 |
| ; CHECK: OpDecorate %[[sampler_var]] Binding 0 |
| |
| ; This is what we are checking in this test. |
| ; CHECK: OpDecorate %[[im:\d+]] RelaxedPrecision |
| ; CHECK: OpDecorate %[[s:\d+]] RelaxedPrecision |
| |
| ; CHECK: %10 = OpTypeImage % |
| ; CHECK: %[[image_ptr_ty:\w+]] = OpTypePointer UniformConstant %10 |
| ; CHECK: %[[sampler_ty:\d+]] = OpTypeSampler |
| ; CHECK: %[[sampler_ptr_ty:\w+]] = OpTypePointer UniformConstant %[[sampler_ty]] |
| |
| ; The combined image variable is replaced by an image variable and a sampler variable. |
| |
| ; CHECK-NOT: %100 = OpVariable |
| ; CHECK-NOT: OpVariable _ptr_UniformConstant_11 |
| ; CHECK-DAG: %[[sampler_var]] = OpVariable %[[sampler_ptr_ty]] UniformConstant |
| ; CHECK-DAG: %[[image_var]] = OpVariable %[[image_ptr_ty]] UniformConstant |
| ; CHECK: = OpFunction |
| |
| ; The load of the combined image+sampler is replaced by a two loads, then |
| ; a combination operation. The new loads get the same decorations that the |
| ; original load had. |
| ; CHECK: %[[im]] = OpLoad %10 %[[image_var]] |
| ; CHECK: %[[s]] = OpLoad %[[sampler_ty]] %[[sampler_var]] |
| ; CHECK: %combined = OpSampledImage %11 %[[im]] %[[s]] |
| |
| %bool = OpTypeBool ; location marker |
| )" + BasicTypes() + |
| " %10 = " + GetParam().image_type_decl + R"( |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| |
| %100 = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %combined = OpLoad %11 %100 |
| |
| ; Uses of the combined image sampler are preserved. |
| ; CHECK: OpCopyObject %11 %combined |
| |
| %7 = OpCopyObject %11 %combined |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassTypeCaseTest, |
| Combined_DeletesCopyObjectOfPtr) { |
| // OpCopyObject is deleted, and its uses updated. |
| const std::string kTest = Preamble() + |
| R"( |
| OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| |
| ; CHECK: OpName |
| ; CHECK-NOT: OpDecorate %100 |
| ; CHECK: OpDecorate %[[image_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[sampler_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[image_var]] Binding 0 |
| ; CHECK: OpDecorate %[[sampler_var]] Binding 0 |
| |
| ; CHECK: %10 = OpTypeImage % |
| ; CHECK: %[[image_ptr_ty:\w+]] = OpTypePointer UniformConstant %10 |
| ; CHECK: %[[sampler_ty:\d+]] = OpTypeSampler |
| ; CHECK: %[[sampler_ptr_ty:\w+]] = OpTypePointer UniformConstant %[[sampler_ty]] |
| |
| ; The combined image variable is replaced by an image variable and a sampler variable. |
| |
| ; CHECK-NOT: %100 = OpVariable |
| ; CHECK-DAG: %[[sampler_var]] = OpVariable %[[sampler_ptr_ty]] UniformConstant |
| ; CHECK-DAG: %[[image_var]] = OpVariable %[[image_ptr_ty]] UniformConstant |
| ; CHECK: = OpFunction |
| |
| |
| )" + BasicTypes() + |
| " %10 = " + GetParam().image_type_decl + R"( |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| |
| %100 = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %101 = OpCopyObject %_ptr_UniformConstant_11 %100 |
| %102 = OpLoad %11 %101 |
| %103 = OpCopyObject %_ptr_UniformConstant_11 %101 |
| %104 = OpCopyObject %11 %102 ;; this copy survives |
| OpReturn |
| OpFunctionEnd |
| |
| ; The OpCopyObject instructions are removed. |
| ; The load of the combined image+sampler is replaced by a two loads, then |
| ; a combination operation. The only OpCopyObject that remains is the copy |
| ; of the copy of the sampled image value. |
| ; CHECK: %[[im:\d+]] = OpLoad %10 %[[image_var]] |
| ; CHECK: %[[s:\d+]] = OpLoad %[[sampler_ty]] %[[sampler_var]] |
| ; CHECK: %[[si:\d+]] = OpSampledImage %11 %[[im]] %[[s]] |
| ; CHECK-NEXT: OpCopyObject %11 %[[si]] |
| ; CHECK-NEXT: OpReturn |
| )"; |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassTypeCaseTest, ArrayCombined_RemapLoad) { |
| const std::string kTest = Preamble() + |
| R"( |
| OpName %combined "combined" |
| OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| |
| ; CHECK: OpName |
| ; CHECK-NOT: OpDecorate %100 |
| ; CHECK: OpDecorate %[[image_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[sampler_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[image_var]] Binding 0 |
| ; CHECK: OpDecorate %[[sampler_var]] Binding 0 |
| |
| ; CHECK: %10 = OpTypeImage % |
| ; CHECK: %[[image_ptr_ty:\w+]] = OpTypePointer UniformConstant %10 |
| ; CHECK: %[[sampler_ty:\d+]] = OpTypeSampler |
| ; CHECK: %[[sampler_ptr_ty:\w+]] = OpTypePointer UniformConstant %[[sampler_ty]] |
| |
| ; The combined image variable is replaced by an image variable and a sampler variable. |
| |
| ; CHECK: %[[array_image_ty:\w+]] = OpTypeArray %10 %uint_3 |
| ; CHECK: %[[ptr_array_image_ty:\w+]] = OpTypePointer UniformConstant %[[array_image_ty]] |
| |
| ; CHECK: %[[array_sampler_ty:\w+]] = OpTypeArray %[[sampler_ty]] %uint_3 |
| ; CHECK: %[[ptr_array_sampler_ty:\w+]] = OpTypePointer UniformConstant %[[array_sampler_ty]] |
| |
| ; CHECK-NOT: %100 = OpVariable |
| ; CHECK-DAG: %[[sampler_var]] = OpVariable %[[ptr_array_sampler_ty]] UniformConstant |
| ; CHECK-DAG: %[[image_var]] = OpVariable %[[ptr_array_image_ty]] UniformConstant |
| ; CHECK: = OpFunction |
| |
| ; The access chain and load is replaced by two access chains, two loads, then |
| ; a combine operation. |
| ; CHECK: %[[ptr_im:\d+]] = OpAccessChain %[[image_ptr_ty]] %[[image_var]] %uint_1 |
| ; CHECK: %[[ptr_s:\d+]] = OpAccessChain %[[sampler_ptr_ty]] %[[sampler_var]] %uint_1 |
| ; CHECK: %[[im:\d+]] = OpLoad %10 %[[ptr_im]] |
| ; CHECK: %[[s:\d+]] = OpLoad %[[sampler_ty]] %[[ptr_s]] |
| ; CHECK: %combined = OpSampledImage %11 %[[im]] %[[s]] |
| |
| )" + BasicTypes() + |
| " %10 = " + GetParam().image_type_decl + R"( |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| %12 = OpTypeArray %11 %uint_3 |
| %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 |
| |
| %100 = OpVariable %_ptr_UniformConstant_12 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %ptr = OpAccessChain %_ptr_UniformConstant_11 %100 %uint_1 |
| %combined = OpLoad %11 %ptr |
| |
| ; Uses of the combined image sampler are preserved. |
| ; CHECK: OpCopyObject %11 %combined |
| |
| %7 = OpCopyObject %11 %combined |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassTypeCaseTest, RtArrayCombined_RemapLoad) { |
| const std::string kTest = Preamble() + |
| R"( |
| OpName %combined "combined" |
| OpDecorate %100 DescriptorSet 0 |
| OpDecorate %100 Binding 0 |
| |
| ; CHECK: OpName |
| ; CHECK-NOT: OpDecorate %100 |
| ; CHECK: OpDecorate %[[image_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[sampler_var:\d+]] DescriptorSet 0 |
| ; CHECK: OpDecorate %[[image_var]] Binding 0 |
| ; CHECK: OpDecorate %[[sampler_var]] Binding 0 |
| |
| ; CHECK: %10 = OpTypeImage % |
| ; CHECK: %[[image_ptr_ty:\w+]] = OpTypePointer UniformConstant %10 |
| ; CHECK: %[[sampler_ty:\d+]] = OpTypeSampler |
| ; CHECK: %[[sampler_ptr_ty:\w+]] = OpTypePointer UniformConstant %[[sampler_ty]] |
| |
| ; The combined image variable is replaced by an image variable and a sampler variable. |
| |
| ; CHECK: %[[array_image_ty:\w+]] = OpTypeRuntimeArray %10 |
| ; CHECK: %[[ptr_array_image_ty:\w+]] = OpTypePointer UniformConstant %[[array_image_ty]] |
| |
| ; CHECK: %[[array_sampler_ty:\w+]] = OpTypeRuntimeArray %[[sampler_ty]] |
| ; CHECK: %[[ptr_array_sampler_ty:\w+]] = OpTypePointer UniformConstant %[[array_sampler_ty]] |
| |
| ; CHECK-NOT: %100 = OpVariable |
| ; CHECK-DAG: %[[sampler_var]] = OpVariable %[[ptr_array_sampler_ty]] UniformConstant |
| ; CHECK-DAG: %[[image_var]] = OpVariable %[[ptr_array_image_ty]] UniformConstant |
| ; CHECK: = OpFunction |
| |
| ; The access chain and load is replaced by two access chains, two loads, then |
| ; a combine operation. |
| ; CHECK: %[[ptr_im:\d+]] = OpAccessChain %[[image_ptr_ty]] %[[image_var]] %uint_1 |
| ; CHECK: %[[ptr_s:\d+]] = OpAccessChain %[[sampler_ptr_ty]] %[[sampler_var]] %uint_1 |
| ; CHECK: %[[im:\d+]] = OpLoad %10 %[[ptr_im]] |
| ; CHECK: %[[s:\d+]] = OpLoad %[[sampler_ty]] %[[ptr_s]] |
| ; CHECK: %combined = OpSampledImage %11 %[[im]] %[[s]] |
| |
| )" + BasicTypes() + |
| " %10 = " + GetParam().image_type_decl + R"( |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| %12 = OpTypeRuntimeArray %11 |
| %_ptr_UniformConstant_12 = OpTypePointer UniformConstant %12 |
| |
| %100 = OpVariable %_ptr_UniformConstant_12 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| %ptr = OpAccessChain %_ptr_UniformConstant_11 %100 %uint_1 |
| %combined = OpLoad %11 %ptr |
| |
| ; Uses of the combined image sampler are preserved. |
| ; CHECK: OpCopyObject %11 %combined |
| |
| %7 = OpCopyObject %11 %combined |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(AllCombinedTypes, |
| SplitCombinedImageSamplerPassTypeCaseTest, |
| ::testing::ValuesIn(ImageTypeCases())); |
| |
| // Remap entry point |
| |
| struct EntryPointRemapCase { |
| const spv_target_env environment = SPV_ENV_VULKAN_1_0; |
| const char* initial_interface = ""; |
| const char* expected_interface = nullptr; |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, const EntryPointRemapCase& eprc) { |
| os << "(env " << spvLogStringForEnv(eprc.environment) << ", init " |
| << eprc.initial_interface << " -> expect " << eprc.expected_interface |
| << ")"; |
| return os; |
| } |
| |
| struct SplitCombinedImageSamplerPassEntryPointRemapTest |
| : public PassTest<::testing::TestWithParam<EntryPointRemapCase>> { |
| virtual void SetUp() override { |
| SetTargetEnv(GetParam().environment); |
| SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); |
| SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | |
| SPV_BINARY_TO_TEXT_OPTION_INDENT | |
| SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); |
| } |
| }; |
| |
| std::vector<EntryPointRemapCase> EntryPointInterfaceCases() { |
| return std::vector<EntryPointRemapCase>{ |
| {SPV_ENV_VULKAN_1_0, " %in_var %out_var", " %in_var %out_var"}, |
| {SPV_ENV_VULKAN_1_4, " %combined_var", |
| " %combined_var_image %combined_var_sampler"}, |
| {SPV_ENV_VULKAN_1_4, " %combined_var %in_var %out_var", |
| " %combined_var_image %in_var %out_var %combined_var_sampler"}, |
| {SPV_ENV_VULKAN_1_4, " %in_var %combined_var %out_var", |
| " %in_var %combined_var_image %out_var %combined_var_sampler"}, |
| {SPV_ENV_VULKAN_1_4, " %in_var %out_var %combined_var", |
| " %in_var %out_var %combined_var_image %combined_var_sampler"}, |
| }; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassEntryPointRemapTest, |
| EntryPoint_Combined_UsedInShader) { |
| const std::string kTest = PreambleFragment(GetParam().initial_interface) + |
| R"( |
| OpName %combined "combined" |
| OpName %combined_var "combined_var" |
| OpName %in_var "in_var" |
| OpName %out_var "out_var" |
| OpDecorate %combined_var DescriptorSet 0 |
| OpDecorate %combined_var Binding 0 |
| OpDecorate %in_var BuiltIn FragCoord |
| OpDecorate %out_var Location 0 |
| |
| ; CHECK: OpEntryPoint Fragment %main "main")" + |
| GetParam().expected_interface + R"( |
| ; These clauses ensure the expected interface is the whole interface. |
| ; CHECK-NOT: %{{\d+}} |
| ; CHECK-NOT: %in_var |
| ; CHECK-NOT: %out_var |
| ; CHECK-NOT: %combined_var |
| ; CHECK: OpExecutionMode %main OriginUpperLeft |
| |
| ; Check the var names, tracing up through the types. |
| ; CHECK: %10 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| ; CHECK: %[[image_ptr_ty:\w+]] = OpTypePointer UniformConstant %10 |
| ; CHECK: %[[sampler_ty:\d+]] = OpTypeSampler |
| ; CHECK: %[[sampler_ptr_ty:\w+]] = OpTypePointer UniformConstant %[[sampler_ty]] |
| ; The combined image variable is replaced by an image variable and a sampler variable. |
| ; CHECK-DAG: %combined_var_sampler = OpVariable %[[sampler_ptr_ty]] UniformConstant |
| ; CHECK-DAG: %combined_var_image = OpVariable %[[image_ptr_ty]] UniformConstant |
| ; CHECK: = OpFunction |
| |
| %bool = OpTypeBool |
| )" + BasicTypes() + R"( %10 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| %in_ptr_v4f = OpTypePointer Input %v4float |
| %in_var = OpVariable %in_ptr_v4f Input |
| %out_ptr_v4f = OpTypePointer Output %v4float |
| %out_var = OpVariable %out_ptr_v4f Output |
| |
| %combined_var = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| ;CHECK: %main_0 = OpLabel |
| ;CHECK: OpLoad |
| |
| %main_0 = OpLabel |
| %combined = OpLoad %11 %combined_var |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassEntryPointRemapTest, |
| EntryPoint_Combined_UsedOnlyInEntryPointInstruction) { |
| // If the combined var is in the interface, that is enough to trigger |
| // its replacement. Otherwise the entry point interface is untouched |
| // when the combined var is not otherwise used. |
| const bool combined_var_in_interface = |
| std::string(GetParam().initial_interface).find("%combined_var") != |
| std::string::npos; |
| if (combined_var_in_interface) { |
| const std::string kTest = PreambleFragment(GetParam().initial_interface) + |
| R"( |
| OpName %combined_var "combined_var" |
| OpName %in_var "in_var" |
| OpName %out_var "out_var" |
| OpDecorate %combined_var DescriptorSet 0 |
| OpDecorate %combined_var Binding 0 |
| OpDecorate %in_var BuiltIn FragCoord |
| OpDecorate %out_var Location 0 |
| |
| ; CHECK: OpEntryPoint Fragment %main "main")" + |
| GetParam().expected_interface + R"( |
| ; These clauses ensure the expected interface is the whole interface. |
| ; CHECK-NOT: %{{\d+}} |
| ; CHECK-NOT: %in_var |
| ; CHECK-NOT: %out_var |
| ; CHECK-NOT: %combined_var |
| ; CHECK: OpExecutionMode %main OriginUpperLeft |
| |
| %bool = OpTypeBool |
| )" + BasicTypes() + R"( %10 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| %in_ptr_v4f = OpTypePointer Input %v4float |
| %in_var = OpVariable %in_ptr_v4f Input |
| %out_ptr_v4f = OpTypePointer Output %v4float |
| %out_var = OpVariable %out_ptr_v4f Output |
| |
| ; %combined_var is not used! |
| %combined_var = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto [disasm, status] = |
| SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassEntryPointRemapTest, |
| EntryPoint_Combined_Unused) { |
| // If the combined var is in the interface, that is enough to trigger |
| // its replacement. Otherwise the entry point interface is untouched |
| // when the combined var is not otherwise used. |
| const bool combined_var_in_interface = |
| std::string(GetParam().initial_interface).find("%combined_var") != |
| std::string::npos; |
| if (!combined_var_in_interface) { |
| const std::string kTest = PreambleFragment(GetParam().initial_interface) + |
| R"( |
| ; CHECK: OpEntryPoint Fragment %main "main")" + |
| GetParam().initial_interface // Note this is the |
| // intial interface |
| + R"( |
| ; These clauses ensure the expected interface is the whole interface. |
| ; CHECK-NOT: %{{\d+}} |
| ; CHECK-NOT: %in_var |
| ; CHECK-NOT: %out_var |
| ; CHECK-NOT: %combined_var |
| ; CHECK: OpExecutionMode %main OriginUpperLeft |
| |
| ; The variable disappears. |
| ; CHECK-NOT: %combined_var = |
| ; CHECK: OpFunctionEnd |
| OpName %combined_var "combined_var" |
| OpName %in_var "in_var" |
| OpName %out_var "out_var" |
| OpDecorate %combined_var DescriptorSet 0 |
| OpDecorate %combined_var Binding 0 |
| OpDecorate %in_var BuiltIn FragCoord |
| OpDecorate %out_var Location 0 |
| |
| |
| %bool = OpTypeBool |
| )" + BasicTypes() + R"( %10 = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %11 = OpTypeSampledImage %10 |
| %_ptr_UniformConstant_11 = OpTypePointer UniformConstant %11 |
| %in_ptr_v4f = OpTypePointer Input %v4float |
| %in_var = OpVariable %in_ptr_v4f Input |
| %out_ptr_v4f = OpTypePointer Output %v4float |
| %out_var = OpVariable %out_ptr_v4f Output |
| |
| ; %combined_var is not used! |
| %combined_var = OpVariable %_ptr_UniformConstant_11 UniformConstant |
| %main = OpFunction %void None %voidfn |
| %main_0 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto [disasm, status] = |
| SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(EntryPointRemap, |
| SplitCombinedImageSamplerPassEntryPointRemapTest, |
| ::testing::ValuesIn(EntryPointInterfaceCases())); |
| |
| // Remap function types |
| |
| struct FunctionTypeCase { |
| const char* initial_type_params = ""; |
| const char* expected_type_params = ""; |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, const FunctionTypeCase& ftc) { |
| os << "(init " << ftc.initial_type_params << " -> expect " |
| << ftc.expected_type_params << ")"; |
| return os; |
| } |
| |
| struct SplitCombinedImageSamplerPassFunctionTypeTest |
| : public PassTest<::testing::TestWithParam<FunctionTypeCase>> { |
| virtual void SetUp() override { |
| SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS); |
| SetDisassembleOptions(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | |
| SPV_BINARY_TO_TEXT_OPTION_INDENT | |
| SPV_BINARY_TO_TEXT_OPTION_NO_HEADER); |
| } |
| }; |
| |
| std::vector<FunctionTypeCase> FunctionTypeCases() { |
| return std::vector<FunctionTypeCase>{ |
| {"", ""}, |
| {" %image_ty", " %image_ty"}, |
| {" %sampler_ty", " %sampler_ty"}, |
| {" %sampled_image_ty", " %image_ty %sampler_ty"}, |
| {" %uint %sampled_image_ty %float", |
| " %uint %image_ty %sampler_ty %float"}, |
| {" %ptr_sampled_image_ty", |
| " %_ptr_UniformConstant_image_ty %_ptr_UniformConstant_sampler_ty"}, |
| {" %uint %ptr_sampled_image_ty %float", |
| " %uint %_ptr_UniformConstant_image_ty %_ptr_UniformConstant_sampler_ty " |
| "%float"}, |
| {" %uint %ptr_sampled_image_ty %ptr_sampled_image_ty %float", |
| " %uint %_ptr_UniformConstant_image_ty %_ptr_UniformConstant_sampler_ty " |
| "%_ptr_UniformConstant_image_ty %_ptr_UniformConstant_sampler_ty " |
| "%float"}, |
| }; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassFunctionTypeTest, |
| ReplaceCombinedImageSamplersOnly) { |
| const std::string kTest = Preamble() + +R"( |
| OpName %f_ty "f_ty" |
| OpName %sampler_ty "sampler_ty" |
| OpName %image_ty "image_ty" |
| OpName %sampled_image_ty "sampled_image_ty" |
| OpName %ptr_sampled_image_ty "sampled_image_ty" |
| |
| )" + BasicTypes() + R"( |
| |
| %sampler_ty = OpTypeSampler |
| %image_ty = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %sampled_image_ty = OpTypeSampledImage %image_ty |
| %ptr_sampled_image_ty = OpTypePointer UniformConstant %sampled_image_ty |
| |
| %f_ty = OpTypeFunction %float)" + |
| GetParam().initial_type_params + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %float)" + |
| GetParam().expected_type_params + R"( |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_P(SplitCombinedImageSamplerPassFunctionTypeTest, AvoidDuplicateType) { |
| // SPIR-V does not allow duplicate non-aggregate types. That includes function |
| // types. Test that when replacing function type parameters would cause a |
| // collision, that the original function type is replaced with the new one. |
| const std::string initial_params(GetParam().initial_type_params); |
| const std::string expected_params(GetParam().expected_type_params); |
| const std::string kTest = Preamble() + +R"( |
| OpName %sampler_ty "sampler_ty" |
| OpName %image_ty "image_ty" |
| OpName %sampled_image_ty "sampled_image_ty" |
| OpName %_ptr_UniformConstant_sampler_ty "_ptr_UniformConstant_sampler_ty" |
| OpName %_ptr_UniformConstant_image_ty "_ptr_UniformConstant_image_ty" |
| OpName %ptr_sampled_image_ty "sampled_image_ty" |
| OpName %dest_ty "dest_ty" |
| |
| )" + BasicTypes() + R"( |
| |
| %sampler_ty = OpTypeSampler |
| %image_ty = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %sampled_image_ty = OpTypeSampledImage %image_ty |
| %ptr_sampled_image_ty = OpTypePointer UniformConstant %sampled_image_ty |
| %_ptr_UniformConstant_image_ty = OpTypePointer UniformConstant %image_ty |
| %_ptr_UniformConstant_sampler_ty = OpTypePointer UniformConstant %sampler_ty |
| |
| %100 = OpTypeFunction %float)" + |
| initial_params + R"( |
| %dest_ty = OpTypeFunction %float)" + |
| expected_params + R"( |
| |
| ; CHECK: OpTypeSampler |
| ; CHECK-NOT: %100 = |
| ; CHECK: %dest_ty = OpTypeFunction %float)" + |
| expected_params + R"( |
| ; CHECK-NOT: %100 = |
| ; CHECK: %main = OpFunction |
| )" + Main(); |
| // The original source is invalid if initial and expected params are the same, |
| // because the type is already duplicated. |
| // Only test when they are different. |
| if (initial_params != expected_params) { |
| auto [disasm, status] = |
| SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(FunctionTypeRemap, |
| SplitCombinedImageSamplerPassFunctionTypeTest, |
| ::testing::ValuesIn(FunctionTypeCases())); |
| |
| // Test array and runtime-array cases for function type replacement. |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionType_ReplaceSampledImageArg) { |
| // The original module has a sampled image type, used only as a function |
| // parameter. We still want to replace it. But no other sampled-image types |
| // exist. This proves that the pass needs a sampled_image_used_as_param_ |
| // state variable. |
| const std::string kTest = Preamble() + +R"( |
| OpName %f_ty "f_ty" |
| OpName %sampler_ty "sampler_ty" |
| OpName %image_ty "image_ty" |
| OpName %sampled_image_ty "sampled_image_ty" |
| |
| )" + BasicTypes() + R"( |
| |
| %sampler_ty = OpTypeSampler |
| %image_ty = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %sampled_image_ty = OpTypeSampledImage %image_ty |
| |
| %f_ty = OpTypeFunction %float %sampled_image_ty %float |
| ; CHECK: %f_ty = OpTypeFunction %float %image_ty %sampler_ty %float |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionType_ReplaceArrayArg) { |
| const std::string kTest = Preamble() + +R"( |
| OpName %f_ty "f_ty" |
| OpName %sampler_ty "sampler_ty" |
| OpName %image_ty "image_ty" |
| OpName %sampled_image_ty "sampled_image_ty" |
| OpName %ptr_array_si_ty "ptr_array_si_ty" |
| |
| )" + BasicTypes() + R"( |
| |
| %sampler_ty = OpTypeSampler |
| %image_ty = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %sampled_image_ty = OpTypeSampledImage %image_ty |
| %array_si_ty = OpTypeArray %sampled_image_ty %uint_3 |
| %ptr_array_si_ty = OpTypePointer UniformConstant %array_si_ty |
| |
| ; CHECK: %[[array_i_ty:\w+]] = OpTypeArray %image_ty %uint_3 |
| ; CHECK: %[[ptr_array_i_ty:\w+]] = OpTypePointer UniformConstant %[[array_i_ty]] |
| ; CHECK: %[[array_s_ty:\w+]] = OpTypeArray %sampler_ty %uint_3 |
| ; CHECK: %[[ptr_array_s_ty:\w+]] = OpTypePointer UniformConstant %[[array_s_ty]] |
| |
| %f_ty = OpTypeFunction %float %uint %ptr_array_si_ty %float |
| ; CHECK: %f_ty = OpTypeFunction %float %uint %[[ptr_array_i_ty]] %[[ptr_array_s_ty]] %float |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionType_ReplaceRtArrayArg) { |
| const std::string kTest = Preamble() + +R"( |
| OpName %f_ty "f_ty" |
| OpName %sampler_ty "sampler_ty" |
| OpName %image_ty "image_ty" |
| OpName %sampled_image_ty "sampled_image_ty" |
| OpName %ptr_array_si_ty "ptr_array_si_ty" |
| |
| )" + BasicTypes() + R"( |
| |
| %sampler_ty = OpTypeSampler |
| %image_ty = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %sampled_image_ty = OpTypeSampledImage %image_ty |
| %array_si_ty = OpTypeRuntimeArray %sampled_image_ty |
| %ptr_array_si_ty = OpTypePointer UniformConstant %array_si_ty |
| |
| ; CHECK: %[[array_i_ty:\w+]] = OpTypeRuntimeArray %image_ty |
| ; CHECK: %[[ptr_array_i_ty:\w+]] = OpTypePointer UniformConstant %[[array_i_ty]] |
| ; CHECK: %[[array_s_ty:\w+]] = OpTypeRuntimeArray %sampler_ty |
| ; CHECK: %[[ptr_array_s_ty:\w+]] = OpTypePointer UniformConstant %[[array_s_ty]] |
| |
| %f_ty = OpTypeFunction %float %uint %ptr_array_si_ty %float |
| ; CHECK: %f_ty = OpTypeFunction %float %uint %[[ptr_array_i_ty]] %[[ptr_array_s_ty]] %float |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| // Remap function bodies |
| |
| std::string NamedITypes() { |
| return R"( |
| OpName %f "f" |
| OpName %f_ty "f_ty" |
| OpName %i_ty "i_ty" |
| OpName %s_ty "s_ty" |
| OpName %p_i_ty "p_i_ty" |
| OpName %p_s_ty "p_s_ty" |
| )"; |
| } |
| |
| std::string NamedCombinedTypes() { |
| return R"( |
| OpName %si_ty "si_ty" |
| OpName %p_si_ty "p_si_ty" |
| OpName %array_si_ty "array_si_ty" |
| OpName %rtarray_si_ty "rtarray_si_ty" |
| OpName %p_array_si_ty "p_array_si_ty" |
| OpName %p_rtarray_si_ty "p_rtarray_si_ty" |
| )"; |
| } |
| |
| std::string NamedCaller() { |
| return R"( |
| OpName %caller_ty "caller_ty" |
| OpName %caller "caller" |
| OpName %caller_entry "caller_entry" |
| OpName %caller_call "caller_call" |
| OpName %caller_arg "caller_arg" |
| )"; |
| } |
| |
| std::string ITypes() { |
| return R"( |
| %i_ty = OpTypeImage %float 2D 0 0 0 1 Unknown |
| %s_ty = OpTypeSampler |
| %p_i_ty = OpTypePointer UniformConstant %i_ty |
| %p_s_ty = OpTypePointer UniformConstant %s_ty |
| )"; |
| } |
| |
| std::string CombinedTypes() { |
| return R"( |
| %si_ty = OpTypeSampledImage %i_ty |
| %p_si_ty = OpTypePointer UniformConstant %si_ty |
| %array_si_ty = OpTypeArray %si_ty %uint_3 |
| %p_array_si_ty = OpTypePointer UniformConstant %array_si_ty |
| %rtarray_si_ty = OpTypeRuntimeArray %si_ty |
| %p_rtarray_si_ty = OpTypePointer UniformConstant %rtarray_si_ty |
| )"; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionBody_ScalarNoChange) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| BasicTypes() + ITypes() + CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %float %i_ty %s_ty %p_i_ty %p_s_ty |
| %f_ty = OpTypeFunction %float %i_ty %s_ty %p_i_ty %p_s_ty |
| |
| ; CHECK: %f = OpFunction %float None %f_ty |
| ; CHECK-NEXT: OpFunctionParameter %i_ty |
| ; CHECK-NEXT: OpFunctionParameter %s_ty |
| ; CHECK-NEXT: OpFunctionParameter %p_i_ty |
| ; CHECK-NEXT: OpFunctionParameter %p_s_ty |
| ; CHECK-NEXT: OpLabel |
| %f = OpFunction %float None %f_ty |
| %100 = OpFunctionParameter %i_ty |
| %101 = OpFunctionParameter %s_ty |
| %102 = OpFunctionParameter %p_i_ty |
| %103 = OpFunctionParameter %p_s_ty |
| %110 = OpLabel |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| FunctionBody_SampledImage_OpImageSample) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| BasicTypes() + ITypes() + CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %v4float %uint %i_ty %s_ty %float |
| %f_ty = OpTypeFunction %v4float %uint %si_ty %float |
| |
| ; CHECK: %f = OpFunction %v4float None %f_ty |
| ; CHECK: OpFunctionParameter %uint |
| ; CHECK-NEXT: %[[i:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[s:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: OpFunctionParameter %float |
| ; CHECK-NEXT: OpLabel |
| ; CHECK-NEXT: %[[si:\w+]] = OpSampledImage %si_ty %[[i]] %[[s]] |
| ; CHECK-NEXT: %200 = OpImageSampleExplicitLod %v4float %[[si]] %13 Lod %float_0 |
| ; CHECK-NEXT: OpReturnValue %200 |
| |
| %f = OpFunction %v4float None %f_ty |
| %100 = OpFunctionParameter %uint |
| %101 = OpFunctionParameter %si_ty ; replace this |
| %110 = OpFunctionParameter %float |
| %120 = OpLabel |
| %200 = OpImageSampleExplicitLod %v4float %101 %13 Lod %float_0 |
| OpReturnValue %200 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionBody_SampledImage_OpImage) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| BasicTypes() + ITypes() + CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %uint %i_ty %s_ty %float |
| %f_ty = OpTypeFunction %void %uint %si_ty %float |
| |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK: OpFunctionParameter %uint |
| ; CHECK-NEXT: %[[i:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[s:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: OpFunctionParameter %float |
| ; CHECK-NEXT: OpLabel |
| ; CHECK-NEXT: %[[si:\w+]] = OpSampledImage %si_ty %[[i]] %[[s]] |
| ; CHECK-NEXT: %200 = OpImage %i_ty %[[si]] |
| ; CHECK-NEXT: OpReturn |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %uint |
| %101 = OpFunctionParameter %si_ty ; replace this |
| %110 = OpFunctionParameter %float |
| %120 = OpLabel |
| %200 = OpImage %i_ty %101 |
| OpReturn |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionBody_PtrSampledImage) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| BasicTypes() + ITypes() + CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %v4float %uint %p_i_ty %p_s_ty %float |
| %f_ty = OpTypeFunction %v4float %uint %p_si_ty %float |
| |
| ; CHECK: %f = OpFunction %v4float None %f_ty |
| ; CHECK-NEXT: OpFunctionParameter %uint |
| ; CHECK-NEXT: %[[pi:\w+]] = OpFunctionParameter %p_i_ty |
| ; CHECK-NEXT: %[[ps:\w+]] = OpFunctionParameter %p_s_ty |
| ; CHECK-NEXT: OpFunctionParameter %float |
| ; CHECK-NEXT: OpLabel |
| ; CHECK-NEXT: %[[i:\w+]] = OpLoad %i_ty %[[pi]] |
| ; CHECK-NEXT: %[[s:\w+]] = OpLoad %s_ty %[[ps]] |
| ; CHECK-NEXT: %[[si:\w+]] = OpSampledImage %si_ty %[[i]] %[[s]] |
| ; CHECK-NEXT: %200 = OpImageSampleExplicitLod %v4float %[[si]] %13 Lod %float_0 |
| ; CHECK-NEXT: OpReturnValue %200 |
| |
| %f = OpFunction %v4float None %f_ty |
| %100 = OpFunctionParameter %uint |
| %101 = OpFunctionParameter %p_si_ty ; replace this |
| %110 = OpFunctionParameter %float |
| %120 = OpLabel |
| %121 = OpLoad %si_ty %101 |
| %200 = OpImageSampleExplicitLod %v4float %121 %13 Lod %float_0 |
| OpReturnValue %200 |
| OpFunctionEnd |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| FunctionCall_NoImageOrSampler_NoChange) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCaller() + |
| BasicTypes() + ITypes() + CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %uint %float |
| %f_ty = OpTypeFunction %void %uint %float |
| %caller_ty = OpTypeFunction %float ; make it return non-void otherwise it's just like main |
| |
| ; The called function does not change |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: = OpFunctionParameter %uint |
| ; CHECK-NEXT: = OpFunctionParameter %float |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %uint |
| %101 = OpFunctionParameter %float |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; The caller does not change |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_arg = OpCopyObject %uint %uint_0 |
| ; CHECK-NEXT: OpFunctionCall %void %f %caller_arg %float_0 |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_entry = OpLabel |
| %caller_arg = OpCopyObject %uint %uint_0 |
| %caller_call = OpFunctionCall %void %f %caller_arg %float_0 |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| // We still get a success-with-change result because the boilerplate included |
| // combined types, which were removed. |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionCall_Image_NoChange) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCaller() + |
| BasicTypes() + ITypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %i_ty |
| %f_ty = OpTypeFunction %void %i_ty |
| %caller_ty = OpTypeFunction %float %i_ty |
| |
| ; The called function does not change |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %i_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; The caller does not change |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %caller_arg = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: OpFunctionCall %void %f %caller_arg |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %i_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithoutChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionCall_Sampler_NoChange) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCaller() + |
| BasicTypes() + ITypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %s_ty |
| %f_ty = OpTypeFunction %void %s_ty |
| %caller_ty = OpTypeFunction %float %s_ty |
| |
| ; The called function does not change |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %s_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; The caller does not change |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %caller_arg = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: OpFunctionCall %void %f %caller_arg |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %s_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithoutChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionCall_PtrImage_NoChange) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCaller() + |
| BasicTypes() + ITypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %p_i_ty |
| %f_ty = OpTypeFunction %void %p_i_ty |
| %caller_ty = OpTypeFunction %float %p_i_ty |
| |
| ; The called function does not change |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: = OpFunctionParameter %p_i_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %p_i_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; The caller does not change |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %caller_arg = OpFunctionParameter %p_i_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: OpFunctionCall %void %f %caller_arg |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %p_i_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithoutChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionCall_PtrSampler_NoChange) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCaller() + |
| BasicTypes() + ITypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %p_s_ty |
| %f_ty = OpTypeFunction %void %p_s_ty |
| %caller_ty = OpTypeFunction %float %p_s_ty |
| |
| ; The called function does not change |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: = OpFunctionParameter %p_s_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %p_s_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; The caller does not change |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %caller_arg = OpFunctionParameter %p_s_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: OpFunctionCall %void %f %caller_arg |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %p_s_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithoutChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionCall_SampledImage_Split) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| NamedCaller() + BasicTypes() + ITypes() + |
| CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %i_ty %s_ty |
| %f_ty = OpTypeFunction %void %si_ty |
| %caller_ty = OpTypeFunction %float %si_ty |
| |
| ; Call function arg is split. We've checked these details in other tests. |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: %[[callee_i:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[callee_s:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %si_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %[[caller_i:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[caller_s:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_call = OpFunctionCall %void %f %[[caller_i]] %[[caller_s]] |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %si_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| FunctionCall_SampledImageDuplicatedArg_Split) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| NamedCaller() + BasicTypes() + ITypes() + |
| CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %i_ty %s_ty %i_ty %s_ty |
| %f_ty = OpTypeFunction %void %si_ty %si_ty |
| %caller_ty = OpTypeFunction %float %si_ty |
| |
| ; Call function arg is split. We've checked these details in other tests. |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: %[[callee_i_0:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[callee_s_0:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %[[callee_i_1:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[callee_s_1:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %si_ty |
| %101 = OpFunctionParameter %si_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %[[caller_i:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[caller_s:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_call = OpFunctionCall %void %f %[[caller_i]] %[[caller_s]] %[[caller_i]] %[[caller_s]] |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %si_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| FunctionCall_SampledImageTwoDistinct_Split) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| NamedCaller() + BasicTypes() + ITypes() + |
| CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %i_ty %s_ty %i_ty %s_ty |
| %f_ty = OpTypeFunction %void %si_ty %si_ty |
| %caller_ty = OpTypeFunction %float %si_ty %si_ty |
| |
| ; Call function arg is split. We've checked these details in other tests. |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: %[[callee_i_0:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[callee_s_0:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %[[callee_i_1:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[callee_s_1:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %si_ty |
| %101 = OpFunctionParameter %si_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %[[caller_i_0:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[caller_s_0:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %[[caller_i_1:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[caller_s_1:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_call = OpFunctionCall %void %f %[[caller_i_0]] %[[caller_s_0]] %[[caller_i_1]] %[[caller_s_1]] |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %si_ty |
| %201 = OpFunctionParameter %si_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg %201 |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| FunctionCall_SampledImageAndCopy_Split) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| NamedCaller() + BasicTypes() + ITypes() + |
| CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %i_ty %s_ty %i_ty %s_ty |
| %f_ty = OpTypeFunction %void %si_ty %si_ty |
| ; CHECK: %caller_ty = OpTypeFunction %float %i_ty %s_ty |
| %caller_ty = OpTypeFunction %float %si_ty |
| |
| ; Call function arg is split. We've checked these details in other tests. |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: %[[callee_i_0:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[callee_s_0:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %[[callee_i_1:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[callee_s_1:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %si_ty |
| %101 = OpFunctionParameter %si_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %[[caller_i:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[caller_s:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_call = OpFunctionCall %void %f %[[caller_i]] %[[caller_s]] %[[caller_i]] %[[caller_s]] |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %si_ty |
| %caller_entry = OpLabel |
| %copy = OpCopyObject %si_ty %caller_arg |
| %caller_call = OpFunctionCall %void %f %caller_arg %copy |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| FunctionCall_SampledImageSurrounded_Split) { |
| // Test indexing by surrounding the sampled image parameter with other |
| // arguments that should not be touched. |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| NamedCaller() + BasicTypes() + ITypes() + |
| CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %float %i_ty %s_ty %uint |
| %f_ty = OpTypeFunction %void %float %si_ty %uint |
| ; CHECK: %caller_ty = OpTypeFunction %float %uint %i_ty %s_ty %float |
| %caller_ty = OpTypeFunction %float %uint %si_ty %float |
| |
| ; Call function arg is split. We've checked these details in other tests. |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: %[[callee_f:\w+]] = OpFunctionParameter %float |
| ; CHECK-NEXT: %[[callee_i:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[callee_s:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %[[callee_u:\w+]] = OpFunctionParameter %uint |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %99 = OpFunctionParameter %float |
| %100 = OpFunctionParameter %si_ty |
| %101 = OpFunctionParameter %uint |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %[[u_param:\w+]] = OpFunctionParameter %uint |
| ; CHECK-NEXT: %[[caller_i:\w+]] = OpFunctionParameter %i_ty |
| ; CHECK-NEXT: %[[caller_s:\w+]] = OpFunctionParameter %s_ty |
| ; CHECK-NEXT: %[[f_param:\w+]] = OpFunctionParameter %float |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_call = OpFunctionCall %void %f %[[f_param]] %[[caller_i]] %[[caller_s]] %[[u_param]] |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %200 = OpFunctionParameter %uint |
| %caller_arg = OpFunctionParameter %si_ty |
| %201 = OpFunctionParameter %float |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %201 %caller_arg %200 |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, FunctionCall_PtrSampledImage_Split) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| NamedCaller() + BasicTypes() + ITypes() + |
| CombinedTypes() + R"( |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %p_i_ty %p_s_ty |
| %f_ty = OpTypeFunction %void %p_si_ty |
| %caller_ty = OpTypeFunction %float %p_si_ty |
| |
| ; Call function arg is split. We've checked these details in other tests. |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: %[[callee_i:\w+]] = OpFunctionParameter %p_i_ty |
| ; CHECK-NEXT: %[[callee_s:\w+]] = OpFunctionParameter %p_s_ty |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %p_si_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %[[caller_i:\w+]] = OpFunctionParameter %p_i_ty |
| ; CHECK-NEXT: %[[caller_s:\w+]] = OpFunctionParameter %p_s_ty |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_call = OpFunctionCall %void %f %[[caller_i]] %[[caller_s]] |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %p_si_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| FunctionCall_PtrArraySampledImage_Split) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| NamedCaller() + BasicTypes() + ITypes() + |
| CombinedTypes() + R"( |
| |
| ; CHECK: %[[array_i_ty:\w+]] = OpTypeArray %i_ty %uint_3 |
| ; CHECK: %[[p_array_i_ty:\w+]] = OpTypePointer UniformConstant %[[array_i_ty]] |
| ; CHECK: %[[array_s_ty:\w+]] = OpTypeArray %s_ty %uint_3 |
| ; CHECK: %[[p_array_s_ty:\w+]] = OpTypePointer UniformConstant %[[array_s_ty]] |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %[[p_array_i_ty]] %[[p_array_s_ty]] |
| %f_ty = OpTypeFunction %void %p_array_si_ty |
| %caller_ty = OpTypeFunction %float %p_array_si_ty |
| |
| ; Call function arg is split. We've checked these details in other tests. |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: %[[callee_i:\w+]] = OpFunctionParameter %[[p_array_i_ty]] |
| ; CHECK-NEXT: %[[callee_s:\w+]] = OpFunctionParameter %[[p_array_s_ty]] |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %p_array_si_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %[[caller_i:\w+]] = OpFunctionParameter %[[p_array_i_ty]] |
| ; CHECK-NEXT: %[[caller_s:\w+]] = OpFunctionParameter %[[p_array_s_ty]] |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_call = OpFunctionCall %void %f %[[caller_i]] %[[caller_s]] |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %p_array_si_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| TEST_F(SplitCombinedImageSamplerPassTest, |
| FunctionCall_PtrRtArraySampledImage_Split) { |
| const std::string kTest = Preamble() + NamedITypes() + NamedCombinedTypes() + |
| NamedCaller() + BasicTypes() + ITypes() + |
| CombinedTypes() + R"( |
| |
| ; CHECK: %[[array_i_ty:\w+]] = OpTypeRuntimeArray %i_ty |
| ; CHECK: %[[p_array_i_ty:\w+]] = OpTypePointer UniformConstant %[[array_i_ty]] |
| ; CHECK: %[[array_s_ty:\w+]] = OpTypeRuntimeArray |
| ; CHECK: %[[p_array_s_ty:\w+]] = OpTypePointer UniformConstant %[[array_s_ty]] |
| |
| ; CHECK: %f_ty = OpTypeFunction %void %[[p_array_i_ty]] %[[p_array_s_ty]] |
| %f_ty = OpTypeFunction %void %p_rtarray_si_ty |
| %caller_ty = OpTypeFunction %float %p_rtarray_si_ty |
| |
| ; Call function arg is split. We've checked these details in other tests. |
| ; CHECK: %f = OpFunction %void None %f_ty |
| ; CHECK-NEXT: %[[callee_i:\w+]] = OpFunctionParameter %[[p_array_i_ty]] |
| ; CHECK-NEXT: %[[callee_s:\w+]] = OpFunctionParameter %[[p_array_s_ty]] |
| ; CHECK-NEXT: = OpLabel |
| ; CHECK-NEXT: OpReturn |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %f = OpFunction %void None %f_ty |
| %100 = OpFunctionParameter %p_rtarray_si_ty |
| %110 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| ; CHECK: %caller = OpFunction %float None %caller_ty |
| ; CHECK-NEXT: %[[caller_i:\w+]] = OpFunctionParameter %[[p_array_i_ty]] |
| ; CHECK-NEXT: %[[caller_s:\w+]] = OpFunctionParameter %[[p_array_s_ty]] |
| ; CHECK-NEXT: %caller_entry = OpLabel |
| ; CHECK-NEXT: %caller_call = OpFunctionCall %void %f %[[caller_i]] %[[caller_s]] |
| ; CHECK-NEXT: OpReturnValue %float_0 |
| ; CHECK-NEXT: OpFunctionEnd |
| |
| %caller = OpFunction %float None %caller_ty |
| %caller_arg = OpFunctionParameter %p_rtarray_si_ty |
| %caller_entry = OpLabel |
| %caller_call = OpFunctionCall %void %f %caller_arg |
| OpReturnValue %float_0 |
| OpFunctionEnd |
| |
| )" + Main(); |
| |
| auto [disasm, status] = SinglePassRunAndMatch<SplitCombinedImageSamplerPass>( |
| kTest, /* do_validation= */ true); |
| EXPECT_EQ(status, Pass::Status::SuccessWithChange) << disasm; |
| } |
| |
| } // namespace |
| } // namespace opt |
| } // namespace spvtools |
