| // 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" |
| #include "src/utils/string.h" |
| |
| namespace tint { |
| namespace reader { |
| namespace spirv { |
| namespace { |
| |
| using SpvModuleScopeVarParserTest = SpvParserTest; |
| |
| using ::testing::ElementsAre; |
| using ::testing::Eq; |
| using ::testing::HasSubstr; |
| using ::testing::Not; |
| |
| std::string Preamble() { |
| return R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| )"; |
| } |
| |
| std::string FragMain() { |
| return R"( |
| OpEntryPoint Fragment %main "main" |
| OpExecutionMode %main OriginUpperLeft |
| )"; |
| } |
| |
| std::string MainBody() { |
| return R"( |
| %main = OpFunction %void None %voidfn |
| %main_entry = OpLabel |
| OpReturn |
| OpFunctionEnd |
| )"; |
| } |
| |
| std::string CommonCapabilities() { |
| return R"( |
| OpCapability Shader |
| OpCapability SampleRateShading |
| OpMemoryModel Logical Simple |
| )"; |
| } |
| |
| 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 Private %bool |
| %ptr_float = OpTypePointer Private %float |
| %ptr_uint = OpTypePointer Private %uint |
| %ptr_int = OpTypePointer Private %int |
| |
| %true = OpConstantTrue %bool |
| %false = OpConstantFalse %bool |
| %float_0 = OpConstant %float 0.0 |
| %float_1p5 = OpConstant %float 1.5 |
| %uint_1 = OpConstant %uint 1 |
| %int_m1 = OpConstant %int -1 |
| %int_14 = OpConstant %int 14 |
| %uint_2 = OpConstant %uint 2 |
| |
| %v2bool = OpTypeVector %bool 2 |
| %v2uint = OpTypeVector %uint 2 |
| %v2int = OpTypeVector %int 2 |
| %v2float = OpTypeVector %float 2 |
| %v4float = OpTypeVector %float 4 |
| %m3v2float = OpTypeMatrix %v2float 3 |
| |
| %arr2uint = OpTypeArray %uint %uint_2 |
| )"; |
| } |
| |
| std::string StructTypes() { |
| return R"( |
| %strct = OpTypeStruct %uint %float %arr2uint |
| )"; |
| } |
| |
| // Returns layout annotations for types in StructTypes() |
| std::string CommonLayout() { |
| return R"( |
| OpMemberDecorate %strct 0 Offset 0 |
| OpMemberDecorate %strct 1 Offset 4 |
| OpMemberDecorate %strct 2 Offset 8 |
| OpDecorate %arr2uint ArrayStride 4 |
| )"; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, NoVar) { |
| auto assembly = Preamble() + FragMain() + CommonTypes() + MainBody(); |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()) << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_ast = test::ToString(p->program()); |
| EXPECT_THAT(module_ast, Not(HasSubstr("Variable"))) << module_ast; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BadStorageClass_NotAWebGPUStorageClass) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| %float = OpTypeFloat 32 |
| %ptr = OpTypePointer CrossWorkgroup %float |
| %52 = OpVariable %ptr CrossWorkgroup |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| EXPECT_TRUE(p->BuildInternalModule()); |
| // Normally we should run ParserImpl::RegisterTypes before emitting |
| // variables. But defensive coding in EmitModuleScopeVariables lets |
| // us catch this error. |
| EXPECT_FALSE(p->EmitModuleScopeVariables()) << p->error(); |
| EXPECT_THAT(p->error(), HasSubstr("unknown SPIR-V storage class: 5")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BadStorageClass_Function) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| %float = OpTypeFloat 32 |
| %ptr = OpTypePointer Function %float |
| %52 = OpVariable %ptr Function |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| EXPECT_TRUE(p->BuildInternalModule()); |
| // Normally we should run ParserImpl::RegisterTypes before emitting |
| // variables. But defensive coding in EmitModuleScopeVariables lets |
| // us catch this error. |
| EXPECT_FALSE(p->EmitModuleScopeVariables()) << p->error(); |
| EXPECT_THAT(p->error(), |
| HasSubstr("invalid SPIR-V storage class 7 for module scope " |
| "variable: %52 = OpVariable %3 Function")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BadPointerType) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| %float = OpTypeFloat 32 |
| %fn_ty = OpTypeFunction %float |
| %3 = OpTypePointer Private %fn_ty |
| %52 = OpVariable %3 Private |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| EXPECT_TRUE(p->BuildInternalModule()); |
| // Normally we should run ParserImpl::RegisterTypes before emitting |
| // variables. But defensive coding in EmitModuleScopeVariables lets |
| // us catch this error. |
| EXPECT_FALSE(p->EmitModuleScopeVariables()); |
| EXPECT_THAT(p->error(), HasSubstr("internal error: failed to register Tint " |
| "AST type for SPIR-V type with ID: 3")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, NonPointerType) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| %float = OpTypeFloat 32 |
| %5 = OpTypeFunction %float |
| %3 = OpTypePointer Private %5 |
| %52 = OpVariable %float Private |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| EXPECT_TRUE(p->BuildInternalModule()); |
| EXPECT_FALSE(p->RegisterTypes()); |
| EXPECT_THAT( |
| p->error(), |
| HasSubstr("SPIR-V pointer type with ID 3 has invalid pointee type 5")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, AnonWorkgroupVar) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| %float = OpTypeFloat 32 |
| %ptr = OpTypePointer Workgroup %float |
| %52 = OpVariable %ptr Workgroup |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr("var<workgroup> x_52 : f32;")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, NamedWorkgroupVar) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %52 "the_counter" |
| %float = OpTypeFloat 32 |
| %ptr = OpTypePointer Workgroup %float |
| %52 = OpVariable %ptr Workgroup |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr("var<workgroup> the_counter : f32;")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, PrivateVar) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %52 "my_own_private_idaho" |
| %float = OpTypeFloat 32 |
| %ptr = OpTypePointer Private %float |
| %52 = OpVariable %ptr Private |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("var<private> my_own_private_idaho : f32;")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinVertexIndex) { |
| // This is the simple case for the vertex_index builtin, |
| // where the SPIR-V uses the same store type as in WGSL. |
| // See later for tests where the SPIR-V store type is signed |
| // integer, as in GLSL. |
| auto p = parser(test::Assemble(Preamble() + R"( |
| OpEntryPoint Vertex %main "main" %52 %position |
| OpName %position "position" |
| OpDecorate %position BuiltIn Position |
| OpDecorate %52 BuiltIn VertexIndex |
| %uint = OpTypeInt 32 0 |
| %ptr = OpTypePointer Input %uint |
| %52 = OpVariable %ptr Input |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %v4float = OpTypeVector %float 4 |
| %posty = OpTypePointer Output %v4float |
| %position = OpVariable %posty Output |
| )" + MainBody())); |
| |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr("var<private> x_52 : u32;")); |
| } |
| |
| std::string PerVertexPreamble() { |
| return R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| OpEntryPoint Vertex %main "main" %1 |
| |
| OpMemberDecorate %10 0 BuiltIn Position |
| OpMemberDecorate %10 1 BuiltIn PointSize |
| OpMemberDecorate %10 2 BuiltIn ClipDistance |
| OpMemberDecorate %10 3 BuiltIn CullDistance |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %12 = OpTypeVector %float 4 |
| %uint = OpTypeInt 32 0 |
| %uint_0 = OpConstant %uint 0 |
| %uint_1 = OpConstant %uint 1 |
| %arr = OpTypeArray %float %uint_1 |
| %10 = OpTypeStruct %12 %float %arr %arr |
| %11 = OpTypePointer Output %10 |
| %1 = OpVariable %11 Output |
| )"; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPosition_StoreWholeStruct_NotSupported) { |
| // Glslang does not generate this code pattern. |
| const std::string assembly = PerVertexPreamble() + R"( |
| %nil = OpConstantNull %10 ; the whole struct |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| OpStore %1 %nil ; store the whole struct |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()) << assembly; |
| EXPECT_THAT(p->error(), Eq("storing to the whole per-vertex structure is not " |
| "supported: OpStore %1 %13")) |
| << p->error(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPosition_IntermediateWholeStruct_NotSupported) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %1000 = OpUndef %10 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()) << assembly; |
| EXPECT_THAT(p->error(), Eq("operations producing a per-vertex structure are " |
| "not supported: %1000 = OpUndef %10")) |
| << p->error(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPosition_IntermediatePtrWholeStruct_NotSupported) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %1000 = OpCopyObject %11 %1 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_THAT(p->error(), |
| Eq("operations producing a pointer to a per-vertex structure are " |
| "not supported: %1000 = OpCopyObject %11 %1")) |
| << p->error(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinPosition_StorePosition) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr_v4float = OpTypePointer Output %12 |
| %nil = OpConstantNull %12 |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %ptr_v4float %1 %uint_0 ; address of the Position member |
| OpStore %100 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("gl_Position = vec4<f32>(0.0, 0.0, 0.0, 0.0);")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPosition_StorePosition_PerVertexStructOutOfOrderDecl) { |
| const std::string assembly = R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| OpEntryPoint Vertex %main "main" %1 |
| |
| ; scramble the member indices |
| OpMemberDecorate %10 0 BuiltIn ClipDistance |
| OpMemberDecorate %10 1 BuiltIn CullDistance |
| OpMemberDecorate %10 2 BuiltIn Position |
| OpMemberDecorate %10 3 BuiltIn PointSize |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %12 = OpTypeVector %float 4 |
| %uint = OpTypeInt 32 0 |
| %uint_0 = OpConstant %uint 0 |
| %uint_1 = OpConstant %uint 1 |
| %uint_2 = OpConstant %uint 2 |
| %arr = OpTypeArray %float %uint_1 |
| %10 = OpTypeStruct %arr %arr %12 %float |
| %11 = OpTypePointer Output %10 |
| %1 = OpVariable %11 Output |
| |
| %ptr_v4float = OpTypePointer Output %12 |
| %nil = OpConstantNull %12 |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %ptr_v4float %1 %uint_2 ; address of the Position member |
| OpStore %100 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("gl_Position = vec4<f32>(0.0, 0.0, 0.0, 0.0);")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPosition_StorePositionMember_OneAccessChain) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr_float = OpTypePointer Output %float |
| %nil = OpConstantNull %float |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %ptr_float %1 %uint_0 %uint_1 ; address of the Position.y member |
| OpStore %100 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr("gl_Position.y = 0.0;")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPosition_StorePositionMember_TwoAccessChain) { |
| // The algorithm is smart enough to collapse it down. |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr = OpTypePointer Output %12 |
| %ptr_float = OpTypePointer Output %float |
| %nil = OpConstantNull %float |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %ptr %1 %uint_0 ; address of the Position member |
| %101 = OpAccessChain %ptr_float %100 %uint_1 ; address of the Position.y member |
| OpStore %101 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr("gl_Position.y = 0.0;")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinPointSize_Write1_IsErased) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr = OpTypePointer Output %float |
| %one = OpConstant %float 1.0 |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %ptr %1 %uint_1 ; address of the PointSize member |
| OpStore %100 %one |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_EQ(module_str, R"(var<private> gl_Position : vec4<f32>; |
| |
| fn main_1() { |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(position)]] |
| gl_Position : vec4<f32>; |
| }; |
| |
| [[stage(vertex)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(gl_Position); |
| } |
| )") << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinPointSize_WriteNon1_IsError) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr = OpTypePointer Output %float |
| %999 = OpConstant %float 2.0 |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %ptr %1 %uint_1 ; address of the PointSize member |
| OpStore %100 %999 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_THAT(p->error(), |
| HasSubstr("cannot store a value other than constant 1.0 to " |
| "PointSize builtin: OpStore %100 %999")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinPointSize_ReadReplaced) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr = OpTypePointer Output %float |
| %nil = OpConstantNull %12 |
| %private_ptr = OpTypePointer Private %float |
| %900 = OpVariable %private_ptr Private |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %ptr %1 %uint_1 ; address of the PointSize member |
| %99 = OpLoad %float %100 |
| OpStore %900 %99 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_EQ(module_str, R"(var<private> x_900 : f32; |
| |
| var<private> gl_Position : vec4<f32>; |
| |
| fn main_1() { |
| x_900 = 1.0; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(position)]] |
| gl_Position : vec4<f32>; |
| }; |
| |
| [[stage(vertex)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(gl_Position); |
| } |
| )") << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPointSize_WriteViaCopyObjectPriorAccess_Unsupported) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr = OpTypePointer Output %float |
| %nil = OpConstantNull %12 |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %20 = OpCopyObject %11 %1 |
| %100 = OpAccessChain %20 %1 %uint_1 ; address of the PointSize member |
| OpStore %100 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()) << p->error(); |
| EXPECT_THAT( |
| p->error(), |
| HasSubstr("operations producing a pointer to a per-vertex structure are " |
| "not supported: %20 = OpCopyObject %11 %1")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPointSize_WriteViaCopyObjectPostAccessChainErased) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr = OpTypePointer Output %float |
| %one = OpConstant %float 1.0 |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %ptr %1 %uint_1 ; address of the PointSize member |
| %101 = OpCopyObject %ptr %100 |
| OpStore %101 %one |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_EQ(module_str, R"(var<private> gl_Position : vec4<f32>; |
| |
| fn main_1() { |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(position)]] |
| gl_Position : vec4<f32>; |
| }; |
| |
| [[stage(vertex)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(gl_Position); |
| } |
| )") << module_str; |
| } |
| |
| std::string LoosePointSizePreamble(std::string stage = "Vertex") { |
| return R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| OpEntryPoint )" + |
| stage + R"( %500 "main" %1 |
| )" + (stage == "Vertex" ? " %2 " : "") + |
| +(stage == "Fragment" ? "OpExecutionMode %500 OriginUpperLeft" : "") + |
| +(stage == "Vertex" ? " OpDecorate %2 BuiltIn Position " : "") + |
| R"( |
| OpDecorate %1 BuiltIn PointSize |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %v4float = OpTypeVector %float 4 |
| %uint = OpTypeInt 32 0 |
| %uint_0 = OpConstant %uint 0 |
| %uint_1 = OpConstant %uint 1 |
| %11 = OpTypePointer Output %float |
| %1 = OpVariable %11 Output |
| %12 = OpTypePointer Output %v4float |
| %2 = OpVariable %12 Output |
| )"; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinPointSize_Loose_Write1_IsErased) { |
| const std::string assembly = LoosePointSizePreamble() + R"( |
| %ptr = OpTypePointer Output %float |
| %one = OpConstant %float 1.0 |
| |
| %500 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| OpStore %1 %one |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_EQ(module_str, R"(var<private> x_2 : vec4<f32>; |
| |
| fn main_1() { |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(position)]] |
| x_2_1 : vec4<f32>; |
| }; |
| |
| [[stage(vertex)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(x_2); |
| } |
| )") << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinPointSize_Loose_WriteNon1_IsError) { |
| const std::string assembly = LoosePointSizePreamble() + R"( |
| %ptr = OpTypePointer Output %float |
| %999 = OpConstant %float 2.0 |
| |
| %500 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| OpStore %1 %999 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_THAT(p->error(), |
| HasSubstr("cannot store a value other than constant 1.0 to " |
| "PointSize builtin: OpStore %1 %999")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPointSize_Loose_ReadReplaced_Vertex) { |
| const std::string assembly = LoosePointSizePreamble() + R"( |
| %ptr = OpTypePointer Private %float |
| %900 = OpVariable %ptr Private |
| |
| %500 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %99 = OpLoad %float %1 |
| OpStore %900 %99 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| |
| EXPECT_TRUE(p->BuildAndParseInternalModule()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_EQ(module_str, R"(var<private> x_2 : vec4<f32>; |
| |
| var<private> x_900 : f32; |
| |
| fn main_1() { |
| x_900 = 1.0; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(position)]] |
| x_2_1 : vec4<f32>; |
| }; |
| |
| [[stage(vertex)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(x_2); |
| } |
| )") << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPointSize_Loose_ReadReplaced_Fragment) { |
| const std::string assembly = LoosePointSizePreamble("Fragment") + R"( |
| %ptr = OpTypePointer Private %float |
| %900 = OpVariable %ptr Private |
| |
| %500 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %99 = OpLoad %float %1 |
| OpStore %900 %99 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| |
| // This example is invalid because you PointSize is not valid in Vulkan |
| // Fragment shaders. |
| EXPECT_FALSE(p->Parse()); |
| EXPECT_FALSE(p->success()); |
| EXPECT_THAT(p->error(), HasSubstr("VUID-PointSize-PointSize-04314")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPointSize_Loose_WriteViaCopyObjectPriorAccess_Erased) { |
| const std::string assembly = LoosePointSizePreamble() + R"( |
| %one = OpConstant %float 1.0 |
| |
| %500 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %20 = OpCopyObject %11 %1 |
| %100 = OpAccessChain %11 %20 |
| OpStore %100 %one |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_EQ(module_str, R"(var<private> x_2 : vec4<f32>; |
| |
| fn main_1() { |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(position)]] |
| x_2_1 : vec4<f32>; |
| }; |
| |
| [[stage(vertex)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(x_2); |
| } |
| )") << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPointSize_Loose_WriteViaCopyObjectPostAccessChainErased) { |
| const std::string assembly = LoosePointSizePreamble() + R"( |
| %one = OpConstant %float 1.0 |
| |
| %500 = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %100 = OpAccessChain %11 %1 |
| %101 = OpCopyObject %11 %100 |
| OpStore %101 %one |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_TRUE(p->BuildAndParseInternalModule()) << p->error(); |
| EXPECT_TRUE(p->error().empty()) << p->error(); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_EQ(module_str, R"(var<private> x_2 : vec4<f32>; |
| |
| fn main_1() { |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(position)]] |
| x_2_1 : vec4<f32>; |
| }; |
| |
| [[stage(vertex)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(x_2); |
| } |
| )") << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinClipDistance_NotSupported) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr_float = OpTypePointer Output %float |
| %nil = OpConstantNull %float |
| %uint_2 = OpConstant %uint 2 |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| ; address of the first entry in ClipDistance |
| %100 = OpAccessChain %ptr_float %1 %uint_2 %uint_0 |
| OpStore %100 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_EQ(p->error(), |
| "accessing per-vertex member 2 is not supported. Only Position is " |
| "supported, and PointSize is ignored"); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinCullDistance_NotSupported) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr_float = OpTypePointer Output %float |
| %nil = OpConstantNull %float |
| %uint_3 = OpConstant %uint 3 |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| ; address of the first entry in CullDistance |
| %100 = OpAccessChain %ptr_float %1 %uint_3 %uint_0 |
| OpStore %100 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_EQ(p->error(), |
| "accessing per-vertex member 3 is not supported. Only Position is " |
| "supported, and PointSize is ignored"); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BuiltinPerVertex_MemberIndex_NotConstant) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr_float = OpTypePointer Output %float |
| %nil = OpConstantNull %float |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %sum = OpIAdd %uint %uint_0 %uint_0 |
| %100 = OpAccessChain %ptr_float %1 %sum |
| OpStore %100 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_THAT(p->error(), |
| Eq("first index of access chain into per-vertex structure is not " |
| "a constant: %100 = OpAccessChain %13 %1 %16")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BuiltinPerVertex_MemberIndex_NotConstantInteger) { |
| const std::string assembly = PerVertexPreamble() + R"( |
| %ptr_float = OpTypePointer Output %float |
| %nil = OpConstantNull %float |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| ; nil is bad here! |
| %100 = OpAccessChain %ptr_float %1 %nil |
| OpStore %100 %nil |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| EXPECT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_THAT(p->error(), |
| Eq("first index of access chain into per-vertex structure is not " |
| "a constant integer: %100 = OpAccessChain %13 %1 %14")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarInitializers) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %1 = OpVariable %ptr_bool Private %true |
| %2 = OpVariable %ptr_bool Private %false |
| %3 = OpVariable %ptr_int Private %int_m1 |
| %4 = OpVariable %ptr_uint Private %uint_1 |
| %5 = OpVariable %ptr_float Private %float_1p5 |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(var<private> x_1 : bool = true; |
| |
| var<private> x_2 : bool = false; |
| |
| var<private> x_3 : i32 = -1; |
| |
| var<private> x_4 : u32 = 1u; |
| |
| var<private> x_5 : f32 = 1.5; |
| )")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarNullInitializers) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %null_bool = OpConstantNull %bool |
| %null_int = OpConstantNull %int |
| %null_uint = OpConstantNull %uint |
| %null_float = OpConstantNull %float |
| |
| %1 = OpVariable %ptr_bool Private %null_bool |
| %2 = OpVariable %ptr_int Private %null_int |
| %3 = OpVariable %ptr_uint Private %null_uint |
| %4 = OpVariable %ptr_float Private %null_float |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(var<private> x_1 : bool = false; |
| |
| var<private> x_2 : i32 = 0; |
| |
| var<private> x_3 : u32 = 0u; |
| |
| var<private> x_4 : f32 = 0.0; |
| )")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarUndefInitializers) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %undef_bool = OpUndef %bool |
| %undef_int = OpUndef %int |
| %undef_uint = OpUndef %uint |
| %undef_float = OpUndef %float |
| |
| %1 = OpVariable %ptr_bool Private %undef_bool |
| %2 = OpVariable %ptr_int Private %undef_int |
| %3 = OpVariable %ptr_uint Private %undef_uint |
| %4 = OpVariable %ptr_float Private %undef_float |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(var<private> x_1 : bool = false; |
| |
| var<private> x_2 : i32 = 0; |
| |
| var<private> x_3 : u32 = 0u; |
| |
| var<private> x_4 : f32 = 0.0; |
| )")); |
| |
| // This example module emits ok, but is not valid SPIR-V in the first place. |
| p->DeliberatelyInvalidSpirv(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2float |
| %two = OpConstant %float 2.0 |
| %const = OpConstantComposite %v2float %float_1p5 %two |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("var<private> x_200 : vec2<f32> = vec2<f32>(1.5, 2.0);")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorBoolNullInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2bool |
| %const = OpConstantNull %v2bool |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("var<private> x_200 : vec2<bool> = vec2<bool>(false, false);")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorBoolUndefInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2bool |
| %const = OpUndef %v2bool |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("var<private> x_200 : vec2<bool> = vec2<bool>(false, false);")); |
| |
| // This example module emits ok, but is not valid SPIR-V in the first place. |
| p->DeliberatelyInvalidSpirv(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorUintNullInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2uint |
| %const = OpConstantNull %v2uint |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("var<private> x_200 : vec2<u32> = vec2<u32>(0u, 0u);")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorUintUndefInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2uint |
| %const = OpUndef %v2uint |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("var<private> x_200 : vec2<u32> = vec2<u32>(0u, 0u);")); |
| |
| // This example module emits ok, but is not valid SPIR-V in the first place. |
| p->DeliberatelyInvalidSpirv(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorIntNullInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2int |
| %const = OpConstantNull %v2int |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("var<private> x_200 : vec2<i32> = vec2<i32>(0, 0);")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorIntUndefInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2int |
| %const = OpUndef %v2int |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("var<private> x_200 : vec2<i32> = vec2<i32>(0, 0);")); |
| |
| // This example module emits ok, but is not valid SPIR-V in the first place. |
| p->DeliberatelyInvalidSpirv(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorFloatNullInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2float |
| %const = OpConstantNull %v2float |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("var<private> x_200 : vec2<f32> = vec2<f32>(0.0, 0.0);")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, VectorFloatUndefInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %v2float |
| %const = OpUndef %v2float |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("var<private> x_200 : vec2<f32> = vec2<f32>(0.0, 0.0);")); |
| |
| // This example module emits ok, but is not valid SPIR-V in the first place. |
| p->DeliberatelyInvalidSpirv(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, MatrixInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %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 |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("var<private> x_200 : mat3x2<f32> = mat3x2<f32>(" |
| "vec2<f32>(1.5, 2.0), " |
| "vec2<f32>(2.0, 3.0), " |
| "vec2<f32>(3.0, 4.0));")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, MatrixNullInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %m3v2float |
| %const = OpConstantNull %m3v2float |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("var<private> x_200 : mat3x2<f32> = mat3x2<f32>(" |
| "vec2<f32>(0.0, 0.0), " |
| "vec2<f32>(0.0, 0.0), " |
| "vec2<f32>(0.0, 0.0));")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, MatrixUndefInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %m3v2float |
| %const = OpUndef %m3v2float |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("var<private> x_200 : mat3x2<f32> = mat3x2<f32>(" |
| "vec2<f32>(0.0, 0.0), " |
| "vec2<f32>(0.0, 0.0), " |
| "vec2<f32>(0.0, 0.0));")); |
| |
| // This example module emits ok, but is not valid SPIR-V in the first place. |
| p->DeliberatelyInvalidSpirv(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ArrayInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %arr2uint |
| %two = OpConstant %uint 2 |
| %const = OpConstantComposite %arr2uint %uint_1 %two |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr( |
| "var<private> x_200 : array<u32, 2u> = array<u32, 2u>(1u, 2u);")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ArrayNullInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %arr2uint |
| %const = OpConstantNull %arr2uint |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr( |
| "var<private> x_200 : array<u32, 2u> = array<u32, 2u>(0u, 0u);")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ArrayUndefInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + R"( |
| %ptr = OpTypePointer Private %arr2uint |
| %const = OpUndef %arr2uint |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr( |
| "var<private> x_200 : array<u32, 2u> = array<u32, 2u>(0u, 0u);")); |
| |
| // This example module emits ok, but is not valid SPIR-V in the first place. |
| p->DeliberatelyInvalidSpirv(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, StructInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + |
| StructTypes() + R"( |
| %ptr = OpTypePointer Private %strct |
| %two = OpConstant %uint 2 |
| %arrconst = OpConstantComposite %arr2uint %uint_1 %two |
| %const = OpConstantComposite %strct %uint_1 %float_1p5 %arrconst |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("var<private> x_200 : S = S(1u, 1.5, array<u32, 2u>(1u, 2u));")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, StructNullInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + |
| StructTypes() + R"( |
| %ptr = OpTypePointer Private %strct |
| %const = OpConstantNull %strct |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("var<private> x_200 : S = S(0u, 0.0, array<u32, 2u>(0u, 0u));")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, StructUndefInitializer) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonTypes() + |
| StructTypes() + R"( |
| %ptr = OpTypePointer Private %strct |
| %const = OpUndef %strct |
| %200 = OpVariable %ptr Private %const |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("var<private> x_200 : S = S(0u, 0.0, array<u32, 2u>(0u, 0u));")) |
| << module_str; |
| |
| // This example module emits ok, but is not valid SPIR-V in the first place. |
| p->DeliberatelyInvalidSpirv(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| LocationDecoration_MissingOperandWontAssemble) { |
| const auto assembly = Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %myvar Location |
| )" + CommonTypes() + R"( |
| %ptr = OpTypePointer Input %uint |
| %myvar = OpVariable %ptr Input |
| )" + MainBody(); |
| EXPECT_THAT(test::AssembleFailure(assembly), |
| Eq("10:4: Expected operand, found next instruction instead.")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| LocationDecoration_TwoOperandsWontAssemble) { |
| const auto assembly = Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %myvar Location 3 4 |
| )" + CommonTypes() + R"( |
| %ptr = OpTypePointer Input %uint |
| %myvar = OpVariable %ptr Input |
| )" + MainBody(); |
| EXPECT_THAT( |
| test::AssembleFailure(assembly), |
| Eq("8:34: Expected <opcode> or <result-id> at the beginning of an " |
| "instruction, found '4'.")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, DescriptorGroupDecoration_Valid) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + CommonLayout() + R"( |
| OpDecorate %1 DescriptorSet 3 |
| OpDecorate %1 Binding 9 ; Required to pass WGSL validation |
| OpDecorate %strct Block |
| )" + CommonTypes() + StructTypes() + |
| R"( |
| %ptr_sb_strct = OpTypePointer StorageBuffer %strct |
| %1 = OpVariable %ptr_sb_strct StorageBuffer |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("[[group(3), binding(9)]] var<storage, read_write> x_1 : S;")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| DescriptorGroupDecoration_MissingOperandWontAssemble) { |
| const auto assembly = Preamble() + FragMain() + CommonLayout() + R"( |
| OpDecorate %1 DescriptorSet |
| OpDecorate %strct Block |
| )" + CommonTypes() + StructTypes() + |
| R"( |
| %ptr_sb_strct = OpTypePointer StorageBuffer %strct |
| %1 = OpVariable %ptr_sb_strct StorageBuffer |
| )" + MainBody(); |
| EXPECT_THAT(test::AssembleFailure(assembly), |
| Eq("13:5: Expected operand, found next instruction instead.")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| DescriptorGroupDecoration_TwoOperandsWontAssemble) { |
| const auto assembly = Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %myvar DescriptorSet 3 4 |
| OpDecorate %strct Block |
| )" + CommonTypes() + StructTypes() + |
| R"( |
| %ptr_sb_strct = OpTypePointer StorageBuffer %strct |
| %myvar = OpVariable %ptr_sb_strct StorageBuffer |
| )" + MainBody(); |
| EXPECT_THAT( |
| test::AssembleFailure(assembly), |
| Eq("8:39: Expected <opcode> or <result-id> at the beginning of an " |
| "instruction, found '4'.")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BindingDecoration_Valid) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpDecorate %1 DescriptorSet 0 ; WGSL validation requires this already |
| OpDecorate %1 Binding 3 |
| OpDecorate %strct Block |
| )" + CommonLayout() + CommonTypes() + |
| StructTypes() + |
| R"( |
| %ptr_sb_strct = OpTypePointer StorageBuffer %strct |
| %1 = OpVariable %ptr_sb_strct StorageBuffer |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT( |
| module_str, |
| HasSubstr("[[group(0), binding(3)]] var<storage, read_write> x_1 : S;")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| BindingDecoration_MissingOperandWontAssemble) { |
| const auto assembly = Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %myvar Binding |
| OpDecorate %strct Block |
| )" + CommonTypes() + StructTypes() + |
| R"( |
| %ptr_sb_strct = OpTypePointer StorageBuffer %strct |
| %myvar = OpVariable %ptr_sb_strct StorageBuffer |
| )" + MainBody(); |
| EXPECT_THAT(test::AssembleFailure(assembly), |
| Eq("9:5: Expected operand, found next instruction instead.")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, BindingDecoration_TwoOperandsWontAssemble) { |
| const auto assembly = Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %myvar Binding 3 4 |
| OpDecorate %strct Block |
| )" + CommonTypes() + StructTypes() + |
| R"( |
| %ptr_sb_strct = OpTypePointer StorageBuffer %strct |
| %myvar = OpVariable %ptr_sb_strct StorageBuffer |
| )" + MainBody(); |
| EXPECT_THAT( |
| test::AssembleFailure(assembly), |
| Eq("8:33: Expected <opcode> or <result-id> at the beginning of an " |
| "instruction, found '4'.")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| StructMember_NonReadableDecoration_Dropped) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpDecorate %1 DescriptorSet 0 |
| OpDecorate %1 Binding 0 |
| OpDecorate %strct Block |
| OpMemberDecorate %strct 0 NonReadable |
| )" + CommonLayout() + CommonTypes() + |
| StructTypes() + R"( |
| %ptr_sb_strct = OpTypePointer StorageBuffer %strct |
| %1 = OpVariable %ptr_sb_strct StorageBuffer |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(type Arr = [[stride(4)]] array<u32, 2u>; |
| |
| struct S { |
| field0 : u32; |
| field1 : f32; |
| field2 : Arr; |
| }; |
| |
| [[group(0), binding(0)]] var<storage, read_write> x_1 : S; |
| )")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ColMajorDecoration_Dropped) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %myvar DescriptorSet 0 |
| OpDecorate %myvar Binding 0 |
| OpDecorate %s Block |
| OpMemberDecorate %s 0 ColMajor |
| OpMemberDecorate %s 0 Offset 0 |
| OpMemberDecorate %s 0 MatrixStride 8 |
| %float = OpTypeFloat 32 |
| %v2float = OpTypeVector %float 2 |
| %m3v2float = OpTypeMatrix %v2float 3 |
| |
| %s = OpTypeStruct %m3v2float |
| %ptr_sb_s = OpTypePointer StorageBuffer %s |
| %myvar = OpVariable %ptr_sb_s StorageBuffer |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(struct S { |
| field0 : mat3x2<f32>; |
| }; |
| |
| [[group(0), binding(0)]] var<storage, read_write> myvar : S; |
| )")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, MatrixStrideDecoration_Natural_Dropped) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %myvar DescriptorSet 0 |
| OpDecorate %myvar Binding 0 |
| OpDecorate %s Block |
| OpMemberDecorate %s 0 MatrixStride 8 |
| OpMemberDecorate %s 0 Offset 0 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %v2float = OpTypeVector %float 2 |
| %m3v2float = OpTypeMatrix %v2float 3 |
| |
| %s = OpTypeStruct %m3v2float |
| %ptr_sb_s = OpTypePointer StorageBuffer %s |
| %myvar = OpVariable %ptr_sb_s StorageBuffer |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(struct S { |
| field0 : mat3x2<f32>; |
| }; |
| |
| [[group(0), binding(0)]] var<storage, read_write> myvar : S; |
| )")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, MatrixStrideDecoration) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %myvar DescriptorSet 0 |
| OpDecorate %myvar Binding 0 |
| OpDecorate %s Block |
| OpMemberDecorate %s 0 MatrixStride 64 |
| OpMemberDecorate %s 0 Offset 0 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %v2float = OpTypeVector %float 2 |
| %m3v2float = OpTypeMatrix %v2float 3 |
| |
| %s = OpTypeStruct %m3v2float |
| %ptr_sb_s = OpTypePointer StorageBuffer %s |
| %myvar = OpVariable %ptr_sb_s StorageBuffer |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(struct S { |
| [[stride(64), internal(disable_validation__ignore_stride)]] |
| field0 : mat3x2<f32>; |
| }; |
| |
| [[group(0), binding(0)]] var<storage, read_write> myvar : S; |
| )")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, RowMajorDecoration_IsError) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %myvar "myvar" |
| OpDecorate %s Block |
| OpMemberDecorate %s 0 RowMajor |
| OpMemberDecorate %s 0 Offset 0 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %v2float = OpTypeVector %float 2 |
| %m3v2float = OpTypeMatrix %v2float 3 |
| |
| %s = OpTypeStruct %m3v2float |
| %ptr_sb_s = OpTypePointer StorageBuffer %s |
| %myvar = OpVariable %ptr_sb_s StorageBuffer |
| )" + MainBody())); |
| EXPECT_FALSE(p->BuildAndParseInternalModuleExceptFunctions()); |
| EXPECT_THAT( |
| p->error(), |
| Eq(R"(WGSL does not support row-major matrices: can't translate member 0 of %3 = OpTypeStruct %8)")) |
| << p->error(); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, StorageBuffer_NonWritable_AllMembers) { |
| // Variable should have access(read) |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpDecorate %s Block |
| OpDecorate %1 DescriptorSet 0 |
| OpDecorate %1 Binding 0 |
| OpMemberDecorate %s 0 NonWritable |
| OpMemberDecorate %s 1 NonWritable |
| OpMemberDecorate %s 0 Offset 0 |
| OpMemberDecorate %s 1 Offset 4 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| |
| %s = OpTypeStruct %float %float |
| %ptr_sb_s = OpTypePointer StorageBuffer %s |
| %1 = OpVariable %ptr_sb_s StorageBuffer |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(struct S { |
| field0 : f32; |
| field1 : f32; |
| }; |
| |
| [[group(0), binding(0)]] var<storage, read> x_1 : S; |
| )")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, StorageBuffer_NonWritable_NotAllMembers) { |
| // Variable should have access(read_write) |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpDecorate %1 DescriptorSet 0 |
| OpDecorate %1 Binding 0 |
| OpDecorate %s Block |
| OpMemberDecorate %s 0 NonWritable |
| OpMemberDecorate %s 0 Offset 0 |
| OpMemberDecorate %s 1 Offset 4 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| |
| %s = OpTypeStruct %float %float |
| %ptr_sb_s = OpTypePointer StorageBuffer %s |
| %1 = OpVariable %ptr_sb_s StorageBuffer |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(struct S { |
| field0 : f32; |
| field1 : f32; |
| }; |
| |
| [[group(0), binding(0)]] var<storage, read_write> x_1 : S; |
| )")) << module_str; |
| } |
| |
| TEST_F( |
| SpvModuleScopeVarParserTest, |
| StorageBuffer_NonWritable_NotAllMembers_DuplicatedOnSameMember) { // NOLINT |
| // Variable should have access(read_write) |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpDecorate %s Block |
| OpDecorate %1 DescriptorSet 0 |
| OpDecorate %1 Binding 0 |
| OpMemberDecorate %s 0 NonWritable |
| OpMemberDecorate %s 0 NonWritable ; same member. Don't double-count it |
| OpMemberDecorate %s 0 Offset 0 |
| OpMemberDecorate %s 1 Offset 4 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| |
| %s = OpTypeStruct %float %float |
| %ptr_sb_s = OpTypePointer StorageBuffer %s |
| %1 = OpVariable %ptr_sb_s StorageBuffer |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr(R"(struct S { |
| field0 : f32; |
| field1 : f32; |
| }; |
| |
| [[group(0), binding(0)]] var<storage, read_write> x_1 : S; |
| )")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarSpecConstant_DeclareConst_Id_TooBig) { |
| // Override IDs must be between 0 and 65535 |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpDecorate %1 SpecId 65536 |
| %bool = OpTypeBool |
| %1 = OpSpecConstantTrue %bool |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| EXPECT_FALSE(p->Parse()); |
| EXPECT_EQ(p->error(), |
| "SpecId too large. WGSL override IDs must be between 0 and 65535: " |
| "ID %1 has SpecId 65536"); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| ScalarSpecConstant_DeclareConst_Id_MaxValid) { |
| // Override IDs must be between 0 and 65535 |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpDecorate %1 SpecId 65535 |
| %bool = OpTypeBool |
| %1 = OpSpecConstantTrue %bool |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| EXPECT_TRUE(p->Parse()); |
| EXPECT_EQ(p->error(), ""); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarSpecConstant_DeclareConst_True) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %c "myconst" |
| OpDecorate %c SpecId 12 |
| %bool = OpTypeBool |
| %c = OpSpecConstantTrue %bool |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("[[override(12)]] let myconst : bool = true;")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarSpecConstant_DeclareConst_False) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %c "myconst" |
| OpDecorate %c SpecId 12 |
| %bool = OpTypeBool |
| %c = OpSpecConstantFalse %bool |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("[[override(12)]] let myconst : bool = false;")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarSpecConstant_DeclareConst_U32) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %c "myconst" |
| OpDecorate %c SpecId 12 |
| %uint = OpTypeInt 32 0 |
| %c = OpSpecConstant %uint 42 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("[[override(12)]] let myconst : u32 = 42u;")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarSpecConstant_DeclareConst_I32) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %c "myconst" |
| OpDecorate %c SpecId 12 |
| %int = OpTypeInt 32 1 |
| %c = OpSpecConstant %int 42 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr("[[override(12)]] let myconst : i32 = 42;")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarSpecConstant_DeclareConst_F32) { |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %c "myconst" |
| OpDecorate %c SpecId 12 |
| %float = OpTypeFloat 32 |
| %c = OpSpecConstant %float 2.5 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, |
| HasSubstr("[[override(12)]] let myconst : f32 = 2.5;")) |
| << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, |
| ScalarSpecConstant_DeclareConst_F32_WithoutSpecId) { |
| // When we don't have a spec ID, declare an undecorated module-scope constant. |
| auto p = parser(test::Assemble(Preamble() + FragMain() + R"( |
| OpName %c "myconst" |
| %float = OpTypeFloat 32 |
| %c = OpSpecConstant %float 2.5 |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| )" + MainBody())); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| EXPECT_THAT(module_str, HasSubstr("let myconst : f32 = 2.5;")) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, ScalarSpecConstant_UsedInFunction) { |
| const auto assembly = Preamble() + FragMain() + R"( |
| OpName %c "myconst" |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %c = OpSpecConstant %float 2.5 |
| %floatfn = OpTypeFunction %float |
| %100 = OpFunction %float None %floatfn |
| %entry = OpLabel |
| %1 = OpFAdd %float %c %c |
| OpReturnValue %1 |
| OpFunctionEnd |
| )" + MainBody(); |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error(); |
| auto fe = p->function_emitter(100); |
| EXPECT_TRUE(fe.EmitBody()) << p->error(); |
| EXPECT_TRUE(p->error().empty()); |
| |
| Program program = p->program(); |
| const auto got = test::ToString(program, fe.ast_body()); |
| |
| EXPECT_THAT(got, HasSubstr("return (myconst + myconst);")) << got; |
| } |
| |
| // Returns the start of a shader for testing SampleId, |
| // parameterized by store type of %int or %uint |
| std::string SampleIdPreamble(std::string store_type) { |
| return R"( |
| OpCapability Shader |
| OpCapability SampleRateShading |
| OpMemoryModel Logical Simple |
| OpEntryPoint Fragment %main "main" %1 |
| OpExecutionMode %main OriginUpperLeft |
| OpDecorate %1 BuiltIn SampleId |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %uint = OpTypeInt 32 0 |
| %int = OpTypeInt 32 1 |
| %ptr_ty = OpTypePointer Input )" + |
| store_type + R"( |
| %1 = OpVariable %ptr_ty Input |
| )"; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleId_I32_Load_Direct) { |
| const std::string assembly = SampleIdPreamble("%int") + R"( |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpLoad %int %1 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = |
| R"(var<private> x_1 : i32; |
| |
| fn main_1() { |
| let x_2 : i32 = x_1; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_index)]] x_1_param : u32) { |
| x_1 = bitcast<i32>(x_1_param); |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleId_I32_Load_CopyObject) { |
| const std::string assembly = SampleIdPreamble("%int") + R"( |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %copy_ptr = OpCopyObject %ptr_ty %1 |
| %2 = OpLoad %int %copy_ptr |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = |
| R"(Module{ |
| Variable{ |
| x_1 |
| private |
| undefined |
| __i32 |
| } |
| Function main_1 -> __void |
| () |
| { |
| VariableDeclStatement{ |
| VariableConst{ |
| x_11 |
| none |
| undefined |
| __ptr_private__i32 |
| { |
| UnaryOp[not set]{ |
| address-of |
| Identifier[not set]{x_1} |
| } |
| } |
| } |
| } |
| VariableDeclStatement{ |
| VariableConst{ |
| x_2 |
| none |
| undefined |
| __i32 |
| { |
| UnaryOp[not set]{ |
| indirection |
| Identifier[not set]{x_14} |
| } |
| } |
| } |
| } |
| Return{} |
| } |
| Function main -> __void |
| StageDecoration{fragment} |
| ( |
| VariableConst{ |
| Decorations{ |
| BuiltinDecoration{sample_index} |
| } |
| x_1_param |
| none |
| undefined |
| __u32 |
| } |
| ) |
| { |
| Assignment{ |
| Identifier[not set]{x_1} |
| Bitcast[not set]<__i32>{ |
| Identifier[not set]{x_1_param} |
| } |
| } |
| Call[not set]{ |
| Identifier[not set]{main_1} |
| ( |
| ) |
| } |
| } |
| } |
| )"; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleId_I32_Load_AccessChain) { |
| const std::string assembly = SampleIdPreamble("%int") + R"( |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %copy_ptr = OpAccessChain %ptr_ty %1 |
| %2 = OpLoad %int %copy_ptr |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : i32; |
| |
| fn main_1() { |
| let x_2 : i32 = x_1; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_index)]] x_1_param : u32) { |
| x_1 = bitcast<i32>(x_1_param); |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleId_I32_FunctParam) { |
| const std::string assembly = SampleIdPreamble("%int") + R"( |
| %helper_ty = OpTypeFunction %int %ptr_ty |
| %helper = OpFunction %int None %helper_ty |
| %param = OpFunctionParameter %ptr_ty |
| %helper_entry = OpLabel |
| %3 = OpLoad %int %param |
| OpReturnValue %3 |
| OpFunctionEnd |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %result = OpFunctionCall %int %helper %1 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| |
| // This example is invalid because you can't pass pointer-to-Input |
| // as a function parameter. |
| EXPECT_FALSE(p->Parse()); |
| EXPECT_FALSE(p->success()); |
| EXPECT_THAT(p->error(), |
| HasSubstr("Invalid storage class for pointer operand 1")); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleId_U32_Load_Direct) { |
| const std::string assembly = SampleIdPreamble("%uint") + R"( |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpLoad %uint %1 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : u32; |
| |
| fn main_1() { |
| let x_2 : u32 = x_1; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_index)]] x_1_param : u32) { |
| x_1 = x_1_param; |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleId_U32_Load_CopyObject) { |
| const std::string assembly = SampleIdPreamble("%uint") + R"( |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %copy_ptr = OpCopyObject %ptr_ty %1 |
| %2 = OpLoad %uint %copy_ptr |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : u32; |
| |
| fn main_1() { |
| let x_11 : ptr<private, u32> = &(x_1); |
| let x_2 : u32 = *(x_11); |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_index)]] x_1_param : u32) { |
| x_1 = x_1_param; |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleId_U32_Load_AccessChain) { |
| const std::string assembly = SampleIdPreamble("%uint") + R"( |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %copy_ptr = OpAccessChain %ptr_ty %1 |
| %2 = OpLoad %uint %copy_ptr |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : u32; |
| |
| fn main_1() { |
| let x_2 : u32 = x_1; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_index)]] x_1_param : u32) { |
| x_1 = x_1_param; |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleId_U32_FunctParam) { |
| const std::string assembly = SampleIdPreamble("%uint") + R"( |
| %helper_ty = OpTypeFunction %uint %ptr_ty |
| %helper = OpFunction %uint None %helper_ty |
| %param = OpFunctionParameter %ptr_ty |
| %helper_entry = OpLabel |
| %3 = OpLoad %uint %param |
| OpReturnValue %3 |
| OpFunctionEnd |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %result = OpFunctionCall %uint %helper %1 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| // This example is invalid because you can't pass pointer-to-Input |
| // as a function parameter. |
| EXPECT_FALSE(p->Parse()); |
| EXPECT_THAT(p->error(), |
| HasSubstr("Invalid storage class for pointer operand 1")); |
| } |
| |
| // Returns the start of a shader for testing SampleMask |
| // parameterized by store type. |
| std::string SampleMaskPreamble(std::string store_type, uint32_t stride = 0u) { |
| return std::string(R"( |
| OpCapability Shader |
| OpMemoryModel Logical Simple |
| OpEntryPoint Fragment %main "main" %1 |
| OpExecutionMode %main OriginUpperLeft |
| OpDecorate %1 BuiltIn SampleMask |
| )") + |
| (stride > 0u ? R"( |
| OpDecorate %uarr1 ArrayStride 4 |
| OpDecorate %uarr2 ArrayStride 4 |
| OpDecorate %iarr1 ArrayStride 4 |
| OpDecorate %iarr2 ArrayStride 4 |
| )" |
| : "") + |
| R"( |
| %void = OpTypeVoid |
| %voidfn = OpTypeFunction %void |
| %float = OpTypeFloat 32 |
| %uint = OpTypeInt 32 0 |
| %int = OpTypeInt 32 1 |
| %int_12 = OpConstant %int 12 |
| %uint_0 = OpConstant %uint 0 |
| %uint_1 = OpConstant %uint 1 |
| %uint_2 = OpConstant %uint 2 |
| %uarr1 = OpTypeArray %uint %uint_1 |
| %uarr2 = OpTypeArray %uint %uint_2 |
| %iarr1 = OpTypeArray %int %uint_1 |
| %iarr2 = OpTypeArray %int %uint_2 |
| %iptr_in_ty = OpTypePointer Input %int |
| %uptr_in_ty = OpTypePointer Input %uint |
| %iptr_out_ty = OpTypePointer Output %int |
| %uptr_out_ty = OpTypePointer Output %uint |
| %in_ty = OpTypePointer Input )" + |
| store_type + R"( |
| %out_ty = OpTypePointer Output )" + |
| store_type + R"( |
| )"; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_In_ArraySize2_Error) { |
| const std::string assembly = SampleMaskPreamble("%uarr2") + R"( |
| %1 = OpVariable %in_ty Input |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_in_ty %1 %uint_0 |
| %3 = OpLoad %int %2 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_THAT(p->error(), |
| HasSubstr("WGSL supports a sample mask of at most 32 bits. " |
| "SampleMask must be an array of 1 element")) |
| << p->error() << assembly; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_In_U32_Direct) { |
| const std::string assembly = SampleMaskPreamble("%uarr1") + R"( |
| %1 = OpVariable %in_ty Input |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_in_ty %1 %uint_0 |
| %3 = OpLoad %uint %2 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<u32, 1u>; |
| |
| fn main_1() { |
| let x_3 : u32 = x_1[0]; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_mask)]] x_1_param : u32) { |
| x_1[0] = x_1_param; |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_In_U32_CopyObject) { |
| const std::string assembly = SampleMaskPreamble("%uarr1") + R"( |
| %1 = OpVariable %in_ty Input |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_in_ty %1 %uint_0 |
| %3 = OpCopyObject %uptr_in_ty %2 |
| %4 = OpLoad %uint %3 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<u32, 1u>; |
| |
| fn main_1() { |
| let x_4 : u32 = x_1[0]; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_mask)]] x_1_param : u32) { |
| x_1[0] = x_1_param; |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_In_U32_AccessChain) { |
| const std::string assembly = SampleMaskPreamble("%uarr1") + R"( |
| %1 = OpVariable %in_ty Input |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_in_ty %1 %uint_0 |
| %3 = OpAccessChain %uptr_in_ty %2 |
| %4 = OpLoad %uint %3 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<u32, 1u>; |
| |
| fn main_1() { |
| let x_4 : u32 = x_1[0]; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_mask)]] x_1_param : u32) { |
| x_1[0] = x_1_param; |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_In_I32_Direct) { |
| const std::string assembly = SampleMaskPreamble("%iarr1") + R"( |
| %1 = OpVariable %in_ty Input |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %iptr_in_ty %1 %uint_0 |
| %3 = OpLoad %int %2 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<i32, 1u>; |
| |
| fn main_1() { |
| let x_3 : i32 = x_1[0]; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_mask)]] x_1_param : u32) { |
| x_1[0] = bitcast<i32>(x_1_param); |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_In_I32_CopyObject) { |
| const std::string assembly = SampleMaskPreamble("%iarr1") + R"( |
| %1 = OpVariable %in_ty Input |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %iptr_in_ty %1 %uint_0 |
| %3 = OpCopyObject %iptr_in_ty %2 |
| %4 = OpLoad %int %3 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<i32, 1u>; |
| |
| fn main_1() { |
| let x_4 : i32 = x_1[0]; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_mask)]] x_1_param : u32) { |
| x_1[0] = bitcast<i32>(x_1_param); |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_In_I32_AccessChain) { |
| const std::string assembly = SampleMaskPreamble("%iarr1") + R"( |
| %1 = OpVariable %in_ty Input |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %iptr_in_ty %1 %uint_0 |
| %3 = OpAccessChain %iptr_in_ty %2 |
| %4 = OpLoad %int %3 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<i32, 1u>; |
| |
| fn main_1() { |
| let x_4 : i32 = x_1[0]; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_mask)]] x_1_param : u32) { |
| x_1[0] = bitcast<i32>(x_1_param); |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected) << module_str; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_Out_ArraySize2_Error) { |
| const std::string assembly = SampleMaskPreamble("%uarr2") + R"( |
| %1 = OpVariable %out_ty Output |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_out_ty %1 %uint_0 |
| OpStore %2 %uint_0 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_FALSE(p->BuildAndParseInternalModule()); |
| EXPECT_THAT(p->error(), |
| HasSubstr("WGSL supports a sample mask of at most 32 bits. " |
| "SampleMask must be an array of 1 element")) |
| << p->error() << assembly; |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_Out_U32_Direct) { |
| const std::string assembly = SampleMaskPreamble("%uarr1") + R"( |
| %1 = OpVariable %out_ty Output |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_out_ty %1 %uint_0 |
| OpStore %2 %uint_0 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<u32, 1u>; |
| |
| fn main_1() { |
| x_1[0] = 0u; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(sample_mask)]] |
| x_1_1 : u32; |
| }; |
| |
| [[stage(fragment)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(x_1[0]); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_Out_U32_CopyObject) { |
| const std::string assembly = SampleMaskPreamble("%uarr1") + R"( |
| %1 = OpVariable %out_ty Output |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_out_ty %1 %uint_0 |
| %3 = OpCopyObject %uptr_out_ty %2 |
| OpStore %2 %uint_0 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<u32, 1u>; |
| |
| fn main_1() { |
| x_1[0] = 0u; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(sample_mask)]] |
| x_1_1 : u32; |
| }; |
| |
| [[stage(fragment)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(x_1[0]); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_Out_U32_AccessChain) { |
| const std::string assembly = SampleMaskPreamble("%uarr1") + R"( |
| %1 = OpVariable %out_ty Output |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_out_ty %1 %uint_0 |
| %3 = OpAccessChain %uptr_out_ty %2 |
| OpStore %2 %uint_0 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<u32, 1u>; |
| |
| fn main_1() { |
| x_1[0] = 0u; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(sample_mask)]] |
| x_1_1 : u32; |
| }; |
| |
| [[stage(fragment)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(x_1[0]); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_Out_I32_Direct) { |
| const std::string assembly = SampleMaskPreamble("%iarr1") + R"( |
| %1 = OpVariable %out_ty Output |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %iptr_out_ty %1 %uint_0 |
| OpStore %2 %int_12 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<i32, 1u>; |
| |
| fn main_1() { |
| x_1[0] = 12; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(sample_mask)]] |
| x_1_1 : u32; |
| }; |
| |
| [[stage(fragment)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(bitcast<u32>(x_1[0])); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_Out_I32_CopyObject) { |
| const std::string assembly = SampleMaskPreamble("%iarr1") + R"( |
| %1 = OpVariable %out_ty Output |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %iptr_out_ty %1 %uint_0 |
| %3 = OpCopyObject %iptr_out_ty %2 |
| OpStore %2 %int_12 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<i32, 1u>; |
| |
| fn main_1() { |
| x_1[0] = 12; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(sample_mask)]] |
| x_1_1 : u32; |
| }; |
| |
| [[stage(fragment)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(bitcast<u32>(x_1[0])); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_Out_I32_AccessChain) { |
| const std::string assembly = SampleMaskPreamble("%iarr1") + R"( |
| %1 = OpVariable %out_ty Output |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %iptr_out_ty %1 %uint_0 |
| %3 = OpAccessChain %iptr_out_ty %2 |
| OpStore %2 %int_12 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(var<private> x_1 : array<i32, 1u>; |
| |
| fn main_1() { |
| x_1[0] = 12; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(sample_mask)]] |
| x_1_1 : u32; |
| }; |
| |
| [[stage(fragment)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(bitcast<u32>(x_1[0])); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_In_WithStride) { |
| const std::string assembly = SampleMaskPreamble("%uarr1", 4u) + R"( |
| %1 = OpVariable %in_ty Input |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_in_ty %1 %uint_0 |
| %3 = OpLoad %uint %2 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(type Arr = [[stride(4)]] array<u32, 1u>; |
| |
| type Arr_1 = [[stride(4)]] array<u32, 2u>; |
| |
| type Arr_2 = [[stride(4)]] array<i32, 1u>; |
| |
| type Arr_3 = [[stride(4)]] array<i32, 2u>; |
| |
| var<private> x_1 : Arr; |
| |
| fn main_1() { |
| let x_3 : u32 = x_1[0]; |
| return; |
| } |
| |
| [[stage(fragment)]] |
| fn main([[builtin(sample_mask)]] x_1_param : u32) { |
| x_1[0] = x_1_param; |
| main_1(); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| TEST_F(SpvModuleScopeVarParserTest, SampleMask_Out_WithStride) { |
| const std::string assembly = SampleMaskPreamble("%uarr1", 4u) + R"( |
| %1 = OpVariable %out_ty Output |
| |
| %main = OpFunction %void None %voidfn |
| %entry = OpLabel |
| %2 = OpAccessChain %uptr_out_ty %1 %uint_0 |
| OpStore %2 %uint_0 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| auto p = parser(test::Assemble(assembly)); |
| ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error() << assembly; |
| EXPECT_TRUE(p->error().empty()); |
| const auto module_str = test::ToString(p->program()); |
| const std::string expected = R"(type Arr = [[stride(4)]] array<u32, 1u>; |
| |
| type Arr_1 = [[stride(4)]] array<u32, 2u>; |
| |
| type Arr_2 = [[stride(4)]] array<i32, 1u>; |
| |
| type Arr_3 = [[stride(4)]] array<i32, 2u>; |
| |
| var<private> x_1 : Arr; |
| |
| fn main_1() { |
| x_1[0] = 0u; |
| return; |
| } |
| |
| struct main_out { |
| [[builtin(sample_mask)]] |
| x_1_1 : u32; |
| }; |
| |
| [[stage(fragment)]] |
| fn main() -> main_out { |
| main_1(); |
| return main_out(x_1[0]); |
| } |
| )"; |
| EXPECT_EQ(module_str, expected); |
| } |
| |
| // Returns the start of a shader for testing VertexIndex, |
| // parameterized by store type of %int or %uint |
| std::string VertexIndexPreamble(std::string store_type) { |
| |