case 64:
        *dtype = itype.isUnsigned() ? DT_UINT64 : DT_INT64;
        return absl::OkStatus();
      default:
        return errors::Unimplemented(
            absl::StrCat("Converting ", debugString(type), " to DataType"));
    }
  } else if (auto complex_type = mlir::dyn_cast<mlir::ComplexType>(type)) {
    auto etype = complex_type.getElementType();
    if (etype.isF32()) {
      *dtype = DT_COMPLEX64;

        attrs.push_back(attr);
      }
      if (!value.list().func().empty()) {
        return tensorflow::errors::Unimplemented(
            absl::StrCat("Attribute ", value.DebugString()));
      }
      return builder->getArrayAttr(llvm::ArrayRef(attrs.begin(), attrs.end()));
    }
    case AttrValue::VALUE_NOT_SET:
      return builder->getUnitAttr();
    // kPlaceholder is not implemented.

}

std::string DeviceCompilationProfiler::DebugString() const {
  std::string debug_string =
      "DeviceCompilationProfiler {\ncluster_compile_stats: {\n";
  {
    mutex_lock lock(mu_);

    for (const auto& [key, stats] : cluster_compile_stats_) {
      absl::StrAppend(&debug_string, key, ": ", stats.DebugString(), "\n");
    }
  }

  absl::StrAppend(&debug_string, "}\nnum_ongoing_compilations=",

  }

  /// Overload AbslHashValue to make TensorSpec hashable.
  template <typename H>
  friend H AbslHashValue(H h, const TensorSpec& t) {
    return H::combine(std::move(h), t.shape.DebugString(), t.dtype);
  }
};

// Defined in `iostream.cc`.
std::ostream& operator<<(std::ostream& o, const TensorSpec& x);

}  // namespace impl
}  // namespace libtf
}  // namespace tf

        "be nullptr.");
  }

  LOG(INFO) << "User-provided quantization config: "
            << quantization_config.DebugString();
  const QuantizationConfig updated_config =
      ExpandPresets(PopulateDefaults(quantization_config));
  LOG(INFO) << "Updated quantization config: " << updated_config.DebugString();

  const absl::flat_hash_map<std::string, SignatureDef> signature_def_map =

}

std::ostream& operator<<(std::ostream& o, const String& str) {
  return o << str.str();
}

std::ostream& operator<<(std::ostream& o, const TensorSpec& x) {
  o << "TensorSpec(shape = " << x.shape.DebugString() << ", dtype = " << x.dtype
    << ")";
  return o;
}

}  // namespace impl
}  // namespace libtf

void ExpectSummaryMatches(const Summary& actual, const string& expected_str) {
  Summary expected;
  ASSERT_TRUE(protobuf::TextFormat::ParseFromString(expected_str, &expected));
  EXPECT_EQ(expected.DebugString(), actual.DebugString());
}

void TestScalarSummaryOp(Tensor* tags, Tensor* values, string expected_output,
                         error::Code expected_code) {
  // Initialize node used to fetch OpKernel
  Status status;

  // Prints out the internal state of this instance.  For debugging purposes
  // only.
  virtual void Print() const = 0;
  virtual ~DeadnessAnalysis();

  string DebugString(DeadnessPredicate predicate) const;

  // Run the deadness analysis over `graph` and returns an error or a populated
  // instance of DeadnessAnalysis in `result`.
  static Status Run(const Graph& graph,

    return listener->Listen(jit_compilation_activity);
  });
}

Status BroadcastOptimizationRemark(XlaOptimizationRemark optimization_remark) {
  VLOG(2) << "OptimizationRemark: " << optimization_remark.DebugString();
  return ForEachListener([&](XlaActivityListener* listener) {
    return listener->Listen(optimization_remark);
  });
}

Status BroadcastOptimizationRemark(

  TF_ASSERT_OK(device_context_->CopyDeviceTensorToCPUSync(
      &device_tensor, "", device_.get(), &dest_cpu_tensor));
  LOG(INFO) << "H2D - D2H roundtrip completes. tensor: "
            << dest_cpu_tensor.DebugString(4);

  tensorflow::test::ExpectClose(origin_cpu_tensor, dest_cpu_tensor);
}
#endif

}  // namespace