registry.insert<shape::ShapeDialect>();
  }

 public:
  StringRef getArgument() const final { return "tf-mhlo"; }
  StringRef getDescription() const final {
    return "This pass will legalize TF Ops to MHLO Ops.";
  }

 protected:
  Option<bool> skip_quantization_ops_{
      *this, "skip-quantization-ops",
      ::llvm::cl::desc("Skip quantization ops")};

  Option<bool> skip_resize_{

// RUN: tf-opt -tfe-legalize-tfg %s | FileCheck %s

module  {
  tfg.graph #tf_type.version<producer = 62, min_consumer = 12> {
    %Const, %ctl = Const name("Constant") {dtype = i32, value = dense<0> : tensor<i32>} : () -> (tensor<i32>)
    %foo, %ctl_0 = foo(%Const) name("_tf.foo") : (tensor<i32>) -> (tensor<*xi32>)
  }
  tfg.func @foo(%arg: tensor<*xi32> {tfg.name = "arg"})
       -> (tensor<*xi32> {tfg.dtype = i32, tfg.name = "return_value"})
   {

// RUN: odml-to-stablehlo-opt %s -tfl-legalize-hlo -split-input-file | FileCheck %s --dump-input=fail

// CHECK-LABEL: mhlo_custom_call_test__legalize_string_backend_config
func.func @mhlo_custom_call_test__legalize_string_backend_config(%arg0: tensor<1x4xf32>) -> tensor<1x8xf32> {
  %0 = mhlo.custom_call @custom_call.my_custom_op(%arg0) {
    api_version = 1 : i32,
    backend_config = "this_is_a_test_string"
  } : (tensor<1x4xf32>) -> (tensor<1x8xf32>)

          for (auto arg : block.getArguments()) {
            ConvertAndWrapUsesInUnrealizedCast(arg, converter, rewriter);
          }
        }
      }
    });
  });
  return success();
}

// Legalize StableHLO portion of program to VHLO, leaves TFL untouched
LogicalResult ApplyStablehloToVhloPatterns(ModuleOp module,
                                           bool is_func_legal) {
  MLIRContext *context = module.getContext();

// RUN: tf-opt -tfe-legalize-tfg %s | FileCheck %s

// CHECK: module attributes {tf.versions = {bad_consumers = [], min_consumer = 12 : i32, producer = 919 : i32}}
module  {
  // CHECK: tf_executor.graph
  tfg.graph #tf_type.version<producer = 919, min_consumer = 12> {

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace mlir {
namespace TFL {
namespace {
#define GEN_PASS_DEF_LEGALIZEWHILEPASS
#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

// Legalize TF While to TFL While with calls to the original functions from the
// cond and body regions.
struct LegalizeWhilePass
    : public impl::LegalizeWhilePassBase<LegalizeWhilePass> {

                                         llvm::SmallVector<Value>& outputs);

  // Tries to legalize the specified TensorFlow op, if supported.
  //
  // Emits an error and returns failure if an error is encountered during
  // conversion. Note that success return value doesn't mean successful
  // legalization.
  mlir::LogicalResult LegalizeOp();

  // Converts the given operand to expression of kind kConstant or kXlaOp.

  CellReader<int64_t> counts(kBridgeStatusCounter);

  auto result = CompileMlirModule(kBadMlirModuleStr);

  ASSERT_FALSE(result.ok());
  // Never failed to legalize because it was never attempted
  EXPECT_EQ(legalize_failure_count.Read("tf.DoesntExist", "Unknown"), 0);
  EXPECT_THAT(result,
              IncrementedOrFiltered(counts.Delta(kMlirCombinedMlirSuccess), 1));

    // This will output different alternative subgraphs in mlir format for debug
    // purpose.
    bool debug_mode = false;
    // Whether to enable inliner passes or not.
    bool enable_inliner = false;
    // Whether to legalize ops to TFLite ops before exporting.
    bool legalize_to_tflite_ops = false;
  };

  virtual ~TacModule() = default;

  explicit TacModule(const Options& options) : options_(options) {}

namespace mlir {
namespace TFL {
namespace {
#define GEN_PASS_DEF_LEGALIZEHASHTABLESPASS
#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

// This file has Legalize hash tables pass which is responsible for:
// - Converting static hash table ops to the TFLite equivalent ops.
//
// There are needs to fall back to Flex for the following cases:
// - Mutable hash table cases