| // Copyright 2020 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/reader/spirv/function.h" |
| #include "src/reader/spirv/parser_impl_test_helper.h" |
| #include "src/reader/spirv/spirv_tools_helpers_test.h" |
| |
| namespace tint { |
| namespace reader { |
| namespace spirv { |
| namespace { |
| |
| using ::testing::Eq; |
| using ::testing::HasSubstr; |
| |
| /// @returns a SPIR-V assembly segment which assigns debug names |
| /// to particular IDs. |
| std::string Names(std::vector<std::string> ids) { |
| std::ostringstream outs; |
| for (auto& id : ids) { |
| outs << " OpName %" << id << " \"" << id << "\"\n"; |
| } |
| return outs.str(); |
| } |
| |
| std::string CommonTypes() { |
| return |
| R"( |
| |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| |
| %bool = OpTypeBool |
| %float = OpTypeFloat 32 |
| %uint = OpTypeInt 32 0 |
| %int = OpTypeInt 32 1 |
| |
| %ptr_bool = OpTypePointer Function %bool |
| %ptr_float = OpTypePointer Function %float |
| %ptr_uint = OpTypePointer Function %uint |
| %ptr_int = OpTypePointer Function %int |
| |
| %true = OpConstantTrue %bool |
| %false = OpConstantFalse %bool |
| %float_0 = OpConstant %float 0.0 |
| %float_1p5 = OpConstant %float 1.5 |
| %uint_0 = OpConstant %uint 0 |
| %uint_1 = OpConstant %uint 1 |
| %int_m1 = OpConstant %int -1 |
| %int_0 = OpConstant %int 0 |
| %int_1 = OpConstant %int 1 |
| %int_3 = OpConstant %int 3 |
| %uint_2 = OpConstant %uint 2 |
| %uint_3 = OpConstant %uint 3 |
| %uint_4 = OpConstant %uint 4 |
| %uint_5 = OpConstant %uint 5 |
| |
| %v2int = OpTypeVector %int 2 |
| %v2float = OpTypeVector %float 2 |
| %m3v2float = OpTypeMatrix %v2float 3 |
| |
| %v2int_null = OpConstantNull %v2int |
| |
| %arr2uint = OpTypeArray %uint %uint_2 |
| %strct = OpTypeStruct %uint %float %arr2uint |
| )"; |
| } |
| |
| // Returns the SPIR-V assembly for capabilities, the memory model, |
| // a vertex shader entry point declaration, and name declarations |
| // for specified IDs. |
| std::string Caps(std::vector<std::string> ids = {}) { |
| return R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| OpEntryPoint Vertex %100 "main" |
| )" + Names(ids); |
| } |
| |
| // Returns the SPIR-V assembly for a vertex shader, optionally |
| // with OpName decorations for certain SPIR-V IDs |
| std::string PreambleNames(std::vector<std::string> ids) { |
| return Caps(ids) + CommonTypes(); |
| } |
| |
| std::string Preamble() { |
| return PreambleNames({}); |
| } |
| |
| using SpvParserFunctionVarTest = SpvParserTest; |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_AnonymousVars) { |
| auto p = parser(test::Assemble(Preamble() + R"( |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %1 = OpVariable %ptr_uint Function |
| %2 = OpVariable %ptr_uint Function |
| %3 = OpVariable %ptr_uint Function |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_1 |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| x_2 |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| x_3 |
| none |
| undefined |
| __u32 |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_NamedVars) { |
| auto p = parser(test::Assemble(PreambleNames({"a", "b", "c"}) + R"( |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %a = OpVariable %ptr_uint Function |
| %b = OpVariable %ptr_uint Function |
| %c = OpVariable %ptr_uint Function |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| a |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| b |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| c |
| none |
| undefined |
| __u32 |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_MixedTypes) { |
| auto p = parser(test::Assemble(PreambleNames({"a", "b", "c"}) + R"( |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %a = OpVariable %ptr_uint Function |
| %b = OpVariable %ptr_int Function |
| %c = OpVariable %ptr_float Function |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| a |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| b |
| none |
| undefined |
| __i32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| c |
| none |
| undefined |
| __f32 |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_ScalarInitializers) { |
| auto p = parser(test::Assemble(PreambleNames({"a", "b", "c", "d", "e"}) + R"( |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %a = OpVariable %ptr_bool Function %true |
| %b = OpVariable %ptr_bool Function %false |
| %c = OpVariable %ptr_int Function %int_m1 |
| %d = OpVariable %ptr_uint Function %uint_1 |
| %e = OpVariable %ptr_float Function %float_1p5 |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| a |
| none |
| undefined |
| __bool |
| { |
| ScalarConstructor[not set]{true} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| b |
| none |
| undefined |
| __bool |
| { |
| ScalarConstructor[not set]{false} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| c |
| none |
| undefined |
| __i32 |
| { |
| ScalarConstructor[not set]{-1} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| d |
| none |
| undefined |
| __u32 |
| { |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| e |
| none |
| undefined |
| __f32 |
| { |
| ScalarConstructor[not set]{1.500000} |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_ScalarNullInitializers) { |
| auto p = parser(test::Assemble(PreambleNames({"a", "b", "c", "d"}) + R"( |
| %null_bool = OpConstantNull %bool |
| %null_int = OpConstantNull %int |
| %null_uint = OpConstantNull %uint |
| %null_float = OpConstantNull %float |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %a = OpVariable %ptr_bool Function %null_bool |
| %b = OpVariable %ptr_int Function %null_int |
| %c = OpVariable %ptr_uint Function %null_uint |
| %d = OpVariable %ptr_float Function %null_float |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| a |
| none |
| undefined |
| __bool |
| { |
| ScalarConstructor[not set]{false} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| b |
| none |
| undefined |
| __i32 |
| { |
| ScalarConstructor[not set]{0} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| c |
| none |
| undefined |
| __u32 |
| { |
| ScalarConstructor[not set]{0u} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| d |
| none |
| undefined |
| __f32 |
| { |
| ScalarConstructor[not set]{0.000000} |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_VectorInitializer) { |
| auto p = parser(test::Assemble(Preamble() + R"( |
| %ptr = OpTypePointer Function %v2float |
| %two = OpConstant %float 2.0 |
| %const = OpConstantComposite %v2float %float_1p5 %two |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %200 = OpVariable %ptr Function %const |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __vec_2__f32 |
| { |
| TypeConstructor[not set]{ |
| __vec_2__f32 |
| ScalarConstructor[not set]{1.500000} |
| ScalarConstructor[not set]{2.000000} |
| } |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_MatrixInitializer) { |
| auto p = parser(test::Assemble(Preamble() + R"( |
| %ptr = OpTypePointer Function %m3v2float |
| %two = OpConstant %float 2.0 |
| %three = OpConstant %float 3.0 |
| %four = OpConstant %float 4.0 |
| %v0 = OpConstantComposite %v2float %float_1p5 %two |
| %v1 = OpConstantComposite %v2float %two %three |
| %v2 = OpConstantComposite %v2float %three %four |
| %const = OpConstantComposite %m3v2float %v0 %v1 %v2 |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %200 = OpVariable %ptr Function %const |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __mat_2_3__f32 |
| { |
| TypeConstructor[not set]{ |
| __mat_2_3__f32 |
| TypeConstructor[not set]{ |
| __vec_2__f32 |
| ScalarConstructor[not set]{1.500000} |
| ScalarConstructor[not set]{2.000000} |
| } |
| TypeConstructor[not set]{ |
| __vec_2__f32 |
| ScalarConstructor[not set]{2.000000} |
| ScalarConstructor[not set]{3.000000} |
| } |
| TypeConstructor[not set]{ |
| __vec_2__f32 |
| ScalarConstructor[not set]{3.000000} |
| ScalarConstructor[not set]{4.000000} |
| } |
| } |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_ArrayInitializer) { |
| auto p = parser(test::Assemble(Preamble() + R"( |
| %ptr = OpTypePointer Function %arr2uint |
| %two = OpConstant %uint 2 |
| %const = OpConstantComposite %arr2uint %uint_1 %two |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %200 = OpVariable %ptr Function %const |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __array__u32_2 |
| { |
| TypeConstructor[not set]{ |
| __array__u32_2 |
| ScalarConstructor[not set]{1u} |
| ScalarConstructor[not set]{2u} |
| } |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_ArrayInitializer_Alias) { |
| auto p = parser(test::Assemble(R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| OpEntryPoint Vertex %100 "main" |
| OpDecorate %arr2uint ArrayStride 16 |
| )" + CommonTypes() + R"( |
| %ptr = OpTypePointer Function %arr2uint |
| %two = OpConstant %uint 2 |
| %const = OpConstantComposite %arr2uint %uint_1 %two |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %200 = OpVariable %ptr Function %const |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| const char* expect = R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __type_name_Arr |
| { |
| TypeConstructor[not set]{ |
| __type_name_Arr |
| ScalarConstructor[not set]{1u} |
| ScalarConstructor[not set]{2u} |
| } |
| } |
| } |
| } |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_ArrayInitializer_Null) { |
| auto p = parser(test::Assemble(Preamble() + R"( |
| %ptr = OpTypePointer Function %arr2uint |
| %two = OpConstant %uint 2 |
| %const = OpConstantNull %arr2uint |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %200 = OpVariable %ptr Function %const |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __array__u32_2 |
| { |
| TypeConstructor[not set]{ |
| __array__u32_2 |
| ScalarConstructor[not set]{0u} |
| ScalarConstructor[not set]{0u} |
| } |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitFunctionVariables_ArrayInitializer_Alias_Null) { |
| auto p = parser(test::Assemble(R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| OpEntryPoint Vertex %100 "main" |
| OpDecorate %arr2uint ArrayStride 16 |
| )" + CommonTypes() + R"( |
| %ptr = OpTypePointer Function %arr2uint |
| %two = OpConstant %uint 2 |
| %const = OpConstantNull %arr2uint |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %200 = OpVariable %ptr Function %const |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __type_name_Arr |
| { |
| TypeConstructor[not set]{ |
| __type_name_Arr |
| ScalarConstructor[not set]{0u} |
| ScalarConstructor[not set]{0u} |
| } |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_StructInitializer) { |
| auto p = parser(test::Assemble(Preamble() + R"( |
| %ptr = OpTypePointer Function %strct |
| %two = OpConstant %uint 2 |
| %arrconst = OpConstantComposite %arr2uint %uint_1 %two |
| %const = OpConstantComposite %strct %uint_1 %float_1p5 %arrconst |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %200 = OpVariable %ptr Function %const |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __type_name_S |
| { |
| TypeConstructor[not set]{ |
| __type_name_S |
| ScalarConstructor[not set]{1u} |
| ScalarConstructor[not set]{1.500000} |
| TypeConstructor[not set]{ |
| __array__u32_2 |
| ScalarConstructor[not set]{1u} |
| ScalarConstructor[not set]{2u} |
| } |
| } |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitFunctionVariables_StructInitializer_Null) { |
| auto p = parser(test::Assemble(Preamble() + R"( |
| %ptr = OpTypePointer Function %strct |
| %two = OpConstant %uint 2 |
| %arrconst = OpConstantComposite %arr2uint %uint_1 %two |
| %const = OpConstantNull %strct |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %200 = OpVariable %ptr Function %const |
| OpReturn |
| OpFunctionEnd |
| )")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| EXPECT_THAT(ToString(p->builder(), fe.ast_body()), |
| HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __type_name_S |
| { |
| TypeConstructor[not set]{ |
| __type_name_S |
| ScalarConstructor[not set]{0u} |
| ScalarConstructor[not set]{0.000000} |
| TypeConstructor[not set]{ |
| __array__u32_2 |
| ScalarConstructor[not set]{0u} |
| ScalarConstructor[not set]{0u} |
| } |
| } |
| } |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitFunctionVariables_Decorate_RelaxedPrecision) { |
| // RelaxedPrecisionis dropped |
| const auto assembly = Caps({"myvar"}) + R"( |
| OpDecorate %myvar RelaxedPrecision |
| |
| %float = OpTypeFloat 32 |
| %ptr = OpTypePointer Function %float |
| |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %myvar = OpVariable %ptr Function |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| const auto got = ToString(p->builder(), fe.ast_body()); |
| EXPECT_EQ(got, R"(VariableDeclStatement{ |
| Variable{ |
| myvar |
| none |
| undefined |
| __f32 |
| } |
| } |
| )") << got; |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitFunctionVariables_MemberDecorate_RelaxedPrecision) { |
| // RelaxedPrecisionis dropped |
| const auto assembly = Caps({"myvar", "strct"}) + R"( |
| OpMemberDecorate %strct 0 RelaxedPrecision |
| |
| %float = OpTypeFloat 32 |
| %strct = OpTypeStruct %float |
| %ptr = OpTypePointer Function %strct |
| |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| |
| %100 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %myvar = OpVariable %ptr Function |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) |
| << assembly << p->error() << std::endl; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| const auto got = ToString(p->builder(), fe.ast_body()); |
| EXPECT_EQ(got, R"(VariableDeclStatement{ |
| Variable{ |
| myvar |
| none |
| undefined |
| __type_name_strct |
| } |
| } |
| )") << got; |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitFunctionVariables_StructDifferOnlyInMemberName) { |
| auto p = parser(test::Assemble(R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| OpEntryPoint Vertex %100 "main" |
| OpName %_struct_5 "S" |
| OpName %_struct_6 "S" |
| OpMemberName %_struct_5 0 "algo" |
| OpMemberName %_struct_6 0 "rithm" |
| |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %uint = OpTypeInt 32 0 |
| |
| %_struct_5 = OpTypeStruct %uint |
| %_struct_6 = OpTypeStruct %uint |
| %_ptr_Function__struct_5 = OpTypePointer Function %_struct_5 |
| %_ptr_Function__struct_6 = OpTypePointer Function %_struct_6 |
| %100 = OpFunction %void None %voidfn |
| %39 = OpLabel |
| %40 = OpVariable %_ptr_Function__struct_5 Function |
| %41 = OpVariable %_ptr_Function__struct_6 Function |
| OpReturn |
| OpFunctionEnd)")); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitFunctionVariables()); |
| |
| const auto got = ToString(p->builder(), fe.ast_body()); |
| EXPECT_THAT(got, HasSubstr(R"(VariableDeclStatement{ |
| Variable{ |
| x_40 |
| none |
| undefined |
| __type_name_S |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| x_41 |
| none |
| undefined |
| __type_name_S_1 |
| } |
| } |
| )")); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitStatement_CombinatorialValue_Defer_UsedOnceSameConstruct) { |
| auto assembly = Preamble() + R"( |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| %25 = OpVariable %ptr_uint Function |
| %2 = OpIAdd %uint %uint_1 %uint_1 |
| OpStore %25 %uint_1 ; Do initial store to mark source location |
| OpBranch %20 |
| |
| %20 = OpLabel |
| OpStore %25 %2 ; defer emission of the addition until here. |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = |
| R"(VariableDeclStatement{ |
| Variable{ |
| x_25 |
| none |
| undefined |
| __u32 |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_25} |
| ScalarConstructor[not set]{1u} |
| } |
| Assignment{ |
| Identifier[not set]{x_25} |
| Binary[not set]{ |
| ScalarConstructor[not set]{1u} |
| add |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitStatement_CombinatorialValue_Immediate_UsedTwice) { |
| auto assembly = Preamble() + R"( |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| %25 = OpVariable %ptr_uint Function |
| %2 = OpIAdd %uint %uint_1 %uint_1 |
| OpStore %25 %uint_1 ; Do initial store to mark source location |
| OpBranch %20 |
| |
| %20 = OpLabel |
| OpStore %25 %2 |
| OpStore %25 %2 |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| Variable{ |
| x_25 |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __u32 |
| { |
| Binary[not set]{ |
| ScalarConstructor[not set]{1u} |
| add |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_25} |
| ScalarConstructor[not set]{1u} |
| } |
| Assignment{ |
| Identifier[not set]{x_25} |
| Identifier[not set]{x_2} |
| } |
| Assignment{ |
| Identifier[not set]{x_25} |
| Identifier[not set]{x_2} |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitStatement_CombinatorialValue_Immediate_UsedOnceDifferentConstruct) { |
| // Translation should not sink expensive operations into or out of control |
| // flow. As a simple heuristic, don't move *any* combinatorial operation |
| // across any control flow. |
| auto assembly = Preamble() + R"( |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| %25 = OpVariable %ptr_uint Function |
| %2 = OpIAdd %uint %uint_1 %uint_1 |
| OpStore %25 %uint_1 ; Do initial store to mark source location |
| OpBranch %20 |
| |
| %20 = OpLabel ; Introduce a new construct |
| OpLoopMerge %99 %80 None |
| OpBranch %80 |
| |
| %80 = OpLabel |
| OpStore %25 %2 ; store combinatorial value %2, inside the loop |
| OpBranch %20 |
| |
| %99 = OpLabel ; merge block |
| OpStore %25 %uint_2 |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| Variable{ |
| x_25 |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __u32 |
| { |
| Binary[not set]{ |
| ScalarConstructor[not set]{1u} |
| add |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_25} |
| ScalarConstructor[not set]{1u} |
| } |
| Loop{ |
| continuing { |
| Assignment{ |
| Identifier[not set]{x_25} |
| Identifier[not set]{x_2} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_25} |
| ScalarConstructor[not set]{2u} |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F( |
| SpvParserFunctionVarTest, |
| EmitStatement_CombinatorialNonPointer_DefConstruct_DoesNotEncloseAllUses) { |
| // Compensate for the difference between dominance and scoping. |
| // Exercise hoisting of the constant definition to before its natural |
| // location. |
| // |
| // The definition of %2 should be hoisted |
| auto assembly = Preamble() + R"( |
| %pty = OpTypePointer Private %uint |
| %1 = OpVariable %pty Private |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %3 = OpLabel |
| OpStore %1 %uint_0 |
| OpBranch %5 |
| |
| %5 = OpLabel |
| OpStore %1 %uint_1 |
| OpLoopMerge %99 %80 None |
| OpBranchConditional %false %99 %20 |
| |
| %20 = OpLabel |
| OpStore %1 %uint_3 |
| OpSelectionMerge %50 None |
| OpBranchConditional %true %30 %40 |
| |
| %30 = OpLabel |
| ; This combinatorial definition in nested control flow dominates |
| ; the use in the merge block in %50 |
| %2 = OpIAdd %uint %uint_1 %uint_1 |
| OpBranch %50 |
| |
| %40 = OpLabel |
| OpReturn |
| |
| %50 = OpLabel ; merge block for if-selection |
| OpStore %1 %2 |
| OpBranch %80 |
| |
| %80 = OpLabel ; merge block |
| OpStore %1 %uint_4 |
| OpBranchConditional %false %99 %5 ; loop backedge |
| |
| %99 = OpLabel |
| OpStore %1 %uint_5 |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(Assignment{ |
| Identifier[not set]{x_1} |
| ScalarConstructor[not set]{0u} |
| } |
| Loop{ |
| VariableDeclStatement{ |
| Variable{ |
| x_2 |
| none |
| undefined |
| __u32 |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_1} |
| ScalarConstructor[not set]{1u} |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{false} |
| ) |
| { |
| Break{} |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_1} |
| ScalarConstructor[not set]{3u} |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_2} |
| Binary[not set]{ |
| ScalarConstructor[not set]{1u} |
| add |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| } |
| Else{ |
| { |
| Return{} |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_1} |
| Identifier[not set]{x_2} |
| } |
| continuing { |
| Assignment{ |
| Identifier[not set]{x_1} |
| ScalarConstructor[not set]{4u} |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{false} |
| ) |
| { |
| Break{} |
| } |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_1} |
| ScalarConstructor[not set]{5u} |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F( |
| SpvParserFunctionVarTest, |
| EmitStatement_CombinatorialNonPointer_Hoisting_DefFirstBlockIf_InFunction) { |
| // This is a hoisting case, where the definition is in the first block |
| // of an if selection construct. In this case the definition should count |
| // as being in the parent (enclosing) construct. |
| // |
| // The definition of %1 is in an IfSelection construct and also the enclosing |
| // Function construct, both of which start at block %10. For the purpose of |
| // determining the construct containing %10, go to the parent construct of |
| // the IfSelection. |
| auto assembly = Preamble() + R"( |
| %pty = OpTypePointer Private %uint |
| %200 = OpVariable %pty Private |
| %cond = OpConstantTrue %bool |
| |
| %100 = OpFunction %void None %voidfn |
| |
| ; in IfSelection construct, nested in Function construct |
| %10 = OpLabel |
| %1 = OpCopyObject %uint %uint_1 |
| OpSelectionMerge %99 None |
| OpBranchConditional %cond %20 %99 |
| |
| %20 = OpLabel ; in IfSelection construct |
| OpBranch %99 |
| |
| %99 = OpLabel |
| %3 = OpCopyObject %uint %1; in Function construct |
| OpStore %200 %3 |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| // We don't hoist x_1 into its own mutable variable. It is emitted as |
| // a const definition. |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| VariableConst{ |
| x_1 |
| none |
| undefined |
| __u32 |
| { |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_3 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_1} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_200} |
| Identifier[not set]{x_3} |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitStatement_CombinatorialNonPointer_Hoisting_DefFirstBlockIf_InIf) { |
| // This is like the previous case, but the IfSelection is nested inside |
| // another IfSelection. |
| // This tests that the hoisting algorithm goes to only one parent of |
| // the definining if-selection block, and doesn't jump all the way out |
| // to the Function construct that encloses everything. |
| // |
| // We should not hoist %1 because its definition should count as being |
| // in the outer IfSelection, not the inner IfSelection. |
| auto assembly = Preamble() + R"( |
| |
| %pty = OpTypePointer Private %uint |
| %200 = OpVariable %pty Private |
| %cond = OpConstantTrue %bool |
| |
| %100 = OpFunction %void None %voidfn |
| |
| ; outer IfSelection |
| %10 = OpLabel |
| OpSelectionMerge %99 None |
| OpBranchConditional %cond %20 %99 |
| |
| ; inner IfSelection |
| %20 = OpLabel |
| %1 = OpCopyObject %uint %uint_1 |
| OpSelectionMerge %89 None |
| OpBranchConditional %cond %30 %89 |
| |
| %30 = OpLabel ; last block of inner IfSelection |
| OpBranch %89 |
| |
| ; in outer IfSelection |
| %89 = OpLabel |
| %3 = OpCopyObject %uint %1; Last use of %1, in outer IfSelection |
| OpStore %200 %3 |
| OpBranch %99 |
| |
| %99 = OpLabel |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| VariableDeclStatement{ |
| VariableConst{ |
| x_1 |
| none |
| undefined |
| __u32 |
| { |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_3 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_1} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_200} |
| Identifier[not set]{x_3} |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F( |
| SpvParserFunctionVarTest, |
| EmitStatement_CombinatorialNonPointer_Hoisting_DefFirstBlockSwitch_InIf) { |
| // This is like the previous case, but the definition is in a SwitchSelection |
| // inside another IfSelection. |
| // Tests that definitions in the first block of a switch count as being |
| // in the parent of the switch construct. |
| auto assembly = Preamble() + R"( |
| %pty = OpTypePointer Private %uint |
| %200 = OpVariable %pty Private |
| %cond = OpConstantTrue %bool |
| |
| %100 = OpFunction %void None %voidfn |
| |
| ; outer IfSelection |
| %10 = OpLabel |
| OpSelectionMerge %99 None |
| OpBranchConditional %cond %20 %99 |
| |
| ; inner SwitchSelection |
| %20 = OpLabel |
| %1 = OpCopyObject %uint %uint_1 |
| OpSelectionMerge %89 None |
| OpSwitch %uint_1 %89 0 %30 |
| |
| %30 = OpLabel ; last block of inner SwitchSelection |
| OpBranch %89 |
| |
| ; in outer IfSelection |
| %89 = OpLabel |
| %3 = OpCopyObject %uint %1; Last use of %1, in outer IfSelection |
| OpStore %200 %3 |
| OpBranch %99 |
| |
| %99 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| VariableDeclStatement{ |
| VariableConst{ |
| x_1 |
| none |
| undefined |
| __u32 |
| { |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| Switch{ |
| ScalarConstructor[not set]{1u} |
| { |
| Case 0u{ |
| } |
| Default{ |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_3 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_1} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_200} |
| Identifier[not set]{x_3} |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitStatement_CombinatorialNonPointer_Hoisting_DefAndUseFirstBlockIf) { |
| // In this test, both the defintion and the use are in the first block |
| // of an IfSelection. No hoisting occurs because hoisting is triggered |
| // on whether the defining construct contains the last use, rather than |
| // whether the two constructs are the same. |
| // |
| // This example has two SSA IDs which are tempting to hoist but should not: |
| // %1 is defined and used in the first block of an IfSelection. |
| // Do not hoist it. |
| auto assembly = Preamble() + R"( |
| %cond = OpConstantTrue %bool |
| |
| %100 = OpFunction %void None %voidfn |
| |
| ; in IfSelection construct, nested in Function construct |
| %10 = OpLabel |
| %1 = OpCopyObject %uint %uint_1 |
| %2 = OpCopyObject %uint %1 |
| OpSelectionMerge %99 None |
| OpBranchConditional %cond %20 %99 |
| |
| %20 = OpLabel ; in IfSelection construct |
| OpBranch %99 |
| |
| %99 = OpLabel |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| // We don't hoist x_1 into its own mutable variable. It is emitted as |
| // a const definition. |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| VariableConst{ |
| x_1 |
| none |
| undefined |
| __u32 |
| { |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_1} |
| } |
| } |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitStatement_Phi_SingleBlockLoopIndex) { |
| auto assembly = Preamble() + R"( |
| %pty = OpTypePointer Private %uint |
| %1 = OpVariable %pty Private |
| %boolpty = OpTypePointer Private %bool |
| %7 = OpVariable %boolpty Private |
| %8 = OpVariable %boolpty Private |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %5 = OpLabel |
| OpBranch %10 |
| |
| ; Use an outer loop to show we put the new variable in the |
| ; smallest enclosing scope. |
| %10 = OpLabel |
| %101 = OpLoad %bool %7 |
| %102 = OpLoad %bool %8 |
| OpLoopMerge %99 %89 None |
| OpBranchConditional %101 %99 %20 |
| |
| %20 = OpLabel |
| %2 = OpPhi %uint %uint_0 %10 %4 %20 ; gets computed value |
| %3 = OpPhi %uint %uint_1 %10 %3 %20 ; gets itself |
| %4 = OpIAdd %uint %2 %uint_1 |
| OpLoopMerge %79 %20 None |
| OpBranchConditional %102 %79 %20 |
| |
| %79 = OpLabel |
| OpBranch %89 |
| |
| %89 = OpLabel |
| OpBranch %10 |
| |
| %99 = OpLabel |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(Loop{ |
| VariableDeclStatement{ |
| Variable{ |
| x_2_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| x_3_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_101 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_7} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_102 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_8} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| ScalarConstructor[not set]{0u} |
| } |
| Assignment{ |
| Identifier[not set]{x_3_phi} |
| ScalarConstructor[not set]{1u} |
| } |
| If{ |
| ( |
| Identifier[not set]{x_101} |
| ) |
| { |
| Break{} |
| } |
| } |
| Loop{ |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_2_phi} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_3 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_3_phi} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| Binary[not set]{ |
| Identifier[not set]{x_2} |
| add |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_3_phi} |
| Identifier[not set]{x_3} |
| } |
| If{ |
| ( |
| Identifier[not set]{x_102} |
| ) |
| { |
| Break{} |
| } |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitStatement_Phi_MultiBlockLoopIndex) { |
| auto assembly = Preamble() + R"( |
| %pty = OpTypePointer Private %uint |
| %1 = OpVariable %pty Private |
| %boolpty = OpTypePointer Private %bool |
| %7 = OpVariable %boolpty Private |
| %8 = OpVariable %boolpty Private |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %5 = OpLabel |
| OpBranch %10 |
| |
| ; Use an outer loop to show we put the new variable in the |
| ; smallest enclosing scope. |
| %10 = OpLabel |
| %101 = OpLoad %bool %7 |
| %102 = OpLoad %bool %8 |
| OpLoopMerge %99 %89 None |
| OpBranchConditional %101 %99 %20 |
| |
| %20 = OpLabel |
| %2 = OpPhi %uint %uint_0 %10 %4 %30 ; gets computed value |
| %3 = OpPhi %uint %uint_1 %10 %3 %30 ; gets itself |
| OpLoopMerge %79 %30 None |
| OpBranchConditional %102 %79 %30 |
| |
| %30 = OpLabel |
| %4 = OpIAdd %uint %2 %uint_1 |
| OpBranch %20 |
| |
| %79 = OpLabel |
| OpBranch %89 |
| |
| %89 = OpLabel ; continue target for outer loop |
| OpBranch %10 |
| |
| %99 = OpLabel |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(Loop{ |
| VariableDeclStatement{ |
| Variable{ |
| x_2_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| x_3_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_101 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_7} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_102 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_8} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| ScalarConstructor[not set]{0u} |
| } |
| Assignment{ |
| Identifier[not set]{x_3_phi} |
| ScalarConstructor[not set]{1u} |
| } |
| If{ |
| ( |
| Identifier[not set]{x_101} |
| ) |
| { |
| Break{} |
| } |
| } |
| Loop{ |
| VariableDeclStatement{ |
| Variable{ |
| x_4 |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_2_phi} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_3 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_3_phi} |
| } |
| } |
| } |
| If{ |
| ( |
| Identifier[not set]{x_102} |
| ) |
| { |
| Break{} |
| } |
| } |
| continuing { |
| Assignment{ |
| Identifier[not set]{x_4} |
| Binary[not set]{ |
| Identifier[not set]{x_2} |
| add |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| Identifier[not set]{x_4} |
| } |
| Assignment{ |
| Identifier[not set]{x_3_phi} |
| Identifier[not set]{x_3} |
| } |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitStatement_Phi_ValueFromLoopBodyAndContinuing) { |
| auto assembly = Preamble() + R"( |
| %pty = OpTypePointer Private %uint |
| %1 = OpVariable %pty Private |
| %boolpty = OpTypePointer Private %bool |
| %17 = OpVariable %boolpty Private |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %9 = OpLabel |
| %101 = OpLoad %bool %17 |
| OpBranch %10 |
| |
| ; Use an outer loop to show we put the new variable in the |
| ; smallest enclosing scope. |
| %10 = OpLabel |
| OpLoopMerge %99 %89 None |
| OpBranch %20 |
| |
| %20 = OpLabel |
| %2 = OpPhi %uint %uint_0 %10 %4 %30 ; gets computed value |
| %5 = OpPhi %uint %uint_1 %10 %7 %30 |
| %4 = OpIAdd %uint %2 %uint_1 ; define %4 |
| %6 = OpIAdd %uint %4 %uint_1 ; use %4 |
| OpLoopMerge %79 %30 None |
| OpBranchConditional %101 %79 %30 |
| |
| %30 = OpLabel |
| %7 = OpIAdd %uint %4 %6 ; use %4 again |
| OpBranch %20 |
| |
| %79 = OpLabel |
| OpBranch %89 |
| |
| %89 = OpLabel |
| OpBranch %10 |
| |
| %99 = OpLabel |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) |
| << assembly << p->error(); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| VariableConst{ |
| x_101 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_17} |
| } |
| } |
| } |
| Loop{ |
| VariableDeclStatement{ |
| Variable{ |
| x_2_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| Variable{ |
| x_5_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| ScalarConstructor[not set]{0u} |
| } |
| Assignment{ |
| Identifier[not set]{x_5_phi} |
| ScalarConstructor[not set]{1u} |
| } |
| Loop{ |
| VariableDeclStatement{ |
| Variable{ |
| x_7 |
| none |
| undefined |
| __u32 |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_2_phi} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_5 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_5_phi} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_4 |
| none |
| undefined |
| __u32 |
| { |
| Binary[not set]{ |
| Identifier[not set]{x_2} |
| add |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_6 |
| none |
| undefined |
| __u32 |
| { |
| Binary[not set]{ |
| Identifier[not set]{x_4} |
| add |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| } |
| If{ |
| ( |
| Identifier[not set]{x_101} |
| ) |
| { |
| Break{} |
| } |
| } |
| continuing { |
| Assignment{ |
| Identifier[not set]{x_7} |
| Binary[not set]{ |
| Identifier[not set]{x_4} |
| add |
| Identifier[not set]{x_6} |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| Identifier[not set]{x_4} |
| } |
| Assignment{ |
| Identifier[not set]{x_5_phi} |
| Identifier[not set]{x_7} |
| } |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitStatement_Phi_FromElseAndThen) { |
| auto assembly = Preamble() + R"( |
| %pty = OpTypePointer Private %uint |
| %1 = OpVariable %pty Private |
| %boolpty = OpTypePointer Private %bool |
| %7 = OpVariable %boolpty Private |
| %8 = OpVariable %boolpty Private |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %5 = OpLabel |
| %101 = OpLoad %bool %7 |
| %102 = OpLoad %bool %8 |
| OpBranch %10 |
| |
| ; Use an outer loop to show we put the new variable in the |
| ; smallest enclosing scope. |
| %10 = OpLabel |
| OpLoopMerge %99 %89 None |
| OpBranchConditional %101 %99 %20 |
| |
| %20 = OpLabel ; if seleciton |
| OpSelectionMerge %79 None |
| OpBranchConditional %102 %30 %40 |
| |
| %30 = OpLabel |
| OpBranch %89 |
| |
| %40 = OpLabel |
| OpBranch %89 |
| |
| %79 = OpLabel ; disconnected selection merge node |
| OpBranch %89 |
| |
| %89 = OpLabel |
| %2 = OpPhi %uint %uint_0 %30 %uint_1 %40 %uint_0 %79 |
| OpStore %1 %2 |
| OpBranch %10 |
| |
| %99 = OpLabel |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| VariableConst{ |
| x_101 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_7} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_102 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_8} |
| } |
| } |
| } |
| Loop{ |
| VariableDeclStatement{ |
| Variable{ |
| x_2_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| If{ |
| ( |
| Identifier[not set]{x_101} |
| ) |
| { |
| Break{} |
| } |
| } |
| If{ |
| ( |
| Identifier[not set]{x_102} |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| ScalarConstructor[not set]{0u} |
| } |
| Continue{} |
| } |
| } |
| Else{ |
| { |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| ScalarConstructor[not set]{1u} |
| } |
| Continue{} |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| ScalarConstructor[not set]{0u} |
| } |
| continuing { |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_2_phi} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_1} |
| Identifier[not set]{x_2} |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got) << got; |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitStatement_Phi_FromHeaderAndThen) { |
| auto assembly = Preamble() + R"( |
| %pty = OpTypePointer Private %uint |
| %1 = OpVariable %pty Private |
| %boolpty = OpTypePointer Private %bool |
| %7 = OpVariable %boolpty Private |
| %8 = OpVariable %boolpty Private |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %5 = OpLabel |
| %101 = OpLoad %bool %7 |
| %102 = OpLoad %bool %8 |
| OpBranch %10 |
| |
| ; Use an outer loop to show we put the new variable in the |
| ; smallest enclosing scope. |
| %10 = OpLabel |
| OpLoopMerge %99 %89 None |
| OpBranchConditional %101 %99 %20 |
| |
| %20 = OpLabel ; if seleciton |
| OpSelectionMerge %79 None |
| OpBranchConditional %102 %30 %89 |
| |
| %30 = OpLabel |
| OpBranch %89 |
| |
| %79 = OpLabel ; disconnected selection merge node |
| OpUnreachable |
| |
| %89 = OpLabel |
| %2 = OpPhi %uint %uint_0 %20 %uint_1 %30 |
| OpStore %1 %2 |
| OpBranch %10 |
| |
| %99 = OpLabel |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| VariableConst{ |
| x_101 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_7} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_102 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_8} |
| } |
| } |
| } |
| Loop{ |
| VariableDeclStatement{ |
| Variable{ |
| x_2_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| If{ |
| ( |
| Identifier[not set]{x_101} |
| ) |
| { |
| Break{} |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| ScalarConstructor[not set]{0u} |
| } |
| If{ |
| ( |
| Identifier[not set]{x_102} |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_2_phi} |
| ScalarConstructor[not set]{1u} |
| } |
| Continue{} |
| } |
| } |
| Else{ |
| { |
| Continue{} |
| } |
| } |
| Return{} |
| continuing { |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_2_phi} |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_1} |
| Identifier[not set]{x_2} |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got) << got; |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitStatement_Phi_InMerge_PredecessorsDominatdByNestedSwitchCase) { |
| // This is the essence of the bug report from crbug.com/tint/495 |
| auto assembly = Preamble() + R"( |
| %cond = OpConstantTrue %bool |
| %pty = OpTypePointer Private %uint |
| %1 = OpVariable %pty Private |
| %boolpty = OpTypePointer Private %bool |
| %7 = OpVariable %boolpty Private |
| %8 = OpVariable %boolpty Private |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| OpSelectionMerge %99 None |
| OpSwitch %uint_1 %20 0 %20 1 %30 |
| |
| %20 = OpLabel ; case 0 |
| OpBranch %30 ;; fall through |
| |
| %30 = OpLabel ; case 1 |
| OpSelectionMerge %50 None |
| OpBranchConditional %true %40 %45 |
| |
| %40 = OpLabel |
| OpBranch %50 |
| |
| %45 = OpLabel |
| OpBranch %99 ; break |
| |
| %50 = OpLabel ; end the case |
| OpBranch %99 |
| |
| %99 = OpLabel |
| ; predecessors are all dominated by case construct head at %30 |
| %phi = OpPhi %uint %uint_0 %45 %uint_1 %50 |
| OpReturn |
| |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| Variable{ |
| x_41_phi |
| none |
| undefined |
| __u32 |
| } |
| } |
| Switch{ |
| ScalarConstructor[not set]{1u} |
| { |
| Default{ |
| Fallthrough{} |
| } |
| Case 0u{ |
| Fallthrough{} |
| } |
| Case 1u{ |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| } |
| } |
| Else{ |
| { |
| Assignment{ |
| Identifier[not set]{x_41_phi} |
| ScalarConstructor[not set]{0u} |
| } |
| Break{} |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_41_phi} |
| ScalarConstructor[not set]{1u} |
| } |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_41 |
| none |
| undefined |
| __u32 |
| { |
| Identifier[not set]{x_41_phi} |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got) << got << assembly; |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitStatement_UseInPhiCountsAsUse) { |
| // From crbug.com/215 |
| // If the only use of a combinatorially computed ID is as the value |
| // in an OpPhi, then we still have to emit it. The algorithm fix |
| // is to always count uses in Phis. |
| // This is the reduced case from the bug report. |
| // |
| // The only use of %12 is in the phi. |
| // The only use of %11 is in %12. |
| // Both definintions need to be emitted to the output. |
| auto assembly = Preamble() + R"( |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| %11 = OpLogicalAnd %bool %true %true |
| %12 = OpLogicalNot %bool %11 ; |
| OpSelectionMerge %99 None |
| OpBranchConditional %true %20 %99 |
| |
| %20 = OpLabel |
| OpBranch %99 |
| |
| %99 = OpLabel |
| %101 = OpPhi %bool %11 %10 %12 %20 |
| OpReturn |
| |
| OpFunctionEnd |
| |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| auto got = ToString(p->builder(), fe.ast_body()); |
| auto* expect = R"(VariableDeclStatement{ |
| Variable{ |
| x_101_phi |
| none |
| undefined |
| __bool |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_11 |
| none |
| undefined |
| __bool |
| { |
| Binary[not set]{ |
| ScalarConstructor[not set]{true} |
| logical_and |
| ScalarConstructor[not set]{true} |
| } |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_12 |
| none |
| undefined |
| __bool |
| { |
| UnaryOp[not set]{ |
| not |
| Identifier[not set]{x_11} |
| } |
| } |
| } |
| } |
| Assignment{ |
| Identifier[not set]{x_101_phi} |
| Identifier[not set]{x_11} |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_101_phi} |
| Identifier[not set]{x_12} |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_101 |
| none |
| undefined |
| __bool |
| { |
| Identifier[not set]{x_101_phi} |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(expect, got); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, |
| EmitStatement_Phi_ValueFromBlockNotInBlockOrderIgnored) { |
| // From crbug.com/tint/804 |
| const auto assembly = Preamble() + R"( |
| %float_42 = OpConstant %float 42.0 |
| %cond = OpUndef %bool |
| |
| %100 = OpFunction %void None %voidfn |
| %10 = OpLabel |
| OpBranch %30 |
| |
| ; unreachable |
| %20 = OpLabel |
| %499 = OpFAdd %float %float_42 %float_42 |
| %500 = OpFAdd %float %499 %float_42 |
| OpBranch %25 |
| |
| %25 = OpLabel |
| OpBranch %80 |
| |
| |
| %30 = OpLabel |
| OpLoopMerge %90 %80 None |
| OpBranchConditional %cond %90 %40 |
| |
| %40 = OpLabel |
| OpBranch %90 |
| |
| %80 = OpLabel ; unreachable continue target |
| ; but "dominated" by %20 and %25 |
| %81 = OpPhi %float %500 %25 |
| OpBranch %30 ; backedge |
| |
| %90 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| const auto* expected = R"(Loop{ |
| If{ |
| ( |
| ScalarConstructor[not set]{false} |
| ) |
| { |
| Break{} |
| } |
| } |
| Break{} |
| continuing { |
| VariableDeclStatement{ |
| Variable{ |
| x_81_phi_1 |
| none |
| undefined |
| __f32 |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_81 |
| none |
| undefined |
| __f32 |
| { |
| Identifier[not set]{x_81_phi_1} |
| } |
| } |
| } |
| } |
| } |
| Return{} |
| )"; |
| const auto got = ToString(p->builder(), fe.ast_body()); |
| EXPECT_EQ(got, expected); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitStatement_Hoist_CompositeInsert) { |
| // From crbug.com/tint/804 |
| const auto assembly = Preamble() + R"( |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| OpSelectionMerge %50 None |
| OpBranchConditional %true %20 %30 |
| |
| %20 = OpLabel |
| %200 = OpCompositeInsert %v2int %int_0 %v2int_null 0 |
| OpBranch %50 |
| |
| %30 = OpLabel |
| OpReturn |
| |
| %50 = OpLabel ; dominated by %20, but %200 needs to be hoisted |
| %201 = OpCopyObject %v2int %200 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| const auto* expected = R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __vec_2__i32 |
| } |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_200} |
| TypeConstructor[not set]{ |
| __vec_2__i32 |
| ScalarConstructor[not set]{0} |
| ScalarConstructor[not set]{0} |
| } |
| } |
| Assignment{ |
| MemberAccessor[not set]{ |
| Identifier[not set]{x_200} |
| Identifier[not set]{x} |
| } |
| ScalarConstructor[not set]{0} |
| } |
| } |
| } |
| Else{ |
| { |
| Return{} |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_201 |
| none |
| undefined |
| __vec_2__i32 |
| { |
| Identifier[not set]{x_200} |
| } |
| } |
| } |
| Return{} |
| )"; |
| const auto got = ToString(p->builder(), fe.ast_body()); |
| EXPECT_EQ(got, expected); |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitStatement_Hoist_VectorInsertDynamic) { |
| // Spawned from crbug.com/tint/804 |
| const auto assembly = Preamble() + R"( |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| OpSelectionMerge %50 None |
| OpBranchConditional %true %20 %30 |
| |
| %20 = OpLabel |
| %200 = OpVectorInsertDynamic %v2int %v2int_null %int_3 %int_1 |
| OpBranch %50 |
| |
| %30 = OpLabel |
| OpReturn |
| |
| %50 = OpLabel ; dominated by %20, but %200 needs to be hoisted |
| %201 = OpCopyObject %v2int %200 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| const auto got = ToString(p->builder(), fe.ast_body()); |
| const auto* expected = R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __vec_2__i32 |
| } |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_200} |
| TypeConstructor[not set]{ |
| __vec_2__i32 |
| ScalarConstructor[not set]{0} |
| ScalarConstructor[not set]{0} |
| } |
| } |
| Assignment{ |
| ArrayAccessor[not set]{ |
| Identifier[not set]{x_200} |
| ScalarConstructor[not set]{1} |
| } |
| ScalarConstructor[not set]{3} |
| } |
| } |
| } |
| Else{ |
| { |
| Return{} |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_201 |
| none |
| undefined |
| __vec_2__i32 |
| { |
| Identifier[not set]{x_200} |
| } |
| } |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(got, expected) << got; |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, EmitStatement_Hoist_UsedAsNonPtrArg) { |
| // Spawned from crbug.com/tint/804 |
| const auto assembly = Preamble() + R"( |
| %fn_int = OpTypeFunction %void %int |
| |
| %500 = OpFunction %void None %fn_int |
| %501 = OpFunctionParameter %int |
| %502 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| OpSelectionMerge %50 None |
| OpBranchConditional %true %20 %30 |
| |
| %20 = OpLabel |
| %200 = OpCopyObject %int %int_1 |
| OpBranch %50 |
| |
| %30 = OpLabel |
| OpReturn |
| |
| %50 = OpLabel ; dominated by %20, but %200 needs to be hoisted |
| %201 = OpFunctionCall %void %500 %200 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| const auto got = ToString(p->builder(), fe.ast_body()); |
| const auto* expected = R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __i32 |
| } |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_200} |
| ScalarConstructor[not set]{1} |
| } |
| } |
| } |
| Else{ |
| { |
| Return{} |
| } |
| } |
| Call[not set]{ |
| Identifier[not set]{x_500} |
| ( |
| Identifier[not set]{x_200} |
| ) |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(got, expected) << got; |
| } |
| |
| TEST_F(SpvParserFunctionVarTest, DISABLED_EmitStatement_Hoist_UsedAsPtrArg) { |
| // Spawned from crbug.com/tint/804 |
| // Blocked by crbug.com/tint/98: hoisting pointer types |
| const auto assembly = Preamble() + R"( |
| |
| %fn_int = OpTypeFunction %void %ptr_int |
| |
| %500 = OpFunction %void None %fn_int |
| %501 = OpFunctionParameter %ptr_int |
| %502 = OpLabel |
| OpReturn |
| OpFunctionEnd |
| |
| %100 = OpFunction %void None %voidfn |
| |
| %10 = OpLabel |
| %199 = OpVariable %ptr_int Function |
| OpSelectionMerge %50 None |
| OpBranchConditional %true %20 %30 |
| |
| %20 = OpLabel |
| %200 = OpCopyObject %ptr_int %199 |
| OpBranch %50 |
| |
| %30 = OpLabel |
| OpReturn |
| |
| %50 = OpLabel ; dominated by %20, but %200 needs to be hoisted |
| %201 = OpFunctionCall %void %500 %200 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| |
| const auto got = ToString(p->builder(), fe.ast_body()); |
| const auto* expected = R"(VariableDeclStatement{ |
| Variable{ |
| x_200 |
| none |
| undefined |
| __i32 |
| } |
| Variable{ |
| x_199 |
| none |
| undefined |
| __i32 |
| } |
| } |
| If{ |
| ( |
| ScalarConstructor[not set]{true} |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_200} |
| ScalarConstructor[not set]{1} |
| } |
| } |
| } |
| Else{ |
| { |
| Return{} |
| } |
| } |
| Call[not set]{ |
| Identifier[not set]{x_500} |
| ( |
| Identifier[not set]{x_200} |
| ) |
| } |
| Return{} |
| )"; |
| EXPECT_EQ(got, expected) << got; |
| } |
| |
| } // namespace |
| } // namespace spirv |
| } // namespace reader |
| } // namespace tint |
