| // Copyright 2021 The Dawn & Tint Authors | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are met: | |
| // | |
| // 1. Redistributions of source code must retain the above copyright notice, this | |
| // list of conditions and the following disclaimer. | |
| // | |
| // 2. Redistributions in binary form must reproduce the above copyright notice, | |
| // this list of conditions and the following disclaimer in the documentation | |
| // and/or other materials provided with the distribution. | |
| // | |
| // 3. Neither the name of the copyright holder nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| #include <functional> | |
| #include "src/tint/lang/core/builtin_value.h" | |
| #include "src/tint/lang/wgsl/ast/call_statement.h" | |
| #include "src/tint/lang/wgsl/extension.h" | |
| #include "src/tint/lang/wgsl/resolver/resolver_helper_test.h" | |
| #include "src/tint/utils/text/string_stream.h" | |
| namespace tint::resolver { | |
| namespace { | |
| using namespace tint::core::fluent_types; // NOLINT | |
| using namespace tint::core::number_suffixes; // NOLINT | |
| template <typename T> | |
| using DataType = builder::DataType<T>; | |
| class ResolverBuiltinsValidationTest : public resolver::TestHelper, public testing::Test {}; | |
| namespace StageTest { | |
| struct Params { | |
| builder::ast_type_func_ptr type; | |
| core::BuiltinValue builtin; | |
| ast::PipelineStage stage; | |
| bool is_valid; | |
| }; | |
| template <typename T> | |
| constexpr Params ParamsFor(core::BuiltinValue builtin, ast::PipelineStage stage, bool is_valid) { | |
| return Params{DataType<T>::AST, builtin, stage, is_valid}; | |
| } | |
| static constexpr Params cases[] = { | |
| ParamsFor<vec4<f32>>(core::BuiltinValue::kPosition, ast::PipelineStage::kVertex, false), | |
| ParamsFor<vec4<f32>>(core::BuiltinValue::kPosition, ast::PipelineStage::kFragment, true), | |
| ParamsFor<vec4<f32>>(core::BuiltinValue::kPosition, ast::PipelineStage::kCompute, false), | |
| ParamsFor<u32>(core::BuiltinValue::kVertexIndex, ast::PipelineStage::kVertex, true), | |
| ParamsFor<u32>(core::BuiltinValue::kVertexIndex, ast::PipelineStage::kFragment, false), | |
| ParamsFor<u32>(core::BuiltinValue::kVertexIndex, ast::PipelineStage::kCompute, false), | |
| ParamsFor<u32>(core::BuiltinValue::kInstanceIndex, ast::PipelineStage::kVertex, true), | |
| ParamsFor<u32>(core::BuiltinValue::kInstanceIndex, ast::PipelineStage::kFragment, false), | |
| ParamsFor<u32>(core::BuiltinValue::kInstanceIndex, ast::PipelineStage::kCompute, false), | |
| ParamsFor<bool>(core::BuiltinValue::kFrontFacing, ast::PipelineStage::kVertex, false), | |
| ParamsFor<bool>(core::BuiltinValue::kFrontFacing, ast::PipelineStage::kFragment, true), | |
| ParamsFor<bool>(core::BuiltinValue::kFrontFacing, ast::PipelineStage::kCompute, false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kLocalInvocationId, | |
| ast::PipelineStage::kVertex, | |
| false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kLocalInvocationId, | |
| ast::PipelineStage::kFragment, | |
| false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kLocalInvocationId, | |
| ast::PipelineStage::kCompute, | |
| true), | |
| ParamsFor<u32>(core::BuiltinValue::kLocalInvocationIndex, ast::PipelineStage::kVertex, false), | |
| ParamsFor<u32>(core::BuiltinValue::kLocalInvocationIndex, ast::PipelineStage::kFragment, false), | |
| ParamsFor<u32>(core::BuiltinValue::kLocalInvocationIndex, ast::PipelineStage::kCompute, true), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kGlobalInvocationId, | |
| ast::PipelineStage::kVertex, | |
| false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kGlobalInvocationId, | |
| ast::PipelineStage::kFragment, | |
| false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kGlobalInvocationId, | |
| ast::PipelineStage::kCompute, | |
| true), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kWorkgroupId, ast::PipelineStage::kVertex, false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kWorkgroupId, ast::PipelineStage::kFragment, false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kWorkgroupId, ast::PipelineStage::kCompute, true), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kNumWorkgroups, ast::PipelineStage::kVertex, false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kNumWorkgroups, ast::PipelineStage::kFragment, false), | |
| ParamsFor<vec3<u32>>(core::BuiltinValue::kNumWorkgroups, ast::PipelineStage::kCompute, true), | |
| ParamsFor<u32>(core::BuiltinValue::kSampleIndex, ast::PipelineStage::kVertex, false), | |
| ParamsFor<u32>(core::BuiltinValue::kSampleIndex, ast::PipelineStage::kFragment, true), | |
| ParamsFor<u32>(core::BuiltinValue::kSampleIndex, ast::PipelineStage::kCompute, false), | |
| ParamsFor<u32>(core::BuiltinValue::kSampleMask, ast::PipelineStage::kVertex, false), | |
| ParamsFor<u32>(core::BuiltinValue::kSampleMask, ast::PipelineStage::kFragment, true), | |
| ParamsFor<u32>(core::BuiltinValue::kSampleMask, ast::PipelineStage::kCompute, false), | |
| }; | |
| using ResolverBuiltinsStageTest = ResolverTestWithParam<Params>; | |
| TEST_P(ResolverBuiltinsStageTest, All_input) { | |
| const Params& params = GetParam(); | |
| auto* p = GlobalVar("p", ty.vec4<f32>(), core::AddressSpace::kPrivate); | |
| auto* input = | |
| Param("input", params.type(*this), Vector{Builtin(Source{{12, 34}}, params.builtin)}); | |
| switch (params.stage) { | |
| case ast::PipelineStage::kVertex: | |
| Func("main", Vector{input}, ty.vec4<f32>(), Vector{Return(p)}, | |
| Vector{Stage(ast::PipelineStage::kVertex)}, | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kPosition), | |
| }); | |
| break; | |
| case ast::PipelineStage::kFragment: | |
| Func("main", Vector{input}, ty.void_(), tint::Empty, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| {}); | |
| break; | |
| case ast::PipelineStage::kCompute: | |
| Func("main", Vector{input}, ty.void_(), tint::Empty, | |
| Vector{ | |
| Stage(ast::PipelineStage::kCompute), | |
| WorkgroupSize(1_i), | |
| }); | |
| break; | |
| default: | |
| break; | |
| } | |
| if (params.is_valid) { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } else { | |
| StringStream err; | |
| err << "12:34 error: '@builtin(" << params.builtin << ")' cannot be used for " | |
| << params.stage << " shader input"; | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), err.str()); | |
| } | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest, | |
| ResolverBuiltinsStageTest, | |
| testing::ValuesIn(cases)); | |
| TEST_F(ResolverBuiltinsValidationTest, FragDepthIsInput_Fail) { | |
| // @fragment | |
| // fn fs_main( | |
| // @builtin(frag_depth) fd: f32, | |
| // ) -> @location(0) f32 { return 1.0; } | |
| Func("fs_main", | |
| Vector{ | |
| Param("fd", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kFragDepth), | |
| }), | |
| }, | |
| ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: '@builtin(frag_depth)' cannot be used for fragment shader input"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, FragDepthIsInputStruct_Fail) { | |
| // struct MyInputs { | |
| // @builtin(frag_depth) ff: f32; | |
| // }; | |
| // @fragment | |
| // fn fragShader(arg: MyInputs) -> @location(0) f32 { return 1.0; } | |
| auto* s = Structure("MyInputs", | |
| Vector{ | |
| Member("frag_depth", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kFragDepth), | |
| }), | |
| }); | |
| Func("fragShader", | |
| Vector{ | |
| Param("arg", ty.Of(s)), | |
| }, | |
| ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: '@builtin(frag_depth)' cannot be used for fragment shader input | |
| note: while analyzing entry point 'fragShader')"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, StructBuiltinInsideEntryPoint_Ignored) { | |
| // struct S { | |
| // @builtin(vertex_index) idx: u32; | |
| // }; | |
| // @fragment | |
| // fn fragShader() { var s : S; } | |
| Structure("S", Vector{ | |
| Member("idx", ty.u32(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kVertexIndex), | |
| }), | |
| }); | |
| Func("fragShader", tint::Empty, ty.void_(), Vector{Decl(Var("s", ty("S")))}, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()); | |
| } | |
| } // namespace StageTest | |
| TEST_F(ResolverBuiltinsValidationTest, PositionNotF32_Struct_Fail) { | |
| // struct MyInputs { | |
| // @builtin(kPosition) p: vec4<u32>; | |
| // }; | |
| // @fragment | |
| // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; } | |
| auto* s = Structure("MyInputs", | |
| Vector{ | |
| Member("position", ty.vec4<u32>(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kPosition), | |
| }), | |
| }); | |
| Func("fragShader", | |
| Vector{ | |
| Param("arg", ty.Of(s)), | |
| }, | |
| ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(position)' must be 'vec4<f32>'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, PositionNotF32_ReturnType_Fail) { | |
| // @vertex | |
| // fn main() -> @builtin(position) f32 { return 1.0; } | |
| Func("main", tint::Empty, ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{Stage(ast::PipelineStage::kVertex)}, | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(position)' must be 'vec4<f32>'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, PositionIsVec4h_Fail) { | |
| // @vertex | |
| // fn main() -> @builtin(position) vec4h { return vec4h(); } | |
| Enable(wgsl::Extension::kF16); | |
| Func("main", tint::Empty, ty.vec4<f16>(), | |
| Vector{ | |
| Return(Call(ty.vec4<f16>())), | |
| }, | |
| Vector{Stage(ast::PipelineStage::kVertex)}, | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(position)' must be 'vec4<f32>'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, FragDepthNotF32_Struct_Fail) { | |
| // struct MyInputs { | |
| // @builtin(kFragDepth) p: i32; | |
| // }; | |
| // @fragment | |
| // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; } | |
| auto* s = Structure("MyInputs", | |
| Vector{ | |
| Member("frag_depth", ty.i32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kFragDepth), | |
| }), | |
| }); | |
| Func("fragShader", Vector{Param("arg", ty.Of(s))}, ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(frag_depth)' must be 'f32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_Struct_Fail) { | |
| // struct MyInputs { | |
| // @builtin(sample_mask) m: f32; | |
| // }; | |
| // @fragment | |
| // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; } | |
| auto* s = Structure("MyInputs", | |
| Vector{ | |
| Member("m", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kSampleMask), | |
| }), | |
| }); | |
| Func("fragShader", Vector{Param("arg", ty.Of(s))}, ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(sample_mask)' must be 'u32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_ReturnType_Fail) { | |
| // @fragment | |
| // fn main() -> @builtin(sample_mask) i32 { return 1; } | |
| Func("main", tint::Empty, ty.i32(), Vector{Return(1_i)}, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kSampleMask), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(sample_mask)' must be 'u32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, SampleMaskIsNotU32_Fail) { | |
| // @fragment | |
| // fn fs_main( | |
| // @builtin(sample_mask) arg: bool | |
| // ) -> @location(0) f32 { return 1.0; } | |
| Func("fs_main", | |
| Vector{ | |
| Param("arg", ty.bool_(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kSampleMask), | |
| }), | |
| }, | |
| ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(sample_mask)' must be 'u32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Struct_Fail) { | |
| // struct MyInputs { | |
| // @builtin(sample_index) m: f32; | |
| // }; | |
| // @fragment | |
| // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; } | |
| auto* s = Structure("MyInputs", | |
| Vector{ | |
| Member("m", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kSampleIndex), | |
| }), | |
| }); | |
| Func("fragShader", Vector{Param("arg", ty.Of(s))}, ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(sample_index)' must be 'u32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Fail) { | |
| // @fragment | |
| // fn fs_main( | |
| // @builtin(sample_index) arg: bool | |
| // ) -> @location(0) f32 { return 1.0; } | |
| Func("fs_main", | |
| Vector{ | |
| Param("arg", ty.bool_(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kSampleIndex), | |
| }), | |
| }, | |
| ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(sample_index)' must be 'u32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, PositionIsNotF32_Fail) { | |
| // @fragment | |
| // fn fs_main( | |
| // @builtin(kPosition) p: vec3<f32>, | |
| // ) -> @location(0) f32 { return 1.0; } | |
| Func("fs_main", | |
| Vector{ | |
| Param("p", ty.vec3<f32>(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kPosition), | |
| }), | |
| }, | |
| ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(position)' must be 'vec4<f32>'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, FragDepthIsNotF32_Fail) { | |
| // @fragment | |
| // fn fs_main() -> @builtin(kFragDepth) f32 { var fd: i32; return fd; } | |
| auto* fd = Var("fd", ty.i32()); | |
| Func("fs_main", tint::Empty, ty.i32(), | |
| Vector{ | |
| Decl(fd), | |
| Return(fd), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kFragDepth), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(frag_depth)' must be 'f32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, VertexIndexIsNotU32_Fail) { | |
| // @vertex | |
| // fn main( | |
| // @builtin(kVertexIndex) vi : f32, | |
| // @builtin(kPosition) p :vec4<f32> | |
| // ) -> @builtin(kPosition) vec4<f32> { return vec4<f32>(); } | |
| auto* p = Param("p", ty.vec4<f32>(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| auto* vi = Param("vi", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kVertexIndex), | |
| }); | |
| Func("main", Vector{vi, p}, ty.vec4<f32>(), Vector{Return(Expr("p"))}, | |
| Vector{ | |
| Stage(ast::PipelineStage::kVertex), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(vertex_index)' must be 'u32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, InstanceIndexIsNotU32) { | |
| // @vertex | |
| // fn main( | |
| // @builtin(kInstanceIndex) ii : f32, | |
| // @builtin(kPosition) p :vec4<f32> | |
| // ) -> @builtin(kPosition) vec4<f32> { return vec4<f32>(); } | |
| auto* p = Param("p", ty.vec4<f32>(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| auto* ii = Param("ii", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kInstanceIndex), | |
| }); | |
| Func("main", Vector{ii, p}, ty.vec4<f32>(), Vector{Return(Expr("p"))}, | |
| Vector{ | |
| Stage(ast::PipelineStage::kVertex), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(instance_index)' must be 'u32'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltin_Pass) { | |
| // @fragment | |
| // fn fs_main( | |
| // @builtin(kPosition) p: vec4<f32>, | |
| // @builtin(front_facing) ff: bool, | |
| // @builtin(sample_index) si: u32, | |
| // @builtin(sample_mask) sm : u32 | |
| // ) -> @builtin(frag_depth) f32 { var fd: f32; return fd; } | |
| auto* p = Param("p", ty.vec4<f32>(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| auto* ff = Param("ff", ty.bool_(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kFrontFacing), | |
| }); | |
| auto* si = Param("si", ty.u32(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kSampleIndex), | |
| }); | |
| auto* sm = Param("sm", ty.u32(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kSampleMask), | |
| }); | |
| auto* var_fd = Var("fd", ty.f32()); | |
| Func("fs_main", Vector{p, ff, si, sm}, ty.f32(), | |
| Vector{ | |
| Decl(var_fd), | |
| Return(var_fd), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kFragDepth), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, VertexBuiltin_Pass) { | |
| // @vertex | |
| // fn main( | |
| // @builtin(vertex_index) vi : u32, | |
| // @builtin(instance_index) ii : u32, | |
| // ) -> @builtin(position) vec4<f32> { var p :vec4<f32>; return p; } | |
| auto* vi = Param("vi", ty.u32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kVertexIndex), | |
| }); | |
| auto* ii = Param("ii", ty.u32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kInstanceIndex), | |
| }); | |
| auto* p = Var("p", ty.vec4<f32>()); | |
| Func("main", Vector{vi, ii}, ty.vec4<f32>(), | |
| Vector{ | |
| Decl(p), | |
| Return(p), | |
| }, | |
| Vector{Stage(ast::PipelineStage::kVertex)}, | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_Pass) { | |
| // @compute @workgroup_size(1) | |
| // fn main( | |
| // @builtin(local_invocationId) li_id: vec3<u32>, | |
| // @builtin(local_invocationIndex) li_index: u32, | |
| // @builtin(global_invocationId) gi: vec3<u32>, | |
| // @builtin(workgroup_id) wi: vec3<u32>, | |
| // @builtin(num_workgroups) nwgs: vec3<u32>, | |
| // ) {} | |
| auto* li_id = Param("li_id", ty.vec3<u32>(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kLocalInvocationId), | |
| }); | |
| auto* li_index = Param("li_index", ty.u32(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kLocalInvocationIndex), | |
| }); | |
| auto* gi = Param("gi", ty.vec3<u32>(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kGlobalInvocationId), | |
| }); | |
| auto* wi = Param("wi", ty.vec3<u32>(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kWorkgroupId), | |
| }); | |
| auto* nwgs = Param("nwgs", ty.vec3<u32>(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kNumWorkgroups), | |
| }); | |
| Func("main", Vector{li_id, li_index, gi, wi, nwgs}, ty.void_(), tint::Empty, | |
| Vector{Stage(ast::PipelineStage::kCompute), | |
| WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))}); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_WorkGroupIdNotVec3U32) { | |
| auto* wi = Param("wi", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kWorkgroupId), | |
| }); | |
| Func("main", Vector{wi}, ty.void_(), tint::Empty, | |
| Vector{Stage(ast::PipelineStage::kCompute), | |
| WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))}); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: store type of '@builtin(workgroup_id)' must be 'vec3<u32>')"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_NumWorkgroupsNotVec3U32) { | |
| auto* nwgs = Param("nwgs", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kNumWorkgroups), | |
| }); | |
| Func("main", Vector{nwgs}, ty.void_(), tint::Empty, | |
| Vector{Stage(ast::PipelineStage::kCompute), | |
| WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))}); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: store type of '@builtin(num_workgroups)' must be 'vec3<u32>')"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_GlobalInvocationNotVec3U32) { | |
| auto* gi = Param("gi", ty.vec3<i32>(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kGlobalInvocationId), | |
| }); | |
| Func("main", Vector{gi}, ty.void_(), tint::Empty, | |
| Vector{Stage(ast::PipelineStage::kCompute), | |
| WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))}); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: store type of '@builtin(global_invocation_id)' must be 'vec3<u32>')"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationIndexNotU32) { | |
| auto* li_index = Param("li_index", ty.vec3<u32>(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kLocalInvocationIndex), | |
| }); | |
| Func("main", Vector{li_index}, ty.void_(), tint::Empty, | |
| Vector{Stage(ast::PipelineStage::kCompute), | |
| WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))}); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: store type of '@builtin(local_invocation_index)' must be 'u32')"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationNotVec3U32) { | |
| auto* li_id = Param("li_id", ty.vec2<u32>(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kLocalInvocationId), | |
| }); | |
| Func("main", Vector{li_id}, ty.void_(), tint::Empty, | |
| Vector{Stage(ast::PipelineStage::kCompute), | |
| WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))}); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: store type of '@builtin(local_invocation_id)' must be 'vec3<u32>')"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltinStruct_Pass) { | |
| // Struct MyInputs { | |
| // @builtin(kPosition) p: vec4<f32>; | |
| // @builtin(frag_depth) fd: f32; | |
| // @builtin(sample_index) si: u32; | |
| // @builtin(sample_mask) sm : u32;; | |
| // }; | |
| // @fragment | |
| // fn fragShader(arg: MyInputs) -> @location(0) f32 { return 1.0; } | |
| auto* s = Structure("MyInputs", Vector{ | |
| Member("position", ty.vec4<f32>(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kPosition), | |
| }), | |
| Member("front_facing", ty.bool_(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kFrontFacing), | |
| }), | |
| Member("sample_index", ty.u32(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kSampleIndex), | |
| }), | |
| Member("sample_mask", ty.u32(), | |
| Vector{ | |
| Builtin(core::BuiltinValue::kSampleMask), | |
| }), | |
| }); | |
| Func("fragShader", Vector{Param("arg", ty.Of(s))}, ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, FrontFacingParamIsNotBool_Fail) { | |
| // @fragment | |
| // fn fs_main( | |
| // @builtin(front_facing) is_front: i32; | |
| // ) -> @location(0) f32 { return 1.0; } | |
| auto* is_front = Param("is_front", ty.i32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kFrontFacing), | |
| }); | |
| Func("fs_main", Vector{is_front}, ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(front_facing)' must be 'bool'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, FrontFacingMemberIsNotBool_Fail) { | |
| // struct MyInputs { | |
| // @builtin(front_facing) pos: f32; | |
| // }; | |
| // @fragment | |
| // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; } | |
| auto* s = Structure("MyInputs", | |
| Vector{ | |
| Member("pos", ty.f32(), | |
| Vector{ | |
| Builtin(Source{{12, 34}}, core::BuiltinValue::kFrontFacing), | |
| }), | |
| }); | |
| Func("fragShader", Vector{Param("is_front", ty.Of(s))}, ty.f32(), | |
| Vector{ | |
| Return(1_f), | |
| }, | |
| Vector{ | |
| Stage(ast::PipelineStage::kFragment), | |
| }, | |
| Vector{ | |
| Location(0_a), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: store type of '@builtin(front_facing)' must be 'bool'"); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Length_Float_Scalar) { | |
| auto* builtin = Call("length", 1_f); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Length_Float_Vec2) { | |
| auto* builtin = Call("length", Call<vec2<f32>>(1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Length_Float_Vec3) { | |
| auto* builtin = Call("length", Call<vec3<f32>>(1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Length_Float_Vec4) { | |
| auto* builtin = Call("length", Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Distance_Float_Scalar) { | |
| auto* builtin = Call("distance", 1_f, 1_f); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Distance_Float_Vec2) { | |
| auto* builtin = Call("distance", Call<vec2<f32>>(1_f, 1_f), Call<vec2<f32>>(1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Distance_Float_Vec3) { | |
| auto* builtin = | |
| Call("distance", Call<vec3<f32>>(1_f, 1_f, 1_f), Call<vec3<f32>>(1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Distance_Float_Vec4) { | |
| auto* builtin = | |
| Call("distance", Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f), Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Determinant_Mat2x2) { | |
| auto* builtin = Call("determinant", | |
| Call<mat2x2<f32>>(Call<vec2<f32>>(1_f, 1_f), Call<vec2<f32>>(1_f, 1_f))); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Determinant_Mat3x3) { | |
| auto* builtin = Call("determinant", Call<mat3x3<f32>>(Call<vec3<f32>>(1_f, 1_f, 1_f), | |
| Call<vec3<f32>>(1_f, 1_f, 1_f), | |
| Call<vec3<f32>>(1_f, 1_f, 1_f))); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Determinant_Mat4x4) { | |
| auto* builtin = Call("determinant", Call<mat4x4<f32>>(Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f), | |
| Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f), | |
| Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f), | |
| Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f))); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Frexp_Scalar) { | |
| auto* builtin = Call("frexp", 1_f); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* res_ty = TypeOf(builtin)->As<core::type::Struct>(); | |
| ASSERT_TRUE(res_ty != nullptr); | |
| auto members = res_ty->Members(); | |
| ASSERT_EQ(members.Length(), 2u); | |
| EXPECT_TRUE(members[0]->Type()->Is<core::type::F32>()); | |
| EXPECT_TRUE(members[1]->Type()->Is<core::type::I32>()); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec2) { | |
| auto* builtin = Call("frexp", Call<vec2<f32>>(1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* res_ty = TypeOf(builtin)->As<core::type::Struct>(); | |
| ASSERT_TRUE(res_ty != nullptr); | |
| auto members = res_ty->Members(); | |
| ASSERT_EQ(members.Length(), 2u); | |
| ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>()); | |
| ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>()); | |
| EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 2u); | |
| EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 2u); | |
| EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->Type()->Is<core::type::I32>()); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec3) { | |
| auto* builtin = Call("frexp", Call<vec3<f32>>(1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* res_ty = TypeOf(builtin)->As<core::type::Struct>(); | |
| ASSERT_TRUE(res_ty != nullptr); | |
| auto members = res_ty->Members(); | |
| ASSERT_EQ(members.Length(), 2u); | |
| ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>()); | |
| ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>()); | |
| EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 3u); | |
| EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 3u); | |
| EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->Type()->Is<core::type::I32>()); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec4) { | |
| auto* builtin = Call("frexp", Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* res_ty = TypeOf(builtin)->As<core::type::Struct>(); | |
| ASSERT_TRUE(res_ty != nullptr); | |
| auto members = res_ty->Members(); | |
| ASSERT_EQ(members.Length(), 2u); | |
| ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>()); | |
| ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>()); | |
| EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 4u); | |
| EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 4u); | |
| EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->Type()->Is<core::type::I32>()); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Modf_Scalar) { | |
| auto* builtin = Call("modf", 1_f); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* res_ty = TypeOf(builtin)->As<core::type::Struct>(); | |
| ASSERT_TRUE(res_ty != nullptr); | |
| auto members = res_ty->Members(); | |
| ASSERT_EQ(members.Length(), 2u); | |
| EXPECT_TRUE(members[0]->Type()->Is<core::type::F32>()); | |
| EXPECT_TRUE(members[1]->Type()->Is<core::type::F32>()); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Modf_Vec2) { | |
| auto* builtin = Call("modf", Call<vec2<f32>>(1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* res_ty = TypeOf(builtin)->As<core::type::Struct>(); | |
| ASSERT_TRUE(res_ty != nullptr); | |
| auto members = res_ty->Members(); | |
| ASSERT_EQ(members.Length(), 2u); | |
| ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>()); | |
| ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>()); | |
| EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 2u); | |
| EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 2u); | |
| EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Modf_Vec3) { | |
| auto* builtin = Call("modf", Call<vec3<f32>>(1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* res_ty = TypeOf(builtin)->As<core::type::Struct>(); | |
| ASSERT_TRUE(res_ty != nullptr); | |
| auto members = res_ty->Members(); | |
| ASSERT_EQ(members.Length(), 2u); | |
| ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>()); | |
| ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>()); | |
| EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 3u); | |
| EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 3u); | |
| EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Modf_Vec4) { | |
| auto* builtin = Call("modf", Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* res_ty = TypeOf(builtin)->As<core::type::Struct>(); | |
| ASSERT_TRUE(res_ty != nullptr); | |
| auto members = res_ty->Members(); | |
| ASSERT_EQ(members.Length(), 2u); | |
| ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>()); | |
| ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>()); | |
| EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 4u); | |
| EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 4u); | |
| EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->Type()->Is<core::type::F32>()); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Cross_Float_Vec3) { | |
| auto* builtin = Call("cross", Call<vec3<f32>>(1_f, 1_f, 1_f), Call<vec3<f32>>(1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Dot_Float_Vec2) { | |
| auto* builtin = Call("dot", Call<vec2<f32>>(1_f, 1_f), Call<vec2<f32>>(1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Dot_Float_Vec3) { | |
| auto* builtin = Call("dot", Call<vec3<f32>>(1_f, 1_f, 1_f), Call<vec3<f32>>(1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Dot_Float_Vec4) { | |
| auto* builtin = | |
| Call("dot", Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f), Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Select_Float_Scalar) { | |
| auto* builtin = Call("select", Expr(1_f), Expr(1_f), Expr(true)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Select_Integer_Scalar) { | |
| auto* builtin = Call("select", Expr(1_i), Expr(1_i), Expr(true)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Select_Boolean_Scalar) { | |
| auto* builtin = Call("select", Expr(true), Expr(true), Expr(true)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Select_Float_Vec2) { | |
| auto* builtin = Call("select", Call<vec2<f32>>(1_f, 1_f), Call<vec2<f32>>(1_f, 1_f), | |
| Call<vec2<bool>>(true, true)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Select_Integer_Vec2) { | |
| auto* builtin = Call("select", Call<vec2<i32>>(1_i, 1_i), Call<vec2<i32>>(1_i, 1_i), | |
| Call<vec2<bool>>(true, true)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverBuiltinsValidationTest, Select_Boolean_Vec2) { | |
| auto* builtin = Call("select", Call<vec2<bool>>(true, true), Call<vec2<bool>>(true, true), | |
| Call<vec2<bool>>(true, true)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| template <typename T> | |
| class ResolverBuiltinsValidationTestWithParams : public resolver::TestHelper, | |
| public testing::TestWithParam<T> {}; | |
| using FloatAllMatching = | |
| ResolverBuiltinsValidationTestWithParams<std::tuple<std::string, uint32_t>>; | |
| TEST_P(FloatAllMatching, Scalar) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Expr(f32(i + 1))); | |
| } | |
| auto* builtin = Call(name, params); | |
| Func("func", tint::Empty, ty.void_(), | |
| Vector{ | |
| Assign(Phony(), builtin), | |
| }, | |
| Vector{ | |
| create<ast::StageAttribute>(ast::PipelineStage::kFragment), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->Is<core::type::F32>()); | |
| } | |
| TEST_P(FloatAllMatching, Vec2) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec2<f32>>(f32(i + 1), f32(i + 1))); | |
| } | |
| auto* builtin = Call(name, params); | |
| Func("func", tint::Empty, ty.void_(), | |
| Vector{ | |
| Assign(Phony(), builtin), | |
| }, | |
| Vector{ | |
| create<ast::StageAttribute>(ast::PipelineStage::kFragment), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsFloatVector()); | |
| } | |
| TEST_P(FloatAllMatching, Vec3) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec3<f32>>(f32(i + 1), f32(i + 1), f32(i + 1))); | |
| } | |
| auto* builtin = Call(name, params); | |
| Func("func", tint::Empty, ty.void_(), | |
| Vector{ | |
| Assign(Phony(), builtin), | |
| }, | |
| Vector{ | |
| create<ast::StageAttribute>(ast::PipelineStage::kFragment), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsFloatVector()); | |
| } | |
| TEST_P(FloatAllMatching, Vec4) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec4<f32>>(f32(i + 1), f32(i + 1), f32(i + 1), f32(i + 1))); | |
| } | |
| auto* builtin = Call(name, params); | |
| Func("func", tint::Empty, ty.void_(), | |
| Vector{ | |
| Assign(Phony(), builtin), | |
| }, | |
| Vector{ | |
| create<ast::StageAttribute>(ast::PipelineStage::kFragment), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsFloatVector()); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest, | |
| FloatAllMatching, | |
| ::testing::Values(std::make_tuple("abs", 1), | |
| std::make_tuple("acos", 1), | |
| std::make_tuple("asin", 1), | |
| std::make_tuple("atan", 1), | |
| std::make_tuple("atan2", 2), | |
| std::make_tuple("ceil", 1), | |
| std::make_tuple("clamp", 3), | |
| std::make_tuple("cos", 1), | |
| std::make_tuple("cosh", 1), | |
| std::make_tuple("dpdx", 1), | |
| std::make_tuple("dpdxCoarse", 1), | |
| std::make_tuple("dpdxFine", 1), | |
| std::make_tuple("dpdy", 1), | |
| std::make_tuple("dpdyCoarse", 1), | |
| std::make_tuple("dpdyFine", 1), | |
| std::make_tuple("exp", 1), | |
| std::make_tuple("exp2", 1), | |
| std::make_tuple("floor", 1), | |
| std::make_tuple("fma", 3), | |
| std::make_tuple("fract", 1), | |
| std::make_tuple("fwidth", 1), | |
| std::make_tuple("fwidthCoarse", 1), | |
| std::make_tuple("fwidthFine", 1), | |
| std::make_tuple("inverseSqrt", 1), | |
| std::make_tuple("log", 1), | |
| std::make_tuple("log2", 1), | |
| std::make_tuple("max", 2), | |
| std::make_tuple("min", 2), | |
| std::make_tuple("mix", 3), | |
| std::make_tuple("pow", 2), | |
| std::make_tuple("round", 1), | |
| std::make_tuple("sign", 1), | |
| std::make_tuple("sin", 1), | |
| std::make_tuple("sinh", 1), | |
| std::make_tuple("smoothstep", 3), | |
| std::make_tuple("sqrt", 1), | |
| std::make_tuple("step", 2), | |
| std::make_tuple("tan", 1), | |
| std::make_tuple("tanh", 1), | |
| std::make_tuple("trunc", 1))); | |
| using IntegerAllMatching = | |
| ResolverBuiltinsValidationTestWithParams<std::tuple<std::string, uint32_t>>; | |
| TEST_P(IntegerAllMatching, ScalarUnsigned) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<u32>(1_i)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->Is<core::type::U32>()); | |
| } | |
| TEST_P(IntegerAllMatching, Vec2Unsigned) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec2<u32>>(1_u, 1_u)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsUnsignedIntegerVector()); | |
| } | |
| TEST_P(IntegerAllMatching, Vec3Unsigned) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec3<u32>>(1_u, 1_u, 1_u)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsUnsignedIntegerVector()); | |
| } | |
| TEST_P(IntegerAllMatching, Vec4Unsigned) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec4<u32>>(1_u, 1_u, 1_u, 1_u)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsUnsignedIntegerVector()); | |
| } | |
| TEST_P(IntegerAllMatching, ScalarSigned) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<i32>(1_i)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->Is<core::type::I32>()); | |
| } | |
| TEST_P(IntegerAllMatching, Vec2Signed) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec2<i32>>(1_i, 1_i)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsSignedIntegerVector()); | |
| } | |
| TEST_P(IntegerAllMatching, Vec3Signed) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec3<i32>>(1_i, 1_i, 1_i)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsSignedIntegerVector()); | |
| } | |
| TEST_P(IntegerAllMatching, Vec4Signed) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec4<i32>>(1_i, 1_i, 1_i, 1_i)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| EXPECT_TRUE(TypeOf(builtin)->IsSignedIntegerVector()); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest, | |
| IntegerAllMatching, | |
| ::testing::Values(std::make_tuple("abs", 1), | |
| std::make_tuple("clamp", 3), | |
| std::make_tuple("countOneBits", 1), | |
| std::make_tuple("max", 2), | |
| std::make_tuple("min", 2), | |
| std::make_tuple("reverseBits", 1))); | |
| using BooleanVectorInput = | |
| ResolverBuiltinsValidationTestWithParams<std::tuple<std::string, uint32_t>>; | |
| TEST_P(BooleanVectorInput, Vec2) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec2<bool>>(true, true)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_P(BooleanVectorInput, Vec3) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec3<bool>>(true, true, true)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_P(BooleanVectorInput, Vec4) { | |
| std::string name = std::get<0>(GetParam()); | |
| uint32_t num_params = std::get<1>(GetParam()); | |
| Vector<const ast::Expression*, 8> params; | |
| for (uint32_t i = 0; i < num_params; ++i) { | |
| params.Push(Call<vec4<bool>>(true, true, true, true)); | |
| } | |
| auto* builtin = Call(name, params); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest, | |
| BooleanVectorInput, | |
| ::testing::Values(std::make_tuple("all", 1), std::make_tuple("any", 1))); | |
| using DataPacking4x8 = ResolverBuiltinsValidationTestWithParams<std::string>; | |
| TEST_P(DataPacking4x8, Float_Vec4) { | |
| auto name = GetParam(); | |
| auto* builtin = Call(name, Call<vec4<f32>>(1_f, 1_f, 1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest, | |
| DataPacking4x8, | |
| ::testing::Values("pack4x8snorm", "pack4x8unorm")); | |
| using DataPacking2x16 = ResolverBuiltinsValidationTestWithParams<std::string>; | |
| TEST_P(DataPacking2x16, Float_Vec2) { | |
| auto name = GetParam(); | |
| auto* builtin = Call(name, Call<vec2<f32>>(1_f, 1_f)); | |
| WrapInFunction(builtin); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverBuiltinsValidationTest, | |
| DataPacking2x16, | |
| ::testing::Values("pack2x16snorm", "pack2x16unorm", "pack2x16float")); | |
| using ExprMaker = std::function<const ast::Expression*(ast::Builder*)>; | |
| template <typename T> | |
| ExprMaker Mk(core::Number<T> v) { | |
| return [v](ast::Builder* b) -> const ast::Expression* { return b->Expr(v); }; | |
| } | |
| // We''ll construct cases like this: | |
| // fn foo() { | |
| // var s: STYPE; | |
| // _ = clamp(s, LOW, HIGH); | |
| // } | |
| struct ClampPartialConstCase { | |
| builder::ast_type_func_ptr sType; | |
| ExprMaker makeLow; | |
| ExprMaker makeHigh; | |
| bool expectPass = true; | |
| std::string lowStr = ""; | |
| std::string highStr = ""; | |
| }; | |
| using ClampPartialConst = | |
| ResolverBuiltinsValidationTestWithParams<std::tuple<ClampPartialConstCase, bool, bool>>; | |
| TEST_P(ClampPartialConst, Scalar) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto sTy = params.sType(*this); | |
| const ast::Expression* low = params.makeLow(this); | |
| const ast::Expression* high = params.makeHigh(this); | |
| const ast::Variable* lowDecl; | |
| if (firstConst) { | |
| lowDecl = Const("low", low); | |
| } else { | |
| lowDecl = Var("low", low); | |
| } | |
| const ast::Variable* highDecl; | |
| if (secondConst) { | |
| highDecl = Const("high", high); | |
| } else { | |
| highDecl = Var("high", high); | |
| } | |
| WrapInFunction(Var("s", sTy), lowDecl, highDecl, | |
| Ignore(Call(Source{{12, 34}}, "clamp", "s", "low", "high"))); | |
| const auto expectPass = params.expectPass || !(firstConst && secondConst); | |
| if (expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| StringStream ss; | |
| ss << "12:34 error: clamp called with 'low' (" << params.lowStr << ") greater than 'high' (" | |
| << params.highStr << ")"; | |
| auto expect = ss.str(); | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| TEST_P(ClampPartialConst, Vector) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto sTy = params.sType(*this); | |
| const ast::Expression* low = params.makeLow(this); | |
| const ast::Expression* high = params.makeHigh(this); | |
| const ast::Variable* lowDecl; | |
| if (firstConst) { | |
| lowDecl = Const("low", low); | |
| } else { | |
| lowDecl = Var("low", low); | |
| } | |
| const ast::Variable* highDecl; | |
| if (secondConst) { | |
| highDecl = Const("high", high); | |
| } else { | |
| highDecl = Var("high", high); | |
| } | |
| WrapInFunction(Var("s", sTy), lowDecl, highDecl, | |
| Ignore(Call(Source{{12, 34}}, "clamp", Call(Ident("vec3"), "s", "s", "s"), | |
| Call(Ident("vec3"), Expr(0_a), "low", Expr(0_a)), | |
| Call(Ident("vec3"), Expr(1_a), "high", Expr(1_a))))); | |
| const auto expectPass = params.expectPass || !(firstConst && secondConst); | |
| if (expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| StringStream ss; | |
| ss << "12:34 error: clamp called with 'low' (" << params.lowStr << ") greater than 'high' (" | |
| << params.highStr << ")"; | |
| auto expect = ss.str(); | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| TEST_P(ClampPartialConst, VectorMixedRuntimeConstNotChecked) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto sTy = params.sType(*this); | |
| const ast::Expression* low = params.makeLow(this); | |
| const ast::Expression* high = params.makeHigh(this); | |
| // Some components of the low and high vector are runtime, so the other | |
| // components are not checked, and therefore do not generate errors. | |
| WrapInFunction(Var("s", sTy), | |
| Ignore(Call(Source{{12, 34}}, "clamp", Call(Ident("vec2"), "s", "s"), | |
| Call(Ident("vec2"), "s", low), Call(Ident("vec2"), "s", high)))); | |
| EXPECT_TRUE(r()->Resolve()); | |
| } | |
| std::vector<ClampPartialConstCase> clampCases() { | |
| return std::vector<ClampPartialConstCase>{ | |
| // Simple passing cases. | |
| {DataType<f32>::AST, Mk(1_a), Mk(1_a), true}, // low == high | |
| {DataType<f32>::AST, Mk(1_a), Mk(2_a), true}, // low < high | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(1_a), true}, // AFloat AInt | |
| {DataType<f32>::AST, Mk(1_a), Mk(2_f), true}, // AInt AFloat | |
| {DataType<f32>::AST, Mk(1_a), Mk(2_f), true}, // AFloat f32 | |
| {DataType<f32>::AST, Mk(1_f), Mk(2.0_a), true}, // f32 AFloat | |
| {DataType<f32>::AST, Mk(1_f), Mk(2_f), true}, // f32 f32 | |
| {DataType<u32>::AST, Mk(1_a), Mk(1_u), true}, // AInt u32 | |
| {DataType<u32>::AST, Mk(1_u), Mk(2_u), true}, // u32 u32 | |
| {DataType<i32>::AST, Mk(1_i), Mk(1_a), true}, // i32 AInt | |
| {DataType<i32>::AST, Mk(1_i), Mk(2_i), true}, // i32 i32 | |
| // AInt AInt | |
| {DataType<f32>::AST, Mk(1_a), Mk(0_a), false, "1.0", "0.0"}, | |
| {DataType<i32>::AST, Mk(1_a), Mk(0_a), false, "1", "0"}, | |
| {DataType<u32>::AST, Mk(1_a), Mk(0_a), false, "1", "0"}, | |
| // AFloat AInt | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(0_a), false, "1.0", "0.0"}, | |
| // AInt AFloat | |
| {DataType<f32>::AST, Mk(1_a), Mk(0.0_a), false, "1.0", "0.0"}, | |
| // AFloat AFloat | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(0.0_a), false, "1.0", "0.0"}, | |
| // AFloat f32 | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(0_f), false, "1.0", "0.0"}, | |
| // f32 AFloat | |
| {DataType<f32>::AST, Mk(1_f), Mk(0.0_a), false, "1.0", "0.0"}, | |
| // AInt f32 | |
| {DataType<f32>::AST, Mk(1_a), Mk(0_f), false, "1.0", "0.0"}, | |
| // f32 AInt | |
| {DataType<f32>::AST, Mk(1_f), Mk(0_a), false, "1.0", "0.0"}, | |
| // f32 f32 | |
| {DataType<f32>::AST, Mk(1_f), Mk(0_f), false, "1.0", "0.0"}, | |
| // AInt i32 | |
| {DataType<i32>::AST, Mk(1_a), Mk(0_i), false, "1", "0"}, | |
| // i32 AInt | |
| {DataType<i32>::AST, Mk(1_i), Mk(0_a), false, "1", "0"}, | |
| // i32 i32 | |
| {DataType<i32>::AST, Mk(1_i), Mk(0_i), false, "1", "0"}, | |
| // AInt u32 | |
| {DataType<u32>::AST, Mk(1_a), Mk(0_u), false, "1", "0"}, | |
| // i32 AInt | |
| {DataType<u32>::AST, Mk(1_u), Mk(0_a), false, "1", "0"}, | |
| // i32 i32 | |
| {DataType<u32>::AST, Mk(1_u), Mk(0_u), false, "1", "0"}, | |
| }; | |
| } | |
| INSTANTIATE_TEST_SUITE_P(Clamp, | |
| ClampPartialConst, | |
| ::testing::Combine(::testing::ValuesIn(clampCases()), | |
| ::testing::ValuesIn({true}), | |
| ::testing::ValuesIn({true}))); | |
| // We''ll construct cases like this: | |
| // fn foo() { | |
| // var s: STYPE; | |
| // _ = smoothstep(LOW, HIGH, s); | |
| // } | |
| struct SmoothstepPartialConstCase { | |
| builder::ast_type_func_ptr sType; | |
| ExprMaker makeLow; | |
| ExprMaker makeHigh; | |
| bool expectPass = true; | |
| std::string lowStr = ""; | |
| std::string highStr = ""; | |
| }; | |
| using SmoothstepPartialConst = | |
| ResolverBuiltinsValidationTestWithParams<std::tuple<SmoothstepPartialConstCase, bool, bool>>; | |
| TEST_P(SmoothstepPartialConst, Scalar) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto sTy = params.sType(*this); | |
| const ast::Expression* low = params.makeLow(this); | |
| const ast::Expression* high = params.makeHigh(this); | |
| const ast::Variable* lowDecl; | |
| if (firstConst) { | |
| lowDecl = Const("low", low); | |
| } else { | |
| lowDecl = Var("low", low); | |
| } | |
| const ast::Variable* highDecl; | |
| if (secondConst) { | |
| highDecl = Const("high", high); | |
| } else { | |
| highDecl = Var("high", high); | |
| } | |
| WrapInFunction(Var("s", sTy), lowDecl, highDecl, | |
| Ignore(Call(Source{{12, 34}}, "smoothstep", "low", "high", "s"))); | |
| const auto expectPass = params.expectPass || !(firstConst && secondConst); | |
| if (expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| StringStream ss; | |
| ss << "12:34 error: smoothstep called with 'low' (" << params.lowStr | |
| << ") not less than 'high' (" << params.highStr << ")"; | |
| auto expect = ss.str(); | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| TEST_P(SmoothstepPartialConst, Vector) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto sTy = params.sType(*this); | |
| const ast::Expression* low = params.makeLow(this); | |
| const ast::Expression* high = params.makeHigh(this); | |
| const ast::Variable* lowDecl; | |
| if (firstConst) { | |
| lowDecl = Const("low", low); | |
| } else { | |
| lowDecl = Var("low", low); | |
| } | |
| const ast::Variable* highDecl; | |
| if (secondConst) { | |
| highDecl = Const("high", high); | |
| } else { | |
| highDecl = Var("high", high); | |
| } | |
| WrapInFunction(Var("s", sTy), lowDecl, highDecl, | |
| Ignore(Call(Source{{12, 34}}, "smoothstep", | |
| Call(Ident("vec3"), Expr(0_a), "low", Expr(0_a)), | |
| Call(Ident("vec3"), Expr(1_a), "high", Expr(1_a)), | |
| Call(Ident("vec3"), "s", "s", "s")))); | |
| const auto expectPass = params.expectPass || !(firstConst && secondConst); | |
| if (expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| StringStream ss; | |
| ss << "12:34 error: smoothstep called with 'low' (" << params.lowStr | |
| << ") not less than 'high' (" << params.highStr << ")"; | |
| auto expect = ss.str(); | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| TEST_P(SmoothstepPartialConst, VectorMixedRuntimeConstNotChecked) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto sTy = params.sType(*this); | |
| const ast::Expression* low = params.makeLow(this); | |
| const ast::Expression* high = params.makeHigh(this); | |
| // Some components of the low and high vector are runtime, so the other | |
| // components are not checked, and therefore do not generate errors. | |
| WrapInFunction(Var("s", sTy), | |
| Ignore(Call(Source{{12, 34}}, "smoothstep", Call(Ident("vec2"), "s", low), | |
| Call(Ident("vec2"), "s", high), Call(Ident("vec2"), "s", "s")))); | |
| EXPECT_TRUE(r()->Resolve()); | |
| } | |
| std::vector<SmoothstepPartialConstCase> smoothstepCases() { | |
| return std::vector<SmoothstepPartialConstCase>{ | |
| // Simple passing cases. | |
| {DataType<f32>::AST, Mk(1_a), Mk(2_a), true}, // low < high | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(2_a), true}, // AFloat AInt | |
| {DataType<f32>::AST, Mk(1_a), Mk(2_f), true}, // AInt AFloat | |
| {DataType<f32>::AST, Mk(1_a), Mk(2_f), true}, // AFloat f32 | |
| {DataType<f32>::AST, Mk(1_f), Mk(2.0_a), true}, // f32 AFloat | |
| {DataType<f32>::AST, Mk(1_f), Mk(2_f), true}, // f32 f32 | |
| // AInt AInt | |
| {DataType<f32>::AST, Mk(1_a), Mk(1_a), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1_a), Mk(0_a), false, "1.0", "0.0"}, | |
| // AFloat AInt | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(1_a), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(0_a), false, "1.0", "0.0"}, | |
| // AInt AFloat | |
| {DataType<f32>::AST, Mk(1_a), Mk(1.0_a), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1_a), Mk(0.0_a), false, "1.0", "0.0"}, | |
| // AFloat AFloat | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(1.0_a), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(0.0_a), false, "1.0", "0.0"}, | |
| // AInt f32 | |
| {DataType<f32>::AST, Mk(1_a), Mk(1_f), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1_a), Mk(0_f), false, "1.0", "0.0"}, | |
| // f32 AInt | |
| {DataType<f32>::AST, Mk(1_f), Mk(1_a), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1_f), Mk(0_a), false, "1.0", "0.0"}, | |
| // AFloat f32 | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(1_f), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1.0_a), Mk(0_f), false, "1.0", "0.0"}, | |
| // f32 AFloat | |
| {DataType<f32>::AST, Mk(1_a), Mk(1.0_a), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1_a), Mk(0.0_a), false, "1.0", "0.0"}, | |
| // f32 f32 | |
| {DataType<f32>::AST, Mk(1_f), Mk(1.0_f), false, "1.0", "1.0"}, | |
| {DataType<f32>::AST, Mk(1_f), Mk(0.0_f), false, "1.0", "0.0"}, | |
| }; | |
| } | |
| INSTANTIATE_TEST_SUITE_P(Smoothstep, | |
| SmoothstepPartialConst, | |
| ::testing::Combine(::testing::ValuesIn(smoothstepCases()), | |
| ::testing::ValuesIn({true}), | |
| ::testing::ValuesIn({true}))); | |
| // We'll construct cases like this: | |
| // fn foo() { | |
| // var e: ETYPE; | |
| // _ = insertBits(e, e, COUNT, OFFSET); | |
| // } | |
| struct InsertBitsPartialConstCase { | |
| builder::ast_type_func_ptr eType; | |
| ExprMaker makeOffset; | |
| ExprMaker makeCount; | |
| bool expectPass = true; | |
| int width = 32; | |
| }; | |
| using InsertBitsPartialConst = | |
| ResolverBuiltinsValidationTestWithParams<std::tuple<InsertBitsPartialConstCase, bool, bool>>; | |
| TEST_P(InsertBitsPartialConst, Scalar) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto eTy = params.eType(*this); | |
| const ast::Expression* offset = params.makeOffset(this); | |
| const ast::Expression* count = params.makeCount(this); | |
| const ast::Variable* offsetDecl; | |
| if (firstConst) { | |
| offsetDecl = Const("offset", offset); | |
| } else { | |
| offsetDecl = Var("offset", offset); | |
| } | |
| const ast::Variable* countDecl; | |
| if (secondConst) { | |
| countDecl = Const("count", count); | |
| } else { | |
| countDecl = Var("count", count); | |
| } | |
| WrapInFunction(Var("e", eTy), offsetDecl, countDecl, | |
| Ignore(Call(Source{{12, 34}}, "insertBits", "e", "e", "offset", "count"))); | |
| const auto expectPass = params.expectPass || !(firstConst && secondConst); | |
| if (expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| const std::string expect = | |
| "12:34 error: 'offset' + 'count' must be less than or equal to the bit width of 'e'"; | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| TEST_P(InsertBitsPartialConst, Vector) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto eTy = params.eType(*this); | |
| const ast::Expression* offset = params.makeOffset(this); | |
| const ast::Expression* count = params.makeCount(this); | |
| const ast::Variable* offsetDecl; | |
| if (firstConst) { | |
| offsetDecl = Const("offset", offset); | |
| } else { | |
| offsetDecl = Var("offset", offset); | |
| } | |
| const ast::Variable* countDecl; | |
| if (secondConst) { | |
| countDecl = Const("count", count); | |
| } else { | |
| countDecl = Var("count", count); | |
| } | |
| WrapInFunction(Var("e", eTy), offsetDecl, countDecl, // | |
| Ignore(Call(Source{{12, 34}}, "insertBits", // | |
| Call(Ident("vec3"), "e", "e", "e"), // | |
| Call(Ident("vec3"), "e", "e", "e"), // | |
| "offset", "count"))); | |
| const auto expectPass = params.expectPass || !(firstConst && secondConst); | |
| if (expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| const std::string expect = | |
| "12:34 error: 'offset' + 'count' must be less than or equal to the bit width of 'e'"; | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| std::vector<InsertBitsPartialConstCase> insertBitsCases() { | |
| return std::vector<InsertBitsPartialConstCase>{ | |
| // Simple passing cases. | |
| {DataType<u32>::AST, Mk(0_a), Mk(0_a), true}, | |
| {DataType<i32>::AST, Mk(0_a), Mk(0_a), true}, | |
| {DataType<u32>::AST, Mk(16_a), Mk(16_a), true}, | |
| {DataType<i32>::AST, Mk(16_a), Mk(16_a), true}, | |
| {DataType<u32>::AST, Mk(32_a), Mk(0_a), true}, | |
| {DataType<i32>::AST, Mk(32_a), Mk(0_a), true}, | |
| {DataType<u32>::AST, Mk(0_a), Mk(0_a), true}, | |
| {DataType<i32>::AST, Mk(0_a), Mk(0_a), true}, | |
| {DataType<u32>::AST, Mk(32_a), Mk(0_u), true}, | |
| {DataType<i32>::AST, Mk(32_u), Mk(0_a), true}, | |
| // AInt AInt | |
| {DataType<u32>::AST, Mk(0_a), Mk(33_a), false}, | |
| {DataType<u32>::AST, Mk(16_a), Mk(17_a), false}, | |
| {DataType<u32>::AST, Mk(33_a), Mk(0_a), false}, | |
| {DataType<i32>::AST, Mk(0_a), Mk(33_u), false}, // Aint u32 | |
| {DataType<i32>::AST, Mk(16_u), Mk(17_a), false}, // u32 AInt | |
| }; | |
| } | |
| INSTANTIATE_TEST_SUITE_P(InsertBits, | |
| InsertBitsPartialConst, | |
| ::testing::Combine(::testing::ValuesIn(insertBitsCases()), | |
| ::testing::ValuesIn({true}), | |
| ::testing::ValuesIn({true}))); | |
| // We'll construct cases like this: | |
| // fn foo() { | |
| // var e: ETYPE; | |
| // _ = extractBits(e, COUNT, OFFSET); | |
| // } | |
| struct ExtractBitsPartialConstCase { | |
| builder::ast_type_func_ptr eType; | |
| ExprMaker makeOffset; | |
| ExprMaker makeCount; | |
| bool expectPass = true; | |
| int width = 32; | |
| }; | |
| using ExtractBitsPartialConst = | |
| ResolverBuiltinsValidationTestWithParams<std::tuple<ExtractBitsPartialConstCase, bool, bool>>; | |
| TEST_P(ExtractBitsPartialConst, Scalar) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto eTy = params.eType(*this); | |
| const ast::Expression* offset = params.makeOffset(this); | |
| const ast::Expression* count = params.makeCount(this); | |
| const ast::Variable* offsetDecl; | |
| if (firstConst) { | |
| offsetDecl = Const("offset", offset); | |
| } else { | |
| offsetDecl = Var("offset", offset); | |
| } | |
| const ast::Variable* countDecl; | |
| if (secondConst) { | |
| countDecl = Const("count", count); | |
| } else { | |
| countDecl = Var("count", count); | |
| } | |
| WrapInFunction(Var("e", eTy), offsetDecl, countDecl, | |
| Ignore(Call(Source{{12, 34}}, "extractBits", "e", "offset", "count"))); | |
| const auto expectPass = params.expectPass || !(firstConst && secondConst); | |
| if (expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| const std::string expect = | |
| "12:34 error: 'offset' + 'count' must be less than or equal to the bit width of 'e'"; | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| TEST_P(ExtractBitsPartialConst, Vector) { | |
| auto [params, firstConst, secondConst] = GetParam(); | |
| auto eTy = params.eType(*this); | |
| const ast::Expression* offset = params.makeOffset(this); | |
| const ast::Expression* count = params.makeCount(this); | |
| const ast::Variable* offsetDecl; | |
| if (firstConst) { | |
| offsetDecl = Const("offset", offset); | |
| } else { | |
| offsetDecl = Var("offset", offset); | |
| } | |
| const ast::Variable* countDecl; | |
| if (secondConst) { | |
| countDecl = Const("count", count); | |
| } else { | |
| countDecl = Var("count", count); | |
| } | |
| WrapInFunction(Var("e", eTy), offsetDecl, countDecl, // | |
| Ignore(Call(Source{{12, 34}}, "extractBits", // | |
| Call(Ident("vec3"), "e", "e", "e"), // | |
| "offset", "count"))); | |
| const auto expectPass = params.expectPass || !(firstConst && secondConst); | |
| if (expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| const std::string expect = | |
| "12:34 error: 'offset' + 'count' must be less than or equal to the bit width of 'e'"; | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| std::vector<ExtractBitsPartialConstCase> extractBitsCases() { | |
| return std::vector<ExtractBitsPartialConstCase>{ | |
| // Simple passing cases. | |
| {DataType<u32>::AST, Mk(0_a), Mk(0_a), true}, | |
| {DataType<i32>::AST, Mk(0_a), Mk(0_a), true}, | |
| {DataType<u32>::AST, Mk(16_a), Mk(16_a), true}, | |
| {DataType<i32>::AST, Mk(16_a), Mk(16_a), true}, | |
| {DataType<u32>::AST, Mk(32_a), Mk(0_a), true}, | |
| {DataType<i32>::AST, Mk(32_a), Mk(0_a), true}, | |
| {DataType<u32>::AST, Mk(0_a), Mk(0_a), true}, | |
| {DataType<i32>::AST, Mk(0_a), Mk(0_a), true}, | |
| {DataType<u32>::AST, Mk(32_a), Mk(0_u), true}, | |
| {DataType<i32>::AST, Mk(32_u), Mk(0_a), true}, | |
| // AInt AInt | |
| {DataType<u32>::AST, Mk(0_a), Mk(33_a), false}, | |
| {DataType<u32>::AST, Mk(16_a), Mk(17_a), false}, | |
| {DataType<u32>::AST, Mk(33_a), Mk(0_a), false}, | |
| {DataType<i32>::AST, Mk(0_a), Mk(33_u), false}, // Aint u32 | |
| {DataType<i32>::AST, Mk(16_u), Mk(17_a), false}, // u32 AInt | |
| }; | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ExtractBits, | |
| ExtractBitsPartialConst, | |
| ::testing::Combine(::testing::ValuesIn(extractBitsCases()), | |
| ::testing::ValuesIn({true}), | |
| ::testing::ValuesIn({true}))); | |
| // We'll construct cases like this: | |
| // fn foo() { | |
| // var x: XTYPE; | |
| // _ = ldexp(x, EXPONENT); | |
| // } | |
| struct LdexpPartialConstCase { | |
| builder::ast_type_func_ptr eType; | |
| ExprMaker makeExponent; | |
| bool expectPass = true; | |
| int highestAllowed = 128; | |
| }; | |
| using LdexpPartialConst = ResolverBuiltinsValidationTestWithParams<LdexpPartialConstCase>; | |
| TEST_P(LdexpPartialConst, Scalar) { | |
| auto params = GetParam(); | |
| auto xTy = params.eType(*this); | |
| const ast::Expression* exponent = params.makeExponent(this); | |
| Enable(wgsl::Extension::kF16); | |
| WrapInFunction(Var("x", xTy), Ignore(Call(Source{{12, 34}}, "ldexp", "x", exponent))); | |
| if (params.expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| const std::string expect = "12:34 error: e2 must be less than or equal to " + | |
| std::to_string(params.highestAllowed); | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| TEST_P(LdexpPartialConst, Vector) { | |
| auto params = GetParam(); | |
| auto xTy = params.eType(*this); | |
| const ast::Expression* exponent = params.makeExponent(this); | |
| Enable(wgsl::Extension::kF16); | |
| WrapInFunction(Var("x", xTy), // | |
| Ignore(Call(Source{{12, 34}}, "ldexp", // | |
| Call(Ident("vec3"), "x", "x", "x"), // | |
| Call(Ident("vec3"), Expr(0_a), exponent, Expr(1_a))))); | |
| if (params.expectPass) { | |
| EXPECT_TRUE(r()->Resolve()); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| const std::string expect = "12:34 error: e2 must be less than or equal to " + | |
| std::to_string(params.highestAllowed); | |
| EXPECT_EQ(r()->error(), expect); | |
| } | |
| } | |
| std::vector<LdexpPartialConstCase> ldexpCases() { | |
| // Abstract Float cases don't apply here, because if the first parameter | |
| // is abstract float, then it must be const already. So that case is | |
| // already checked by the full const-eval rules. | |
| return std::vector<LdexpPartialConstCase>{ | |
| // Simple passing cases. | |
| {DataType<f32>::AST, Mk(128_a), true}, | |
| {DataType<f32>::AST, Mk(128_i), true}, | |
| {DataType<f32>::AST, Mk(-5000_a), true}, | |
| {DataType<f32>::AST, Mk(-5000_i), true}, | |
| {DataType<f16>::AST, Mk(16_a), true}, | |
| {DataType<f16>::AST, Mk(16_i), true}, | |
| {DataType<f16>::AST, Mk(-5000_a), true}, | |
| {DataType<f16>::AST, Mk(-5000_i), true}, | |
| // Failing cases | |
| {DataType<f32>::AST, Mk(129_a), false, 128}, | |
| {DataType<f32>::AST, Mk(129_i), false, 128}, | |
| {DataType<f32>::AST, Mk(5000_a), false, 128}, | |
| {DataType<f32>::AST, Mk(5000_i), false, 128}, | |
| {DataType<f16>::AST, Mk(17_a), false, 16}, | |
| {DataType<f16>::AST, Mk(17_i), false, 16}, | |
| {DataType<f16>::AST, Mk(5000_a), false, 16}, | |
| {DataType<f16>::AST, Mk(5000_i), false, 16}, | |
| }; | |
| } | |
| INSTANTIATE_TEST_SUITE_P(Ldexp, LdexpPartialConst, ::testing::ValuesIn(ldexpCases())); | |
| } // namespace | |
| } // namespace tint::resolver |