| // 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. |
| |
| #ifndef SRC_TINT_LANG_SPIRV_WRITER_AST_PRINTER_HELPER_TEST_H_ |
| #define SRC_TINT_LANG_SPIRV_WRITER_AST_PRINTER_HELPER_TEST_H_ |
| |
| #include <memory> |
| #include <string> |
| #include <utility> |
| |
| #include "gtest/gtest.h" |
| #include "spirv-tools/libspirv.hpp" |
| #include "src/tint/lang/spirv/writer/ast_printer/ast_printer.h" |
| #include "src/tint/lang/spirv/writer/common/binary_writer.h" |
| #include "src/tint/lang/wgsl/resolver/resolve.h" |
| |
| namespace tint::spirv::writer { |
| |
| /// Helper class for testing |
| template <typename BASE> |
| class TestHelperBase : public ProgramBuilder, public BASE { |
| public: |
| /// Builder is an alias to the spirv::writer::Builder (as opposed to the ast::Builder) |
| using Builder = writer::Builder; |
| |
| TestHelperBase() = default; |
| ~TestHelperBase() override = default; |
| |
| /// @returns the default generator options for SanitizeAndBuild(), if no explicit options are |
| /// provided. |
| static Options DefaultOptions() { |
| Options opts; |
| opts.disable_robustness = true; |
| return opts; |
| } |
| |
| /// Builds and returns a Builder from the program. |
| /// @note The Builder is only built once. Multiple calls to Build() |
| /// will return the same Builder without rebuilding. |
| /// @return the built Builder |
| Builder& Build() { |
| if (spirv_builder) { |
| return *spirv_builder; |
| } |
| [&] { |
| ASSERT_TRUE(IsValid()) << "Builder program is not valid\n" << Diagnostics().str(); |
| }(); |
| program = std::make_unique<Program>(resolver::Resolve(*this)); |
| [&] { ASSERT_TRUE(program->IsValid()) << program->Diagnostics().str(); }(); |
| spirv_builder = std::make_unique<Builder>(program.get()); |
| return *spirv_builder; |
| } |
| |
| /// Builds the program, runs the program through the transform::Spirv |
| /// sanitizer and returns a Builder from the sanitized program. |
| /// @param options The SPIR-V generator options. |
| /// @note The Builder is only built once. Multiple calls to Build() |
| /// will return the same Builder without rebuilding. |
| /// @return the built Builder |
| Builder& SanitizeAndBuild(const Options& options = DefaultOptions()) { |
| if (spirv_builder) { |
| return *spirv_builder; |
| } |
| [&] { |
| ASSERT_TRUE(IsValid()) << "Builder program is not valid\n" << Diagnostics().str(); |
| }(); |
| program = std::make_unique<Program>(resolver::Resolve(*this)); |
| [&] { ASSERT_TRUE(program->IsValid()) << program->Diagnostics().str(); }(); |
| auto result = Sanitize(program.get(), options); |
| [&] { ASSERT_TRUE(result.program.IsValid()) << result.program.Diagnostics().str(); }(); |
| *program = std::move(result.program); |
| bool zero_initialize_workgroup_memory = |
| !options.disable_workgroup_init && |
| options.use_zero_initialize_workgroup_memory_extension; |
| spirv_builder = |
| std::make_unique<Builder>(program.get(), zero_initialize_workgroup_memory, |
| options.experimental_require_subgroup_uniform_control_flow); |
| return *spirv_builder; |
| } |
| |
| /// Validate passes the generated SPIR-V of the builder `b` to the SPIR-V |
| /// Tools Validator. If the validator finds problems the test will fail. |
| /// @param b the Builder containing the built SPIR-V module |
| void Validate(Builder& b) { |
| BinaryWriter writer; |
| writer.WriteHeader(b.Module().IdBound()); |
| writer.WriteModule(&b.Module()); |
| auto binary = writer.Result(); |
| |
| std::string spv_errors; |
| auto msg_consumer = [&spv_errors](spv_message_level_t level, const char*, |
| const spv_position_t& position, const char* message) { |
| switch (level) { |
| case SPV_MSG_FATAL: |
| case SPV_MSG_INTERNAL_ERROR: |
| case SPV_MSG_ERROR: |
| spv_errors += |
| "error: line " + std::to_string(position.index) + ": " + message + "\n"; |
| break; |
| case SPV_MSG_WARNING: |
| spv_errors += |
| "warning: line " + std::to_string(position.index) + ": " + message + "\n"; |
| break; |
| case SPV_MSG_INFO: |
| spv_errors += |
| "info: line " + std::to_string(position.index) + ": " + message + "\n"; |
| break; |
| case SPV_MSG_DEBUG: |
| break; |
| } |
| }; |
| |
| spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_2); |
| tools.SetMessageConsumer(msg_consumer); |
| ASSERT_TRUE(tools.Validate(binary)) << spv_errors; |
| } |
| |
| /// The program built with a call to Build() |
| std::unique_ptr<Program> program; |
| |
| private: |
| std::unique_ptr<Builder> spirv_builder; |
| }; |
| using TestHelper = TestHelperBase<testing::Test>; |
| |
| template <typename T> |
| using TestParamHelper = TestHelperBase<testing::TestWithParam<T>>; |
| |
| } // namespace tint::spirv::writer |
| |
| #endif // SRC_TINT_LANG_SPIRV_WRITER_AST_PRINTER_HELPER_TEST_H_ |