*(*ptr)->tensor() = value;
                                (*ptr)->is_initialized = true;
                                return absl::OkStatus();
                              }));
  mutex_lock ml(*variable->mu());
  OP_REQUIRES(
      context,
      !variable->is_initialized || variable->tensor()->dtype() == dtype_,
      errors::InvalidArgument(

  auto* var_ptr = GetVariableFromSession(var_handle_op, device_name, mgr);
  if (!var_ptr) return false;
  auto* tensor = var_ptr->tensor();
  bool is_initialized = tensor && tensor->IsInitialized();
  var_ptr->Unref();
  return is_initialized;
}

LogicalResult MarkInitializedVariablesInFunction(func::FuncOp function,
                                                 tensorflow::Session* session) {

#include "tensorflow/core/public/session.h"

namespace mlir {
namespace tf_saved_model {
// Marks all variables in 'function' whether they are initialized
// in 'session' or not by setting an attribute named 'is_initialized'
// on each variable op with value true/false based on variable is initialized
// in the session or not.
// If 'session' is NULL the function is no-op.

            << " at input index: " << actual_input_index << " with shape "
            << write.shape.DebugString() << "; variable tensor has shape: "
            << var->tensor()->shape().DebugString();

    if (var->is_initialized && var->tensor()->dtype() != write.type) {
      return errors::Internal("Mismatched type in variable write");
    }

    TF_ASSIGN_OR_RETURN(
        Tensor output_tensor,

                               *(*ptr)->tensor() = value;
                               (*ptr)->is_initialized = true;
                               return absl::OkStatus();
                             }));
  tensorflow::mutex_lock ml(*variable->mu());

  if (validate_shape) {
    OP_REQUIRES(cc_ctx,
                (!variable->is_initialized ||
                 variable->tensor()->shape().IsSameSize(value.shape())),

                      const gtl::ArraySlice<T> data) {
    Tensor* init_var_value = CreateDeviceTensor<T>(shape, data);
    Var* var = new Var(DataTypeToEnum<T>::v());
    *var->tensor() = *init_var_value;
    var->is_initialized = true;

    return var;
  }

  // Creates a Variable, adds it to the resource manager and also adds it as one
  // of the inputs in the context_
  template <typename T>

      arg.kind = XlaCompiler::Argument::kResource;
      arg.resource_kind = XlaResource::kVariable;
      arg.definition_stack_trace = variable.definition_stack_trace();
      TF_RET_CHECK(variable.var() && variable.var()->is_initialized);
      const Tensor* value = variable.var()->tensor();
      arg.type = value->dtype();
      arg.shape = value->shape();
      arg.initialized = true;
    } else {

                      const gtl::ArraySlice<T> data) {
    Tensor* init_var_value = CreateDeviceTensor<T>(shape, data);
    Var* var = new Var(DataTypeToEnum<T>::v());
    *var->tensor() = *init_var_value;
    var->is_initialized = true;

    return var;
  }

  // Creates a Variable, adds it to the resource manager and also adds it as one
  // of the inputs in the context_
  template <typename T>

  // CHECK: "tf.VarHandleOp"
  // CHECK-SAME: shared_name = "var1"
  // CHECK-SAME: _is_initialized = true
  // CHECK: "tf.VarHandleOp"
  // CHECK-SAME: shared_name = "var2"
  // CHECK-SAME: _is_initialized = true
  // CHECK: "tf.VarHandleOp"
  // CHECK-SAME: shared_name = "var3"
  // CHECK-SAME: _is_initialized = false

  // INVALID-NOT: _is_initialized

  }

  // One resource, one read. _is_initialized is true, should be promoted.
  // CHECK-LABEL: func @read(%arg0: tensor<f32> {tf.resource_name = "x"}) -> tensor<f32>
  func.func @read() -> tensor<f32> {
    // CHECK-NOT: "tf.VarHandleOp"
    // CHECK-NOT: "tf.ReadVariableOp"
    // CHECK: return %arg0
    %1 = "tf.VarHandleOp"() {container = "", shared_name = "x", _is_initialized = true} : () -> tensor<!tf_type.resource<tensor<f32>>>