blob: 3f9c3985c6247c92ac7370a7860a8d54fb84d1bc [file] [log] [blame] [edit]
// 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/tint/reader/spirv/function.h"
#include "src/tint/reader/spirv/parser_impl_test_helper.h"
#include "src/tint/reader/spirv/spirv_tools_helpers_test.h"
namespace tint::reader::spirv {
namespace {
using ::testing::Eq;
using ::testing::HasSubstr;
std::string Preamble() {
return R"(
OpCapability Shader
OpMemoryModel Logical Simple
OpEntryPoint Fragment %100 "main"
OpExecutionMode %100 OriginUpperLeft
)";
}
std::string CommonTypes() {
return R"(
%void = OpTypeVoid
%voidfn = OpTypeFunction %void
%bool = OpTypeBool
%uint = OpTypeInt 32 0
%int = OpTypeInt 32 1
%float = OpTypeFloat 32
%v2bool = OpTypeVector %bool 2
%v2uint = OpTypeVector %uint 2
%v2int = OpTypeVector %int 2
%v2float = OpTypeVector %float 2
)";
}
using SpvParserTestMiscInstruction = SpvParserTest;
TEST_F(SpvParserTestMiscInstruction, OpUndef_BeforeFunction_Scalar) {
const auto assembly = Preamble() + CommonTypes() + R"(
%1 = OpUndef %bool
%2 = OpUndef %uint
%3 = OpUndef %int
%4 = OpUndef %float
%100 = OpFunction %void None %voidfn
%entry = OpLabel
%11 = OpCopyObject %bool %1
%12 = OpCopyObject %uint %2
%13 = OpCopyObject %int %3
%14 = OpCopyObject %float %4
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 ast_body = fe.ast_body();
EXPECT_THAT(test::ToString(p->program(), ast_body), HasSubstr(R"(let x_11 : bool = false;
let x_12 : u32 = 0u;
let x_13 : i32 = 0i;
let x_14 : f32 = 0.0f;
return;
)"));
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_BeforeFunction_Vector) {
const auto assembly = Preamble() + CommonTypes() + R"(
%4 = OpUndef %v2bool
%1 = OpUndef %v2uint
%2 = OpUndef %v2int
%3 = OpUndef %v2float
%100 = OpFunction %void None %voidfn
%entry = OpLabel
%14 = OpCopyObject %v2bool %4
%11 = OpCopyObject %v2uint %1
%12 = OpCopyObject %v2int %2
%13 = OpCopyObject %v2float %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();
auto ast_body = fe.ast_body();
EXPECT_THAT(test::ToString(p->program(), ast_body),
HasSubstr(R"(let x_14 : vec2<bool> = vec2<bool>();
let x_11 : vec2<u32> = vec2<u32>();
let x_12 : vec2<i32> = vec2<i32>();
let x_13 : vec2<f32> = vec2<f32>();
)"));
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Scalar) {
const auto assembly = Preamble() + CommonTypes() + R"(
%100 = OpFunction %void None %voidfn
%entry = OpLabel
%1 = OpUndef %bool
%2 = OpUndef %uint
%3 = OpUndef %int
%4 = OpUndef %float
%11 = OpCopyObject %bool %1
%12 = OpCopyObject %uint %2
%13 = OpCopyObject %int %3
%14 = OpCopyObject %float %4
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 ast_body = fe.ast_body();
EXPECT_THAT(test::ToString(p->program(), ast_body), HasSubstr(R"(let x_11 : bool = false;
let x_12 : u32 = 0u;
let x_13 : i32 = 0i;
let x_14 : f32 = 0.0f;
return;
)"));
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Vector) {
const auto assembly = Preamble() + CommonTypes() + R"(
%100 = OpFunction %void None %voidfn
%entry = OpLabel
%1 = OpUndef %v2uint
%2 = OpUndef %v2int
%3 = OpUndef %v2float
%11 = OpCopyObject %v2uint %1
%12 = OpCopyObject %v2int %2
%13 = OpCopyObject %v2float %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();
auto ast_body = fe.ast_body();
EXPECT_THAT(test::ToString(p->program(), ast_body),
HasSubstr(R"(let x_11 : vec2<u32> = vec2<u32>();
let x_12 : vec2<i32> = vec2<i32>();
let x_13 : vec2<f32> = vec2<f32>();
)"));
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Matrix) {
const auto assembly = Preamble() + CommonTypes() + R"(
%mat = OpTypeMatrix %v2float 2
%100 = OpFunction %void None %voidfn
%entry = OpLabel
%1 = OpUndef %mat
%11 = OpCopyObject %mat %1
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 ast_body = fe.ast_body();
EXPECT_THAT(test::ToString(p->program(), ast_body),
HasSubstr("let x_11 : mat2x2<f32> = mat2x2<f32>();"));
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Array) {
const auto assembly = Preamble() + CommonTypes() + R"(
%uint_2 = OpConstant %uint 2
%arr = OpTypeArray %uint %uint_2
%100 = OpFunction %void None %voidfn
%entry = OpLabel
%1 = OpUndef %arr
%11 = OpCopyObject %arr %1
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 ast_body = fe.ast_body();
EXPECT_THAT(test::ToString(p->program(), ast_body),
HasSubstr("let x_11 : array<u32, 2u> = array<u32, 2u>();"));
}
TEST_F(SpvParserTestMiscInstruction, OpUndef_InFunction_Struct) {
const auto assembly = Preamble() + CommonTypes() + R"(
%strct = OpTypeStruct %bool %uint %int %float
%100 = OpFunction %void None %voidfn
%entry = OpLabel
%1 = OpUndef %strct
%11 = OpCopyObject %strct %1
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 ast_body = fe.ast_body();
EXPECT_THAT(test::ToString(p->program(), ast_body),
HasSubstr("let x_11 : S = S(false, 0u, 0i, 0.0f);"));
}
TEST_F(SpvParserTestMiscInstruction, OpNop) {
const auto assembly = Preamble() + CommonTypes() + R"(
%100 = OpFunction %void None %voidfn
%entry = OpLabel
OpNop
OpReturn
OpFunctionEnd
)";
auto p = parser(test::Assemble(assembly));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error() << assembly;
auto fe = p->function_emitter(100);
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto ast_body = fe.ast_body();
EXPECT_EQ(test::ToString(p->program(), ast_body), "return;\n");
}
// Test swizzle generation.
struct SwizzleCase {
uint32_t index;
std::string expected_expr;
std::string expected_error;
};
using SpvParserSwizzleTest = SpvParserTestBase<::testing::TestWithParam<SwizzleCase>>;
TEST_P(SpvParserSwizzleTest, Sample) {
// We need a function so we can get a FunctionEmitter.
const auto assembly = Preamble() + CommonTypes() + R"(
%100 = OpFunction %void None %voidfn
%entry = OpLabel
OpReturn
OpFunctionEnd
)";
auto p = parser(test::Assemble(assembly));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
auto fe = p->function_emitter(100);
auto* result = fe.Swizzle(GetParam().index);
if (GetParam().expected_error.empty()) {
Program program(p->program());
EXPECT_TRUE(fe.success());
ASSERT_NE(result, nullptr);
auto got = test::ToString(program, result);
EXPECT_EQ(got, GetParam().expected_expr);
} else {
EXPECT_EQ(result, nullptr);
EXPECT_FALSE(fe.success());
EXPECT_EQ(p->error(), GetParam().expected_error);
}
}
INSTANTIATE_TEST_SUITE_P(ValidIndex,
SpvParserSwizzleTest,
::testing::ValuesIn(std::vector<SwizzleCase>{
{0, "x", ""},
{1, "y", ""},
{2, "z", ""},
{3, "w", ""},
{4, "", "vector component index is larger than 3: 4"},
{99999, "", "vector component index is larger than 3: 99999"}}));
TEST_F(SpvParserTest, ValueFromBlockNotInBlockOrder) {
// crbug.com/tint/804
const auto assembly = Preamble() + CommonTypes() + 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 = OpFMul %float %500 %float_42 ; %500 is defined in %20
OpBranch %30 ; backedge
%90 = OpLabel
OpReturn
OpFunctionEnd
)";
auto p = parser(test::Assemble(assembly));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
auto fe = p->function_emitter(100);
EXPECT_TRUE(fe.EmitBody()) << p->error();
auto ast_body = fe.ast_body();
const auto got = test::ToString(p->program(), ast_body);
EXPECT_THAT(got, HasSubstr("let x_81 : f32 = (0.0f * 42.0f);"));
}
// TODO(dneto): OpSizeof : requires Kernel (OpenCL)
} // namespace
} // namespace tint::reader::spirv