chore: import upstream snapshot with attribution

tensorflow/cc/framework/fuzzing/BUILD

@@ -0,0 +1,71 @@
+# TODO(unda): describe this package.
+
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("//tensorflow:tensorflow.bzl", "tf_copts")
+load(
+    "//tensorflow/cc/framework/fuzzing:op_fuzzing.bzl",
+    "tf_gen_op_wrappers_fuzz",
+)
+
+# copybara:uncomment package(default_applicable_licenses = ["//tensorflow:license"])
+
+cc_library(
+    name = "cc_op_fuzz_gen_main",
+    srcs = [
+        "cc_op_fuzz_gen.cc",
+        "cc_op_fuzz_gen.h",
+        "cc_op_fuzz_gen_main.cc",
+    ],
+    copts = tf_copts(),
+    data = [
+        "//tensorflow/core/api_def:base_api_def",
+    ],
+    deps = [
+        "//tensorflow/cc:cc_op_gen_util",
+        "//tensorflow/core:framework",
+        "//tensorflow/core:lib",
+        "//tensorflow/core:lib_internal",
+        "//tensorflow/core:op_gen_lib",
+        "//tensorflow/core:protos_all_cc",
+        "//tensorflow/core/platform:hash",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/log",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:statusor",
+        "@com_google_absl//absl/strings",
+        "@xla//xla/tsl/platform:status",
+    ],
+)
+
+# copybara:uncomment_begin
+# tf_gen_op_wrappers_fuzz(
+#     name = "array_ops_fuzz",
+#     api_def_srcs = ["//tensorflow/core/api_def:base_api_def"],
+#     kernel_deps = [
+#         "//tensorflow/c/kernels:bitcast_op",
+#         "//tensorflow/core/kernels:array",
+#         "//tensorflow/core/kernels:check_numerics_op",
+#         "//tensorflow/core/kernels:fake_quant_ops",
+#         "//tensorflow/core/kernels:quantized_ops",
+#         "//tensorflow/core/kernels:scatter_nd_op",
+#         "//tensorflow/core/kernels/image:extract_image_patches_op",
+#         "//tensorflow/core/kernels/image:extract_volume_patches_op",
+#         "//tensorflow/core/kernels/image:mirror_pad_op",
+#         "//tensorflow/core/kernels/linalg:matrix_band_part_op",
+#         "//tensorflow/core/kernels/linalg:matrix_diag_op",
+#         "//tensorflow/core/kernels/linalg:matrix_set_diag_op",
+#     ],
+#     op_def_src = "//tensorflow/core/ops:array_ops_op_lib",
+# )
+# copybara:uncomment_end
+
+bzl_library(
+    name = "op_fuzzing_bzl",
+    srcs = ["op_fuzzing.bzl"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//tensorflow:tensorflow_bzl",
+        "//tensorflow/core/platform:rules_cc_bzl",
+    ],
+)

tensorflow/cc/framework/fuzzing/cc_op_fuzz_gen.cc

