}
    } else if (auto attr = mlir::dyn_cast<mlir::ElementsAttr>(a)) {
      TensorProto tensor;
      TF_RETURN_IF_ERROR(ConvertToTensorProto(attr, &tensor));
      *list->add_tensor() = tensor;
    } else if (auto attr = mlir::dyn_cast<mlir::FlatSymbolRefAttr>(a)) {
      AttrValue attr_val;
      TF_RETURN_IF_ERROR(ConvertAttribute(attr, &attr_val));
      *list->add_func() = attr_val.func();

    return nullptr;
  }
  TF_DataType dtype;
  Status s = TfDataTypeFormDlDataType(dl_tensor->dtype, &dtype);
  if (!s.ok()) {
    status->status = std::move(s);
    return nullptr;
  }
  int num_dims = dl_tensor->ndim;
  const int64_t* dims = dl_tensor->shape;
  void* data = dl_tensor->data;

  if (dl_tensor->byte_offset != 0) {
    status->status = tensorflow::errors::InvalidArgument(

                                                  TF_Status* status) {
  auto* cc_ctx = reinterpret_cast<tensorflow::OpKernelContext*>(ctx);
  const tensorflow::Tensor& arg_tensor = cc_ctx->input(index);
  absl::Status cc_status;
  if (arg_tensor.dtype() != tensorflow::DT_RESOURCE) {
    cc_status = absl::InvalidArgumentError(
        absl::StrCat("Trying to obtain resource handle from Input[", index,

    //
    // 3. AsyncValueTensor, containing a PjRtBuffer. This is the legacy mode
    // and certain device type (e.g. TPU) still uses this path.
    AsyncValueTensor* av_tensor = AsyncValueTensor::FromTensor(tensor);
    if (use_pjrt_tensor_buffer) {
      if (av_tensor != nullptr) {
        return absl::InvalidArgumentError(
            "If use_pjrt_tensor_buffer is set, the input tensor should not "

  auto begin_tensor = CreateI32DenseConst(builder, begin, loc);
  auto end_tensor = CreateI32DenseConst(builder, end, loc);
  auto strides_tensor = CreateI32DenseConst(builder, strides, loc);

  return builder->create<TF::StridedSliceOp>(
      loc, output_type, input, begin_tensor, end_tensor, strides_tensor,
      builder->getI64IntegerAttr(begin_mask),
      builder->getI64IntegerAttr(end_mask),