| // Copyright 2022 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 "src/tint/sem/materialize.h" |
| |
| #include "src/tint/resolver/resolver.h" |
| #include "src/tint/resolver/resolver_test_helper.h" |
| #include "src/tint/sem/test_helper.h" |
| |
| #include "gmock/gmock.h" |
| |
| using namespace tint::number_suffixes; // NOLINT |
| |
| namespace tint::resolver { |
| namespace { |
| |
| using AFloatV = builder::vec<3, AFloat>; |
| using AFloatM = builder::mat<3, 2, AFloat>; |
| using AIntV = builder::vec<3, AInt>; |
| using f32V = builder::vec<3, f32>; |
| using f16V = builder::vec<3, f16>; |
| using i32V = builder::vec<3, i32>; |
| using u32V = builder::vec<3, u32>; |
| using f32M = builder::mat<3, 2, f32>; |
| using i32Varr = builder::array<3, i32>; |
| |
| constexpr double kHighestU32 = static_cast<double>(u32::kHighest); |
| constexpr double kLowestU32 = static_cast<double>(u32::kLowest); |
| constexpr double kHighestI32 = static_cast<double>(i32::kHighest); |
| constexpr double kLowestI32 = static_cast<double>(i32::kLowest); |
| constexpr double kHighestF32 = static_cast<double>(f32::kHighest); |
| constexpr double kLowestF32 = static_cast<double>(f32::kLowest); |
| // constexpr double kHighestF16 = static_cast<double>(f16::kHighest); |
| // constexpr double kLowestF16 = static_cast<double>(f16::kLowest); |
| constexpr double kTooBigF32 = static_cast<double>(3.5e+38); |
| // constexpr double kTooBigF16 = static_cast<double>(6.6e+4); |
| constexpr double kPiF64 = 3.141592653589793; |
| constexpr double kPiF32 = 3.1415927410125732; // kPiF64 quantized to f32 |
| // constexpr double kPiF16 = 3.140625; // kPiF64 quantized to f16 |
| |
| constexpr double kSubnormalF32 = 0x1.0p-128; |
| // constexpr double kSubnormalF16 = 0x1.0p-16; |
| |
| enum class Expectation { |
| kMaterialize, |
| kNoMaterialize, |
| kInvalidConversion, |
| kValueCannotBeRepresented, |
| }; |
| |
| static std::ostream& operator<<(std::ostream& o, Expectation m) { |
| switch (m) { |
| case Expectation::kMaterialize: |
| return o << "materialize"; |
| case Expectation::kNoMaterialize: |
| return o << "no-materialize"; |
| case Expectation::kInvalidConversion: |
| return o << "invalid-conversion"; |
| case Expectation::kValueCannotBeRepresented: |
| return o << "value cannot be represented"; |
| } |
| return o << "<unknown>"; |
| } |
| |
| template <typename CASE> |
| class MaterializeTest : public resolver::ResolverTestWithParam<CASE> { |
| protected: |
| using ProgramBuilder::FriendlyName; |
| |
| void CheckTypesAndValues(const sem::Expression* expr, |
| const tint::sem::Type* expected_sem_ty, |
| const std::variant<AInt, AFloat>& expected_value) { |
| std::visit([&](auto v) { CheckTypesAndValuesImpl(expr, expected_sem_ty, v); }, |
| expected_value); |
| } |
| |
| private: |
| template <typename T> |
| void CheckTypesAndValuesImpl(const sem::Expression* expr, |
| const tint::sem::Type* expected_sem_ty, |
| T expected_value) { |
| EXPECT_TYPE(expr->Type(), expected_sem_ty); |
| |
| auto* value = expr->ConstantValue(); |
| ASSERT_NE(value, nullptr); |
| EXPECT_TYPE(expr->Type(), value->Type()); |
| |
| tint::Switch( |
| expected_sem_ty, // |
| [&](const sem::Vector* v) { |
| for (uint32_t i = 0; i < v->Width(); i++) { |
| auto* el = value->Index(i); |
| ASSERT_NE(el, nullptr); |
| EXPECT_TYPE(el->Type(), v->type()); |
| EXPECT_EQ(std::get<T>(el->Value()), expected_value); |
| } |
| }, |
| [&](const sem::Matrix* m) { |
| for (uint32_t c = 0; c < m->columns(); c++) { |
| auto* column = value->Index(c); |
| ASSERT_NE(column, nullptr); |
| EXPECT_TYPE(column->Type(), m->ColumnType()); |
| for (uint32_t r = 0; r < m->rows(); r++) { |
| auto* el = column->Index(r); |
| ASSERT_NE(el, nullptr); |
| EXPECT_TYPE(el->Type(), m->type()); |
| EXPECT_EQ(std::get<T>(el->Value()), expected_value); |
| } |
| } |
| }, |
| [&](Default) { EXPECT_EQ(std::get<T>(value->Value()), expected_value); }); |
| } |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // MaterializeAbstractNumericToConcreteType |
| // Tests that an abstract-numeric will materialize to the expected concrete type |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| namespace materialize_abstract_numeric_to_concrete_type { |
| // How should the materialization occur? |
| enum class Method { |
| // var a : target_type = abstract_expr; |
| kVar, |
| |
| // let a : target_type = abstract_expr; |
| kLet, |
| |
| // var a : target_type; |
| // a = abstract_expr; |
| kAssign, |
| |
| // _ = abstract_expr; |
| kPhonyAssign, |
| |
| // fn F(v : target_type) {} |
| // fn x() { |
| // F(abstract_expr); |
| // } |
| kFnArg, |
| |
| // min(target_expr, abstract_expr); |
| kBuiltinArg, |
| |
| // fn F() : target_type { |
| // return abstract_expr; |
| // } |
| kReturn, |
| |
| // array<target_type, 1>(abstract_expr); |
| kArray, |
| |
| // struct S { |
| // v : target_type |
| // }; |
| // fn x() { |
| // _ = S(abstract_expr) |
| // } |
| kStruct, |
| |
| // target_expr + abstract_expr |
| kBinaryOp, |
| |
| // switch (abstract_expr) { |
| // case target_expr: {} |
| // default: {} |
| // } |
| kSwitchCond, |
| |
| // switch (target_expr) { |
| // case abstract_expr: {} |
| // default: {} |
| // } |
| kSwitchCase, |
| |
| // switch (abstract_expr) { |
| // case 123: {} |
| // case target_expr: {} |
| // default: {} |
| // } |
| kSwitchCondWithAbstractCase, |
| |
| // switch (target_expr) { |
| // case 123: {} |
| // case abstract_expr: {} |
| // default: {} |
| // } |
| kSwitchCaseWithAbstractCase, |
| |
| // @workgroup_size(target_expr, abstract_expr, 123) |
| // @compute |
| // fn f() {} |
| kWorkgroupSize |
| }; |
| |
| static std::ostream& operator<<(std::ostream& o, Method m) { |
| switch (m) { |
| case Method::kVar: |
| return o << "var"; |
| case Method::kLet: |
| return o << "let"; |
| case Method::kAssign: |
| return o << "assign"; |
| case Method::kPhonyAssign: |
| return o << "phony-assign"; |
| case Method::kFnArg: |
| return o << "fn-arg"; |
| case Method::kBuiltinArg: |
| return o << "builtin-arg"; |
| case Method::kReturn: |
| return o << "return"; |
| case Method::kArray: |
| return o << "array"; |
| case Method::kStruct: |
| return o << "struct"; |
| case Method::kBinaryOp: |
| return o << "binary-op"; |
| case Method::kSwitchCond: |
| return o << "switch-cond"; |
| case Method::kSwitchCase: |
| return o << "switch-case"; |
| case Method::kSwitchCondWithAbstractCase: |
| return o << "switch-cond-with-abstract"; |
| case Method::kSwitchCaseWithAbstractCase: |
| return o << "switch-case-with-abstract"; |
| case Method::kWorkgroupSize: |
| return o << "workgroup-size"; |
| } |
| return o << "<unknown>"; |
| } |
| |
| struct Data { |
| std::string target_type_name; |
| std::string target_element_type_name; |
| builder::ast_type_func_ptr target_ast_ty; |
| builder::sem_type_func_ptr target_sem_ty; |
| builder::ast_expr_func_ptr target_expr; |
| std::string abstract_type_name; |
| builder::ast_expr_func_ptr abstract_expr; |
| std::variant<AInt, AFloat> materialized_value; |
| double literal_value; |
| }; |
| |
| template <typename TARGET_TYPE, typename ABSTRACT_TYPE, typename MATERIALIZED_TYPE> |
| Data Types(MATERIALIZED_TYPE materialized_value, double literal_value) { |
| using TargetDataType = builder::DataType<TARGET_TYPE>; |
| using AbstractDataType = builder::DataType<ABSTRACT_TYPE>; |
| using TargetElementDataType = builder::DataType<typename TargetDataType::ElementType>; |
| return { |
| TargetDataType::Name(), // target_type_name |
| TargetElementDataType::Name(), // target_element_type_name |
| TargetDataType::AST, // target_ast_ty |
| TargetDataType::Sem, // target_sem_ty |
| TargetDataType::Expr, // target_expr |
| AbstractDataType::Name(), // abstract_type_name |
| AbstractDataType::Expr, // abstract_expr |
| materialized_value, |
| literal_value, |
| }; |
| } |
| |
| template <typename TARGET_TYPE, typename ABSTRACT_TYPE> |
| Data Types() { |
| using TargetDataType = builder::DataType<TARGET_TYPE>; |
| using AbstractDataType = builder::DataType<ABSTRACT_TYPE>; |
| using TargetElementDataType = builder::DataType<typename TargetDataType::ElementType>; |
| return { |
| TargetDataType::Name(), // target_type_name |
| TargetElementDataType::Name(), // target_element_type_name |
| TargetDataType::AST, // target_ast_ty |
| TargetDataType::Sem, // target_sem_ty |
| TargetDataType::Expr, // target_expr |
| AbstractDataType::Name(), // abstract_type_name |
| AbstractDataType::Expr, // abstract_expr |
| 0_a, |
| 0.0, |
| }; |
| } |
| |
| static std::ostream& operator<<(std::ostream& o, const Data& c) { |
| auto print_value = [&](auto&& v) { o << v; }; |
| o << "[" << c.target_type_name << " <- " << c.abstract_type_name << "] ["; |
| std::visit(print_value, c.materialized_value); |
| o << " <- " << c.literal_value << "]"; |
| return o; |
| } |
| |
| using MaterializeAbstractNumericToConcreteType = |
| MaterializeTest<std::tuple<Expectation, Method, Data>>; |
| |
| TEST_P(MaterializeAbstractNumericToConcreteType, Test) { |
| // Once built-in and ops using f16 is properly supported, we'll need to enable this: |
| // Enable(ast::Extension::kF16); |
| |
| const auto& param = GetParam(); |
| const auto& expectation = std::get<0>(param); |
| const auto& method = std::get<1>(param); |
| const auto& data = std::get<2>(param); |
| |
| auto target_ty = [&] { return data.target_ast_ty(*this); }; |
| auto target_expr = [&] { return data.target_expr(*this, 42); }; |
| auto* abstract_expr = data.abstract_expr(*this, data.literal_value); |
| switch (method) { |
| case Method::kVar: |
| WrapInFunction(Decl(Var("a", target_ty(), abstract_expr))); |
| break; |
| case Method::kLet: |
| WrapInFunction(Decl(Let("a", target_ty(), abstract_expr))); |
| break; |
| case Method::kAssign: |
| WrapInFunction(Decl(Var("a", target_ty(), nullptr)), Assign("a", abstract_expr)); |
| break; |
| case Method::kPhonyAssign: |
| WrapInFunction(Assign(Phony(), abstract_expr)); |
| break; |
| case Method::kFnArg: |
| Func("F", {Param("P", target_ty())}, ty.void_(), {}); |
| WrapInFunction(CallStmt(Call("F", abstract_expr))); |
| break; |
| case Method::kBuiltinArg: |
| WrapInFunction(CallStmt(Call("min", target_expr(), abstract_expr))); |
| break; |
| case Method::kReturn: |
| Func("F", {}, target_ty(), {Return(abstract_expr)}); |
| break; |
| case Method::kArray: |
| WrapInFunction(Construct(ty.array(target_ty(), 1_i), abstract_expr)); |
| break; |
| case Method::kStruct: |
| Structure("S", {Member("v", target_ty())}); |
| WrapInFunction(Construct(ty.type_name("S"), abstract_expr)); |
| break; |
| case Method::kBinaryOp: |
| WrapInFunction(Add(target_expr(), abstract_expr)); |
| break; |
| case Method::kSwitchCond: |
| WrapInFunction(Switch(abstract_expr, // |
| Case(target_expr()->As<ast::IntLiteralExpression>()), // |
| DefaultCase())); |
| break; |
| case Method::kSwitchCase: |
| WrapInFunction(Switch(target_expr(), // |
| Case(abstract_expr->As<ast::IntLiteralExpression>()), // |
| DefaultCase())); |
| break; |
| case Method::kSwitchCondWithAbstractCase: |
| WrapInFunction(Switch(abstract_expr, // |
| Case(Expr(123_a)), // |
| Case(target_expr()->As<ast::IntLiteralExpression>()), // |
| DefaultCase())); |
| break; |
| case Method::kSwitchCaseWithAbstractCase: |
| WrapInFunction(Switch(target_expr(), // |
| Case(Expr(123_a)), // |
| Case(abstract_expr->As<ast::IntLiteralExpression>()), // |
| DefaultCase())); |
| break; |
| case Method::kWorkgroupSize: |
| Func("f", {}, ty.void_(), {}, |
| {WorkgroupSize(target_expr(), abstract_expr, Expr(123_a)), |
| Stage(ast::PipelineStage::kCompute)}); |
| break; |
| } |
| |
| switch (expectation) { |
| case Expectation::kMaterialize: { |
| ASSERT_TRUE(r()->Resolve()) << r()->error(); |
| auto* materialize = Sem().Get<sem::Materialize>(abstract_expr); |
| ASSERT_NE(materialize, nullptr); |
| CheckTypesAndValues(materialize, data.target_sem_ty(*this), data.materialized_value); |
| break; |
| } |
| case Expectation::kNoMaterialize: { |
| ASSERT_TRUE(r()->Resolve()) << r()->error(); |
| auto* sem = Sem().Get(abstract_expr); |
| ASSERT_NE(sem, nullptr); |
| EXPECT_FALSE(sem->Is<sem::Materialize>()); |
| CheckTypesAndValues(sem, data.target_sem_ty(*this), data.materialized_value); |
| break; |
| } |
| case Expectation::kInvalidConversion: { |
| ASSERT_FALSE(r()->Resolve()); |
| std::string expect; |
| switch (method) { |
| case Method::kBuiltinArg: |
| expect = "error: no matching call to min(" + data.target_type_name + ", " + |
| data.abstract_type_name + ")"; |
| break; |
| case Method::kBinaryOp: |
| expect = "error: no matching overload for operator + (" + |
| data.target_type_name + ", " + data.abstract_type_name + ")"; |
| break; |
| default: |
| expect = "error: cannot convert value of type '" + data.abstract_type_name + |
| "' to type '" + data.target_type_name + "'"; |
| break; |
| } |
| EXPECT_THAT(r()->error(), testing::StartsWith(expect)); |
| break; |
| } |
| case Expectation::kValueCannotBeRepresented: |
| ASSERT_FALSE(r()->Resolve()); |
| EXPECT_THAT(r()->error(), testing::HasSubstr("cannot be represented as '" + |
| data.target_element_type_name + "'")); |
| break; |
| } |
| } |
| |
| /// Methods that support scalar materialization |
| constexpr Method kScalarMethods[] = { |
| Method::kLet, Method::kVar, Method::kAssign, Method::kFnArg, Method::kBuiltinArg, |
| Method::kReturn, Method::kArray, Method::kStruct, Method::kBinaryOp, |
| }; |
| |
| /// Methods that support vector materialization |
| constexpr Method kVectorMethods[] = { |
| Method::kLet, Method::kVar, Method::kAssign, Method::kFnArg, Method::kBuiltinArg, |
| Method::kReturn, Method::kArray, Method::kStruct, Method::kBinaryOp, |
| }; |
| |
| /// Methods that support matrix materialization |
| constexpr Method kMatrixMethods[] = { |
| Method::kLet, Method::kVar, Method::kAssign, Method::kFnArg, |
| Method::kReturn, Method::kArray, Method::kStruct, Method::kBinaryOp, |
| }; |
| |
| /// Methods that support materialization for switch cases |
| constexpr Method kSwitchMethods[] = { |
| Method::kSwitchCond, |
| Method::kSwitchCase, |
| Method::kSwitchCondWithAbstractCase, |
| Method::kSwitchCaseWithAbstractCase, |
| }; |
| |
| /// Methods that do not materialize |
| constexpr Method kNoMaterializeMethods[] = { |
| Method::kPhonyAssign, |
| // TODO(crbug.com/tint/1504): Enable once we have abstract overloads of builtins / binary |
| // ops: Method::kBuiltinArg, Method::kBinaryOp, |
| }; |
| INSTANTIATE_TEST_SUITE_P( |
| MaterializeScalar, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::ValuesIn(kScalarMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, 0.0), // |
| Types<i32, AInt>(1_a, 1.0), // |
| Types<i32, AInt>(-1_a, -1.0), // |
| Types<i32, AInt>(AInt(kHighestI32), kHighestI32), // |
| Types<i32, AInt>(AInt(kLowestI32), kLowestI32), // |
| Types<u32, AInt>(0_a, 0.0), // |
| Types<u32, AInt>(1_a, 1.0), // |
| Types<u32, AInt>(AInt(kHighestU32), kHighestU32), // |
| Types<u32, AInt>(AInt(kLowestU32), kLowestU32), // |
| Types<f32, AFloat>(0.0_a, 0.0), // |
| Types<f32, AFloat>(AFloat(kHighestF32), kHighestF32), // |
| Types<f32, AFloat>(AFloat(kLowestF32), kLowestF32), // |
| Types<f32, AFloat>(AFloat(kPiF32), kPiF64), // |
| Types<f32, AFloat>(AFloat(kSubnormalF32), kSubnormalF32), // |
| Types<f32, AFloat>(AFloat(-kSubnormalF32), -kSubnormalF32), // |
| /* Types<f16, AFloat>(0.0_a, 0.0), */ // |
| /* Types<f16, AFloat>(1.0_a, 1.0), */ // |
| /* Types<f16, AFloat>(AFloat(kHighestF16), kHighestF16), */ // |
| /* Types<f16, AFloat>(AFloat(kLowestF16), kLowestF16), */ // |
| /* Types<f16, AFloat>(AFloat(kPiF16), kPiF64), */ // |
| /* Types<f16, AFloat>(AFloat(kSubnormalF16), kSubnormalF16), */ // |
| /* Types<f16, AFloat>(AFloat(-kSubnormalF16), -kSubnormalF16), */ // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| MaterializeVector, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::ValuesIn(kVectorMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32V, AIntV>(0_a, 0.0), // |
| Types<i32V, AIntV>(1_a, 1.0), // |
| Types<i32V, AIntV>(-1_a, -1.0), // |
| Types<i32V, AIntV>(AInt(kHighestI32), kHighestI32), // |
| Types<i32V, AIntV>(AInt(kLowestI32), kLowestI32), // |
| Types<u32V, AIntV>(0_a, 0.0), // |
| Types<u32V, AIntV>(1_a, 1.0), // |
| Types<u32V, AIntV>(AInt(kHighestU32), kHighestU32), // |
| Types<u32V, AIntV>(AInt(kLowestU32), kLowestU32), // |
| Types<f32V, AFloatV>(0.0_a, 0.0), // |
| Types<f32V, AFloatV>(1.0_a, 1.0), // |
| Types<f32V, AFloatV>(-1.0_a, -1.0), // |
| Types<f32V, AFloatV>(AFloat(kHighestF32), kHighestF32), // |
| Types<f32V, AFloatV>(AFloat(kLowestF32), kLowestF32), // |
| Types<f32V, AFloatV>(AFloat(kPiF32), kPiF64), // |
| Types<f32V, AFloatV>(AFloat(kSubnormalF32), kSubnormalF32), // |
| Types<f32V, AFloatV>(AFloat(-kSubnormalF32), -kSubnormalF32), // |
| /* Types<f16V, AFloatV>(0.0_a, 0.0), */ // |
| /* Types<f16V, AFloatV>(1.0_a, 1.0), */ // |
| /* Types<f16V, AFloatV>(-1.0_a, -1.0), */ // |
| /* Types<f16V, AFloatV>(AFloat(kHighestF16), kHighestF16), */ // |
| /* Types<f16V, AFloatV>(AFloat(kLowestF16), kLowestF16), */ // |
| /* Types<f16V, AFloatV>(AFloat(kPiF16), kPiF64), */ // |
| /* Types<f16V, AFloatV>(AFloat(kSubnormalF16), kSubnormalF16), */ // |
| /* Types<f16V, AFloatV>(AFloat(-kSubnormalF16), -kSubnormalF16), */ // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| MaterializeMatrix, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::ValuesIn(kMatrixMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<f32M, AFloatM>(0.0_a, 0.0), // |
| Types<f32M, AFloatM>(1.0_a, 1.0), // |
| Types<f32M, AFloatM>(-1.0_a, -1.0), // |
| Types<f32M, AFloatM>(AFloat(kHighestF32), kHighestF32), // |
| Types<f32M, AFloatM>(AFloat(kLowestF32), kLowestF32), // |
| Types<f32M, AFloatM>(AFloat(kPiF32), kPiF64), // |
| Types<f32M, AFloatM>(AFloat(kSubnormalF32), kSubnormalF32), // |
| Types<f32M, AFloatM>(AFloat(-kSubnormalF32), -kSubnormalF32), // |
| /* Types<f16M, AFloatM>(0.0_a, 0.0), */ // |
| /* Types<f16M, AFloatM>(1.0_a, 1.0), */ // |
| /* Types<f16M, AFloatM>(-1.0_a, -1.0), */ // |
| /* Types<f16M, AFloatM>(AFloat(kHighestF16), kHighestF16), */ // |
| /* Types<f16M, AFloatM>(AFloat(kLowestF16), kLowestF16), */ // |
| /* Types<f16M, AFloatM>(AFloat(kPiF16), kPiF64), */ // |
| /* Types<f16M, AFloatM>(AFloat(kSubnormalF16), kSubnormalF16), */ // |
| /* Types<f16M, AFloatM>(AFloat(-kSubnormalF16), -kSubnormalF16), */ // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(MaterializeSwitch, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::ValuesIn(kSwitchMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, 0.0), // |
| Types<i32, AInt>(1_a, 1.0), // |
| Types<i32, AInt>(-1_a, -1.0), // |
| Types<i32, AInt>(AInt(kHighestI32), kHighestI32), // |
| Types<i32, AInt>(AInt(kLowestI32), kLowestI32), // |
| Types<u32, AInt>(0_a, 0.0), // |
| Types<u32, AInt>(1_a, 1.0), // |
| Types<u32, AInt>(AInt(kHighestU32), kHighestU32), // |
| Types<u32, AInt>(AInt(kLowestU32), kLowestU32), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(MaterializeWorkgroupSize, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::Values(Method::kWorkgroupSize), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(1_a, 1.0), // |
| Types<i32, AInt>(10_a, 10.0), // |
| Types<i32, AInt>(65535_a, 65535.0), // |
| Types<u32, AInt>(1_a, 1.0), // |
| Types<u32, AInt>(10_a, 10.0), // |
| Types<u32, AInt>(65535_a, 65535.0), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(NoMaterialize, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kNoMaterialize), |
| testing::ValuesIn(kNoMaterializeMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<AInt, AInt>(1_a, 1_a), // |
| Types<AIntV, AIntV>(1_a, 1_a), // |
| Types<AFloat, AFloat>(1.0_a, 1.0_a), // |
| Types<AFloatV, AFloatV>(1.0_a, 1.0_a), // |
| Types<AFloatM, AFloatM>(1.0_a, 1.0_a), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(InvalidConversion, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kInvalidConversion), |
| testing::ValuesIn(kScalarMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AFloat>(), // |
| Types<u32, AFloat>(), // |
| Types<i32V, AFloatV>(), // |
| Types<u32V, AFloatV>(), // |
| Types<i32Varr, AInt>(), // |
| Types<i32Varr, AIntV>(), // |
| Types<i32Varr, AFloat>(), // |
| Types<i32Varr, AFloatV>(), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(ScalarValueCannotBeRepresented, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::ValuesIn(kScalarMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, kHighestI32 + 1), // |
| Types<i32, AInt>(0_a, kLowestI32 - 1), // |
| Types<u32, AInt>(0_a, kHighestU32 + 1), // |
| Types<u32, AInt>(0_a, kLowestU32 - 1), // |
| Types<f32, AFloat>(0.0_a, kTooBigF32), // |
| Types<f32, AFloat>(0.0_a, -kTooBigF32), // |
| /* Types<f16, AFloat>(0.0_a, kTooBigF16), */ // |
| /* Types<f16, AFloat>(0.0_a, -kTooBigF16), */ // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(VectorValueCannotBeRepresented, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::ValuesIn(kVectorMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32V, AIntV>(0_a, kHighestI32 + 1), // |
| Types<i32V, AIntV>(0_a, kLowestI32 - 1), // |
| Types<u32V, AIntV>(0_a, kHighestU32 + 1), // |
| Types<u32V, AIntV>(0_a, kLowestU32 - 1), // |
| Types<f32V, AFloatV>(0.0_a, kTooBigF32), // |
| Types<f32V, AFloatV>(0.0_a, -kTooBigF32), // |
| /* Types<f16V, AFloatV>(0.0_a, kTooBigF16), */ // |
| /* Types<f16V, AFloatV>(0.0_a, -kTooBigF16), */ // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(MatrixValueCannotBeRepresented, |
| MaterializeAbstractNumericToConcreteType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::ValuesIn(kMatrixMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<f32M, AFloatM>(0.0_a, kTooBigF32), // |
| Types<f32M, AFloatM>(0.0_a, -kTooBigF32), // |
| /* Types<f16M, AFloatM>(0.0_a, kTooBigF16), */ // |
| /* Types<f16M, AFloatM>(0.0_a, -kTooBigF16), */ // |
| }))); |
| |
| } // namespace materialize_abstract_numeric_to_concrete_type |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Tests that in the absence of a 'target type' an abstract-int will materialize to i32, and an |
| // abstract-float will materialize to f32. |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| namespace materialize_abstract_numeric_to_default_type { |
| |
| // How should the materialization occur? |
| enum class Method { |
| // var a = abstract_expr; |
| kVar, |
| |
| // let a = abstract_expr; |
| kLet, |
| |
| // min(abstract_expr, abstract_expr) |
| kBuiltinArg, |
| |
| // bitcast<f32>(abstract_expr) |
| kBitcastF32Arg, |
| |
| // bitcast<vec3<f32>>(abstract_expr) |
| kBitcastVec3F32Arg, |
| |
| // array<i32, abstract_expr>() |
| kArrayLength, |
| |
| // switch (abstract_expr) { |
| // case abstract_expr: {} |
| // default: {} |
| // } |
| kSwitch, |
| |
| // @workgroup_size(abstract_expr) |
| // @compute |
| // fn f() {} |
| kWorkgroupSize, |
| |
| // arr[abstract_expr] |
| kIndex, |
| }; |
| |
| static std::ostream& operator<<(std::ostream& o, Method m) { |
| switch (m) { |
| case Method::kVar: |
| return o << "var"; |
| case Method::kLet: |
| return o << "let"; |
| case Method::kBuiltinArg: |
| return o << "builtin-arg"; |
| case Method::kBitcastF32Arg: |
| return o << "bitcast-f32-arg"; |
| case Method::kBitcastVec3F32Arg: |
| return o << "bitcast-vec3-f32-arg"; |
| case Method::kArrayLength: |
| return o << "array-length"; |
| case Method::kSwitch: |
| return o << "switch"; |
| case Method::kWorkgroupSize: |
| return o << "workgroup-size"; |
| case Method::kIndex: |
| return o << "index"; |
| } |
| return o << "<unknown>"; |
| } |
| |
| struct Data { |
| std::string expected_type_name; |
| std::string expected_element_type_name; |
| builder::sem_type_func_ptr expected_sem_ty; |
| std::string abstract_type_name; |
| builder::ast_expr_func_ptr abstract_expr; |
| std::variant<AInt, AFloat> materialized_value; |
| double literal_value; |
| }; |
| |
| template <typename EXPECTED_TYPE, typename ABSTRACT_TYPE, typename MATERIALIZED_TYPE> |
| Data Types(MATERIALIZED_TYPE materialized_value, double literal_value) { |
| using ExpectedDataType = builder::DataType<EXPECTED_TYPE>; |
| using AbstractDataType = builder::DataType<ABSTRACT_TYPE>; |
| using TargetElementDataType = builder::DataType<typename ExpectedDataType::ElementType>; |
| return { |
| ExpectedDataType::Name(), // expected_type_name |
| TargetElementDataType::Name(), // expected_element_type_name |
| ExpectedDataType::Sem, // expected_sem_ty |
| AbstractDataType::Name(), // abstract_type_name |
| AbstractDataType::Expr, // abstract_expr |
| materialized_value, |
| literal_value, |
| }; |
| } |
| |
| static std::ostream& operator<<(std::ostream& o, const Data& c) { |
| auto print_value = [&](auto&& v) { o << v; }; |
| o << "[" << c.expected_type_name << " <- " << c.abstract_type_name << "] ["; |
| std::visit(print_value, c.materialized_value); |
| o << " <- " << c.literal_value << "]"; |
| return o; |
| } |
| |
| using MaterializeAbstractNumericToDefaultType = |
| MaterializeTest<std::tuple<Expectation, Method, Data>>; |
| |
| TEST_P(MaterializeAbstractNumericToDefaultType, Test) { |
| const auto& param = GetParam(); |
| const auto& expectation = std::get<0>(param); |
| const auto& method = std::get<1>(param); |
| const auto& data = std::get<2>(param); |
| |
| ast::ExpressionList abstract_exprs; |
| auto abstract_expr = [&] { |
| auto* expr = data.abstract_expr(*this, data.literal_value); |
| abstract_exprs.emplace_back(expr); |
| return expr; |
| }; |
| switch (method) { |
| case Method::kVar: |
| WrapInFunction(Decl(Var("a", nullptr, abstract_expr()))); |
| break; |
| case Method::kLet: |
| WrapInFunction(Decl(Let("a", nullptr, abstract_expr()))); |
| break; |
| case Method::kBuiltinArg: |
| WrapInFunction(CallStmt(Call("min", abstract_expr(), abstract_expr()))); |
| break; |
| case Method::kBitcastF32Arg: |
| WrapInFunction(Bitcast<f32>(abstract_expr())); |
| break; |
| case Method::kBitcastVec3F32Arg: |
| WrapInFunction(Bitcast(ty.vec3<f32>(), abstract_expr())); |
| break; |
| case Method::kArrayLength: |
| WrapInFunction(Construct(ty.array(ty.i32(), abstract_expr()))); |
| break; |
| case Method::kSwitch: |
| WrapInFunction(Switch(abstract_expr(), |
| Case(abstract_expr()->As<ast::IntLiteralExpression>()), |
| DefaultCase())); |
| break; |
| case Method::kWorkgroupSize: |
| Func("f", {}, ty.void_(), {}, |
| {WorkgroupSize(abstract_expr()), Stage(ast::PipelineStage::kCompute)}); |
| break; |
| case Method::kIndex: |
| GlobalVar("arr", ty.array<i32, 4>(), ast::StorageClass::kPrivate); |
| WrapInFunction(IndexAccessor("arr", abstract_expr())); |
| break; |
| } |
| |
| switch (expectation) { |
| case Expectation::kMaterialize: { |
| ASSERT_TRUE(r()->Resolve()) << r()->error(); |
| for (auto* expr : abstract_exprs) { |
| auto* materialize = Sem().Get<sem::Materialize>(expr); |
| ASSERT_NE(materialize, nullptr); |
| CheckTypesAndValues(materialize, data.expected_sem_ty(*this), |
| data.materialized_value); |
| } |
| break; |
| } |
| case Expectation::kInvalidConversion: { |
| ASSERT_FALSE(r()->Resolve()); |
| std::string expect; |
| switch (method) { |
| case Method::kBuiltinArg: |
| expect = "error: no matching call to min(" + data.abstract_type_name + ", " + |
| data.abstract_type_name + ")"; |
| break; |
| default: |
| expect = "error: cannot convert value of type '" + data.abstract_type_name + |
| "' to type '" + data.expected_type_name + "'"; |
| break; |
| } |
| EXPECT_THAT(r()->error(), testing::StartsWith(expect)); |
| break; |
| } |
| case Expectation::kValueCannotBeRepresented: |
| ASSERT_FALSE(r()->Resolve()); |
| EXPECT_THAT(r()->error(), testing::HasSubstr("cannot be represented as '" + |
| data.expected_element_type_name + "'")); |
| break; |
| default: |
| FAIL() << "unhandled expectation: " << expectation; |
| } |
| } |
| |
| /// Methods that support scalar materialization |
| constexpr Method kScalarMethods[] = { |
| Method::kLet, |
| Method::kVar, |
| Method::kBuiltinArg, |
| Method::kBitcastF32Arg, |
| }; |
| |
| /// Methods that support abstract-integer materialization |
| /// Note: Doesn't contain kWorkgroupSize or kArrayLength as they have tighter constraints on the |
| /// range of allowed integer values. |
| constexpr Method kAIntMethods[] = { |
| Method::kSwitch, |
| Method::kIndex, |
| }; |
| |
| /// Methods that support vector materialization |
| constexpr Method kVectorMethods[] = { |
| Method::kLet, |
| Method::kVar, |
| Method::kBuiltinArg, |
| Method::kBitcastVec3F32Arg, |
| }; |
| |
| /// Methods that support matrix materialization |
| constexpr Method kMatrixMethods[] = { |
| Method::kLet, |
| Method::kVar, |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| MaterializeScalar, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::ValuesIn(kScalarMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, 0.0), // |
| Types<i32, AInt>(1_a, 1.0), // |
| Types<i32, AInt>(-1_a, -1.0), // |
| Types<i32, AInt>(AInt(kHighestI32), kHighestI32), // |
| Types<i32, AInt>(AInt(kLowestI32), kLowestI32), // |
| Types<f32, AFloat>(0.0_a, 0.0), // |
| Types<f32, AFloat>(AFloat(kHighestF32), kHighestF32), // |
| Types<f32, AFloat>(AFloat(kLowestF32), kLowestF32), // |
| Types<f32, AFloat>(AFloat(kPiF32), kPiF64), // |
| Types<f32, AFloat>(AFloat(kSubnormalF32), kSubnormalF32), // |
| Types<f32, AFloat>(AFloat(-kSubnormalF32), -kSubnormalF32), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| MaterializeVector, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::ValuesIn(kVectorMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32V, AIntV>(0_a, 0.0), // |
| Types<i32V, AIntV>(1_a, 1.0), // |
| Types<i32V, AIntV>(-1_a, -1.0), // |
| Types<i32V, AIntV>(AInt(kHighestI32), kHighestI32), // |
| Types<i32V, AIntV>(AInt(kLowestI32), kLowestI32), // |
| Types<f32V, AFloatV>(0.0_a, 0.0), // |
| Types<f32V, AFloatV>(1.0_a, 1.0), // |
| Types<f32V, AFloatV>(-1.0_a, -1.0), // |
| Types<f32V, AFloatV>(AFloat(kHighestF32), kHighestF32), // |
| Types<f32V, AFloatV>(AFloat(kLowestF32), kLowestF32), // |
| Types<f32V, AFloatV>(AFloat(kPiF32), kPiF64), // |
| Types<f32V, AFloatV>(AFloat(kSubnormalF32), kSubnormalF32), // |
| Types<f32V, AFloatV>(AFloat(-kSubnormalF32), -kSubnormalF32), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| MaterializeMatrix, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::ValuesIn(kMatrixMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<f32M, AFloatM>(0.0_a, 0.0), // |
| Types<f32M, AFloatM>(1.0_a, 1.0), // |
| Types<f32M, AFloatM>(-1.0_a, -1.0), // |
| Types<f32M, AFloatM>(AFloat(kHighestF32), kHighestF32), // |
| Types<f32M, AFloatM>(AFloat(kLowestF32), kLowestF32), // |
| Types<f32M, AFloatM>(AFloat(kPiF32), kPiF64), // |
| Types<f32M, AFloatM>(AFloat(kSubnormalF32), kSubnormalF32), // |
| Types<f32M, AFloatM>(AFloat(-kSubnormalF32), -kSubnormalF32), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(MaterializeAInt, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::ValuesIn(kAIntMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, 0.0), // |
| Types<i32, AInt>(10_a, 10.0), // |
| Types<i32, AInt>(AInt(kHighestI32), kHighestI32), // |
| Types<i32, AInt>(AInt(kLowestI32), kLowestI32), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| MaterializeArrayLength, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::Values(Method::kArrayLength), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(1_a, 1.0), // |
| Types<i32, AInt>(10_a, 10.0), // |
| Types<i32, AInt>(1000_a, 1000.0), // |
| // Note: kHighestI32 cannot be used due to max-byte-size validation |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(MaterializeWorkgroupSize, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kMaterialize), |
| testing::Values(Method::kWorkgroupSize), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(1_a, 1.0), // |
| Types<i32, AInt>(10_a, 10.0), // |
| Types<i32, AInt>(65535_a, 65535.0), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(ScalarValueCannotBeRepresented, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::ValuesIn(kScalarMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, kHighestI32 + 1), // |
| Types<i32, AInt>(0_a, kLowestI32 - 1), // |
| Types<f32, AFloat>(0.0_a, kTooBigF32), // |
| Types<f32, AFloat>(0.0_a, -kTooBigF32), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(VectorValueCannotBeRepresented, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::ValuesIn(kVectorMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32V, AIntV>(0_a, kHighestI32 + 1), // |
| Types<i32V, AIntV>(0_a, kLowestI32 - 1), // |
| Types<i32V, AIntV>(0_a, kHighestU32 + 1), // |
| Types<f32V, AFloatV>(0.0_a, kTooBigF32), // |
| Types<f32V, AFloatV>(0.0_a, -kTooBigF32), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(MatrixValueCannotBeRepresented, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::ValuesIn(kMatrixMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<f32M, AFloatM>(0.0_a, kTooBigF32), // |
| Types<f32M, AFloatM>(0.0_a, -kTooBigF32), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(AIntValueCannotBeRepresented, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::ValuesIn(kAIntMethods), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, kHighestI32 + 1), // |
| Types<i32, AInt>(0_a, kLowestI32 - 1), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(WorkgroupSizeValueCannotBeRepresented, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::Values(Method::kWorkgroupSize), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, kHighestI32 + 1), // |
| Types<i32, AInt>(0_a, kLowestI32 - 1), // |
| }))); |
| |
| INSTANTIATE_TEST_SUITE_P(ArrayLengthValueCannotBeRepresented, |
| MaterializeAbstractNumericToDefaultType, |
| testing::Combine(testing::Values(Expectation::kValueCannotBeRepresented), |
| testing::Values(Method::kArrayLength), |
| testing::ValuesIn(std::vector<Data>{ |
| Types<i32, AInt>(0_a, kHighestI32 + 1), // |
| }))); |
| |
| } // namespace materialize_abstract_numeric_to_default_type |
| |
| using MaterializeAbstractNumericToUnrelatedType = resolver::ResolverTest; |
| |
| TEST_F(MaterializeAbstractNumericToUnrelatedType, AIntToStructVarCtor) { |
| Structure("S", {Member("a", ty.i32())}); |
| WrapInFunction(Decl(Var("v", ty.type_name("S"), Expr(Source{{12, 34}}, 1_a)))); |
| ASSERT_FALSE(r()->Resolve()); |
| EXPECT_THAT( |
| r()->error(), |
| testing::HasSubstr("error: cannot convert value of type 'abstract-int' to type 'S'")); |
| } |
| |
| TEST_F(MaterializeAbstractNumericToUnrelatedType, AIntToStructLetCtor) { |
| Structure("S", {Member("a", ty.i32())}); |
| WrapInFunction(Decl(Let("v", ty.type_name("S"), Expr(Source{{12, 34}}, 1_a)))); |
| ASSERT_FALSE(r()->Resolve()); |
| EXPECT_THAT( |
| r()->error(), |
| testing::HasSubstr("error: cannot convert value of type 'abstract-int' to type 'S'")); |
| } |
| |
| } // namespace |
| } // namespace tint::resolver |