@@ -0,0 +1,332 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+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 "tensorflow/cc/framework/fuzzing/cc_op_fuzz_gen.h"
+
+#include <iostream>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/substitute.h"
+#include "tensorflow/cc/framework/cc_op_gen_util.h"
+#include "tensorflow/core/framework/api_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/op_def_util.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/platform/hash.h"
+#include "tensorflow/core/platform/strcat.h"
+#include "tensorflow/core/platform/stringpiece.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/public/version.h"
+
+namespace tensorflow {
+namespace cc_op {
+namespace {
+
+std::string DefaultValue(OpDef_AttrDef attr) {
+  static const auto* attr_default_value_map =
+      new absl::flat_hash_map<absl::string_view, absl::string_view,
+                              StringPieceHasher>{
+          {"int", "0"},
+          {"string", "\"\""},
+          {"list(int)", "{ 0, 1 }"},
+          {"list(float)", "{0.0, 1.0}"},
+          {"type", "DT_UINT8"},
+          {"shape",
+           "mediapipe::ParseTextProtoOrDie<TensorShapeProto>("
+           "\"dim:[] unknown_rank:true\")"}};
+
+  if (attr.has_minimum()) {
+    if (attr.type() == "int") {
+      return absl::StrCat(attr.minimum());
+    } else if (attr.type() == "list(int)") {
+      std::vector<int> v(attr.minimum());
+      for (int i = 0; i < v.size(); ++i) v[i] = i;
+      std::string s = absl::StrCat("{", absl::StrJoin(v, ","), "}");
+      return s;
+    }
+  }
+  if (attr.has_allowed_values()) {
+    if (!attr.allowed_values().list().s().empty()) {
+      return absl::StrCat("\"", attr.allowed_values().list().s(0), "\"");
+    } else if (!attr.allowed_values().list().type().empty()) {
+      return DataType_Name(attr.allowed_values().list().type(0));
+    }
+  }
+  auto entry = attr_default_value_map->find(attr.type());
+  if (entry == attr_default_value_map->end()) {
+    LOG(ERROR) << "Unsupported Attr type: " << attr.type();
+    return "";
+  }
+  return std::string(entry->second);
+}
+
+std::string WriteClassFuzzDef(const OpInfo& op_info) {
+  std::string class_signature_str = absl::Substitute(
+      "class Fuzz$0 : public FuzzSession<$1> {\n", op_info.op_name,
+      absl::StrJoin(op_info.graph_op_def.input_arg(), ", ",
+                    [](std::string* out, const auto arg) {
+                      absl::StrAppend(out, "Tensor");
+                      if (ArgIsList(arg)) absl::StrAppend(out, ", Tensor");
+                    }));
+
+  std::string build_graph_body = absl::StrCat(
+      absl::StrJoin(
+          op_info.graph_op_def.input_arg(), "",
+          [op_info](std::string* out, const OpDef_ArgDef arg) {
+            std::string type = "DT_UINT8";
+
+            if (arg.type() != DT_INVALID) {
+              type = DataType_Name(arg.type());
+            } else if (!arg.type_attr().empty()) {
+              OpDef_AttrDef attr =
+                  *FindAttr(arg.type_attr(), op_info.graph_op_def);
+              if (attr.has_default_value() &&
+                  attr.default_value().value_case() == AttrValue::kType) {
+                type = DataType_Name(attr.default_value().type());
+              } else if (attr.has_allowed_values() &&
+                         attr.allowed_values().value_case() ==
+                             AttrValue::kList &&
+                         !attr.allowed_values().list().type().empty()) {
+                type = DataType_Name(attr.allowed_values().list().type(0));
+              }
+            }
+            if (ArgIsList(arg)) {
+              strings::StrAppend(
+                  out, "    Input ", arg.name(),
+                  "_0 = ", "tensorflow::ops::Placeholder(scope.WithOpName(\"",
+                  arg.name(), "\"), ", type, ");\n");
+              strings::StrAppend(
+                  out, "    Input ", arg.name(),
+                  "_1 = ", "tensorflow::ops::Placeholder(scope.WithOpName(\"",
+                  arg.name(), "\"), ", type, ");\n");
+              absl::StrAppend(
+                  out, absl::Substitute("    InputList $0({$0_0, $0_1});\n",
+                                        arg.name()));
+            } else {
+              strings::StrAppend(
+                  out, "    auto ", arg.name(), " = ",
+                  "tensorflow::ops::Placeholder(scope.WithOpName(\"",
+                  arg.name(), "\"), ", type, ");\n");
+            }
+          }),
+      absl::StrJoin(op_info.graph_op_def.attr(), "",
+                    [op_info](std::string* out, const OpDef_AttrDef attr) {
+                      if (op_info.inferred_input_attrs.count(attr.name()) ==
+                              0 &&
+                          !attr.has_default_value()) {
+                        strings::StrAppend(out, "    auto ", attr.name(), " = ",
+                                           DefaultValue(attr), ";\n");
+                      }
+                    }));
+
+  std::string constructor_call_str = absl::Substitute(
+      "    tensorflow::ops::$0(scope.WithOpName(\"output\")$1);\n",
+      op_info.op_name,
+      absl::StrCat(
+          op_info.api_def.arg_order().empty()
+              ? absl::StrJoin(op_info.api_def.in_arg(), "",
+                              [](std::string* out, const auto api_def_arg) {
+                                strings::StrAppend(out, ", ",
+                                                   api_def_arg.name());
+                              })
+              : absl::StrJoin(op_info.api_def.arg_order(), "",
+                              [](std::string* out, const auto name) {
+                                strings::StrAppend(out, ", ", name);
+                              }),
+          absl::StrJoin(op_info.graph_op_def.attr(), "",
+                        [op_info](std::string* out, const OpDef_AttrDef attr) {
+                          if (op_info.inferred_input_attrs.count(attr.name()) ==
+                                  0 &&
+                              !attr.has_default_value()) {
+                            absl::StrAppend(out, ", ", attr.name());
+                          }
+                        })));
+
+  std::string fuzz_impl_signature_str = absl::Substitute(
+      "  void FuzzImpl($0) final {\n",
+      absl::StrJoin(
+          op_info.graph_op_def.input_arg(), ", ",
+          [](std::string* out, const auto arg) {
+            strings::StrAppend(out, "const Tensor& ", arg.name(), "_0");
+            if (ArgIsList(arg))
+              strings::StrAppend(out, ", const Tensor& ", arg.name(), "_1");
+          }));
+
+  std::string run_inputs_str = absl::Substitute(
+      "    RunInputs({$0});\n",
+      absl::StrJoin(op_info.graph_op_def.input_arg(), ", ",
+                    [](std::string* out, const auto arg) {
+                      if (ArgIsList(arg)) {
+                        strings::StrAppend(
+                            out, "{\"", arg.name(), "\", ", arg.name(), "_0}, ",
+                            "{\"", arg.name(), "\", ", arg.name(), "_1}");
+                      } else {
+                        strings::StrAppend(out, "{\"", arg.name(), "\", ",
+                                           arg.name(), "_0}");
+                      }
+                    }));
+
+  std::string fuzz_class_def = strings::StrCat(
+      class_signature_str, "  void BuildGraph(const Scope& scope) override {\n",
+      build_graph_body, constructor_call_str, "  }\n", fuzz_impl_signature_str,
+      run_inputs_str, "  }\n", "};\n");
+
+  return fuzz_class_def;
+}
+
+std::string WriteFuzzTest(const OpInfo& op_info) {
+  return absl::Substitute(
+      "FUZZ_TEST_F(Fuzz$0, Fuzz).WithDomains($1);\n", op_info.op_name,
+      absl::StrJoin(op_info.graph_op_def.input_arg(), ", ",
+                    [](std::string* out, const auto arg) {
+                      absl::StrAppend(out, "AnyTensor()");
+                      if (ArgIsList(arg)) absl::StrAppend(out, ", AnyTensor()");
+                    }));
+}
+
+std::string FuzzerFileStart() {
+  const std::string fuzz_namespace_begin = R"namespace(
+namespace tensorflow {
+namespace fuzzing {
+
+)namespace";
+
+  const std::string fuzz_header =
+      absl::StrCat(R"include(// This file is MACHINE GENERATED! Do not edit.
+
+#include "tensorflow/cc/ops/const_op.h"
+#include "tensorflow/cc/ops/standard_ops.h"
+#include "tensorflow/security/fuzzing/cc/fuzz_session.h"
+#include "third_party/mediapipe/framework/port/parse_text_proto.h"
+)include",
+                   fuzz_namespace_begin);
+
+  return fuzz_header;
+}
+
+std::string FuzzerFileEnd() {
+  const std::string fuzz_footer = R"footer(
+}  // namespace fuzzing
+}  // namespace tensorflow
+)footer";
+
+  return fuzz_footer;
+}
+
+}  // namespace
+
+bool OpFuzzingIsOk(const OpInfo& op_info) {
+  // Skip deprecated ops.
+  if (op_info.graph_op_def.has_deprecation() &&
+      op_info.graph_op_def.deprecation().version() <= TF_GRAPH_DEF_VERSION) {
+    std::cout << "NOT fuzzing: " << op_info.graph_op_def.name()
+              << " is deprecated.\n";
+    return false;
+  }
+
+  // TODO(unda, b/249347507): should we hide fuzzers for hidden ops?
+  if (op_info.api_def.visibility() == ApiDef::HIDDEN) {
+    std::cout << "NOT fuzzing: " << op_info.graph_op_def.name()
+              << " is hidden.\n";
+    return false;
+  }
+
+  if (op_info.api_def.visibility() == ApiDef::SKIP) {
+    std::cout << "NOT fuzzing: " << op_info.graph_op_def.name()
+              << " is skipped.\n";
+    return false;
+  }
+
+  // TODO(unda) : zero input ops
+  std::set<std::string> zero_input_ops = {"Placeholder", "ImmutableConst"};
+  if (zero_input_ops.find(op_info.op_name) != zero_input_ops.end()) {
+    std::cout << "NOT fuzzing: " << op_info.graph_op_def.name()
+              << " takes zero inputs.\n";
+    return false;
+  }
+
+  // TODO(unda, 253431636): constrained kernel
+  std::set<std::string> constrained_kernel = {"Diag",
+                                              "DiagPart",
+                                              "GatherNd",
+                                              "GatherV2",
+                                              "QuantizeAndDequantizeV2",
+                                              "QuantizeAndDequantizeV3",
+                                              "QuantizeAndDequantizeV4",
+                                              "QuantizeAndDequantizeV4Grad",
+                                              "QuantizedConcat",
+                                              "QuantizedInstanceNorm",
+                                              "QuantizedReshape",
+                                              "ScatterNd",
+                                              "TensorScatterUpdate"};
+
+  // TODO(unda, b/253431636): constrained kernel
+  if (constrained_kernel.find(op_info.op_name) != constrained_kernel.end()) {
+    std::cout << "NOT fuzzing: " << op_info.graph_op_def.name()
+              << " has a constrained kernel.\n";
+    return false;
+  }
+
+  for (int i = 0; i < op_info.graph_op_def.input_arg_size(); ++i) {
+    const auto& arg(op_info.graph_op_def.input_arg(i));
+    // TODO(unda, b/249298521): deal with inputs that are required to be refs
+    if (arg.is_ref()) {
+      std::cout << "NOT fuzzing: " << op_info.graph_op_def.name()
+                << " requires a ref argument.\n";
+      return false;
+    }
+  }
+
+  std::set<std::string> unhandled_attr_types = {
+      "list(type)",   "func",         "float",      "bool",
+      "tensor",       "list(string)", "list(bool)", "list(shape)",
+      "list(tensor)", "list(attr)"};
+  for (int i = 0; i < op_info.graph_op_def.attr_size(); ++i) {
+    const auto& attr(op_info.graph_op_def.attr(i));
+    const auto& api_def_attr(op_info.api_def.attr(i));
+    // Skip inferred arguments
+    if (op_info.inferred_input_attrs.count(attr.name()) > 0) continue;
+    // Skip if it has default value (TODO(unda, b/249345399): add our custom
+    // values)
+    if (api_def_attr.has_default_value()) continue;
+    // TODO(unda, b/253432797): handle unimplemented input attribute types
+    if (unhandled_attr_types.find(attr.type()) != unhandled_attr_types.end()) {
+      std::cout << "NOT fuzzing: " << op_info.graph_op_def.name()
+                << " requires an unhandled attr type (" << attr.type()
+                << ").\n";
+      return false;
+    }
+  }
+  std::cout << "fuzzing: " << op_info.graph_op_def.name() << "\n";
+  return true;
+}
+
+std::string WriteSingleFuzzer(const OpInfo& op_info, bool is_fuzzable) {
+  return absl::StrCat(
+      FuzzerFileStart(), is_fuzzable ? WriteClassFuzzDef(op_info) : "",
+      is_fuzzable ? WriteFuzzTest(op_info) : "", FuzzerFileEnd());
+}
+
+}  // namespace cc_op
+}  // namespace tensorflow

