| // Copyright 2021 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/transform/localize_struct_array_assignment.h" |
| #include "src/transform/simplify_pointers.h" |
| #include "src/transform/unshadow.h" |
| |
| #include "src/transform/test_helper.h" |
| |
| namespace tint { |
| namespace transform { |
| namespace { |
| |
| using LocalizeStructArrayAssignmentTest = TransformTest; |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, MissingSimplifyPointers) { |
| auto* src = R"()"; |
| auto* expect = |
| "error: tint::transform::LocalizeStructArrayAssignment depends on " |
| "tint::transform::SimplifyPointers but the dependency was not run"; |
| |
| auto got = Run<LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, EmptyModule) { |
| auto* src = R"()"; |
| auto* expect = src; |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, StructArray) { |
| auto* src = R"( |
| [[block]] struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct OuterS { |
| a1 : array<InnerS, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| s1.a1[uniforms.i] = v; |
| } |
| )"; |
| |
| auto* expect = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct OuterS { |
| a1 : array<InnerS, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| { |
| let tint_symbol = &(s1.a1); |
| var tint_symbol_1 = *(tint_symbol); |
| tint_symbol_1[uniforms.i] = v; |
| *(tint_symbol) = tint_symbol_1; |
| } |
| } |
| )"; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, StructStructArray) { |
| auto* src = R"( |
| [[block]] struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct S1 { |
| a : array<InnerS, 8>; |
| }; |
| |
| struct OuterS { |
| s2 : S1; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| s1.s2.a[uniforms.i] = v; |
| } |
| )"; |
| |
| auto* expect = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct S1 { |
| a : array<InnerS, 8>; |
| }; |
| |
| struct OuterS { |
| s2 : S1; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| { |
| let tint_symbol = &(s1.s2.a); |
| var tint_symbol_1 = *(tint_symbol); |
| tint_symbol_1[uniforms.i] = v; |
| *(tint_symbol) = tint_symbol_1; |
| } |
| } |
| )"; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, StructArrayArray) { |
| auto* src = R"( |
| [[block]] struct Uniforms { |
| i : u32; |
| j : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct OuterS { |
| a1 : array<array<InnerS, 8>, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| s1.a1[uniforms.i][uniforms.j] = v; |
| } |
| )"; |
| |
| auto* expect = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| j : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct OuterS { |
| a1 : array<array<InnerS, 8>, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| { |
| let tint_symbol = &(s1.a1); |
| var tint_symbol_1 = *(tint_symbol); |
| tint_symbol_1[uniforms.i][uniforms.j] = v; |
| *(tint_symbol) = tint_symbol_1; |
| } |
| } |
| )"; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, StructArrayStruct) { |
| auto* src = R"( |
| [[block]] struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct S1 { |
| s2 : InnerS; |
| }; |
| |
| struct OuterS { |
| a1 : array<S1, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| s1.a1[uniforms.i].s2 = v; |
| } |
| )"; |
| |
| auto* expect = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct S1 { |
| s2 : InnerS; |
| }; |
| |
| struct OuterS { |
| a1 : array<S1, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| { |
| let tint_symbol = &(s1.a1); |
| var tint_symbol_1 = *(tint_symbol); |
| tint_symbol_1[uniforms.i].s2 = v; |
| *(tint_symbol) = tint_symbol_1; |
| } |
| } |
| )"; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, StructArrayStructArray) { |
| auto* src = R"( |
| [[block]] struct Uniforms { |
| i : u32; |
| j : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct S1 { |
| a2 : array<InnerS, 8>; |
| }; |
| |
| struct OuterS { |
| a1 : array<S1, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s : OuterS; |
| s.a1[uniforms.i].a2[uniforms.j] = v; |
| } |
| )"; |
| |
| auto* expect = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| j : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct S1 { |
| a2 : array<InnerS, 8>; |
| }; |
| |
| struct OuterS { |
| a1 : array<S1, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s : OuterS; |
| { |
| let tint_symbol = &(s.a1); |
| var tint_symbol_1 = *(tint_symbol); |
| let tint_symbol_2 = &(tint_symbol_1[uniforms.i].a2); |
| var tint_symbol_3 = *(tint_symbol_2); |
| tint_symbol_3[uniforms.j] = v; |
| *(tint_symbol_2) = tint_symbol_3; |
| *(tint_symbol) = tint_symbol_1; |
| } |
| } |
| )"; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, IndexingWithSideEffectFunc) { |
| auto* src = R"( |
| [[block]] struct Uniforms { |
| i : u32; |
| j : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct S1 { |
| a2 : array<InnerS, 8>; |
| }; |
| |
| struct OuterS { |
| a1 : array<S1, 8>; |
| }; |
| |
| var<private> nextIndex : u32; |
| fn getNextIndex() -> u32 { |
| nextIndex = nextIndex + 1u; |
| return nextIndex; |
| } |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s : OuterS; |
| s.a1[getNextIndex()].a2[uniforms.j] = v; |
| } |
| )"; |
| |
| auto* expect = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| j : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct S1 { |
| a2 : array<InnerS, 8>; |
| }; |
| |
| struct OuterS { |
| a1 : array<S1, 8>; |
| }; |
| |
| var<private> nextIndex : u32; |
| |
| fn getNextIndex() -> u32 { |
| nextIndex = (nextIndex + 1u); |
| return nextIndex; |
| } |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s : OuterS; |
| { |
| let tint_symbol = &(s.a1); |
| var tint_symbol_1 = *(tint_symbol); |
| let tint_symbol_2 = &(tint_symbol_1[getNextIndex()].a2); |
| var tint_symbol_3 = *(tint_symbol_2); |
| tint_symbol_3[uniforms.j] = v; |
| *(tint_symbol_2) = tint_symbol_3; |
| *(tint_symbol) = tint_symbol_1; |
| } |
| } |
| )"; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, ViaPointerArg) { |
| auto* src = R"( |
| [[block]] struct Uniforms { |
| i : u32; |
| }; |
| struct InnerS { |
| v : i32; |
| }; |
| struct OuterS { |
| a1 : array<InnerS, 8>; |
| }; |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| fn f(p : ptr<function, OuterS>) { |
| var v : InnerS; |
| (*p).a1[uniforms.i] = v; |
| } |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var s1 : OuterS; |
| f(&s1); |
| } |
| )"; |
| |
| auto* expect = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct OuterS { |
| a1 : array<InnerS, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| fn f(p : ptr<function, OuterS>) { |
| var v : InnerS; |
| { |
| let tint_symbol = &((*(p)).a1); |
| var tint_symbol_1 = *(tint_symbol); |
| tint_symbol_1[uniforms.i] = v; |
| *(tint_symbol) = tint_symbol_1; |
| } |
| } |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var s1 : OuterS; |
| f(&(s1)); |
| } |
| )"; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, ViaPointerVar) { |
| auto* src = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct OuterS { |
| a1 : array<InnerS, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| fn f(p : ptr<function, InnerS>, v : InnerS) { |
| *(p) = v; |
| } |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| let p = &(s1.a1[uniforms.i]); |
| *(p) = v; |
| } |
| )"; |
| |
| auto* expect = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| }; |
| |
| struct InnerS { |
| v : i32; |
| }; |
| |
| struct OuterS { |
| a1 : array<InnerS, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| fn f(p : ptr<function, InnerS>, v : InnerS) { |
| *(p) = v; |
| } |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var v : InnerS; |
| var s1 : OuterS; |
| let p_save = uniforms.i; |
| { |
| let tint_symbol = &(s1.a1); |
| var tint_symbol_1 = *(tint_symbol); |
| tint_symbol_1[p_save] = v; |
| *(tint_symbol) = tint_symbol_1; |
| } |
| } |
| )"; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| TEST_F(LocalizeStructArrayAssignmentTest, VectorAssignment) { |
| auto* src = R"( |
| [[block]] |
| struct Uniforms { |
| i : u32; |
| }; |
| |
| [[block]] |
| struct OuterS { |
| a1 : array<u32, 8>; |
| }; |
| |
| [[group(1), binding(4)]] var<uniform> uniforms : Uniforms; |
| |
| fn f(i : u32) -> u32 { |
| return (i + 1u); |
| } |
| |
| [[stage(compute), workgroup_size(1)]] |
| fn main() { |
| var s1 : OuterS; |
| var v : vec3<f32>; |
| v[s1.a1[uniforms.i]] = 1.0; |
| v[f(s1.a1[uniforms.i])] = 1.0; |
| } |
| )"; |
| |
| // Transform does nothing here as we're not actually assigning to the array in |
| // the struct. |
| auto* expect = src; |
| |
| auto got = |
| Run<Unshadow, SimplifyPointers, LocalizeStructArrayAssignment>(src); |
| EXPECT_EQ(expect, str(got)); |
| } |
| |
| } // namespace |
| } // namespace transform |
| } // namespace tint |