[spirv-writer] Emit function signatures.
This CL updates the SPIR-V writer to emit the OpTypeFunction and
OpFunction instructions.
Bug: tint:5
Change-Id: I85ead161ca37304a977213257a825ff268d29f2d
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/17741
Reviewed-by: David Neto <dneto@google.com>
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 70979a2..10605fd 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -408,6 +408,7 @@
writer/spirv/builder_test.cc
writer/spirv/builder_type_test.cc
writer/spirv/builder_entry_point_test.cc
+ writer/spirv/builder_function_test.cc
writer/spirv/instruction_test.cc
writer/spirv/operand_test.cc
writer/spirv/spv_dump.cc
diff --git a/src/ast/function.cc b/src/ast/function.cc
index 4d13d13..4aa7c52 100644
--- a/src/ast/function.cc
+++ b/src/ast/function.cc
@@ -14,6 +14,8 @@
#include "src/ast/function.h"
+#include <sstream>
+
namespace tint {
namespace ast {
@@ -83,5 +85,16 @@
out << "}" << std::endl;
}
+std::string Function::type_name() const {
+ std::ostringstream out;
+
+ out << "__func" + return_type_->type_name();
+ for (const auto& param : params_) {
+ out << param->type()->type_name();
+ }
+
+ return out.str();
+}
+
} // namespace ast
} // namespace tint
diff --git a/src/ast/function.h b/src/ast/function.h
index 691f059..71afe7c 100644
--- a/src/ast/function.h
+++ b/src/ast/function.h
@@ -94,6 +94,9 @@
/// @param indent number of spaces to indent the node when writing
void to_str(std::ostream& out, size_t indent) const override;
+ /// @returns the type name for this function
+ std::string type_name() const;
+
private:
Function(const Function&) = delete;
diff --git a/src/ast/function_test.cc b/src/ast/function_test.cc
index d2bd9aa..e4506a5 100644
--- a/src/ast/function_test.cc
+++ b/src/ast/function_test.cc
@@ -16,6 +16,7 @@
#include "gtest/gtest.h"
#include "src/ast/nop_statement.h"
+#include "src/ast/type/f32_type.h"
#include "src/ast/type/i32_type.h"
#include "src/ast/type/void_type.h"
#include "src/ast/variable.h"
@@ -202,5 +203,27 @@
)");
}
+TEST_F(FunctionTest, TypeName) {
+ type::VoidType void_type;
+
+ Function f("func", {}, &void_type);
+ EXPECT_EQ(f.type_name(), "__func__void");
+}
+
+TEST_F(FunctionTest, TypeName_WithParams) {
+ type::VoidType void_type;
+ type::I32Type i32;
+ type::F32Type f32;
+
+ std::vector<std::unique_ptr<Variable>> params;
+ params.push_back(
+ std::make_unique<Variable>("var1", StorageClass::kNone, &i32));
+ params.push_back(
+ std::make_unique<Variable>("var2", StorageClass::kNone, &f32));
+
+ Function f("func", std::move(params), &void_type);
+ EXPECT_EQ(f.type_name(), "__func__void__i32__f32");
+}
+
} // namespace ast
} // namespace tint
diff --git a/src/reader/spirv/namer_test.cc b/src/reader/spirv/namer_test.cc
index 75c46c1..4f94907 100644
--- a/src/reader/spirv/namer_test.cc
+++ b/src/reader/spirv/namer_test.cc
@@ -200,7 +200,7 @@
TEST_F(
SpvNamerTest,
- SuggestSanitizedMemberName_TakeSuggestionWhenNoConflictAfterSuggestionForLowerMember) {
+ SuggestSanitizedMemberName_TakeSuggestionWhenNoConflictAfterSuggestionForLowerMember) { // NOLINT
Namer namer(fail_stream_);
EXPECT_TRUE(namer.SuggestSanitizedMemberName(1, 7, "mother"));
EXPECT_THAT(namer.GetMemberName(1, 2), Eq(""));
diff --git a/src/reader/spirv/parser_impl.cc b/src/reader/spirv/parser_impl.cc
index 000cd64..97ce5f2 100644
--- a/src/reader/spirv/parser_impl.cc
+++ b/src/reader/spirv/parser_impl.cc
@@ -238,7 +238,7 @@
bool ParserImpl::ParseInternalModule() {
if (!success_) {
return false;
- };
+ }
if (!RegisterExtendedInstructionImports()) {
return false;
}
diff --git a/src/writer/spirv/builder.cc b/src/writer/spirv/builder.cc
index 6a9063d..7d511ee 100644
--- a/src/writer/spirv/builder.cc
+++ b/src/writer/spirv/builder.cc
@@ -14,6 +14,8 @@
#include "src/writer/spirv/builder.h"
+#include <utility>
+
#include "spirv/unified1/spirv.h"
#include "src/ast/struct.h"
#include "src/ast/struct_member.h"
@@ -74,6 +76,12 @@
{Operand::Int(SpvAddressingModelLogical),
Operand::Int(SpvMemoryModelVulkanKHR)});
+ for (const auto& func : m.functions()) {
+ if (!GenerateFunction(func.get())) {
+ return false;
+ }
+ }
+
for (const auto& ep : m.entry_points()) {
if (!GenerateEntryPoint(ep.get())) {
return false;
@@ -142,6 +150,58 @@
return true;
}
+bool Builder::GenerateFunction(ast::Function* func) {
+ uint32_t func_type_id = GenerateFunctionTypeIfNeeded(func);
+ if (func_type_id == 0) {
+ return false;
+ }
+
+ auto func_op = result_op();
+ auto func_id = func_op.to_i();
+
+ push_debug(spv::Op::OpName,
+ {Operand::Int(func_id), Operand::String(func->name())});
+
+ auto ret_id = GenerateTypeIfNeeded(func->return_type());
+ if (ret_id == 0) {
+ return false;
+ }
+
+ // TODO(dsinclair): Handle parameters
+ push_inst(spv::Op::OpFunction, {Operand::Int(ret_id), func_op,
+ Operand::Int(SpvFunctionControlMaskNone),
+ Operand::Int(func_type_id)});
+ push_inst(spv::Op::OpLabel, {result_op()});
+
+ // TODO(dsinclair): Function body ...
+
+ push_inst(spv::Op::OpFunctionEnd, {});
+
+ func_name_to_id_[func->name()] = func_id;
+ return true;
+}
+
+uint32_t Builder::GenerateFunctionTypeIfNeeded(ast::Function* func) {
+ auto val = type_name_to_id_.find(func->type_name());
+ if (val != type_name_to_id_.end()) {
+ return val->second;
+ }
+
+ auto func_op = result_op();
+ auto func_type_id = func_op.to_i();
+
+ auto ret_id = GenerateTypeIfNeeded(func->return_type());
+ if (ret_id == 0) {
+ return 0;
+ }
+
+ // TODO(dsinclair): Handle parameters
+ push_type(spv::Op::OpTypeFunction, {func_op, Operand::Int(ret_id)});
+
+ type_name_to_id_[func->type_name()] = func_type_id;
+ return func_type_id;
+}
+
void Builder::GenerateImport(ast::Import* imp) {
auto result = result_op();
auto id = result.to_i();
diff --git a/src/writer/spirv/builder.h b/src/writer/spirv/builder.h
index 31efbde..fe56501 100644
--- a/src/writer/spirv/builder.h
+++ b/src/writer/spirv/builder.h
@@ -110,7 +110,7 @@
instructions_.push_back(Instruction{op, operands});
}
/// @returns the instruction list
- const std::vector<Instruction>& inst() const { return instructions_; }
+ const std::vector<Instruction>& instructions() const { return instructions_; }
/// Adds an instruction to the annotations
/// @param op the op to set
/// @param operands the operands for the instruction
@@ -124,6 +124,14 @@
/// @param ep the entry point
/// @returns true if the instruction was generated, false otherwise
bool GenerateEntryPoint(ast::EntryPoint* ep);
+ /// Generates the instructions for a function
+ /// @param func the function to generate
+ /// @returns true if the instructions were generated
+ bool GenerateFunction(ast::Function* func);
+ /// Generates a function type if not already created
+ /// @param func the function to generate for
+ /// @returns the ID to use for the function type. Returns 0 on failure.
+ uint32_t GenerateFunctionTypeIfNeeded(ast::Function* func);
/// Generates an import instruction
/// @param imp the import
void GenerateImport(ast::Import* imp);
diff --git a/src/writer/spirv/builder_entry_point_test.cc b/src/writer/spirv/builder_entry_point_test.cc
index 953fb47..44213b4 100644
--- a/src/writer/spirv/builder_entry_point_test.cc
+++ b/src/writer/spirv/builder_entry_point_test.cc
@@ -85,7 +85,7 @@
ASSERT_EQ(preamble.size(), 1);
EXPECT_EQ(preamble[0].opcode(), spv::Op::OpEntryPoint);
- ASSERT_TRUE(preamble[0].operands().size() >= 3);
+ ASSERT_GE(preamble[0].operands().size(), 3);
EXPECT_EQ(preamble[0].operands()[0].to_i(), params.model);
}
INSTANTIATE_TEST_SUITE_P(
diff --git a/src/writer/spirv/builder_function_test.cc b/src/writer/spirv/builder_function_test.cc
new file mode 100644
index 0000000..891675d
--- /dev/null
+++ b/src/writer/spirv/builder_function_test.cc
@@ -0,0 +1,80 @@
+// 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 <string>
+
+#include "gtest/gtest.h"
+#include "spirv/unified1/spirv.h"
+#include "spirv/unified1/spirv.hpp11"
+#include "src/ast/function.h"
+#include "src/ast/type/void_type.h"
+#include "src/writer/spirv/builder.h"
+#include "src/writer/spirv/spv_dump.h"
+
+namespace tint {
+namespace writer {
+namespace spirv {
+
+using BuilderTest = testing::Test;
+
+TEST_F(BuilderTest, Function_Empty) {
+ ast::type::VoidType void_type;
+ ast::Function func("a_func", {}, &void_type);
+
+ Builder b;
+ ASSERT_TRUE(b.GenerateFunction(&func));
+
+ EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %3 "a_func"
+)");
+ EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+)");
+ EXPECT_EQ(DumpInstructions(b.instructions()), R"(%3 = OpFunction %2 None %1
+%4 = OpLabel
+OpFunctionEnd
+)");
+}
+
+TEST_F(BuilderTest, DISABLED_Function_WithParams) {}
+
+TEST_F(BuilderTest, DISABLED_Function_WithBody) {}
+
+TEST_F(BuilderTest, FunctionType) {
+ ast::type::VoidType void_type;
+ ast::Function func("a_func", {}, &void_type);
+
+ Builder b;
+ ASSERT_TRUE(b.GenerateFunction(&func));
+ EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+)");
+}
+
+TEST_F(BuilderTest, FunctionType_DeDuplicate) {
+ ast::type::VoidType void_type;
+ ast::Function func1("a_func", {}, &void_type);
+ ast::Function func2("b_func", {}, &void_type);
+
+ Builder b;
+ ASSERT_TRUE(b.GenerateFunction(&func1));
+ ASSERT_TRUE(b.GenerateFunction(&func2));
+ EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+)");
+}
+
+
+} // namespace spirv
+} // namespace writer
+} // namespace tint
diff --git a/src/writer/spirv/spv_dump.h b/src/writer/spirv/spv_dump.h
index 34a023e..c9079c7 100644
--- a/src/writer/spirv/spv_dump.h
+++ b/src/writer/spirv/spv_dump.h
@@ -16,6 +16,7 @@
#define SRC_WRITER_SPIRV_SPV_DUMP_H_
#include <string>
+#include <vector>
#include "src/writer/spirv/builder.h"
#include "src/writer/spirv/instruction.h"
