// large functions (and maybe other metadata as well).
}

const tac::TargetHardware* TacModule::GetTargetHardware(
    const std::string& hardware_name) const {
  for (auto& hardware : backends_) {
    if (GetHardwareName(hardware.get()) == hardware_name) return hardware.get();
  }
  return nullptr;
}

absl::Status TacModule::RunTacPasses(mlir::ModuleOp* module, bool debug_mode) {
  mlir::PassManager pm((*module)->getName(),

// 1) users should create object form this class, with desired options
//    (TacModule::Options).
// 2) Use SetImporter/SetExporter to the desired importer
//    and exporter.
// 3) Call Run()
//
// The module fetches all TargetHardware backends registered in the binary
// and only create TargetHardware requested in Options.
//
// This class is not thread safe.
class TacModule {
 public:
  // TAC options. Contains knobs to configure TAC as needed.

  mlir::TFL::tac::TacModule::Options options;
  options.hardware_backends = device_specs;
  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(model_file_path));

  tac_module.RegisterExtraDialects(registry);
  tac_module.SetImporter(CreateTfLiteImporter());
  tac_module.SetExporter(CreateTfLiteExporter(options.hardware_backends));
  return tac_module.Run();
}
}  // namespace

int main(int argc, char** argv) {
  tensorflow::InitMlir y(&argc, &argv);

  llvm::cl::ParseCommandLineOptions(argc, argv, "Target aware conversion\n");

        "@llvm-project//mlir:Pass",
        "@llvm-project//mlir:Support",
    ],
    alwayslink = 1,
)

# TODO(b/177376459): split tac_module and passes dependency to separate libraries.
cc_library(
    name = "target_aware_conversion",
    srcs = [
        "tac_module.cc",
        "transforms/compute_cost.cc",
        "transforms/fold_constants_to_subgraph.cc",
        "transforms/get_alternative_subgraph.cc",

#include "mlir/Pass/Pass.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/lite/experimental/tac/hardwares/target_hardware.h"
#include "tensorflow/compiler/mlir/lite/experimental/tac/tac_module.h"

namespace mlir {
namespace TFL {
namespace tac {
// An OperationPass<> with access to the TAC module instance that the
// pass is running part of.

namespace mlir {
namespace TFL {
namespace tac {

// Interface for Importing program to TAC (Target Aware Conversion) Module.
// This class is an interface for importing program in TAC.
// See TacModule in how to register it with the module and use it.
class TacImporter {
 public:
  virtual ~TacImporter() = default;

  // Imports and returns the Module for the imported program.

#include "mlir/Pass/Pass.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/lite/experimental/tac/tac_filter.pb.h"

namespace mlir {
namespace TFL {
namespace tac {
class TacModule;

// Create an instance of the TargetAnnotationPass.
// TODO(b/177376459): Remove in favor of the one below.
std::unique_ptr<OperationPass<func::FuncOp>> CreateTargetAnnotationPass(

      mlir::MLIRContext* mlir_ctx);

  // Constructor of the decompose context. To share the decompose library, the
  // whole decompose TFR function library is loaded.
  explicit TFRDecomposeContext(mlir::ModuleOp tfr_module);

  // Constructs the decompose context from the tfr text module and the mlir
  // context. The tfr text module is added to the mlir context.
  static std::unique_ptr<TFRDecomposeContext> GetFromText(

    return 2
  os.makedirs(export_path)

  tf_module = module_ctor()
  if version == 2:
    options = save_options.SaveOptions(save_debug_info=True)
    saved_model.save(tf_module, export_path, options=options)
  else:
    builder = saved_model.builder.SavedModelBuilder(export_path)
    builder.add_meta_graph_and_variables(tf_module, ["serve"])
    builder.save()


if __name__ == "__main__":