tensorflow/cc/framework/fuzzing/cc_op_fuzz_gen.h

@@ -0,0 +1,36 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+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 TENSORFLOW_CC_FRAMEWORK_FUZZING_CC_OP_FUZZ_GEN_H_
+#define TENSORFLOW_CC_FRAMEWORK_FUZZING_CC_OP_FUZZ_GEN_H_
+
+#include "tensorflow/cc/framework/cc_op_gen_util.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/op_gen_lib.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace cc_op {
+
+// String with single fuzzer file content.
+std::string WriteSingleFuzzer(const OpInfo& op_info, bool is_fuzzable);
+
+// Do we have all we need to create a fuzzer
+bool OpFuzzingIsOk(const OpInfo& op_info);
+
+}  // namespace cc_op
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_FRAMEWORK_FUZZING_CC_OP_FUZZ_GEN_H_

tensorflow/cc/framework/fuzzing/cc_op_fuzz_gen_main.cc

@@ -0,0 +1,98 @@
+// Main executable to generate op fuzzers
+
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+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 <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "tensorflow/cc/framework/cc_op_gen_util.h"
+#include "tensorflow/cc/framework/fuzzing/cc_op_fuzz_gen.h"
+#include "xla/tsl/platform/status.h"
+#include "tensorflow/core/framework/api_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/op_gen_lib.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/file_system.h"
+#include "tensorflow/core/platform/init_main.h"
+#include "tensorflow/core/platform/str_util.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace cc_op {
+namespace {
+
+void WriteAllFuzzers(std::string root_location,
+                     std::vector<std::string> api_def_dirs,
+                     std::vector<std::string> op_names) {
+  OpList ops;
+  absl::StatusOr<ApiDefMap> api_def_map =
+      LoadOpsAndApiDefs(ops, false, api_def_dirs);
+
+  TF_CHECK_OK(api_def_map.status());
+
+  Env* env = Env::Default();
+  absl::Status status;
+  std::unique_ptr<WritableFile> fuzz_file = nullptr;
+  for (const OpDef& op_def : ops.op()) {
+    if (std::find(op_names.begin(), op_names.end(), op_def.name()) ==
+        op_names.end())
+      continue;
+
+    const ApiDef* api_def = api_def_map->GetApiDef(op_def.name());
+    if (api_def == nullptr) {
+      continue;
+    }
+
+    OpInfo op_info(op_def, *api_def, std::vector<std::string>());
+    status.Update(env->NewWritableFile(
+        root_location + "/" + op_def.name() + "_fuzz.cc", &fuzz_file));
+    status.Update(
+        fuzz_file->Append(WriteSingleFuzzer(op_info, OpFuzzingIsOk(op_info))));
+    status.Update(fuzz_file->Close());
+  }
+  TF_CHECK_OK(status);
+}
+
+}  // namespace
+}  // namespace cc_op
+}  // namespace tensorflow
+
+int main(int argc, char* argv[]) {
+  tensorflow::port::InitMain(argv[0], &argc, &argv);
+  if (argc != 4) {
+    for (int i = 1; i < argc; ++i) {
+      fprintf(stderr, "Arg %d = %s\n", i, argv[i]);
+    }
+    fprintf(stderr, "Usage: %s location api_def1,api_def2 op1,op2,op3\n",
+            argv[0]);
+    exit(1);
+  }
+  for (int i = 1; i < argc; ++i) {
+    fprintf(stdout, "Arg %d = %s\n", i, argv[i]);
+  }
+  std::vector<std::string> api_def_srcs = tensorflow::str_util::Split(
+      argv[2], ",", tensorflow::str_util::SkipEmpty());
+  std::vector<std::string> op_names = tensorflow::str_util::Split(
+      argv[3], ",", tensorflow::str_util::SkipEmpty());
+  tensorflow::cc_op::WriteAllFuzzers(argv[1], api_def_srcs, op_names);
+  return 0;
+}

