Re-land fuzzing work with fix Revert "Revert 3 fuzzing CLs, since they are preventing rolling into Chromium." This reverts commit 1d9935cf37fdd1b9eb18f3e41d6142a345bba4a6. Also adjusts BUILD.gn file, so that Chromium build can find all the needed symbols. BUG=tint:58,tint:59,tint:193,tint:194,tint:199,tint:436 Change-Id: I3fe71ff52c8156f30fccfaab0bf7f647f158aea4 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/37460 Commit-Queue: Ryan Harrison <rharrison@chromium.org> Commit-Queue: dan sinclair <dsinclair@chromium.org> Auto-Submit: Ryan Harrison <rharrison@chromium.org> Reviewed-by: dan sinclair <dsinclair@chromium.org>
diff --git a/BUILD.gn b/BUILD.gn index 547b74a..c6cafcb 100644 --- a/BUILD.gn +++ b/BUILD.gn
@@ -75,6 +75,13 @@ ] } +config("tint_config") { + include_dirs = [] + if (tint_build_spv_reader || tint_build_spv_writer) { + include_dirs += [ "${tint_spirv_tools_dir}/include/" ] + } +} + ############################################################################### # Generated - Generated source files ############################################################################### @@ -1306,38 +1313,114 @@ # source_set. source_set("tint_fuzzer_common") { - configs += [ ":tint_common_config" ] - public_configs = [ ":tint_public_config" ] + public_configs = [ + ":tint_config", + ":tint_common_config", + ":tint_public_config", + ] + + public_deps = [ ":libtint" ] + + sources = [ + "fuzzers/tint_common_fuzzer.cc", + "fuzzers/tint_common_fuzzer.h", + ] } if (tint_build_wgsl_reader) { fuzzer_test("tint_wgsl_reader_fuzzer") { sources = [ "fuzzers/tint_wgsl_reader_fuzzer.cc" ] - deps = [ - ":libtint_wgsl_reader_src", - ":tint_fuzzer_common", - ] + deps = [ ":tint_fuzzer_common" ] + } + } + + if (tint_build_wgsl_reader && tint_build_wgsl_writer) { + fuzzer_test("tint_wgsl_reader_wgsl_writer_fuzzer") { + sources = [ "fuzzers/tint_wgsl_reader_wgsl_writer_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + } + + if (tint_build_wgsl_reader && tint_build_spv_writer) { + fuzzer_test("tint_wgsl_reader_spv_writer_fuzzer") { + sources = [ "fuzzers/tint_wgsl_reader_spv_writer_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + + fuzzer_test("tint_all_transforms_fuzzer") { + sources = [ "fuzzers/tint_all_transforms_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + + fuzzer_test("tint_bound_array_accessors_fuzzer") { + sources = [ "fuzzers/tint_bound_array_accessors_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + + fuzzer_test("tint_emit_vertex_point_size_fuzzer") { + sources = [ "fuzzers/tint_emit_vertex_point_size_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + + fuzzer_test("tint_first_index_offset_fuzzer") { + sources = [ "fuzzers/tint_first_index_offset_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + } + + if (tint_build_wgsl_reader && tint_build_hlsl_writer) { + fuzzer_test("tint_wgsl_reader_hlsl_writer_fuzzer") { + sources = [ "fuzzers/tint_wgsl_reader_hlsl_writer_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + } + + if (tint_build_wgsl_reader && tint_build_msl_writer) { + fuzzer_test("tint_wgsl_reader_msl_writer_fuzzer") { + sources = [ "fuzzers/tint_wgsl_reader_msl_writer_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] } } if (tint_build_spv_reader) { fuzzer_test("tint_spv_reader_fuzzer") { sources = [ "fuzzers/tint_spv_reader_fuzzer.cc" ] - deps = [ - ":libtint_spv_reader_src", - ":tint_fuzzer_common", - ] + deps = [ ":tint_fuzzer_common" ] + } + } + + if (tint_build_spv_reader && tint_build_wgsl_writer) { + fuzzer_test("tint_spv_reader_wgsl_writer_fuzzer") { + sources = [ "fuzzers/tint_spv_reader_wgsl_writer_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + } + + if (tint_build_spv_reader && tint_build_spv_writer) { + fuzzer_test("tint_spv_reader_spv_writer_fuzzer") { + sources = [ "fuzzers/tint_spv_reader_spv_writer_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + } + + if (tint_build_spv_reader && tint_build_hlsl_writer) { + fuzzer_test("tint_spv_reader_hlsl_writer_fuzzer") { + sources = [ "fuzzers/tint_spv_reader_hlsl_writer_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] + } + } + + if (tint_build_spv_reader && tint_build_msl_writer) { + fuzzer_test("tint_spv_reader_msl_writer_fuzzer") { + sources = [ "fuzzers/tint_spv_reader_msl_writer_fuzzer.cc" ] + deps = [ ":tint_fuzzer_common" ] } } if (tint_build_wgsl_reader && tint_build_wgsl_writer) { fuzzer_test("tint_ast_clone_fuzzer") { sources = [ "fuzzers/tint_ast_clone_fuzzer.cc" ] - deps = [ - ":libtint_wgsl_reader_src", - ":libtint_wgsl_writer_src", - ":tint_fuzzer_common", - ] + deps = [ ":tint_fuzzer_common" ] } } } @@ -1346,13 +1429,6 @@ # Samples - Executables exposing command line functionality ############################################################################### -config("tint_config") { - include_dirs = [] - if (tint_build_spv_reader || tint_build_spv_writer) { - include_dirs += [ "${tint_spirv_tools_dir}/include/" ] - } -} - executable("tint") { sources = [ "samples/main.cc" ] deps = [
diff --git a/fuzzers/CMakeLists.txt b/fuzzers/CMakeLists.txt index bfa50e7..50b43a1 100644 --- a/fuzzers/CMakeLists.txt +++ b/fuzzers/CMakeLists.txt
@@ -13,20 +13,59 @@ # limitations under the License. function(add_tint_fuzzer NAME) - add_executable(${NAME} ${NAME}.cc) + add_executable(${NAME} + ${NAME}.cc + tint_common_fuzzer.cc) target_link_libraries(${NAME} libtint-fuzz) tint_default_compile_options(${NAME}) target_compile_options(${NAME} PRIVATE -Wno-missing-prototypes) endfunction() -if (${TINT_BUILD_WGSL_READER}) +if ({$TINT_BUILD_WGSL_READER}) add_tint_fuzzer(tint_wgsl_reader_fuzzer) endif() +if ({$TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_WGSL_WRITER}) + add_tint_fuzzer(tint_wgsl_reader_wgsl_writer_fuzzer) +endif() + +if ({$TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_SPV_WRITER}) + add_tint_fuzzer(tint_all_transforms_fuzzer) + add_tint_fuzzer(tint_bound_array_accessors_fuzzer) + add_tint_fuzzer(tint_emit_vertex_point_size_fuzzer) + add_tint_fuzzer(tint_first_index_offset_fuzzer) + add_tint_fuzzer(tint_wgsl_reader_spv_writer_fuzzer) +endif() + +if ({$TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_HLSL_WRITER}) + add_tint_fuzzer(tint_wgsl_reader_hlsl_writer_fuzzer) +endif() + +if ({$TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_MSL_WRITER}) + add_tint_fuzzer(tint_wgsl_reader_msl_writer_fuzzer) +endif() + if (${TINT_BUILD_SPV_READER}) add_tint_fuzzer(tint_spv_reader_fuzzer) endif() +if (${TINT_BUILD_SPV_READER} AND ${TINT_BUILD_WGSL_WRITER}) + add_tint_fuzzer(tint_spv_reader_wgsl_writer_fuzzer) +endif() + +if (${TINT_BUILD_SPV_READER} AND ${TINT_BUILD_SPV_WRITER}) + add_tint_fuzzer(tint_spv_reader_spv_writer_fuzzer) +endif() + +if (${TINT_BUILD_SPV_READER} AND ${TINT_BUILD_HLSL_WRITER}) + add_tint_fuzzer(tint_spv_reader_hlsl_writer_fuzzer) +endif() + +if (${TINT_BUILD_SPV_READER} AND ${TINT_BUILD_MSL_WRITER}) + add_tint_fuzzer(tint_spv_reader_msl_writer_fuzzer) +endif() + + if (${TINT_BUILD_WGSL_READER} AND ${TINT_BUILD_WGSL_WRITER}) add_tint_fuzzer(tint_ast_clone_fuzzer) endif()
diff --git a/fuzzers/tint_all_transforms_fuzzer.cc b/fuzzers/tint_all_transforms_fuzzer.cc new file mode 100644 index 0000000..0fb4f33 --- /dev/null +++ b/fuzzers/tint_all_transforms_fuzzer.cc
@@ -0,0 +1,36 @@ +// 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. + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::transform::Manager transform_manager; + transform_manager.append( + std::make_unique<tint::transform::BoundArrayAccessors>()); + transform_manager.append( + std::make_unique<tint::transform::EmitVertexPointSize>()); + transform_manager.append( + std::make_unique<tint::transform::FirstIndexOffset>(0, 0)); + + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv); + fuzzer.SetTransformManager(&transform_manager); + + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_bound_array_accessors_fuzzer.cc b/fuzzers/tint_bound_array_accessors_fuzzer.cc new file mode 100644 index 0000000..7bb09d1 --- /dev/null +++ b/fuzzers/tint_bound_array_accessors_fuzzer.cc
@@ -0,0 +1,32 @@ +// 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. + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::transform::Manager transform_manager; + transform_manager.append( + std::make_unique<tint::transform::BoundArrayAccessors>()); + + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv); + fuzzer.SetTransformManager(&transform_manager); + + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_common_fuzzer.cc b/fuzzers/tint_common_fuzzer.cc new file mode 100644 index 0000000..a43ac9a --- /dev/null +++ b/fuzzers/tint_common_fuzzer.cc
@@ -0,0 +1,134 @@ +// 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. + +#include "fuzzers/tint_common_fuzzer.h" + +#include <memory> +#include <string> +#include <utility> +#include <vector> + +namespace tint { +namespace fuzzers { + +CommonFuzzer::CommonFuzzer(InputFormat input, OutputFormat output) + : input_(input), output_(output) {} +CommonFuzzer::~CommonFuzzer() = default; + +int CommonFuzzer::Run(const uint8_t* data, size_t size) { + std::unique_ptr<tint::reader::Reader> parser; +#if TINT_BUILD_WGSL_READER + std::unique_ptr<tint::Source::File> file; +#endif // TINT_BUILD_WGSL_READER + + switch (input_) { + case InputFormat::kWGSL: +#if TINT_BUILD_WGSL_READER + { + std::string str(reinterpret_cast<const char*>(data), size); + + file = std::make_unique<tint::Source::File>("test.wgsl", str); + parser = std::make_unique<tint::reader::wgsl::Parser>(file.get()); + } +#endif // TINT_BUILD_WGSL_READER + break; + case InputFormat::kSpv: +#if TINT_BUILD_SPV_READER + { + size_t sizeInU32 = size / sizeof(uint32_t); + const uint32_t* u32Data = reinterpret_cast<const uint32_t*>(data); + std::vector<uint32_t> input(u32Data, u32Data + sizeInU32); + + if (input.size() != 0) { + parser = std::make_unique<tint::reader::spirv::Parser>(input); + } + } +#endif // TINT_BUILD_WGSL_READER + break; + default: + break; + } + + if (!parser) { + return 0; + } + + if (!parser->Parse()) { + return 0; + } + + if (output_ == OutputFormat::kNone) { + return 0; + } + + auto mod = parser->module(); + if (!mod.IsValid()) { + return 0; + } + + tint::TypeDeterminer td(&mod); + if (!td.Determine()) { + return 0; + } + + tint::Validator v; + if (!v.Validate(&mod)) { + return 0; + } + + if (transform_manager_) { + auto out = transform_manager_->Run(&mod); + if (out.diagnostics.contains_errors()) { + return 0; + } + + mod = std::move(out.module); + } + + std::unique_ptr<tint::writer::Writer> writer; + + switch (output_) { + case OutputFormat::kWGSL: +#if TINT_BUILD_WGSL_WRITER + writer = std::make_unique<tint::writer::wgsl::Generator>(std::move(mod)); +#endif // TINT_BUILD_WGSL_WRITER + break; + case OutputFormat::kSpv: +#if TINT_BUILD_SPV_WRITER + writer = std::make_unique<tint::writer::spirv::Generator>(std::move(mod)); +#endif // TINT_BUILD_SPV_WRITER + break; + case OutputFormat::kHLSL: +#if TINT_BUILD_HLSL_WRITER + writer = std::make_unique<tint::writer::hlsl::Generator>(std::move(mod)); +#endif // TINT_BUILD_HLSL_WRITER + break; + case OutputFormat::kMSL: +#if TINT_BUILD_MSL_WRITER + writer = std::make_unique<tint::writer::msl::Generator>(std::move(mod)); +#endif // TINT_BUILD_MSL_WRITER + break; + case OutputFormat::kNone: + break; + } + + if (writer) { + writer->Generate(); + } + + return 0; +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_common_fuzzer.h b/fuzzers/tint_common_fuzzer.h new file mode 100644 index 0000000..346132d --- /dev/null +++ b/fuzzers/tint_common_fuzzer.h
@@ -0,0 +1,45 @@ +// 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 FUZZERS_TINT_COMMON_FUZZER_H_ +#define FUZZERS_TINT_COMMON_FUZZER_H_ + +#include "include/tint/tint.h" + +namespace tint { +namespace fuzzers { + +enum class InputFormat { kWGSL, kSpv, kNone }; + +enum class OutputFormat { kWGSL, kSpv, kHLSL, kMSL, kNone }; + +class CommonFuzzer { + public: + explicit CommonFuzzer(InputFormat input, OutputFormat output); + ~CommonFuzzer(); + + void SetTransformManager(transform::Manager* tm) { transform_manager_ = tm; } + + int Run(const uint8_t* data, size_t size); + + private: + InputFormat input_; + OutputFormat output_; + transform::Manager* transform_manager_; +}; + +} // namespace fuzzers +} // namespace tint + +#endif // FUZZERS_TINT_COMMON_FUZZER_H_
diff --git a/fuzzers/tint_emit_vertex_point_size_fuzzer.cc b/fuzzers/tint_emit_vertex_point_size_fuzzer.cc new file mode 100644 index 0000000..a2104c2 --- /dev/null +++ b/fuzzers/tint_emit_vertex_point_size_fuzzer.cc
@@ -0,0 +1,32 @@ +// 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. + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::transform::Manager transform_manager; + transform_manager.append( + std::make_unique<tint::transform::EmitVertexPointSize>()); + + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv); + fuzzer.SetTransformManager(&transform_manager); + + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_first_index_offset_fuzzer.cc b/fuzzers/tint_first_index_offset_fuzzer.cc new file mode 100644 index 0000000..eb7b74d --- /dev/null +++ b/fuzzers/tint_first_index_offset_fuzzer.cc
@@ -0,0 +1,32 @@ +// 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. + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::transform::Manager transform_manager; + transform_manager.append( + std::make_unique<tint::transform::FirstIndexOffset>(0, 0)); + + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv); + fuzzer.SetTransformManager(&transform_manager); + + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_spv_reader_fuzzer.cc b/fuzzers/tint_spv_reader_fuzzer.cc index e809e55..b90c09a 100644 --- a/fuzzers/tint_spv_reader_fuzzer.cc +++ b/fuzzers/tint_spv_reader_fuzzer.cc
@@ -14,17 +14,15 @@ #include <vector> -#include "src/reader/spirv/parser.h" +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - size_t sizeInU32 = size / sizeof(uint32_t); - const uint32_t* u32Data = reinterpret_cast<const uint32_t*>(data); - std::vector<uint32_t> input(u32Data, u32Data + sizeInU32); - - if (input.size() != 0) { - tint::reader::spirv::Parser parser(input); - parser.Parse(); - } - - return 0; + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kNone); + return fuzzer.Run(data, size); } + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_spv_reader_hlsl_writer_fuzzer.cc b/fuzzers/tint_spv_reader_hlsl_writer_fuzzer.cc new file mode 100644 index 0000000..990002b --- /dev/null +++ b/fuzzers/tint_spv_reader_hlsl_writer_fuzzer.cc
@@ -0,0 +1,28 @@ +// 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. + +#include <vector> + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kHLSL); + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_spv_reader_msl_writer_fuzzer.cc b/fuzzers/tint_spv_reader_msl_writer_fuzzer.cc new file mode 100644 index 0000000..cfff9ba --- /dev/null +++ b/fuzzers/tint_spv_reader_msl_writer_fuzzer.cc
@@ -0,0 +1,28 @@ +// 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. + +#include <vector> + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kMSL); + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_spv_reader_spv_writer_fuzzer.cc b/fuzzers/tint_spv_reader_spv_writer_fuzzer.cc new file mode 100644 index 0000000..ac2d0dd --- /dev/null +++ b/fuzzers/tint_spv_reader_spv_writer_fuzzer.cc
@@ -0,0 +1,28 @@ +// 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. + +#include <vector> + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kSpv); + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_spv_reader_wgsl_writer_fuzzer.cc b/fuzzers/tint_spv_reader_wgsl_writer_fuzzer.cc new file mode 100644 index 0000000..30a4f1a --- /dev/null +++ b/fuzzers/tint_spv_reader_wgsl_writer_fuzzer.cc
@@ -0,0 +1,28 @@ +// 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. + +#include <vector> + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kSpv, OutputFormat::kWGSL); + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_fuzzer.cc b/fuzzers/tint_wgsl_reader_fuzzer.cc index d1a7507..280700e 100644 --- a/fuzzers/tint_wgsl_reader_fuzzer.cc +++ b/fuzzers/tint_wgsl_reader_fuzzer.cc
@@ -14,14 +14,15 @@ #include <string> -#include "src/reader/wgsl/parser.h" +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - std::string str(reinterpret_cast<const char*>(data), size); - - tint::Source::File file("test.wgsl", str); - tint::reader::wgsl::Parser parser(&file); - parser.Parse(); - - return 0; + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kNone); + return fuzzer.Run(data, size); } + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_hlsl_writer_fuzzer.cc b/fuzzers/tint_wgsl_reader_hlsl_writer_fuzzer.cc new file mode 100644 index 0000000..f10dcf5 --- /dev/null +++ b/fuzzers/tint_wgsl_reader_hlsl_writer_fuzzer.cc
@@ -0,0 +1,28 @@ +// 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. + +#include <string> + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kHLSL); + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_msl_writer_fuzzer.cc b/fuzzers/tint_wgsl_reader_msl_writer_fuzzer.cc new file mode 100644 index 0000000..028cab3 --- /dev/null +++ b/fuzzers/tint_wgsl_reader_msl_writer_fuzzer.cc
@@ -0,0 +1,28 @@ +// 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. + +#include <string> + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kMSL); + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_spv_writer_fuzzer.cc b/fuzzers/tint_wgsl_reader_spv_writer_fuzzer.cc new file mode 100644 index 0000000..885f9a9 --- /dev/null +++ b/fuzzers/tint_wgsl_reader_spv_writer_fuzzer.cc
@@ -0,0 +1,28 @@ +// 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. + +#include <string> + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kSpv); + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint
diff --git a/fuzzers/tint_wgsl_reader_wgsl_writer_fuzzer.cc b/fuzzers/tint_wgsl_reader_wgsl_writer_fuzzer.cc new file mode 100644 index 0000000..8568425 --- /dev/null +++ b/fuzzers/tint_wgsl_reader_wgsl_writer_fuzzer.cc
@@ -0,0 +1,28 @@ +// 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. + +#include <string> + +#include "fuzzers/tint_common_fuzzer.h" + +namespace tint { +namespace fuzzers { + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + tint::fuzzers::CommonFuzzer fuzzer(InputFormat::kWGSL, OutputFormat::kWGSL); + return fuzzer.Run(data, size); +} + +} // namespace fuzzers +} // namespace tint