#include "mlir/IR/DialectRegistry.h"  // from @llvm-project

namespace mlir {
namespace {

TEST(RegisterCommonDialectsTest, DoesntCrash) {
  mlir::DialectRegistry registry;

  mlir::RegisterCommonToolingDialects(registry);

  EXPECT_FALSE(registry.getDialectNames().empty());
}

}  // namespace

    const std::vector<std::string>& exported_model_signatures,
    const std::vector<std::string>& tag_names,
    absl::string_view input_arg_shapes_str) {
  mlir::DialectRegistry registry;
  RegisterAllTensorFlowDialects(registry);
  mlir::MLIRContext context(registry);
  context.loadAllAvailableDialects();

  auto module =
      TfToStablehlo(input_path, &context, exported_model_signatures, tag_names,

    return "Convert Fake Quant op to quant.qcast and quant.dcast pairs";
  }

  void getDependentDialects(DialectRegistry& registry) const override {
    registry.insert<TF::TensorFlowDialect>();
    registry.insert<quant::QuantizationDialect>();
    registry.insert<quantfork::QuantizationForkDialect>();
  }

  void runOnOperation() override;
};

static PassRegistration<ConvertFakeQuantToQdqPass> pass;

namespace mlir {
namespace TF {

// A global ops registry that is used to hold TPU embedding ops.
//
// Example:
//    TPUEmbeddingOpsRegistry::Global().Add<TF::FooOp>();
//    for (auto op_type_id : TPUEmbeddingOpsRegistry::Global().GetOpsTypeIds())
//    {
//      ...
//    }
class TPUEmbeddingOpsRegistry {
 public:
  // Add the op to the registry.
  //

    return 1;
  }

  // Load the MLIR module.
  mlir::DialectRegistry registry;
  registry.insert<mlir::TF::TensorFlowDialect, mlir::TFL::TensorFlowLiteDialect,
                  mlir::arith::ArithDialect, mlir::func::FuncDialect>();
  mlir::MLIRContext context(registry);

  llvm::SourceMgr source_mgr;
  source_mgr.AddNewSourceBuffer(std::move(*file_or_err), llvm::SMLoc());

  }
  options.enable_inliner = true;
  options.legalize_to_tflite_ops = true;
  mlir::TFL::tac::TacModule tac_module(options);
  mlir::DialectRegistry registry;
  mlir::RegisterAllTensorFlowDialects(registry);
  tac_module.RegisterExtraDialects(registry);
  tac_module.SetImporter(CreateTfLiteImporter());
  tac_module.SetExporter(CreateTfLiteExporter(options.hardware_backends));
  return tac_module.Run();
}

        "//tensorflow/c/experimental/ops/gen/cpp",
        "//tensorflow/c/experimental/ops/gen/model",
        "//tensorflow/core:lib",
        # Without this line to link in ops, the global registry will be empty:
        "//tensorflow/core:ops",
    ],
)

tf_cc_binary(
    name = "generate_cpp",
    args = ["--stderrthreshold=1"],  # Warnings and errors to stderr.
    deps = [":generate_cpp_main"],

    }
  }

  TF_DeleteTensor(analytical_tensor);
  delete[] danalytical;
}

Model BuildGradModel(Model forward, GradientRegistry registry) {
  return [forward_model = std::move(forward),
          grad_registry = std::move(registry)](
             AbstractContext* ctx,
             absl::Span<AbstractTensorHandle* const> inputs,
             absl::Span<AbstractTensorHandle*> outputs) -> Status {

      llvm::cl::ZeroOrMore};

  void getDependentDialects(mlir::DialectRegistry& registry) const override {
    if (!module_) {
      for (const auto& device : device_specs_flag_) {
        auto* hardware = this->GetTargetHardware(device);
        if (hardware == nullptr) continue;
        hardware->GetDependentDialects(registry);
      }
    }
  }
};

class GraphOptPass
    : public mlir::PassWrapper<GraphOptPass,
                               mlir::OperationPass<mlir::ModuleOp>> {
  void getDependentDialects(mlir::DialectRegistry& registry) const override {
    mlir::RegisterAllTensorFlowDialects(registry);
  }

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(GraphOptPass)

  explicit GraphOptPass(std::vector<tensorflow::GraphOptimizationPass*> passes)