});

    // Create IdentityOp or IdentityNOp based on the number of outputs.
    Operation* identity_op;
    if (max_tensor_index == 0) {
      Value output_value = node_output_tensors.front().value;
      identity_op = builder.create<TF::IdentityOp>(
          new_loc, output_value.getType(), output_value);
    } else {

  if (!classes_attr) {
    // Attempt to parse "_class" from the IdentityOp that follows VariableV2.
    // For read-only reference variables, IdentityOp should be the only user of
    // VariableV2.
    auto identity_op = op->getUsers().begin();
    classes_attr = identity_op->getAttrOfType<ArrayAttr>(kClassAttr);
    if (!classes_attr) {

  builder.setInsertionPointToStart(&wrapper_island_op.GetBody());
  auto identity_op = builder.create<TF::IdentityOp>(
      name_loc, /*result_types=*/main_file_prefix_arg.getType(),
      /*input=*/main_file_prefix_arg);

  builder.create<tf_executor::YieldOp>(name_loc, identity_op.getResult());

  return wrapper_island_op;
}

      if (cluster_name.has_value()) continue;
      if (auto identity_op = llvm::dyn_cast_or_null<TF::IdentityOp>(op)) {
        auto identity_input = identity_op.getInput();
        auto output = identity_op.getOutput();
        output.replaceAllUsesWith(identity_input);
        identity_op.erase();
      }
    }
  }
}

void TpuV1BridgeExecutorIslandCoarsening::runOnOperation() {

`--per_file_copt` bazel option. For example, if you want to debug the Identity
op, which are in files starting with `identity_op`, you can run

```bash
bazel build --config=dbg --per_file_copt=+tensorflow/core/kernels/identity_op.*@-g //tensorflow/tools/pip_package:build_pip_package
```

  EXPECT_TRUE(compilation_result == nullptr);
  EXPECT_TRUE(xla_executable == nullptr);
}

TEST_F(OpsTestBase, CompileSingleOpSuccess) {
  TF_EXPECT_OK(NodeDefBuilder("identity_op", "Identity")
                   .Input(FakeInput(DT_FLOAT))
                   .Attr("T", DT_FLOAT)
                   .Finalize(node_def()));
  TF_EXPECT_OK(InitOp());

    while (true) {
      if (auto block_arg = llvm::dyn_cast<BlockArgument>(val)) {
        return block_arg.getArgNumber();
      }
      if (auto identity_op =
              llvm::dyn_cast<TF::IdentityOp>(val.getDefiningOp())) {
        val = identity_op.getOperand();
      } else {
        return -1;
      }
    }
  };

  for (auto call_op :

# https://github.com/tensorflow/tensorflow/issues/48919.
# Users can still include debug info for a specific kernel, e.g. with:
#     --config=dbg --per_file_copt=+tensorflow/core/kernels/identity_op.*@-g
# Since this .bazelrc file is synced between the tensorflow/tensorflow repo and
# the openxla/xla repo, also include debug info for files under xla/.
build:dbg --per_file_copt=+.*,-tensorflow.*,-xla.*@-g0

struct TensorDeviceCopyConversionPass
    : public impl::TensorDeviceCopyConversionPassBase<
          TensorDeviceCopyConversionPass> {
  void runOnOperation() override;
};

// Folds tf.IdentityOp and tf.IdentityNOp if op device and the argument devices
// from the defining ops match.
void TensorDeviceCopyConversionPass::runOnOperation() {
  func::FuncOp func_op = getOperation();

class IdentityOp;
class IdentityNOp;

// Returns if a value corresponds to a constant, returns the matched constant
// as an attribute.
template <typename AttrT>
bool GetValueAsConstant(Value val, AttrT &attr) {
  while (auto result = mlir::dyn_cast<OpResult>(val)) {
    Operation *op = result.getOwner();
    if (!isa<IdentityOp>(op) && !isa<IdentityNOp>(op)) break;