ImmediateTensorHandlePtr* handle) {
  ImmediateOpPtr varhandle_op(ctx->CreateOperation());

  TF_RETURN_IF_ERROR(varhandle_op->Reset("VarHandleOp", raw_device_name));
  TF_RETURN_IF_ERROR(varhandle_op->SetAttrType("dtype", dtype));

  // Note that if shape is unknown rank, shape.dim_sizes() will be empty, and
  // shape.dims() will be -1.

}

// Returns cloned `VarHandleOp`s. Assumes `save_func`'s body is empty.
SmallVector<TF::VarHandleOp> CloneVarHandleOpsIntoSaveFunc(
    func::FuncOp save_func, const ArrayRef<TF::VarHandleOp> var_handle_ops) {
  Block& save_op_block = save_func.getBody().front();

  IRMapping mapper{};
  SmallVector<TF::VarHandleOp> cloned_var_handle_ops = {};
  for (auto var_handle_op : var_handle_ops) {

        var_handle_op &&
        isa<TF::ConstOp>(assigned_value_operand.getDefiningOp())) {
      var_handle_ops.emplace_back(var_handle_op);
    }
  }

  return var_handle_ops;
}

// Creates a `ConstOp` of 1-dimensional TF::StringType out of `str_values`.
TF::ConstOp Create1DStringConst(const ArrayRef<std::string> str_values,

  // hoisted.
  auto read_var_op = llvm::dyn_cast<ReadVariableOp>(op);
  if (!read_var_op) return false;
  auto var_handle_op = llvm::dyn_cast_or_null<VarHandleOp>(
      read_var_op.getResource().getDefiningOp());
  if (!var_handle_op) return false;
  return read_only_vars.contains(GetResourceHandle(var_handle_op));
}

bool ShouldMoveOutOfRegion(
    Operation *op, Region *region,

    }
  }
  // Update resource tensors.
  for (VarHandleOp var_handle_op : var_handle_ops) {
    builder.setInsertionPoint(var_handle_op);
    auto output_type = UnrankedTensorType::get(TF::ResourceType::get(
        {mlir::cast<TensorType>(ref_qtype)}, builder.getContext()));
    auto new_var_handle_op = builder.create<VarHandleOp>(
        var_handle_op.getLoc(), output_type, var_handle_op.getContainer(),
        var_handle_op.getSharedName());

    llvm::ArrayRef<TF::VarHandleOp> var_handle_ops) {
  std::vector<std::string> names;
  names.reserve(var_handle_ops.size());
  for (auto var_handle_op : var_handle_ops)
    names.push_back(GetVariableName(var_handle_op));
  return names;
}

tensorflow::Var* GetVariableFromSession(mlir::TF::VarHandleOp var_handle_op,
                                        llvm::StringRef device_name,

// Returns the variable for the provided 'var_handle_op'.
std::string GetVariableName(TF::VarHandleOp var_handle_op);

// Returns pointer to the variable from 'session' that 'var_handle_op'
// refers to which is in 'device_name' device. If failed to fetch the value null
// will be returned.
// Note, caller is responsible for Unref the variable.
tensorflow::Var* GetVariableFromSession(mlir::TF::VarHandleOp var_handle_op,

      variables;
  for (auto var_handle_op : var_handle_ops)
    variables.insert(GetResourceKey(var_handle_op));

  llvm::SmallVector<Operation*, 4> work_list;
  for (auto var_handle_op : session_init_func.getOps<TF::VarHandleOp>()) {
    if (variables.count(GetResourceKey(var_handle_op)))
      work_list.push_back(var_handle_op);
  }

    // Creates a VarHandleOp -> ReadVariableOp pair for each ConstOp.
    const auto resource_type = RankedTensorType::get(
        /*shape=*/{}, /*elementType=*/TF::ResourceType::get(
            /*subtypes=*/llvm::ArrayRef<TensorType>{const_op.getType()},
            builder.getContext()));
    auto var_handle_op =
        builder.create<TF::VarHandleOp>(const_op.getLoc(),

      auto resource_type = var_handle_op.getResource().getType();
      func_arg_types.push_back(resource_type);
      var_handle_op.getResource().replaceAllUsesWith(
          block.addArgument(resource_type, var_handle_op.getLoc()));
    } else {
      var_handle_op.getResource().replaceAllUsesWith(
          block.getArgument(it.first->getSecond()));
    }
    var_handle_op.erase();
  }