}, {
    tf_device.return %arg0 : tensor<i1>
  // CHECK:      }) : () -> (tensor<i1>, tensor<i1>)
  }) : () -> (tensor<i1>, tensor<i1>)
  // CHECK-NEXT: [[VAR:%.+]] = "tf.VarHandleOp"
  %1 = "tf.VarHandleOp"() {container = "", shape = #tf_type.shape<>, shared_name = "x"} : () -> tensor<!tf_type.resource<tensor<i1>>>
  // CHECK-NEXT: "tf.AssignVariableOp"([[VAR]], [[PARALLEL_EXECUTE]]#0)

// CHECK: }

func.func @unknown_side_effecting_op(%arg0: tensor<32xf32>) -> () {
  tf_executor.graph {
    %island = tf_executor.island {
      %vh0 = "tf.VarHandleOp"() {container = "c", shared_name = "v0"} : () -> tensor<*x!tf_type.resource<tensor<32xf32>>>
      %vh1 = "tf.VarHandleOp"() {container = "c", shared_name = "v1"} : () -> tensor<*x!tf_type.resource<tensor<32xf32>>>

namespace {

TEST(ResourceVariableGradTest, ReadVariableOpGrad) {
  TensorShape shape({});
  auto scope = Scope::NewRootScope();
  auto x = Placeholder(scope, DT_FLOAT, Placeholder::Shape(shape));

  auto var = VarHandleOp(scope, DT_FLOAT, shape);
  auto init = AssignVariableOp(scope, var, Const(scope, 2.0f, shape));

  auto temp = ReadVariableOp(scope, var, DT_FLOAT);

  auto y = Mul(scope, temp, x);

      "IdentityN",  // Variadic input+output
      "SparseSoftmaxCrossEntropyWithLogits",  // 2 outputs
      "AccumulatorApplyGradient",             // 0 outputs
      "VarHandleOp",                          // type, shape, list(string) attrs
      "RestoreV2",  // Variadic output-only, list(type) attr
  };

  cpp::CppConfig cpp_config(category, name_space);

  bool unconditionally_use_set_output_shapes = false;

  // Apply default attributes from the op definition to the loaded op.
  bool add_default_attributes = true;

  // If set, promote tf.VarHandleOp to resource arguments for all functions.
  bool lift_variables = true;

  // Keeps the variables in initializers before lifting variables (when
  // `lift_variables == true`) or newly adding variable initialization patterns

func.func @unknown_side_effecting_op(%arg0: tensor<32xf32>) {
  tf_executor.graph {
    %outputs, %control = tf_executor.island wraps "tf.VarHandleOp"() {container = "c", shared_name = "v0"} : () -> tensor<*x!tf_type.resource<tensor<32xf32>>>
    %outputs_0, %control_1 = tf_executor.island wraps "tf.VarHandleOp"() {container = "c", shared_name = "v1"} : () -> tensor<*x!tf_type.resource<tensor<32xf32>>>

  auto* operation = resource.getDefiningOp();
  if (operation && isa<TF::VarHandleOp>(operation)) {
    mutable_variables_.insert(GetResourceKey(operation));
  }
}

bool ResourceAnalyzer::IsPotentiallyWritten(Value resource) const {
  assert(IsResource(resource));
  auto* operation = resource.getDefiningOp();
  if (operation && isa<TF::VarHandleOp>(operation))
    return mutable_variables_.contains(GetResourceKey(operation));

                                                                               \
  REGISTER_KERNEL_BUILDER(                                                     \
      Name("VarHandleOp").Device(DEVICE).HostMemory("resource"), VarHandleOp); \
  REGISTER_KERNEL_BUILDER(                                                     \
      Name("_VarHandlesOp").Device(DEVICE).HostMemory("resources"),            \

#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/platform/status.h"

namespace tensorflow {
namespace internal {

// Executes a VarHandleOp using `ctx`, and fills `handle` with the DT_RESOURCE
// TensorHandle associated with the variable. This is equivalent to creating an
// unitialized TF2 tf.Variable.

#include "tensorflow/c/eager/abstract_context.h"
#include "tensorflow/c/eager/abstract_tensor_handle.h"

namespace tensorflow {
namespace ops {

// Creates a handle to a Variable resource.
Status VarHandleOp(AbstractContext* ctx, AbstractTensorHandle** resource,
                   DataType dtype, const PartialTensorShape shape,
                   const char* container = "", const char* shared_name = "",