| // Copyright 2023 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 "gmock/gmock.h" |
| #include "src/tint/lang/core/constant/scalar.h" |
| #include "src/tint/lang/core/ir/block.h" |
| #include "src/tint/lang/core/ir/constant.h" |
| #include "src/tint/lang/core/ir/program_test_helper.h" |
| #include "src/tint/lang/core/ir/var.h" |
| #include "src/tint/lang/wgsl/ast/case_selector.h" |
| #include "src/tint/lang/wgsl/ast/int_literal_expression.h" |
| |
| namespace tint::ir { |
| namespace { |
| |
| using namespace tint::builtin::fluent_types; // NOLINT |
| using namespace tint::number_suffixes; // NOLINT |
| |
| using IR_FromProgramShadowingTest = ProgramTestHelper; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Shadowing tests |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IR_FromProgramShadowingTest, Shadow_Struct_With_FnVar) { |
| auto m = Build(R"( |
| struct S { |
| i : i32, |
| } |
| |
| fn f() -> i32 { |
| var S : S = S(); |
| return S.i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| S = struct @align(4) { |
| i:i32 @offset(0) |
| } |
| |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %S:ptr<function, S, read_write> = var, S(0i) |
| %3:ptr<function, i32, read_write> = access %S, 0u |
| %4:i32 = load %3 |
| ret %4 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_Struct_With_Param) { |
| auto m = Build(R"( |
| struct S { |
| i : i32, |
| } |
| |
| fn f(S : S) -> i32 { |
| return S.i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| S = struct @align(4) { |
| i:i32 @offset(0) |
| } |
| |
| %f = func(%S:S):i32 -> %b1 { |
| %b1 = block { |
| %3:i32 = access %S, 0u |
| ret %3 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_ModVar_With_FnVar) { |
| auto m = Build(R"( |
| var<private> i : i32 = 1i; |
| |
| fn f() -> i32 { |
| i = (i + 1i); |
| var i : i32 = (i + 1i); |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %b1 = block { # root |
| %i:ptr<private, i32, read_write> = var, 1i |
| } |
| |
| %f = func():i32 -> %b2 { |
| %b2 = block { |
| %3:i32 = load %i |
| %4:i32 = add %3, 1i |
| store %i, %4 |
| %5:i32 = load %i |
| %6:i32 = add %5, 1i |
| %i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i' |
| %8:i32 = load %i_1 |
| ret %8 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_ModVar_With_FnLet) { |
| auto m = Build(R"( |
| var<private> i : i32 = 1i; |
| |
| fn f() -> i32 { |
| i = (i + 1i); |
| let i = (i + 1i); |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %b1 = block { # root |
| %i:ptr<private, i32, read_write> = var, 1i |
| } |
| |
| %f = func():i32 -> %b2 { |
| %b2 = block { |
| %3:i32 = load %i |
| %4:i32 = add %3, 1i |
| store %i, %4 |
| %5:i32 = load %i |
| %i_1:i32 = add %5, 1i # %i_1: 'i' |
| ret %i_1 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_IfVar) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| if (true) { |
| i = (i + 1i); |
| var i : i32 = (i + 1i); |
| i = (i + 1i); |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| if true [t: %b2] { # if_1 |
| %b2 = block { # true |
| %3:i32 = load %i |
| %4:i32 = add %3, 1i |
| store %i, %4 |
| %5:i32 = load %i |
| %6:i32 = add %5, 1i |
| %i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i' |
| %8:i32 = load %i_1 |
| %9:i32 = add %8, 1i |
| store %i_1, %9 |
| exit_if # if_1 |
| } |
| } |
| %10:i32 = load %i |
| ret %10 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_IfLet) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| if (true) { |
| i = (i + 1i); |
| let i = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| if true [t: %b2] { # if_1 |
| %b2 = block { # true |
| %3:i32 = load %i |
| %4:i32 = add %3, 1i |
| store %i, %4 |
| %5:i32 = load %i |
| %i_1:i32 = add %5, 1i # %i_1: 'i' |
| ret %i_1 |
| } |
| } |
| %7:i32 = load %i |
| ret %7 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_WhileVar) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| while((i < 4i)) { |
| var i : i32 = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [b: %b2, c: %b3] { # loop_1 |
| %b2 = block { # body |
| %3:i32 = load %i |
| %4:bool = lt %3, 4i |
| if %4 [t: %b4, f: %b5] { # if_1 |
| %b4 = block { # true |
| exit_if # if_1 |
| } |
| %b5 = block { # false |
| exit_loop # loop_1 |
| } |
| } |
| %5:i32 = load %i |
| %6:i32 = add %5, 1i |
| %i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i' |
| %8:i32 = load %i_1 |
| ret %8 |
| } |
| %b3 = block { # continuing |
| next_iteration %b2 |
| } |
| } |
| %9:i32 = load %i |
| ret %9 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_WhileLet) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| while((i < 4i)) { |
| let i = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [b: %b2, c: %b3] { # loop_1 |
| %b2 = block { # body |
| %3:i32 = load %i |
| %4:bool = lt %3, 4i |
| if %4 [t: %b4, f: %b5] { # if_1 |
| %b4 = block { # true |
| exit_if # if_1 |
| } |
| %b5 = block { # false |
| exit_loop # loop_1 |
| } |
| } |
| %5:i32 = load %i |
| %i_1:i32 = add %5, 1i # %i_1: 'i' |
| ret %i_1 |
| } |
| %b3 = block { # continuing |
| next_iteration %b2 |
| } |
| } |
| %7:i32 = load %i |
| ret %7 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_ForInitVar) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| for(var i : f32 = 0.0f; (i < 4.0f); ) { |
| let j = i; |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [i: %b2, b: %b3] { # loop_1 |
| %b2 = block { # initializer |
| %i_1:ptr<function, f32, read_write> = var, 0.0f # %i_1: 'i' |
| next_iteration %b3 |
| } |
| %b3 = block { # body |
| %4:f32 = load %i_1 |
| %5:bool = lt %4, 4.0f |
| if %5 [t: %b4, f: %b5] { # if_1 |
| %b4 = block { # true |
| exit_if # if_1 |
| } |
| %b5 = block { # false |
| exit_loop # loop_1 |
| } |
| } |
| %j:f32 = load %i_1 |
| continue %b6 |
| } |
| } |
| %7:i32 = load %i |
| ret %7 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_ForInitLet) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| for(let i = 0.0f; (i < 4.0f); ) { |
| let j = i; |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [i: %b2, b: %b3] { # loop_1 |
| %b2 = block { # initializer |
| %i_1:f32 = let 0.0f # %i_1: 'i' |
| next_iteration %b3 |
| } |
| %b3 = block { # body |
| %4:bool = lt %i_1, 4.0f |
| if %4 [t: %b4, f: %b5] { # if_1 |
| %b4 = block { # true |
| exit_if # if_1 |
| } |
| %b5 = block { # false |
| exit_loop # loop_1 |
| } |
| } |
| %j:f32 = let %i_1 |
| continue %b6 |
| } |
| } |
| %6:i32 = load %i |
| ret %6 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_ForBodyVar) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| for(var x : i32 = 0i; (i < 4i); ) { |
| var i : i32 = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [i: %b2, b: %b3] { # loop_1 |
| %b2 = block { # initializer |
| %x:ptr<function, i32, read_write> = var, 0i |
| next_iteration %b3 |
| } |
| %b3 = block { # body |
| %4:i32 = load %i |
| %5:bool = lt %4, 4i |
| if %5 [t: %b4, f: %b5] { # if_1 |
| %b4 = block { # true |
| exit_if # if_1 |
| } |
| %b5 = block { # false |
| exit_loop # loop_1 |
| } |
| } |
| %6:i32 = load %i |
| %7:i32 = add %6, 1i |
| %i_1:ptr<function, i32, read_write> = var, %7 # %i_1: 'i' |
| %9:i32 = load %i_1 |
| ret %9 |
| } |
| } |
| %10:i32 = load %i |
| ret %10 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_ForBodyLet) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| for(var x : i32 = 0i; (i < 4i); ) { |
| let i = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [i: %b2, b: %b3] { # loop_1 |
| %b2 = block { # initializer |
| %x:ptr<function, i32, read_write> = var, 0i |
| next_iteration %b3 |
| } |
| %b3 = block { # body |
| %4:i32 = load %i |
| %5:bool = lt %4, 4i |
| if %5 [t: %b4, f: %b5] { # if_1 |
| %b4 = block { # true |
| exit_if # if_1 |
| } |
| %b5 = block { # false |
| exit_loop # loop_1 |
| } |
| } |
| %6:i32 = load %i |
| %i_1:i32 = add %6, 1i # %i_1: 'i' |
| ret %i_1 |
| } |
| } |
| %8:i32 = load %i |
| ret %8 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_LoopBodyVar) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| loop { |
| if ((i == 2i)) { |
| break; |
| } |
| var i : i32 = (i + 1i); |
| if ((i == 3i)) { |
| break; |
| } |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [b: %b2, c: %b3] { # loop_1 |
| %b2 = block { # body |
| %3:i32 = load %i |
| %4:bool = eq %3, 2i |
| if %4 [t: %b4] { # if_1 |
| %b4 = block { # true |
| exit_loop # loop_1 |
| } |
| } |
| %5:i32 = load %i |
| %6:i32 = add %5, 1i |
| %i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i' |
| %8:i32 = load %i_1 |
| %9:bool = eq %8, 3i |
| if %9 [t: %b5] { # if_2 |
| %b5 = block { # true |
| exit_loop # loop_1 |
| } |
| } |
| continue %b3 |
| } |
| %b3 = block { # continuing |
| next_iteration %b2 |
| } |
| } |
| %10:i32 = load %i |
| ret %10 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_LoopBodyLet) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| loop { |
| if ((i == 2i)) { |
| break; |
| } |
| let i = (i + 1i); |
| if ((i == 3i)) { |
| break; |
| } |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [b: %b2, c: %b3] { # loop_1 |
| %b2 = block { # body |
| %3:i32 = load %i |
| %4:bool = eq %3, 2i |
| if %4 [t: %b4] { # if_1 |
| %b4 = block { # true |
| exit_loop # loop_1 |
| } |
| } |
| %5:i32 = load %i |
| %i_1:i32 = add %5, 1i # %i_1: 'i' |
| %7:bool = eq %i_1, 3i |
| if %7 [t: %b5] { # if_2 |
| %b5 = block { # true |
| exit_loop # loop_1 |
| } |
| } |
| continue %b3 |
| } |
| %b3 = block { # continuing |
| next_iteration %b2 |
| } |
| } |
| %8:i32 = load %i |
| ret %8 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_LoopContinuingVar) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| loop { |
| if ((i == 2i)) { |
| break; |
| } |
| |
| continuing { |
| var i : i32 = (i + 1i); |
| break if (i > 2i); |
| } |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [b: %b2, c: %b3] { # loop_1 |
| %b2 = block { # body |
| %3:i32 = load %i |
| %4:bool = eq %3, 2i |
| if %4 [t: %b4] { # if_1 |
| %b4 = block { # true |
| exit_loop # loop_1 |
| } |
| } |
| continue %b3 |
| } |
| %b3 = block { # continuing |
| %5:i32 = load %i |
| %6:i32 = add %5, 1i |
| %i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i' |
| %8:i32 = load %i_1 |
| %9:bool = gt %8, 2i |
| break_if %9 %b2 |
| } |
| } |
| %10:i32 = load %i |
| ret %10 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_LoopContinuingLet) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| loop { |
| if ((i == 2i)) { |
| break; |
| } |
| |
| continuing { |
| let i = (i + 1i); |
| break if (i > 2i); |
| } |
| } |
| return i; |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| loop [b: %b2, c: %b3] { # loop_1 |
| %b2 = block { # body |
| %3:i32 = load %i |
| %4:bool = eq %3, 2i |
| if %4 [t: %b4] { # if_1 |
| %b4 = block { # true |
| exit_loop # loop_1 |
| } |
| } |
| continue %b3 |
| } |
| %b3 = block { # continuing |
| %5:i32 = load %i |
| %i_1:i32 = add %5, 1i # %i_1: 'i' |
| %7:bool = gt %i_1, 2i |
| break_if %7 %b2 |
| } |
| } |
| %8:i32 = load %i |
| ret %8 |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_SwitchCaseVar) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| switch(i) { |
| case 0i: { |
| return i; |
| } |
| case 1i: { |
| var i : i32 = (i + 1i); |
| return i; |
| } |
| default: { |
| return i; |
| } |
| } |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| %3:i32 = load %i |
| switch %3 [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] { # switch_1 |
| %b2 = block { # case |
| %4:i32 = load %i |
| ret %4 |
| } |
| %b3 = block { # case |
| %5:i32 = load %i |
| %6:i32 = add %5, 1i |
| %i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i' |
| %8:i32 = load %i_1 |
| ret %8 |
| } |
| %b4 = block { # case |
| %9:i32 = load %i |
| ret %9 |
| } |
| } |
| unreachable |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IR_FromProgramShadowingTest, Shadow_FnVar_With_SwitchCaseLet) { |
| auto m = Build(R"( |
| fn f() -> i32 { |
| var i : i32; |
| switch(i) { |
| case 0i: { |
| return i; |
| } |
| case 1i: { |
| let i = (i + 1i); |
| return i; |
| } |
| default: { |
| return i; |
| } |
| } |
| } |
| )"); |
| |
| ASSERT_TRUE(m) << (!m ? m.Failure() : ""); |
| |
| EXPECT_EQ("\n" + Disassemble(m.Get()), R"( |
| %f = func():i32 -> %b1 { |
| %b1 = block { |
| %i:ptr<function, i32, read_write> = var |
| %3:i32 = load %i |
| switch %3 [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] { # switch_1 |
| %b2 = block { # case |
| %4:i32 = load %i |
| ret %4 |
| } |
| %b3 = block { # case |
| %5:i32 = load %i |
| %i_1:i32 = add %5, 1i # %i_1: 'i' |
| ret %i_1 |
| } |
| %b4 = block { # case |
| %7:i32 = load %i |
| ret %7 |
| } |
| } |
| unreachable |
| } |
| } |
| )"); |
| } |
| |
| } // namespace |
| } // namespace tint::ir |