| // 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/resolver/resolver.h" | |
| #include "gtest/gtest.h" | |
| #include "src/tint/resolver/resolver_test_helper.h" | |
| #include "src/tint/sem/expression.h" | |
| #include "src/tint/sem/member_accessor_expression.h" | |
| namespace tint::resolver { | |
| namespace { | |
| struct SideEffectsTest : ResolverTest { | |
| template <typename T> | |
| void MakeSideEffectFunc(const char* name) { | |
| auto global = Sym(); | |
| Global(global, ty.Of<T>(), ast::StorageClass::kPrivate); | |
| auto local = Sym(); | |
| Func(name, {}, ty.Of<T>(), | |
| { | |
| Decl(Var(local, ty.Of<T>())), | |
| Assign(global, local), | |
| Return(global), | |
| }); | |
| } | |
| template <typename MAKE_TYPE_FUNC> | |
| void MakeSideEffectFunc(const char* name, MAKE_TYPE_FUNC make_type) { | |
| auto global = Sym(); | |
| Global(global, make_type(), ast::StorageClass::kPrivate); | |
| auto local = Sym(); | |
| Func(name, {}, make_type(), | |
| { | |
| Decl(Var(local, make_type())), | |
| Assign(global, local), | |
| Return(global), | |
| }); | |
| } | |
| }; | |
| TEST_F(SideEffectsTest, Phony) { | |
| auto* expr = Phony(); | |
| auto* body = Assign(expr, 1); | |
| WrapInFunction(body); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Literal) { | |
| auto* expr = Expr(1); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, VariableUser) { | |
| auto* var = Decl(Var("a", ty.i32())); | |
| auto* expr = Expr("a"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::VariableUser>()); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Call_Builtin_NoSE) { | |
| Global("a", ty.f32(), ast::StorageClass::kPrivate); | |
| auto* expr = Call("dpdx", "a"); | |
| Func("f", {}, ty.void_(), {Ignore(expr)}, | |
| {create<ast::StageAttribute>(ast::PipelineStage::kFragment)}); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::Call>()); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Call_Builtin_NoSE_WithSEArg) { | |
| MakeSideEffectFunc<f32>("se"); | |
| auto* expr = Call("dpdx", Call("se")); | |
| Func("f", {}, ty.void_(), {Ignore(expr)}, | |
| {create<ast::StageAttribute>(ast::PipelineStage::kFragment)}); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::Call>()); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Call_Builtin_SE) { | |
| Global("a", ty.atomic(ty.i32()), ast::StorageClass::kWorkgroup); | |
| auto* expr = Call("atomicAdd", AddressOf("a"), 1); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::Call>()); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Call_Function) { | |
| Func("f", {}, ty.i32(), {Return(1)}); | |
| auto* expr = Call("f"); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::Call>()); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Call_TypeConversion_NoSE) { | |
| auto* var = Decl(Var("a", ty.i32())); | |
| auto* expr = Construct(ty.f32(), "a"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::Call>()); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Call_TypeConversion_SE) { | |
| MakeSideEffectFunc<i32>("se"); | |
| auto* expr = Construct(ty.f32(), Call("se")); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::Call>()); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Call_TypeConstructor_NoSE) { | |
| auto* var = Decl(Var("a", ty.f32())); | |
| auto* expr = Construct(ty.f32(), "a"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::Call>()); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Call_TypeConstructor_SE) { | |
| MakeSideEffectFunc<f32>("se"); | |
| auto* expr = Construct(ty.f32(), Call("se")); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->Is<sem::Call>()); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, MemberAccessor_Struct_NoSE) { | |
| auto* s = Structure("S", {Member("m", ty.i32())}); | |
| auto* var = Decl(Var("a", ty.Of(s))); | |
| auto* expr = MemberAccessor("a", "m"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, MemberAccessor_Struct_SE) { | |
| auto* s = Structure("S", {Member("m", ty.i32())}); | |
| MakeSideEffectFunc("se", [&] { return ty.Of(s); }); | |
| auto* expr = MemberAccessor(Call("se"), "m"); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, MemberAccessor_Vector) { | |
| auto* var = Decl(Var("a", ty.vec4<f32>())); | |
| auto* expr = MemberAccessor("a", "x"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| EXPECT_TRUE(sem->Is<sem::MemberAccessorExpression>()); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, MemberAccessor_VectorSwizzleNoSE) { | |
| auto* var = Decl(Var("a", ty.vec4<f32>())); | |
| auto* expr = MemberAccessor("a", "xzyw"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| EXPECT_TRUE(sem->Is<sem::Swizzle>()); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, MemberAccessor_VectorSwizzleSE) { | |
| MakeSideEffectFunc("se", [&] { return ty.vec4<f32>(); }); | |
| auto* expr = MemberAccessor(Call("se"), "xzyw"); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| EXPECT_TRUE(sem->Is<sem::Swizzle>()); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Binary_NoSE) { | |
| auto* a = Decl(Var("a", ty.i32())); | |
| auto* b = Decl(Var("b", ty.i32())); | |
| auto* expr = Add("a", "b"); | |
| WrapInFunction(a, b, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Binary_LeftSE) { | |
| MakeSideEffectFunc<i32>("se"); | |
| auto* b = Decl(Var("b", ty.i32())); | |
| auto* expr = Add(Call("se"), "b"); | |
| WrapInFunction(b, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Binary_RightSE) { | |
| MakeSideEffectFunc<i32>("se"); | |
| auto* a = Decl(Var("a", ty.i32())); | |
| auto* expr = Add("a", Call("se")); | |
| WrapInFunction(a, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Binary_BothSE) { | |
| MakeSideEffectFunc<i32>("se1"); | |
| MakeSideEffectFunc<i32>("se2"); | |
| auto* expr = Add(Call("se1"), Call("se2")); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Unary_NoSE) { | |
| auto* var = Decl(Var("a", ty.bool_())); | |
| auto* expr = Not("a"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Unary_SE) { | |
| MakeSideEffectFunc<bool>("se"); | |
| auto* expr = Not(Call("se")); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, IndexAccessor_NoSE) { | |
| auto* var = Decl(Var("a", ty.array<i32, 10>())); | |
| auto* expr = IndexAccessor("a", 0); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, IndexAccessor_ObjSE) { | |
| MakeSideEffectFunc("se", [&] { return ty.array<i32, 10>(); }); | |
| auto* expr = IndexAccessor(Call("se"), 0); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, IndexAccessor_IndexSE) { | |
| MakeSideEffectFunc<i32>("se"); | |
| auto* var = Decl(Var("a", ty.array<i32, 10>())); | |
| auto* expr = IndexAccessor("a", Call("se")); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, IndexAccessor_BothSE) { | |
| MakeSideEffectFunc("se1", [&] { return ty.array<i32, 10>(); }); | |
| MakeSideEffectFunc<i32>("se2"); | |
| auto* expr = IndexAccessor(Call("se1"), Call("se2")); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Bitcast_NoSE) { | |
| auto* var = Decl(Var("a", ty.i32())); | |
| auto* expr = Bitcast<f32>("a"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_FALSE(sem->HasSideEffects()); | |
| } | |
| TEST_F(SideEffectsTest, Bitcast_SE) { | |
| MakeSideEffectFunc<i32>("se"); | |
| auto* expr = Bitcast<f32>(Call("se")); | |
| WrapInFunction(expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* sem = Sem().Get(expr); | |
| ASSERT_NE(sem, nullptr); | |
| EXPECT_TRUE(sem->HasSideEffects()); | |
| } | |
| } // namespace | |
| } // namespace tint::resolver |