| // 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 <memory> |
| |
| #include "gtest/gtest.h" |
| #include "src/ast/call_expression.h" |
| #include "src/ast/float_literal.h" |
| #include "src/ast/identifier_expression.h" |
| #include "src/ast/scalar_constructor_expression.h" |
| #include "src/ast/sint_literal.h" |
| #include "src/ast/type/bool_type.h" |
| #include "src/ast/type/depth_texture_type.h" |
| #include "src/ast/type/f32_type.h" |
| #include "src/ast/type/i32_type.h" |
| #include "src/ast/type/matrix_type.h" |
| #include "src/ast/type/multisampled_texture_type.h" |
| #include "src/ast/type/sampled_texture_type.h" |
| #include "src/ast/type/sampler_type.h" |
| #include "src/ast/type/u32_type.h" |
| #include "src/ast/type/vector_type.h" |
| #include "src/ast/type_constructor_expression.h" |
| #include "src/ast/variable.h" |
| #include "src/context.h" |
| #include "src/type_determiner.h" |
| #include "src/writer/spirv/builder.h" |
| #include "src/writer/spirv/spv_dump.h" |
| |
| namespace tint { |
| namespace writer { |
| namespace spirv { |
| namespace { |
| |
| using BuilderTest = testing::Test; |
| |
| struct IntrinsicData { |
| std::string name; |
| std::string op; |
| }; |
| inline std::ostream& operator<<(std::ostream& out, IntrinsicData data) { |
| out << data.name; |
| return out; |
| } |
| |
| using IntrinsicBoolTest = testing::TestWithParam<IntrinsicData>; |
| TEST_P(IntrinsicBoolTest, Call_Bool) { |
| auto param = GetParam(); |
| |
| ast::type::BoolType bool_type; |
| ast::type::VectorType vec3(&bool_type, 3); |
| |
| auto var = |
| std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &vec3); |
| |
| ast::ExpressionList params; |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v")); |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>(param.name), |
| std::move(params)); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| td.RegisterVariableForTesting(var.get()); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| |
| Builder b(&mod); |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error(); |
| |
| EXPECT_EQ(b.GenerateCallExpression(&expr), 6u) << b.error(); |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeBool |
| %3 = OpTypeVector %4 3 |
| %2 = OpTypePointer Private %3 |
| %5 = OpConstantNull %3 |
| %1 = OpVariable %2 Private %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %6 = )" + param.op + |
| " %4 %7\n"); |
| } |
| INSTANTIATE_TEST_SUITE_P(BuilderTest, |
| IntrinsicBoolTest, |
| testing::Values(IntrinsicData{"any", "OpAny"}, |
| IntrinsicData{"all", "OpAll"})); |
| |
| using IntrinsicFloatTest = testing::TestWithParam<IntrinsicData>; |
| TEST_P(IntrinsicFloatTest, Call_Float_Scalar) { |
| auto param = GetParam(); |
| |
| ast::type::F32Type f32; |
| |
| auto var = |
| std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &f32); |
| |
| ast::ExpressionList params; |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v")); |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>(param.name), |
| std::move(params)); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| td.RegisterVariableForTesting(var.get()); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| |
| Builder b(&mod); |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error(); |
| |
| EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error(); |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32 |
| %2 = OpTypePointer Private %3 |
| %4 = OpConstantNull %3 |
| %1 = OpVariable %2 Private %4 |
| %6 = OpTypeBool |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %5 = )" + param.op + |
| " %6 %7\n"); |
| } |
| |
| TEST_P(IntrinsicFloatTest, Call_Float_Vector) { |
| auto param = GetParam(); |
| |
| ast::type::F32Type f32; |
| ast::type::VectorType vec3(&f32, 3); |
| |
| auto var = |
| std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &vec3); |
| |
| ast::ExpressionList params; |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v")); |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>(param.name), |
| std::move(params)); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| td.RegisterVariableForTesting(var.get()); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| |
| Builder b(&mod); |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error(); |
| |
| EXPECT_EQ(b.GenerateCallExpression(&expr), 6u) << b.error(); |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeVector %4 3 |
| %2 = OpTypePointer Private %3 |
| %5 = OpConstantNull %3 |
| %1 = OpVariable %2 Private %5 |
| %8 = OpTypeBool |
| %7 = OpTypeVector %8 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%9 = OpLoad %3 %1 |
| %6 = )" + param.op + |
| " %7 %9\n"); |
| } |
| INSTANTIATE_TEST_SUITE_P(BuilderTest, |
| IntrinsicFloatTest, |
| testing::Values(IntrinsicData{"isNan", "OpIsNan"}, |
| IntrinsicData{"isInf", "OpIsInf"})); |
| |
| TEST_F(BuilderTest, Call_Dot) { |
| ast::type::F32Type f32; |
| ast::type::VectorType vec3(&f32, 3); |
| |
| auto var = |
| std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &vec3); |
| |
| ast::ExpressionList params; |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v")); |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v")); |
| ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>("dot"), |
| std::move(params)); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| td.RegisterVariableForTesting(var.get()); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| |
| Builder b(&mod); |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error(); |
| |
| EXPECT_EQ(b.GenerateCallExpression(&expr), 6u) << b.error(); |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeVector %4 3 |
| %2 = OpTypePointer Private %3 |
| %5 = OpConstantNull %3 |
| %1 = OpVariable %2 Private %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %8 = OpLoad %3 %1 |
| %6 = OpDot %4 %7 %8 |
| )"); |
| } |
| |
| using IntrinsicDeriveTest = testing::TestWithParam<IntrinsicData>; |
| TEST_P(IntrinsicDeriveTest, Call_Derivative_Scalar) { |
| auto param = GetParam(); |
| |
| ast::type::F32Type f32; |
| |
| auto var = |
| std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &f32); |
| |
| ast::ExpressionList params; |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v")); |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>(param.name), |
| std::move(params)); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| td.RegisterVariableForTesting(var.get()); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| |
| Builder b(&mod); |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error(); |
| |
| EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error(); |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32 |
| %2 = OpTypePointer Private %3 |
| %4 = OpConstantNull %3 |
| %1 = OpVariable %2 Private %4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%6 = OpLoad %3 %1 |
| %5 = )" + param.op + |
| " %3 %6\n"); |
| } |
| |
| TEST_P(IntrinsicDeriveTest, Call_Derivative_Vector) { |
| auto param = GetParam(); |
| |
| ast::type::F32Type f32; |
| ast::type::VectorType vec3(&f32, 3); |
| |
| auto var = |
| std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &vec3); |
| |
| ast::ExpressionList params; |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v")); |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>(param.name), |
| std::move(params)); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| td.RegisterVariableForTesting(var.get()); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| |
| Builder b(&mod); |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error(); |
| |
| EXPECT_EQ(b.GenerateCallExpression(&expr), 6u) << b.error(); |
| |
| if (param.name != "dpdx" && param.name != "dpdy" && param.name != "fwidth") { |
| EXPECT_EQ(DumpInstructions(b.capabilities()), |
| R"(OpCapability DerivativeControl |
| )"); |
| } |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeVector %4 3 |
| %2 = OpTypePointer Private %3 |
| %5 = OpConstantNull %3 |
| %1 = OpVariable %2 Private %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %6 = )" + param.op + |
| " %3 %7\n"); |
| } |
| INSTANTIATE_TEST_SUITE_P( |
| BuilderTest, |
| IntrinsicDeriveTest, |
| testing::Values(IntrinsicData{"dpdx", "OpDPdx"}, |
| IntrinsicData{"dpdxFine", "OpDPdxFine"}, |
| IntrinsicData{"dpdxCoarse", "OpDPdxCoarse"}, |
| IntrinsicData{"dpdy", "OpDPdy"}, |
| IntrinsicData{"dpdyFine", "OpDPdyFine"}, |
| IntrinsicData{"dpdyCoarse", "OpDPdyCoarse"}, |
| IntrinsicData{"fwidth", "OpFwidth"}, |
| IntrinsicData{"fwidthFine", "OpFwidthFine"}, |
| IntrinsicData{"fwidthCoarse", "OpFwidthCoarse"})); |
| |
| TEST_F(BuilderTest, Call_OuterProduct) { |
| ast::type::F32Type f32; |
| ast::type::VectorType vec2(&f32, 2); |
| ast::type::VectorType vec3(&f32, 3); |
| ast::type::MatrixType mat(&f32, 2, 3); |
| |
| auto v2 = |
| std::make_unique<ast::Variable>("v2", ast::StorageClass::kPrivate, &vec2); |
| auto v3 = |
| std::make_unique<ast::Variable>("v3", ast::StorageClass::kPrivate, &vec3); |
| |
| ast::ExpressionList params; |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v2")); |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v3")); |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("outerProduct"), |
| std::move(params)); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| td.RegisterVariableForTesting(v2.get()); |
| td.RegisterVariableForTesting(v3.get()); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| |
| Builder b(&mod); |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateGlobalVariable(v2.get())) << b.error(); |
| ASSERT_TRUE(b.GenerateGlobalVariable(v3.get())) << b.error(); |
| |
| EXPECT_EQ(b.GenerateCallExpression(&expr), 10u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeVector %4 2 |
| %2 = OpTypePointer Private %3 |
| %5 = OpConstantNull %3 |
| %1 = OpVariable %2 Private %5 |
| %8 = OpTypeVector %4 3 |
| %7 = OpTypePointer Private %8 |
| %9 = OpConstantNull %8 |
| %6 = OpVariable %7 Private %9 |
| %11 = OpTypeMatrix %3 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%12 = OpLoad %3 %1 |
| %13 = OpLoad %8 %6 |
| %10 = OpOuterProduct %11 %12 %13 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_Select) { |
| ast::type::F32Type f32; |
| ast::type::BoolType bool_type; |
| ast::type::VectorType bool_vec3(&bool_type, 3); |
| ast::type::VectorType vec3(&f32, 3); |
| |
| auto v3 = |
| std::make_unique<ast::Variable>("v3", ast::StorageClass::kPrivate, &vec3); |
| auto bool_v3 = std::make_unique<ast::Variable>( |
| "bool_v3", ast::StorageClass::kPrivate, &bool_vec3); |
| |
| ast::ExpressionList params; |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v3")); |
| params.push_back(std::make_unique<ast::IdentifierExpression>("v3")); |
| params.push_back(std::make_unique<ast::IdentifierExpression>("bool_v3")); |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("select"), std::move(params)); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| td.RegisterVariableForTesting(v3.get()); |
| td.RegisterVariableForTesting(bool_v3.get()); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| |
| Builder b(&mod); |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateGlobalVariable(v3.get())) << b.error(); |
| ASSERT_TRUE(b.GenerateGlobalVariable(bool_v3.get())) << b.error(); |
| |
| EXPECT_EQ(b.GenerateCallExpression(&expr), 11u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeVector %4 3 |
| %2 = OpTypePointer Private %3 |
| %5 = OpConstantNull %3 |
| %1 = OpVariable %2 Private %5 |
| %9 = OpTypeBool |
| %8 = OpTypeVector %9 3 |
| %7 = OpTypePointer Private %8 |
| %10 = OpConstantNull %8 |
| %6 = OpVariable %7 Private %10 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%12 = OpLoad %3 %1 |
| %13 = OpLoad %3 %1 |
| %14 = OpLoad %8 %6 |
| %11 = OpSelect %3 %12 %13 %14 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureLoad_Storage_RO_1d) { |
| ast::type::F32Type f32; |
| ast::type::I32Type i32; |
| ast::type::StorageTextureType s(ast::type::TextureDimension::k1d, |
| ast::type::StorageAccess::kRead, |
| ast::type::ImageFormat::kR16Float); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| ASSERT_TRUE(td.DetermineStorageTextureSubtype(&s)) << td.error(); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::SintLiteral>(&i32, 2))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureLoad"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 1D 0 0 0 2 R16f |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %6 = OpTypeVector %4 4 |
| %8 = OpConstant %4 1 |
| %9 = OpTypeInt 32 1 |
| %10 = OpConstant %9 2 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %5 = OpImageRead %6 %7 %8 Lod %10 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureLoad_Storage_RO_2d) { |
| ast::type::F32Type f32; |
| ast::type::I32Type i32; |
| ast::type::VectorType vec2(&f32, 2); |
| ast::type::StorageTextureType s(ast::type::TextureDimension::k2d, |
| ast::type::StorageAccess::kRead, |
| ast::type::ImageFormat::kR16Float); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| ASSERT_TRUE(td.DetermineStorageTextureSubtype(&s)) << td.error(); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::ExpressionList vals; |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::SintLiteral>(&i32, 2))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureLoad"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 2D 0 0 0 2 R16f |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %6 = OpTypeVector %4 4 |
| %8 = OpTypeVector %4 2 |
| %9 = OpConstant %4 1 |
| %10 = OpConstant %4 2 |
| %11 = OpConstantComposite %8 %9 %10 |
| %12 = OpTypeInt 32 1 |
| %13 = OpConstant %12 2 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %5 = OpImageRead %6 %7 %11 Lod %13 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureLoad_Sampled_1d) { |
| ast::type::F32Type f32; |
| ast::type::I32Type i32; |
| ast::type::SampledTextureType s(ast::type::TextureDimension::k1d, &f32); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::SintLiteral>(&i32, 2))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureLoad"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 1D 0 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %6 = OpTypeVector %4 4 |
| %8 = OpConstant %4 1 |
| %9 = OpTypeInt 32 1 |
| %10 = OpConstant %9 2 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %5 = OpImageFetch %6 %7 %8 Lod %10 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureLoad_Sampled_2d) { |
| ast::type::F32Type f32; |
| ast::type::I32Type i32; |
| ast::type::VectorType vec2(&f32, 2); |
| ast::type::SampledTextureType s(ast::type::TextureDimension::k2d, &f32); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::ExpressionList vals; |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::SintLiteral>(&i32, 2))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureLoad"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 2D 0 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %6 = OpTypeVector %4 4 |
| %8 = OpTypeVector %4 2 |
| %9 = OpConstant %4 1 |
| %10 = OpConstant %4 2 |
| %11 = OpConstantComposite %8 %9 %10 |
| %12 = OpTypeInt 32 1 |
| %13 = OpConstant %12 2 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %5 = OpImageFetch %6 %7 %11 Lod %13 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureLoad_Multisampled_2d) { |
| ast::type::F32Type f32; |
| ast::type::I32Type i32; |
| ast::type::VectorType vec2(&f32, 2); |
| ast::type::MultisampledTextureType s(ast::type::TextureDimension::k2d, &f32); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::ExpressionList vals; |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::SintLiteral>(&i32, 2))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureLoad"), |
| std::move(call_params)); |
| |
| ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 2D 0 0 1 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %6 = OpTypeVector %4 4 |
| %8 = OpTypeVector %4 2 |
| %9 = OpConstant %4 1 |
| %10 = OpConstant %4 2 |
| %11 = OpConstantComposite %8 %9 %10 |
| %12 = OpTypeInt 32 1 |
| %13 = OpConstant %12 2 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %5 = OpImageFetch %6 %7 %11 Sample %13 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureSample_1d) { |
| ast::type::F32Type f32; |
| |
| ast::type::SamplerType s(ast::type::SamplerKind::kSampler); |
| ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, &s); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &t); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::Variable sampler("sampler", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&sampler); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&sampler)) << b.error(); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureSample"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 7u) << b.error(); |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeSampler |
| %3 = OpTypeImage %4 1D 0 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %6 = OpTypePointer Private %4 |
| %5 = OpVariable %6 Private |
| %8 = OpTypeVector %4 4 |
| %11 = OpTypeFloat 32 |
| %12 = OpConstant %11 1 |
| %13 = OpTypeSampledImage %3 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%9 = OpLoad %3 %1 |
| %10 = OpLoad %4 %5 |
| %14 = OpSampledImage %13 %9 %10 |
| %7 = OpImageSampleImplicitLod %8 %14 %12 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureSample_2d) { |
| ast::type::F32Type f32; |
| ast::type::VectorType vec2(&f32, 2); |
| |
| ast::type::SamplerType s(ast::type::SamplerKind::kSampler); |
| ast::type::SampledTextureType t(ast::type::TextureDimension::k2d, &s); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &t); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::Variable sampler("sampler", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&sampler); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&sampler)) << b.error(); |
| |
| ast::ExpressionList vals; |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureSample"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 7u) << b.error(); |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeSampler |
| %3 = OpTypeImage %4 2D 0 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %6 = OpTypePointer Private %4 |
| %5 = OpVariable %6 Private |
| %8 = OpTypeVector %4 4 |
| %12 = OpTypeFloat 32 |
| %11 = OpTypeVector %12 2 |
| %13 = OpConstant %12 1 |
| %14 = OpConstant %12 2 |
| %15 = OpConstantComposite %11 %13 %14 |
| %16 = OpTypeSampledImage %3 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%9 = OpLoad %3 %1 |
| %10 = OpLoad %4 %5 |
| %17 = OpSampledImage %16 %9 %10 |
| %7 = OpImageSampleImplicitLod %8 %17 %15 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureSampleLevel_1d) { |
| ast::type::F32Type f32; |
| |
| ast::type::SamplerType s(ast::type::SamplerKind::kSampler); |
| ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, &f32); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &t); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::Variable sampler("sampler", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&sampler); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&sampler)) << b.error(); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureSampleLevel"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 1D 0 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %7 = OpTypeSampler |
| %6 = OpTypePointer Private %7 |
| %5 = OpVariable %6 Private |
| %9 = OpTypeVector %4 4 |
| %12 = OpConstant %4 1 |
| %13 = OpConstant %4 2 |
| %14 = OpTypeSampledImage %3 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%10 = OpLoad %3 %1 |
| %11 = OpLoad %7 %5 |
| %15 = OpSampledImage %14 %10 %11 |
| %8 = OpImageSampleExplicitLod %9 %15 %12 Lod %13 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureSampleLevel_2d) { |
| ast::type::F32Type f32; |
| ast::type::VectorType vec2(&f32, 2); |
| |
| ast::type::SamplerType s(ast::type::SamplerKind::kSampler); |
| ast::type::SampledTextureType t(ast::type::TextureDimension::k2d, &f32); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &t); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::Variable sampler("sampler", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&sampler); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&sampler)) << b.error(); |
| |
| ast::ExpressionList vals; |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureSampleLevel"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 2D 0 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %7 = OpTypeSampler |
| %6 = OpTypePointer Private %7 |
| %5 = OpVariable %6 Private |
| %9 = OpTypeVector %4 4 |
| %12 = OpTypeVector %4 2 |
| %13 = OpConstant %4 1 |
| %14 = OpConstant %4 2 |
| %15 = OpConstantComposite %12 %13 %14 |
| %16 = OpTypeSampledImage %3 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%10 = OpLoad %3 %1 |
| %11 = OpLoad %7 %5 |
| %17 = OpSampledImage %16 %10 %11 |
| %8 = OpImageSampleExplicitLod %9 %17 %15 Lod %14 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureSampleBias_1d) { |
| ast::type::F32Type f32; |
| |
| ast::type::SamplerType s(ast::type::SamplerKind::kSampler); |
| ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, &f32); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &t); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::Variable sampler("sampler", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&sampler); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&sampler)) << b.error(); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureSampleBias"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 1D 0 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %7 = OpTypeSampler |
| %6 = OpTypePointer Private %7 |
| %5 = OpVariable %6 Private |
| %9 = OpTypeVector %4 4 |
| %12 = OpConstant %4 1 |
| %13 = OpConstant %4 2 |
| %14 = OpTypeSampledImage %3 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%10 = OpLoad %3 %1 |
| %11 = OpLoad %7 %5 |
| %15 = OpSampledImage %14 %10 %11 |
| %8 = OpImageSampleImplicitLod %9 %15 %12 Bias %13 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureSampleBias_2d) { |
| ast::type::F32Type f32; |
| ast::type::VectorType vec2(&f32, 2); |
| |
| ast::type::SamplerType s(ast::type::SamplerKind::kSampler); |
| ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, &f32); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &t); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::Variable sampler("sampler", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&sampler); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&sampler)) << b.error(); |
| |
| ast::ExpressionList vals; |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureSampleBias"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 1D 0 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %7 = OpTypeSampler |
| %6 = OpTypePointer Private %7 |
| %5 = OpVariable %6 Private |
| %9 = OpTypeVector %4 4 |
| %12 = OpTypeVector %4 2 |
| %13 = OpConstant %4 1 |
| %14 = OpConstant %4 2 |
| %15 = OpConstantComposite %12 %13 %14 |
| %16 = OpTypeSampledImage %3 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%10 = OpLoad %3 %1 |
| %11 = OpLoad %7 %5 |
| %17 = OpSampledImage %16 %10 %11 |
| %8 = OpImageSampleImplicitLod %9 %17 %15 Bias %14 |
| )"); |
| } |
| |
| TEST_F(BuilderTest, Call_TextureSampleCompare) { |
| ast::type::F32Type f32; |
| ast::type::VectorType vec2(&f32, 2); |
| |
| ast::type::SamplerType s(ast::type::SamplerKind::kComparisonSampler); |
| ast::type::DepthTextureType t(ast::type::TextureDimension::k2d); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &t); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::Variable sampler("sampler", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&sampler); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&sampler)) << b.error(); |
| |
| ast::ExpressionList vals; |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::CallExpression expr( |
| std::make_unique<ast::IdentifierExpression>("textureSampleCompare"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); |
| EXPECT_EQ(DumpInstructions(b.types()), |
| R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 2D 1 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %7 = OpTypeSampler |
| %6 = OpTypePointer Private %7 |
| %5 = OpVariable %6 Private |
| %11 = OpTypeVector %4 2 |
| %12 = OpConstant %4 1 |
| %13 = OpConstant %4 2 |
| %14 = OpConstantComposite %11 %12 %13 |
| %15 = OpTypeSampledImage %3 |
| %17 = OpConstant %4 0 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%9 = OpLoad %3 %1 |
| %10 = OpLoad %7 %5 |
| %16 = OpSampledImage %15 %9 %10 |
| %8 = OpImageSampleDrefExplicitLod %4 %16 %14 %13 Lod %17 |
| )"); |
| } |
| |
| // This tests that we do not push OpTypeSampledImage and float_0 type twice. |
| TEST_F(BuilderTest, Call_TextureSampleCompare_Twice) { |
| ast::type::F32Type f32; |
| ast::type::VectorType vec2(&f32, 2); |
| |
| ast::type::SamplerType s(ast::type::SamplerKind::kComparisonSampler); |
| ast::type::DepthTextureType t(ast::type::TextureDimension::k2d); |
| |
| Context ctx; |
| ast::Module mod; |
| TypeDeterminer td(&ctx, &mod); |
| Builder b(&mod); |
| |
| b.push_function(Function{}); |
| |
| ast::Variable tex("texture", ast::StorageClass::kNone, &t); |
| td.RegisterVariableForTesting(&tex); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&tex)) << b.error(); |
| |
| ast::Variable sampler("sampler", ast::StorageClass::kNone, &s); |
| td.RegisterVariableForTesting(&sampler); |
| ASSERT_TRUE(b.GenerateGlobalVariable(&sampler)) << b.error(); |
| |
| ast::ExpressionList vals; |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::ExpressionList call_params; |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::CallExpression expr1( |
| std::make_unique<ast::IdentifierExpression>("textureSampleCompare"), |
| std::move(call_params)); |
| |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 1.0))); |
| vals.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("texture")); |
| call_params.push_back(std::make_unique<ast::IdentifierExpression>("sampler")); |
| call_params.push_back( |
| std::make_unique<ast::TypeConstructorExpression>(&vec2, std::move(vals))); |
| call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>( |
| std::make_unique<ast::FloatLiteral>(&f32, 2.0))); |
| |
| ast::CallExpression expr2( |
| std::make_unique<ast::IdentifierExpression>("textureSampleCompare"), |
| std::move(call_params)); |
| |
| EXPECT_TRUE(td.DetermineResultType(&expr1)) << td.error(); |
| EXPECT_TRUE(td.DetermineResultType(&expr2)) << td.error(); |
| |
| EXPECT_EQ(b.GenerateExpression(&expr1), 8u) << b.error(); |
| EXPECT_EQ(b.GenerateExpression(&expr2), 18u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32 |
| %3 = OpTypeImage %4 2D 1 0 0 1 Unknown |
| %2 = OpTypePointer Private %3 |
| %1 = OpVariable %2 Private |
| %7 = OpTypeSampler |
| %6 = OpTypePointer Private %7 |
| %5 = OpVariable %6 Private |
| %11 = OpTypeVector %4 2 |
| %12 = OpConstant %4 1 |
| %13 = OpConstant %4 2 |
| %14 = OpConstantComposite %11 %12 %13 |
| %15 = OpTypeSampledImage %3 |
| %17 = OpConstant %4 0 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%9 = OpLoad %3 %1 |
| %10 = OpLoad %7 %5 |
| %16 = OpSampledImage %15 %9 %10 |
| %8 = OpImageSampleDrefExplicitLod %4 %16 %14 %13 Lod %17 |
| %19 = OpLoad %3 %1 |
| %20 = OpLoad %7 %5 |
| %21 = OpSampledImage %15 %19 %20 |
| %18 = OpImageSampleDrefExplicitLod %4 %21 %14 %13 Lod %17 |
| )"); |
| } |
| |
| } // namespace |
| } // namespace spirv |
| } // namespace writer |
| } // namespace tint |