// A subgraph may associate with 1...n FuncOp, and each FuncOp may correspond
// with different hardwares.
struct Subgraph {
  // The call can be thought as an "API".
  func::CallOp call;

  // available_choces can be viewed as "real implementation" assosicated with
  // the hardware.
  std::unordered_map<InferenceDeviceType, func::FuncOp,
                     InferenceDeviceType::inference_device_type_hash>

  TF_EXPECT_OK(RunFunctionTf2xlaClusteringBridge(
      *mlir_module_, /*is_supported_by_replicated_brige*/ true,
      /*is_in_fallback_enabled_mode=*/false));

  FuncOp main = mlir_module_->lookupSymbol<mlir::func::FuncOp>("main");
  ASSERT_TRUE(main);

  EXPECT_EQ(compilation_status.Delta(mlir::TF::kMlirPh1BridgeCounterReplicated,
                                     mlir::TF::kMlirPh1BridgeCounterV2,

def QuantizeWeightPass : Pass<"stablehlo-quantize-weight", "mlir::func::FuncOp"> {
  let summary = "Quantizes the weight component of StableHLO graph.";
  let dependentDialects = ["mlir::stablehlo::StablehloDialect"];
  let constructor = "mlir::quant::stablehlo::CreateQuantizeWeightPass()";
}

def UnfuseMhloBatchNormPass : Pass<"stablehlo-unfuse-mhlo-batch-norm", "mlir::func::FuncOp"> {
  let summary = "Unfuses batch normalization into arithmetic ops.";

  void runOnOperation() override;
};

// Move FuncOp referenced by `symbol_ref` from one symbol table to another.
void MoveFuncOp(FlatSymbolRefAttr &symbol_ref, SymbolTable &from,
                SymbolTable &to) {
  if (to.lookup<func::FuncOp>(symbol_ref.getValue())) return;
  func::FuncOp callee = from.lookup<func::FuncOp>(symbol_ref.getValue());
  callee.getOperation()->getBlock()->getOperations().remove(

  }

  return init_func_ops;
}

func::FuncOp GetInitializerFunction(ModuleOp module_op,
                                    const StringRef initializer_type) {
  SmallVector<func::FuncOp, 2> init_func_ops =
      GetInitializerFunctions(module_op);

  auto init_func_itr = absl::c_find_if(
      init_func_ops, [initializer_type](const func::FuncOp init_func_op) {

                             StringRef(content.data(), content.size()));
}

inline TensorType GetInputType(func::FuncOp func, int idx) {
  return mlir::dyn_cast_or_null<TensorType>(
      func.getFunctionType().getInput(idx));
}

inline TensorType GetResultType(func::FuncOp func, int idx) {
  return mlir::dyn_cast_or_null<TensorType>(
      func.getFunctionType().getResult(idx));
}

                                  const_op.getResult()});
}

func::FuncOp CreateSessionInitFunc(ModuleOp module) {
  constexpr char kSessionInitFuncName[] = "SessionInitializerFunction";

  mlir::OpBuilder builder(module.getBodyRegion());
  auto func_type =
      FunctionType::get(module.getContext(), /*inputs=*/{}, /*results=*/{});
  auto func = builder.create<func::FuncOp>(module->getLoc(),

// qint types to int types and surround TF UniformQuantized ops with qint <->
// int casts.
std::unique_ptr<OperationPass<func::FuncOp>> CreateConvertTFQuantTypesPass();

// Creates an instance of the VerifyQuantLegalization pass, which verifies all
// quant ops and types are lowered.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateVerifyQuantLegalizationPass();

// Add all passes for lowering TF quant ops and types to MHLO int.

// Checks if the function is the main or initializer function.
bool IsMainOrInitializerFunction(ModuleOp module, func::FuncOp func) {
  if (func.getSymName() ==
          llvm::StringRef(tensorflow::kImportModelDefaultGraphFuncName) ||
      func.getSymName() == kTfQuantSaveFuncName) {
    return true;
  }

  for (func::FuncOp init_func :
       tf_saved_model::GetInitializerFunctions(module)) {

  ASSERT_TRUE(result);
  EXPECT_EQ(noinline_pcall_ops.size(), 2);
  auto func =
      llvm::dyn_cast<mlir::func::FuncOp>(noinline_pcall_ops[0]->getParentOp());
  ASSERT_TRUE(func);
  EXPECT_EQ(func.getSymName(), "while_body_func");
  func =
      llvm::dyn_cast<mlir::func::FuncOp>(noinline_pcall_ops[1]->getParentOp());
  ASSERT_TRUE(func);
  EXPECT_EQ(func.getSymName(), "outer_stateful_pcall_func");