| // Copyright 2021 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_FUZZERS_TINT_COMMON_FUZZER_H_ |
| #define SRC_TINT_FUZZERS_TINT_COMMON_FUZZER_H_ |
| |
| #include <cassert> |
| #include <cstring> |
| #include <memory> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "include/tint/tint.h" |
| |
| #include "src/tint/fuzzers/data_builder.h" |
| |
| namespace tint::fuzzers { |
| |
| // TODO(crbug.com/tint/1356): Add using shader reflection to generate options |
| // that are potentially valid for Generate*Options |
| // functions. |
| /// Generates random set of options for SPIRV generation |
| void GenerateSpirvOptions(DataBuilder* b, writer::spirv::Options* options); |
| |
| /// Generates random set of options for WGSL generation |
| void GenerateWgslOptions(DataBuilder* b, writer::wgsl::Options* options); |
| |
| /// Generates random set of options for HLSL generation |
| void GenerateHlslOptions(DataBuilder* b, writer::hlsl::Options* options); |
| |
| /// Generates random set of options for MSL generation |
| void GenerateMslOptions(DataBuilder* b, writer::msl::Options* options); |
| |
| /// Shader language the fuzzer is reading |
| enum class InputFormat { kWGSL, kSpv }; |
| |
| /// Shader language the fuzzer is emitting |
| enum class OutputFormat { kWGSL, kSpv, kHLSL, kMSL }; |
| |
| /// Generic runner for reading and emitting shaders using Tint, used by most |
| /// fuzzers to share common code. |
| class CommonFuzzer { |
| public: |
| /// Constructor |
| /// @param input shader language being read |
| /// @param output shader language being emitted |
| CommonFuzzer(InputFormat input, OutputFormat output); |
| |
| /// Destructor |
| ~CommonFuzzer(); |
| |
| /// @param tm manager for transforms to run |
| /// @param inputs data for transforms to run |
| void SetTransformManager(transform::Manager* tm, transform::DataMap* inputs) { |
| assert((!tm || inputs) && "DataMap must be !nullptr if Manager !nullptr"); |
| transform_manager_ = tm; |
| transform_inputs_ = inputs; |
| } |
| |
| /// @param enabled if the input shader for run should be outputted to the log |
| void SetDumpInput(bool enabled) { dump_input_ = enabled; } |
| |
| /// @param enabled if the shader being valid after parsing is being enforced. |
| /// If false, invalidation of the shader will cause an early exit, but not |
| /// throw an error. |
| /// If true invalidation will throw an error that is caught by libFuzzer and |
| /// will generate a crash report. |
| void SetEnforceValidity(bool enabled) { enforce_validity = enabled; } |
| |
| /// Convert given shader from input to output format. |
| /// Will also apply provided transforms and run the inspector over the result. |
| /// @param data buffer of data that will interpreted as a byte array or string |
| /// depending on the shader input format. |
| /// @param size number of elements in buffer |
| /// @returns 0, this is what libFuzzer expects |
| int Run(const uint8_t* data, size_t size); |
| |
| /// @returns diagnostic messages generated while Run() is executed. |
| const tint::diag::List& Diagnostics() const { return diagnostics_; } |
| |
| /// @returns if there are any errors in the diagnostic messages |
| bool HasErrors() const { return diagnostics_.contains_errors(); } |
| |
| /// @returns generated SPIR-V binary, if SPIR-V was emitted. |
| const std::vector<uint32_t>& GetGeneratedSpirv() const { |
| return generated_spirv_; |
| } |
| |
| /// @returns generated WGSL string, if WGSL was emitted. |
| const std::string& GetGeneratedWgsl() const { return generated_wgsl_; } |
| |
| /// @returns generated HLSL string, if HLSL was emitted. |
| const std::string& GetGeneratedHlsl() const { return generated_hlsl_; } |
| |
| /// @returns generated MSL string, if HLSL was emitted. |
| const std::string& GetGeneratedMsl() const { return generated_msl_; } |
| |
| /// @param options SPIR-V emission options |
| void SetOptionsSpirv(const writer::spirv::Options& options) { |
| options_spirv_ = options; |
| } |
| |
| /// @param options WGSL emission options |
| void SetOptionsWgsl(const writer::wgsl::Options& options) { |
| options_wgsl_ = options; |
| } |
| |
| /// @param options HLSL emission options |
| void SetOptionsHlsl(const writer::hlsl::Options& options) { |
| options_hlsl_ = options; |
| } |
| |
| /// @param options MSL emission options |
| void SetOptionsMsl(const writer::msl::Options& options) { |
| options_msl_ = options; |
| } |
| |
| private: |
| InputFormat input_; |
| OutputFormat output_; |
| transform::Manager* transform_manager_ = nullptr; |
| transform::DataMap* transform_inputs_ = nullptr; |
| bool dump_input_ = false; |
| tint::diag::List diagnostics_; |
| bool enforce_validity = false; |
| |
| std::vector<uint32_t> generated_spirv_; |
| std::string generated_wgsl_; |
| std::string generated_hlsl_; |
| std::string generated_msl_; |
| |
| writer::spirv::Options options_spirv_; |
| writer::wgsl::Options options_wgsl_; |
| writer::hlsl::Options options_hlsl_; |
| writer::msl::Options options_msl_; |
| |
| #if TINT_BUILD_WGSL_READER |
| /// The source file needs to live at least as long as #diagnostics_ |
| std::unique_ptr<Source::File> file_; |
| #endif // TINT_BUILD_WGSL_READER |
| |
| /// Runs a series of reflection operations to exercise the Inspector API. |
| void RunInspector(Program* program); |
| }; |
| |
| } // namespace tint::fuzzers |
| |
| #endif // SRC_TINT_FUZZERS_TINT_COMMON_FUZZER_H_ |