[spirv-reader] Emit module-scope var initializers

Bug: tint:3
Change-Id: Ifadd7616945e2392d6705746b295448a21366b0f
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/18821
Reviewed-by: dan sinclair <dsinclair@google.com>
This commit is contained in:
David Neto 2020-04-08 14:24:06 +00:00 committed by dan sinclair
parent 4194d0f948
commit ec322349e2
2 changed files with 260 additions and 1 deletions

View File

@ -710,7 +710,13 @@ bool ParserImpl::EmitModuleScopeVariables() {
auto* ast_store_type = ast_type->AsPointer()->type();
auto ast_var =
MakeVariable(var.result_id(), ast_storage_class, ast_store_type);
if (var.NumInOperands() > 1) {
// SPIR-V initializers are always constants.
// (OpenCL also allows the ID of an OpVariable, but we don't handle that
// here.)
ast_var->set_constructor(
MakeConstantExpression(var.GetSingleWordInOperand(1)));
}
// TODO(dneto): initializers (a.k.a. constructor expression)
ast_module_.AddGlobalVariable(std::move(ast_var));
}

View File

@ -27,6 +27,37 @@ namespace {
using ::testing::HasSubstr;
using ::testing::Not;
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
%uint_2 = OpConstant %uint 2
%v2float = OpTypeVector %float 2
%m3v2float = OpTypeMatrix %v2float 3
%arr2uint = OpTypeArray %uint %uint_2
%strct = OpTypeStruct %uint %float %arr2uint
)";
}
TEST_F(SpvParserTest, ModuleScopeVar_NoVar) {
auto p = parser(test::Assemble(""));
EXPECT_TRUE(p->BuildAndParseInternalModule());
@ -143,6 +174,228 @@ TEST_F(SpvParserTest, ModuleScopeVar_BuiltinVerteIndex) {
})"));
}
TEST_F(SpvParserTest, ModuleScopeVar_ScalarInitializers) {
auto p = parser(test::Assemble(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
)"));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
EXPECT_THAT(module_str, HasSubstr(R"(Variable{
x_1
private
__bool
{
ScalarConstructor{true}
}
}
Variable{
x_2
private
__bool
{
ScalarConstructor{false}
}
}
Variable{
x_3
private
__i32
{
ScalarConstructor{-1}
}
}
Variable{
x_4
private
__u32
{
ScalarConstructor{1}
}
}
Variable{
x_5
private
__f32
{
ScalarConstructor{1.500000}
}
})"));
}
TEST_F(SpvParserTest, ModuleScopeVar_ScalarNullInitializers) {
auto p = parser(test::Assemble(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
)"));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
EXPECT_THAT(module_str, HasSubstr(R"(Variable{
x_1
private
__bool
{
ScalarConstructor{false}
}
}
Variable{
x_2
private
__i32
{
ScalarConstructor{0}
}
}
Variable{
x_3
private
__u32
{
ScalarConstructor{0}
}
}
Variable{
x_4
private
__f32
{
ScalarConstructor{0.000000}
}
})"));
}
TEST_F(SpvParserTest, ModuleScopeVar_VectorInitializer) {
auto p = parser(test::Assemble(CommonTypes() + R"(
%ptr = OpTypePointer Private %v2float
%two = OpConstant %float 2.0
%const = OpConstantComposite %v2float %float_1p5 %two
%200 = OpVariable %ptr Private %const
)"));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
EXPECT_THAT(module_str, HasSubstr(R"(Variable{
x_200
private
__vec_2__f32
{
TypeConstructor{
__vec_2__f32
ScalarConstructor{1.500000}
ScalarConstructor{2.000000}
}
}
})"));
}
TEST_F(SpvParserTest, ModuleScopeVar_MatrixInitializer) {
auto p = parser(test::Assemble(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
)"));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
EXPECT_THAT(module_str, HasSubstr(R"(Variable{
x_200
private
__mat_2_3__f32
{
TypeConstructor{
__mat_2_3__f32
TypeConstructor{
__vec_2__f32
ScalarConstructor{1.500000}
ScalarConstructor{2.000000}
}
TypeConstructor{
__vec_2__f32
ScalarConstructor{2.000000}
ScalarConstructor{3.000000}
}
TypeConstructor{
__vec_2__f32
ScalarConstructor{3.000000}
ScalarConstructor{4.000000}
}
}
}
})"));
}
TEST_F(SpvParserTest, ModuleScopeVar_ArrayInitializer) {
auto p = parser(test::Assemble(CommonTypes() + R"(
%ptr = OpTypePointer Private %arr2uint
%two = OpConstant %uint 2
%const = OpConstantComposite %arr2uint %uint_1 %two
%200 = OpVariable %ptr Private %const
)"));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
EXPECT_THAT(module_str, HasSubstr(R"(Variable{
x_200
private
__array__u32_2
{
TypeConstructor{
__array__u32_2
ScalarConstructor{1}
ScalarConstructor{2}
}
}
})"));
}
TEST_F(SpvParserTest, ModuleScopeVar_StructInitializer) {
auto p = parser(test::Assemble(CommonTypes() + 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
)"));
ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
EXPECT_TRUE(p->error().empty());
const auto module_str = p->module().to_str();
EXPECT_THAT(module_str, HasSubstr(R"(Variable{
x_200
private
__struct_S
{
TypeConstructor{
__struct_S
ScalarConstructor{1}
ScalarConstructor{1.500000}
TypeConstructor{
__array__u32_2
ScalarConstructor{1}
ScalarConstructor{2}
}
}
}
})"));
}
} // namespace
} // namespace spirv
} // namespace reader