| // Copyright 2022 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 "src/tint/lang/wgsl/resolver/resolver.h" | |
| #include "src/tint/lang/wgsl/resolver/resolver_helper_test.h" | |
| #include "src/tint/utils/text/string_stream.h" | |
| #include "gmock/gmock.h" | |
| namespace tint::resolver { | |
| namespace { | |
| using namespace tint::core::fluent_types; // NOLINT | |
| using namespace tint::core::number_suffixes; // NOLINT | |
| struct ResolverAliasAnalysisTest : public resolver::TestHelper, public testing::Test {}; | |
| // Base test harness for tests that pass two pointers to a function. | |
| // | |
| // fn target(p1 : ptr<function, i32>, p2 : ptr<function, i32>) { | |
| // <test statements> | |
| // } | |
| // fn caller() { | |
| // var v1 : i32; | |
| // var v2 : i32; | |
| // target(&v1, aliased ? &v1 : &v2); | |
| // } | |
| struct TwoPointerConfig { | |
| const core::AddressSpace address_space; // The address space for the pointers. | |
| const bool aliased; // Whether the pointers alias or not. | |
| }; | |
| class TwoPointers : public ResolverTestWithParam<TwoPointerConfig> { | |
| protected: | |
| void SetUp() override { | |
| Vector<const ast::Statement*, 4> body; | |
| if (GetParam().address_space == core::AddressSpace::kFunction) { | |
| body.Push(Decl(Var("v1", ty.i32()))); | |
| body.Push(Decl(Var("v2", ty.i32()))); | |
| } else { | |
| GlobalVar("v1", core::AddressSpace::kPrivate, ty.i32()); | |
| GlobalVar("v2", core::AddressSpace::kPrivate, ty.i32()); | |
| } | |
| body.Push(CallStmt(Call("target", AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, GetParam().aliased ? "v1" : "v2")))); | |
| Func("caller", tint::Empty, ty.void_(), body); | |
| } | |
| void Run(Vector<const ast::Statement*, 4>&& body, const char* err = nullptr) { | |
| auto addrspace = GetParam().address_space; | |
| Func("target", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(addrspace)), | |
| Param("p2", ty.ptr<i32>(addrspace)), | |
| }, | |
| ty.void_(), std::move(body)); | |
| if (GetParam().aliased && err) { | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), err); | |
| } else { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| } | |
| }; | |
| TEST_P(TwoPointers, ReadRead) { | |
| // _ = *p1; | |
| // _ = *p2; | |
| Run({ | |
| Assign(Phony(), Deref("p1")), | |
| Assign(Phony(), Deref("p2")), | |
| }); | |
| } | |
| TEST_P(TwoPointers, ReadWrite) { | |
| // _ = *p1; | |
| // *p2 = 42; | |
| Run( | |
| { | |
| Assign(Phony(), Deref("p1")), | |
| Assign(Deref("p2"), 42_a), | |
| }, | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(TwoPointers, WriteRead) { | |
| // *p1 = 42; | |
| // _ = *p2; | |
| Run( | |
| { | |
| Assign(Deref("p1"), 42_a), | |
| Assign(Phony(), Deref("p2")), | |
| }, | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(TwoPointers, WriteWrite) { | |
| // *p1 = 42; | |
| // *p2 = 42; | |
| Run( | |
| { | |
| Assign(Deref("p1"), 42_a), | |
| Assign(Deref("p2"), 42_a), | |
| }, | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(TwoPointers, ReadWriteThroughChain) { | |
| // fn f2(p1 : ptr<function, i32>, p2 : ptr<function, i32>) { | |
| // _ = *p1; | |
| // *p2 = 42; | |
| // } | |
| // fn f1(p1 : ptr<function, i32>, p2 : ptr<function, i32>) { | |
| // f2(p1, p2); | |
| // } | |
| // | |
| // f1(p1, p2); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(GetParam().address_space)), | |
| Param("p2", ty.ptr<i32>(GetParam().address_space)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), Deref("p1")), | |
| Assign(Deref("p2"), 42_a), | |
| }); | |
| Func("f1", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(GetParam().address_space)), | |
| Param("p2", ty.ptr<i32>(GetParam().address_space)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f2", "p1", "p2")), | |
| }); | |
| Run( | |
| { | |
| CallStmt(Call("f1", "p1", "p2")), | |
| }, | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(TwoPointers, ReadWriteAcrossDifferentFunctions) { | |
| // fn f1(p1 : ptr<function, i32>) { | |
| // _ = *p1; | |
| // } | |
| // fn f2(p2 : ptr<function, i32>) { | |
| // *p2 = 42; | |
| // } | |
| // | |
| // f1(p1); | |
| // f2(p2); | |
| Func("f1", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(GetParam().address_space)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), Deref("p1")), | |
| }); | |
| Func("f2", | |
| Vector{ | |
| Param("p2", ty.ptr<i32>(GetParam().address_space)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Deref("p2"), 42_a), | |
| }); | |
| Run( | |
| { | |
| CallStmt(Call("f1", "p1")), | |
| CallStmt(Call("f2", "p2")), | |
| }, | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, | |
| TwoPointers, | |
| ::testing::Values(TwoPointerConfig{core::AddressSpace::kFunction, false}, | |
| TwoPointerConfig{core::AddressSpace::kFunction, true}, | |
| TwoPointerConfig{core::AddressSpace::kPrivate, false}, | |
| TwoPointerConfig{core::AddressSpace::kPrivate, true}), | |
| [](const ::testing::TestParamInfo<TwoPointers::ParamType>& p) { | |
| StringStream ss; | |
| ss << (p.param.aliased ? "Aliased" : "Unaliased") << "_" | |
| << p.param.address_space; | |
| return ss.str(); | |
| }); | |
| // Base test harness for tests that pass a pointer to a function that references a module-scope var. | |
| // | |
| // var<private> global_1 : i32; | |
| // var<private> global_2 : i32; | |
| // fn target(p1 : ptr<private, i32>) { | |
| // <test statements> | |
| // } | |
| // fn caller() { | |
| // target(aliased ? &global_1 : &global_2); | |
| // } | |
| class OnePointerOneModuleScope : public ResolverTestWithParam<bool> { | |
| protected: | |
| void SetUp() override { | |
| GlobalVar("global_1", core::AddressSpace::kPrivate, ty.i32()); | |
| GlobalVar("global_2", core::AddressSpace::kPrivate, ty.i32()); | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("target", | |
| AddressOf(Source{{12, 34}}, GetParam() ? "global_1" : "global_2"))), | |
| }); | |
| } | |
| void Run(Vector<const ast::Statement*, 4>&& body, const char* err = nullptr) { | |
| Func("target", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), std::move(body)); | |
| if (GetParam() && err) { | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), err); | |
| } else { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| } | |
| }; | |
| TEST_P(OnePointerOneModuleScope, ReadRead) { | |
| // _ = *p1; | |
| // _ = global_1; | |
| Run({ | |
| Assign(Phony(), Deref("p1")), | |
| Assign(Phony(), "global_1"), | |
| }); | |
| } | |
| TEST_P(OnePointerOneModuleScope, ReadWrite) { | |
| // _ = *p1; | |
| // global_1 = 42; | |
| Run( | |
| { | |
| Assign(Phony(), Deref("p1")), | |
| Assign(Expr(Source{{56, 78}}, "global_1"), 42_a), | |
| }, | |
| R"(12:34 error: invalid aliased pointer argument | |
| 56:78 note: aliases with module-scope variable write in 'target')"); | |
| } | |
| TEST_P(OnePointerOneModuleScope, WriteRead) { | |
| // *p1 = 42; | |
| // _ = global_1; | |
| Run( | |
| { | |
| Assign(Deref("p1"), 42_a), | |
| Assign(Phony(), Expr(Source{{56, 78}}, "global_1")), | |
| }, | |
| R"(12:34 error: invalid aliased pointer argument | |
| 56:78 note: aliases with module-scope variable read in 'target')"); | |
| } | |
| TEST_P(OnePointerOneModuleScope, WriteWrite) { | |
| // *p1 = 42; | |
| // global_1 = 42; | |
| Run( | |
| { | |
| Assign(Deref("p1"), 42_a), | |
| Assign(Expr(Source{{56, 78}}, "global_1"), 42_a), | |
| }, | |
| R"(12:34 error: invalid aliased pointer argument | |
| 56:78 note: aliases with module-scope variable write in 'target')"); | |
| } | |
| TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_GlobalViaArg) { | |
| // fn f2(p1 : ptr<private, i32>) { | |
| // *p1 = 42; | |
| // } | |
| // fn f1(p1 : ptr<private, i32>) { | |
| // _ = *p1; | |
| // f2(&global_1); | |
| // } | |
| // | |
| // f1(p1); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Deref("p1"), 42_a), | |
| }); | |
| Func("f1", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), Deref("p1")), | |
| CallStmt(Call("f2", AddressOf(Source{{56, 78}}, "global_1"))), | |
| }); | |
| Run( | |
| { | |
| CallStmt(Call("f1", "p1")), | |
| }, | |
| R"(12:34 error: invalid aliased pointer argument | |
| 56:78 note: aliases with module-scope variable write in 'f1')"); | |
| } | |
| TEST_P(OnePointerOneModuleScope, ReadWriteThroughChain_Both) { | |
| // fn f2(p1 : ptr<private, i32>) { | |
| // _ = *p1; | |
| // global_1 = 42; | |
| // } | |
| // fn f1(p1 : ptr<private, i32>) { | |
| // f2(p1); | |
| // } | |
| // | |
| // f1(p1); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), Deref("p1")), | |
| Assign(Expr(Source{{56, 78}}, "global_1"), 42_a), | |
| }); | |
| Func("f1", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f2", "p1")), | |
| }); | |
| Run( | |
| { | |
| CallStmt(Call("f1", "p1")), | |
| }, | |
| R"(12:34 error: invalid aliased pointer argument | |
| 56:78 note: aliases with module-scope variable write in 'f2')"); | |
| } | |
| TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_GlobalViaArg) { | |
| // fn f2(p1 : ptr<private, i32>) { | |
| // _ = *p1; | |
| // } | |
| // fn f1(p1 : ptr<private, i32>) { | |
| // *p1 = 42; | |
| // f2(&global_1); | |
| // } | |
| // | |
| // f1(p1); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), Deref("p1")), | |
| }); | |
| Func("f1", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Deref("p1"), 42_a), | |
| CallStmt(Call("f2", AddressOf(Source{{56, 78}}, "global_1"))), | |
| }); | |
| Run( | |
| { | |
| CallStmt(Call("f1", "p1")), | |
| }, | |
| R"(12:34 error: invalid aliased pointer argument | |
| 56:78 note: aliases with module-scope variable read in 'f1')"); | |
| } | |
| TEST_P(OnePointerOneModuleScope, WriteReadThroughChain_Both) { | |
| // fn f2(p1 : ptr<private, i32>) { | |
| // *p1 = 42; | |
| // _ = global_1; | |
| // } | |
| // fn f1(p1 : ptr<private, i32>) { | |
| // f2(p1); | |
| // } | |
| // | |
| // f1(p1); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Deref("p1"), 42_a), | |
| Assign(Phony(), Expr(Source{{56, 78}}, "global_1")), | |
| }); | |
| Func("f1", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f2", "p1")), | |
| }); | |
| Run( | |
| { | |
| CallStmt(Call("f1", "p1")), | |
| }, | |
| R"(12:34 error: invalid aliased pointer argument | |
| 56:78 note: aliases with module-scope variable read in 'f2')"); | |
| } | |
| TEST_P(OnePointerOneModuleScope, ReadWriteAcrossDifferentFunctions) { | |
| // fn f1(p1 : ptr<private, i32>) { | |
| // _ = *p1; | |
| // } | |
| // fn f2() { | |
| // global_1 = 42; | |
| // } | |
| // | |
| // f1(p1); | |
| // f2(); | |
| Func("f1", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kPrivate)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), Deref("p1")), | |
| }); | |
| Func("f2", tint::Empty, ty.void_(), | |
| Vector{ | |
| Assign(Expr(Source{{56, 78}}, "global_1"), 42_a), | |
| }); | |
| Run( | |
| { | |
| CallStmt(Call("f1", "p1")), | |
| CallStmt(Call("f2")), | |
| }, | |
| R"(12:34 error: invalid aliased pointer argument | |
| 56:78 note: aliases with module-scope variable write in 'f2')"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, | |
| OnePointerOneModuleScope, | |
| ::testing::Values(false, true), | |
| [](const ::testing::TestParamInfo<bool>& p) { | |
| return p.param ? "Aliased" : "Unaliased"; | |
| }); | |
| // Base test harness for tests that use a potentially aliased pointer in a variety of expressions. | |
| // | |
| // fn target(p1 : ptr<function, i32>, p2 : ptr<function, i32>) { | |
| // *p1 = 42; | |
| // <test statements> | |
| // } | |
| // fn caller() { | |
| // var v1 : i32; | |
| // var v2 : i32; | |
| // target(&v1, aliased ? &v1 : &v2); | |
| // } | |
| class Use : public ResolverTestWithParam<bool> { | |
| protected: | |
| void SetUp() override { | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v1", ty.i32())), | |
| Decl(Var("v2", ty.i32())), | |
| CallStmt(Call("target", AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, GetParam() ? "v1" : "v2"))), | |
| }); | |
| } | |
| void Run(const ast::Statement* stmt, const char* err = nullptr) { | |
| Func("target", | |
| Vector{ | |
| Param("p1", ty.ptr<i32>(core::AddressSpace::kFunction)), | |
| Param("p2", ty.ptr<i32>(core::AddressSpace::kFunction)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Deref("p1"), 42_a), | |
| stmt, | |
| }); | |
| if (GetParam() && err) { | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), err); | |
| } else { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| } | |
| }; | |
| TEST_P(Use, NoAccess) { | |
| // Expect no errors even when aliasing occurs. | |
| Run(Assign(Phony(), 42_a)); | |
| } | |
| TEST_P(Use, Write_Increment) { | |
| // (*p2)++; | |
| Run(Increment(Deref("p2")), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Write_Decrement) { | |
| // (*p2)--; | |
| Run(Decrement(Deref("p2")), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Write_CompoundAssignment_LHS) { | |
| // *p2 += 42; | |
| Run(CompoundAssign(Deref("p2"), 42_a, core::BinaryOp::kAdd), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_CompoundAssignment_RHS) { | |
| // var<private> global : i32; | |
| // global += *p2; | |
| GlobalVar("global", core::AddressSpace::kPrivate, ty.i32()); | |
| Run(CompoundAssign("global", Deref("p2"), core::BinaryOp::kAdd), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_BinaryOp_LHS) { | |
| // _ = (*p2) + 1; | |
| Run(Assign(Phony(), Add(Deref("p2"), 1_a)), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_BinaryOp_RHS) { | |
| // _ = 1 + (*p2); | |
| Run(Assign(Phony(), Add(1_a, Deref("p2"))), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_UnaryMinus) { | |
| // _ = -(*p2); | |
| Run(Assign(Phony(), Negation(Deref("p2"))), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_FunctionCallArg) { | |
| // abs(*p2); | |
| Run(Assign(Phony(), Call("abs", Deref("p2"))), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_Bitcast) { | |
| // _ = bitcast<f32>(*p2); | |
| Run(Assign(Phony(), Bitcast<f32>(Deref("p2"))), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_Convert) { | |
| // _ = f32(*p2); | |
| Run(Assign(Phony(), Call<f32>(Deref("p2"))), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_IndexAccessor) { | |
| // var<private> data : array<f32, 4>; | |
| // _ = data[*p2]; | |
| GlobalVar("data", core::AddressSpace::kPrivate, ty.array<f32, 4>()); | |
| Run(Assign(Phony(), IndexAccessor("data", Deref("p2"))), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_LetInitializer) { | |
| // let x = *p2; | |
| Run(Decl(Let("x", Deref("p2"))), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_VarInitializer) { | |
| // var x = *p2; | |
| Run(Decl(Var("x", core::AddressSpace::kFunction, Deref("p2"))), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_ReturnValue) { | |
| // fn foo(p : ptr<function, i32>) -> i32 { return *p; } | |
| // foo(p2); | |
| Func("foo", | |
| Vector{ | |
| Param("p", ty.ptr<i32>(core::AddressSpace::kFunction)), | |
| }, | |
| ty.i32(), | |
| Vector{ | |
| Return(Deref("p")), | |
| }); | |
| Run(Assign(Phony(), Call("foo", "p2")), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, Read_Switch) { | |
| // Switch (*p2) { default {} } | |
| Run(Switch(Deref("p2"), Vector{DefaultCase(Block())}), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(Use, NoAccess_AddressOf_Deref) { | |
| // Should not invoke the load-rule, and therefore expect no errors even when aliasing occurs. | |
| // let newp = &(*p2); | |
| Run(Decl(Let("newp", AddressOf(Deref("p2"))))); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, | |
| Use, | |
| ::testing::Values(false, true), | |
| [](const ::testing::TestParamInfo<bool>& p) { | |
| return p.param ? "Aliased" : "Unaliased"; | |
| }); | |
| // Base test harness for tests that use a potentially aliased pointer in a variety of expressions. | |
| // As above, but using the bool type to test expressions that invoke that load-rule for booleans. | |
| // | |
| // fn target(p1 : ptr<function, bool>, p2 : ptr<function, bool>) { | |
| // *p1 = true; | |
| // <test statements> | |
| // } | |
| // fn caller() { | |
| // var v1 : bool; | |
| // var v2 : bool; | |
| // target(&v1, aliased ? &v1 : &v2); | |
| // } | |
| class UseBool : public ResolverTestWithParam<bool> { | |
| protected: | |
| void SetUp() override { | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v1", ty.bool_())), | |
| Decl(Var("v2", ty.bool_())), | |
| CallStmt(Call("target", AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, GetParam() ? "v1" : "v2"))), | |
| }); | |
| } | |
| void Run(const ast::Statement* stmt, const char* err = nullptr) { | |
| Func("target", | |
| Vector{ | |
| Param("p1", ty.ptr<bool>(core::AddressSpace::kFunction)), | |
| Param("p2", ty.ptr<bool>(core::AddressSpace::kFunction)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Deref("p1"), true), | |
| stmt, | |
| }); | |
| if (GetParam() && err) { | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), err); | |
| } else { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| } | |
| }; | |
| TEST_P(UseBool, Read_IfCond) { | |
| // if (*p2) {} | |
| Run(If(Deref("p2"), Block()), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(UseBool, Read_WhileCond) { | |
| // while (*p2) {} | |
| Run(While(Deref("p2"), Block()), R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(UseBool, Read_ForCond) { | |
| // for (; *p2; ) {} | |
| Run(For(nullptr, Deref("p2"), nullptr, Block()), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(UseBool, Read_BreakIf) { | |
| // loop { continuing { break if (*p2); } } | |
| Run(Loop(Block(), Block(BreakIf(Deref("p2")))), | |
| R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, | |
| UseBool, | |
| ::testing::Values(false, true), | |
| [](const ::testing::TestParamInfo<bool>& p) { | |
| return p.param ? "Aliased" : "Unaliased"; | |
| }); | |
| TEST_F(ResolverAliasAnalysisTest, NoAccess_MemberAccessor) { | |
| // Should not invoke the load-rule, and therefore expect no errors even when aliasing occurs. | |
| // | |
| // struct S { a : i32 } | |
| // fn f2(p1 : ptr<function, S>, p2 : ptr<function, S>) { | |
| // let newp = &((*p2).a); | |
| // (*p1).a = 42; | |
| // } | |
| // fn f1() { | |
| // var v : S; | |
| // f2(&v, &v); | |
| // } | |
| Structure("S", Vector{Member("a", ty.i32())}); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<function>(ty("S"))), | |
| Param("p2", ty.ptr<function>(ty("S"))), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Decl(Let("newp", AddressOf(MemberAccessor(Deref("p2"), "a")))), | |
| Assign(MemberAccessor(Deref("p1"), "a"), 42_a), | |
| }); | |
| Func("f1", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty("S"))), | |
| CallStmt(Call("f2", AddressOf("v"), AddressOf("v"))), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverAliasAnalysisTest, Read_MemberAccessor) { | |
| // struct S { a : i32 } | |
| // fn f2(p1 : ptr<function, S>, p2 : ptr<function, S>) { | |
| // _ = (*p2).a; | |
| // *p1 = S(); | |
| // } | |
| // fn f1() { | |
| // var v : S; | |
| // f2(&v, &v); | |
| // } | |
| Structure("S", Vector{Member("a", ty.i32())}); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<function>(ty("S"))), | |
| Param("p2", ty.ptr<function>(ty("S"))), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), MemberAccessor(Deref("p2"), "a")), | |
| Assign(Deref("p1"), Call("S")), | |
| }); | |
| Func("f1", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty("S"))), | |
| CallStmt( | |
| Call("f2", AddressOf(Source{{12, 34}}, "v"), AddressOf(Source{{56, 76}}, "v"))), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), R"(56:76 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_F(ResolverAliasAnalysisTest, Write_MemberAccessor) { | |
| // struct S { a : i32 } | |
| // fn f2(p1 : ptr<function, S>, p2 : ptr<function, S>) { | |
| // _ = *p2; | |
| // (*p1).a = 42; | |
| // } | |
| // fn f1() { | |
| // var v : S; | |
| // f2(&v, &v); | |
| // } | |
| Structure("S", Vector{Member("a", ty.i32())}); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<function>(ty("S"))), | |
| Param("p2", ty.ptr<function>(ty("S"))), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), Deref("p2")), | |
| Assign(MemberAccessor(Deref("p1"), "a"), 42_a), | |
| }); | |
| Func("f1", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty("S"))), | |
| CallStmt( | |
| Call("f2", AddressOf(Source{{12, 34}}, "v"), AddressOf(Source{{56, 76}}, "v"))), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), R"(56:76 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_F(ResolverAliasAnalysisTest, Read_MultiComponentSwizzle) { | |
| // fn f2(p1 : ptr<function, vec4<f32>, p2 : ptr<function, vec4<f32>) { | |
| // _ = (*p2).zy; | |
| // *p1 = vec4<f32>(); | |
| // } | |
| // fn f1() { | |
| // var v : vec4<f32>; | |
| // f2(&v, &v); | |
| // } | |
| Structure("S", Vector{Member("a", ty.i32())}); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<function, vec4<f32>>()), | |
| Param("p2", ty.ptr<function, vec4<f32>>()), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), MemberAccessor(Deref("p2"), "zy")), | |
| Assign(Deref("p1"), Call<vec4<f32>>()), | |
| }); | |
| Func("f1", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty.vec4<f32>())), | |
| CallStmt( | |
| Call("f2", AddressOf(Source{{12, 34}}, "v"), AddressOf(Source{{56, 76}}, "v"))), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), R"(56:76 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_F(ResolverAliasAnalysisTest, Read_MultiComponentSwizzle_FromPointer) { | |
| // fn f2(p1 : ptr<function, vec4<f32>, p2 : ptr<function, vec4<f32>) { | |
| // _ = p2.zy; | |
| // *p1 = vec4<f32>(); | |
| // } | |
| // fn f1() { | |
| // var v : vec4<f32>; | |
| // f2(&v, &v); | |
| // } | |
| Structure("S", Vector{Member("a", ty.i32())}); | |
| Func("f2", | |
| Vector{ | |
| Param("p1", ty.ptr<function, vec4<f32>>()), | |
| Param("p2", ty.ptr<function, vec4<f32>>()), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Phony(), MemberAccessor("p2", "zy")), | |
| Assign(Deref("p1"), Call<vec4<f32>>()), | |
| }); | |
| Func("f1", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty.vec4<f32>())), | |
| CallStmt( | |
| Call("f2", AddressOf(Source{{12, 34}}, "v"), AddressOf(Source{{56, 76}}, "v"))), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), R"(56:76 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_F(ResolverAliasAnalysisTest, SinglePointerReadWrite) { | |
| // Test that we can both read and write from a single pointer parameter. | |
| // | |
| // fn f1(p : ptr<function, i32>) { | |
| // _ = *p; | |
| // *p = 42; | |
| // } | |
| // fn f2() { | |
| // var v : i32; | |
| // f1(&v); | |
| // } | |
| Func("f1", | |
| Vector{ | |
| Param("p", ty.ptr<i32>(core::AddressSpace::kFunction)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty.i32())), | |
| Assign(Phony(), Deref("p")), | |
| Assign(Deref("p"), 42_a), | |
| }); | |
| Func("f2", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty.i32())), | |
| CallStmt(Call("f1", AddressOf("v"))), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverAliasAnalysisTest, AliasingInsideFunction) { | |
| // Test that we can use two aliased pointers inside the same function they are created in. | |
| // | |
| // fn f1() { | |
| // var v : i32; | |
| // let p1 = &v; | |
| // let p2 = &v; | |
| // *p1 = 42; | |
| // *p2 = 42; | |
| // } | |
| Func("f1", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty.i32())), | |
| Decl(Let("p1", AddressOf("v"))), | |
| Decl(Let("p2", AddressOf("v"))), | |
| Assign(Deref("p1"), 42_a), | |
| Assign(Deref("p2"), 42_a), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverAliasAnalysisTest, NonOverlappingCalls) { | |
| // Test that we pass the same pointer to multiple non-overlapping function calls. | |
| // | |
| // fn f2(p : ptr<function, i32>) { | |
| // *p = 42; | |
| // } | |
| // fn f3(p : ptr<function, i32>) { | |
| // *p = 42; | |
| // } | |
| // fn f1() { | |
| // var v : i32; | |
| // f2(&v); | |
| // f3(&v); | |
| // } | |
| Func("f2", | |
| Vector{ | |
| Param("p", ty.ptr<i32>(core::AddressSpace::kFunction)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Deref("p"), 42_a), | |
| }); | |
| Func("f3", | |
| Vector{ | |
| Param("p", ty.ptr<i32>(core::AddressSpace::kFunction)), | |
| }, | |
| ty.void_(), | |
| Vector{ | |
| Assign(Deref("p"), 42_a), | |
| }); | |
| Func("f1", tint::Empty, ty.void_(), | |
| Vector{ | |
| Decl(Var("v", ty.i32())), | |
| CallStmt(Call("f2", AddressOf("v"))), | |
| CallStmt(Call("f3", AddressOf("v"))), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| // Atomics | |
| //////////////////////////////////////////////////////////////////////////////// | |
| class AtomicPointers | |
| : public ResolverTestWithParam< | |
| std::tuple<wgsl::BuiltinFn, wgsl::BuiltinFn, core::AddressSpace, bool /* aliased */>> { | |
| protected: | |
| static constexpr std::string_view kPass = "<PASS>"; | |
| ast::Type Ptr() { | |
| auto address_space = std::get<2>(GetParam()); | |
| if (address_space == storage) { | |
| return ty.ptr<storage, atomic<i32>, read_write>(); | |
| } else { | |
| return ty.ptr<atomic<i32>>(address_space); | |
| } | |
| } | |
| void SetUp() override { | |
| auto address_space = std::get<2>(GetParam()); | |
| if (address_space == storage) { | |
| GlobalVar("v1", address_space, read_write, ty.Of<atomic<i32>>(), // | |
| Binding(0_a), Group(0_a)); | |
| GlobalVar("v2", address_space, read_write, ty.Of<atomic<i32>>(), // | |
| Binding(1_a), Group(0_a)); | |
| } else { | |
| GlobalVar("v1", address_space, ty.Of<atomic<i32>>()); | |
| GlobalVar("v2", address_space, ty.Of<atomic<i32>>()); | |
| } | |
| } | |
| bool IsWrite(wgsl::BuiltinFn fn) const { | |
| switch (fn) { | |
| case wgsl::BuiltinFn::kAtomicStore: | |
| case wgsl::BuiltinFn::kAtomicAdd: | |
| case wgsl::BuiltinFn::kAtomicSub: | |
| case wgsl::BuiltinFn::kAtomicMax: | |
| case wgsl::BuiltinFn::kAtomicMin: | |
| case wgsl::BuiltinFn::kAtomicAnd: | |
| case wgsl::BuiltinFn::kAtomicOr: | |
| case wgsl::BuiltinFn::kAtomicXor: | |
| case wgsl::BuiltinFn::kAtomicExchange: | |
| case wgsl::BuiltinFn::kAtomicCompareExchangeWeak: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| bool ShouldPass() const { | |
| auto [builtin_a, builtin_b, space, aliased] = GetParam(); | |
| bool fail = aliased && (IsWrite(builtin_a) || IsWrite(builtin_b)); | |
| return !fail; | |
| } | |
| const ast::Statement* CallBuiltin(wgsl::BuiltinFn fn, std::string_view ptr) { | |
| switch (fn) { | |
| case wgsl::BuiltinFn::kAtomicLoad: | |
| return CallStmt(Call(fn, ptr)); | |
| case wgsl::BuiltinFn::kAtomicStore: | |
| case wgsl::BuiltinFn::kAtomicAdd: | |
| case wgsl::BuiltinFn::kAtomicSub: | |
| case wgsl::BuiltinFn::kAtomicMax: | |
| case wgsl::BuiltinFn::kAtomicMin: | |
| case wgsl::BuiltinFn::kAtomicAnd: | |
| case wgsl::BuiltinFn::kAtomicOr: | |
| case wgsl::BuiltinFn::kAtomicXor: | |
| case wgsl::BuiltinFn::kAtomicExchange: | |
| return CallStmt(Call(fn, ptr, 42_a)); | |
| case wgsl::BuiltinFn::kAtomicCompareExchangeWeak: | |
| return CallStmt(Call(fn, ptr, 10_a, 42_a)); | |
| default: | |
| TINT_UNIMPLEMENTED() << fn; | |
| } | |
| } | |
| std::string Run() { | |
| if (r()->Resolve()) { | |
| return std::string(kPass); | |
| } | |
| return r()->error(); | |
| } | |
| }; | |
| TEST_P(AtomicPointers, CallDirect) { | |
| // var<ADDRESS_SPACE> v1 : atomic<i32>; | |
| // var<ADDRESS_SPACE> v2 : atomic<i32>; | |
| // | |
| // fn caller() { | |
| // callee(&v1, aliased ? &v1 : &v2); | |
| // } | |
| // | |
| // fn callee(p1 : PTR, p2 : PTR) { | |
| // <builtin-a>(p1); | |
| // <builtin-b>(p2); | |
| // } | |
| auto [builtin_a, builtin_b, space, aliased] = GetParam(); | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("callee", // | |
| AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, aliased ? "v1" : "v2"))), | |
| }); | |
| Func("callee", Vector{Param("p1", Ptr()), Param("p2", Ptr())}, ty.void_(), | |
| Vector{ | |
| CallBuiltin(builtin_a, "p1"), | |
| CallBuiltin(builtin_b, "p2"), | |
| }); | |
| EXPECT_EQ(Run(), ShouldPass() ? kPass : R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(AtomicPointers, CallThroughChain) { | |
| // var<ADDRESS_SPACE> v1 : atomic<i32>; | |
| // var<ADDRESS_SPACE> v2 : atomic<i32>; | |
| // | |
| // fn caller() { | |
| // callee(&v1, aliased ? &v1 : &v2); | |
| // } | |
| // | |
| // fn f2(p1 : PTR, p2 : PTR) { | |
| // f1(p1, p2); | |
| // } | |
| // | |
| // fn f1(p1 : PTR, p2 : PTR) { | |
| // callee(p1, p2); | |
| // } | |
| // | |
| // fn callee(p1 : PTR, p2 : PTR) { | |
| // <builtin-a>(p1); | |
| // <builtin-b>(p2); | |
| // } | |
| auto [builtin_a, builtin_b, space, aliased] = GetParam(); | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("callee", // | |
| AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, aliased ? "v1" : "v2"))), | |
| }); | |
| Func("f2", Vector{Param("p1", Ptr()), Param("p2", Ptr())}, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f1", "p1", "p2")), | |
| }); | |
| Func("f1", Vector{Param("p1", Ptr()), Param("p2", Ptr())}, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("callee", "p1", "p2")), | |
| }); | |
| Func("callee", Vector{Param("p1", Ptr()), Param("p2", Ptr())}, ty.void_(), | |
| Vector{ | |
| CallBuiltin(builtin_a, "p1"), | |
| CallBuiltin(builtin_b, "p2"), | |
| }); | |
| EXPECT_EQ(Run(), ShouldPass() ? kPass : R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(AtomicPointers, ReadWriteAcrossDifferentFunctions) { | |
| // var<ADDRESS_SPACE> v1 : atomic<i32>; | |
| // var<ADDRESS_SPACE> v2 : atomic<i32>; | |
| // | |
| // fn caller() { | |
| // f(&v1, aliased ? &v1 : &v2); | |
| // } | |
| // | |
| // fn f(p1 : PTR, p2 : PTR) { | |
| // f1(p1); | |
| // f2(p2); | |
| // } | |
| // | |
| // fn f1(p : PTR) { | |
| // <builtin-a>(p); | |
| // } | |
| // | |
| // fn f2(p : PTR) { | |
| // <builtin-b>(p); | |
| // } | |
| auto [builtin_a, builtin_b, space, aliased] = GetParam(); | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f", // | |
| AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, aliased ? "v1" : "v2"))), | |
| }); | |
| Func("f", Vector{Param("p1", Ptr()), Param("p2", Ptr())}, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f1", "p1")), | |
| CallStmt(Call("f2", "p2")), | |
| }); | |
| Func("f1", Vector{Param("p", Ptr())}, ty.void_(), | |
| Vector{ | |
| CallBuiltin(builtin_a, "p"), | |
| }); | |
| Func("f2", Vector{Param("p", Ptr())}, ty.void_(), | |
| Vector{ | |
| CallBuiltin(builtin_b, "p"), | |
| }); | |
| EXPECT_EQ(Run(), ShouldPass() ? kPass : R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| std::array kAtomicFns{ | |
| wgsl::BuiltinFn::kAtomicLoad, | |
| wgsl::BuiltinFn::kAtomicStore, | |
| wgsl::BuiltinFn::kAtomicAdd, | |
| wgsl::BuiltinFn::kAtomicSub, | |
| wgsl::BuiltinFn::kAtomicMax, | |
| wgsl::BuiltinFn::kAtomicMin, | |
| wgsl::BuiltinFn::kAtomicAnd, | |
| wgsl::BuiltinFn::kAtomicOr, | |
| wgsl::BuiltinFn::kAtomicXor, | |
| wgsl::BuiltinFn::kAtomicExchange, | |
| wgsl::BuiltinFn::kAtomicCompareExchangeWeak, | |
| }; | |
| INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, | |
| AtomicPointers, | |
| ::testing::Combine(::testing::ValuesIn(kAtomicFns), | |
| ::testing::ValuesIn(kAtomicFns), | |
| ::testing::Values(core::AddressSpace::kWorkgroup, | |
| core::AddressSpace::kStorage), | |
| ::testing::Values(true, false))); | |
| //////////////////////////////////////////////////////////////////////////////// | |
| // WorkgroupUniformLoad | |
| //////////////////////////////////////////////////////////////////////////////// | |
| enum class WorkgroupUniformLoadAction { | |
| kRead, | |
| kWrite, | |
| kWorkgroupUniformLoad, | |
| }; | |
| std::array kWorkgroupUniformLoadActions{ | |
| WorkgroupUniformLoadAction::kRead, | |
| WorkgroupUniformLoadAction::kWrite, | |
| WorkgroupUniformLoadAction::kWorkgroupUniformLoad, | |
| }; | |
| class WorkgroupUniformLoad | |
| : public ResolverTestWithParam< | |
| std::tuple<WorkgroupUniformLoadAction, WorkgroupUniformLoadAction, bool>> { | |
| protected: | |
| static constexpr std::string_view kPass = "<PASS>"; | |
| void SetUp() override { | |
| GlobalVar("v1", workgroup, ty.i32()); | |
| GlobalVar("v2", workgroup, ty.i32()); | |
| } | |
| const ast::Statement* Do(WorkgroupUniformLoadAction action, std::string_view ptr) { | |
| switch (action) { | |
| case WorkgroupUniformLoadAction::kRead: | |
| return Assign(Phony(), Deref(ptr)); | |
| case WorkgroupUniformLoadAction::kWrite: | |
| return Assign(Deref(ptr), 42_a); | |
| case WorkgroupUniformLoadAction::kWorkgroupUniformLoad: | |
| return Assign(Phony(), Call(wgsl::BuiltinFn::kWorkgroupUniformLoad, ptr)); | |
| } | |
| return nullptr; | |
| } | |
| bool IsWrite(WorkgroupUniformLoadAction action) const { | |
| return action == WorkgroupUniformLoadAction::kWrite; | |
| } | |
| bool ShouldPass() const { | |
| auto [action_a, action_b, aliased] = GetParam(); | |
| bool fail = aliased && (IsWrite(action_a) || IsWrite(action_b)); | |
| return !fail; | |
| } | |
| std::string Run() { | |
| if (r()->Resolve()) { | |
| return std::string(kPass); | |
| } | |
| return r()->error(); | |
| } | |
| }; | |
| TEST_P(WorkgroupUniformLoad, CallDirect) { | |
| // var<workgroup> v1 : i32; | |
| // var<workgroup> v2 : i32; | |
| // | |
| // fn caller() { | |
| // callee(&v1, aliased ? &v1 : &v2); | |
| // } | |
| // | |
| // fn callee(p1 : PTR, p2 : PTR) { | |
| // <action-a>(p1); | |
| // <action-b>(p2); | |
| // } | |
| auto [action_a, action_b, aliased] = GetParam(); | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("callee", // | |
| AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, aliased ? "v1" : "v2"))), | |
| }); | |
| Func("callee", | |
| Vector{Param("p1", ty.ptr<workgroup, i32>()), Param("p2", ty.ptr<workgroup, i32>())}, | |
| ty.void_(), | |
| Vector{ | |
| Do(action_a, "p1"), | |
| Do(action_b, "p2"), | |
| }); | |
| EXPECT_EQ(Run(), ShouldPass() ? kPass : R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(WorkgroupUniformLoad, CallThroughChain) { | |
| // var<workgroup> v1 : i32; | |
| // var<workgroup> v2 : i32; | |
| // | |
| // fn caller() { | |
| // callee(&v1, aliased ? &v1 : &v2); | |
| // } | |
| // | |
| // fn f2(p1 : PTR, p2 : PTR) { | |
| // f1(p1, p2); | |
| // } | |
| // | |
| // fn f1(p1 : PTR, p2 : PTR) { | |
| // callee(p1, p2); | |
| // } | |
| // | |
| // fn callee(p1 : PTR, p2 : PTR) { | |
| // <action-a>(p1); | |
| // <action-b>(p2); | |
| // } | |
| auto [action_a, action_b, aliased] = GetParam(); | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("callee", // | |
| AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, aliased ? "v1" : "v2"))), | |
| }); | |
| Func("f2", Vector{Param("p1", ty.ptr<workgroup, i32>()), Param("p2", ty.ptr<workgroup, i32>())}, | |
| ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f1", "p1", "p2")), | |
| }); | |
| Func("f1", Vector{Param("p1", ty.ptr<workgroup, i32>()), Param("p2", ty.ptr<workgroup, i32>())}, | |
| ty.void_(), | |
| Vector{ | |
| CallStmt(Call("callee", "p1", "p2")), | |
| }); | |
| Func("callee", | |
| Vector{Param("p1", ty.ptr<workgroup, i32>()), Param("p2", ty.ptr<workgroup, i32>())}, | |
| ty.void_(), | |
| Vector{ | |
| Do(action_a, "p1"), | |
| Do(action_b, "p2"), | |
| }); | |
| EXPECT_EQ(Run(), ShouldPass() ? kPass : R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| TEST_P(WorkgroupUniformLoad, ReadWriteAcrossDifferentFunctions) { | |
| // var<workgroup> v1 : i32; | |
| // var<workgroup> v2 : i32; | |
| // | |
| // fn caller() { | |
| // f(&v1, aliased ? &v1 : &v2); | |
| // } | |
| // | |
| // fn f(p1 : PTR, p2 : PTR) { | |
| // f1(p1); | |
| // f2(p2); | |
| // } | |
| // | |
| // fn f1(p : PTR) { | |
| // <action-a>(p); | |
| // } | |
| // | |
| // fn f2(p : PTR) { | |
| // <action-b>(p); | |
| // } | |
| auto [action_a, action_b, aliased] = GetParam(); | |
| Func("caller", tint::Empty, ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f", // | |
| AddressOf(Source{{12, 34}}, "v1"), | |
| AddressOf(Source{{56, 78}}, aliased ? "v1" : "v2"))), | |
| }); | |
| Func("f", Vector{Param("p1", ty.ptr<workgroup, i32>()), Param("p2", ty.ptr<workgroup, i32>())}, | |
| ty.void_(), | |
| Vector{ | |
| CallStmt(Call("f1", "p1")), | |
| CallStmt(Call("f2", "p2")), | |
| }); | |
| Func("f1", Vector{Param("p", ty.ptr<workgroup, i32>())}, ty.void_(), Vector{Do(action_a, "p")}); | |
| Func("f2", Vector{Param("p", ty.ptr<workgroup, i32>())}, ty.void_(), Vector{Do(action_b, "p")}); | |
| EXPECT_EQ(Run(), ShouldPass() ? kPass : R"(56:78 error: invalid aliased pointer argument | |
| 12:34 note: aliases with another argument passed here)"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverAliasAnalysisTest, | |
| WorkgroupUniformLoad, | |
| ::testing::Combine(::testing::ValuesIn(kWorkgroupUniformLoadActions), | |
| ::testing::ValuesIn(kWorkgroupUniformLoadActions), | |
| ::testing::Values(true, false))); | |
| } // namespace | |
| } // namespace tint::resolver |