isa<tf_executor::GraphOp>(*copy_range.begin())) {
    // Already a graph.
    return;
  }

  auto return_op = dyn_cast<func::ReturnOp>(body.getTerminator());
  if (!return_op) {
    LLVM_DEBUG(llvm::dbgs() << "Expect function to end with return\n");
    return;
  }
  // Build GraphOp.
  OpBuilder builder(&body, body.begin());
  auto graph_op = builder.create<tf_executor::GraphOp>(

    return;
  }

  tf_executor::GraphOp graph_op;

  if (llvm::hasSingleElement(func.front().without_terminator())) {
    graph_op = dyn_cast<tf_executor::GraphOp>(func.front().front());
  }

  if (!graph_op) {
    func.emitError("expected function to contain only a graph_op");
    signalPassFailure();
    return;
  }

  if (!(llvm::hasSingleElement(graph_op.GetBody().without_terminator()) &&

  func.setType(ftype);

  // Rewrite GraphOp to have same number of results as the
  // function.
  OpBuilder builder(graph_op);
  auto new_graph_op =
      builder.create<GraphOp>(graph_op.getLoc(), new_result_types);
  new_graph_op.getRegion().takeBody(graph_op.getRegion());
  graph_op->replaceAllUsesWith(
      new_graph_op->getResults().drop_back(num_resources));
  graph_op.erase();

// bug in common runtime (see b/185483669).
void AddStatefulControlFlowDependencies(tf_executor::GraphOp graph_op) {
  llvm::SmallDenseSet<Value, 8> graph_fetches;
  for (Value value : graph_op.GetFetch().getFetches()) {
    graph_fetches.insert(value);
  }
  for (Operation& op : graph_op.GetBody().without_terminator()) {
    auto island = dyn_cast<tf_executor::IslandOp>(&op);
    if (!island) continue;

    // The pass runs on a valid tf_executor dialect, so the op should be the
    // GraphOp.
    return cast<GraphOp>(graph_op_range.begin());
  }

  return {};
}

void MergeDuplicateResourceOpsPass::runOnOperation() {
  func::FuncOp func_op = getOperation();
  GraphOp graph_op = GetGraphOpFromFuncOp(func_op);
  if (!graph_op) return;

  llvm::StringMap<Operation*> shared_name_to_resource;

      if (execute.use_empty())
        unused_execute_controls.push_back(execute.getControl());

    if (!unused_execute_controls.empty()) {
      auto graph_op = island_op->getParentOfType<tf_executor::GraphOp>();
      tf_executor::FetchOp fetch = graph_op.GetFetch();
      auto fetches = llvm::to_vector<8>(fetch.getOperands());
      fetches.append(unused_execute_controls.begin(),

}

// Appends `value` to the arguments of the `FetchOp` of `graph_op`.
void AppendValueToFetch(GraphOp graph_op, Value value) {
  FetchOp old_main_fetch = graph_op.GetFetch();
  auto fetches = llvm::to_vector(old_main_fetch.getFetches());
  fetches.emplace_back(value);

  auto builder = OpBuilder::atBlockTerminator(&graph_op.GetBody());
  builder.create<FetchOp>(old_main_fetch.getLoc(), std::move(fetches));

  // islands per replica of the replicate.
  llvm::SmallVector<tf_executor::IslandOp, 4> replicate_op_islands;
  getOperation().walk([&](tf_executor::GraphOp graph_op) {
    for (auto island_op : graph_op.getOps<tf_executor::IslandOp>()) {
      if (!island_op.WrapsSingleOp()) continue;

      if (isa<tf_device::ReplicateOp>(&island_op.GetBody().front()))

// * Its GraphOp should only have control outputs.
// * "tf_saved_model.initializer_type" attribute must exist.
LogicalResult ValidateInitFunc(func::FuncOp init_func_op) {
  GraphOp graph_op = GetGraphOpFromFuncOp(init_func_op);
  if (!graph_op) return success();  // Consider empty FuncOp valid.

  FetchOp fetch_op = graph_op.GetFetch();
  for (const Value fetch : fetch_op.getFetches()) {

  }

  Exporter exporter(&configs, graph.get(), tf_dialect, &symbol_table);

  auto graph_op = llvm::cast<mlir::tf_executor::GraphOp>(block.front());

  // Set input and output names and increment the use counter for them to help
  // generate unique names.
  if (!output_names.empty()) {
    const int num_data_results = graph_op.getNumResults();
    const int64_t output_names_size = output_names.size();