return ops;
}

bool checkWhetherGraphHasValidStaticLookupTables(ModuleOp module) {
  auto hashtables = GetAllOps<TF::HashTableV2Op>(&module);
  // No needs to run the legalization patterns.
  if (hashtables.empty()) {
    return false;
  }

  for (auto hashtable : hashtables) {
    auto key_dtype = hashtable.getKeyDtype();
    auto value_dtype = hashtable.getValueDtype();

// RUN: tf-opt -split-input-file -verify-diagnostics -xla-legalize-tf-communication %s | FileCheck %s

// Test legalization of `tf._XlaHostComputeMlir` expands into individual
// `mhlo.send` per operand and `mhlo.recv` per result. Channel Id's are uniquely
// assigned per mhlo communcation op, and frontend attributes (modified keys)
// and op shardings are added. Sink tokens are created
// if there are more than one operand or more than one result.
//

    InsertQuantOpsAfterTFFakeQuantOp<TF::FakeQuantWithMinMaxVarsPerChannelOp,
                                     true>;

// TODO(fengliuai): add the support of the tf.QuantizeAndDequantize*
// legalization.

void LegalizeTFToQuant::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  auto func = getOperation();
  auto *ctx = func.getContext();

    "emit-stablehlo-ops",
    llvm::cl::desc("Wether serialize stablehlo ops or not"),
    llvm::cl::location(emit_stablehlo_ops), llvm::cl::init(false));

// Flatbuffer import by default will also perform vhlo to stablehlo legalization
// to hide serialization detail from user, but for debug purpose we need to be
// able to dump raw vhlo ops as well
// NOLINTNEXTLINE
static opt<bool, true> disable_vhlo_to_stablehlo_flag(

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

// This transformation pass prepares for legalization to the TFLite dialect by
// converting Tensorlist operations in TensorFlow dialect into operations that
// can be legalized to TensorFlow Lite dialect with simple replacements.  The

    llvm::cl::init(false));

// NOLINTNEXTLINE
opt<bool> preserve_assert_op(
    "preserve-assert-op",
    llvm::cl::desc("Preserve AssertOp during tfl legalization."),
    llvm::cl::init(false));

// NOLINTNEXTLINE
opt<bool> enable_stablehlo_conversion(
    "enable-stablehlo-conversion",
    llvm::cl::desc("Enable converting TF to Stablehlo."),

      succeeded(MatchReduceToArgMinMaxType2(reduce_op, true))) {
    // If the ReduceOp matches to one of the patterns above, its illegal to have
    // it in the model after the legalization is ran, because it should have
    // been legalized to an ArgMax/ArgMin op.
    return false;
  }

  return true;
}
}  // namespace odml

  // after conversion to mhlo compared to the original type in TF. For example,
  // a TF op with result type tensor<*xf32> will have a bounded type after
  // fallback legalization.
  auto cast_value = [&](OpBuilder& builder, Type result_type, ValueRange inputs,
                        Location loc) -> Value {
    return builder.create<mlir::tensor::CastOp>(loc, result_type,

  }

  // CHECK-LABEL: unsupported_dtype
  func.func @unsupported_dtype(%arg0: tensor<2x!tf_type.variant>) -> tensor<2x!tf_type.variant> {
    // CHECK: tf.AddN
    // expected-remark@+1 {{skipping legalization due to unsupported type 'tensor<2x!tf_type.variant>'}}
    %0 = "tf.AddN"(%arg0, %arg0) : (tensor<2x!tf_type.variant>, tensor<2x!tf_type.variant>) -> tensor<2x!tf_type.variant>

    func.return %0 : tensor<2x!tf_type.variant>

  }
  
  bool IsOpSupported(mlir::Operation* op) const override {
    // check whether the op is supported, if the user has they own dialect,
    // this can be target dialect legalization process.
  }
  
 double GetHardwareSwitchingCost(const TargetHardware* from,
                                 size_t buffer_size) const override {
    // Get the hardware switching cost from the source hardware.
 }