```mlir
    func @tf_tpu_rewrite(%arg0: tensor<i8>) {
      %0:2 = "tf_device.launch"() ( {
        %compilation_status, %program = "tf._TPUCompileMlir"() {mlir_module = "<serialized func>"} : () -> (tensor<!tf_type.string>, tensor<3x!tf_type.string>)
        tf_device.return %compilation_status, %program : tensor<!tf_type.string>, tensor<3x!tf_type.string>

     tf_device.return
   }) {device = "/job:localhost/replica:0/task:0/device:CPU:0"} : () -> ()
   %0:2 = "tf_device.launch"() ({
     %compilation_status, %program = "tf._TPUCompileMlir"() { metadata = "...", mlir_module = "..." } : () -> (tensor<!tf_type.string>, tensor<3x!tf_type.string>)
     tf_device.return %compilation_status, %program : tensor<!tf_type.string>, tensor<3x!tf_type.string>

                                /*shape_determination_fns=*/{},
                                &compilation_result, custom_legalization_passes)
                .status();
  if (!compilation_status.ok()) {
    LOG(ERROR) << "TF/XLA compilation failed: " << compilation_status;
    return mlir::failure();
  }

  return PrintHloModuleText(compilation_result, output);
}

static mlir::LogicalResult MlirTfGraphToHloTextTranslateFunction(

    cache_value.compilation_status = compiler.CompileSingleOp(
        compile_options, ctx, args, out_compilation_result.get());
  } else {
    CHECK(scope == CompileScope::kFunction);  // Crash OK
    cache_value.compilation_status = compiler.Compile(
        compile_options, function, args, out_compilation_result.get());
  }
  TF_RETURN_IF_ERROR(cache_value.compilation_status);

  // CHECK-LABEL: @converts_cluster
  func.func @converts_cluster() {
    // CHECK: %0:2 = "tf_device.launch"() <{{.*}}> ({
    // CHECK: %compilation_status, %program = "tf._TPUCompileMlir"()

TEST_F(LowerClusterToRuntimeOpsTest, ErrorsWithBadCluster) {
  CellReader<int64_t> compilation_status(kCompilationStreamz);

  TF_ASSERT_OK(CreateMlirModule("malformed_cluster.mlir"));

  EXPECT_FALSE(RunLowerClusterToRuntimeOpsPassPipeline(
                   *mlir_module_, DeviceType(DEVICE_TPU_XLA_JIT))
                   .ok());

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

  tf_device.return
}) {device = "/job:localhost/replica:0/task:0/device:CPU:0"} : () -> ()
%0:2 = "tf_device.launch"() ({
  %compilation_status, %program = "tf._TPUCompileMlir"() { metadata = "...", mlir_module = "..." } : () -> (tensor<!tf_type.string>, tensor<3x!tf_type.string>)
  tf_device.return %compilation_status, %program : tensor<!tf_type.string>, tensor<3x!tf_type.string>

  EXPECT_TRUE(cache_value->compile_state == DeviceCompileState::kCompiled);
  EXPECT_TRUE(cache_value->compilation_result != nullptr);
  EXPECT_TRUE(cache_value->executable != nullptr);
  EXPECT_TRUE(cache_value->compilation_status.ok());
}

TEST_F(DeviceCompilerTest, CompilePersistentCacheEnabled) {
  auto xla_device_compiler =
      CreateXlaDeviceCompiler(/*enable_persistence=*/true);

  } else {
    metadata.SerializeToString(&txt_metadata);
  }

  auto compile_op = builder->create<TF::_TPUCompileMlirOp>(
      cluster_func.getLoc(),
      /*compilation_status=*/compilation_status_type, /*program=*/
      llvm::SmallVector<Type, 8>(num_cores_per_replica, program_type),
      compile_op_operands, txt_module, txt_metadata);

  let description = [{
This op produces no output and closes the device during failure to ensure all
pending device interactions fail.

'compilation_status' is a serialized CompilationResultProto.
  }];

  let arguments = (ins
    TF_StrTensor:$compilation_status
  );

  let results = (outs);
}

def TF_TPUCopyWithLayoutOp : TF_Op<"TPUCopyWithLayout", [Pure]> {