}];

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

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

  let description = [{
    Transfer a CPU tensor to device.

    Example:
      %device_tensor = gpurt.transfer_to_device %cpu_tensor
  }];

  let arguments = (ins TFTensorType);
  let results = (outs TFTensorType);
  let assemblyFormat = "operands attr-dict";
}

// TODO(b/260267885): We may add a device argument when we want to support
// GPU MIG.
def TransferFromDeviceOp: Gpu_Op<"transfer_from_device"> {

    Note that the trailing number indicates the number of results.
  }];

  let arguments = (ins
    Variadic<TFTensorType>,
    StrAttr:$node_def,
    I32Attr:$op_key
  );

  let results = (outs Variadic<TFTensorType>);

  let assemblyFormat = "`(`operands`)` attr-dict `:` functional-type(operands, results)";
}

  parse_options.has_cost = false;

  auto &builder = parser.getBuilder();
  if (mlir::failed(fallback_common::ParseExecuteOpCommon(
          parser, builder, result, builder.getType<fallback::TFTensorType>(),
          parse_options)))
    return mlir::failure();

  mlir::IntegerAttr num_args;
  if (parser.parseKeyword("num_args") || parser.parseLParen() ||

    Note that this kernel always create a new AsyncValue for each result to
    avoid atomic contention on AsyncValue's refcount.
  }];

  let arguments = (ins
    TFTensorType:$operand
  );

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

  let assemblyFormat = "$operand attr-dict `:` `(` type($operand) `)` `->` `(` type($results) `)`";
}

  }];

  let cppNamespace = "::tfrt::fallback";
}

// This corresponds to tensorflow::Tensor.
def TFTensorType : DialectType<Fallback_Dialect,
    CPred<"$_self.isa<::tfrt::fallback::TFTensorType>()">, "!tfrt_fallback.tf_tensor type">,
    BuildableType<"$_builder.getType<::tfrt::fallback::TFTensorType>()"> {
  let description = [{
    `!tfrt_fallback.tf_tensor type` represents a tensorflow::Tensor.
  }];
}

  if (keyword == "tf_tensor") return TFTensorType::get(getContext());
  if (keyword == "tf_allocator") return TFAllocatorType::get(getContext());

  parser.emitError(parser.getNameLoc(), "unknown type: ") << keyword;
  return Type();
}

/// Print a type registered to this dialect.
void FallbackDialect::printType(Type type, DialectAsmPrinter &os) const {
  if (mlir::isa<TFTensorType>(type)) {
    os << "tf_tensor";
    return;

  Type parseType(DialectAsmParser &parser) const override;
  void printType(Type type, DialectAsmPrinter &os) const override;
};

// The MLIR type represents a tensorflow::Tensor.
class TFTensorType : public Type::TypeBase<TFTensorType, Type, TypeStorage> {
 public:
  using Base::Base;
  static constexpr StringLiteral name = "tfrt.tf_tensor";
};

// The MLIR type represents a tensorflow::Allocator.
class TFAllocatorType

//===----------------------------------------------------------------------===//
// Type definitions
//===----------------------------------------------------------------------===//
def TfTensorType : OpaqueType<"tfd", "tf_tensor", "!tfd.tf_tensor type">;

//===----------------------------------------------------------------------===//
// Runtime Fallback Dialect definitions

}

// This corresponds to tensorflow::Tensor.
def TFTensorType : DialectType<TensorflowMlrt_Dialect,
    CPred<"$_self.isa<::tensorflow::tf_mlrt::TFTensorType>()">, "!tf_mlrt.tensor type">,
    BuildableType<"$_builder.getType<::tensorflow::tf_mlrt::TFTensorType>()"> {
  let description = [{
    `!tf_mlrt.tensor type` represents a tensorflow::Tensor.
  }];
}