absl::StatusOr<mlir::ElementsAttr> ConvertTensorProto(
    const TensorProto& input_tensor, mlir::Builder* builder);

// Converts an TensorFlow tensor into an MLIR elements attribute.
absl::StatusOr<mlir::ElementsAttr> ConvertTensor(const Tensor& input_tensor,
                                                 mlir::Builder* builder);

// Converts a shape from MLIR to a TensorFlow tensor shape proto.

    const StringRef name = std::get<0>(iter);
    const Tensor& tensor = std::get<1>(iter);

    // Create tensor attribute for this variable.
    absl::StatusOr<ElementsAttr> tensor_attr_or =
        ConvertTensor(tensor, &builder);
    if (!tensor_attr_or.ok()) {
      return module.emitOpError()
             << "failed to convert tensor (name: " << name.str() << ")";
    }

    auto clean_tensor =
        MakeCleanup([tf_tensor] { TF_DeleteTensor(tf_tensor); });
    Tensor tensor;
    RETURN_FAILURE_IF_ERROR(TF_TensorToTensor(tf_tensor, &tensor));
    auto attr_or = ConvertTensor(tensor, &builder);
    RETURN_FAILURE_IF_ERROR(attr_or.status());
    results->push_back(attr_or.value());
  }

  VLOG(1) << "Evaluate node " << node_name << " successfully!";

  return mlir::success();

                        tensorflow::Tensor* tensor,
                        func::FuncOp session_init_func, OpBuilder builder) {
  absl::StatusOr<ElementsAttr> tensor_attr_or =
      tensorflow::ConvertTensor(*tensor, &builder);
  assert(tensor_attr_or.ok() && "Expect valid tensor");
  ElementsAttr tensor_attr = tensor_attr_or.value();

  builder.setInsertionPointToStart(&session_init_func.getBlocks().front());

  Builder builder(inst->getContext());

  for (int i = 0; i < op_kernel_context.num_outputs(); ++i) {
    DCHECK(op_kernel_context.mutable_output(i));
    absl::StatusOr<ElementsAttr> result_attr = tensorflow::ConvertTensor(
        *op_kernel_context.mutable_output(i), &builder);
    RETURN_FAILURE_IF_ERROR(result_attr.status());
    results.push_back(result_attr.value());
  }