encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-06-11 00:53:41 +00:00
Code Issues Packages Projects Releases Wiki Activity
dawn-cmake/src/reader/spirv/parser_impl_handle_test.cc
David Neto 3ec71a63aa spirv-reader: test textureSample with depth texture 
Bug: tint:109
Change-Id: Ia13940b521229012a7c73fe0896e6ea75c4b1307
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34020
Commit-Queue: David Neto <dneto@google.com>
Auto-Submit: David Neto <dneto@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
2020-11-26 16:58:02 +00:00

1808 lines
60 KiB
C++
Raw Blame History

// 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 <string>
#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<UsageSampledImageCase>>;
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<UsageRawImageCase>>;
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<DeclUnderspecifiedHandleCase>>;
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<DeclSampledImageCase>>;
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<DeclSampledImageCase>{
// 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<DeclSampledImageCase>{
// 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
Reference in New Issue View Git Blame Copy Permalink