/// Note: This is a module pass because when legalizing with TF2XLA fallback,
/// functions are imported into the module. Importing functions into a
/// module is not thread safe.
std::unique_ptr<OperationPass<ModuleOp>> createLegalizeTFPass(
    bool legalize_chlo = true,
    std::optional<StringRef> tf2xla_fallback_device_type = std::nullopt,
    bool prefer_tf2xla = false);

/// Adds the TF to TF lowerings and TF to XLA rewrite patterns to the pattern

  passes(&pm);

  return pm.run(module.get()).succeeded();
}

std::function<void(PassManager*)> legalizeTFPasses() {
  return [](PassManager* pm) {
    pm->addPass(mlir::mhlo::createLegalizeTFPass(
        /* legalize_chlo=*/true, llvm::StringRef("gpu/xpu"),
        /* prefer_tf2xla=*/false));
  };
}

TEST(XlaLegalizeTest, IllegalOp) {
  constexpr char kMlirIllegalOpStr[] = R"(

                        prefer_tf2xla_))) {
    signalPassFailure();
  }
}

}  // end namespace

std::unique_ptr<OperationPass<ModuleOp>> createLegalizeTFPass(
    bool legalize_chlo, std::optional<StringRef> tf2xla_fallback_device_type,
    bool prefer_tf2xla) {
  return std::make_unique<LegalizeTF>(
      legalize_chlo, tf2xla_fallback_device_type, prefer_tf2xla);
}

std::unique_ptr<OperationPass<func::FuncOp>> CreateLegalizeTFPass(
    bool run_tfl_runtime_verification, bool preserve_assert_op) {
  return std::make_unique<LegalizeTFPass>(run_tfl_runtime_verification,
                                          preserve_assert_op);
}

std::unique_ptr<OperationPass<func::FuncOp>> CreateLegalizeTFPass() {
  return std::make_unique<LegalizeTFPass>();
}

    pass_manager->addNestedPass<mlir::func::FuncOp>(
        mlir::TF::CreateInitTextFileToImportPass(saved_model_dir.str()));

    pass_manager->addNestedPass<mlir::func::FuncOp>(
        mlir::TFL::CreateLegalizeTFPass(pass_config.runtime_verification,
                                        pass_config.preserve_assert_op));
    pass_manager->addPass(mlir::TFL::CreateAnalyzeVariablesPass());

}

def LegalizeTFPass : Pass<"tfl-legalize-tf", "mlir::func::FuncOp"> {
  let summary = "Legalize from TensorFlow to TensorFlow Lite dialect.";
  let constructor = "CreateLegalizeTFPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect" ,
    "quant::QuantizationDialect",
    "quantfork::QuantizationForkDialect"
  ];
  let options = [

  if (lower_to_xla_hlo) {
    // Lower TF quant ops and types to MHLO int.
    mlir::quant::stablehlo::AddQuantizationLoweringPasses(pm);

    pm.addPass(mlir::mhlo::createLegalizeTFPass(
        legalize_chlo,
        /*tf2xla_fallback_device_type=*/device_type, enable_op_fallback));
  }

  // This has to run after legalization.
  pm.addNestedPass<mlir::func::FuncOp>(