Call TSL workspace macros from XLA

This causes XLA to automatically load TSL's dependencies - including when XLA is loaded as a Bazel dependency.

PiperOrigin-RevId: 509356460

Author: jakeharmon8

WORKSPACE

@@ -6,6 +6,10 @@ workspace(name = "xla")
 # restriction that load() statements need to be at the top of .bzl files.
 # E.g. we can not retrieve a new repository with http_archive and then load()
 # a macro from that repository in the same file.
+load(":workspace4.bzl", "xla_workspace4")
+
+xla_workspace4()
+
 load(":workspace3.bzl", "xla_workspace3")
 
 xla_workspace3()

third_party/eigen3/BUILD

@@ -36,7 +36,7 @@ cc_library(
     includes = if_mkl(["./mkl_include"]),
     visibility = ["//visibility:public"],
     deps = [
-        "@eigen_archive//:eigen3",
+        "@eigen_archive//:eigen3_internal",
     ],
 )
 

third_party/eigen3/eigen_archive.BUILD

@@ -41,8 +41,13 @@ EIGEN_MPL2_SOURCES = glob(
     ],
 )
 
-cc_library(
+alias(
     name = "eigen3",
+    actual = "@xla//third_party/eigen3",
+)
+
+cc_library(
+    name = "eigen3_internal",
     srcs = EIGEN_MPL2_SOURCES,
     hdrs = EIGEN_HEADERS,
     defines = [

third_party/tsl/third_party/BUILD

@@ -0,0 +1 @@
+licenses(["notice"])  # Apache 2.0

third_party/tsl/third_party/__init__.py

@@ -0,0 +1 @@
+# copybara:uncomment package(default_applicable_licenses = ["//third_party/tensorflow:license"])

third_party/tsl/third_party/absl/BUILD

@@ -0,0 +1,5 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])  # Apache
+
+exports_files(["LICENSE"])

third_party/tsl/third_party/absl/com_google_absl.BUILD

@@ -0,0 +1,267 @@
+diff --git a/absl/container/internal/compressed_tuple.h b/absl/container/internal/compressed_tuple.h
+index 5ebe1649..01db7134 100644
+--- a/absl/container/internal/compressed_tuple.h
++++ b/absl/container/internal/compressed_tuple.h
+@@ -32,7 +32,6 @@
+ #ifndef ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+ #define ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+ 
+-#include <initializer_list>
+ #include <tuple>
+ #include <type_traits>
+ #include <utility>
+@@ -77,134 +76,61 @@ constexpr bool IsFinal() {
+ #endif
+ }
+ 
+-// We can't use EBCO on other CompressedTuples because that would mean that we
+-// derive from multiple Storage<> instantiations with the same I parameter,
+-// and potentially from multiple identical Storage<> instantiations.  So anytime
+-// we use type inheritance rather than encapsulation, we mark
+-// CompressedTupleImpl, to make this easy to detect.
+-struct uses_inheritance {};
+-
+ template <typename T>
+ constexpr bool ShouldUseBase() {
+-  return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>() &&
+-         !std::is_base_of<uses_inheritance, T>::value;
++  return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>();
+ }
+ 
+ // The storage class provides two specializations:
+ //  - For empty classes, it stores T as a base class.
+ //  - For everything else, it stores T as a member.
+-template <typename T, size_t I,
+-#if defined(_MSC_VER)
+-          bool UseBase =
+-              ShouldUseBase<typename std::enable_if<true, T>::type>()>
+-#else
+-          bool UseBase = ShouldUseBase<T>()>
+-#endif
++template <typename D, size_t I, bool = ShouldUseBase<ElemT<D, I>>()>
+ struct Storage {
++  using T = ElemT<D, I>;
+   T value;
+   constexpr Storage() = default;
+-  template <typename V>
+-  explicit constexpr Storage(absl::in_place_t, V&& v)
+-      : value(absl::forward<V>(v)) {}
++  explicit constexpr Storage(T&& v) : value(absl::forward<T>(v)) {}
+   constexpr const T& get() const& { return value; }
+   T& get() & { return value; }
+   constexpr const T&& get() const&& { return absl::move(*this).value; }
+   T&& get() && { return std::move(*this).value; }
+ };
+ 
+-template <typename T, size_t I>
+-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T {
++template <typename D, size_t I>
++struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<D, I, true>
++    : ElemT<D, I> {
++  using T = internal_compressed_tuple::ElemT<D, I>;
+   constexpr Storage() = default;
+-
+-  template <typename V>
+-  explicit constexpr Storage(absl::in_place_t, V&& v)
+-      : T(absl::forward<V>(v)) {}
+-
++  explicit constexpr Storage(T&& v) : T(absl::forward<T>(v)) {}
+   constexpr const T& get() const& { return *this; }
+   T& get() & { return *this; }
+   constexpr const T&& get() const&& { return absl::move(*this); }
+   T&& get() && { return std::move(*this); }
+ };
+ 
+-template <typename D, typename I, bool ShouldAnyUseBase>
++template <typename D, typename I>
+ struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
+ 
+-template <typename... Ts, size_t... I, bool ShouldAnyUseBase>
+-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
+-    CompressedTuple<Ts...>, absl::index_sequence<I...>, ShouldAnyUseBase>
++template <typename... Ts, size_t... I>
++struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
++    CompressedTupleImpl<CompressedTuple<Ts...>, absl::index_sequence<I...>>
+     // We use the dummy identity function through std::integral_constant to
+     // convince MSVC of accepting and expanding I in that context. Without it
+     // you would get:
+     //   error C3548: 'I': parameter pack cannot be used in this context
+-    : uses_inheritance,
+-      Storage<Ts, std::integral_constant<size_t, I>::value>... {
++    : Storage<CompressedTuple<Ts...>,
++              std::integral_constant<size_t, I>::value>... {
+   constexpr CompressedTupleImpl() = default;
+-  template <typename... Vs>
+-  explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args)
+-      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
+-  friend CompressedTuple<Ts...>;
++  explicit constexpr CompressedTupleImpl(Ts&&... args)
++      : Storage<CompressedTuple<Ts...>, I>(absl::forward<Ts>(args))... {}
+ };
+ 
+-template <typename... Ts, size_t... I>
+-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
+-    CompressedTuple<Ts...>, absl::index_sequence<I...>, false>
+-    // We use the dummy identity function as above...
+-    : Storage<Ts, std::integral_constant<size_t, I>::value, false>... {
+-  constexpr CompressedTupleImpl() = default;
+-  template <typename... Vs>
+-  explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args)
+-      : Storage<Ts, I, false>(absl::in_place, absl::forward<Vs>(args))... {}
+-  friend CompressedTuple<Ts...>;
+-};
+-
+-std::false_type Or(std::initializer_list<std::false_type>);
+-std::true_type Or(std::initializer_list<bool>);
+-
+-// MSVC requires this to be done separately rather than within the declaration
+-// of CompressedTuple below.
+-template <typename... Ts>
+-constexpr bool ShouldAnyUseBase() {
+-  return decltype(
+-      Or({std::integral_constant<bool, ShouldUseBase<Ts>()>()...})){};
+-}
+-
+-template <typename T, typename V>
+-using TupleElementMoveConstructible =
+-    typename std::conditional<std::is_reference<T>::value,
+-                              std::is_convertible<V, T>,
+-                              std::is_constructible<T, V&&>>::type;
+-
+-template <bool SizeMatches, class T, class... Vs>
+-struct TupleMoveConstructible : std::false_type {};
+-
+-template <class... Ts, class... Vs>
+-struct TupleMoveConstructible<true, CompressedTuple<Ts...>, Vs...>
+-    : std::integral_constant<
+-          bool, absl::conjunction<
+-                    TupleElementMoveConstructible<Ts, Vs&&>...>::value> {};
+-
+-template <typename T>
+-struct compressed_tuple_size;
+-
+-template <typename... Es>
+-struct compressed_tuple_size<CompressedTuple<Es...>>
+-    : public std::integral_constant<std::size_t, sizeof...(Es)> {};
+-
+-template <class T, class... Vs>
+-struct TupleItemsMoveConstructible
+-    : std::integral_constant<
+-          bool, TupleMoveConstructible<compressed_tuple_size<T>::value ==
+-                                           sizeof...(Vs),
+-                                       T, Vs...>::value> {};
+-
+ }  // namespace internal_compressed_tuple
+ 
+ // Helper class to perform the Empty Base Class Optimization.
+ // Ts can contain classes and non-classes, empty or not. For the ones that
+ // are empty classes, we perform the CompressedTuple. If all types in Ts are
+-// empty classes, then CompressedTuple<Ts...> is itself an empty class.  (This
+-// does not apply when one or more of those empty classes is itself an empty
+-// CompressedTuple.)
++// empty classes, then CompressedTuple<Ts...> is itself an empty class.
+ //
+ // To access the members, use member .get<N>() function.
+ //
+@@ -220,59 +146,36 @@ struct TupleItemsMoveConstructible
+ template <typename... Ts>
+ class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
+     : private internal_compressed_tuple::CompressedTupleImpl<
+-          CompressedTuple<Ts...>, absl::index_sequence_for<Ts...>,
+-          internal_compressed_tuple::ShouldAnyUseBase<Ts...>()> {
++          CompressedTuple<Ts...>, absl::index_sequence_for<Ts...>> {
+  private:
+   template <int I>
+   using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
+ 
+-  template <int I>
+-  using StorageT = internal_compressed_tuple::Storage<ElemT<I>, I>;
+-
+  public:
+-  // There seems to be a bug in MSVC dealing in which using '=default' here will
+-  // cause the compiler to ignore the body of other constructors. The work-
+-  // around is to explicitly implement the default constructor.
+-#if defined(_MSC_VER)
+-  constexpr CompressedTuple() : CompressedTuple::CompressedTupleImpl() {}
+-#else
+   constexpr CompressedTuple() = default;
+-#endif
+-  explicit constexpr CompressedTuple(const Ts&... base)
+-      : CompressedTuple::CompressedTupleImpl(absl::in_place, base...) {}
+-
+-  template <typename First, typename... Vs,
+-            absl::enable_if_t<
+-                absl::conjunction<
+-                    // Ensure we are not hiding default copy/move constructors.
+-                    absl::negation<std::is_same<void(CompressedTuple),
+-                                                void(absl::decay_t<First>)>>,
+-                    internal_compressed_tuple::TupleItemsMoveConstructible<
+-                        CompressedTuple<Ts...>, First, Vs...>>::value,
+-                bool> = true>
+-  explicit constexpr CompressedTuple(First&& first, Vs&&... base)
+-      : CompressedTuple::CompressedTupleImpl(absl::in_place,
+-                                             absl::forward<First>(first),
+-                                             absl::forward<Vs>(base)...) {}
++  explicit constexpr CompressedTuple(Ts... base)
++      : CompressedTuple::CompressedTupleImpl(absl::forward<Ts>(base)...) {}
+ 
+   template <int I>
+   ElemT<I>& get() & {
+-    return StorageT<I>::get();
++    return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
+   }
+ 
+   template <int I>
+   constexpr const ElemT<I>& get() const& {
+-    return StorageT<I>::get();
++    return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
+   }
+ 
+   template <int I>
+   ElemT<I>&& get() && {
+-    return std::move(*this).StorageT<I>::get();
++    return std::move(*this)
++        .internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
+   }
+ 
+   template <int I>
+   constexpr const ElemT<I>&& get() const&& {
+-    return absl::move(*this).StorageT<I>::get();
++    return absl::move(*this)
++        .internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
+   }
+ };
+ 
+diff --git a/absl/time/internal/cctz/BUILD.bazel b/absl/time/internal/cctz/BUILD.bazel
+index 7304d40d..75d8e086 100644
+--- a/absl/time/internal/cctz/BUILD.bazel
++++ b/absl/time/internal/cctz/BUILD.bazel
+@@ -72,15 +72,6 @@ cc_library(
+         "include/cctz/time_zone.h",
+         "include/cctz/zone_info_source.h",
+     ],
+-    linkopts = select({
+-        ":osx": [
+-            "-framework Foundation",
+-        ],
+-        ":ios": [
+-            "-framework Foundation",
+-        ],
+-        "//conditions:default": [],
+-    }),
+     visibility = ["//visibility:public"],
+     deps = [
+         ":civil_time",
+diff --git a/absl/base/config.h b/absl/base/config.h
+index 8533aea..07b4e80 100644
+--- a/absl/base/config.h.orig
++++ b/absl/base/config.h
+@@ -906,7 +906,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
+ // SIMD).
+ #ifdef ABSL_INTERNAL_HAVE_ARM_NEON
+ #error ABSL_INTERNAL_HAVE_ARM_NEON cannot be directly set
+-#elif defined(__ARM_NEON)
++#elif defined(__ARM_NEON) && !defined(__CUDACC__)
+ #define ABSL_INTERNAL_HAVE_ARM_NEON 1
+ #endif
+ 

third_party/tsl/third_party/absl/com_google_absl_fix_mac_and_nvcc_build.patch

@@ -0,0 +1,8 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])  # Apache
+
+filegroup(
+    name = "LICENSE",
+    visibility = ["//visibility:public"],
+)

third_party/tsl/third_party/absl/system.BUILD

@@ -0,0 +1,10 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+package(default_visibility = ["//visibility:public"])
+
+[cc_library(
+    name = n,
+) for n in [
+    "algorithm",
+    "container",
+]]