// Copyright 2020 The Tint Authors. // // 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 #include "gmock/gmock.h" #include "src/reader/spirv/function.h" #include "src/reader/spirv/parser_impl.h" #include "src/reader/spirv/parser_impl_test_helper.h" #include "src/reader/spirv/spirv_tools_helpers_test.h" namespace tint { namespace reader { namespace spirv { namespace { using ::testing::Eq; using ::testing::HasSubstr; using ::testing::Not; std::string Preamble() { return R"( OpCapability Shader OpCapability Sampled1D OpCapability Image1D OpCapability StorageImageExtendedFormats OpMemoryModel Logical Simple )"; } std::string CommonTypes() { return R"( %void = OpTypeVoid %voidfn = OpTypeFunction %void %float = OpTypeFloat 32 %uint = OpTypeInt 32 0 %int = OpTypeInt 32 1 %int_3 = OpConstant %uint 3 %int_4 = OpConstant %uint 4 %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %uint_100 = OpConstant %uint 100 %v2int = OpTypeVector %int 2 %v2uint = OpTypeVector %uint 2 %v4uint = OpTypeVector %uint 4 %v4int = OpTypeVector %int 4 %v2float = OpTypeVector %float 2 %v3float = OpTypeVector %float 3 %v4float = OpTypeVector %float 4 %float_null = OpConstantNull %float %float_7 = OpConstant %float 7 %v2float_null = OpConstantNull %v2float %v3float_null = OpConstantNull %v3float %v4float_null = OpConstantNull %v4float %depth = OpConstant %float 0.2 %offsets2d = OpConstantComposite %v2int %int_3 %int_4 ; Define types for all sampler and texture types that can map to WGSL, ; modulo texel formats for storage textures. For now, we limit ; ourselves to 2-channel 32-bit texel formats. ; Because the SPIR-V reader also already generalizes so it can work with ; combined image-samplers, we also test that too. %sampler = OpTypeSampler ; sampled images %f_texture_1d = OpTypeImage %float 1D 0 0 0 1 Unknown %f_texture_1d_array = OpTypeImage %float 1D 0 1 0 1 Unknown %f_texture_2d = OpTypeImage %float 2D 0 0 0 1 Unknown %f_texture_2d_ms = OpTypeImage %float 2D 0 0 1 1 Unknown %f_texture_2d_array = OpTypeImage %float 2D 0 1 0 1 Unknown %f_texture_2d_ms_array = OpTypeImage %float 2D 0 1 1 1 Unknown ; not in WebGPU %f_texture_3d = OpTypeImage %float 3D 0 0 0 1 Unknown %f_texture_cube = OpTypeImage %float Cube 0 0 0 1 Unknown %f_texture_cube_array = OpTypeImage %float Cube 0 1 0 1 Unknown ; storage images %f_storage_1d = OpTypeImage %float 1D 0 0 0 1 Rg32f %f_storage_1d_array = OpTypeImage %float 1D 0 1 0 1 Rg32f %f_storage_2d = OpTypeImage %float 2D 0 0 0 1 Rg32f %f_storage_2d_array = OpTypeImage %float 2D 0 1 0 1 Rg32f %f_storage_3d = OpTypeImage %float 3D 0 0 0 1 Rg32f ; Now all the same, but for unsigned integer sampled type. %u_texture_1d = OpTypeImage %uint 1D 0 0 0 1 Unknown %u_texture_1d_array = OpTypeImage %uint 1D 0 1 0 1 Unknown %u_texture_2d = OpTypeImage %uint 2D 0 0 0 1 Unknown %u_texture_2d_ms = OpTypeImage %uint 2D 0 0 1 1 Unknown %u_texture_2d_array = OpTypeImage %uint 2D 0 1 0 1 Unknown %u_texture_2d_ms_array = OpTypeImage %uint 2D 0 1 1 1 Unknown ; not in WebGPU %u_texture_3d = OpTypeImage %uint 3D 0 0 0 1 Unknown %u_texture_cube = OpTypeImage %uint Cube 0 0 0 1 Unknown %u_texture_cube_array = OpTypeImage %uint Cube 0 1 0 1 Unknown %u_storage_1d = OpTypeImage %uint 1D 0 0 0 1 Rg32ui %u_storage_1d_array = OpTypeImage %uint 1D 0 1 0 1 Rg32ui %u_storage_2d = OpTypeImage %uint 2D 0 0 0 1 Rg32ui %u_storage_2d_array = OpTypeImage %uint 2D 0 1 0 1 Rg32ui %u_storage_3d = OpTypeImage %uint 3D 0 0 0 1 Rg32ui ; Now all the same, but for signed integer sampled type. %i_texture_1d = OpTypeImage %int 1D 0 0 0 1 Unknown %i_texture_1d_array = OpTypeImage %int 1D 0 1 0 1 Unknown %i_texture_2d = OpTypeImage %int 2D 0 0 0 1 Unknown %i_texture_2d_ms = OpTypeImage %int 2D 0 0 1 1 Unknown %i_texture_2d_array = OpTypeImage %int 2D 0 1 0 1 Unknown %i_texture_2d_ms_array = OpTypeImage %int 2D 0 1 1 1 Unknown ; not in WebGPU %i_texture_3d = OpTypeImage %int 3D 0 0 0 1 Unknown %i_texture_cube = OpTypeImage %int Cube 0 0 0 1 Unknown %i_texture_cube_array = OpTypeImage %int Cube 0 1 0 1 Unknown %i_storage_1d = OpTypeImage %int 1D 0 0 0 1 Rg32i %i_storage_1d_array = OpTypeImage %int 1D 0 1 0 1 Rg32i %i_storage_2d = OpTypeImage %int 2D 0 0 0 1 Rg32i %i_storage_2d_array = OpTypeImage %int 2D 0 1 0 1 Rg32i %i_storage_3d = OpTypeImage %int 3D 0 0 0 1 Rg32i ;; Now pointers to each of the above, so we can declare variables for them. %ptr_sampler = OpTypePointer UniformConstant %sampler %ptr_f_texture_1d = OpTypePointer UniformConstant %f_texture_1d %ptr_f_texture_1d_array = OpTypePointer UniformConstant %f_texture_1d_array %ptr_f_texture_2d = OpTypePointer UniformConstant %f_texture_2d %ptr_f_texture_2d_ms = OpTypePointer UniformConstant %f_texture_2d_ms %ptr_f_texture_2d_array = OpTypePointer UniformConstant %f_texture_2d_array %ptr_f_texture_2d_ms_array = OpTypePointer UniformConstant %f_texture_2d_ms_array %ptr_f_texture_3d = OpTypePointer UniformConstant %f_texture_3d %ptr_f_texture_cube = OpTypePointer UniformConstant %f_texture_cube %ptr_f_texture_cube_array = OpTypePointer UniformConstant %f_texture_cube_array ; storage images %ptr_f_storage_1d = OpTypePointer UniformConstant %f_storage_1d %ptr_f_storage_1d_array = OpTypePointer UniformConstant %f_storage_1d_array %ptr_f_storage_2d = OpTypePointer UniformConstant %f_storage_2d %ptr_f_storage_2d_array = OpTypePointer UniformConstant %f_storage_2d_array %ptr_f_storage_3d = OpTypePointer UniformConstant %f_storage_3d ; Now all the same, but for unsigned integer sampled type. %ptr_u_texture_1d = OpTypePointer UniformConstant %u_texture_1d %ptr_u_texture_1d_array = OpTypePointer UniformConstant %u_texture_1d_array %ptr_u_texture_2d = OpTypePointer UniformConstant %u_texture_2d %ptr_u_texture_2d_ms = OpTypePointer UniformConstant %u_texture_2d_ms %ptr_u_texture_2d_array = OpTypePointer UniformConstant %u_texture_2d_array %ptr_u_texture_2d_ms_array = OpTypePointer UniformConstant %u_texture_2d_ms_array %ptr_u_texture_3d = OpTypePointer UniformConstant %u_texture_3d %ptr_u_texture_cube = OpTypePointer UniformConstant %u_texture_cube %ptr_u_texture_cube_array = OpTypePointer UniformConstant %u_texture_cube_array %ptr_u_storage_1d = OpTypePointer UniformConstant %u_storage_1d %ptr_u_storage_1d_array = OpTypePointer UniformConstant %u_storage_1d_array %ptr_u_storage_2d = OpTypePointer UniformConstant %u_storage_2d %ptr_u_storage_2d_array = OpTypePointer UniformConstant %u_storage_2d_array %ptr_u_storage_3d = OpTypePointer UniformConstant %u_storage_3d ; Now all the same, but for signed integer sampled type. %ptr_i_texture_1d = OpTypePointer UniformConstant %i_texture_1d %ptr_i_texture_1d_array = OpTypePointer UniformConstant %i_texture_1d_array %ptr_i_texture_2d = OpTypePointer UniformConstant %i_texture_2d %ptr_i_texture_2d_ms = OpTypePointer UniformConstant %i_texture_2d_ms %ptr_i_texture_2d_array = OpTypePointer UniformConstant %i_texture_2d_array %ptr_i_texture_2d_ms_array = OpTypePointer UniformConstant %i_texture_2d_ms_array %ptr_i_texture_3d = OpTypePointer UniformConstant %i_texture_3d %ptr_i_texture_cube = OpTypePointer UniformConstant %i_texture_cube %ptr_i_texture_cube_array = OpTypePointer UniformConstant %i_texture_cube_array %ptr_i_storage_1d = OpTypePointer UniformConstant %i_storage_1d %ptr_i_storage_1d_array = OpTypePointer UniformConstant %i_storage_1d_array %ptr_i_storage_2d = OpTypePointer UniformConstant %i_storage_2d %ptr_i_storage_2d_array = OpTypePointer UniformConstant %i_storage_2d_array %ptr_i_storage_3d = OpTypePointer UniformConstant %i_storage_3d )"; } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_WellFormedButNotAHandle) { const auto assembly = Preamble() + CommonTypes() + R"( %10 = OpConstantNull %ptr_sampler %20 = OpConstantNull %ptr_f_texture_1d )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(10, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(20, true); EXPECT_EQ(sampler, nullptr); EXPECT_EQ(image, nullptr); EXPECT_TRUE(p->error().empty()); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_Direct) { const auto assembly = Preamble() + CommonTypes() + R"( %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_1d UniformConstant )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(10, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(20, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_AccessChain) { // Show that we would generalize to arrays of handles, even though that // is not supported in WGSL MVP. const auto assembly = Preamble() + CommonTypes() + R"( %sampler_array = OpTypeArray %sampler %uint_100 %image_array = OpTypeArray %f_texture_1d %uint_100 %ptr_sampler_array = OpTypePointer UniformConstant %sampler_array %ptr_image_array = OpTypePointer UniformConstant %image_array %10 = OpVariable %ptr_sampler_array UniformConstant %20 = OpVariable %ptr_image_array UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %110 = OpAccessChain %ptr_sampler %10 %uint_1 %120 = OpAccessChain %ptr_f_texture_1d %20 %uint_2 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_InBoundsAccessChain) { const auto assembly = Preamble() + CommonTypes() + R"( %sampler_array = OpTypeArray %sampler %uint_100 %image_array = OpTypeArray %f_texture_1d %uint_100 %ptr_sampler_array = OpTypePointer UniformConstant %sampler_array %ptr_image_array = OpTypePointer UniformConstant %image_array %10 = OpVariable %ptr_sampler_array UniformConstant %20 = OpVariable %ptr_image_array UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %110 = OpInBoundsAccessChain %ptr_sampler %10 %uint_1 %120 = OpInBoundsAccessChain %ptr_f_texture_1d %20 %uint_2 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_PtrAccessChain) { // Show that we would generalize to arrays of handles, even though that // is not supported in WGSL MVP. const auto assembly = Preamble() + CommonTypes() + R"( %sampler_array = OpTypeArray %sampler %uint_100 %image_array = OpTypeArray %f_texture_1d %uint_100 %ptr_sampler_array = OpTypePointer UniformConstant %sampler_array %ptr_image_array = OpTypePointer UniformConstant %image_array %10 = OpVariable %ptr_sampler_array UniformConstant %20 = OpVariable %ptr_image_array UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %110 = OpPtrAccessChain %ptr_sampler %10 %uint_1 %uint_1 %120 = OpPtrAccessChain %ptr_f_texture_1d %20 %uint_1 %uint_2 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_InBoundsPtrAccessChain) { const auto assembly = Preamble() + CommonTypes() + R"( %sampler_array = OpTypeArray %sampler %uint_100 %image_array = OpTypeArray %f_texture_1d %uint_100 %ptr_sampler_array = OpTypePointer UniformConstant %sampler_array %ptr_image_array = OpTypePointer UniformConstant %image_array %10 = OpVariable %ptr_sampler_array UniformConstant %20 = OpVariable %ptr_image_array UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %110 = OpInBoundsPtrAccessChain %ptr_sampler %10 %uint_1 %uint_1 %120 = OpInBoundsPtrAccessChain %ptr_f_texture_1d %20 %uint_1 %uint_2 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_CopyObject) { const auto assembly = Preamble() + CommonTypes() + R"( %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_1d UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %110 = OpCopyObject %ptr_sampler %10 %120 = OpCopyObject %ptr_f_texture_1d %20 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_Load) { const auto assembly = Preamble() + CommonTypes() + R"( %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_1d UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %110 = OpLoad %sampler %10 %120 = OpLoad %f_texture_1d %20 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_SampledImage) { // Trace through the sampled image instruction, but in two different // directions. const auto assembly = Preamble() + CommonTypes() + R"( %sampled_image_type = OpTypeSampledImage %f_texture_1d %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_1d UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %s = OpLoad %sampler %10 %im = OpLoad %f_texture_1d %20 %100 = OpSampledImage %sampled_image_type %im %s OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(100, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(100, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_Variable_Image) { const auto assembly = Preamble() + CommonTypes() + R"( %sampled_image_type = OpTypeSampledImage %f_texture_1d %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_1d UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %s = OpLoad %sampler %10 %im = OpLoad %f_texture_1d %20 %100 = OpSampledImage %sampled_image_type %im %s %200 = OpImage %im %100 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* image = p->GetMemoryObjectDeclarationForHandle(200, true); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_Direct) { const auto assembly = Preamble() + CommonTypes() + R"( %fty = OpTypeFunction %void %ptr_sampler %ptr_f_texture_1d %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler %20 = OpFunctionParameter %ptr_f_texture_1d %entry = OpLabel OpReturn )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(10, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(20, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_AccessChain) { // Show that we would generalize to arrays of handles, even though that // is not supported in WGSL MVP. const auto assembly = Preamble() + CommonTypes() + R"( %sampler_array = OpTypeArray %sampler %uint_100 %image_array = OpTypeArray %f_texture_1d %uint_100 %ptr_sampler_array = OpTypePointer UniformConstant %sampler_array %ptr_image_array = OpTypePointer UniformConstant %image_array %fty = OpTypeFunction %void %ptr_sampler_array %ptr_image_array %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler_array %20 = OpFunctionParameter %ptr_image_array %entry = OpLabel %110 = OpAccessChain %ptr_sampler %10 %uint_1 %120 = OpAccessChain %ptr_f_texture_1d %20 %uint_2 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_InBoundsAccessChain) { const auto assembly = Preamble() + CommonTypes() + R"( %sampler_array = OpTypeArray %sampler %uint_100 %image_array = OpTypeArray %f_texture_1d %uint_100 %ptr_sampler_array = OpTypePointer UniformConstant %sampler_array %ptr_image_array = OpTypePointer UniformConstant %image_array %fty = OpTypeFunction %void %ptr_sampler_array %ptr_image_array %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler_array %20 = OpFunctionParameter %ptr_image_array %entry = OpLabel %110 = OpInBoundsAccessChain %ptr_sampler %10 %uint_1 %120 = OpInBoundsAccessChain %ptr_f_texture_1d %20 %uint_2 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_PtrAccessChain) { // Show that we would generalize to arrays of handles, even though that // is not supported in WGSL MVP. const auto assembly = Preamble() + CommonTypes() + R"( %sampler_array = OpTypeArray %sampler %uint_100 %image_array = OpTypeArray %f_texture_1d %uint_100 %ptr_sampler_array = OpTypePointer UniformConstant %sampler_array %ptr_image_array = OpTypePointer UniformConstant %image_array %fty = OpTypeFunction %void %ptr_sampler_array %ptr_image_array %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler_array %20 = OpFunctionParameter %ptr_image_array %entry = OpLabel %110 = OpPtrAccessChain %ptr_sampler %10 %uint_1 %uint_1 %120 = OpPtrAccessChain %ptr_f_texture_1d %20 %uint_1 %uint_2 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_InBoundsPtrAccessChain) { const auto assembly = Preamble() + CommonTypes() + R"( %sampler_array = OpTypeArray %sampler %uint_100 %image_array = OpTypeArray %f_texture_1d %uint_100 %ptr_sampler_array = OpTypePointer UniformConstant %sampler_array %ptr_image_array = OpTypePointer UniformConstant %image_array %fty = OpTypeFunction %void %ptr_sampler_array %ptr_image_array %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler_array %20 = OpFunctionParameter %ptr_image_array %entry = OpLabel %110 = OpInBoundsPtrAccessChain %ptr_sampler %10 %uint_1 %uint_1 %120 = OpInBoundsPtrAccessChain %ptr_f_texture_1d %20 %uint_1 %uint_2 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_CopyObject) { const auto assembly = Preamble() + CommonTypes() + R"( %fty = OpTypeFunction %void %ptr_sampler %ptr_f_texture_1d %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler %20 = OpFunctionParameter %ptr_f_texture_1d %entry = OpLabel %110 = OpCopyObject %ptr_sampler %10 %120 = OpCopyObject %ptr_f_texture_1d %20 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_Load) { const auto assembly = Preamble() + CommonTypes() + R"( %fty = OpTypeFunction %void %ptr_sampler %ptr_f_texture_1d %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler %20 = OpFunctionParameter %ptr_f_texture_1d %entry = OpLabel %110 = OpLoad %sampler %10 %120 = OpLoad %f_texture_1d %20 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(110, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(120, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_SampledImage) { // Trace through the sampled image instruction, but in two different // directions. const auto assembly = Preamble() + CommonTypes() + R"( %sampled_image_type = OpTypeSampledImage %f_texture_1d %fty = OpTypeFunction %void %ptr_sampler %ptr_f_texture_1d %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler %20 = OpFunctionParameter %ptr_f_texture_1d %entry = OpLabel %s = OpLoad %sampler %10 %im = OpLoad %f_texture_1d %20 %100 = OpSampledImage %sampled_image_type %im %s OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* sampler = p->GetMemoryObjectDeclarationForHandle(100, false); const auto* image = p->GetMemoryObjectDeclarationForHandle(100, true); ASSERT_TRUE(sampler != nullptr); EXPECT_EQ(sampler->result_id(), 10u); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } TEST_F(SpvParserTest, GetMemoryObjectDeclarationForHandle_FuncParam_Image) { const auto assembly = Preamble() + CommonTypes() + R"( %sampled_image_type = OpTypeSampledImage %f_texture_1d %fty = OpTypeFunction %void %ptr_sampler %ptr_f_texture_1d %func = OpFunction %void None %fty %10 = OpFunctionParameter %ptr_sampler %20 = OpFunctionParameter %ptr_f_texture_1d %entry = OpLabel %s = OpLoad %sampler %10 %im = OpLoad %f_texture_1d %20 %100 = OpSampledImage %sampled_image_type %im %s %200 = OpImage %im %100 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->error().empty()); const auto* image = p->GetMemoryObjectDeclarationForHandle(200, true); ASSERT_TRUE(image != nullptr); EXPECT_EQ(image->result_id(), 20u); } // Test RegisterHandleUsage, sampled image cases struct UsageSampledImageCase { std::string inst; std::string expected_sampler_usage; std::string expected_image_usage; }; inline std::ostream& operator<<(std::ostream& out, const UsageSampledImageCase& c) { out << "UsageSampledImageCase(" << c.inst << ", " << c.expected_sampler_usage << ", " << c.expected_image_usage << ")"; return out; } using SpvParserTest_RegisterHandleUsage_SampledImage = SpvParserTestBase<::testing::TestWithParam>; TEST_P(SpvParserTest_RegisterHandleUsage_SampledImage, Variable) { const auto assembly = Preamble() + CommonTypes() + R"( %si_ty = OpTypeSampledImage %f_texture_2d %coords = OpConstantNull %v2float %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_2d UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %sam = OpLoad %sampler %10 %im = OpLoad %f_texture_2d %20 %sampled_image = OpSampledImage %si_ty %im %sam )" + GetParam().inst + R"( OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->RegisterHandleUsage()); EXPECT_TRUE(p->error().empty()); Usage su = p->GetHandleUsage(10); Usage iu = p->GetHandleUsage(20); EXPECT_THAT(su.to_str(), Eq(GetParam().expected_sampler_usage)); EXPECT_THAT(iu.to_str(), Eq(GetParam().expected_image_usage)); } TEST_P(SpvParserTest_RegisterHandleUsage_SampledImage, FunctionParam) { const auto assembly = Preamble() + CommonTypes() + R"( %f_ty = OpTypeFunction %void %ptr_sampler %ptr_f_texture_2d %si_ty = OpTypeSampledImage %f_texture_2d %coords = OpConstantNull %v2float %component = OpConstant %uint 1 %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_2d UniformConstant %func = OpFunction %void None %f_ty %110 = OpFunctionParameter %ptr_sampler %120 = OpFunctionParameter %ptr_f_texture_2d %func_entry = OpLabel %sam = OpLoad %sampler %110 %im = OpLoad %f_texture_2d %120 %sampled_image = OpSampledImage %si_ty %im %sam )" + GetParam().inst + R"( OpReturn OpFunctionEnd %main = OpFunction %void None %voidfn %entry = OpLabel %foo = OpFunctionCall %void %func %10 %20 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()) << p->error() << assembly << std::endl; EXPECT_TRUE(p->RegisterHandleUsage()) << p->error() << assembly << std::endl; EXPECT_TRUE(p->error().empty()) << p->error() << assembly << std::endl; Usage su = p->GetHandleUsage(10); Usage iu = p->GetHandleUsage(20); EXPECT_THAT(su.to_str(), Eq(GetParam().expected_sampler_usage)); EXPECT_THAT(iu.to_str(), Eq(GetParam().expected_image_usage)); } INSTANTIATE_TEST_SUITE_P( Samples, SpvParserTest_RegisterHandleUsage_SampledImage, ::testing::Values( // OpImageGather UsageSampledImageCase{"%result = OpImageGather " "%v4float %sampled_image %coords %uint_1", "Usage(Sampler( ))", "Usage(Texture( is_sampled ))"}, // OpImageDrefGather UsageSampledImageCase{"%result = OpImageDrefGather " "%v4float %sampled_image %coords %depth", "Usage(Sampler( comparison ))", "Usage(Texture( is_sampled depth ))"}, // Sample the texture. // OpImageSampleImplicitLod UsageSampledImageCase{"%result = OpImageSampleImplicitLod " "%v4float %sampled_image %coords", "Usage(Sampler( ))", "Usage(Texture( is_sampled ))"}, // OpImageSampleExplicitLod UsageSampledImageCase{"%result = OpImageSampleExplicitLod " "%v4float %sampled_image %coords Lod %float_null", "Usage(Sampler( ))", "Usage(Texture( is_sampled ))"}, // OpImageSampleDrefImplicitLod UsageSampledImageCase{"%result = OpImageSampleDrefImplicitLod " "%v4float %sampled_image %coords %depth", "Usage(Sampler( comparison ))", "Usage(Texture( is_sampled depth ))"}, // OpImageSampleDrefExplicitLod UsageSampledImageCase{ "%result = OpImageSampleDrefExplicitLod " "%v4float %sampled_image %coords %depth Lod %float_null", "Usage(Sampler( comparison ))", "Usage(Texture( is_sampled depth ))"}, // Sample the texture, with *Proj* variants, even though WGSL doesn't // support them. // OpImageSampleProjImplicitLod UsageSampledImageCase{"%result = OpImageSampleProjImplicitLod " "%v4float %sampled_image %coords", "Usage(Sampler( ))", "Usage(Texture( is_sampled ))"}, // OpImageSampleProjExplicitLod UsageSampledImageCase{"%result = OpImageSampleProjExplicitLod " "%v4float %sampled_image %coords Lod %float_null", "Usage(Sampler( ))", "Usage(Texture( is_sampled ))"}, // OpImageSampleProjDrefImplicitLod UsageSampledImageCase{"%result = OpImageSampleProjDrefImplicitLod " "%v4float %sampled_image %coords %depth", "Usage(Sampler( comparison ))", "Usage(Texture( is_sampled depth ))"}, // OpImageSampleProjDrefExplicitLod UsageSampledImageCase{ "%result = OpImageSampleProjDrefExplicitLod " "%v4float %sampled_image %coords %depth Lod %float_null", "Usage(Sampler( comparison ))", "Usage(Texture( is_sampled depth ))"}, // OpImageQueryLod UsageSampledImageCase{ "%result = OpImageQueryLod %v2float %sampled_image %coords", "Usage(Sampler( ))", "Usage(Texture( is_sampled ))"})); // Test RegisterHandleUsage, raw image cases. // For these we test the use of an image value directly, and not combined // with the sampler. The image still could be of sampled image type. struct UsageRawImageCase { std::string type; // Example: f_storage_1d or f_texture_1d std::string inst; std::string expected_image_usage; }; inline std::ostream& operator<<(std::ostream& out, const UsageRawImageCase& c) { out << "UsageRawImageCase(" << c.type << ", " << c.inst << ", " << c.expected_image_usage << ")"; return out; } using SpvParserTest_RegisterHandleUsage_RawImage = SpvParserTestBase<::testing::TestWithParam>; TEST_P(SpvParserTest_RegisterHandleUsage_RawImage, Variable) { const auto assembly = Preamble() + CommonTypes() + R"( %20 = OpVariable %ptr_)" + GetParam().type + R"( UniformConstant %main = OpFunction %void None %voidfn %entry = OpLabel %im = OpLoad %)" + GetParam().type + R"( %20 )" + GetParam().inst + R"( OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->RegisterHandleUsage()); EXPECT_TRUE(p->error().empty()); Usage iu = p->GetHandleUsage(20); EXPECT_THAT(iu.to_str(), Eq(GetParam().expected_image_usage)); Usage su = p->GetHandleUsage(20); } TEST_P(SpvParserTest_RegisterHandleUsage_RawImage, FunctionParam) { const auto assembly = Preamble() + CommonTypes() + R"( %f_ty = OpTypeFunction %void %ptr_)" + GetParam().type + R"( %20 = OpVariable %ptr_)" + GetParam().type + R"( UniformConstant %func = OpFunction %void None %f_ty %i_param = OpFunctionParameter %ptr_)" + GetParam().type + R"( %func_entry = OpLabel %im = OpLoad %)" + GetParam().type + R"( %i_param )" + GetParam().inst + R"( OpReturn OpFunctionEnd %main = OpFunction %void None %voidfn %entry = OpLabel %foo = OpFunctionCall %void %func %20 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()); EXPECT_TRUE(p->RegisterHandleUsage()); EXPECT_TRUE(p->error().empty()); Usage iu = p->GetHandleUsage(20); EXPECT_THAT(iu.to_str(), Eq(GetParam().expected_image_usage)); } INSTANTIATE_TEST_SUITE_P( Samples, SpvParserTest_RegisterHandleUsage_RawImage, ::testing::Values( // OpImageRead UsageRawImageCase{"f_storage_1d", "%result = OpImageRead %v4float %im %uint_1", "Usage(Texture( read ))"}, // OpImageWrite UsageRawImageCase{"f_storage_1d", "OpImageWrite %im %uint_1 %v4float_null", "Usage(Texture( write ))"}, // OpImageFetch UsageRawImageCase{"f_texture_1d", "%result = OpImageFetch " "%v4float %im %float_null", "Usage(Texture( is_sampled ))"}, // Image queries // OpImageQuerySizeLod // Applies to NonReadable, hence write-only storage UsageRawImageCase{"f_storage_2d", "%result = OpImageQuerySizeLod " "%v2uint %im %uint_1", "Usage(Texture( write ))"}, // OpImageQuerySize // Applies to NonReadable, hence write-only storage UsageRawImageCase{"f_storage_2d", "%result = OpImageQuerySize " "%v2uint %im", "Usage(Texture( write ))"}, // OpImageQueryLevels UsageRawImageCase{"f_texture_2d", "%result = OpImageQueryLevels " "%uint %im", "Usage(Texture( ))"}, // OpImageQuerySamples UsageRawImageCase{"f_texture_2d_ms", "%result = OpImageQuerySamples " "%uint %im", "Usage(Texture( is_sampled ms ))"})); // Test emission of handle variables. // Test emission of variables where we don't have enough clues from their // use in image access instructions in executable code. For these we have // to infer usage from the SPIR-V sampler or image type. struct DeclUnderspecifiedHandleCase { std::string decorations; // SPIR-V decorations std::string inst; // SPIR-V variable declarations std::string var_decl; // WGSL variable declaration }; inline std::ostream& operator<<(std::ostream& out, const DeclUnderspecifiedHandleCase& c) { out << "DeclUnderspecifiedHandleCase(" << c.inst << "\n" << c.var_decl << ")"; return out; } using SpvParserTest_DeclUnderspecifiedHandle = SpvParserTestBase<::testing::TestWithParam>; TEST_P(SpvParserTest_DeclUnderspecifiedHandle, Variable) { const auto assembly = Preamble() + R"( OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 )" + GetParam().decorations + CommonTypes() + GetParam().inst + R"( %main = OpFunction %void None %voidfn %entry = OpLabel OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; EXPECT_TRUE(p->error().empty()) << p->error(); const auto module = p->module().to_str(); EXPECT_THAT(module, HasSubstr(GetParam().var_decl)) << module; } INSTANTIATE_TEST_SUITE_P(Samplers, SpvParserTest_DeclUnderspecifiedHandle, ::testing::Values( DeclUnderspecifiedHandleCase{"", R"( %ptr = OpTypePointer UniformConstant %sampler %10 = OpVariable %ptr UniformConstant )", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler })"})); INSTANTIATE_TEST_SUITE_P(Images, SpvParserTest_DeclUnderspecifiedHandle, ::testing::Values( DeclUnderspecifiedHandleCase{"", R"( %10 = OpVariable %ptr_f_texture_1d UniformConstant )", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampled_texture_1d__f32 })"}, DeclUnderspecifiedHandleCase{R"( OpDecorate %10 NonWritable )", R"( %10 = OpVariable %ptr_f_storage_1d UniformConstant )", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __storage_texture_read_only_1d_rg32float })"}, DeclUnderspecifiedHandleCase{R"( OpDecorate %10 NonReadable )", R"( %10 = OpVariable %ptr_f_storage_1d UniformConstant )", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __storage_texture_write_only_1d_rg32float })"})); // Test emission of variables when we have sampled image accesses in // executable code. struct DeclSampledImageCase { std::string inst; // The provoking image access instruction. std::string var_decl; // WGSL variable declaration std::string texture_builtin; // WGSL texture usage. }; inline std::ostream& operator<<(std::ostream& out, const DeclSampledImageCase& c) { out << "DeclSampledImageCase(" << c.inst << "\n" << c.var_decl << "\n" << c.texture_builtin << ")"; return out; } using SpvParserTest_DeclHandle_SampledImage = SpvParserTestBase<::testing::TestWithParam>; TEST_P(SpvParserTest_DeclHandle_SampledImage, Variable) { const auto assembly = Preamble() + R"( OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 OpDecorate %20 DescriptorSet 2 OpDecorate %20 Binding 1 OpDecorate %30 DescriptorSet 0 OpDecorate %30 Binding 1 )" + CommonTypes() + R"( ; Vulkan ignores the "depth" parameter on OpTypeImage. ; So this image type can serve for both regular sampling and depth-compare. %si_ty = OpTypeSampledImage %f_texture_2d %coords = OpConstantNull %v2float %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_2d UniformConstant %30 = OpVariable %ptr_sampler UniformConstant ; comparison sampler, when needed %main = OpFunction %void None %voidfn %entry = OpLabel %sam = OpLoad %sampler %10 %im = OpLoad %f_texture_2d %20 %sampled_image = OpSampledImage %si_ty %im %sam )" + GetParam().inst + R"( OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; EXPECT_TRUE(p->error().empty()) << p->error(); const auto module = p->module().to_str(); EXPECT_THAT(module, HasSubstr(GetParam().var_decl)) << "DECLARATIONS ARE BAD " << module; EXPECT_THAT(module, HasSubstr(GetParam().texture_builtin)) << "TEXTURE BUILTIN IS BAD " << module << assembly; } // TODO(dneto): Test variable declaration and texture builtins provoked by // use of an image access instruction inside helper function. TEST_P(SpvParserTest_RegisterHandleUsage_SampledImage, DISABLED_FunctionParam) { const auto assembly = Preamble() + CommonTypes() + R"( %f_ty = OpTypeFunction %void %ptr_sampler %ptr_f_texture_2d %si_ty = OpTypeSampledImage %f_texture_2d %coords = OpConstantNull %v2float %component = OpConstant %uint 1 %10 = OpVariable %ptr_sampler UniformConstant %20 = OpVariable %ptr_f_texture_2d UniformConstant %func = OpFunction %void None %f_ty %110 = OpFunctionParameter %ptr_sampler %120 = OpFunctionParameter %ptr_f_texture_2d %func_entry = OpLabel %sam = OpLoad %sampler %110 %im = OpLoad %f_texture_2d %120 %sampled_image = OpSampledImage %si_ty %im %sam )" + GetParam().inst + R"( OpReturn OpFunctionEnd %main = OpFunction %void None %voidfn %entry = OpLabel %foo = OpFunctionCall %void %func %10 %20 OpReturn OpFunctionEnd )"; auto p = parser(test::Assemble(assembly)); ASSERT_TRUE(p->BuildInternalModule()) << p->error() << assembly << std::endl; EXPECT_TRUE(p->RegisterHandleUsage()) << p->error() << assembly << std::endl; EXPECT_TRUE(p->error().empty()) << p->error() << assembly << std::endl; Usage su = p->GetHandleUsage(10); Usage iu = p->GetHandleUsage(20); EXPECT_THAT(su.to_str(), Eq(GetParam().expected_sampler_usage)); EXPECT_THAT(iu.to_str(), Eq(GetParam().expected_image_usage)); } INSTANTIATE_TEST_SUITE_P( DISABLED_ImageGather, SpvParserTest_DeclHandle_SampledImage, ::testing::ValuesIn(std::vector{ // TODO(dneto): OpImageGather // TODO(dneto): OpImageGather with ConstOffset (signed and unsigned) // TODO(dneto): OpImageGather with Offset (signed and unsigned) // TODO(dneto): OpImageGather with Offsets (signed and unsigned) })); INSTANTIATE_TEST_SUITE_P( DISABLED_ImageDrefGather, SpvParserTest_DeclHandle_SampledImage, ::testing::ValuesIn(std::vector{ // TODO(dneto): OpImageDrefGather // TODO(dneto): OpImageDrefGather with ConstOffset (signed and // unsigned) // TODO(dneto): OpImageDrefGather with Offset (signed and unsigned) // TODO(dneto): OpImageDrefGather with Offsets (signed and unsigned) })); INSTANTIATE_TEST_SUITE_P( ImageSampleImplicitLod, SpvParserTest_DeclHandle_SampledImage, ::testing::Values( // OpImageSampleImplicitLod DeclSampledImageCase{"%result = OpImageSampleImplicitLod " "%v4float %sampled_image %coords", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __sampled_texture_2d__f32 })", R"( Call[not set]{ Identifier[not set]{textureSample} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ) })"}, // OpImageSampleImplicitLod with ConstOffset DeclSampledImageCase{ "%result = OpImageSampleImplicitLod " "%v4float %sampled_image %coords ConstOffset %offsets2d", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __sampled_texture_2d__f32 })", R"( Call[not set]{ Identifier[not set]{textureSample} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } TypeConstructor[not set]{ __vec_2__i32 ScalarConstructor[not set]{3} ScalarConstructor[not set]{4} } ) })"}, // OpImageSampleImplicitLod with Bias DeclSampledImageCase{"%result = OpImageSampleImplicitLod " "%v4float %sampled_image %coords Bias %float_7", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __sampled_texture_2d__f32 })", R"( Call[not set]{ Identifier[not set]{textureSampleBias} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{7.000000} ) })"}, // OpImageSampleImplicitLod with Bias and ConstOffset // TODO(dneto): OpImageSampleImplicitLod with Bias and unsigned // ConstOffset DeclSampledImageCase{"%result = OpImageSampleImplicitLod " "%v4float %sampled_image %coords Bias|ConstOffset " "%float_7 %offsets2d", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __sampled_texture_2d__f32 })", R"( Call[not set]{ Identifier[not set]{textureSampleBias} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{7.000000} TypeConstructor[not set]{ __vec_2__i32 ScalarConstructor[not set]{3} ScalarConstructor[not set]{4} } ) })"})); INSTANTIATE_TEST_SUITE_P( // This test shows the use of a sampled image used with both regular // sampling and depth-refernce sampling. The texture is a depth-texture, // and we use builtins textureSample and textureSampleCompare ImageSampleImplicitLod_BothDrefAndNonDref, SpvParserTest_DeclHandle_SampledImage, ::testing::Values( // OpImageSampleImplicitLod DeclSampledImageCase{R"( %sam_dref = OpLoad %sampler %30 %sampled_dref_image = OpSampledImage %si_ty %im %sam_dref %200 = OpImageSampleImplicitLod %v4float %sampled_image %coords %210 = OpImageSampleDrefImplicitLod %v4float %sampled_dref_image %coords %depth )", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __depth_texture_2d } DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{1} } x_30 uniform_constant __sampler_comparison })", R"( VariableDeclStatement{ VariableConst{ x_200 none __vec_4__f32 { Call[not set]{ Identifier[not set]{textureSample} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ) } } } } VariableDeclStatement{ VariableConst{ x_210 none __vec_4__f32 { Call[not set]{ Identifier[not set]{textureSampleCompare} ( Identifier[not set]{x_20} Identifier[not set]{x_30} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{0.200000} ) } } } })"})); INSTANTIATE_TEST_SUITE_P( ImageSampleDrefImplicitLod, SpvParserTest_DeclHandle_SampledImage, ::testing::Values( // ImageSampleDrefImplicitLod DeclSampledImageCase{"%result = OpImageSampleDrefImplicitLod " "%v4float %sampled_image %coords %depth", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_comparison } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __depth_texture_2d })", R"( Call[not set]{ Identifier[not set]{textureSampleCompare} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{0.200000} ) })"}, // ImageSampleDrefImplicitLod with ConstOffset DeclSampledImageCase{ "%result = OpImageSampleDrefImplicitLod %v4float " "%sampled_image %coords %depth ConstOffset %offsets2d", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_comparison } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __depth_texture_2d })", R"( Call[not set]{ Identifier[not set]{textureSampleCompare} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{0.200000} TypeConstructor[not set]{ __vec_2__i32 ScalarConstructor[not set]{3} ScalarConstructor[not set]{4} } ) })"} )); INSTANTIATE_TEST_SUITE_P( ImageSampleExplicitLod, SpvParserTest_DeclHandle_SampledImage, ::testing::Values( // OpImageSampleExplicitLod - using Lod DeclSampledImageCase{"%result = OpImageSampleExplicitLod " "%v4float %sampled_image %coords Lod %float_null", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __sampled_texture_2d__f32 })", R"( Call[not set]{ Identifier[not set]{textureSampleLevel} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{0.000000} ) })"}, // OpImageSampleExplicitLod - using Lod and ConstOffset // TODO(dneto) OpImageSampleExplicitLod - using Lod and unsigned // ConstOffset DeclSampledImageCase{"%result = OpImageSampleExplicitLod " "%v4float %sampled_image %coords Lod|ConstOffset " "%float_null %offsets2d", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __sampled_texture_2d__f32 })", R"( Call[not set]{ Identifier[not set]{textureSampleLevel} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{0.000000} TypeConstructor[not set]{ __vec_2__i32 ScalarConstructor[not set]{3} ScalarConstructor[not set]{4} } ) })"}, // OpImageSampleExplicitLod - using Grad DeclSampledImageCase{ "%result = OpImageSampleExplicitLod " "%v4float %sampled_image %coords Grad %float_7 %float_null", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __sampled_texture_2d__f32 })", R"( Call[not set]{ Identifier[not set]{textureSampleGrad} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{7.000000} ScalarConstructor[not set]{0.000000} ) })"}, // OpImageSampleExplicitLod - using Grad and ConstOffset // TODO(dneto): OpImageSampleExplicitLod - using Grad and unsigned // ConstOffset DeclSampledImageCase{"%result = OpImageSampleExplicitLod " "%v4float %sampled_image %coords Grad|ConstOffset " "%float_7 %float_null %offsets2d", R"( DecoratedVariable{ Decorations{ SetDecoration{0} BindingDecoration{0} } x_10 uniform_constant __sampler_sampler } DecoratedVariable{ Decorations{ SetDecoration{2} BindingDecoration{1} } x_20 uniform_constant __sampled_texture_2d__f32 })", R"( Call[not set]{ Identifier[not set]{textureSampleGrad} ( Identifier[not set]{x_20} Identifier[not set]{x_10} TypeConstructor[not set]{ __vec_2__f32 ScalarConstructor[not set]{0.000000} ScalarConstructor[not set]{0.000000} } ScalarConstructor[not set]{7.000000} ScalarConstructor[not set]{0.000000} TypeConstructor[not set]{ __vec_2__i32 ScalarConstructor[not set]{3} ScalarConstructor[not set]{4} } ) })"})); } // namespace } // namespace spirv } // namespace reader } // namespace tint