blob: f01b4da7a3afe94f50813f0b918406aa0671a883 [file] [log] [blame]
// Copyright 2023 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 "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/var.h"
#include "src/tint/lang/wgsl/ast/case_selector.h"
#include "src/tint/lang/wgsl/ast/int_literal_expression.h"
#include "src/tint/lang/wgsl/helpers/ir_program_test.h"
namespace tint::wgsl {
namespace {
using namespace tint::core::fluent_types; // NOLINT
using namespace tint::core::number_suffixes; // NOLINT
using ProgramToIRShadowingTest = helpers::IRProgramTest;
////////////////////////////////////////////////////////////////////////////////
// Shadowing tests
////////////////////////////////////////////////////////////////////////////////
TEST_F(ProgramToIRShadowingTest, Shadow_Struct_With_FnVar) {
auto m = Build(R"(
struct S {
i : i32,
}
fn f() -> i32 {
var S : S = S();
return S.i;
}
)");
ASSERT_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, Shadow_Struct_With_Param) {
auto m = Build(R"(
struct S {
i : i32,
}
fn f(S : S) -> i32 {
return S.i;
}
)");
ASSERT_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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:i32 = let %6 # %i_1: 'i'
ret %i_1
}
}
)");
}
TEST_F(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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:i32 = let %6 # %i_1: 'i'
ret %i_1
}
}
%8:i32 = load %i
ret %8
}
}
)");
}
TEST_F(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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:i32 = let %6 # %i_1: 'i'
ret %i_1
}
%b3 = block { # continuing
next_iteration %b2
}
}
%8:i32 = load %i
ret %8
}
}
)");
}
TEST_F(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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
}
}
%6:f32 = load %i_1
%j:f32 = let %6
continue %b6
}
}
%8:i32 = load %i
ret %8
}
}
)");
}
TEST_F(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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:i32 = let %7 # %i_1: 'i'
ret %i_1
}
}
%9:i32 = load %i
ret %9
}
}
)");
}
TEST_F(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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:i32 = let %6 # %i_1: 'i'
%8:bool = eq %i_1, 3i
if %8 [t: %b5] { # if_2
%b5 = block { # true
exit_loop # loop_1
}
}
continue %b3
}
%b3 = block { # continuing
next_iteration %b2
}
}
%9:i32 = load %i
ret %9
}
}
)");
}
TEST_F(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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:i32 = let %6 # %i_1: 'i'
%8:bool = gt %i_1, 2i
break_if %8 %b2
}
}
%9:i32 = load %i
ret %9
}
}
)");
}
TEST_F(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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(ProgramToIRShadowingTest, 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_EQ(m, Success);
EXPECT_EQ(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:i32 = let %6 # %i_1: 'i'
ret %i_1
}
%b4 = block { # case
%8:i32 = load %i
ret %8
}
}
unreachable
}
}
)");
}
} // namespace
} // namespace tint::wgsl