namespace {

using ::mlir::tfg::mangling_util::PrintShortTextProto;

const char kAttributePrefix[] = "tf.";
const char kDataTypePrefix[] = "tfdtype$";
const char kTensorShapePrefix[] = "tfshape$";
const char kTensorPrefix[] = "tftensor$";

}  // namespace

string MangleAttributeName(absl::string_view str) {
  return absl::StrCat(kAttributePrefix, str);
}

bool IsMangledAttributeName(absl::string_view str) {

           "tftensor".
           The value serialization format can be found in attr_util.h.

      %out_c, %out_tensor = "tfd.delegate_kernel"(
        %in_c, %in1_tensor, %in2_tensor) {
        _name = "MatMul",
        attr1_name = "transpose_a", attr1_value = "bool$false",
        attr2_name = "transpose_b", attr2_value = "bool$false"
      } : (!tfrt.chain, !tfd.tf_tensor, !tfd.tf_tensor) -> (

TF_Tensor* TF_TensorMaybeMove(TF_Tensor* t) {
  return t->tensor->CanMove() ? t : nullptr;
}

void TF_DeleteTensor(TF_Tensor* t) {
  if (t == nullptr) {
    return;
  }

  if (t->tensor) {
    t->tensor->Release();
  }

  delete t;
}

TF_DataType TF_TensorType(const TF_Tensor* t) {
  return static_cast<TF_DataType>(t->tensor->Type());

// Return the length of the tensor in the "dim_index" dimension.
// REQUIRES: 0 <= dim_index < TF_NumDims(tensor)
TF_CAPI_EXPORT extern int64_t TF_Dim(const TF_Tensor* tensor, int dim_index);

// Return the size of the underlying data in bytes.
TF_CAPI_EXPORT extern size_t TF_TensorByteSize(const TF_Tensor*);

// Return a pointer to the underlying data buffer.
TF_CAPI_EXPORT extern void* TF_TensorData(const TF_Tensor*);

// passed to or returned from C functions *by pointer*. Otherwise, changes to
// its internal structure will break the C API's binary interface.
typedef struct TF_Tensor {
  tensorflow::AbstractTensorInterface* tensor;
} TF_Tensor;

class TF_ManagedBuffer : public tensorflow::TensorBuffer {
 public:
  TF_ManagedBuffer(void* data, size_t len,
                   void (*deallocator)(void* data, size_t len, void* arg),

  tfrt.return %ra, %rarg0, %rb, %rarg1 : !tfrt_fallback.tf_tensor, !tfrt_fallback.tf_tensor, !tfrt_fallback.tf_tensor, !tfrt_fallback.tf_tensor
}

  tfrt.return %ch3: !tfrt.chain
}

// CHECK-LABEL: func @copy_if_small
func.func @copy_if_small(%arg: !tfrt_fallback.tf_tensor) -> (!tfrt_fallback.tf_tensor, !tfrt_fallback.tf_tensor) {
  // CHECK: tfrt_fallback_async.copy_if_small {{%.*}} {_tfrt_cost = 1 : i64} : (!tfrt_fallback.tf_tensor) -> (!tfrt_fallback.tf_tensor, !tfrt_fallback.tf_tensor)

    TF_OpKernelContext* ctx, int input_index, int value_index, int Op,
    int isVariantType,
    void (*copyFunc)(TF_OpKernelContext* ctx, TF_Tensor* source,
                     TF_Tensor* dest),
    void (*updateFunc)(TF_OpKernelContext* ctx, TF_Tensor* tensor,
                       TF_Tensor* value, int Op),
    TF_Status* status);

// Expose higher level temporary variable operator for Pluggable vendors to

// A wrapper that will automatically delete the allocated TF_Tensor
// once out of scope.
struct TF_TensorWrapper {
  TF_Tensor* tf_tensor;
  explicit TF_TensorWrapper(TF_Tensor* tensor) { tf_tensor = tensor; }
  ~TF_TensorWrapper() { TF_DeleteTensor(tf_tensor); }
};

void TestShapeMatch(TensorShape shape) {
  Tensor tensor(DT_FLOAT, shape);
  Status status;
  TF_Tensor* tf_tensor = TF_TensorFromTensor(tensor, &status);

      return $tensor_list_or_flow_in[$max_iterations]
  }];

  let arguments = (ins
    TF_Tensor:$max_iterations,
    Variadic<TF_Tensor>:$tensor_list_or_flow_in,
    Variadic<TF_Tensor>:$invariant_args,
    FlatSymbolRefAttr:$body_fn,
    I32Attr:$num_tensor_list_or_flow_in
  );

  let results = (outs
     Variadic<TF_Tensor>:$result
  );