tensorflow/cc/framework/fuzzing/op_fuzzing.bzl

@@ -0,0 +1,171 @@
+"""Functions for automatically generating fuzzers."""
+
+load(
+    "//tensorflow:tensorflow.bzl",
+    "if_not_windows",
+    "lrt_if_needed",
+    "tf_cc_binary",
+    "tf_copts",
+)
+load(
+    "//tensorflow/core/platform:rules_cc.bzl",
+    "cc_test",
+)
+
+def tf_gen_op_wrappers_fuzz(
+        name,
+        op_def_src,
+        api_def_srcs = [],
+        kernel_deps = []):
+    """
+    Generates fuzzers for several groups of ops.
+
+    For each one we need the corresponding OpDef, ApiDef and KernelDef,
+    since they all can contain constraints for the inputs.
+
+    Args:
+        name: the name of the fuzz artifact
+        op_def_src: op definitions
+        api_def_srcs: api definitions
+        kernel_deps: op kernel dependencies
+    """
+
+    # Create tool to generate .cc fuzzer files.
+    tf_cc_binary(
+        name = "op_fuzz_gen_tool",
+        copts = tf_copts(),
+        linkopts = if_not_windows(["-lm", "-Wl,-ldl"]) + lrt_if_needed(),
+        linkstatic = 1,  # Faster to link this one-time-use binary dynamically
+        deps = [
+            "//tensorflow/cc/framework/fuzzing:cc_op_fuzz_gen_main",
+            op_def_src,
+        ] + kernel_deps,
+    )
+
+    # Add relevant locations to look for api_defs.
+    api_def_src_locations = ",".join(["$$(dirname $$(echo $(locations " + api_def_src + ") | cut -d\" \" -f1))" for api_def_src in api_def_srcs])
+
+    out_fuzz_files = [op_name + "_fuzz.cc" for op_name in op_names]
+    native.genrule(
+        name = name + "_genrule",
+        outs = out_fuzz_files,
+        srcs = api_def_srcs,
+        tools = [":op_fuzz_gen_tool"],
+        cmd = ("$(location :op_fuzz_gen_tool) " +
+               " $$(dirname $(location " + out_fuzz_files[0] + "))" +
+               " " + api_def_src_locations + " " + (",".join(op_names))),
+    )
+
+    for op_name in op_names:
+        cc_test(
+            name = op_name.lower() + "_fuzz",
+            srcs = [op_name + "_fuzz.cc"],
+            deps = kernel_deps +
+                   [
+                       "//tensorflow/security/fuzzing/cc:fuzz_session",
+                       "@com_google_googletest//:gtest_main",
+                       "@com_google_fuzztest//fuzztest",
+                       "//tensorflow/cc:cc_ops",
+                       "//third_party/mediapipe/framework/port:parse_text_proto",
+                   ],
+        )
+
+op_names = [
+    "BatchMatrixBandPart",
+    "BatchMatrixDiag",
+    "BatchMatrixDiagPart",
+    "BatchMatrixSetDiag",
+    "BatchToSpace",
+    "BatchToSpaceND",
+    "Bitcast",
+    "BroadcastArgs",
+    "BroadcastTo",
+    "CheckNumerics",
+    "ConcatV2",
+    "ConjugateTranspose",
+    "DebugGradientIdentity",
+    "DeepCopy",
+    "DepthToSpace",
+    "Dequantize",
+    "EditDistance",
+    "Empty",
+    "EnsureShape",
+    "ExpandDims",
+    "ExtractImagePatches",
+    "ExtractVolumePatches",
+    "FakeQuantWithMinMaxArgs",
+    "FakeQuantWithMinMaxArgsGradient",
+    "FakeQuantWithMinMaxVars",
+    "FakeQuantWithMinMaxVarsGradient",
+    "FakeQuantWithMinMaxVarsPerChannel",
+    "FakeQuantWithMinMaxVarsPerChannelGradient",
+    "Fill",
+    "Fingerprint",
+    "Gather",
+    "GuaranteeConst",
+    "Identity",
+    "IdentityN",
+    "InplaceAdd",
+    "InplaceSub",
+    "InplaceUpdate",
+    "InvertPermutation",
+    "ListDiff",
+    "MatrixBandPart",
+    "MatrixDiag",
+    "MatrixDiagPart",
+    "MatrixDiagPartV2",
+    "MatrixDiagPartV3",
+    "MatrixDiagV2",
+    "MatrixDiagV3",
+    "MatrixSetDiag",
+    "MatrixSetDiagV2",
+    "MatrixSetDiagV3",
+    "MirrorPad",
+    "OneHot",
+    "OnesLike",
+    "Pack",
+    "Pad",
+    "PadV2",
+    "ParallelConcat",
+    "PlaceholderV2",
+    "PlaceholderWithDefault",
+    "PreventGradient",
+    "QuantizeAndDequantize",
+    "QuantizeV2",
+    "Rank",
+    "Reshape",
+    "ResourceStridedSliceAssign",
+    "ReverseSequence",
+    "ReverseV2",
+    "ScatterNdNonAliasingAdd",
+    "Shape",
+    "ShapeN",
+    "Size",
+    "Slice",
+    "Snapshot",
+    "SpaceToBatch",
+    "SpaceToBatchND",
+    "SpaceToDepth",
+    "Split",
+    "SplitV",
+    "Squeeze",
+    "StopGradient",
+    "StridedSlice",
+    "StridedSliceGrad",
+    "TensorScatterAdd",
+    "TensorScatterMax",
+    "TensorScatterMin",
+    "TensorScatterSub",
+    "TensorStridedSliceUpdate",
+    "Tile",
+    "TileGrad",
+    "Transpose",
+    "Unique",
+    "UniqueV2",
+    "UniqueWithCounts",
+    "UniqueWithCountsV2",
+    "Unpack",
+    "UnravelIndex",
+    "Where",
+    "ZerosLike",
+]