llvm::isa<tf_executor::IslandOp>(graph_op.GetBody().front()))) {
    graph_op.emitError(
        "expected graph op to contain only a single island_op and a single "
        "fetch_op");
    signalPassFailure();
    return;
  }

  tf_executor::IslandOp island_op =
      dyn_cast<tf_executor::IslandOp>(graph_op.GetBody().front());

  // We only call this function for island or fetch ops. The second pair of
  // parentheses is needed for successful compilation.
  assert((isa<IslandOp, FetchOp>(op)));
  mlir::MutableOperandRange mutable_control_inputs =
      isa<IslandOp>(op) ? cast<IslandOp>(op).getControlInputsMutable()
                        : cast<FetchOp>(op).getFetchesMutable();
  // Add control inputs in program order of the defining ops.

  GraphPruningPass() = default;
  explicit GraphPruningPass(llvm::ArrayRef<std::string> ops_to_preserve);
  void runOnOperation() override;

 private:
  bool ShouldPreserveOp(Operation* op);
  bool ShouldPreserveIsland(IslandOp island);
  void PruneGraph(GraphOp graph);

  llvm::SmallDenseSet<mlir::StringAttr, 4> ops_to_preserve_ids_;
};

// Checks if a tf_executor.Graph can be pruned.

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace mlir {
namespace quant {
namespace {

using ::mlir::tf_executor::GraphOp;
using ::mlir::tf_executor::IslandOp;

constexpr StringRef kSharedNameAttr = "shared_name";

class MergeDuplicateResourceOpsPass
    : public PassWrapper<MergeDuplicateResourceOpsPass,
                         OperationPass<func::FuncOp>> {
 public:

  SymbolTable outlined_symbol_table(outlined_module);

  // Find every island that contains a TPU node and extract it into a new module
  // to run the V1 bridge there.
  llvm::SmallVector<IslandOp, 8> islands_to_outline;
  getOperation().walk([&](IslandOp island_op) {
    auto parent_func = island_op->getParentOfType<func::FuncOp>();
    auto skip_island_outlining =
        parent_func->getAttrOfType<BoolAttr>(mlir::TF::kSkipIslandOutlining);

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_executor.h"

namespace mlir {
namespace TF {

// Converts a single island into multiple islands (one for each op).
void SplitIsland(mlir::tf_executor::IslandOp island_op,
                 mlir::tf_executor::ControlType control_type);

}  // namespace TF
}  // namespace mlir

    // violate the invariant imposed by the GraphExport pipeline that every
    // IslandOp perfectly wraps a single op.
    auto control_type =
        mlir::tf_executor::ControlType::get(tf_dialect->getContext());
    getOperation().walk(
        [&control_type](mlir::tf_executor::IslandOp curr_island) {
          mlir::TF::SplitIsland(curr_island, control_type);
        });
  }
}

  auto graph_position = graph.getOperation()->getIterator();
  Block* parent_block = graph.getOperation()->getBlock();
  for (Operation& op : graph.GetBody().without_terminator()) {
    auto island_op = llvm::dyn_cast<tf_executor::IslandOp>(op);
    if (!island_op)
      return op.emitOpError()
             << "is not supported for lifting out of tf_executor.graph, "
                "expected tf_executor.island";

          auto result = graph.getResult(arg.getOperandNumber());
          this->join(getLatticeElement(result), *getLatticeElement(arg.get()));
        }
      }
    } else if (auto island = dyn_cast<tf_executor::IslandOp>(op)) {
      for (auto &arg : island.GetYield()->getOpOperands()) {
        auto result = island.getResult(arg.getOperandNumber());
        this->join(getLatticeElement(result), *getLatticeElement(arg.get()));
      }

  for (Value operand : op->getOperands()) {
    if (Operation* pred = operand.getDefiningOp()) {
      int result_number = llvm::cast<OpResult>(operand).getResultNumber();
      if (auto pred_island = llvm::dyn_cast<tf_executor::IslandOp>(pred)) {
        Value yield_operand = pred_island.GetYield().getOperand(result_number);
        predecessors.push_back(yield_operand.getDefiningOp());
      }
    }
  }
  return predecessors;
}